@commonlyai/cli 0.1.87 → 0.1.89

package/package.json

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

package/src/commands/agent.js

@@ -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: {

package/src/lib/enforcement.js

@@ -483,12 +483,53 @@ export const createClaimKeeper = (client, {
 
 // ── post-time length gate ───────────────────────────────────────────────────
 
+// A sentence ends at [.!?] followed by whitespace, except when what precedes
+// the whitespace is only a numbered list marker at the start of the line: in
+// "3. Run it once." the first period belongs to the marker, not a sentence.
+// Applied to one line at a time, so `^` is the line start.
+const SENTENCE_END = /(?<=[.!?])(?<!^[ \t]*\d{1,3}\.)\s+/;
+
+// Split one over-limit line at sentence boundaries, and a sentence that is
+// itself over the limit at word boundaries. A single over-limit word (a URL)
+// posts whole rather than being cut.
+const splitLineForChat = (line, limit) => {
+  const units = [];
+  let piece = '';
+  const flushPiece = () => {
+    if (piece.trim()) units.push(piece.trim());
+    piece = '';
+  };
+  for (const sentence of line.split(SENTENCE_END)) {
+    if (sentence.length > limit) {
+      flushPiece();
+      let run = '';
+      for (const word of sentence.split(/\s+/)) {
+        if (run && `${run} ${word}`.length > limit) {
+          units.push(run);
+          run = word;
+        } else {
+          run = run ? `${run} ${word}` : word;
+        }
+      }
+      if (run) units.push(run);
+    } else if (piece && `${piece} ${sentence}`.length > limit) {
+      flushPiece();
+      piece = sentence;
+    } else {
+      piece = piece ? `${piece} ${sentence}` : sentence;
+    }
+  }
+  flushPiece();
+  return units;
+};
+
 /**
  * Split chat text into tone-contract-sized messages without ever cutting
  * content. Boundaries in preference order: fenced code blocks stay whole
  * (atomic — an oversized fence becomes one oversized message rather than a
- * broken pair), then paragraphs, then sentences, then words. Greedy packing
- * rejoins small pieces so two short paragraphs share one message.
+ * broken pair), then paragraphs, then lines (a list item never leaves its
+ * marker), then sentences, then words. Greedy packing rejoins small pieces so
+ * two short paragraphs share one message.
  */
 export const splitForChat = (text, { limit = 400 } = {}) => {
   const trimmed = String(text || '').trim();
@@ -529,39 +570,39 @@ export const splitForChat = (text, { limit = 400 } = {}) => {
   }
   flushProse();
 
-  // Pass 2: split oversized prose blocks at sentence then word boundaries.
+  // Pass 2: split oversized prose blocks at line, then sentence, then word
+  // boundaries. Lines come first because a list is one paragraph block whose
+  // items are separated by single newlines: splitting it by sentence read a
+  // numbered marker ("3.") as a sentence end and packed it onto the previous
+  // piece, so a support reply posted one message ending in "3." and the next
+  // opening with step 3's body (hq-support, 2026-10-09). Lines pack greedily
+  // with single newlines, so a list stays a list inside a message; only a line
+  // that is itself over the limit goes on to sentences and words.
   const units = [];
   for (const block of blocks) {
     if (block.atomic || block.text.length <= limit) {
       units.push(block.text);
       continue;
     }
-    let piece = '';
-    const flushPiece = () => {
-      if (piece.trim()) units.push(piece.trim());
-      piece = '';
+    let group = '';
+    const flushGroup = () => {
+      if (group) units.push(group);
+      group = '';
     };
-    for (const sentence of block.text.split(/(?<=[.!?])\s+/)) {
-      if (sentence.length > limit) {
-        flushPiece();
-        let run = '';
-        for (const word of sentence.split(/\s+/)) {
-          if (run && `${run} ${word}`.length > limit) {
-            units.push(run);
-            run = word;
-          } else {
-            run = run ? `${run} ${word}` : word;
-          }
-        }
-        if (run) units.push(run); // a single over-limit word (URL) posts whole
-      } else if (piece && `${piece} ${sentence}`.length > limit) {
-        flushPiece();
-        piece = sentence;
+    for (const rawLine of block.text.split('\n')) {
+      const line = rawLine.trimEnd(); // keep a nested item's indentation
+      if (!line.trim()) continue;
+      if (line.length > limit) {
+        flushGroup();
+        units.push(...splitLineForChat(line, limit));
+      } else if (group && `${group}\n${line}`.length > limit) {
+        flushGroup();
+        group = line;
       } else {
-        piece = piece ? `${piece} ${sentence}` : sentence;
+        group = group ? `${group}\n${line}` : line;
       }
     }
-    flushPiece();
+    flushGroup();
   }
 
   // Pass 3: greedy packing back up to the limit.
@@ -646,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
@@ -655,7 +731,7 @@ 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) {
@@ -663,7 +739,7 @@ export const deliverChatReply = async ({
     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 };
@@ -683,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
@@ -695,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) };
@@ -710,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 };
@@ -736,7 +812,7 @@ 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`);
@@ -744,7 +820,7 @@ export const deliverChatReply = async ({
     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 };