@linzumi/cli 0.0.89-beta → 0.0.90-beta

package/README.md

@@ -58,7 +58,7 @@ Install the CLI or run it with `npx`:
 ```bash
 npm install -g @linzumi/cli@latest
 npx -y @linzumi/cli@latest signup
-npx -y @linzumi/cli@0.0.89-beta --version
+npx -y @linzumi/cli@0.0.90-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -5338,6 +5338,43 @@ var init_itemProjection = __esm({
 function rowStreamStateIsTerminal(state) {
   return state !== void 0 && terminalRowStreamStates.has(state);
 }
+function codexProtocolFailureReasonFromItems(items) {
+  for (const value of items) {
+    const reason = codexProtocolFailureReasonFromItem(objectValue(value));
+    if (reason !== void 0) {
+      return reason;
+    }
+  }
+  return void 0;
+}
+function codexProtocolFailureReasonFromItem(item) {
+  if (item === void 0) {
+    return void 0;
+  }
+  const explicitReason = stringValue(item.codex_protocol_failure_reason) ?? stringValue(item.protocolFailureReason);
+  if (explicitReason !== void 0) {
+    return explicitReason;
+  }
+  const itemType = stringValue(item.type);
+  if (itemType !== "function_call_output" && itemType !== "custom_tool_call_output") {
+    return void 0;
+  }
+  const output = stringValue(item.output) ?? stringValue(item.result) ?? stringValue(item.text) ?? stringValue(item.content);
+  const unsupportedCall = unsupportedCodexCallName(output);
+  return unsupportedCall === void 0 ? void 0 : `${unsupportedCodexToolCallReasonPrefix}: ${unsupportedCall}`;
+}
+function unsupportedCodexCallName(output) {
+  const prefix = "unsupported call:";
+  if (output === void 0) {
+    return void 0;
+  }
+  const normalized = output.trim();
+  if (!normalized.toLowerCase().startsWith(prefix)) {
+    return void 0;
+  }
+  const callName = normalized.slice(prefix.length).trim();
+  return callName === "" ? "unknown" : callName;
+}
 function createInitialLoopState() {
   return {
     phase: "running",
@@ -5482,6 +5519,7 @@ function createTurn(state, turnId, sourceSeq) {
     turnId,
     sourceSeq,
     phase: "active",
+    protocolFailureReason: void 0,
     items: []
   };
   state.turns.set(turnId, turn);
@@ -5588,6 +5626,10 @@ function handleDelta(turn, signal, deps, effects) {
   emitRowUpdate(turn, item, deltaIndex, streamState, deps, effects);
 }
 function handleItemCompleted(turn, params, deps, effects) {
+  const completedItem = objectValue(params.item);
+  if (completedItem !== void 0) {
+    turn.protocolFailureReason ??= codexProtocolFailureReasonFromItem(completedItem);
+  }
   const completed = completedItemForNotification(params);
   if (completed === void 0) {
     return;
@@ -5757,6 +5799,7 @@ function handleSnapshot(state, turnId, snapshot, deps, effects) {
     return;
   }
   const rawItems = Array.isArray(snapshot.items) ? snapshot.items : [];
+  turn.protocolFailureReason ??= codexProtocolFailureReasonFromItems(rawItems);
   const projected = projectSnapshotItems(rawItems);
   const consumedItemKeys = /* @__PURE__ */ new Set();
   const matches = /* @__PURE__ */ new Map();
@@ -5862,6 +5905,17 @@ function handleSnapshot(state, turnId, snapshot, deps, effects) {
   const assistantResponseSeen = turn.items.some(
     (item) => item.identity.streamKind === "assistant" && item.posted
   ) || projected.some((proj) => proj.streamKind === "assistant");
+  const terminalFailureReason = turn.protocolFailureReason ?? (assistantResponseSeen ? void 0 : completedWithoutAssistantOutputReason);
+  if (turn.protocolFailureReason !== void 0) {
+    effects.push(
+      log("codex.turn_completed_with_protocol_failure", {
+        thread_key: deps.threadKey,
+        turn_id: turn.turnId,
+        source_seq: turn.sourceSeq,
+        reason: turn.protocolFailureReason
+      })
+    );
+  }
   if (!assistantResponseSeen) {
     effects.push(
       log("codex.turn_completed_without_assistant_output", {
@@ -5880,19 +5934,19 @@ function handleSnapshot(state, turnId, snapshot, deps, effects) {
       thread_key: deps.threadKey,
       turn_id: turn.turnId,
       seq: turn.sourceSeq,
-      ...assistantResponseSeen ? { status: "processed" } : {
+      ...terminalFailureReason === void 0 ? { status: "processed" } : {
         status: "failed",
-        reason: completedWithoutAssistantOutputReason
+        reason: terminalFailureReason
       }
     },
     resolution: "must_ack"
   });
   effects.push(
-    assistantResponseSeen ? { type: "turnTerminal", turnId: turn.turnId, outcome: "completed" } : {
+    terminalFailureReason === void 0 ? { type: "turnTerminal", turnId: turn.turnId, outcome: "completed" } : {
       type: "turnTerminal",
       turnId: turn.turnId,
       outcome: "failed",
-      reason: completedWithoutAssistantOutputReason
+      reason: terminalFailureReason
     }
   );
   state.turns.delete(turn.turnId);
@@ -5973,7 +6027,7 @@ function failureReason(params) {
 function log(event, fields) {
   return { type: "log", event, fields };
 }
-var terminalRowStreamStates, turnMappingReadyMethod, turnMappingFailedMethod, maxTerminalTurnIds, completedWithoutAssistantOutputReason, turnTerminalFailureMethods, handledNotificationMethods;
+var terminalRowStreamStates, turnMappingReadyMethod, turnMappingFailedMethod, maxTerminalTurnIds, completedWithoutAssistantOutputReason, unsupportedCodexToolCallReasonPrefix, turnTerminalFailureMethods, handledNotificationMethods;
 var init_transition = __esm({
   "src/pipeline/transition.ts"() {
     "use strict";
@@ -5989,6 +6043,7 @@ var init_transition = __esm({
     turnMappingFailedMethod = "pipeline/turnMappingFailed";
     maxTerminalTurnIds = 512;
     completedWithoutAssistantOutputReason = "Codex completed without producing a response.";
+    unsupportedCodexToolCallReasonPrefix = "Codex emitted unsupported tool call";
     turnTerminalFailureMethods = /* @__PURE__ */ new Map([
       ["turn/failed", "failed"],
       ["turn/aborted", "interrupted"],
@@ -6543,17 +6598,22 @@ function rawItemFromToolCallMessage(message) {
   const structured = message.structured;
   const itemId = /^item-\d+$/.test(message.itemKey) ? void 0 : message.itemKey;
   const idField = itemId === void 0 ? {} : { id: itemId };
+  const output = typeof structured.output === "string" ? structured.output : "";
   switch (stringValue(structured.kind)) {
-    case "codex_command_execution":
+    case "codex_command_execution": {
+      const protocolFailureReason = unsupportedToolCallReason(output);
+      const protocolFailureField = protocolFailureReason === void 0 ? {} : { codex_protocol_failure_reason: protocolFailureReason };
       return {
         type: "commandExecution",
         ...idField,
+        ...protocolFailureField,
         command: stringValue(structured.command) ?? "command",
         cwd: stringValue(structured.cwd) ?? "",
         status: stringValue(structured.status) ?? "",
         ...stringValue(structured.process_id) === void 0 || stringValue(structured.process_id) === "" ? {} : { processId: stringValue(structured.process_id) },
-        aggregatedOutput: typeof structured.output === "string" ? structured.output : ""
+        aggregatedOutput: output
       };
+    }
     case "codex_file_change":
       return {
         type: "fileChange",
@@ -6566,6 +6626,15 @@ function rawItemFromToolCallMessage(message) {
       return void 0;
   }
 }
+function unsupportedToolCallReason(output) {
+  const prefix = "unsupported call:";
+  const normalized = output.trim();
+  if (!normalized.toLowerCase().startsWith(prefix)) {
+    return void 0;
+  }
+  const callName = normalized.slice(prefix.length).trim();
+  return `Codex emitted unsupported tool call: ${callName === "" ? "unknown" : callName}`;
+}
 function mergeSnapshotItems(readItems, sessionItems) {
   if (sessionItems.length === 0) {
     return [...readItems];
@@ -11599,6 +11668,23 @@ var init_channelSession = __esm({
 // src/claudeCodePipeline.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
+function claudeIncompleteProgressCompletionReason(body, bodySource) {
+  if (bodySource !== "assistant_aggregate") {
+    return void 0;
+  }
+  const normalized = body.trim().replace(/\s+/g, " ").toLowerCase();
+  if (normalized === "") {
+    return void 0;
+  }
+  const continuationPatterns = [
+    /\blet me\b.*\bbefore\b.*\b(writing|implementing|editing|patching|making|changing|coding|updating)\b/u,
+    /\blet me\b.*\b(check|inspect|confirm|look|verify|investigate|find|review)\b/u,
+    /\bi(?:'|\u2019)ll\b.*\b(check|inspect|confirm|look|verify|investigate|find|review|write|implement|update|edit|patch|run)\b/u,
+    /\bi will\b.*\b(check|inspect|confirm|look|verify|investigate|find|review|write|implement|update|edit|patch|run)\b/u,
+    /\bnext\b.*\b(i(?:'|\u2019)ll|i will|let me)\b/u
+  ];
+  return continuationPatterns.some((pattern) => pattern.test(normalized)) ? incompleteProgressCompletionReason : void 0;
+}
 function createClaudeCodeSessionPipeline(host) {
   const sourceSeqByTurn = /* @__PURE__ */ new Map();
   const snapshotsByTurn = /* @__PURE__ */ new Map();
@@ -11728,6 +11814,10 @@ function createClaudeCodeSessionPipeline(host) {
     submit("turn/completed", { turnId: turn.turnId });
     activeTurn = void 0;
   };
+  const failTurn2 = (turn, reason) => {
+    submit("turn/failed", { turnId: turn.turnId, reason });
+    activeTurn = void 0;
+  };
   const handleToolResult = (turn, event) => {
     const pending = turn.pendingTools.get(event.itemKey);
     turn.pendingTools.delete(event.itemKey);
@@ -11945,6 +12035,19 @@ function createClaudeCodeSessionPipeline(host) {
         }
         const turn = ensureTurn();
         lastUsage = event.usage ?? lastUsage;
+        const incompleteProgressReason = claudeIncompleteProgressCompletionReason(
+          event.body,
+          event.bodySource
+        );
+        if (incompleteProgressReason !== void 0) {
+          host.log("claude_pipeline.incomplete_progress_completion", {
+            thread_key: host.threadKey,
+            turn_id: turn.turnId,
+            body_source: event.bodySource ?? "unspecified"
+          });
+          failTurn2(turn, incompleteProgressReason);
+          return;
+        }
         finishTurn(turn, event.body);
         return;
       }
@@ -11954,6 +12057,19 @@ function createClaudeCodeSessionPipeline(host) {
           return;
         }
         lastUsage = event.usage ?? lastUsage;
+        const incompleteProgressReason = claudeIncompleteProgressCompletionReason(
+          event.body,
+          event.bodySource
+        );
+        if (incompleteProgressReason !== void 0) {
+          host.log("claude_pipeline.incomplete_progress_completion", {
+            thread_key: host.threadKey,
+            turn_id: activeTurn.turnId,
+            body_source: event.bodySource ?? "unspecified"
+          });
+          failTurn2(activeTurn, incompleteProgressReason);
+          return;
+        }
         finishTurn(activeTurn, event.body);
         return;
       }
@@ -11966,11 +12082,7 @@ function createClaudeCodeSessionPipeline(host) {
           });
           return;
         }
-        submit("turn/failed", {
-          turnId: activeTurn.turnId,
-          reason: event.reason
-        });
-        activeTurn = void 0;
+        failTurn2(activeTurn, event.reason);
         return;
       }
     }
@@ -12182,12 +12294,13 @@ function claudeToolInputSummary(input) {
     return void 0;
   }
 }
-var maxRetainedSnapshots, todoStatusGlyphs;
+var incompleteProgressCompletionReason, maxRetainedSnapshots, todoStatusGlyphs;
 var init_claudeCodePipeline = __esm({
   "src/claudeCodePipeline.ts"() {
     "use strict";
     init_json();
     init_integration();
+    incompleteProgressCompletionReason = "Claude Code ended after an incomplete progress response instead of a final answer";
     maxRetainedSnapshots = 8;
     todoStatusGlyphs = {
       completed: "[x]",
@@ -13322,7 +13435,9 @@ async function startClaudeCodeSession(options) {
   return completeClaudeCodeSession(options, state);
 }
 async function emitClaudeCodeTurnCompleted(options, state) {
-  const body = state.resultText ?? nonEmptyText(claudeAssistantAggregateText(state)) ?? "";
+  const aggregateText = nonEmptyText(claudeAssistantAggregateText(state));
+  const body = state.resultText ?? aggregateText ?? "";
+  const bodySource = state.resultText !== void 0 ? "result" : aggregateText !== void 0 ? "assistant_aggregate" : "empty";
   if (state.sessionId === void 0) {
     return;
   }
@@ -13330,12 +13445,17 @@ async function emitClaudeCodeTurnCompleted(options, state) {
     type: "turn_completed",
     sessionId: state.sessionId,
     body,
+    bodySource,
     usage: state.usage
   });
 }
 async function completeClaudeCodeSession(options, state) {
-  const body = state.resultText ?? nonEmptyText(claudeAssistantAggregateText(state)) ?? state.lastCompletedTurnBody;
-  if (body === void 0) {
+  const aggregateText = nonEmptyText(claudeAssistantAggregateText(state));
+  const completion = state.resultText !== void 0 ? { body: state.resultText, bodySource: "result" } : aggregateText !== void 0 ? { body: aggregateText, bodySource: "assistant_aggregate" } : state.lastCompletedTurnBody !== void 0 ? {
+    body: state.lastCompletedTurnBody,
+    bodySource: "last_completed_turn"
+  } : void 0;
+  if (completion === void 0) {
     return await failClaudeCodeSession(
       options,
       state.sessionId,
@@ -13351,13 +13471,14 @@ async function completeClaudeCodeSession(options, state) {
   }
   const result = {
     sessionId: state.sessionId,
-    body,
+    body: completion.body,
     usage: state.usage
   };
   await options.onTranscriptEvent?.({
     type: "session_completed",
     sessionId: result.sessionId,
     body: result.body,
+    bodySource: completion.bodySource,
     usage: result.usage
   });
   return result;
@@ -18989,7 +19110,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.89-beta";
+    linzumiCliVersion = "0.0.90-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -27258,6 +27379,7 @@ async function startClaudeCodeProviderInstance(args) {
       args.log("claude_code.turn_completed", {
         linzumi_thread_id: threadId,
         claude_session_id: event.sessionId,
+        body_source: event.bodySource ?? null,
         body_preview: claudeConsoleBodyPreview(event.body)
       });
       settleFirstTurn();
@@ -27659,6 +27781,7 @@ function claudeSessionStoreEntryPayload(args, event) {
     case "session_completed":
       return {
         body: event.body,
+        bodySource: event.bodySource ?? null,
         usage: event.usage ?? null
       };
     case "turn_interrupted":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.89-beta",
+  "version": "0.0.90-beta",
   "description": "Linzumi CLI — point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {