diff --git a/backend/__tests__/unit/routes/integrations.linkedUserId.test.js b/backend/__tests__/unit/routes/integrations.linkedUserId.test.js
index 3327291dfe..f578e8e3e9 100644
--- a/backend/__tests__/unit/routes/integrations.linkedUserId.test.js
+++ b/backend/__tests__/unit/routes/integrations.linkedUserId.test.js
@@ -95,8 +95,8 @@ describe('PATCH /api/integrations/:id — linkedUserId guard', () => {
 
     expect(res.status).toBe(200);
     const [, update] = Integration.findByIdAndUpdate.mock.calls[0];
-    expect(update.config.liveRelay).toBe(true);
-    expect(update.config.linkedUserId).toBe('user-1');
+    expect(update['config.liveRelay']).toBe(true);
+    expect(update['config.linkedUserId']).toBe('user-1');
   });
 
   it("derives linkedUserId when liveRelay arrives as the string 'true' (#1293)", async () => {
@@ -106,8 +106,8 @@ describe('PATCH /api/integrations/:id — linkedUserId guard', () => {
 
     expect(res.status).toBe(200);
     const [, update] = Integration.findByIdAndUpdate.mock.calls[0];
-    expect(update.config.liveRelay).toBe(true);
-    expect(update.config.linkedUserId).toBe('user-1');
+    expect(update['config.liveRelay']).toBe(true);
+    expect(update['config.linkedUserId']).toBe('user-1');
   });
 
   // Mongoose's Boolean cast is wider than the two literals above: 1, '1' and
@@ -141,8 +141,8 @@ describe('PATCH /api/integrations/:id — linkedUserId guard', () => {
 
     expect(res.status).toBe(200);
     const [, update] = Integration.findByIdAndUpdate.mock.calls[0];
-    expect(update.config.liveRelay).toBe(false);
-    expect(update.config.linkedUserId).toBeUndefined();
+    expect(update['config.liveRelay']).toBe(false);
+    expect(update['config.linkedUserId']).toBeUndefined();
   });
 
   it('does not let a pod-scoped connector move its installation-owned pod', async () => {
@@ -153,6 +153,25 @@ describe('PATCH /api/integrations/:id — linkedUserId guard', () => {
     expect(res.status).toBe(400);
     expect(Integration.findByIdAndUpdate).not.toHaveBeenCalled();
   });
+
+  it('cannot overwrite durable cards, including a stale snapshot from before a send', async () => {
+    const existing = telegramIntegration();
+    existing.config.toObject = () => ({ cards: [], chatId: '42', chatType: 'private' });
+    Integration.findById.mockResolvedValue(existing);
+    const res = await request(app).patch(`/api/integrations/${integrationId}`).send({
+      config: { cards: [{ podMessageId: 'forged', tgMessageId: '1' }], leadAgentUsername: 'kai' },
+    });
+    expect(res.status).toBe(200);
+    expect(Integration.findByIdAndUpdate.mock.calls[0][1]).toEqual({
+      'config.leadAgentUsername': 'kai', status: 'connected',
+    });
+  });
+
+  it.each(['cards.0.podMessageId', '$cards'])('rejects config path injection %s', async (key) => {
+    const res = await request(app).patch(`/api/integrations/${integrationId}`).send({ config: { [key]: 'forged' } });
+    expect(res.status).toBe(400);
+    expect(Integration.findByIdAndUpdate).not.toHaveBeenCalled();
+  });
 });
 
 describe('PATCH /api/integrations/:id — user-scoped connector gates', () => {
@@ -228,7 +247,7 @@ describe('PATCH /api/integrations/:id — user-scoped connector gates', () => {
 
     expect(res.status).toBe(200);
     const [, update] = Integration.findByIdAndUpdate.mock.calls[0];
-    expect(update.config.gates[allowedPodId]).toMatchObject({ enabled: true });
+    expect(update['config.gates'][allowedPodId]).toMatchObject({ enabled: true });
   });
 
   it('allows the linked owner to select a member pod as the active inbound destination', async () => {
@@ -354,6 +373,7 @@ describe('POST /api/integrations — create-path guards', () => {
         type: 'telegram',
         config: {
           connectCode: 'chosen', chatId: '999', chatType: 'private', liveRelay: true, 
+          cards: [{ podMessageId: 'forged', tgMessageId: '1' }],
         },
       });
     expect(res.status).toBe(201);
@@ -363,6 +383,7 @@ describe('POST /api/integrations — create-path guards', () => {
     expect(config.chatId).toBeUndefined();
     expect(config.chatType).toBeUndefined();
     expect(config.linkedUserId).toBe('user-1');
+    expect(config.cards).toBeUndefined();
   });
 });
 
@@ -408,8 +429,9 @@ describe('PATCH /api/integrations/:id — live relay on a group chat', () => {
       .send({ config: { chatId: '777', leadAgentUsername: 'theo' } });
     expect(res.status).toBe(200);
     const [, update] = Integration.findByIdAndUpdate.mock.calls[0];
-    expect(update.config.chatId).toBe('42');
-    expect(update.config.leadAgentUsername).toBe('theo');
+    expect(update.config).toBeUndefined();
+    expect(update['config.chatId']).toBeUndefined();
+    expect(update['config.leadAgentUsername']).toBe('theo');
   });
 });
 
diff --git a/backend/__tests__/unit/services/decisionCardConfirmation.transport.test.js b/backend/__tests__/unit/services/decisionCardConfirmation.transport.test.js
new file mode 100644
index 0000000000..b93549013d
--- /dev/null
+++ b/backend/__tests__/unit/services/decisionCardConfirmation.transport.test.js
@@ -0,0 +1,31 @@
+jest.mock('axios', () => ({ post: jest.fn(), create: jest.fn() }));
+const axios = require('axios');
+const { sendMessage } = require('../../../services/telegramService');
+const SlackApi = require('../../../services/slackApi');
+
+beforeEach(() => jest.clearAllMocks());
+
+test('Telegram confirmation uses reply_parameters and literal text; ordinary HTML is unchanged', async () => {
+  axios.post.mockResolvedValue({ data: { ok: true, result: { message_id: 43 } } });
+  await sendMessage('token', 'chat', '✓ Ruled: <label> & value', { replyToMessageId: '42', plainText: true });
+  expect(axios.post.mock.calls[0][1]).toEqual({
+    chat_id: 'chat', text: '✓ Ruled: <label> & value',
+    reply_parameters: { message_id: 42 }, disable_web_page_preview: true,
+  });
+  await sendMessage('token', 'chat', '<b>agent</b>: ordinary');
+  expect(axios.post.mock.calls[1][1]).toEqual({
+    chat_id: 'chat', text: '<b>agent</b>: ordinary', parse_mode: 'HTML', disable_web_page_preview: true,
+  });
+});
+
+test('Slack confirmation targets the parent card without changing ordinary sends', async () => {
+  const post = jest.fn(async () => ({ data: { ok: true, ts: '43.001' } }));
+  axios.create.mockReturnValue({ post });
+  const api = new SlackApi('token');
+  await api.postMessage('chat', '✓ Ruled: now', undefined, '42.001');
+  expect(post).toHaveBeenCalledWith('/chat.postMessage', {
+    channel: 'chat', text: '✓ Ruled: now', blocks: undefined, thread_ts: '42.001',
+  });
+  await api.postMessage('chat', 'ordinary');
+  expect(post.mock.calls[1][1]).not.toHaveProperty('thread_ts');
+});
diff --git a/backend/__tests__/unit/services/decisionCardReply.bridges.test.js b/backend/__tests__/unit/services/decisionCardReply.bridges.test.js
new file mode 100644
index 0000000000..104457a7f7
--- /dev/null
+++ b/backend/__tests__/unit/services/decisionCardReply.bridges.test.js
@@ -0,0 +1,443 @@
+// Real Mongo CAS, receipts and ledger; provider transport, PG storage and
+// downstream event transport are isolated. Both bridges call the real verb.
+jest.mock('../../../models/Pod', () => ({ findById: jest.fn() }));
+jest.mock('../../../models/User', () => ({ findById: jest.fn() }));
+jest.mock('../../../models/pg/Pod', () => ({ findById: jest.fn(async () => ({ id: 'pod' })) }));
+jest.mock('../../../models/pg/Message', () => ({ create: jest.fn(), findById: jest.fn() }));
+jest.mock('../../../services/pgPodSyncService', () => ({ syncPodFromMongo: jest.fn() }));
+jest.mock('../../../services/agentMessageService', () => ({ postMessage: jest.fn() }));
+jest.mock('../../../services/messageAgentDeliveryService', () => ({ deliverMessageToAgents: jest.fn(async () => ({})) }));
+jest.mock('../../../services/agentEventService', () => ({ enqueue: jest.fn(async () => ({})) }));
+jest.mock('../../../services/attentionItemService', () => ({ resolve: jest.fn(async () => {}), recordDecision: jest.fn() }));
+jest.mock('../../../services/telegramService', () => ({ sendMessage: jest.fn() }));
+jest.mock('../../../services/slackApi', () => jest.fn());
+jest.mock('../../../services/connectorSecrets', () => ({ get: jest.fn(async () => 'token') }));
+jest.mock('../../../config/socket', () => ({ getIO: jest.fn(() => null) }));
+jest.mock('../../../services/threadRootResolver', () => ({ resolveThreadRoot: jest.fn(async () => 600) }));
+
+const mongoose = require('mongoose');
+const { setupMongoDb, closeMongoDb, clearMongoDb } = require('../../utils/testUtils');
+const Decision = require('../../../models/DecisionRequest');
+const Integration = require('../../../models/Integration');
+const Verdict = require('../../../models/ChannelVerdict');
+const Pod = require('../../../models/Pod');
+const User = require('../../../models/User');
+const PGMessage = require('../../../models/pg/Message');
+const telegramSend = require('../../../services/telegramService');
+const SlackApi = require('../../../services/slackApi');
+const decisions = require('../../../services/decisionRequestService');
+const { enqueue } = require('../../../services/agentEventService');
+const { deliverMessageToAgents } = require('../../../services/messageAgentDeliveryService');
+const telegram = require('../../../services/telegramBridgeService');
+const slack = require('../../../services/slackBridgeService');
+
+const podId = String(new mongoose.Types.ObjectId());
+const otherPodId = String(new mongoose.Types.ObjectId());
+const ownerId = String(new mongoose.Types.ObjectId());
+const newOwnerId = String(new mongoose.Types.ObjectId());
+const agentId = String(new mongoose.Types.ObjectId());
+const chain = (value) => ({ select: () => ({ lean: async () => value }) });
+let messages;
+let slackSend;
+let choose;
+
+beforeAll(async () => { await setupMongoDb(); await Verdict.syncIndexes(); });
+afterAll(() => closeMongoDb());
+beforeEach(() => {
+  jest.clearAllMocks();
+  messages = [];
+  process.env.TELEGRAM_BOT_TOKEN = 'test-token';
+  Pod.findById.mockImplementation(() => chain({ name: 'Launch', type: 'team', members: [ownerId, newOwnerId] }));
+  User.findById.mockImplementation(() => chain({ username: 'sam', isBot: false }));
+  PGMessage.create.mockImplementation(async (pid, uid, content, _type, replyTo, _payload, root) => {
+    const message = { id: String(900 + messages.length), podId: pid, userId: uid, content, replyTo, thread_root_id: root || replyTo };
+    messages.push(message);
+    return message;
+  });
+  PGMessage.findById.mockImplementation(async (id) => messages.find((message) => message.id === String(id)));
+  telegramSend.sendMessage.mockResolvedValue({ success: true, messageId: 42 });
+  slackSend = jest.fn(async () => ({ ok: true, ts: '42.001' }));
+  SlackApi.mockImplementation(() => ({ postMessage: slackSend }));
+  choose = jest.spyOn(decisions, 'chooseDecision');
+});
+afterEach(async () => { jest.restoreAllMocks(); await clearMongoDb(); });
+
+describe.each(['telegram', 'slack'])('%s decision reply', (provider) => {
+  let binding;
+  let decision;
+  const externalId = provider === 'telegram' ? '42' : '42.001';
+  const send = (integration, card) => (provider === 'telegram' ? telegram.relayAgentMessageToTelegram : slack.relayAgentMessageToSlack)({
+    integration, podId, agentUsername: 'kai', displayName: 'Kai', podMessageId: card.messageId,
+    content: '[DECISION] ordinary', card,
+  });
+  const receive = async (text = '2', quote = externalId, overrides = {}, id = binding._id) => {
+    const integration = await Integration.findById(id).lean();
+    if (provider === 'telegram') return telegram.relayTelegramMessageToPod({
+      integration, telegramMessage: { text, ...(quote ? { reply_to_message_id: Number(quote) } : {}), ...overrides },
+    });
+    return slack.relaySlackMessageToPod({
+      integration, event: { text, user: 'U1', ...(quote ? { thread_ts: quote } : {}), ...overrides },
+    });
+  };
+  const confirmation = () => provider === 'telegram'
+    ? telegramSend.sendMessage.mock.calls.at(-1)[2] : slackSend.mock.calls.at(-1)[1];
+  const receipts = async () => (await Integration.findById(binding._id).lean()).config.cards;
+  const ledger = async () => Verdict.find({ integrationId: binding._id }).lean();
+  const assertOpen = async () => {
+    expect((await Decision.findById(decision._id)).status).toBe('pending');
+    expect((await receipts())[0].closedAt).toBeUndefined();
+    expect(await ledger()).toEqual([expect.objectContaining({ verdict: 'interrupt', reason: 'card' })]);
+    expect((await ledger())[0].reachedHumanAt).toBeUndefined();
+    expect((await ledger())[0].ruledVia).toBeUndefined();
+  };
+  beforeEach(async () => {
+    decision = await Decision.create({
+      podId, agentUserId: agentId, agentName: 'kai', decisionClass: 'implementation',
+      title: 'Release?', question: 'When?', options: [{ label: 'Later' }, { label: 'Now' }], messageId: '700',
+    });
+    binding = await Integration.create({
+      podId: otherPodId, scope: 'user', type: provider, createdBy: ownerId, isActive: true, status: 'connected',
+      config: {
+        linkedUserId: ownerId, chatType: provider === 'telegram' ? 'private' : 'im', liveRelay: true,
+        chatId: 'chat', teamId: 'T1', slackUserId: 'U1', botTokenRef: 'ref',
+        gates: { [podId]: { enabled: true, since: new Date() } },
+      },
+    });
+    await send(await Integration.findById(binding._id).lean(), decision.toObject());
+    expect((await receipts())).toHaveLength(1);
+    telegramSend.sendMessage.mockClear();
+    slackSend.mockClear();
+  });
+
+  test('200: one threaded ruling, one typed wake, one closed receipt and reached ledger', async () => {
+    await receive();
+    expect(choose).toHaveBeenCalledTimes(1);
+    expect(choose).toHaveBeenCalledWith({ decisionId: String(decision._id), callerUserId: ownerId, value: 'Now' });
+    expect(messages).toEqual([expect.objectContaining({ podId, userId: ownerId, content: 'Now', replyTo: '700', thread_root_id: '700' })]);
+    expect(messages.filter((m) => m.thread_root_id == null)).toHaveLength(0);
+    expect(enqueue).toHaveBeenCalledTimes(1);
+    expect(enqueue).toHaveBeenCalledWith(expect.objectContaining({ type: 'decision.ruled' }));
+    expect((await receipts())[0].closedAt).toEqual(expect.any(Date));
+    expect(await ledger()).toEqual([expect.objectContaining({ reachedHumanAt: expect.any(Date), ruledVia: provider })]);
+    expect(String((await ledger())[0].event.decisionId)).toBe(String(decision._id));
+    expect(confirmation()).toBe('✓ Ruled: Now');
+    if (provider === 'telegram') expect(telegramSend.sendMessage.mock.calls[0][3]).toEqual({ replyToMessageId: externalId, plainText: true });
+    else expect(slackSend.mock.calls[0][3]).toBe(externalId);
+  });
+
+  test('free text is trimmed and capped, with no ordinary duplicate', async () => {
+    await receive(`  ${'x'.repeat(2100)}  `);
+    expect(messages).toHaveLength(1);
+    expect(messages[0].content).toBe('x'.repeat(2000));
+    expect(choose.mock.calls[0][0].value).toBe('x'.repeat(2000));
+  });
+
+  test('out-of-range calls no verb and writes nothing', async () => {
+    await receive('7');
+    expect(choose).not.toHaveBeenCalled();
+    expect(messages).toHaveLength(0);
+    await assertOpen();
+    expect(confirmation()).toBe('Pick 1–2, or write your ruling.');
+  });
+
+  test('403 from verb closes nothing and never falls through', async () => {
+    choose.mockResolvedValueOnce({ status: 403, body: { error: 'Only human pod members can rule' } });
+    await receive();
+    expect(choose).toHaveBeenCalledTimes(1);
+    expect(messages).toHaveLength(0);
+    await assertOpen();
+    expect(confirmation()).toContain("You're no longer in Launch");
+  });
+
+  test('membership guard is first, including for an already-ruled card', async () => {
+    Pod.findById.mockImplementation(() => chain({ name: 'Launch', members: [] }));
+    await receive();
+    expect(choose).not.toHaveBeenCalled();
+    expect(messages).toHaveLength(0);
+    await assertOpen();
+    expect(confirmation()).toContain("You're no longer in Launch");
+    await Decision.updateOne({ _id: decision._id }, { $set: { status: 'ruled', ruling: { value: 'secret', byUsername: 'someone' } } });
+    await receive();
+    expect(messages).toHaveLength(0);
+    expect(confirmation()).not.toContain('secret');
+  });
+
+  test('409-ruled: loser text goes under ask, not winner; standing ruling and ledger stay unchanged', async () => {
+    await receive();
+    const original = await ledger();
+    await receive('1');
+    expect(messages).toHaveLength(2);
+    expect(messages[1]).toMatchObject({ podId, replyTo: '700', thread_root_id: '700' });
+    expect(messages[1].content).toContain('1');
+    expect(choose).toHaveBeenCalledTimes(1);
+    expect((await Decision.findById(decision._id)).ruling.value).toBe('Now');
+    expect(await ledger()).toEqual(original);
+    expect(confirmation()).toContain('Already ruled');
+  });
+
+  test.each([
+    [undefined, ''],
+    [null, ''],
+    [-1, ' just now'],
+    [0, ' just now'],
+    [59, ' just now'],
+    [60, ' 1m ago'],
+    [3599, ' 59m ago'],
+    [3600, ' 1h ago'],
+    [86399, ' 23h ago'],
+    [86400, ' 1d ago'],
+    [172800, ' 2d ago'],
+  ])('standing ruling age %s seconds renders "%s" without changing settlement', async (ageSeconds, relative) => {
+    const now = Date.now();
+    jest.spyOn(Date, 'now').mockReturnValue(now);
+    const at = ageSeconds == null ? ageSeconds : new Date(now - ageSeconds * 1000);
+    await Decision.updateOne({ _id: decision._id }, {
+      $set: { status: 'ruled', ruling: { value: 'Later', byUsername: 'sam', ...(at === undefined ? {} : { at }) } },
+    });
+    const original = (await Decision.findById(decision._id).lean()).ruling;
+    const originalLedger = await ledger();
+    await receive('1');
+    const link = `https://commonly.me/v2/pods/${podId}?message=700`;
+    expect(confirmation()).toBe(`Already ruled${relative} by sam: Later.`
+      + ` To change it, the agent asks again — say so in the workspace: ${link}`);
+    expect(choose).not.toHaveBeenCalled();
+    expect((await Decision.findById(decision._id).lean()).ruling).toEqual(original);
+    expect(await ledger()).toEqual(originalLedger);
+    expect((await receipts())[0].closedAt).toEqual(expect.any(Date));
+    expect(messages).toEqual([expect.objectContaining({ podId, replyTo: '700', thread_root_id: '700' })]);
+  });
+
+  test('409-lock: no write; after injected clock expires the lease, same reply rules', async () => {
+    const now = Date.now();
+    await Decision.updateOne({ _id: decision._id }, { $set: { rulingLock: { token: 'other-tab', expiresAt: new Date(now + 120000) } } });
+    await receive();
+    await assertOpen();
+    expect(messages).toHaveLength(0);
+    expect(confirmation()).toContain('Someone is ruling');
+    jest.useFakeTimers({ doNotFake: ['nextTick', 'setImmediate', 'setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'performance'] });
+    jest.setSystemTime(now + 120001);
+    try { await receive(); } finally { jest.useRealTimers(); }
+    expect(messages).toHaveLength(1);
+    expect((await receipts())[0].closedAt).toEqual(expect.any(Date));
+  });
+
+  test('409-ruled returned by the verb after our pending read takes the late threaded path', async () => {
+    const realChoose = choose.getMockImplementation();
+    choose.mockImplementationOnce(async (args) => {
+      await realChoose({ ...args, value: 'winner' });
+      return realChoose(args);
+    });
+    await receive('1');
+    expect(messages).toHaveLength(2);
+    expect(messages[0].content).toBe('winner');
+    expect(messages[1].replyTo).toBe('700');
+    expect(messages[1].content).toContain('1');
+    expect((await receipts())[0].closedAt).toEqual(expect.any(Date));
+    expect((await ledger())[0].reachedHumanAt).toBeUndefined();
+    expect((await ledger())[0].ruledVia).toBeUndefined();
+    expect(confirmation()).toContain('Already ruled');
+  });
+
+  test('503: no message and released lock, retry gives exactly one ruling', async () => {
+    PGMessage.create.mockRejectedValueOnce(new Error('PG unavailable'));
+    await receive();
+    await assertOpen();
+    expect(messages).toHaveLength(0);
+    expect((await Decision.findById(decision._id)).rulingLock?.token).toBeUndefined();
+    expect(confirmation()).toContain('nothing was saved');
+    await receive();
+    expect(messages).toHaveLength(1);
+    expect(enqueue).toHaveBeenCalledTimes(1);
+  });
+
+  test('thrown finalize conflict: exactly one reply/wake, no close or ledger stamp', async () => {
+    const update = Decision.findOneAndUpdate.bind(Decision);
+    jest.spyOn(Decision, 'findOneAndUpdate').mockImplementation((filter, change, options) => (
+      change.$set?.status === 'ruled' ? Promise.resolve(null) : update(filter, change, options)
+    ));
+    await receive();
+    await assertOpen();
+    expect(messages).toHaveLength(1);
+    expect(messages[0].replyTo).toBe('700');
+    expect(deliverMessageToAgents).toHaveBeenCalledTimes(1);
+    expect(enqueue).not.toHaveBeenCalled();
+    expect(confirmation()).toContain("reached the workspace, but the card didn't close");
+  });
+
+  test('confirmation send failure cannot retry the verb or roll back settlement', async () => {
+    if (provider === 'telegram') telegramSend.sendMessage.mockRejectedValueOnce(new Error('transport failed'));
+    else slackSend.mockRejectedValueOnce(new Error('transport failed'));
+    await receive();
+    expect(choose).toHaveBeenCalledTimes(1);
+    expect(messages).toHaveLength(1);
+    expect((await Decision.findById(decision._id)).status).toBe('ruled');
+    expect((await receipts())[0].closedAt).toEqual(expect.any(Date));
+    expect((await ledger())[0].ruledVia).toBe(provider);
+    expect(provider === 'telegram' ? telegramSend.sendMessage : slackSend).toHaveBeenCalledTimes(1);
+  });
+
+  test('reply to confirmation or another chat card is ordinary, never a bare-number ruling', async () => {
+    await receive('2', '999');
+    expect(choose).not.toHaveBeenCalled();
+    expect(messages).toHaveLength(1);
+    expect(messages[0]).toMatchObject({ podId: otherPodId, replyTo: null, thread_root_id: null });
+    await assertOpen();
+  });
+
+  test('current linked owner, not an identity cached at send time, rules', async () => {
+    await Integration.updateOne({ _id: binding._id }, { $set: { 'config.linkedUserId': newOwnerId } });
+    await receive();
+    expect(choose.mock.calls[0][0].callerUserId).toBe(newOwnerId);
+    expect(messages[0].userId).toBe(newOwnerId);
+  });
+
+  test('one fork on two bindings keeps only the winner reached and routes a marked sibling as late', async () => {
+    const sibling = await Integration.create({
+      podId: otherPodId, scope: 'user', type: provider, createdBy: newOwnerId, isActive: true, status: 'connected',
+      config: { ...binding.toObject({ flattenMaps: true }).config, linkedUserId: newOwnerId, chatId: 'second-chat', cards: [] },
+    });
+    await send(await Integration.findById(sibling._id).lean(), decision.toObject());
+    await receive('2');
+    // PR 3's fan-out may mark this receipt before the losing webhook arrives.
+    await Integration.updateOne({ _id: sibling._id }, { $set: { 'config.cards.0.closedAt': new Date() } });
+    await receive('1', externalId, {}, sibling._id);
+    expect(messages).toHaveLength(2);
+    expect(messages[1]).toMatchObject({ replyTo: '700', userId: newOwnerId, podId });
+    const rows = await Verdict.find({ 'event.podMessageId': '700' }).lean();
+    expect(rows).toHaveLength(2);
+    expect(rows.filter((r) => r.reachedHumanAt)).toHaveLength(1);
+    expect(rows.every((r) => r.ruledVia === provider)).toBe(true);
+    expect(confirmation()).toContain('Already ruled');
+  });
+
+  test('long prose without quote is ordinary chat even with one pending card', async () => {
+    await receive('ship this tomorrow', null);
+    expect(choose).not.toHaveBeenCalled();
+    expect(messages).toHaveLength(1);
+    expect(messages[0].replyTo).toBeNull();
+    await assertOpen();
+  });
+
+  test('card replies do not depend on an active pod; unmatched chat still needs one (64265)', async () => {
+    await Integration.updateOne({ _id: binding._id }, { $unset: { podId: 1 } });
+    await receive('hello', null);
+    expect(messages).toHaveLength(0);
+    expect(confirmation()).toContain('no active pod');
+    await receive('2');
+    expect(messages).toHaveLength(1);
+    expect(messages[0]).toMatchObject({ podId, replyTo: '700' });
+    expect(confirmation()).toBe('✓ Ruled: Now');
+  });
+
+  test('leaving active pod blocks ordinary chat but not a card in another member pod (64265)', async () => {
+    Pod.findById.mockImplementation((id) => chain({ name: 'Launch', members: String(id) === podId ? [ownerId] : [] }));
+    await receive('hello', null);
+    expect(messages).toHaveLength(0);
+    await receive('2');
+    expect(messages).toHaveLength(1);
+    expect(messages[0]).toMatchObject({ podId, replyTo: '700' });
+  });
+
+  test('missing or explicitly closed pending receipt never falls through or closes the decision', async () => {
+    await Integration.updateOne({ _id: binding._id }, { $set: { 'config.cards.0.closedAt': new Date() } });
+    await receive();
+    expect(choose).not.toHaveBeenCalled();
+    expect(messages).toHaveLength(0);
+    expect((await Decision.findById(decision._id)).status).toBe('pending');
+    await Decision.deleteOne({ _id: decision._id });
+    await receive();
+    expect(messages).toHaveLength(0);
+    expect(confirmation()).toContain('no longer available');
+  });
+
+  test('bare number ignores ghost entries whose row has already ruled', async () => {
+    await Decision.create({ ...decision.toObject(), _id: new mongoose.Types.ObjectId(), messageId: '701', status: 'ruled' });
+    await Integration.updateOne({ _id: binding._id }, { $push: { 'config.cards': { podMessageId: '701', externalMessageId: '43', sentAt: new Date() } } });
+    await receive('2', null);
+    expect(choose).toHaveBeenCalledTimes(1);
+    expect(messages).toHaveLength(1);
+    expect(messages[0].replyTo).toBe('700');
+  });
+
+  test('two pending cards disambiguate; zero pending cards use ordinary chat', async () => {
+    await Decision.create({ ...decision.toObject(), _id: new mongoose.Types.ObjectId(), messageId: '701' });
+    await Integration.updateOne({ _id: binding._id }, { $push: { 'config.cards': { podMessageId: '701', externalMessageId: '43', sentAt: new Date() } } });
+    await receive('2', null);
+    expect(choose).not.toHaveBeenCalled();
+    expect(messages).toHaveLength(0);
+    expect(confirmation()).toBe('Which one? Reply to the card you mean.');
+    await Decision.updateMany({}, { $set: { status: 'ruled' } });
+    await receive('2', null);
+    expect(messages).toHaveLength(1);
+    expect(messages[0].replyTo).toBeNull();
+  });
+
+  test('150 ordinary relays cannot evict the card or duplicate its ledger', async () => {
+    const integration = await Integration.findById(binding._id).lean();
+    for (let i = 0; i < 150; i += 1) {
+      // eslint-disable-next-line no-await-in-loop
+      await (provider === 'telegram' ? telegram.relayAgentMessageToTelegram : slack.relayAgentMessageToSlack)({
+        integration, podId, agentUsername: 'kai', displayName: 'Kai', content: '[DECISION] chat', podMessageId: String(1000 + i),
+      });
+    }
+    const saved = await Integration.findById(binding._id).lean();
+    expect(saved.config.relayMap).toHaveLength(100);
+    expect(saved.config.relayMap.some((entry) => entry.podMessageId === '700')).toBe(false);
+    expect(saved.config.cards).toHaveLength(1);
+    expect(await ledger()).toHaveLength(1);
+    await receive();
+    expect(messages).toHaveLength(1);
+    expect(messages[0].replyTo).toBe('700');
+  });
+
+  test('concurrent replies enter the real CAS together and only one settles', async () => {
+    let release;
+    let entered;
+    const inWrite = new Promise((resolve) => { entered = resolve; });
+    const continueWrite = new Promise((resolve) => { release = resolve; });
+    const create = PGMessage.create.getMockImplementation();
+    PGMessage.create.mockImplementationOnce(async (...args) => { entered(); await continueWrite; return create(...args); });
+    const first = receive('2');
+    await inWrite;
+    try {
+      await receive('1');
+      expect(confirmation()).toContain('Someone is ruling');
+      expect(messages).toHaveLength(0);
+    } finally { release(); await first; }
+    expect(choose).toHaveBeenCalledTimes(2);
+    expect(messages).toHaveLength(1);
+    expect(enqueue).toHaveBeenCalledTimes(1);
+    expect((await Decision.findById(decision._id)).ruling.value).toBe('Now');
+  });
+
+  test('provider identity guard refuses before decision lookup', async () => {
+    const lookup = jest.spyOn(Decision, 'findOne');
+    if (provider === 'telegram') await Integration.updateOne({ _id: binding._id }, { $set: { 'config.chatType': 'group' } });
+    await receive('2', externalId, provider === 'slack' ? { user: 'other-user' } : {});
+    expect(lookup).not.toHaveBeenCalled();
+    expect(choose).not.toHaveBeenCalled();
+    expect(messages).toHaveLength(0);
+    await assertOpen();
+  });
+
+  test('admin-pause remains ahead of card lookup', async () => {
+    const lookup = jest.spyOn(Decision, 'findOne');
+    await Integration.updateOne({ _id: binding._id }, { $set: { 'config.adminPause': { reason: 'paused', at: new Date(), adminId: ownerId } } });
+    await receive();
+    expect(lookup).not.toHaveBeenCalled();
+    expect(choose).not.toHaveBeenCalled();
+    expect(messages).toHaveLength(0);
+    await assertOpen();
+  });
+
+  if (provider === 'telegram') {
+    test('a group update is refused even if the stored binding claims private', async () => {
+      const lookup = jest.spyOn(Decision, 'findOne');
+      await receive('2', externalId, { chat: { type: 'group' } });
+      expect(lookup).not.toHaveBeenCalled();
+      expect(choose).not.toHaveBeenCalled();
+      expect(messages).toHaveLength(0);
+      await assertOpen();
+    });
+  }
+});
diff --git a/backend/models/DecisionRequest.ts b/backend/models/DecisionRequest.ts
index 2e739bf715..143ddd6abb 100644
--- a/backend/models/DecisionRequest.ts
+++ b/backend/models/DecisionRequest.ts
@@ -100,6 +100,8 @@ const DecisionRequestSchema = new Schema<IDecisionRequest>(
 // index supplies its pod/status filter; individual pod thread lookups use the
 // messageId stored on the row.
 DecisionRequestSchema.index({ podId: 1, status: 1, createdAt: -1 });
+// Channel receipts resolve by the ask's PG message id, including across pods.
+DecisionRequestSchema.index({ messageId: 1 });
 
 const DecisionRequest: Model<IDecisionRequest> = (mongoose.models.DecisionRequest as Model<IDecisionRequest>)
   || mongoose.model<IDecisionRequest>('DecisionRequest', DecisionRequestSchema);
diff --git a/backend/models/Integration.ts b/backend/models/Integration.ts
index 57f19180d5..4b1f3c23ce 100644
--- a/backend/models/Integration.ts
+++ b/backend/models/Integration.ts
@@ -144,6 +144,14 @@ export interface IIntegration extends Document {
       podMessageId?: string | null;
       podId?: string;
     }[];
+    /** Durable card receipts; unlike relayMap these are never evicted by count. */
+    cards?: {
+      podMessageId: string;
+      tgMessageId?: string;
+      externalMessageId?: string;
+      sentAt: Date;
+      closedAt?: Date;
+    }[];
   };
   ingestTokens: IIngestToken[];
   lastSync?: Date | null;
@@ -288,6 +296,14 @@ const IntegrationSchema = new Schema<IIntegration>(
           podId: String,
         },
       ],
+      cards: [{
+        _id: false,
+        podMessageId: { type: String, required: true },
+        tgMessageId: String,
+        externalMessageId: String,
+        sentAt: { type: Date, required: true },
+        closedAt: Date,
+      }],
       agentAccessEnabled: { type: Boolean, default: false },
       globalAgentAccess: { type: Boolean, default: false },
     },
diff --git a/backend/routes/integrations.ts b/backend/routes/integrations.ts
index 9eda0b201b..68602856ef 100644
--- a/backend/routes/integrations.ts
+++ b/backend/routes/integrations.ts
@@ -51,6 +51,9 @@ const SERVER_OWNED_CONFIG_KEYS = [
   // An administrator's pause is projected from the parent installation. An
   // owner's normal config write must never lift that stop.
   'adminPause',
+  // A receipt proves this channel was shown the card. Owners may configure
+  // gates, but cannot invent, retarget, or close receipts from a browser.
+  'cards',
 ];
 const stripServerOwnedConfig = (config: Record<string, unknown>): Record<string, unknown> => {
   const next = { ...config };
@@ -587,6 +590,9 @@ router.patch('/:id', writeIntegrationsRateLimit, auth, async (req: AuthReq, res:
     const relay = config ? readRelayFlags(stripServerOwnedConfig(config)) : null;
     if (relay?.invalid) return res.status(400).json(relayFlagError(relay.invalid));
     const incoming = relay ? relay.next : null;
+    if (incoming && Object.keys(incoming).some((key) => key.includes('.') || key.startsWith('$'))) {
+      return res.status(400).json({ message: 'config keys must be field names, not update paths' });
+    }
     const nextConfig = incoming ? { ...currentConfig, ...incoming } : currentConfig;
     if (incoming && incoming.liveRelay === true) {
       // Relay authors inbound as linkedUserId and streams outbound to chatId;
@@ -600,7 +606,13 @@ router.patch('/:id', writeIntegrationsRateLimit, auth, async (req: AuthReq, res:
     if (missingRequired.length && status === 'connected') return res.status(400).json({ message: `Missing required fields: ${missingRequired.join(', ')}`, missing: missingRequired });
     validateManifestIfComplete(integration.type || '', nextConfig);
     const update: Record<string, unknown> = {};
-    if (config) update.config = nextConfig;
+    // Do not replace a snapshot of config: cards/relayMap may have been
+    // appended (or closed) since the read above. Only write the requested
+    // top-level fields; a gates map still replaces that one field as before.
+    if (incoming) {
+      Object.keys(incoming).forEach((key) => { update[`config.${key}`] = nextConfig[key]; });
+      if (incoming.liveRelay === true) update['config.linkedUserId'] = req.user?.id;
+    }
     if (podId !== undefined) update.podId = podId;
     if (typeof status === 'string') update.status = status;
     if (typeof isActive === 'boolean') update.isActive = isActive;
diff --git a/backend/services/channelVerdictService.ts b/backend/services/channelVerdictService.ts
index 8984faaddf..09ad2a1658 100644
--- a/backend/services/channelVerdictService.ts
+++ b/backend/services/channelVerdictService.ts
@@ -32,6 +32,7 @@ export interface MarkReachedHuman {
   integrationId: unknown;
   podMessageId: string;
   ruledVia: Extract<ChannelVerdictRuledVia, 'telegram' | 'slack'>;
+  decisionId?: string;
 }
 
 export interface MarkRuled {
@@ -115,7 +116,11 @@ export const markReachedHuman = async (entry: MarkReachedHuman): Promise<void> =
     // that its own human performed the action.
     await ChannelVerdict.updateMany(
       { 'event.podMessageId': entry.podMessageId },
-      { $set: { ruledVia: entry.ruledVia, expiresAt: expiryAfter(now) } },
+      { $set: {
+        ruledVia: entry.ruledVia,
+        expiresAt: expiryAfter(now),
+        ...(entry.decisionId ? { 'event.decisionId': entry.decisionId } : {}),
+      } },
     );
   } catch (error) {
     console.warn('[channel-verdict] reach stamp failed:', (error as Error).message);
diff --git a/backend/services/decisionCardReply.ts b/backend/services/decisionCardReply.ts
new file mode 100644
index 0000000000..3769459de4
--- /dev/null
+++ b/backend/services/decisionCardReply.ts
@@ -0,0 +1,169 @@
+import type { IDecisionRequest } from '../models/DecisionRequest';
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const DecisionRequest = require('../models/DecisionRequest');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const Integration = require('../models/Integration');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const Pod = require('../models/Pod');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const User = require('../models/User');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const isPodMember = require('../utils/isPodMember');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const verdicts = require('./channelVerdictService');
+
+export interface ChannelCardEntry {
+  podMessageId: string;
+  tgMessageId?: string;
+  externalMessageId?: string;
+  sentAt: Date | string;
+  closedAt?: Date | string;
+}
+
+interface CardReplyResult {
+  handled: boolean;
+  confirmation?: string;
+  externalMessageId?: string;
+  lateReply?: { podId: string; messageId: string; threadRootId?: string };
+}
+
+/**
+ * The provider establishes the DM identity first. This service resolves only
+ * cards actually sent to that binding; the active chat pod is not the card's
+ * authority. It never writes a DecisionRequest or a human message.
+ */
+export const resolveDecisionCardReply = async (input: {
+  integrationId: unknown;
+  linkedUserId: string;
+  cards?: ChannelCardEntry[];
+  provider: 'telegram' | 'slack';
+  text: string;
+  replyToExternalId?: string;
+}): Promise<CardReplyResult> => {
+  const cards = Array.isArray(input.cards) ? input.cards : [];
+  if (!cards.length) return { handled: false };
+  let card: ChannelCardEntry | undefined;
+  let row: IDecisionRequest | null = null;
+  if (input.replyToExternalId) {
+    card = cards.find((entry) => (
+      String(entry.externalMessageId ?? entry.tgMessageId) === input.replyToExternalId
+    ));
+    // An explicit reply to an ordinary line (or our confirmation) must never
+    // be reinterpreted as a bare-number ruling on some unrelated card.
+    if (!card) return { handled: false };
+    row = await DecisionRequest.findOne({ messageId: card.podMessageId }).lean();
+  } else {
+    if (!/^\d{1,2}$/.test(input.text)) return { handled: false };
+    const open = cards.filter((entry) => !entry.closedAt);
+    if (!open.length) return { handled: false };
+    const pending: IDecisionRequest[] = await DecisionRequest.find({
+      messageId: { $in: open.map((entry) => entry.podMessageId) }, status: 'pending',
+    }).lean();
+    if (!pending.length) return { handled: false };
+    if (pending.length > 1) {
+      return { handled: true, confirmation: 'Which one? Reply to the card you mean.' };
+    }
+    [row] = pending;
+    card = open.find((entry) => entry.podMessageId === row?.messageId);
+  }
+  const externalMessageId = card?.externalMessageId ?? card?.tgMessageId;
+  const answer = (confirmation: string): CardReplyResult => ({
+    handled: true, externalMessageId, confirmation,
+  });
+  if (!row || !card) return answer('This card is no longer available. Open Commonly to check the thread.');
+  const podId = String(row.podId);
+  const base = (process.env.PUBLIC_APP_URL || 'https://commonly.me').replace(/\/$/, '');
+  const link = `${base}/v2/pods/${encodeURIComponent(podId)}?message=${encodeURIComponent(card.podMessageId)}`;
+  const pod = await Pod.findById(podId).select('name members createdBy').lean();
+  const caller = await User.findById(input.linkedUserId).select('isBot').lean();
+  const denied = `You're no longer in ${pod?.name || 'this pod'}, so this ruling can't be recorded.`
+    + ` Open it in Commonly: ${link}`;
+  // chooseDecision's already-ruled response precedes its membership guard.
+  // Protect the late-reply writer and standing ruling from ex-members too.
+  if (!pod || !caller || caller.isBot || !isPodMember(pod, input.linkedUserId)) return answer(denied);
+
+  const close = async (): Promise<void> => {
+    try {
+      await Integration.updateOne(
+        { _id: input.integrationId },
+        { $set: { 'config.cards.$[card].closedAt': new Date() } },
+        { arrayFilters: [{ 'card.podMessageId': card.podMessageId, 'card.closedAt': { $exists: false } }] },
+      );
+    } catch (error) {
+      // Settlement has committed. Never turn a projection failure into a
+      // provider retry of the human's ruling; PR 3's sweep will repair this mark.
+      console.warn('[decision-card] close stamp failed:', (error as Error).message);
+    }
+  };
+  const alreadyRuled = async (ruling: {
+    at?: Date | string; by?: string; byUsername?: string; value?: string;
+  }): Promise<CardReplyResult> => {
+    await close();
+    const minutes = ruling.at == null ? NaN
+      : Math.max(0, Math.floor((Date.now() - new Date(ruling.at).getTime()) / 60_000));
+    let rel = '';
+    if (Number.isFinite(minutes)) {
+      if (minutes < 1) rel = ' just now';
+      else if (minutes < 60) rel = ` ${minutes}m ago`;
+      else if (minutes < 1440) rel = ` ${Math.floor(minutes / 60)}h ago`;
+      else rel = ` ${Math.floor(minutes / 1440)}d ago`;
+    }
+    return {
+      ...answer(`Already ruled${rel} by ${ruling.by || ruling.byUsername || 'Human'}: ${ruling.value || ''}.`
+        + ` To change it, the agent asks again — say so in the workspace: ${link}`),
+      lateReply: {
+        podId, messageId: card.podMessageId, ...(row.threadRootId ? { threadRootId: row.threadRootId } : {}),
+      },
+    };
+  };
+  if (row.status === 'ruled') return alreadyRuled(row.ruling || {});
+  if (card.closedAt) return answer(`This card has closed. Open it in Commonly to confirm: ${link}`);
+  let value = input.text.trim().slice(0, 2000);
+  if (/^\d+$/.test(value)) {
+    const index = Number(value) - 1;
+    if (index < 0 || index >= row.options.length) return answer(`Pick 1–${row.options.length}, or write your ruling.`);
+    value = row.options[index].label;
+  }
+  // Load at the reply boundary: requestDecision itself dispatches outbound
+  // cards, and importing its graph at bridge boot would create a cycle.
+  // eslint-disable-next-line @typescript-eslint/no-require-imports, global-require
+  const { chooseDecision } = require('./decisionRequestService');
+  let outcome: { status: number; body: Record<string, any> };
+  try {
+    outcome = await chooseDecision({ decisionId: String(row._id), callerUserId: input.linkedUserId, value });
+  } catch (error) {
+    const failure = error as { status?: number; code?: string };
+    if (failure.code === 'ruling_finalize_conflict') {
+      return answer("Your ruling reached the workspace, but the card didn't close."
+        + ` Open it in Commonly to confirm: ${link}`);
+    }
+    if (failure.code === 'ruling_not_posted') {
+      return answer("Couldn't record that — nothing was saved. Try again in a moment.");
+    }
+    // An unclassified error can occur after the verb's durable write. Do not
+    // claim nothing was saved, retry the verb, or fall through to normal chat.
+    console.error('[decision-card] ruling outcome unknown:', (error as Error).message);
+    return answer(`Couldn't confirm the ruling. Check the thread in Commonly before trying again: ${link}`);
+  }
+  if (outcome.status === 200) {
+    await close();
+    await verdicts.markReachedHuman({
+      integrationId: input.integrationId, podMessageId: card.podMessageId, ruledVia: input.provider,
+      decisionId: String(row._id),
+    });
+    return answer(`✓ Ruled: ${value}`);
+  }
+  if (outcome.status === 403) return answer(denied);
+  if (outcome.status === 409 && outcome.body.decision?.status === 'ruled') {
+    return alreadyRuled(outcome.body.decision.ruling || {});
+  }
+  if (outcome.status === 409) return answer('Someone is ruling this right now — try again in a moment.');
+  if (outcome.status === 503 && outcome.body.code === 'ruling_not_posted') {
+    return answer("Couldn't record that — nothing was saved. Try again in a moment.");
+  }
+  return answer(`Couldn't confirm the ruling. Check the thread in Commonly before trying again: ${link}`);
+};
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+module.exports = { resolveDecisionCardReply };
diff --git a/backend/services/slackApi.ts b/backend/services/slackApi.ts
index a13c2d9ae0..6ee05d3fc9 100644
--- a/backend/services/slackApi.ts
+++ b/backend/services/slackApi.ts
@@ -40,11 +40,12 @@ class SlackApi {
     });
   }
 
-  async postMessage(channel: string, text: string, blocks?: unknown): Promise<PostMessageResponse> {
+  async postMessage(channel: string, text: string, blocks?: unknown, threadTs?: string): Promise<PostMessageResponse> {
     const res = await this.client.post<PostMessageResponse>('/chat.postMessage', {
       channel,
       text,
       blocks,
+      ...(threadTs ? { thread_ts: threadTs } : {}),
     });
     return res.data;
   }
diff --git a/backend/services/slackBridgeService.ts b/backend/services/slackBridgeService.ts
index 19f9719e0c..df38e2461f 100644
--- a/backend/services/slackBridgeService.ts
+++ b/backend/services/slackBridgeService.ts
@@ -13,6 +13,8 @@ const { shouldEscalate } = require('./connectorRelayPolicy');
 // eslint-disable-next-line @typescript-eslint/no-require-imports, global-require
 const channelVerdictService = require('./channelVerdictService');
 import type { DecisionRelayCard } from './decisionCardRelay';
+import { resolveDecisionCardReply } from './decisionCardReply';
+import type { ChannelCardEntry } from './decisionCardReply';
 
 const RELAY_MAP_CAP = 100;
 const OUTBOUND_TEXT_CAP = 900;
@@ -46,6 +48,7 @@ interface SlackIntegrationDoc {
       podMessageId?: string | null;
       podId?: string;
     }>;
+    cards?: ChannelCardEntry[];
   };
 }
 
@@ -234,6 +237,9 @@ export const relayAgentMessageToSlack = async (opts: {
           }],
           $slice: -RELAY_MAP_CAP,
         },
+        ...(opts.card && podMessageId ? {
+          'config.cards': { podMessageId, externalMessageId: String(result.ts), sentAt: new Date() },
+        } : {}),
       },
     });
     if (opts.card && podMessageId) {
@@ -295,7 +301,7 @@ export const relaySlackMessageToPod = async (opts: {
   const { integration, event } = opts;
   const rawText = String(event.text || '').trim();
   if (!rawText || rawText.startsWith('/')) return { relayed: false };
-  if (!integration.podId) {
+  if (!integration.podId && !integration.config?.cards?.length) {
     // A user-scoped connector may have gates without an active inbound
     // destination. Fail closed rather than querying/authoring under
     // `String(undefined)`.
@@ -316,12 +322,37 @@ export const relaySlackMessageToPod = async (opts: {
     );
     return { relayed: false };
   }
+  const cardReply = await resolveDecisionCardReply({
+    integrationId: integration._id,
+    linkedUserId: String(config.linkedUserId),
+    cards: config.cards,
+    provider: 'slack',
+    text: rawText,
+    replyToExternalId: event.thread_ts,
+  });
+  if (cardReply.confirmation) {
+    try {
+      const token = await connectorSecrets.get(String(config.botTokenRef));
+      const sent = await new SlackApi(token).postMessage(
+        String(config.chatId), escapeSlackMrkdwn(cardReply.confirmation), undefined, cardReply.externalMessageId,
+      );
+      if (!sent.ok) console.warn('[slack-bridge] card confirmation was not sent');
+    } catch (error) {
+      console.warn('[slack-bridge] card confirmation failed:', (error as Error).message);
+    }
+  }
+  if (cardReply.handled && !cardReply.lateReply) return { relayed: false };
+  if (!cardReply.lateReply && !integration.podId) {
+    await replyNoActivePod(integration);
+    return { relayed: false };
+  }
   const { content: routedText, routedAgent } = routeSlackReplyContent({
     content: rawText,
     threadTs: event.thread_ts,
-    relayMap: config.relayMap,
+    relayMap: cardReply.lateReply ? [] : config.relayMap,
   });
-  const podId = String(integration.podId);
+  const podId = cardReply.lateReply?.podId || String(integration.podId);
+  const replyToMessageId = cardReply.lateReply?.messageId || null;
   const linkedUserId = String(config.linkedUserId);
   const senderName = event.user_profile?.display_name || event.user_profile?.real_name;
   const content = senderName
@@ -361,7 +392,13 @@ export const relaySlackMessageToPod = async (opts: {
   } catch (error) {
     console.warn('[slack-bridge] PG pod backfill skipped:', (error as Error).message);
   }
-  const created = await PGMessage.create(podId, linkedUserId, content, 'text', null, null, null);
+  let threadRootId: number | null = null;
+  if (cardReply.lateReply?.threadRootId) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, global-require
+    const { resolveThreadRoot } = require('./threadRootResolver');
+    threadRootId = await resolveThreadRoot({ podId, replyToMessageId, threadRootId: cardReply.lateReply.threadRootId });
+  }
+  const created = await PGMessage.create(podId, linkedUserId, content, 'text', replyToMessageId, null, threadRootId);
   let message: Record<string, unknown> = created;
   try {
     const populated = created?.id ? await PGMessage.findById(created.id) : null;
@@ -378,7 +415,7 @@ export const relaySlackMessageToPod = async (opts: {
       message,
       userId: linkedUserId,
       requestUser: { username: linkedUser.username },
-      replyToMessageId: null,
+      replyToMessageId,
     });
   } catch (error) {
     console.error('[slack-bridge] agent delivery failed after pod write:', (error as Error).message);
@@ -397,8 +434,8 @@ export const relaySlackMessageToPod = async (opts: {
         username: linkedUser.username,
         profile_picture: linkedUser.profilePicture,
         createdAt: (message as { created_at?: unknown }).created_at || new Date(),
-        replyTo: null,
-        thread_root_id: null,
+        replyTo: replyToMessageId,
+        thread_root_id: (message as { thread_root_id?: unknown }).thread_root_id ?? threadRootId ?? replyToMessageId,
         payload: null,
       });
     }
diff --git a/backend/services/telegramBridgeService.ts b/backend/services/telegramBridgeService.ts
index 79ea386ee1..40bd412f67 100644
--- a/backend/services/telegramBridgeService.ts
+++ b/backend/services/telegramBridgeService.ts
@@ -29,6 +29,8 @@ const { shouldEscalate } = require('./connectorRelayPolicy');
 // eslint-disable-next-line @typescript-eslint/no-require-imports, global-require
 const channelVerdictService = require('./channelVerdictService');
 import type { DecisionRelayCard } from './decisionCardRelay';
+import { resolveDecisionCardReply } from './decisionCardReply';
+import type { ChannelCardEntry } from './decisionCardReply';
 
 const RELAY_MAP_CAP = 100;
 const OUTBOUND_TEXT_CAP = 900;
@@ -54,6 +56,7 @@ interface TelegramIntegrationDoc {
     linkedUserId?: string;
     leadAgentUsername?: string;
     relayMap?: RelayMapEntry[];
+    cards?: ChannelCardEntry[];
     relayAllAgentMessages?: boolean;
     gates?: Record<string, { enabled?: boolean }>;
     adminPause?: { reason?: string; at?: Date | string; adminId?: string };
@@ -289,6 +292,9 @@ export const relayAgentMessageToTelegram = async (opts: {
           $each: [{ tgMessageId, agentUsername, podMessageId: podMessageId || null }],
           $slice: -RELAY_MAP_CAP,
         },
+        ...(opts.card && podMessageId ? {
+          'config.cards': { podMessageId, tgMessageId, sentAt: new Date() },
+        } : {}),
       },
     });
     if (opts.card && podMessageId) {
@@ -315,6 +321,7 @@ export const relayTelegramMessageToPod = async (opts: {
   telegramMessage: {
     text?: string;
     caption?: string;
+    chat?: { type?: string };
     message_id?: number;
     from?: { first_name?: string; last_name?: string };
     reply_to_message_id?: number;
@@ -325,7 +332,7 @@ export const relayTelegramMessageToPod = async (opts: {
   const rawText = (telegramMessage.text || telegramMessage.caption || '').trim();
   if (!rawText) return { relayed: false };
   if (rawText.startsWith('/')) return { relayed: false }; // commands keep legacy handling
-  if (!integration.podId) {
+  if (!integration.podId && !integration.config?.cards?.length) {
     // `podId` is optional for user-scoped rows, but inbound has one active
     // destination. Never stringify null into a query or author into a pod the
     // connector cannot name.
@@ -334,7 +341,7 @@ export const relayTelegramMessageToPod = async (opts: {
     return { relayed: false };
   }
 
-  const podId = String(integration.podId);
+  let podId = String(integration.podId);
   const linkedUserId = integration.config?.linkedUserId;
   if (!linkedUserId || !isInboundRelayableIntegration(integration, podId)) {
     console.warn('[tg-bridge] live relay without linkedUserId — inbound dropped');
@@ -375,7 +382,7 @@ export const relayTelegramMessageToPod = async (opts: {
   // Widening this needs a real Telegram-sender → Commonly-user mapping, not a
   // longer list of accepted chat types.
   const chatType = integration.config?.chatType;
-  if (chatType !== 'private') {
+  if (chatType !== 'private' || (telegramMessage.chat && telegramMessage.chat.type !== 'private')) {
     console.warn(
       `[tg-bridge] inbound dropped — relay authors as the linked user and chatType=${chatType || 'unknown'} `
         + 'cannot guarantee the sender is them',
@@ -386,10 +393,36 @@ export const relayTelegramMessageToPod = async (opts: {
   const replyToTgMessageId = telegramMessage.reply_to_message?.message_id
     ?? telegramMessage.reply_to_message_id
     ?? null;
+  const cardReply = await resolveDecisionCardReply({
+    integrationId: integration._id,
+    linkedUserId: String(linkedUserId),
+    cards: integration.config?.cards,
+    provider: 'telegram',
+    text: rawText,
+    replyToExternalId: replyToTgMessageId != null ? String(replyToTgMessageId) : undefined,
+  });
+  if (cardReply.confirmation) {
+    try {
+      const sent = await telegramSend.sendMessage(
+        process.env.TELEGRAM_BOT_TOKEN, integration.config?.chatId, cardReply.confirmation,
+        { replyToMessageId: cardReply.externalMessageId, plainText: true },
+      );
+      if (!sent?.success) console.warn('[tg-bridge] card confirmation was not sent');
+    } catch (error) {
+      console.warn('[tg-bridge] card confirmation failed:', (error as Error).message);
+    }
+  }
+  if (cardReply.handled && !cardReply.lateReply) return { relayed: false };
+  if (!cardReply.lateReply && !integration.podId) {
+    await replyNoActivePod(integration);
+    return { relayed: false };
+  }
+  if (cardReply.lateReply) podId = cardReply.lateReply.podId;
+  const replyToMessageId = cardReply.lateReply?.messageId || null;
   const { content: routedText, routedAgent } = routeReplyContent({
     content: rawText,
     replyToTgMessageId: replyToTgMessageId != null ? String(replyToTgMessageId) : null,
-    relayMap: integration.config?.relayMap,
+    relayMap: cardReply.lateReply ? [] : integration.config?.relayMap,
   });
 
   const senderName = [
@@ -438,7 +471,15 @@ export const relayTelegramMessageToPod = async (opts: {
     console.warn('[tg-bridge] PG pod backfill skipped:', (syncErr as Error).message);
   }
 
-  const created = await PGMessage.create(podId, String(linkedUserId), content, 'text', null, null, null);
+  let threadRootId: number | null = null;
+  if (cardReply.lateReply?.threadRootId) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, global-require
+    const { resolveThreadRoot } = require('./threadRootResolver');
+    threadRootId = await resolveThreadRoot({ podId, replyToMessageId, threadRootId: cardReply.lateReply.threadRootId });
+  }
+  const created = await PGMessage.create(
+    podId, String(linkedUserId), content, 'text', replyToMessageId, null, threadRootId,
+  );
   let message: Record<string, unknown> = created;
   try {
     const populated = created?.id ? await PGMessage.findById(created.id) : null;
@@ -460,7 +501,7 @@ export const relayTelegramMessageToPod = async (opts: {
       message,
       userId: String(linkedUserId),
       requestUser: { username: linkedUser.username },
-      replyToMessageId: null,
+      replyToMessageId,
     });
   } catch (deliverErr) {
     console.error('[tg-bridge] agent delivery failed after pod write:', (deliverErr as Error).message);
@@ -484,8 +525,8 @@ export const relayTelegramMessageToPod = async (opts: {
         username: linkedUser.username,
         profile_picture: linkedUser.profilePicture,
         createdAt: (message as { created_at?: unknown }).created_at || new Date(),
-        replyTo: null,
-        thread_root_id: null,
+        replyTo: replyToMessageId,
+        thread_root_id: (message as { thread_root_id?: unknown }).thread_root_id ?? threadRootId ?? replyToMessageId,
         payload: null,
       });
     }
diff --git a/backend/services/telegramService.ts b/backend/services/telegramService.ts
index 4c042f06ae..a186cf9be6 100644
--- a/backend/services/telegramService.ts
+++ b/backend/services/telegramService.ts
@@ -9,7 +9,10 @@ interface SendResult {
   messageId?: number;
 }
 
-async function sendMessage(botToken: string, chatId: string | number, text: string): Promise<SendResult> {
+async function sendMessage(botToken: string, chatId: string | number, text: string, options?: {
+  replyToMessageId?: string;
+  plainText?: boolean;
+}): Promise<SendResult> {
   if (!botToken || !chatId || !text) {
     return { success: false, error: 'Missing botToken, chatId, or text' };
   }
@@ -20,7 +23,8 @@ async function sendMessage(botToken: string, chatId: string | number, text: stri
       {
         chat_id: chatId,
         text,
-        parse_mode: 'HTML',
+        ...(!options?.plainText ? { parse_mode: 'HTML' } : {}),
+        ...(options?.replyToMessageId ? { reply_parameters: { message_id: Number(options.replyToMessageId) } } : {}),
         disable_web_page_preview: true,
       },
     );
diff --git a/docs/integrations/decision-card-replies.md b/docs/integrations/decision-card-replies.md
new file mode 100644
index 0000000000..6b8bcd2256
--- /dev/null
+++ b/docs/integrations/decision-card-replies.md
@@ -0,0 +1,70 @@
+# Decision-card channel replies
+
+Implementation of [the card note](../plans/decision-card-in-channel.md) D3–D5,
+TASK-011 PR 2. The decision service remains the only DecisionRequest writer.
+
+## Write boundaries
+
+| Verb outcome | Bridge-authored pod message | Receipt | Ledger |
+| --- | --- | --- | --- |
+| 200 | None; the verb already posted the threaded ruling | Mark closed | Replying channel reached; whole fork settled via that provider |
+| 403 | None | Unchanged | Unchanged |
+| 409, already ruled | One ordinary threaded follow-up under the ask, not under the winning reply | Mark closed | Unchanged |
+| 409, lock held | None | Unchanged | Unchanged |
+| 503 `ruling_not_posted` | None | Unchanged | Unchanged |
+| Thrown `ruling_finalize_conflict` | None; the verb already posted one reply | Unchanged | Unchanged |
+
+An unexpected verb error gets a “check the thread before retrying” response:
+it cannot safely be described as “nothing saved.” Confirmation transport and
+close-stamp failures never retry the verb or fall through to ordinary chat.
+
+The provider authenticates its private DM sender before card resolution.
+Resolution uses only that integration's `config.cards`, never the pod's full
+pending-decision list. The caller comes from the current webhook lookup's
+`config.linkedUserId`, not a stored receipt. Membership is checked against the
+card's pod before exposing a standing ruling or posting a late follow-up;
+`chooseDecision` also checks it before acquiring its write lock.
+
+The active-pod guard applies only to ordinary chat. A card can still be answered
+with no active pod, or after leaving the active pod, if the person remains a
+member of the card's pod (Wren's ruling in pod message 64265).
+
+## Receipts and compatibility
+
+`config.cards` is a server-owned array declared in the Integration schema;
+outbound card sends append it alongside the bounded `relayMap`. It has no
+count-based eviction. Existing integrations require no backfill to continue
+ordinary chat. Only cards sent after PR 2 is deployed acquire durable receipts;
+old PR 1 cards are not retroactively made reply-resolvable. Ask a fresh card for
+the cutover smoke.
+
+Owner PATCH writes individual top-level config fields, not a replacement
+snapshot. This retains the existing one-level merge contract for fields such as
+`gates`, while preventing a settings write from erasing concurrent card sends or
+closure stamps. Client receipt writes and dotted update paths are refused or
+stripped at the route boundary.
+
+Workspace-originated confirmation fan-out and the five-minute/seven-day receipt
+sweep belong to TASK-011 PR 3. PR 2 marks the answering chat; it does not claim to
+have delivered sibling-chat or workspace-originated confirmations.
+
+## Verification
+
+`backend/__tests__/unit/services/decisionCardReply.bridges.test.js` runs both
+provider bridges through the real decision service, MongoDB lock CAS, Integration
+receipt writes and ChannelVerdict writes. PostgreSQL message storage, provider
+network calls and event transport are mocked; these tests are not a live-send or
+real-PostgreSQL claim. The overlapping-reply test blocks the first PG write while
+the second invocation enters the real CAS. Lock expiry uses an injected clock.
+
+Every refusal checks pod messages, receipts and ledger state. A deliberate
+mutation adding a close stamp to the 503 catch fails both providers' `closedAt`
+assertions. Additional cases cover 150 intervening relays, current-owner changes,
+ghost cards, no active pod, and late replies from an already-marked sibling.
+
+Transport contract tests pin Telegram's current
+[`reply_parameters.message_id`](https://core.telegram.org/bots/api#sendmessage)
+and Slack's [`thread_ts`](https://docs.slack.dev/reference/methods/chat.postMessage/)
+to the original card. Telegram confirmations omit HTML parsing so a 2000-character
+human ruling is literal text rather than escaped markup that could exceed the
+provider limit; ordinary outbound HTML remains unchanged.