@linzumi/cli 0.0.40-beta → 0.0.41-beta

package/README.md

@@ -63,7 +63,7 @@ Install the CLI or run it with `npx`:
 
 ```bash
 npm install -g @linzumi/cli@latest
-npx -y @linzumi/cli@0.0.40-beta --version
+npx -y @linzumi/cli@0.0.41-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -290,6 +290,9 @@ function codexSandboxPolicy(sandbox, cwd) {
 // src/codexOutput.ts
 import { Buffer as Buffer2 } from "node:buffer";
 var maxVisibleWebSearchQueries = 6;
+var maxPersistedCommandOutputChars = 14000;
+var maxPersistedCommandLabelChars = 512;
+var commandOutputTruncationReason = "phoenix_insert_body_limit";
 function codexOutputMessagesForTurn(response, turnId) {
   if ("error" in response) {
     return [];
@@ -355,21 +358,20 @@ function codexOutputMessagesForItem(item, index) {
     case "commandExecution": {
       const command = stringValue(item.command) ?? "command";
       const output = nonBlankStringValue(item.aggregatedOutput) ?? "";
-      const body = [`$ ${command}`, output].filter((part) => part.trim() !== "").join(`
-
-`);
+      const projection = codexCommandOutputProjection(command, output);
       return [
         {
           itemKey,
-          body,
+          body: projection.body,
           structured: baseStructured("codex_command_execution", {
-            command,
+            command: projection.command,
             cwd: stringValue(item.cwd) ?? "",
             status: stringValue(item.status) ?? "",
             process_id: stringValue(item.processId) ?? "",
             duration_ms: integerValue(item.durationMs) ?? null,
             exit_code: integerValue(item.exitCode) ?? null,
-            output
+            output: projection.output,
+            ...commandOutputTruncationMetadata(projection)
           })
         }
       ];
@@ -501,21 +503,29 @@ function codexCommandOutputDeltaFromNotification(params) {
   };
 }
 function codexCommandExecutionStructuredMessage(itemKey, fields, streamState) {
+  const projection = codexCommandOutputProjection(fields.command, fields.output);
+  return codexCommandExecutionStructuredMessageFromProjection(itemKey, fields, streamState, projection);
+}
+function codexCommandExecutionStructuredMessageFromProjection(itemKey, fields, streamState, projection) {
   return {
     kind: "codex_command_execution",
     item_id: itemKey,
     transcript_unit_id: `codex_command_execution:${itemKey}`,
     stream_state: streamState,
-    command: fields.command,
+    command: projection.command,
     cwd: fields.cwd ?? "",
     status: fields.status ?? streamState,
     process_id: fields.processId ?? "",
     duration_ms: fields.durationMs ?? null,
     exit_code: fields.exitCode ?? null,
     stream: fields.stream ?? "",
-    output: fields.output
+    output: projection.output,
+    ...commandOutputTruncationMetadata(projection)
   };
 }
+function codexCommandOutputBody(command, output) {
+  return codexCommandOutputProjection(command, output).body;
+}
 function codexFileChangeDeltaFromNotification(params) {
   const patchText = textDeltaFromParams(params);
   if (patchText === undefined || patchText === "") {
@@ -618,6 +628,65 @@ function assistantVisibleText(item) {
 function assistantDeltaText(params) {
   return textDeltaFromParams(params);
 }
+function codexCommandOutputProjection(command, output) {
+  const normalizedCommand = truncatePersistedText(sanitizePersistedText(command), maxPersistedCommandLabelChars, "command label");
+  const normalizedOutput = truncateCommandOutput(sanitizePersistedText(output));
+  const body = commandOutputBodyForProjection(normalizedCommand.text, normalizedOutput.text);
+  return {
+    command: normalizedCommand.text,
+    output: normalizedOutput.text,
+    body,
+    truncated: normalizedCommand.truncated || normalizedOutput.truncated,
+    originalLength: output.length,
+    maxOutputChars: maxPersistedCommandOutputChars,
+    truncationReason: commandOutputTruncationReason
+  };
+}
+function commandOutputTruncationMetadata(projection) {
+  return projection.truncated ? {
+    output_truncated: true,
+    output_original_length: projection.originalLength,
+    output_max_chars: projection.maxOutputChars,
+    output_truncation_reason: projection.truncationReason
+  } : {};
+}
+function commandOutputBodyForProjection(command, output) {
+  return [`$ ${command}`, output].filter((part) => part.trim() !== "").join(`
+
+`);
+}
+function truncateCommandOutput(output) {
+  if (output.length <= maxPersistedCommandOutputChars) {
+    return { text: output, truncated: false };
+  }
+  const marker = `
+
+[Linzumi truncated command output: output was too large to persist fully. Owners should search runner logs for codex.command_output_truncated failure_class=phoenix_insert_body_limit.]
+
+`;
+  const availableChars = Math.max(0, maxPersistedCommandOutputChars - marker.length);
+  const headChars = Math.min(2000, Math.floor(availableChars / 3));
+  const tailChars = availableChars - headChars;
+  const text = `${output.slice(0, headChars)}${marker}${output.slice(-tailChars)}`;
+  return {
+    text: text.slice(0, maxPersistedCommandOutputChars),
+    truncated: true
+  };
+}
+function truncatePersistedText(text, maxChars, label) {
+  if (text.length <= maxChars) {
+    return { text, truncated: false };
+  }
+  const marker = `[Linzumi truncated ${label}]`;
+  const availableChars = Math.max(0, maxChars - marker.length - 1);
+  return {
+    text: `${text.slice(0, availableChars)} ${marker}`.slice(0, maxChars),
+    truncated: true
+  };
+}
+function sanitizePersistedText(text) {
+  return text.replaceAll("\x00", "�");
+}
 function textDeltaFromParams(params) {
   const delta = params.delta;
   if (typeof delta === "string") {
@@ -641,57 +710,67 @@ function commandMessageForFunctionCall(item, output, index) {
   const command = name === "exec_command" ? nonBlankStringValue(args?.cmd) ?? name : `${name}${toolArgumentsSummary(item.arguments)}`;
   const cwd = nonBlankStringValue(args?.cwd) ?? "";
   const outputText = toolOutputText(output);
-  const body = [`$ ${command}`, outputText].filter((part) => part.trim() !== "").join(`
-
-`);
-  return [{
-    itemKey,
-    body,
-    structured: codexCommandExecutionStructuredMessage(itemKey, {
-      command,
-      cwd,
-      output: outputText,
-      status: output === undefined ? "started" : "completed"
-    }, "completed")
-  }];
+  const projection = codexCommandOutputProjection(command, outputText);
+  return [
+    {
+      itemKey,
+      body: projection.body,
+      structured: codexCommandExecutionStructuredMessage(itemKey, {
+        command,
+        cwd,
+        output: outputText,
+        status: output === undefined ? "started" : "completed"
+      }, "completed")
+    }
+  ];
 }
 function messageForCustomToolCall(item, output, index) {
   const name = stringValue(item.name) ?? "custom_tool_call";
   const itemKey = stringValue(item.call_id) ?? stringValue(item.id) ?? `item-${index}`;
   const input = nonBlankStringValue(item.input) ?? nonBlankStringValue(item.arguments) ?? "";
   if (name === "apply_patch") {
-    return [{
-      itemKey,
-      body: input,
-      structured: {
-        kind: "codex_file_change",
-        item_id: itemKey,
-        transcript_unit_id: `codex_file_change:${itemKey}`,
-        stream_state: "completed",
-        status: output === undefined ? "started" : "completed",
-        patch_text: input,
-        changes: fileChangesFromPatch(input)
+    return [
+      {
+        itemKey,
+        body: input,
+        structured: {
+          kind: "codex_file_change",
+          item_id: itemKey,
+          transcript_unit_id: `codex_file_change:${itemKey}`,
+          stream_state: "completed",
+          status: output === undefined ? "started" : "completed",
+          patch_text: input,
+          changes: fileChangesFromPatch(input)
+        }
       }
-    }];
+    ];
   }
   const outputText = toolOutputText(output);
   const command = `${name}${toolArgumentsSummary(item.input)}`;
-  return [{
-    itemKey,
-    body: [`$ ${command}`, outputText].filter((part) => part.trim() !== "").join(`
-
-`),
-    structured: codexCommandExecutionStructuredMessage(itemKey, { command, output: outputText, status: output === undefined ? "started" : "completed" }, "completed")
-  }];
+  const projection = codexCommandOutputProjection(command, outputText);
+  return [
+    {
+      itemKey,
+      body: projection.body,
+      structured: codexCommandExecutionStructuredMessage(itemKey, {
+        command,
+        output: outputText,
+        status: output === undefined ? "started" : "completed"
+      }, "completed")
+    }
+  ];
 }
 function commandMessageForUnpairedToolOutput(item, index) {
   const itemKey = stringValue(item.call_id) ?? stringValue(item.id) ?? `item-${index}`;
   const output = toolOutputText(item);
-  return [{
-    itemKey,
-    body: output,
-    structured: codexCommandExecutionStructuredMessage(itemKey, { command: "tool output", output, status: "completed" }, "completed")
-  }];
+  const projection = codexCommandOutputProjection("tool output", output);
+  return [
+    {
+      itemKey,
+      body: projection.output,
+      structured: codexCommandExecutionStructuredMessageFromProjection(itemKey, { status: "completed" }, "completed", projection)
+    }
+  ];
 }
 function toolArgumentsSummary(value) {
   const text = nonBlankStringValue(value);
@@ -710,13 +789,34 @@ function fileChangesFromPatch(patchText) {
     const addPrefix = "*** Add File: ";
     const deletePrefix = "*** Delete File: ";
     if (line.startsWith(updatePrefix)) {
-      return [{ path: line.slice(updatePrefix.length).trim(), diff: "", kind: "update", move_path: "" }];
+      return [
+        {
+          path: line.slice(updatePrefix.length).trim(),
+          diff: "",
+          kind: "update",
+          move_path: ""
+        }
+      ];
     }
     if (line.startsWith(addPrefix)) {
-      return [{ path: line.slice(addPrefix.length).trim(), diff: "", kind: "add", move_path: "" }];
+      return [
+        {
+          path: line.slice(addPrefix.length).trim(),
+          diff: "",
+          kind: "add",
+          move_path: ""
+        }
+      ];
     }
     if (line.startsWith(deletePrefix)) {
-      return [{ path: line.slice(deletePrefix.length).trim(), diff: "", kind: "delete", move_path: "" }];
+      return [
+        {
+          path: line.slice(deletePrefix.length).trim(),
+          diff: "",
+          kind: "delete",
+          move_path: ""
+        }
+      ];
     }
     return [];
   });
@@ -2345,8 +2445,8 @@ async function attachChannelSession(args) {
   const session = args.options.channelSession;
   const chatTopic = `chat:${session.workspaceSlug}:${session.channelSlug}`;
   const state = initialChannelSessionState(0, session.rootSeq, session.kandanThreadId, session.codexThreadId, args.options);
-  const joined = await args.kandan.join(chatTopic, { last_seq: 0 }, {
-    rejoinPayload: () => ({ last_seq: state.minSeq })
+  const joined = await args.kandan.join(chatTopic, chatJoinPayload(args.options.runnerId, state, 0), {
+    rejoinPayload: () => chatJoinPayload(args.options.runnerId, state, state.minSeq)
   });
   const cursor = integerValue(joined.cursor) ?? 0;
   const runnerIdentity = identityFromAccessToken(args.options.token);
@@ -2492,6 +2592,19 @@ async function attachChannelSession(args) {
     }
   };
 }
+function chatJoinPayload(runnerId, state, lastSeq) {
+  const base = { last_seq: lastSeq };
+  switch (state.kandanThreadId) {
+    case undefined:
+      return base;
+    default:
+      return {
+        ...base,
+        runner_id: runnerId,
+        thread_id: state.kandanThreadId
+      };
+  }
+}
 async function bindCurrentCodexThread(args, state) {
   if (state.codexThreadId === undefined) {
     return;
@@ -3972,13 +4085,25 @@ async function forwardCommandOutputDeltaPayload(args, state, delta, payloadConte
   }
   const existing = findStreamingCommandOutput(state, delta.itemKey);
   const output = `${existing?.output ?? ""}${delta.delta}`;
-  const body = commandOutputBody("command output", output);
   const structured = codexCommandExecutionStructuredMessage(delta.itemKey, {
     command: "command output",
     output,
     processId: delta.processId,
     stream: delta.stream
   }, "streaming");
+  const persistedOutput = typeof structured.output === "string" ? structured.output : output;
+  const body = codexCommandOutputBody("command output", output);
+  if (structured.output_truncated === true) {
+    args.log("codex.command_output_truncated", {
+      item_key: delta.itemKey,
+      turn_id: turnId,
+      process_id: delta.processId ?? null,
+      stream: delta.stream,
+      failure_class: stringValue(structured.output_truncation_reason) ?? null,
+      original_length: integerValue(structured.output_original_length) ?? null,
+      persisted_length: persistedOutput.length
+    });
+  }
   if (existing === undefined) {
     const session = args.options.channelSession;
     const reply = await pushOk(args.kandan, args.topic, "session:post_thread_message", {
@@ -4002,7 +4127,7 @@ async function forwardCommandOutputDeltaPayload(args, state, delta, payloadConte
         itemKey: delta.itemKey,
         turnId,
         seq,
-        output,
+        output: persistedOutput,
         processId: delta.processId,
         stream: delta.stream
       });
@@ -4011,7 +4136,7 @@ async function forwardCommandOutputDeltaPayload(args, state, delta, payloadConte
     await editCodexStructuredOutput(args, state, existing.seq, body, structured);
     rememberStreamingCommandOutput(state, {
       ...existing,
-      output,
+      output: persistedOutput,
       processId: delta.processId ?? existing.processId,
       stream: delta.stream
     });
@@ -4021,7 +4146,7 @@ async function forwardCommandOutputDeltaPayload(args, state, delta, payloadConte
     turn_id: turnId,
     process_id: delta.processId ?? null,
     stream: delta.stream,
-    output_length: output.length
+    output_length: persistedOutput.length
   });
 }
 async function forwardFileChangeDeltaPayload(args, state, delta, payloadContext) {
@@ -4216,11 +4341,6 @@ function webSearchProgressClientMessageId(instanceId, turnId) {
 function webSearchProgressItemKey(turnId) {
   return `web-search:${turnId}`;
 }
-function commandOutputBody(command, output) {
-  return [`$ ${command}`, output].filter((part) => part.trim() !== "").join(`
-
-`);
-}
 async function streamCompletedCodexOutput(args, state, payloadContext, params) {
   if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
     return;
@@ -6249,30 +6369,14 @@ function prepareCodeServerLaunch(options) {
   if (platform !== "darwin") {
     return filesystemSandboxUnavailable();
   }
-  const sandboxExecBin = options.sandboxExecBin ?? "/usr/bin/sandbox-exec";
-  if (!existsSync2(sandboxExecBin)) {
-    return filesystemSandboxUnavailable();
-  }
   const codeServerExecutable = resolveCodeServerExecutable(options.codeServerBin, options.envPath ?? process.env.PATH ?? "");
   if (!codeServerExecutable.ok) {
     return filesystemSandboxUnavailable();
   }
   return {
     ok: true,
-    command: sandboxExecBin,
-    args: [
-      "-p",
-      codeServerSandboxProfile(options, codeServerExecutable.directory),
-      "--",
-      "/bin/sh",
-      "-c",
-      'export HOME="$1"; export PWD="$1"; export TMPDIR="$2"; export TMP="$2"; export TEMP="$2"; shift 2; exec "$@"',
-      "kandan-code-server-env",
-      options.cwd,
-      join4(options.userDataDir, "tmp"),
-      codeServerExecutable.command,
-      ...codeServerArgs(options.port, options.cwd, options.userDataDir, options.extensionsDir)
-    ]
+    command: codeServerExecutable.command,
+    args: codeServerArgs(options.port, options.cwd, options.userDataDir, options.extensionsDir)
   };
 }
 function prepareLinuxCodeServerLaunch(options) {
@@ -6343,43 +6447,6 @@ function filesystemSandboxUnavailable() {
     reason: "local_editor_filesystem_sandbox_unavailable"
   };
 }
-function codeServerSandboxProfile(options, codeServerBinDir) {
-  const readOnlyRoots = uniquePaths([
-    "/System",
-    "/Library",
-    "/usr",
-    "/bin",
-    "/sbin",
-    "/etc",
-    "/private/etc",
-    "/opt/homebrew",
-    ...options.codeServerRuntimeRoot === undefined ? [] : sandboxPathAliases(options.codeServerRuntimeRoot),
-    codeServerBinDir
-  ]);
-  const readWriteRoots = uniquePaths([
-    ...sandboxPathAliases(options.cwd),
-    ...sandboxPathAliases(options.userDataDir),
-    ...options.extensionsDir === undefined ? [] : sandboxPathAliases(options.extensionsDir)
-  ]);
-  return [
-    "(version 1)",
-    "(deny default)",
-    "(allow process*)",
-    "(allow signal (target self))",
-    "(allow signal (target same-sandbox))",
-    "(allow sysctl*)",
-    "(allow mach*)",
-    "(allow ipc*)",
-    "(allow network*)",
-    "(allow file-read-metadata)",
-    "(allow file-map-executable)",
-    '(allow file-read* (literal "/") (literal "/private") (literal "/private/var"))',
-    `(allow file-read* ${readOnlyRoots.map(sandboxSubpath).join(" ")})`,
-    '(allow file-read* file-write* (subpath "/dev"))',
-    `(allow file-read* file-write* ${readWriteRoots.map(sandboxSubpath).join(" ")})`
-  ].join(`
-`);
-}
 function resolveCodeServerExecutable(command, envPath) {
   if (hasPathSeparator(command)) {
     const directory = safeRealpathDir(command);
@@ -6420,9 +6487,6 @@ function sandboxPathAliases(path) {
 function uniquePaths(paths) {
   return Array.from(new Set(paths.filter((path) => path.length > 0)));
 }
-function sandboxSubpath(path) {
-  return `(subpath "${path.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}")`;
-}
 function prepareLocalEditorCollaboration(collaboration, runnerId, serverPort, browserBaseUrl) {
   if (collaboration === undefined || serverPort === undefined) {
     return;
@@ -6548,19 +6612,11 @@ function installDirectory(sourceDir, destinationDir) {
   mkdirSync3(dirname2(destinationDir), { recursive: true });
   cpSync(sourceDir, destinationDir, { recursive: true });
 }
-function codeServerEnv(env, cwd, userDataDir, collaboration) {
+function codeServerEnv(env, cwd, _userDataDir, collaboration) {
   const { PORT: _port, ...hostEnv } = env;
-  const tempDir = join4(userDataDir, "tmp");
   const base = {
     ...hostEnv,
-    HOME: cwd,
-    PWD: cwd,
-    TMPDIR: tempDir,
-    TMP: tempDir,
-    TEMP: tempDir,
-    XDG_CACHE_HOME: join4(userDataDir, "xdg-cache"),
-    XDG_CONFIG_HOME: join4(userDataDir, "xdg-config"),
-    XDG_DATA_HOME: join4(userDataDir, "xdg-data")
+    PWD: cwd
   };
   if (collaboration === undefined) {
     return base;
@@ -8654,6 +8710,8 @@ async function applyControl(codex, kandan, topic, instanceId, options, allowedCw
   switch (control.type) {
     case "start_instance": {
       const cwd = resolveAllowedCwd(control.cwd, allowedCwds);
+      let startupStage = "starting_codex_session";
+      let startedCodexThreadId;
       if (!cwd.ok) {
         return {
           instanceId,
@@ -8672,8 +8730,10 @@ async function applyControl(codex, kandan, topic, instanceId, options, allowedCw
       }
       try {
         if (options.codexUrl === undefined) {
+          startupStage = "checking_project_trust";
           ensureCodexProjectTrusted(cwd.cwd);
         }
+        startupStage = "starting_codex_session";
         const developerPrompt = normalizedWorkDescription(control.developerPrompt);
         const runtimeSettings = startInstanceRuntimeSettings(options, control);
         const response = await codex.request("thread/start", {
@@ -8691,12 +8751,18 @@ async function applyControl(codex, kandan, topic, instanceId, options, allowedCw
           ...runtimeSettings.fast === true ? { serviceTier: "fast" } : {}
         });
         const codexThreadId = extractStartedThreadId(response);
+        startedCodexThreadId = codexThreadId;
         const workDescription = normalizedWorkDescription(control.workDescription);
         if (codexThreadId !== undefined && developerPrompt !== undefined) {
           await postVisibleDeveloperPrompt(kandan, topic, control, developerPrompt, codexThreadId);
         }
-        const startedThreadSession = codexThreadId !== undefined && onStartedThread !== undefined ? await onStartedThread(control, cwd.cwd, codexThreadId) : undefined;
+        let startedThreadSession;
+        if (codexThreadId !== undefined && onStartedThread !== undefined) {
+          startupStage = "binding_kandan_thread";
+          startedThreadSession = await onStartedThread(control, cwd.cwd, codexThreadId);
+        }
         if (codexThreadId !== undefined && workDescription !== undefined) {
+          startupStage = "starting_first_turn";
           const rootSeq = integerValue(control.rootSeq);
           const sourceSeq = integerValue(control.sourceSeq) ?? rootSeq;
           if (startedThreadSession !== undefined && sourceSeq !== undefined) {
@@ -8722,8 +8788,16 @@ async function applyControl(codex, kandan, topic, instanceId, options, allowedCw
           response
         };
       } catch (error) {
+        const failureReason = startInstanceFailureReason(startupStage, error);
+        log("kandan.start_instance_failed", {
+          stage: startupStage,
+          message: error instanceof Error ? error.message : String(error),
+          thread_id: optionalThreadControlField(control, "threadId") ?? null,
+          source_seq: integerValue(control.sourceSeq) ?? integerValue(control.rootSeq) ?? null,
+          codex_thread_id: startedCodexThreadId ?? null
+        });
         try {
-          await publishStartInstanceMessageState(kandan, topic, control, "failed", "failed to start Codex session");
+          await publishStartInstanceMessageState(kandan, topic, control, "failed", failureReason, { codexThreadId: startedCodexThreadId });
         } catch (_publishError) {}
         throw error;
       }
@@ -8835,6 +8909,26 @@ async function applyControl(codex, kandan, topic, instanceId, options, allowedCw
       return { instanceId, controlType: control.type, skipped: true };
   }
 }
+function startInstanceFailureReason(stage, error) {
+  const detail = truncateFailureDetail(error instanceof Error ? error.message : String(error));
+  switch (stage) {
+    case "checking_project_trust":
+      return `Codex could not start because this folder is not trusted locally. Trust the folder with linzumi paths add, or restart the runner from a trusted folder. Detail: ${detail}`;
+    case "starting_codex_session":
+      return `Codex did not create a session. Restart the local runner and try again. Detail: ${detail}`;
+    case "binding_kandan_thread":
+      return `Codex started, but Linzumi could not attach it to this thread. Try starting the agent again; if it repeats, share this failed message with the runner owner. Detail: ${detail}`;
+    case "starting_first_turn":
+      return `Codex started, but the first prompt could not be delivered. Try sending the message again; if it repeats, reconnect the local runner. Detail: ${detail}`;
+  }
+}
+function truncateFailureDetail(message) {
+  const trimmed = message.trim();
+  if (trimmed.length <= 240) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, 237)}...`;
+}
 function commanderDeveloperInstructions(args) {
   const customPrompt = args.developerPrompt === undefined ? "" : `
 <invoker_developer_prompt>
@@ -8915,14 +9009,14 @@ ${developerPrompt}`,
     client_message_id: `codex-start-instructions-${threadId}`
   });
 }
