@commonlyai/cli 0.1.215 → 0.1.216

package/package.json

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

package/src/lib/adapters/claude.js

@@ -494,10 +494,65 @@ const publicSkillPromptArgs = async (skillSources) => {
 
 // `ownGroup` is set only under the run supervisor, which kills the child's
 // whole group; unsupervised, the spawn options are exactly what they were.
+// Stream-json so each model event is a sign of life for the watchdog. The
+// partial messages put thinking deltas on the stream too, so a long think is
+// visible while it runs. A hung provider writes only `system` retry events,
+// and the watchdog does not count those.
+const STREAM_ARGS = ['--output-format', 'stream-json', '--verbose', '--include-partial-messages'];
+
+const parseEvent = (line) => {
+  try {
+    const event = JSON.parse(line);
+    return event && typeof event === 'object' ? event : null;
+  } catch {
+    return null;
+  }
+};
+
+// The reply is the `result` event's text. A turn that reaches no result event
+// (killed mid-stream, exit 0) gets the text of its assistant events, never the
+// raw NDJSON. Output with no JSON lines at all is plain text and returned as it
+// arrived. A result flagged `is_error` is a failed turn, whatever its exit code,
+// so it is raised here, outside the parse guard, and never returned as a reply.
+export const claudeResultText = (stdout, { credentials = [] } = {}) => {
+  const text = String(stdout || '');
+  const events = text.split('\n').map(parseEvent);
+  if (!events.some(Boolean)) return text.trim();
+  for (let i = events.length - 1; i >= 0; i -= 1) {
+    if (events[i]?.type !== 'result') continue;
+    const reply = String(events[i].result ?? '').trim();
+    if (events[i].is_error === true) throw adapterFailure('claude', reply, { credentials });
+    return reply;
+  }
+  return events
+    .filter((event) => event?.type === 'assistant')
+    .flatMap((event) => event.message?.content || [])
+    .filter((block) => block?.type === 'text')
+    .map((block) => block.text)
+    .join('')
+    .trim();
+};
+
+// The failure tail for a non-zero exit. Stream events are mostly system init
+// and status lines, which would push the terminal error past the 2000-char cut,
+// so keep the result text, or the lines that are not system or stream events.
+export const claudeFailureTail = (stdout) => {
+  const text = String(stdout || '');
+  const lines = text.split('\n');
+  const events = lines.map(parseEvent);
+  if (!events.some(Boolean)) return text.trim();
+  const result = [...events].reverse().find((event) => event?.type === 'result');
+  if (String(result?.result ?? '').trim()) return String(result.result).trim();
+  return lines
+    .filter((_, i) => !['system', 'stream_event'].includes(events[i]?.type))
+    .join('\n')
+    .trim();
+};
+
 const runClaude = ({
   cmd, args, cwd, env, timeoutMs, credentials = [], spawnImpl = childSpawn, onSpawn, controls = {}, ownGroup = false,
   transcriptPath = null, firstOutputMs = firstOutputWindowMs(), lockProbe, stallKillGraceMs = STALL_KILL_GRACE_MS,
-  processTable = readProcessTable, survivorIo,
+  processTable = readProcessTable, survivorIo, modelStream = true,
 }) => new Promise((resolve, reject) => {
   const proc = spawnInOwnGroup(spawnImpl, cmd, args, {
     cwd,
@@ -529,6 +584,7 @@ const runClaude = ({
     proc,
     windowMs: firstOutputMs,
     transcriptPath,
+    modelStream,
     lockProbe,
     onStall: (reason) => {
       stalled = spawnStalledError({ label: 'claude', windowMs: firstOutputMs, reason });
@@ -584,7 +640,7 @@ const runClaude = ({
       // reduced to one named field. The status, when the tail names one, is
       // attached as `error.status` so a refusal classifies by field rather than
       // by regex.
-      const detail = [stderr.trim(), stdout.trim()].filter(Boolean).join(' | ');
+      const detail = [stderr.trim(), claudeFailureTail(stdout)].filter(Boolean).join(' | ');
       return reject(adapterFailure('claude', detail, {
         credentials,
         exitCode: code,
@@ -1161,7 +1217,7 @@ export default {
       ...(seatModel ? ['--model', seatModel] : []),
       ...(ctx.environment?.effort ? ['--effort', String(ctx.environment.effort)] : []),
     ];
-    const baseArgs = ['-p', fullPrompt, '--output-format', 'text', sessionFlag, sessionId, ...modelArgs];
+    const baseArgs = ['-p', fullPrompt, ...STREAM_ARGS, sessionFlag, sessionId, ...modelArgs];
 
     let mountedSkills = [];
     let skillMount = { mounted: [], conflicted: [] };
@@ -1274,7 +1330,7 @@ export default {
       const contextTokens = claudeContextTokens({
         cwd: physicalPath(ctx.cwd), sessionId, configDir: claudeConfigDirFor({ ...env, HOME: childHome || env?.HOME }),
       });
-      return { text: stdout.trim(), newSessionId: sessionId, contextTokens };
+      return { text: claudeResultText(stdout, { credentials: spawnCredentials(spawnCtx) }), newSessionId: sessionId, contextTokens };
     } catch (err) {
       // A public seat's refusal is not a session-store failure, whatever its
       // message happens to contain: it must reach the run loop, never the
@@ -1295,7 +1351,7 @@ export default {
           memoryWithheld: ctx.memoryWithheld === true,
         });
         const retryBase = ['-p', freshPrompt,
-        '--output-format', 'text', '--session-id', freshId, ...modelArgs];
+        ...STREAM_ARGS, '--session-id', freshId, ...modelArgs];
         const retryCtx = {
           ...ctx,
           mcpConfigPath: mcpConfig?.file || null,
@@ -1337,7 +1393,7 @@ export default {
           cwd: physicalPath(ctx.cwd), sessionId: freshId,
           configDir: claudeConfigDirFor({ ...retry.env, HOME: retry.childHome || retry.env?.HOME }),
         });
-        return { text: stdout.trim(), newSessionId: freshId, contextTokens };
+        return { text: claudeResultText(stdout, { credentials: spawnCredentials(retryCtx) }), newSessionId: freshId, contextTokens };
       }
       throw err;
     } finally {

package/src/lib/first-output-watchdog.js

@@ -16,6 +16,9 @@
  * A spawn that does neither inside the window is killed with a reason. When
  * the transcript is missing altogether, the path may simply be wrong, so the
  * spawn is killed only if the console is also locked.
+ *
+ * That is the rule for a plain-text spawn. A stream-json spawn (TASK-710) counts
+ * only model events on stdout; see `modelStream` on watchFirstOutput.
  */
 import { realpathSync, statSync } from 'fs';
 import { readProcess } from '@commonlyai/seats/process-group';
@@ -99,15 +102,35 @@ const sizeOf = (file) => {
   }
 };
 
+// A stream-json line is model progress when it is an event other than `system`.
+// The `system` events are `init` (written before any model call) and
+// `api_retry` (a provider failing and retrying). Counting either would keep a
+// hung provider looking alive until the run timeout.
+export const isModelProgressLine = (line) => {
+  try {
+    const event = JSON.parse(line);
+    return !!event && typeof event === 'object' && event.type !== 'system';
+  } catch {
+    return false;
+  }
+};
+
 /**
  * Watch `proc` for its first sign of life. Returns `{ stop }`; call it when the
  * process closes. `onStall(reason)` fires at most once, after the caller should
  * kill the process.
+ *
+ * With `modelStream`, the spawn writes stream-json events. Only model output
+ * counts as life there. A transcript row does not, because claude writes its
+ * first row about a second after spawn, before any model reply. Stderr does
+ * not either: claude prints warnings at spawn (an unrecognised model, a
+ * connector notice) whatever the provider does next.
  */
 export const watchFirstOutput = ({
   proc,
   windowMs,
   transcriptPath = null,
+  modelStream = false,
   onStall,
   lockProbe = consoleLocked,
   setTimeoutImpl = setTimeout,
@@ -116,16 +139,32 @@ export const watchFirstOutput = ({
   if (!windowMs) return { stop: () => {} };
   let started = false;
   let stopped = false;
+  let partial = '';
   const markStarted = () => { started = true; };
-  proc.stdout?.on('data', markStarted);
-  proc.stderr?.on('data', markStarted);
+  if (modelStream) {
+    proc.stdout?.on('data', (chunk) => {
+      const lines = (partial + chunk.toString()).split('\n');
+      partial = lines.pop();
+      if (lines.some(isModelProgressLine)) markStarted();
+    });
+  } else {
+    proc.stdout?.on('data', markStarted);
+    proc.stderr?.on('data', markStarted);
+  }
   // A missing file counts as empty, so creating an empty one is not growth.
   const baseline = Math.max(0, sizeOf(transcriptPath));
   const timer = setTimeoutImpl(async () => {
     const size = sizeOf(transcriptPath);
-    if (started || size > baseline) return;
+    if (started || (!modelStream && size > baseline)) return;
     const locked = await lockProbe().catch(() => null);
-    if (stopped) return;
+    // Output can arrive while the probe runs (ps or ioreg may take a second).
+    if (stopped || started) return;
+    if (modelStream) {
+      // The model signal does not read the transcript, so a missing path cannot
+      // hide a hung provider here.
+      onStall(locked ? 'console locked' : 'stuck: no model output inside the window');
+      return;
+    }
     // No transcript where one was expected may only mean the path is wrong, so
     // that alone never kills a turn: it takes a locked console as well.
     if (size < 0 && locked !== true) return;