@commonlyai/cli 0.1.187 → 0.1.189

package/package.json

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

package/src/commands/agent.js

@@ -2982,8 +2982,11 @@ export const performRun = ({
       // below reaches the SAME composite turn before it can age into the
       // requeue sweep. The service selects the pod before claiming any row;
       // do not reintroduce a mixed-pod `limit: 10` here.
+      // TASK-317: name this CLI for the chat chip. The server keeps it as a
+      // display-only label (runtime.reportedCli) and never as a binding.
       const { events = [], inboxCount } = await client.get('/api/agents/runtime/events', {
         agentName, instanceId, limit: batchLimit,
+        ...(adapter?.name ? { reportedCli: adapter.name } : {}),
       });
       consecutiveAuthErrors = 0;
       consecutivePollFailures = 0;

package/src/lib/adapters/opencode.js

@@ -301,12 +301,19 @@ const validateProviderEnvironment = async (environment, workspacePath) => {
   return resolveProviderKeyFile(environment.provider, workspacePath);
 };
 
+const STALE_SESSION_PATTERN = /session not found/i;
+// Set by runOpenCode only when the rejected run produced no turn output, so a
+// phrase that shows up after the model acted cannot replay the turn.
+const isStaleSessionError = (err) => err?.staleSession === true;
+
 const makeEventParser = () => {
   let buffer = '';
   let sessionId = null;
   let text = '';
   let usage = null;
   let errorMessage = null;
+  // Any text, tool call or step result means the model acted this run.
+  let turnOutput = false;
   // Every tool call that came back as an error, for the public-seat check in
   // spawn (publicToolFailure).
   const toolErrors = [];
@@ -315,11 +322,15 @@ const makeEventParser = () => {
     try {
       const event = JSON.parse(line);
       if (event.sessionID) sessionId = event.sessionID;
+      // Any step event means the run started a turn, so it is not safe to replay.
+      if (String(event.type || '').startsWith('step_') || event.type === 'tool_use') turnOutput = true;
       if (event.type === 'text' && typeof event.part?.text === 'string') {
+        turnOutput = true;
         text += event.part.text;
       } else if (event.type === 'step_finish' && event.part?.tokens) {
         usage = event.part.tokens;
-      } else if (event.type === 'tool_use' && event.part?.state?.status === 'error') {
+      }
+      if (event.type === 'tool_use' && event.part?.state?.status === 'error') {
         const { error } = event.part.state;
         toolErrors.push({
           tool: String(event.part.tool || ''),
@@ -334,6 +345,7 @@ const makeEventParser = () => {
     }
   };
   return {
+    get turnOutput() { return turnOutput; },
     consume(chunk) {
       buffer += chunk.toString();
       let newline;
@@ -428,14 +440,18 @@ const runOpenCode = ({ cmd, args, cwd, env, timeoutMs, credentials, spawnImpl =
     events.flush();
     if (timedOut) return reject(new Error(`opencode timed out after ${timeoutMs}ms`));
     if (events.errorMessage) {
-      return reject(adapterFailure('opencode turn failed', events.errorMessage, {
+      const err = adapterFailure('opencode turn failed', events.errorMessage, {
         credentials, limit: 2000,
-      }));
+      });
+      err.staleSession = !events.turnOutput && STALE_SESSION_PATTERN.test(events.errorMessage);
+      return reject(err);
     }
     if (code !== 0) {
-      return reject(adapterFailure('opencode', stderr.trim(), {
+      const err = adapterFailure('opencode', stderr.trim(), {
         credentials, exitCode: code, limit: 500,
-      }));
+      });
+      err.staleSession = !events.turnOutput && STALE_SESSION_PATTERN.test(stderr);
+      return reject(err);
     }
     resolve({
       sessionId: events.sessionId, text: events.text, usage: events.usage, toolErrors: events.toolErrors,
@@ -650,6 +666,18 @@ export default {
   },
 
   async spawn(prompt, rawCtx = {}) {
+    try {
+      return await this.spawnTurn(prompt, rawCtx);
+    } catch (err) {
+      if (!rawCtx.sessionId || !isStaleSessionError(err)) throw err;
+      // The saved id is one OpenCode does not know: a seat switched from another
+      // adapter carries a Claude id, and a pruned session fails the same way. Nothing
+      // ran, so one fresh turn is safe (pi #1726 does the same fallback).
+      return this.spawnTurn(prompt, { ...rawCtx, sessionId: null });
+    }
+  },
+
+  async spawnTurn(prompt, rawCtx = {}) {
     const seatModel = requireSeatModel(rawCtx.environment, 'opencode');
     const sandbox = normalizeSandboxTrust(rawCtx.environment?.sandbox);
     refuseWorkspaceTrust(sandbox, 'opencode');