@linzumi/cli 0.0.67-beta → 0.0.69-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.67-beta --version
+npx -y @linzumi/cli@0.0.69-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -286,6 +286,7 @@ var init_channelSessionSupport = __esm({
 
 // src/commanderAttachments.ts
 import { readFile, realpath, stat, writeFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
 import {
   basename,
   extname,
@@ -402,13 +403,14 @@ async function uploadedFileIdsForCommanderOutput(runtime, body, structured) {
     return [];
   }
   const cwdRealPath = await realpath(runtime.cwd);
+  const uploadRoots = await commanderAttachmentUploadRoots(cwdRealPath);
   const paths = await extractKandanAttachmentPaths(body, cwdRealPath);
   if (paths.length === 0) {
     return [];
   }
   const files = await Promise.all(
     paths.map(async (path2) => {
-      assertCommanderAttachmentUploadAllowed(cwdRealPath, path2);
+      assertCommanderAttachmentUploadAllowed(uploadRoots, path2);
       const info = await stat(path2);
       if (!info.isFile()) {
         throw new Error(`Kandan attachment path is not a file: ${path2}`);
@@ -556,13 +558,19 @@ async function extractKandanAttachmentPaths(body, cwdRealPath) {
   const paths = [];
   for (const line of lines.slice(headingIndex + 1)) {
     const trimmed = line.trim();
-    if (!trimmed.startsWith("- ")) {
-      if (trimmed !== "") {
-        break;
-      }
+    const rawPath = kandanAttachmentRawPath(trimmed);
+    if (rawPath === "") {
+      continue;
+    }
+    if (rawPath === void 0) {
+      break;
+    }
+    if (commanderAttachmentRawPathHasHiddenSegment(rawPath)) {
       continue;
     }
-    const rawPath = trimmed.slice(2).trim().replace(/^`|`$/g, "");
+    if (!isCommanderAttachmentUploadPathCandidate(rawPath)) {
+      break;
+    }
     const resolvedPath = await resolveCommanderAttachmentPath(
       cwdRealPath,
       rawPath
@@ -575,27 +583,34 @@ async function extractKandanAttachmentPaths(body, cwdRealPath) {
   }
   return paths;
 }
+function kandanAttachmentRawPath(trimmedLine) {
+  if (trimmedLine === "") {
+    return "";
+  }
+  const rawPath = trimmedLine.startsWith("- ") ? trimmedLine.slice(2).trim() : trimmedLine;
+  if (rawPath === "") {
+    return void 0;
+  }
+  return rawPath.replace(/^`|`$/g, "");
+}
 async function resolveCommanderAttachmentPath(cwdRealPath, rawPath) {
   if (rawPath === "") {
     throw new Error("Kandan attachment path must not be empty");
   }
   const candidatePath = isAbsolute(rawPath) ? resolve(rawPath) : resolve(cwdRealPath, rawPath);
-  const path2 = await realpath(candidatePath);
-  const relativePath = relative(cwdRealPath, path2);
-  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
-    throw new Error(
-      `Kandan attachment path must resolve inside the runner cwd: ${rawPath}`
-    );
-  }
-  return path2;
+  return await realpath(candidatePath);
 }
-function assertCommanderAttachmentUploadAllowed(cwdRealPath, filePath) {
-  const relativePath = relative(cwdRealPath, filePath);
-  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+function assertCommanderAttachmentUploadAllowed(uploadRoots, filePath) {
+  const matchedRoot = uploadRoots.find(
+    (root) => pathIsInsideRoot(root.path, filePath)
+  );
+  if (matchedRoot === void 0) {
+    const rootLabels = uploadRoots.map((root) => root.label).join(", ");
     throw new Error(
-      `Kandan attachment path must resolve inside the runner cwd: ${filePath}`
+      `Kandan attachment path must resolve inside an allowed upload root (${rootLabels}): ${filePath}`
     );
   }
+  const relativePath = relative(matchedRoot.path, filePath);
   const hiddenSegment = relativePath.split(/[\\/]+/).find((segment) => segment.startsWith("."));
   if (hiddenSegment !== void 0) {
     throw new Error(
@@ -609,6 +624,25 @@ function assertCommanderAttachmentUploadAllowed(cwdRealPath, filePath) {
     );
   }
 }
+async function commanderAttachmentUploadRoots(cwdRealPath) {
+  const roots = [
+    { path: cwdRealPath, label: "runner cwd" }
+  ];
+  const downloadsPath = resolve(homedir(), "Downloads");
+  try {
+    const downloadsRealPath = await realpath(downloadsPath);
+    if (!roots.some((root) => root.path === downloadsRealPath)) {
+      roots.push({ path: downloadsRealPath, label: "~/Downloads" });
+    }
+  } catch (_error) {
+    return roots;
+  }
+  return roots;
+}
+function pathIsInsideRoot(rootPath, filePath) {
+  const relativePath = relative(rootPath, filePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
 function contentTypeForFileName(fileName) {
   const lower = fileName.toLowerCase();
   if (lower.endsWith(".png")) {
@@ -634,6 +668,69 @@ function contentTypeForFileName(fileName) {
   }
   return "application/octet-stream";
 }
+function bodyWithoutKandanAttachmentFooter(body) {
+  const lines = body.split(/\r?\n/);
+  const headingIndex = lines.findIndex(
+    (line) => line.trim().toLowerCase() === "kandan attachments:"
+  );
+  if (headingIndex === -1) {
+    return body;
+  }
+  const visibleAfterLines = [];
+  let sawVisibleAfterLine = false;
+  for (const line of lines.slice(headingIndex + 1)) {
+    if (line.trim() === "") {
+      switch (sawVisibleAfterLine) {
+        case true:
+          visibleAfterLines.push(line);
+          break;
+        case false:
+          break;
+      }
+      continue;
+    }
+    if (isKandanAttachmentDisplayDirectiveLine(line)) {
+      continue;
+    }
+    visibleAfterLines.push(line);
+    sawVisibleAfterLine = true;
+  }
+  const visibleLines = [...lines.slice(0, headingIndex), ...visibleAfterLines];
+  while (visibleLines.length > 0 && visibleLines[visibleLines.length - 1]?.trim() === "") {
+    visibleLines.pop();
+  }
+  return visibleLines.join("\n");
+}
+function displayBodyForCommanderOutput(body, uploadedFileIds) {
+  const displayBody = bodyWithoutKandanAttachmentFooter(body);
+  switch (displayBody.trim() === "" && uploadedFileIds.length > 0) {
+    case true:
+      return "Attached file.";
+    case false:
+      return displayBody;
+  }
+}
+function structuredWithAssistantContent(structured, content) {
+  return stringValue(structured.kind) === "codex_assistant_message" ? { ...structured, content } : structured;
+}
+function isKandanAttachmentDisplayDirectiveLine(line) {
+  const rawPath = kandanAttachmentRawPath(line.trim());
+  if (rawPath === "") {
+    return true;
+  }
+  if (rawPath === void 0) {
+    return false;
+  }
+  return !commanderAttachmentRawPathHasHiddenSegment(rawPath) && commanderAttachmentUploadExtensions.has(extname(rawPath).toLowerCase());
+}
+function isCommanderAttachmentUploadPathCandidate(rawPath) {
+  return commanderAttachmentUploadExtensions.has(
+    extname(rawPath).toLowerCase()
+  );
+}
+function commanderAttachmentRawPathHasHiddenSegment(rawPath) {
+  return rawPath.split(/[\\/]+/).some((segment) => segment.startsWith("."));
+}
 async function pushOk(kandan, topic, event, payload) {
   const reply = await kandan.push(topic, event, payload);
   if (isJsonObject(reply) && reply.status === "ok" && isJsonObject(reply.response)) {
@@ -754,6 +851,7 @@ var init_codexRuntimeOptions = __esm({
 
 // src/codexOutput.ts
 import { Buffer as Buffer2 } from "node:buffer";
+import { fileURLToPath } from "node:url";
 function codexOutputMessagesForTurn(response, turnId) {
   if ("error" in response) {
     return [];
@@ -803,19 +901,10 @@ function codexOutputMessagesForItem(item, index) {
         }
       ];
     }
-    case "agentMessage": {
-      const text2 = assistantVisibleText(item);
-      return [
-        {
-          itemKey,
-          body: text2,
-          structured: baseStructured("codex_assistant_message", {
-            content: text2,
-            phase: stringValue(item.phase) ?? "final_answer"
-          })
-        }
-      ];
-    }
+    case "agentMessage":
+      return codexAssistantMessageForItem(item, itemKey, baseStructured);
+    case "message":
+      return stringValue(item.role) === "assistant" ? codexAssistantMessageForItem(item, itemKey, baseStructured) : [];
     case "commandExecution": {
       const command = stringValue(item.command) ?? "command";
       const output = nonBlankStringValue(item.aggregatedOutput) ?? "";
@@ -1121,7 +1210,26 @@ function codexUserInputMessageForItem(item, index) {
   const body = textParts.length > 0 ? textParts.join("\n\n") : nonBlankStringValue(item.text) ?? nonBlankStringValue(item.message) ?? "";
   return [{ itemKey, body }];
 }
+function codexAssistantMessageForItem(item, itemKey, baseStructured) {
+  const text2 = assistantVisibleText(item);
+  const attachmentPaths = assistantImageAttachmentPaths(item);
+  const body = assistantBodyWithAttachmentPaths(text2, attachmentPaths);
+  return [
+    {
+      itemKey,
+      body,
+      structured: baseStructured("codex_assistant_message", {
+        content: text2,
+        phase: stringValue(item.phase) ?? "final_answer"
+      })
+    }
+  ];
+}
 function assistantVisibleText(item) {
+  const contentText = assistantContentText(item);
+  if (contentText !== "") {
+    return contentText;
+  }
   const direct = stringValue(item.reply) ?? stringValue(item.summary) ?? stringValue(item.content) ?? stringValue(item.text) ?? "";
   const parsed = parseJsonObjectOrUndefined(direct);
   if (parsed === void 0) {
@@ -1129,6 +1237,52 @@ function assistantVisibleText(item) {
   }
   return stringValue(parsed.reply) ?? stringValue(parsed.summary) ?? stringValue(parsed.content) ?? stringValue(parsed.message) ?? stringValue(parsed.output_text) ?? direct;
 }
+function assistantContentText(item) {
+  return (arrayValue(item.content) ?? []).filter(isJsonObject).flatMap((part) => {
+    const type = stringValue(part.type);
+    if (type !== "text" && type !== "output_text" && type !== "input_text") {
+      return [];
+    }
+    const text2 = nonBlankStringValue(part.text) ?? nonBlankStringValue(part.content) ?? nonBlankStringValue(part.output_text);
+    return text2 === void 0 ? [] : [text2];
+  }).join("\n\n");
+}
+function assistantBodyWithAttachmentPaths(text2, attachmentPaths) {
+  const uniqueAttachmentPaths = [...new Set(attachmentPaths)];
+  if (uniqueAttachmentPaths.length === 0) {
+    return text2;
+  }
+  const attachmentFooter = [
+    "Kandan attachments:",
+    ...uniqueAttachmentPaths.map((path2) => `- ${path2}`)
+  ].join("\n");
+  const normalizedText = text2.trim();
+  return normalizedText === "" ? attachmentFooter : [text2, "", attachmentFooter].join("\n");
+}
+function assistantImageAttachmentPaths(item) {
+  return (arrayValue(item.content) ?? []).filter(isJsonObject).flatMap((part) => {
+    const type = stringValue(part.type)?.toLowerCase();
+    if (type !== "image" && type !== "output_image" && type !== "input_image") {
+      return [];
+    }
+    const rawPath = stringValue(part.path) ?? stringValue(part.file_path) ?? stringValue(part.filePath) ?? stringValue(part.image_url) ?? stringValue(part.imageUrl) ?? stringValue(part.url);
+    const localPath = rawPath === void 0 ? void 0 : localAttachmentPath(rawPath);
+    return localPath === void 0 ? [] : [localPath];
+  });
+}
+function localAttachmentPath(rawPath) {
+  if (/^https?:\/\//i.test(rawPath) || /^data:/i.test(rawPath)) {
+    return void 0;
+  }
+  if (/^file:\/\//i.test(rawPath)) {
+    try {
+      return fileURLToPath(rawPath);
+    } catch (_error) {
+      return void 0;
+    }
+  }
+  return rawPath;
+}
 function assistantDeltaText(params) {
   return textDeltaFromParams(params);
 }
@@ -3292,23 +3446,25 @@ async function attachChannelSession(args) {
               });
             }
             break;
-          case "turn/completed":
-            if (turnId !== void 0) {
-              enqueueWebSearchProgressCompletion(args, state, turnId);
-              enqueueFileChangeCompletion(args, state, turnId);
+          case "turn/completed": {
+            const completedTurnId = turnId ?? inferThreadOnlyCompletedTurnId(args, state, threadId);
+            if (completedTurnId !== void 0) {
+              enqueueWebSearchProgressCompletion(args, state, completedTurnId);
+              enqueueFileChangeCompletion(args, state, completedTurnId);
               void forwardCompletedCodexTurn(
                 args,
                 state,
-                turnId,
+                completedTurnId,
                 payloadContext
               ).catch((error) => {
                 args.log("codex.turn_forward_failed", {
-                  turn_id: turnId,
+                  turn_id: completedTurnId,
                   message: error instanceof Error ? error.message : String(error)
                 });
               });
             }
             break;
+          }
           case "item/agentMessage/delta":
             enqueueAssistantDelta(args, state, params, payloadContext);
             break;
@@ -3331,6 +3487,32 @@ async function attachChannelSession(args) {
           case "item/completed":
             enqueueWebSearchProgress(args, state, params, payloadContext);
             enqueueCompletedFileChange(args, state, params, payloadContext);
+            const completedAssistantItemForward = forwardCompletedAssistantItem(
+              args,
+              state,
+              params,
+              payloadContext
+            );
+            if (turnId !== void 0) {
+              rememberPendingCompletedAssistantItemForward(
+                state,
+                turnId,
+                completedAssistantItemForward
+              );
+            }
+            void completedAssistantItemForward.catch((error) => {
+              args.log("codex.completed_assistant_item_forward_failed", {
+                message: error instanceof Error ? error.message : String(error)
+              });
+            }).finally(() => {
+              if (turnId !== void 0) {
+                forgetPendingCompletedAssistantItemForward(
+                  state,
+                  turnId,
+                  completedAssistantItemForward
+                );
+              }
+            });
             if (turnId !== void 0) {
               const promise = mirrorLocalTuiInputFromNotification(
                 args,
@@ -3424,6 +3606,8 @@ function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThread
     forwardedTurnIds: /* @__PURE__ */ new Set(),
     forwardingTurnIds: /* @__PURE__ */ new Set(),
     retryableTurnIds: /* @__PURE__ */ new Set(),
+    completedAssistantItemKeys: /* @__PURE__ */ new Set(),
+    pendingCompletedAssistantItemForwards: /* @__PURE__ */ new Map(),
     claimedKandanMessageKeys: /* @__PURE__ */ new Set(),
     localTuiTurnIds: /* @__PURE__ */ new Set(),
     mirroredTuiInputProjections: createBoundedCache(maxForwardedTurnIds),
@@ -4695,7 +4879,16 @@ async function processKandanChatEvent(args, state, runnerIdentity, event, payloa
   }
 }
 async function drainKandanMessageQueue(args, state, payloadContext) {
-  if (state.closed || state.turn.status !== "idle" || localTuiTurnIsActive(state)) {
+  if (state.closed) {
+    logQueuedDrainBlocked(args, state, "session_closed");
+    return;
+  }
+  if (state.turn.status !== "idle") {
+    logQueuedDrainBlocked(args, state, "turn_not_idle");
+    return;
+  }
+  if (localTuiTurnIsActive(state)) {
+    logQueuedDrainBlocked(args, state, "local_tui_turn_active");
     return;
   }
   const resumed = await tryResumeCodexThreadForPendingRuntimeSettings(
@@ -4703,6 +4896,7 @@ async function drainKandanMessageQueue(args, state, payloadContext) {
     state
   );
   if (!resumed) {
+    logQueuedDrainBlocked(args, state, "runtime_settings_resume_pending");
     return;
   }
   const next = dequeuePendingKandanMessage(state.queue);
@@ -4823,6 +5017,22 @@ async function drainKandanMessageQueue(args, state, payloadContext) {
     });
   }
 }
+function logQueuedDrainBlocked(args, state, reason) {
+  const queueDepth = pendingKandanMessageQueueLength(state.queue);
+  if (queueDepth === 0) {
+    return;
+  }
+  args.log("kandan.queue_drain_blocked", {
+    reason,
+    queue_depth: queueDepth,
+    turn_status: state.turn.status,
+    active_turn_id: activeTurnId(state.turn) ?? null,
+    active_queued_seq: state.turn.status === "active" || state.turn.status === "completing" ? state.turn.queuedSeq : state.turn.status === "starting" ? state.turn.queuedSeq : null,
+    codex_thread_id: state.codexThreadId ?? null,
+    kandan_thread_id: state.kandanThreadId ?? null,
+    local_tui_turn_count: state.localTuiTurnIds.size
+  });
+}
 async function fetchReconnectContextInjection(args, state) {
   if (state.kandanThreadId === void 0) {
     throw new Error(
@@ -4986,6 +5196,7 @@ async function forwardCompletedCodexTurn(args, state, turnId, payloadContext) {
     };
   }
   await waitForPendingTuiInputMirror(state, turnId);
+  await waitForPendingCompletedAssistantItemForwards(state, turnId);
   await waitForStreamingForwardChains(args, state, payloadContext);
   rememberForwardingTurnId(state, turnId);
   forgetRetryableTurnId(state, turnId);
@@ -5096,9 +5307,17 @@ async function forwardCompletedCodexTurn(args, state, turnId, payloadContext) {
   }
 }
 function completedOutputProjectionsForTurn(state, turnId, messages) {
-  const snapshotOutputs = messages.flatMap(
-    (message, snapshotIndex) => completedSnapshotOutputProjection(state, turnId, message, snapshotIndex)
-  );
+  const snapshotOutputs = messages.flatMap((message, snapshotIndex) => {
+    if (completedAssistantItemForwarded(state, message.itemKey)) {
+      return [];
+    }
+    return completedSnapshotOutputProjection(
+      state,
+      turnId,
+      message,
+      snapshotIndex
+    );
+  });
   const matchedStructuredKeys = new Set(
     snapshotOutputs.flatMap((output) => {
       switch (output.match.kind) {
@@ -5367,7 +5586,101 @@ function logCompletedCodexOutput(args, turnId, message) {
     file_paths: fileChangePaths(message.structured)
   });
 }
+async function forwardCompletedAssistantItem(args, state, params, payloadContext) {
+  if (state.kandanThreadId === void 0 || state.codexThreadId === void 0) {
+    return;
+  }
+  const turnId = stringValue(params.turnId) ?? stringValue(params.turn_id) ?? stringValue(objectValue(params.turn)?.id);
+  const item = objectValue(params.item) ?? params;
+  const completedItemKey = stringValue(params.itemId) ?? stringValue(params.item_id) ?? stringValue(objectValue(params.item)?.id);
+  if (turnId !== void 0) {
+    await waitForPendingTuiInputMirror(state, turnId);
+    await waitForStreamingForwardChains(args, state, payloadContext);
+  }
+  const parsedMessage = codexOutputMessagesForItem(item, 0).find(
+    (candidate) => stringValue(candidate.structured.kind) === "codex_assistant_message"
+  );
+  const fallbackStream = parsedMessage === void 0 ? resolveStreamingAssistantOutputForCompletedSignal(
+    state,
+    turnId,
+    completedItemKey
+  ) : { status: "none" };
+  if (fallbackStream.status === "ambiguous") {
+    throw new LogicalProjectionError(
+      `Cannot reconcile completed assistant item signal from item notification; ${fallbackStream.candidateCount} active streamed assistant outputs exist`
+    );
+  }
+  const message = parsedMessage ?? (fallbackStream.status === "matched" ? {
+    itemKey: fallbackStream.output.itemKey,
+    body: fallbackStream.output.content,
+    structured: codexAssistantStructuredMessage(
+      fallbackStream.output.itemKey,
+      fallbackStream.output.content,
+      "completed"
+    )
+  } : void 0);
+  const messageTurnId = turnId ?? (fallbackStream.status === "matched" ? fallbackStream.output.turnId : void 0);
+  if (message === void 0 || completedAssistantItemForwarded(state, message.itemKey)) {
+    return;
+  }
+  const sourceMessageSeq = messageTurnId === void 0 ? void 0 : sourceMessageSeqForTurn(state, messageTurnId);
+  if (messageTurnId !== void 0 && sourceMessageSeq === void 0) {
+    args.log("codex.completed_assistant_item_without_source_message", {
+      turn_id: messageTurnId,
+      item_key: message.itemKey
+    });
+    return;
+  }
+  const structured = codexAssistantStructuredMessage(
+    message.itemKey,
+    message.body,
+    "completed"
+  );
+  const streamed = resolveStreamingAssistantOutputForCompletedMessage(
+    state,
+    messageTurnId ?? `item:${message.itemKey}`,
+    message.itemKey,
+    message.body,
+    structured
+  );
+  switch (streamed.status) {
+    case "none":
+      await streamCompletedCodexOutput(args, state, payloadContext, {
+        turnId: turnId ?? `item:${message.itemKey}`,
+        sourceMessageSeq,
+        rootSeq: state.rootSeq,
+        message: {
+          ...message,
+          structured
+        }
+      });
+      break;
+    case "matched":
+      await editStreamedCodexOutput(
+        args,
+        state,
+        streamed.output.seq,
+        message.itemKey,
+        message.body,
+        "completed"
+      );
+      forgetStreamingAssistantOutput(state, streamed.output.itemKey);
+      break;
+    case "ambiguous":
+      throw new LogicalProjectionError(
+        `Cannot reconcile completed assistant item ${message.itemKey} from item notification; ${streamed.candidateCount} active streamed assistant outputs exist`
+      );
+  }
+  rememberCompletedAssistantItemKey(state, message.itemKey);
+  logCompletedCodexOutput(args, messageTurnId ?? `item:${message.itemKey}`, {
+    ...message,
+    structured
+  });
+}
 function compareCompletedOutputProjection(left, right) {
+  if (left.kind === "snapshot" && right.kind === "snapshot" && left.match.kind !== right.match.kind && (left.match.kind === "none" || right.match.kind === "none")) {
+    return left.snapshotIndex - right.snapshotIndex;
+  }
   return left.sortOrder === right.sortOrder ? left.snapshotIndex - right.snapshotIndex : left.sortOrder - right.sortOrder;
 }
 function fallbackSnapshotOutputBase(sortOrders) {
@@ -6240,12 +6553,20 @@ async function streamCompletedCodexOutput(args, state, payloadContext, params) {
     params.message.body,
     structured
   );
+  const displayBody = displayBodyForCommanderOutput(
+    params.message.body,
+    uploadedFileIds
+  );
+  const displayStructured = structuredWithAssistantContent(
+    structured,
+    displayBody
+  );
   await pushOk2(args.kandan, args.topic, "session:stream_thread_message", {
     workspace: session.workspaceSlug,
     channel: session.channelSlug,
     thread_id: state.kandanThreadId,
     stream_key: streamKey,
-    body: params.message.body,
+    body: displayBody,
     payload: {
       ...localRunnerPayload(
         args.options,
@@ -6259,7 +6580,7 @@ async function streamCompletedCodexOutput(args, state, payloadContext, params) {
       ...params.rootSeq === void 0 ? {} : { reply_to_seq: params.rootSeq },
       ...params.sourceMessageSeq === void 0 ? {} : { source_message_seq: params.sourceMessageSeq },
       ...streamMetadata,
-      structured
+      structured: displayStructured
     },
     ...uploadedFileIds.length === 0 ? {} : { uploaded_file_ids: uploadedFileIds },
     client_message_id: streamKey
@@ -6282,13 +6603,36 @@ async function editCodexStructuredOutput(args, state, targetSeq, content, struct
     return;
   }
   const session = args.options.channelSession;
+  const uploadedFileIds = stringValue(structured.stream_state) === "completed" ? await uploadedFileIdsForCommanderOutput(
+    {
+      kandan: args.kandan,
+      topic: args.topic,
+      workspace: session.workspaceSlug,
+      channel: session.channelSlug,
+      cwd: args.options.cwd,
+      kandanUrl: args.options.kandanUrl,
+      token: args.options.token,
+      fetch: args.options.fetch
+    },
+    content,
+    structured
+  ) : [];
+  const displayContent = displayBodyForCommanderOutput(
+    content,
+    uploadedFileIds
+  );
+  const displayStructured = structuredWithAssistantContent(
+    structured,
+    displayContent
+  );
   await pushOk2(args.kandan, args.topic, "session:edit_thread_message", {
     workspace: session.workspaceSlug,
     channel: session.channelSlug,
     thread_id: state.kandanThreadId,
     target_seq: targetSeq,
-    body: content,
-    structured
+    body: displayContent,
+    structured: displayStructured,
+    ...uploadedFileIds.length === 0 ? {} : { uploaded_file_ids: uploadedFileIds }
   });
 }
 async function mirrorLocalTuiInputFromNotification(args, state, turnId, params, payloadContext) {
@@ -6464,6 +6808,30 @@ function resolveStreamingAssistantOutputForCompletedMessage(state, turnId, itemK
     }
   }
 }
+function resolveStreamingAssistantOutputForCompletedSignal(state, turnId, itemKey) {
+  if (itemKey !== void 0) {
+    const exact = findStreamingAssistantOutput(state, itemKey);
+    if (exact !== void 0) {
+      return { status: "matched", output: exact };
+    }
+  }
+  if (turnId === void 0) {
+    return { status: "none" };
+  }
+  const candidates = boundedCacheValues(state.streamingAssistantOutputs).filter(
+    (output) => output.turnId === turnId
+  );
+  switch (candidates.length) {
+    case 0:
+      return { status: "none" };
+    case 1: {
+      const [output] = candidates;
+      return output === void 0 ? { status: "none" } : { status: "matched", output };
+    }
+    default:
+      return { status: "ambiguous", candidateCount: candidates.length };
+  }
+}
 function normalizedTranscriptText(value) {
   return value.trim().replace(/\s+/g, " ");
 }
@@ -6480,6 +6848,16 @@ function rememberStreamingAssistantOutput(state, output) {
 function forgetStreamingAssistantOutput(state, itemKey) {
   forgetBoundedCacheValue(state.streamingAssistantOutputs, itemKey);
 }
+function completedAssistantItemForwarded(state, itemKey) {
+  return state.completedAssistantItemKeys.has(itemKey);
+}
+function rememberCompletedAssistantItemKey(state, itemKey) {
+  rememberBoundedStringSet(
+    state.completedAssistantItemKeys,
+    itemKey,
+    maxForwardedTurnIds
+  );
+}
 function rememberStreamingReasoningOutput(state, output) {
   rememberBoundedCacheValue(
     state.streamingReasoningOutputs,
@@ -6559,6 +6937,30 @@ function codexNotificationBelongsToSession(state, threadId, turnId) {
   }
   return activeTurnId(state.turn) === turnId || isLocalTuiTurn(state, turnId);
 }
+function inferThreadOnlyCompletedTurnId(args, state, threadId) {
+  if (threadId === void 0 || state.codexThreadId !== threadId) {
+    return void 0;
+  }
+  switch (state.turn.status) {
+    case "active":
+    case "completing":
+      args.log("codex.turn_completion_inferred", {
+        thread_id: threadId,
+        turn_id: state.turn.turnId,
+        queued_seq: state.turn.queuedSeq,
+        turn_status: state.turn.status
+      });
+      return state.turn.turnId;
+    case "idle":
+    case "starting":
+      args.log("codex.turn_completion_without_turn_id", {
+        thread_id: threadId,
+        turn_status: state.turn.status,
+        queued_seq: state.turn.status === "starting" ? state.turn.queuedSeq : null
+      });
+      return void 0;
+  }
+}
 function codexNotificationActiveTurnFallback(method, state, params) {
   if (method !== "response_item" || codexCompletedFileChangeFromNotification(params) === void 0) {
     return void 0;
@@ -6607,6 +7009,32 @@ async function waitForPendingTuiInputMirror(state, turnId) {
     await pending;
   }
 }
+function rememberPendingCompletedAssistantItemForward(state, turnId, promise) {
+  const existing = state.pendingCompletedAssistantItemForwards.get(turnId);
+  const pending = existing ?? /* @__PURE__ */ new Set();
+  pending.add(promise);
+  state.pendingCompletedAssistantItemForwards.set(turnId, pending);
+  trimBoundedMap(
+    state.pendingCompletedAssistantItemForwards,
+    maxForwardedTurnIds
+  );
+}
+function forgetPendingCompletedAssistantItemForward(state, turnId, promise) {
+  const pending = state.pendingCompletedAssistantItemForwards.get(turnId);
+  if (pending === void 0) {
+    return;
+  }
+  pending.delete(promise);
+  if (pending.size === 0) {
+    state.pendingCompletedAssistantItemForwards.delete(turnId);
+  }
+}
+async function waitForPendingCompletedAssistantItemForwards(state, turnId) {
+  const pending = state.pendingCompletedAssistantItemForwards.get(turnId);
+  if (pending !== void 0) {
+    await Promise.allSettled([...pending]);
+  }
+}
 async function waitForStreamingForwardChains(args, state, payloadContext) {
   flushPendingStreamingDeltas(args, state, payloadContext);
   await Promise.all([
@@ -7120,7 +7548,7 @@ var init_channelSession = __esm({
 
 // src/claudeCodeSession.ts
 import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
+import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
 function claudeCodeSettingSources() {
   return ["user", "project", "local"];
@@ -7128,7 +7556,7 @@ function claudeCodeSettingSources() {
 async function probeClaudeCodeAvailability(args) {
   if (!hasClaudeCodeAuthHint(process.env, {
     cwd: args.cwd,
-    homeDir: homedir(),
+    homeDir: homedir2(),
     platform: process.platform,
     fileExists: existsSync,
     readTextFile: readTextFileIfPresent
@@ -7793,7 +8221,7 @@ var init_claudeCodeSession = __esm({
 // src/runnerLogger.ts
 import { appendFileSync, openSync } from "node:fs";
 import { createWriteStream } from "node:fs";
-import { homedir as homedir2 } from "node:os";
+import { homedir as homedir3 } from "node:os";
 import { dirname, join as join3 } from "node:path";
 import { mkdirSync } from "node:fs";
 function createRunnerLogger(logFile, consoleReporter) {
@@ -7835,10 +8263,10 @@ function writeCliAuditEvent(event, payload, options = {}) {
 }
 function defaultCliAuditLogFile() {
   const override = process.env.LINZUMI_CLI_AUDIT_LOG?.trim();
-  return override === void 0 || override === "" ? join3(homedir2(), ".linzumi", "logs", "command-events.jsonl") : override;
+  return override === void 0 || override === "" ? join3(homedir3(), ".linzumi", "logs", "command-events.jsonl") : override;
 }
 function defaultRunnerLogFile() {
-  return join3(homedir2(), ".linzumi", "logs", "runner-events.jsonl");
+  return join3(homedir3(), ".linzumi", "logs", "runner-events.jsonl");
 }
 function redactForCliLog(value) {
   return redactObject(value);
@@ -8498,11 +8926,11 @@ import {
   realpathSync,
   writeFileSync
 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 import { join as join4, resolve as resolve2 } from "node:path";
 function ensureCodexProjectTrusted(projectPath, options = {}) {
   const trustedPath = realpathSync(resolve2(projectPath));
-  const configHome = options.configHome ?? process.env.CODEX_HOME ?? join4(homedir3(), ".codex");
+  const configHome = options.configHome ?? process.env.CODEX_HOME ?? join4(homedir4(), ".codex");
   const configPath = join4(configHome, "config.toml");
   const currentConfig = existsSync2(configPath) ? readFileSync2(configPath, "utf8") : "";
   const nextConfig = codexConfigWithTrustedProject(currentConfig, trustedPath);
@@ -8557,7 +8985,7 @@ var init_codexProjectTrust = __esm({
 
 // src/localCapabilities.ts
 import { realpathSync as realpathSync2 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3 } from "node:path";
 function parseAllowedCwdList(value) {
   if (value === void 0) {
@@ -8597,10 +9025,10 @@ function assertConfiguredAllowedCwds(paths) {
 }
 function expandUserPath(pathValue) {
   if (pathValue === "~") {
-    return homedir4();
+    return homedir5();
   }
   if (pathValue.startsWith("~/")) {
-    return resolve3(homedir4(), pathValue.slice(2));
+    return resolve3(homedir5(), pathValue.slice(2));
   }
   return pathValue;
 }
@@ -8986,11 +9414,11 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { basename as basename3, dirname as dirname2, join as join5, resolve as resolve4 } from "node:path";
 function localConfigPath(env = process.env) {
   const override = env.LINZUMI_CONFIG_FILE;
-  return override !== void 0 && override.trim() !== "" ? resolve4(expandUserPath(override)) : resolve4(homedir5(), ".linzumi", "config.json");
+  return override !== void 0 && override.trim() !== "" ? resolve4(expandUserPath(override)) : resolve4(homedir6(), ".linzumi", "config.json");
 }
 function localConfigScopeKey(linzumiUrl) {
   const normalizedUrl = kandanHttpBaseUrl(linzumiUrl);
@@ -10686,7 +11114,7 @@ import {
   rmSync,
   writeFileSync as writeFileSync4
 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 import { dirname as dirname4, join as join7, resolve as resolve5 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -11172,7 +11600,7 @@ function fileSha256Sync(path2) {
   return createHash2("sha256").update(readFileSync5(path2)).digest("hex");
 }
 function defaultEditorRuntimeCacheRoot() {
-  return join7(homedir6(), ".linzumi", "editor-runtimes");
+  return join7(homedir7(), ".linzumi", "editor-runtimes");
 }
 function nonEmptyString(value) {
   return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
@@ -11695,7 +12123,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.67-beta";
+    linzumiCliVersion = "0.0.69-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -12124,10 +12552,10 @@ var init_runnerConsoleReporter = __esm({
 
 // src/authCache.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
+import { homedir as homedir8 } from "node:os";
 import { dirname as dirname6, join as join9 } from "node:path";
 function defaultAuthFilePath() {
-  const base = process.env.KANDAN_HOME ?? join9(homedir7(), ".kandan");
+  const base = process.env.KANDAN_HOME ?? join9(homedir8(), ".kandan");
   return join9(base, "auth.json");
 }
 function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePath()) {
@@ -12830,7 +13258,7 @@ import {
   statSync
 } from "node:fs";
 import { createServer as createServer3 } from "node:http";
-import { homedir as homedir8, hostname as hostname2, tmpdir as tmpdir3 } from "node:os";
+import { homedir as homedir9, hostname as hostname2, tmpdir as tmpdir3 } from "node:os";
 import { dirname as dirname7, join as join11, resolve as resolve6 } from "node:path";
 async function runLocalCodexRunner(options) {
   const log = makeRunnerLogger(options);
@@ -16501,16 +16929,24 @@ async function streamClaudeCodeStructuredMessage(args, sessionId, message) {
       message.body,
       message.structured
     ) : [];
+    const displayBody = displayBodyForCommanderOutput(
+      message.body,
+      uploadedFileIds
+    );
+    const displayStructured = structuredWithAssistantContent(
+      message.structured,
+      displayBody
+    );
     await args.kandan.push(args.topic, "session:stream_thread_message", {
       workspace: args.workspace,
       channel: args.channel,
       thread_id: args.threadId,
       stream_key: streamKey,
-      body: message.body,
+      body: displayBody,
       payload: claudeCodePayload(
         { ...args, sourceSeq: args.sourceSeq() },
         sessionId,
-        message.structured
+        displayStructured
       ),
       ...uploadedFileIds.length === 0 ? {} : { uploaded_file_ids: uploadedFileIds },
       client_message_id: streamKey
@@ -16535,15 +16971,23 @@ async function postClaudeCodeStructuredMessage(args, sessionId, message) {
       message.body,
       message.structured
     );
+    const displayBody = displayBodyForCommanderOutput(
+      message.body,
+      uploadedFileIds
+    );
+    const displayStructured = structuredWithAssistantContent(
+      message.structured,
+      displayBody
+    );
     await args.kandan.push(args.topic, "session:post_thread_message", {
       workspace: args.workspace,
       channel: args.channel,
       thread_id: args.threadId,
-      body: message.body,
+      body: displayBody,
       payload: claudeCodePayload(
         { ...args, sourceSeq: args.sourceSeq() },
         sessionId,
-        message.structured
+        displayStructured
       ),
       ...uploadedFileIds.length === 0 ? {} : { uploaded_file_ids: uploadedFileIds },
       client_message_id: claudeCodeMessageClientId(
@@ -17468,7 +17912,7 @@ function isGitProjectDirectory(cwd) {
 }
 function browseRunnerDirectory(control, options) {
   const requestId = stringValue(control.requestId) ?? null;
-  const requestedPath = stringValue(control.path) ?? homedir8();
+  const requestedPath = stringValue(control.path) ?? homedir9();
   try {
     const currentPath = realpathSync5(resolve6(expandUserPath(requestedPath)));
     const stats = statSync(currentPath);
@@ -17499,7 +17943,7 @@ function browseRunnerDirectory(control, options) {
       ok: true,
       currentPath,
       parentPath: parent === currentPath ? null : parent,
-      homePath: homedir8(),
+      homePath: homedir9(),
       runnerCwd: resolve6(options.cwd),
       entries,
       isGit: isGitProjectDirectory(currentPath)
@@ -17534,7 +17978,7 @@ function createRunnerProject(control, options, allowedCwds) {
       error: "invalid_project_name"
     };
   }
-  const projectsRoot = join11(homedir8(), "linzumi");
+  const projectsRoot = join11(homedir9(), "linzumi");
   const projectPath = join11(projectsRoot, projectDirName);
   let createdProjectPath = false;
   try {
@@ -17751,7 +18195,7 @@ var init_kandanTls = __esm({
 // src/helloLinzumiProject.ts
 import { existsSync as existsSync10, mkdirSync as mkdirSync10, readFileSync as readFileSync11, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "node:fs";
 import { dirname as dirname9, join as join13, resolve as resolve7 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 function createHelloLinzumiProject(input = {}) {
   const options = typeof input === "string" ? { rootPath: input } : input;
   const root = resolveHelloProjectRoot(options);
@@ -17840,7 +18284,7 @@ var init_helloLinzumiProject = __esm({
     defaultHelloLinzumiPort = 8787;
     defaultHelloLinzumiHost = "0.0.0.0";
     markerFile = ".linzumi-demo-project";
-    moduleDir = dirname9(fileURLToPath(import.meta.url));
+    moduleDir = dirname9(fileURLToPath2(import.meta.url));
     linzumiLogoSvg = readFileSync11(join13(moduleDir, "assets", "linzumi-logo.svg"), "utf8");
     packageJson = `${JSON.stringify(
       {
@@ -38571,7 +39015,7 @@ import {
   writeFileSync as writeFileSync11
 } from "node:fs";
 import { access } from "node:fs/promises";
-import { homedir as homedir11, tmpdir as tmpdir4 } from "node:os";
+import { homedir as homedir12, tmpdir as tmpdir4 } from "node:os";
 import { delimiter as delimiter2, dirname as dirname11, join as join15, resolve as resolve9 } from "node:path";
 import { stdin as defaultStdin, stdout as defaultStdout } from "node:process";
 import { emitKeypressEvents } from "node:readline";
@@ -40874,7 +41318,7 @@ async function runSignupPreflights(runtime) {
 function defaultPreflightRuntime() {
   return {
     cwd: process.cwd(),
-    homeDir: homedir11(),
+    homeDir: homedir12(),
     probeTool,
     readGitEmail,
     discoverCodeRoots,
@@ -41083,7 +41527,7 @@ function codexTaskSuggestionProcess2(args) {
 function signupCodexTaskSuggestionProcessForTest(args) {
   return codexTaskSuggestionProcess2(args);
 }
-async function resolveSignupCodexCommand(env = process.env, homeDir = homedir11(), executableExists = fileIsExecutable) {
+async function resolveSignupCodexCommand(env = process.env, homeDir = homedir12(), executableExists = fileIsExecutable) {
   const override = firstConfiguredValue([
     env.LINZUMI_SIGNUP_CODEX_BIN,
     env.LINZUMI_CODEX_BIN
@@ -41722,10 +42166,10 @@ function directoryExists(path2) {
 }
 function expandHomePath(path2) {
   if (path2 === "~") {
-    return homedir11();
+    return homedir12();
   }
   if (path2.startsWith("~/")) {
-    return join15(homedir11(), path2.slice(2));
+    return join15(homedir12(), path2.slice(2));
   }
   return resolve9(path2);
 }
@@ -41813,9 +42257,9 @@ init_runner();
 init_claudeCodeSession();
 init_authCache();
 import { existsSync as existsSync13, readFileSync as readFileSync15, realpathSync as realpathSync6 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
+import { homedir as homedir13 } from "node:os";
 import { resolve as resolve10 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/authResolution.ts
 init_authCache();
@@ -41876,7 +42320,7 @@ init_json();
 init_defaultUrls();
 import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
 import { dirname as dirname8, join as join12 } from "node:path";
-import { homedir as homedir9 } from "node:os";
+import { homedir as homedir10 } from "node:os";
 async function runAgentCliCommand(args, deps = {
   fetchImpl: fetch,
   stdout: process.stdout,
@@ -42584,7 +43028,7 @@ function agentTokenFile(flags) {
   return flags.get("agent-token-file") ?? defaultAgentTokenFilePath();
 }
 function defaultAgentTokenFilePath() {
-  return join12(homedir9(), ".linzumi", "agent-token.json");
+  return join12(homedir10(), ".linzumi", "agent-token.json");
 }
 function normalizedApiUrl(apiUrl) {
   return apiUrl.endsWith("/") ? apiUrl : `${apiUrl}/`;
@@ -42692,13 +43136,13 @@ import {
   watch,
   writeFileSync as writeFileSync9
 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
+import { homedir as homedir11 } from "node:os";
 import { dirname as dirname10, join as join14, resolve as resolve8 } from "node:path";
 import { execFileSync, spawn as spawn8 } from "node:child_process";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 var connectedMarkers = ["Connected to Linzumi", "Runner connected:"];
 function commanderStatusDir() {
-  return join14(homedir10(), ".linzumi", "commanders");
+  return join14(homedir11(), ".linzumi", "commanders");
 }
 function commanderStatusFile(runnerId, statusDir = commanderStatusDir()) {
   return join14(statusDir, `${safeRunnerId(runnerId)}.json`);
@@ -42804,7 +43248,7 @@ async function waitForCommanderDaemon(options) {
         if (commanderLogIsConnected(log)) {
           return { ok: true, record: status.record };
         }
-        await waitForFileChangeOrTimeout(
+        const readyAfterWait = await waitForFileChangeOrTimeout(
           status.record.logFile,
           deadline,
           now,
@@ -42813,6 +43257,24 @@ async function waitForCommanderDaemon(options) {
             return updatedLog !== void 0 && commanderLogIsConnected(updatedLog);
           }
         );
+        if (readyAfterWait) {
+          const refreshedStatus = statusImpl(
+            options.runnerId,
+            options.statusDir
+          );
+          switch (refreshedStatus.status) {
+            case "missing":
+              return { ok: false, reason: "missing" };
+            case "stopped":
+              return { ok: false, reason: "stopped" };
+            case "running": {
+              const refreshedLog = readTextFile(refreshedStatus.record.logFile);
+              if (refreshedLog !== void 0 && commanderLogIsConnected(refreshedLog)) {
+                return { ok: true, record: refreshedStatus.record };
+              }
+            }
+          }
+        }
       }
     }
   }
@@ -42830,7 +43292,7 @@ function currentEntrypoint() {
   if (scriptPath !== void 0) {
     return scriptPath;
   }
-  return fileURLToPath2(import.meta.url);
+  return fileURLToPath3(import.meta.url);
 }
 function parseRecord(content) {
   const parsed = JSON.parse(content);
@@ -42936,31 +43398,31 @@ function safeRunnerId(runnerId) {
 }
 async function waitForFileChangeOrTimeout(path2, deadline, now, ready2 = () => false) {
   const remaining = Math.max(0, deadline - now());
-  await new Promise((resolve11) => {
+  return new Promise((resolve11) => {
     let resolved = false;
     let watcher;
-    const finish = () => {
+    const finish = (connected) => {
       if (resolved) {
         return;
       }
       resolved = true;
       watcher?.close();
       clearTimeout(timer);
-      resolve11();
+      resolve11(connected);
     };
-    const timer = setTimeout(finish, remaining);
+    const timer = setTimeout(() => finish(false), remaining);
     try {
-      watcher = watch(path2, finish);
-      watcher.on("error", finish);
+      watcher = watch(path2, () => finish(ready2()));
+      watcher.on("error", () => finish(ready2()));
       if (ready2()) {
-        finish();
+        finish(true);
       }
     } catch (_error) {
       if (ready2()) {
-        finish();
+        finish(true);
         return;
       }
-      finish();
+      finish(false);
     }
   });
 }
@@ -55142,7 +55604,7 @@ function isMainModule() {
   if (scriptPath === void 0) {
     return false;
   }
-  return fileURLToPath3(import.meta.url) === resolve10(scriptPath);
+  return fileURLToPath4(import.meta.url) === resolve10(scriptPath);
 }
 async function main(args) {
   const parsed = parseCommand(args);
@@ -56033,10 +56495,10 @@ function rejectStartTargetingFlags(values) {
 }
 function resolveUserPath(pathValue) {
   if (pathValue === "~") {
-    return homedir12();
+    return homedir13();
   }
   if (pathValue.startsWith("~/")) {
-    return resolve10(homedir12(), pathValue.slice(2));
+    return resolve10(homedir13(), pathValue.slice(2));
   }
   return resolve10(pathValue);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.67-beta",
+  "version": "0.0.69-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": {