-async function publishStartInstanceMessageState(kandan, topic, control, status, reason) {
-  const payload = startInstanceMessageStatePayload(control, status, reason);
+async function publishStartInstanceMessageState(kandan, topic, control, status, reason, diagnostics = {}) {
+  const payload = startInstanceMessageStatePayload(control, status, reason, diagnostics);
   if (payload === undefined) {
     return;
   }
   await kandan.push(topic, "message_state", payload);
 }
-function startInstanceMessageStatePayload(control, status, reason) {
+function startInstanceMessageStatePayload(control, status, reason, diagnostics = {}) {
   const rootSeq = integerValue(control.rootSeq);
   const sourceSeq = integerValue(control.sourceSeq) ?? rootSeq;
   if (sourceSeq === undefined) {
@@ -8937,7 +9031,8 @@ function startInstanceMessageStatePayload(control, status, reason) {
     thread_id: threadId,
     seq: sourceSeq,
     status,
-    reason
+    reason,
+    ...diagnostics.codexThreadId === undefined ? {} : { codex_thread_id: diagnostics.codexThreadId }
   };
 }
 function requiredStartInstanceControlField(control, field) {
@@ -10881,7 +10976,7 @@ async function main(args) {
       process.stdout.write(connectGuideText());
       return;
     case "version":
-      process.stdout.write(`linzumi 0.0.40-beta
+      process.stdout.write(`linzumi 0.0.41-beta
 `);
       return;
     case "auth":
@@ -11407,7 +11502,7 @@ async function parseRunnerArgs(args, deps = {
     process.exit(0);
   }
   if (values.get("version") === true) {
-    process.stdout.write(`linzumi 0.0.40-beta
+    process.stdout.write(`linzumi 0.0.41-beta
 `);
     process.exit(0);
   }

package/package.json

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