fix(cli): a server-skipped post is logged as a skip, not as a delivery (#2106)

* fix(cli): a server-skipped post is logged as a skip, not as a delivery

The runtime post route answers HTTP 200 with `{ success: true, skipped:
true, reason }` when it creates no row: a duplicate inside its dedupe
window, a silent body, a heartbeat it keeps. deliverChatReply only read
`refused`, so a skip counted as a delivery and the wrapper logged
"posted 151 bytes as 1 message (single)" while nothing reached the pod
(hq-support, 2026-10-09 08:10Z). A silent seat could not be read from
its own log.

deliverChatReply now treats a skip like a refusal at every post site:
mode 'skipped', the reason, the duplicate's id and dedupe window when the
server names them, and the sequence stops. The wrapper logs
"server skipped the post: duplicate_recent (30 min window, duplicate of
<id>) — nothing reached the pod", raises onError with code
agent_delivery_skipped, and acks the event under the existing
delivery-refused class so the same text is not replayed into the window.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013geJsV4RJMujdvpf3JV2Cv

* chore(cli): 0.1.89 for the skipped-post log

cli/src changed, so the published version must rise ("Source changed ⇒
version bumped").

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013geJsV4RJMujdvpf3JV2Cv

---------

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>

Author: lilyshen0722

cli/__tests__/enforcement.test.mjs

@@ -549,6 +549,54 @@ describe('deliverChatReply', () => {
     });
   });
 
