@commonlyai/cli 0.1.233 → 0.1.234

package/package.json

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

package/src/commands/agent.js

@@ -134,6 +134,7 @@ import {
   peerHoldsFrame,
   resolveCascadeSettings,
 } from '../lib/enforcement.js';
+import { buildReplyReceipt } from '../lib/reply-receipt.js';
 
 const isPodFocusDiagnostic = (error) => (
   typeof error?.code === 'string'
@@ -2296,6 +2297,8 @@ export const performRun = ({
       ? { mounted: serverSkills.mounted, conflicted: serverSkills.conflicted, ...(skillReadUnavailable ? { status: 'unavailable' } : {}) }
       : null;
     let spawnCompleted = false;
+    // D245 item 4: how long the runtime ran, for the reply receipt.
+    let spawnDurationMs;
     let observedSpawn = false;
     let commitAttribution = null;
     try {
@@ -2364,7 +2367,9 @@ export const performRun = ({
       };
       // Supervised or plain, a failure is thrown exactly as the adapter's own
       // would be, so the run loop's classification and retry apply unchanged.
+      const spawnStartedAt = Date.now();
       result = await turn.run(adapter, spawnPrompt, spawnCtx);
+      spawnDurationMs = Date.now() - spawnStartedAt;
       spawnCompleted = true;
     } finally {
       try {
@@ -2551,6 +2556,12 @@ export const performRun = ({
           maxChunks: maxChatChunks,
           uploadName: `${agentName}-reply-${event._id}.md`,
           log: (line) => log(`[${event.type}] ${line}`),
+          // D245 item 4: the wrapper's own account of this turn.
+          receipt: buildReplyReceipt({
+            adapterName: adapter.name,
+            stats: result.stats,
+            durationMs: spawnDurationMs,
+          }),
         });
       } catch (deliveryError) {
         // TASK-535: every rung threw, so the reply reached nobody. The throw

package/src/lib/adapters/claude.js

@@ -53,6 +53,7 @@ import { describeTurnReap, markTurn, turnReapEnabled } from '@commonlyai/seats/t
  */
 
 import { requireSeatModel, seatModelRequired } from './seat-model.js';
+import { claudeRunStats } from '../reply-receipt.js';
 import { spawn as childSpawn, spawnSync } from 'child_process';
 import { createHash, randomUUID } from 'crypto';
 import { accessSync, constants, realpathSync } from 'fs';
@@ -1521,6 +1522,8 @@ export default {
         text: turnReply(stdout, { credentials: spawnCredentials(spawnCtx), publicMcp: witnessedMcp }),
         newSessionId: sessionId,
         contextTokens,
+        // D245 item 4: what the run said about itself, for the reply receipt.
+        stats: claudeRunStats(stdout),
       };
     } catch (err) {
       // A public seat's refusal is not a session-store failure, whatever its
@@ -1591,6 +1594,7 @@ export default {
           text: turnReply(stdout, { credentials: spawnCredentials(retryCtx), publicMcp: witnessedMcp }),
           newSessionId: freshId,
           contextTokens,
+          stats: claudeRunStats(stdout),
         };
       }
       throw err;

package/src/lib/enforcement.js

@@ -668,6 +668,9 @@ export const deliverChatReply = async ({
   attachThreshold = 800,
   uploadName = 'reply.md',
   log = () => {},
+  // D245 item 4: how this reply was made (lib/reply-receipt.js). It rides
+  // the first message that actually reaches the pod and no later one.
+  receipt = null,
 }) => {
   const messagesPath = `/api/agents/runtime/pods/${podId}/messages`;
   const chunks = splitForChat(text, { limit });
@@ -697,7 +700,14 @@ export const deliverChatReply = async ({
   // override per delivery; a post that still fails throws to the next rung as
   // before. Nothing here loops.
   let freshnessOverride = false;
-  const postMessage = async (body) => {
+  let receiptDelivered = !receipt;
+  const postOnce = async (rawBody) => {
+    const body = receiptDelivered ? rawBody : { ...rawBody, receipt };
+    const response = await postGuarded(body);
+    if (response?.refused !== true && response?.skipped !== true) receiptDelivered = true;
+    return response;
+  };
+  const postGuarded = async (body) => {
     if (freshnessOverride) return client.post(messagesPath, { ...body, continueAnyway: true });
     try {
       return await client.post(messagesPath, body);
@@ -774,7 +784,7 @@ export const deliverChatReply = async ({
   // the gate (found by the fleet's implementation audit).
   const hasIndivisibleOversize = chunks.some((c) => c.length > attachThreshold);
   if (chunks.length <= 1 && !hasIndivisibleOversize) {
-    const response = await postMessage({ content: chunks[0] ?? text });
+    const response = await postOnce({ content: chunks[0] ?? text });
     if (undelivered(response)) return nonDelivery(response, 0, 1);
     return { mode: 'single', messages: 1 };
   }
@@ -782,7 +792,7 @@ export const deliverChatReply = async ({
     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
+      const response = await postOnce({ content: chunk }); // in order, so the reply reads top-down
       if (undelivered(response)) return nonDelivery(response, messages, chunks.length);
       messages += 1;
     }
@@ -802,7 +812,7 @@ export const deliverChatReply = async ({
     // fail at the root-id step before any continuation has posted.
     let posted = 0;
     try {
-      const rootRes = await postMessage({ content: chunks[0] });
+      const rootRes = await postOnce({ content: chunks[0] });
       if (undelivered(rootRes)) return nonDelivery(rootRes, 0, chunks.length);
       posted = 1;
       // The runtime route answers `res.json(result)` with the created row on
@@ -814,7 +824,7 @@ export const deliverChatReply = async ({
       if (!rootId) throw new Error('no message id in post response — cannot root the thread');
       for (const chunk of chunks.slice(1)) {
         // eslint-disable-next-line no-await-in-loop
-        const response = await postMessage({ content: chunk, threadRootId: String(rootId) });
+        const response = await postOnce({ content: chunk, threadRootId: String(rootId) });
         if (undelivered(response)) return nonDelivery(response, posted, chunks.length);
         posted += 1;
       }
@@ -829,7 +839,7 @@ export const deliverChatReply = async ({
         log(`thread continuation failed (${err.message}) — posting the remainder top-level`);
         for (const chunk of chunks.slice(posted)) {
           // eslint-disable-next-line no-await-in-loop
-          const response = await postMessage({ content: chunk });
+          const response = await postOnce({ content: chunk });
           if (undelivered(response)) return nonDelivery(response, posted, chunks.length);
           posted += 1;
         }
@@ -855,7 +865,7 @@ export const deliverChatReply = async ({
     const lead = chunks[0] && chunks[0].length <= limit
       ? chunks[0]
       : '(reply too large for chat — attached in full)';
-    const response = await postMessage({ content: `${lead}\n\n${directive}` });
+    const response = await postOnce({ content: `${lead}\n\n${directive}` });
     if (undelivered(response)) return nonDelivery(response, 0, 1);
     return { mode: 'attach', messages: 1 };
   } catch (err) {
@@ -863,7 +873,7 @@ export const deliverChatReply = async ({
     let messages = 0;
     for (const chunk of chunks) {
       // eslint-disable-next-line no-await-in-loop
-      const response = await postMessage({ content: chunk });
+      const response = await postOnce({ content: chunk });
       if (undelivered(response)) return nonDelivery(response, messages, chunks.length);
       messages += 1;
     }

package/src/lib/reply-receipt.js

@@ -0,0 +1,53 @@
+// D245 item 4: the receipt the wrapper posts with a reply, so a BYO reply
+// carries "how this reply was made" the way a hosted reply has its run trace.
+// It is the wrapper's own account and the server stores it as self-reported
+// (backend/services/byoReceipt.ts), which also bounds and checks every field.
+// This side keeps to what it actually observed: an adapter that reports no
+// stats sends only its name and the measured duration.
+
+const isName = (value) => typeof value === 'string' && value.length > 0;
+const isCount = (value) => Number.isInteger(value) && value >= 0;
+
+const parseLine = (raw) => {
+  try { return JSON.parse(raw); } catch { return null; }
+};
+
+/**
+ * What a Claude Code stream-json run says about itself: the model from the
+ * init event, the turn count from the result event, and each tool it called,
+ * once, in first-use order.
+ */
+export const claudeRunStats = (stdout) => {
+  const events = String(stdout || '').split('\n').map(parseLine).filter(Boolean);
+  const stats = {};
+  const init = events.find((event) => event.type === 'system' && event.subtype === 'init');
+  if (isName(init?.model)) stats.model = init.model;
+  const result = [...events].reverse().find((event) => event.type === 'result');
+  if (isCount(result?.num_turns)) stats.turns = result.num_turns;
+  const tools = [];
+  for (const event of events) {
+    if (event.type !== 'assistant') continue;
+    for (const block of event.message?.content || []) {
+      if (block?.type === 'tool_use' && isName(block.name) && !tools.includes(block.name)) tools.push(block.name);
+    }
+  }
+  if (tools.length) stats.tools = tools;
+  return stats;
+};
+
+/** The receipt for one reply, or null when there is no adapter to name. */
+export const buildReplyReceipt = ({ adapterName, stats = {}, durationMs } = {}) => {
+  if (!isName(adapterName)) return null;
+  const receipt = { adapter: adapterName };
+  // A cloud-hosted model can be named by an ARN or a resource path that
+  // carries the account or project it runs in; that is not this reply's to
+  // publish, so such a model id is left out.
+  if (isName(stats?.model) && !/^arn:|(^|\/)projects\//i.test(stats.model)) receipt.model = stats.model;
+  if (isCount(stats?.turns)) receipt.turns = stats.turns;
+  if (Array.isArray(stats?.tools)) {
+    const tools = stats.tools.filter(isName);
+    if (tools.length) receipt.tools = tools;
+  }
+  if (Number.isFinite(durationMs) && durationMs >= 0) receipt.durationMs = Math.round(durationMs);
+  return receipt;
+};