+  // hq-support, 2026-10-09 08:10Z: the server answered `{ success: true,
+  // skipped: true, reason: 'duplicate_recent' }` and the wrapper logged
+  // "posted 151 bytes as 1 message (single)". Nothing had reached the pod.
+  test('a normal-return skip is not recorded as a single-message delivery', async () => {
+    const post = jest.fn().mockResolvedValue({
+      success: true,
+      skipped: true,
+      reason: 'duplicate_recent',
+      duplicate: { id: 'msg-earlier', createdAt: '2026-10-09T07:55:29.000Z', dedupeWindowMinutes: 30 },
+    });
+    const res = await deliverChatReply({ client: { post }, podId: 'pod-1', text: 'short answer' });
+
+    expect(res).toEqual({
+      mode: 'skipped',
+      messages: 0,
+      attemptedMessages: 1,
+      skipped: true,
+      reason: 'duplicate_recent',
+      duplicate: { id: 'msg-earlier', dedupeWindowMinutes: 30 },
+    });
+  });
+
+  test('a skip without a duplicate record carries only its reason', async () => {
+    const post = jest.fn().mockResolvedValue({ success: true, skipped: true, reason: 'silent_or_empty' });
+    const res = await deliverChatReply({ client: { post }, podId: 'pod-1', text: 'short answer' });
+    expect(res).toEqual({
+      mode: 'skipped', messages: 0, attemptedMessages: 1, skipped: true, reason: 'silent_or_empty',
+    });
+  });
+
+  test('a split reply stops at a skipped chunk and reports only delivered chunks', async () => {
+    const post = jest.fn()
+      .mockResolvedValueOnce({ success: true })
+      .mockResolvedValueOnce({ success: true, skipped: true, reason: 'duplicate_recent', duplicate: { id: 'm-2', dedupeWindowMinutes: 30 } })
+      .mockResolvedValueOnce({ success: true });
+    const text = `${'a'.repeat(390)}\n\n${'b'.repeat(390)}\n\n${'c'.repeat(390)}`;
+    const res = await deliverChatReply({ client: { post }, podId: 'pod-1', text });
+    expect(res).toEqual({
+      mode: 'skipped',
+      messages: 1,
+      attemptedMessages: 3,
+      skipped: true,
+      reason: 'duplicate_recent',
+      duplicate: { id: 'm-2', dedupeWindowMinutes: 30 },
+    });
+    expect(post).toHaveBeenCalledTimes(2); // the third chunk is never attempted
+  });
+
   test('a split-sized reply posts its chunks in order', async () => {
     const post = jest.fn().mockResolvedValue({});
     const text = `${'a'.repeat(390)}\n\n${'b'.repeat(390)}`;

cli/__tests__/run-loop.test.mjs

@@ -465,6 +465,66 @@ describe('performRun', () => {
     expect(onError.mock.calls[0][0].message).toContain(guidance);
   });
 
+  test('a normal-return skip is logged as a skip and acked, never as a posted reply', async () => {
+    // hq-support, 2026-10-09 08:10Z: the post route answered 200 with
+    // { success: true, skipped: true, reason: 'duplicate_recent' } and the
+    // wrapper logged "posted 151 bytes as 1 message (single)". Nothing had
+    // reached the pod, so the seat looked like it spoke when it was silent.
+    const lines = [];
+    const mockGet = jest.fn().mockResolvedValue({ events: [makeEvent({ _id: 'evt-dup' })] });
+    const mockPost = jest.fn(async (route) => {
+      if (route === '/api/agents/runtime/pods/pod-abc/messages') {
+        return {
+          success: true,
+          skipped: true,
+          reason: 'duplicate_recent',
+          duplicate: { id: 'msg-earlier', createdAt: '2026-10-09T07:55:29.000Z', dedupeWindowMinutes: 30 },
+        };
+      }
+      return {};
+    });
+    createClient.mockReturnValue({ get: mockGet, post: mockPost });
+    const onError = jest.fn();
+    const spawn = jest.fn(async () => ({ text: 'Thanks, that answers it.' }));
+    const adapter = { name: 'stub', detect: stubAdapter.detect, spawn };
+
+    const { stop } = performRun({
+      instanceUrl: 'http://localhost:5000',
+      token: 'cm_agent_test',
+      adapter,
+      agentName: 'my-stub',
+      onError,
+      setTimeoutImpl: noopTimeout,
+      log: (line) => lines.push(line),
+    });
+    await drainMicrotasks();
+    stop();
+
+    const skipLine = lines.find((line) => line.includes('server skipped the post'));
+    expect(skipLine).toContain('duplicate_recent');
+    expect(skipLine).toContain('30 min window');
+    expect(skipLine).toContain('duplicate of msg-earlier');
+    expect(skipLine).toContain('nothing reached the pod');
+    expect(lines.some((line) => /posted \d+ bytes as/.test(line))).toBe(false);
+
+    expect(mockPost).toHaveBeenCalledWith(
+      '/api/agents/runtime/events/evt-dup/ack',
+      {
+        result: {
+          outcome: 'no_action',
+          reason: 'duplicate_recent',
+          details: { mode: 'skipped', postedMessages: 0, attemptedMessages: 1 },
+        },
+      },
+    );
+    expect(onError).toHaveBeenCalledWith(expect.objectContaining({
+      code: 'agent_delivery_skipped',
+      reason: 'duplicate_recent',
+      postedMessages: 0,
+      attemptedMessages: 1,
+    }));
+  });
+
   test('first_contact event is forwarded to the adapter like a mention', async () => {
     const events = [makeEvent({
       _id: 'evt-first-contact',

cli/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@commonlyai/cli",
-  "version": "0.1.88",
+  "version": "0.1.89",
   "license": "Apache-2.0",
   "description": "The Commonly CLI — connect agents, manage pods, iterate fast",
   "type": "module",

cli/package.json

@@ -1594,7 +1594,35 @@ export const performRun = ({
         uploadName: `${agentName}-reply-${event._id}.md`,
         log: (line) => log(`[${event.type}] ${line}`),
       });
-      if (delivery.refused) {
+      if (delivery.skipped) {
+        // The server answered 200 and created nothing: a duplicate inside its
+        // dedupe window, a silent body, a heartbeat it keeps. Nothing reached
+        // the pod, so this is not a delivery and must not read as one in the
+        // log — "posted 151 bytes as 1 message" over a skip is how a silent
+        // seat looked like a talking one (hq-support, 2026-10-09 08:10Z). Ack
+        // it like a refusal: re-posting the same text inside the window would
+        // only be skipped again.
+        deliveryRefusal = delivery;
+        const windowMinutes = delivery.duplicate?.dedupeWindowMinutes;
+        const detail = [
+          windowMinutes ? `${windowMinutes} min window` : null,
+          delivery.duplicate?.id ? `duplicate of ${delivery.duplicate.id}` : null,
+          delivery.attemptedMessages > 1
+            ? `after ${delivery.messages}/${delivery.attemptedMessages} messages`
+            : null,
+        ].filter(Boolean).join(', ');
+        log(`[${event.type}] server skipped the post: ${delivery.reason}${detail ? ` (${detail})` : ''} — nothing reached the pod`);
+        onError?.(Object.assign(
+          new Error(`${event.type} server skipped the post: ${delivery.reason}`),
+          {
+            code: 'agent_delivery_skipped',
+            reason: delivery.reason,
+            eventId: event._id,
+            postedMessages: delivery.messages,
+            attemptedMessages: delivery.attemptedMessages,
+          },
+        ));
+      } else if (delivery.refused) {
         // A run-cap refusal is a successful HTTP request but not a delivery.
         // Ack it so the kernel does not replay the same text (the server
         // guidance expressly says not to retry unchanged), while preserving
@@ -1640,6 +1668,8 @@ export const performRun = ({
     if (deliveryRefusal) {
       return {
         outcome: 'no_action',
+        // Kernel class, from REFUSAL_REASONS: a skip is the server declining to
+        // deliver, same class as a refusal; the specific reason rides below.
         refused: { reason: 'delivery-refused' },
         reason: deliveryRefusal.reason,
         details: {

cli/src/commands/agent.js

@@ -687,6 +687,41 @@ export const deliverChatReply = async ({
       ? { consecutive: response.consecutive }
       : {}),
   });
+  // The same route also answers HTTP 200 with `{ success: true, skipped: true,
+  // reason }` when it decided not to create a row: a duplicate inside the dedupe
+  // window, a silent or empty body, a heartbeat it keeps to itself. The wrapper
+  // used to read that as a delivery and log "posted … (single)" while nothing
+  // reached the pod (hq-support, 2026-10-09 08:10Z), so a silent seat could not
+  // be read from its own log. A skip is a completed request and not a delivery,
+  // exactly like a refusal, and it stops a sequence the same way.
+  const skipped = (response, messages, attemptedMessages) => {
+    const duplicate = response.duplicate && typeof response.duplicate === 'object'
+      ? response.duplicate
+      : null;
+    return {
+      mode: 'skipped',
+      messages,
+      attemptedMessages,
+      skipped: true,
+      reason: response.reason || 'message_skipped',
+      ...(duplicate
+        ? {
+          duplicate: {
+            ...(duplicate.id ? { id: String(duplicate.id) } : {}),
+            ...(typeof duplicate.dedupeWindowMinutes === 'number'
+              ? { dedupeWindowMinutes: duplicate.dedupeWindowMinutes }
+              : {}),
+          },
+        }
+        : {}),
+    };
+  };
+  const undelivered = (response) => response?.refused === true || response?.skipped === true;
+  const nonDelivery = (response, messages, attemptedMessages) => (
+    response?.refused === true
+      ? refused(response, messages, attemptedMessages)
+      : skipped(response, messages, attemptedMessages)
+  );
   // An atomic unit (a fenced block, an unbreakable word-run) can exceed the
   // limit by construction — splitForChat keeps it whole rather than breaking
   // its rendering. The tone contract's own rule covers it: over ~800 chars of
@@ -696,15 +731,15 @@ export const deliverChatReply = async ({
   const hasIndivisibleOversize = chunks.some((c) => c.length > attachThreshold);
   if (chunks.length <= 1 && !hasIndivisibleOversize) {
     const response = await postMessage({ content: chunks[0] ?? text });
-    if (response?.refused === true) return refused(response, 0, 1);
+    if (undelivered(response)) return nonDelivery(response, 0, 1);
     return { mode: 'single', messages: 1 };
   }
   if (chunks.length <= maxChunks && !hasIndivisibleOversize) {
     let messages = 0;
     for (const chunk of chunks) {
       // eslint-disable-next-line no-await-in-loop
       const response = await postMessage({ content: chunk }); // in order, so the reply reads top-down
-      if (response?.refused === true) return refused(response, messages, chunks.length);
+      if (undelivered(response)) return nonDelivery(response, messages, chunks.length);
       messages += 1;
     }
     return { mode: 'split', messages };
@@ -724,7 +759,7 @@ export const deliverChatReply = async ({
     let posted = 0;
     try {
       const rootRes = await postMessage({ content: chunks[0] });
-      if (rootRes?.refused === true) return refused(rootRes, 0, chunks.length);
+      if (undelivered(rootRes)) return nonDelivery(rootRes, 0, chunks.length);
       posted = 1;
       // The runtime route answers `res.json(result)` with the created row on
       // `result.message`. Accept either id field; refuse to guess if neither
@@ -736,7 +771,7 @@ export const deliverChatReply = async ({
       for (const chunk of chunks.slice(1)) {
         // eslint-disable-next-line no-await-in-loop
         const response = await postMessage({ content: chunk, threadRootId: String(rootId) });
-        if (response?.refused === true) return refused(response, posted, chunks.length);
+        if (undelivered(response)) return nonDelivery(response, posted, chunks.length);
         posted += 1;
       }
       return { mode: 'thread', messages: chunks.length, threadRootId: String(rootId) };
@@ -751,7 +786,7 @@ export const deliverChatReply = async ({
         for (const chunk of chunks.slice(posted)) {
           // eslint-disable-next-line no-await-in-loop
           const response = await postMessage({ content: chunk });
-          if (response?.refused === true) return refused(response, posted, chunks.length);
+          if (undelivered(response)) return nonDelivery(response, posted, chunks.length);
           posted += 1;
         }
         return { mode: 'thread-fallback', messages: chunks.length };
@@ -777,15 +812,15 @@ export const deliverChatReply = async ({
       ? chunks[0]
       : '(reply too large for chat — attached in full)';
     const response = await postMessage({ content: `${lead}\n\n${directive}` });
-    if (response?.refused === true) return refused(response, 0, 1);
+    if (undelivered(response)) return nonDelivery(response, 0, 1);
     return { mode: 'attach', messages: 1 };
   } catch (err) {
     log(`attach fallback failed (${err.message}) — posting ${chunks.length} split messages instead`);
     let messages = 0;
     for (const chunk of chunks) {
       // eslint-disable-next-line no-await-in-loop
       const response = await postMessage({ content: chunk });
-      if (response?.refused === true) return refused(response, messages, chunks.length);
+      if (undelivered(response)) return nonDelivery(response, messages, chunks.length);
       messages += 1;
     }
     return { mode: 'split-fallback', messages };