@linzumi/cli 0.0.39-beta → 0.0.41-beta

package/dist/index.js

@@ -1,15 +1,16 @@
 // src/index.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { existsSync as existsSync10, readFileSync as readFileSync9, realpathSync as realpathSync5 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync9, realpathSync as realpathSync6 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/runner.ts
 import { spawn as spawn6 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
+import { realpathSync as realpathSync4 } from "node:fs";
 import { hostname as hostname2 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join6, resolve as resolve5 } from "node:path";
 
 // src/channelSessionSupport.ts
 import { spawnSync } from "node:child_process";
@@ -289,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 [];
@@ -354,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)
           })
         }
       ];
@@ -500,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 === "") {
@@ -617,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") {
@@ -640,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);
@@ -709,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 [];
   });
@@ -2344,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);
@@ -2491,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;
@@ -2544,7 +2658,10 @@ function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThread
     webSearchProgressForwardChain: Promise.resolve(),
     typingHeartbeat: undefined,
     typingHeartbeatInFlight: false,
-    runtimeSettings: runtimeSettingsFromOptions(options)
+    runtimeSettings: runtimeSettingsFromOptions(options),
+    pendingRuntimeSettingsResume: false,
+    runtimeSettingsGeneration: 0,
+    runtimeSettingsResumeChain: Promise.resolve()
   };
 }
 async function handleLostPortForwardCandidate(args, state, payloadContext, candidate) {
@@ -2682,7 +2799,7 @@ async function handleChannelSessionControl(args, state, payloadContext, control)
     interruptedQueuedMessages: interrupted.ok ? interrupted.selectedCount : 0
   };
 }
-function updateSessionSettings(args, state, control) {
+async function updateSessionSettings(args, state, control) {
   if (state.codexThreadId !== control.threadId) {
     return;
   }
@@ -2694,6 +2811,8 @@ function updateSessionSettings(args, state, control) {
     };
   }
   state.runtimeSettings = mergeRuntimeSettings(state.runtimeSettings, control);
+  state.pendingRuntimeSettingsResume = true;
+  state.runtimeSettingsGeneration += 1;
   publishRuntimeSettings(args, state).catch((error) => {
     args.log("kandan.session_settings_publish_failed", {
       message: error instanceof Error ? error.message : String(error)
@@ -2706,6 +2825,7 @@ function updateSessionSettings(args, state, control) {
     sandbox: state.runtimeSettings.sandbox ?? null,
     fast: state.runtimeSettings.fast ?? null
   });
+  await tryResumeCodexThreadForPendingRuntimeSettings(args, state);
   return {
     instanceId: args.instanceId,
     ok: true,
@@ -2716,6 +2836,71 @@ function updateSessionSettings(args, state, control) {
     fast: state.runtimeSettings.fast ?? null
   };
 }
+async function resumeCodexThreadForPendingRuntimeSettings(args, state) {
+  const requestedGeneration = state.runtimeSettingsGeneration;
+  const previousResume = state.runtimeSettingsResumeChain.catch(() => {
+    return;
+  });
+  const resume = previousResume.then(() => performCodexThreadResumeForPendingRuntimeSettings(args, state, requestedGeneration));
+  state.runtimeSettingsResumeChain = resume.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return await resume;
+}
+async function performCodexThreadResumeForPendingRuntimeSettings(args, state, requestedGeneration) {
+  if (state.pendingRuntimeSettingsResume !== true || state.closed || state.turn.status !== "idle" || localTuiTurnIsActive(state)) {
+    return true;
+  }
+  const codexThreadId = state.codexThreadId;
+  if (codexThreadId === undefined) {
+    return true;
+  }
+  if (state.runtimeSettingsGeneration !== requestedGeneration) {
+    return false;
+  }
+  const resumeGeneration = requestedGeneration;
+  const resumeSettings = state.runtimeSettings;
+  const runtimeOptions = runtimeOptionsForSettings(args.options, resumeSettings);
+  const resumeParams = {
+    threadId: codexThreadId,
+    ...codexThreadRuntimeOverrides(runtimeOptions)
+  };
+  args.log("codex.session_settings_resume_requested", {
+    codex_thread_id: codexThreadId,
+    model: resumeSettings.model ?? null,
+    reasoning_effort: resumeSettings.reasoningEffort ?? null,
+    approval_policy: resumeSettings.approvalPolicy ?? null,
+    sandbox: resumeSettings.sandbox ?? null,
+    fast: resumeSettings.fast ?? null,
+    generation: resumeGeneration
+  });
+  const resumed = await args.codex.request("thread/resume", resumeParams);
+  if ("error" in resumed) {
+    throw new Error(`failed to resume Codex thread with updated settings: ${resumed.error.message}`);
+  }
+  if (state.pendingRuntimeSettingsResume === true && state.runtimeSettingsGeneration === resumeGeneration) {
+    state.pendingRuntimeSettingsResume = false;
+  }
+  args.log("codex.session_settings_resume_completed", {
+    codex_thread_id: codexThreadId,
+    generation: resumeGeneration,
+    current_generation: state.runtimeSettingsGeneration,
+    pending: state.pendingRuntimeSettingsResume
+  });
+  return state.pendingRuntimeSettingsResume !== true;
+}
+async function tryResumeCodexThreadForPendingRuntimeSettings(args, state) {
+  try {
+    return await resumeCodexThreadForPendingRuntimeSettings(args, state);
+  } catch (error) {
+    args.log("codex.session_settings_resume_failed", {
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
 async function resolvePendingCodexApprovalRequest(args, state, control) {
   if (state.codexThreadId !== control.threadId) {
     return;
@@ -3277,6 +3462,10 @@ async function drainKandanMessageQueue(args, state, payloadContext) {
   if (state.closed || state.turn.status !== "idle" || localTuiTurnIsActive(state)) {
     return;
   }
+  const resumed = await tryResumeCodexThreadForPendingRuntimeSettings(args, state);
+  if (!resumed) {
+    return;
+  }
   const next = dequeuePendingKandanMessage(state.queue);
   if (next === undefined) {
     return;
@@ -3602,11 +3791,17 @@ async function forwardCompletedCodexTurn(args, state, turnId, payloadContext) {
     if (completingActiveTurn && state.turn.status === "completing" && state.turn.turnId === turnId) {
       state.turn = { status: "idle" };
       await stopCodexTyping(args, state);
-      await drainKandanMessageQueue(args, state, payloadContext);
+      const resumed = await tryResumeCodexThreadForPendingRuntimeSettings(args, state);
+      if (resumed) {
+        await drainKandanMessageQueue(args, state, payloadContext);
+      }
     }
     if (completingLocalTuiTurn && !completingActiveTurn) {
       await stopCodexTyping(args, state);
-      await drainKandanMessageQueue(args, state, payloadContext);
+      const resumed = await tryResumeCodexThreadForPendingRuntimeSettings(args, state);
+      if (resumed) {
+        await drainKandanMessageQueue(args, state, payloadContext);
+      }
     }
   }
 }
@@ -3890,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", {
@@ -3920,7 +4127,7 @@ async function forwardCommandOutputDeltaPayload(args, state, delta, payloadConte
         itemKey: delta.itemKey,
         turnId,
         seq,
-        output,
+        output: persistedOutput,
         processId: delta.processId,
         stream: delta.stream
       });
@@ -3929,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
     });
@@ -3939,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) {
@@ -4134,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;
@@ -6167,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) {
@@ -6261,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",
-    "/dev",
-    ...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* ${readWriteRoots.map(sandboxSubpath).join(" ")})`
-  ].join(`
-`);
-}
 function resolveCodeServerExecutable(command, envPath) {
   if (hasPathSeparator(command)) {
     const directory = safeRealpathDir(command);
@@ -6338,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;
@@ -6466,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;
@@ -7955,6 +8093,9 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     };
   });
   const allowedCwds = { value: [...options.allowedCwds] };
+  const missingAllowedCwds = {
+    value: normalizeAllowedCwds(options.missingAllowedCwds ?? [])
+  };
   const localEditorState = {
     value: { status: "disabled" }
   };
@@ -7970,7 +8111,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     codexRemoteTui: true,
     startInstance: allowedCwds.value.length > 0,
     allowedCwds: allowedCwds.value,
-    missingConfiguredAllowedCwds: options.missingConfiguredAllowedCwds ?? [],
+    missingAllowedCwds: missingAllowedCwds.value,
     allowedCwdSuggestions: allowedCwdSuggestions(options.cwd, allowedCwds.value),
     portForwarding: liveForwardPorts.size > 0,
     allowedPorts: Array.from(liveForwardPorts).sort((left, right) => left - right),
@@ -7985,7 +8126,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const joinPayload = () => ({
     clientName: "kandan-local-codex-runner",
     version: "0.0.1",
-    workspace: options.channelSession?.workspaceSlug ?? options.workspaceSlug ?? null,
+    workspace: runnerWorkspaceSlug(options) ?? null,
     channel: options.channelSession?.channelSlug ?? null,
     capabilities: capabilitiesPayload()
   });
@@ -8055,6 +8196,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const codexThreads = options.channelSession === undefined ? await discoverCodexThreads(codex, options.cwd) : [];
   const discoveredCodexThreads = { value: codexThreads };
   const runnerHost = hostname2();
+  const runtimeDefaults = runnerRuntimeDefaults(options);
   const instancePayload = {
     instanceId,
     codexUrl,
@@ -8062,8 +8204,10 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     cwd: options.cwd,
     hostname: runnerHost,
     codexThreads,
-    model: options.channelSession?.model ?? null,
-    reasoningEffort: options.channelSession?.reasoningEffort ?? null,
+    workspace: runnerWorkspaceSlug(options) ?? null,
+    channel: options.channelSession?.channelSlug ?? null,
+    model: runtimeDefaults.model ?? null,
+    reasoningEffort: runtimeDefaults.reasoningEffort ?? null,
     fast: options.fast ?? false
   };
   await kandan.push(topic, "instance_started", instancePayload);
@@ -8108,9 +8252,9 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     dynamicChannelSessions.clear();
   });
   const attachThreadSession = async (control, cwd, codexThreadId) => {
-    const workspaceSlug = normalizedWorkDescription(control.workspace);
-    const channelSlug = normalizedWorkDescription(control.channel);
-    const kandanThreadId = normalizedWorkDescription(control.threadId);
+    const workspaceSlug = optionalThreadControlField(control, "workspace");
+    const channelSlug = optionalThreadControlField(control, "channel");
+    const kandanThreadId = optionalThreadControlField(control, "threadId");
     if (workspaceSlug === undefined || channelSlug === undefined || kandanThreadId === undefined) {
       return;
     }
@@ -8171,13 +8315,13 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     codexUrl,
     cwd: options.cwd,
     hostname: runnerHost,
-    workspace: options.channelSession?.workspaceSlug ?? options.workspaceSlug ?? null,
+    workspace: runnerWorkspaceSlug(options) ?? null,
     channel: options.channelSession?.channelSlug ?? null,
     threadId: channelSession?.currentKandanThreadId() ?? null,
     codexThreadId: channelSession?.currentCodexThreadId() ?? null,
     codexThreads: discoveredCodexThreads.value,
-    model: options.channelSession?.model ?? null,
-    reasoningEffort: options.channelSession?.reasoningEffort ?? null,
+    model: runtimeDefaults.model ?? null,
+    reasoningEffort: runtimeDefaults.reasoningEffort ?? null,
     fast: options.fast ?? false,
     capabilities: capabilitiesPayload()
   });
@@ -8342,7 +8486,9 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       return;
     }
     if (isUpdateRunnerConfigControl(control)) {
-      allowedCwds.value = normalizeAllowedCwds(control.allowedCwds);
+      const updatedAllowedCwds = configuredAllowedCwds(control.allowedCwds);
+      allowedCwds.value = updatedAllowedCwds.allowedCwds;
+      missingAllowedCwds.value = updatedAllowedCwds.missingAllowedCwds;
       pushHeartbeat();
       return;
     }
@@ -8374,7 +8520,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       if (handled !== undefined) {
         return handled;
       }
-      return applyControl(codex, kandan, topic, instanceId, options, allowedCwds.value, control, attachThreadSession);
+      return applyControl(codex, kandan, topic, instanceId, options, allowedCwds.value, control, log, attachThreadSession);
     }).then((response) => {
       return kandan.push(topic, "codex_response", response);
     }).catch((error) => {
@@ -8450,7 +8596,7 @@ async function discoverCodexThreads(codex, cwd) {
 }
 function extractStartedThreadId(response) {
   if ("error" in response) {
-    return;
+    throw new Error(`thread/start failed: ${response.error.message}`);
   }
   return stringValue(objectValue(objectValue(response.result)?.thread)?.id);
 }
@@ -8560,10 +8706,12 @@ async function prepareCodexThreadForTuiResume(codex, codexThreadId) {
     throw new Error(`failed to verify Codex TUI resume: ${verified.error.message}`);
   }
 }
-async function applyControl(codex, kandan, topic, instanceId, options, allowedCwds, control, onStartedThread) {
+async function applyControl(codex, kandan, topic, instanceId, options, allowedCwds, control, log, onStartedThread) {
   switch (control.type) {
     case "start_instance": {
       const cwd = resolveAllowedCwd(control.cwd, allowedCwds);
+      let startupStage = "starting_codex_session";
+      let startedCodexThreadId;
       if (!cwd.ok) {
         return {
           instanceId,
@@ -8572,56 +8720,87 @@ async function applyControl(codex, kandan, topic, instanceId, options, allowedCw
           error: cwd.reason
         };
       }
-      if (options.codexUrl === undefined) {
-        ensureCodexProjectTrusted(cwd.cwd);
+      const processingStatePayload = startInstanceMessageStatePayload(control, "processing", "starting Codex session");
+      if (processingStatePayload !== undefined) {
+        kandan.push(topic, "message_state", processingStatePayload).catch((error) => {
+          log("kandan.start_instance_processing_state_push_failed", {
+            message: error instanceof Error ? error.message : String(error)
+          });
+        });
       }
-      const developerPrompt = normalizedWorkDescription(control.developerPrompt);
-      const runtimeSettings = startInstanceRuntimeSettings(options, control);
-      const response = await codex.request("thread/start", {
-        cwd: cwd.cwd,
-        serviceName: "kandan-local-runner",
-        personality: "pragmatic",
-        developerInstructions: commanderDeveloperInstructions({
+      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", {
           cwd: cwd.cwd,
-          developerPrompt
-        }),
-        ...runtimeSettings.model === undefined ? {} : { model: runtimeSettings.model },
-        ...runtimeSettings.reasoningEffort === undefined ? {} : { reasoningEffort: runtimeSettings.reasoningEffort },
-        ...runtimeSettings.approvalPolicy === undefined ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
-        ...runtimeSettings.sandbox === undefined ? {} : { sandbox: runtimeSettings.sandbox },
-        ...runtimeSettings.fast === true ? { serviceTier: "fast" } : {}
-      });
-      const codexThreadId = extractStartedThreadId(response);
-      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;
-      if (codexThreadId !== undefined && workDescription !== undefined) {
-        const rootSeq = integerValue(control.rootSeq);
-        const sourceSeq = integerValue(control.sourceSeq) ?? rootSeq;
-        if (startedThreadSession !== undefined && sourceSeq !== undefined) {
-          const identity = identityFromAccessToken(options.token);
-          await startedThreadSession.startThreadMessageTurn({
-            seq: sourceSeq,
-            body: workDescription,
-            actorSlug: identity.actorUsername,
-            actorUserId: identity.actorUserId
-          });
-        } else {
-          await codex.request("turn/start", {
-            threadId: codexThreadId,
-            input: [{ type: "text", text: workDescription }]
-          });
+          serviceName: "kandan-local-runner",
+          personality: "pragmatic",
+          developerInstructions: commanderDeveloperInstructions({
+            cwd: cwd.cwd,
+            developerPrompt
+          }),
+          ...runtimeSettings.model === undefined ? {} : { model: runtimeSettings.model },
+          ...runtimeSettings.reasoningEffort === undefined ? {} : { reasoningEffort: runtimeSettings.reasoningEffort },
+          ...runtimeSettings.approvalPolicy === undefined ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
+          ...runtimeSettings.sandbox === undefined ? {} : { sandbox: runtimeSettings.sandbox },
+          ...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);
+        }
+        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) {
+            const identity = identityFromAccessToken(options.token);
+            await startedThreadSession.startThreadMessageTurn({
+              seq: sourceSeq,
+              body: workDescription,
+              actorSlug: identity.actorUsername,
+              actorUserId: identity.actorUserId
+            });
+          } else {
+            await codex.request("turn/start", {
+              threadId: codexThreadId,
+              input: [{ type: "text", text: workDescription }]
+            });
+          }
         }
+        return {
+          instanceId,
+          controlType: control.type,
+          cwd: cwd.cwd,
+          matchedRoot: cwd.matchedRoot,
+          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", failureReason, { codexThreadId: startedCodexThreadId });
+        } catch (_publishError) {}
+        throw error;
       }
-      return {
-        instanceId,
-        controlType: control.type,
-        cwd: cwd.cwd,
-        matchedRoot: cwd.matchedRoot,
-        response
-      };
     }
     case "reconnect_thread": {
       const cwd = resolveAllowedCwd(control.cwd, allowedCwds);
@@ -8730,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>
@@ -8786,9 +8985,9 @@ secure tunnel, and keep the Linzumi thread truthful.
 </task_reminder>`;
 }
 async function postVisibleDeveloperPrompt(kandan, topic, control, developerPrompt, codexThreadId) {
-  const workspace = normalizedWorkDescription(control.workspace);
-  const channel = normalizedWorkDescription(control.channel);
-  const threadId = normalizedWorkDescription(control.threadId);
+  const workspace = optionalThreadControlField(control, "workspace");
+  const channel = optionalThreadControlField(control, "channel");
+  const threadId = optionalThreadControlField(control, "threadId");
   if (workspace === undefined || channel === undefined || threadId === undefined) {
     return;
   }
@@ -8810,24 +9009,81 @@ ${developerPrompt}`,
     client_message_id: `codex-start-instructions-${threadId}`
   });
 }
+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, diagnostics = {}) {
+  const rootSeq = integerValue(control.rootSeq);
+  const sourceSeq = integerValue(control.sourceSeq) ?? rootSeq;
+  if (sourceSeq === undefined) {
+    return;
+  }
+  const workspace = requiredStartInstanceControlField(control, "workspace");
+  const channel = requiredStartInstanceControlField(control, "channel");
+  const threadId = requiredStartInstanceControlField(control, "threadId");
+  return {
+    workspace,
+    channel,
+    thread_id: threadId,
+    seq: sourceSeq,
+    status,
+    reason,
+    ...diagnostics.codexThreadId === undefined ? {} : { codex_thread_id: diagnostics.codexThreadId }
+  };
+}
+function requiredStartInstanceControlField(control, field) {
+  return requiredThreadControlField(control, field);
+}
+function requiredThreadControlField(control, field) {
+  const value = optionalThreadControlField(control, field);
+  if (value === undefined) {
+    throw new Error(`${control.type} control missing ${field}`);
+  }
+  return value;
+}
+function optionalThreadControlField(control, field) {
+  const value = stringValue(control[field])?.trim();
+  if (value === undefined || value === "") {
+    return;
+  }
+  return value;
+}
 function startInstanceRuntimeSettings(options, control) {
-  const session = options.channelSession;
+  const defaults = runnerRuntimeDefaults(options);
   return {
-    model: control.model ?? session?.model,
-    reasoningEffort: control.reasoningEffort ?? session?.reasoningEffort,
-    approvalPolicy: control.approvalPolicy ?? session?.approvalPolicy,
-    sandbox: control.sandbox ?? session?.sandbox,
+    model: control.model ?? defaults.model,
+    reasoningEffort: control.reasoningEffort ?? defaults.reasoningEffort,
+    approvalPolicy: control.approvalPolicy ?? defaults.approvalPolicy,
+    sandbox: control.sandbox ?? defaults.sandbox,
     fast: control.fast ?? options.fast
   };
 }
 async function startOwnedCodexAppServer(options) {
   ensureCodexProjectTrusted(options.cwd);
+  const defaults = runnerRuntimeDefaults(options);
   return await startCodexAppServer(options.codexBin, options.cwd, {
-    model: options.channelSession?.model,
-    reasoningEffort: options.channelSession?.reasoningEffort,
+    model: defaults.model,
+    reasoningEffort: defaults.reasoningEffort,
     fast: options.fast
   });
 }
+function runnerWorkspaceSlug(options) {
+  return options.channelSession?.workspaceSlug ?? options.workspaceSlug;
+}
+function runnerRuntimeDefaults(options) {
+  const session = options.channelSession;
+  const defaults = options.runtimeDefaults;
+  return {
+    model: defaults?.model ?? session?.model,
+    reasoningEffort: defaults?.reasoningEffort ?? session?.reasoningEffort,
+    approvalPolicy: defaults?.approvalPolicy ?? session?.approvalPolicy,
+    sandbox: defaults?.sandbox ?? session?.sandbox
+  };
+}
 function isUpdateRunnerConfigControl(control) {
   return control.type === "update_runner_config";
 }
@@ -8840,6 +9096,30 @@ function normalizeAllowedCwds(values) {
     return normalized === "" ? [] : [normalized];
   })));
 }
+function configuredAllowedCwds(values) {
+  const allowedCwds = [];
+  const missingAllowedCwds = [];
+  for (const value of normalizeAllowedCwds(values)) {
+    const absolutePath = resolve5(expandUserPath(value));
+    try {
+      const realPath = realpathSync4(absolutePath);
+      allowedCwds.push(...realPath === absolutePath ? [realPath] : [realPath, absolutePath]);
+    } catch (error) {
+      if (isMissingAllowedCwdError(error)) {
+        missingAllowedCwds.push(absolutePath);
+        continue;
+      }
+      throw error;
+    }
+  }
+  return {
+    allowedCwds: normalizeAllowedCwds(allowedCwds),
+    missingAllowedCwds: normalizeAllowedCwds(missingAllowedCwds)
+  };
+}
+function isMissingAllowedCwdError(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "EACCES" || error.code === "ELOOP" || error.code === "EIO");
+}
 function allowedCwdSuggestions(cwd, allowedCwds) {
   return normalizeAllowedCwds([cwd, ...allowedCwds]);
 }
@@ -8988,14 +9268,14 @@ import {
   existsSync as existsSync5,
   mkdirSync as mkdirSync6,
   readFileSync as readFileSync4,
-  realpathSync as realpathSync4,
+  realpathSync as realpathSync5,
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { dirname as dirname5, resolve as resolve5 } from "node:path";
+import { dirname as dirname5, resolve as resolve6 } from "node:path";
 function localConfigPath(env = process.env) {
   const override = env.LINZUMI_CONFIG_FILE;
-  return override !== undefined && override.trim() !== "" ? resolve5(expandUserPath(override)) : resolve5(homedir6(), ".linzumi", "config.json");
+  return override !== undefined && override.trim() !== "" ? resolve6(expandUserPath(override)) : resolve6(homedir6(), ".linzumi", "config.json");
 }
 function readLocalConfig(path = localConfigPath()) {
   if (!existsSync5(path)) {
@@ -9010,32 +9290,36 @@ function readLocalConfig(path = localConfigPath()) {
     allowedCwds: uniqueStrings(parsed.allowedCwds)
   };
 }
-function readConfiguredAllowedCwdState(path = localConfigPath()) {
+function readConfiguredAllowedCwdDetails(path = localConfigPath()) {
   const allowedCwds = [];
-  const missingCwds = [];
+  const missingAllowedCwds = [];
   for (const cwd of readLocalConfig(path).allowedCwds) {
+    const absolutePath = resolve6(expandUserPath(cwd));
     try {
-      const absolutePath = resolve5(expandUserPath(cwd));
-      const realPath = realpathSync4(absolutePath);
+      const realPath = realpathSync5(absolutePath);
       allowedCwds.push(...realPath === absolutePath ? [realPath] : [realPath, absolutePath]);
-    } catch (_error) {
-      missingCwds.push(cwd);
+    } catch (error) {
+      if (isMissingPathError(error)) {
+        missingAllowedCwds.push(absolutePath);
+        continue;
+      }
+      throw error;
     }
   }
   return {
     allowedCwds: uniqueStrings(allowedCwds),
-    missingCwds: uniqueStrings(missingCwds)
+    missingAllowedCwds: uniqueStrings(missingAllowedCwds)
   };
 }
 function addAllowedCwd(pathValue, path = localConfigPath()) {
-  const normalizedPath = realpathSync4(resolve5(expandUserPath(pathValue)));
+  const normalizedPath = realpathSync5(resolve6(expandUserPath(pathValue)));
   const config = readLocalConfig(path);
   const allowedCwds = uniqueStrings([...config.allowedCwds, normalizedPath]);
   writeLocalConfig({ version: 1, allowedCwds }, path);
   return allowedCwds;
 }
 function removeAllowedCwd(pathValue, path = localConfigPath()) {
-  const requestedPath = resolve5(expandUserPath(pathValue));
+  const requestedPath = resolve6(expandUserPath(pathValue));
   const normalizedRequest = realpathOrResolved(requestedPath);
   const config = readLocalConfig(path);
   const allowedCwds = config.allowedCwds.filter((cwd) => {
@@ -9058,11 +9342,14 @@ function uniqueStrings(values) {
     ...new Set(values.map((value) => value.trim()).filter((value) => value !== ""))
   ];
 }
+function isMissingPathError(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "EACCES" || error.code === "ELOOP" || error.code === "EIO");
+}
 function realpathOrResolved(pathValue) {
   try {
-    return realpathSync4(resolve5(expandUserPath(pathValue)));
+    return realpathSync5(resolve6(expandUserPath(pathValue)));
   } catch (_error) {
-    return resolve5(expandUserPath(pathValue));
+    return resolve6(expandUserPath(pathValue));
   }
 }
 
@@ -9460,7 +9747,7 @@ async function runClaim(command, deps) {
     workspaceName: stringValue(response.workspace_name),
     channelId: stringValue(response.channel_id),
     ownerUsername: stringValue(response.owner_username),
-    channelUrl: requiredString(response, "channel_url"),
+    channelUrl: stringValue(response.channel_url),
     loginUrl: requiredString(response, "login_url"),
     supportChannelId: requiredString(response, "support_channel_id"),
     supportChannelUrl: requiredString(response, "support_channel_url"),
@@ -9479,8 +9766,10 @@ async function runClaim(command, deps) {
   deps.stdout.write(`login_url: ${tokenFile.loginUrl}
 `);
   writeHumanLoginUrlWarning(deps);
-  deps.stdout.write(`channel_url: ${tokenFile.channelUrl}
+  if (tokenFile.channelUrl !== undefined) {
+    deps.stdout.write(`channel_url: ${tokenFile.channelUrl}
 `);
+  }
   deps.stdout.write(`support_channel_id: ${tokenFile.supportChannelId}
 `);
   deps.stdout.write(`support_channel_url: ${tokenFile.supportChannelUrl}
@@ -9749,7 +10038,7 @@ function readStoredAgentTokenFile(path, readTextFile = readOptionalTextFile) {
     workspaceName: stringValue(parsed.workspaceName),
     channelId: stringValue(parsed.channelId),
     ownerUsername: stringValue(parsed.ownerUsername),
-    channelUrl: requiredString(parsed, "channelUrl"),
+    channelUrl: stringValue(parsed.channelUrl),
     loginUrl: requiredString(parsed, "loginUrl"),
     supportChannelId: requiredString(parsed, "supportChannelId"),
     supportChannelUrl: stringValue(parsed.supportChannelUrl),
@@ -9803,7 +10092,7 @@ Launch target:
 
 // src/helloLinzumiProject.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname7, join as join9, resolve as resolve6 } from "node:path";
+import { dirname as dirname7, join as join9, resolve as resolve7 } from "node:path";
 import { fileURLToPath } from "node:url";
 var defaultHelloLinzumiProjectDir = "/tmp/hello_linzumi";
 var defaultHelloLinzumiProjectName = "hello_linzumi";
@@ -9837,10 +10126,10 @@ function resolveHelloProjectRoot(options) {
     throw new Error("linzumi init-hello-linzumi-demo-app accepts either --dir or --parent-dir/--name, not both");
   }
   if (options.rootPath !== undefined) {
-    return resolve6(options.rootPath);
+    return resolve7(options.rootPath);
   }
   const name = normalizeProjectName(options.name ?? defaultHelloLinzumiProjectName);
-  return resolve6(options.parentDir ?? defaultHelloLinzumiParentDir, name);
+  return resolve7(options.parentDir ?? defaultHelloLinzumiParentDir, name);
 }
 function normalizeProjectName(value) {
   const name = value.trim();
@@ -10375,7 +10664,7 @@ import {
   writeFileSync as writeFileSync8
 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname8, join as join10, resolve as resolve7 } from "node:path";
+import { dirname as dirname8, join as join10, resolve as resolve8 } from "node:path";
 import { execFileSync, spawn as spawn7 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var connectedMarker = "Runner connected:";
@@ -10391,7 +10680,7 @@ function defaultCommanderLogFile(runnerId, statusDir = commanderStatusDir()) {
 function startCommanderDaemon(options) {
   const statusDir = options.statusDir ?? commanderStatusDir();
   const statusFile = commanderStatusFile(options.runnerId, statusDir);
-  const logFile = resolve7(options.logFile ?? defaultCommanderLogFile(options.runnerId, statusDir));
+  const logFile = resolve8(options.logFile ?? defaultCommanderLogFile(options.runnerId, statusDir));
   const entrypoint = options.entrypoint ?? currentEntrypoint();
   const nodeBin = options.nodeBin ?? process.execPath;
   const command = [
@@ -10588,7 +10877,7 @@ function safeRunnerId(runnerId) {
 }
 async function waitForFileChangeOrTimeout(path, deadline, now, ready2 = () => false) {
   const remaining = Math.max(0, deadline - now());
-  await new Promise((resolve8) => {
+  await new Promise((resolve9) => {
     let resolved = false;
     let watcher;
     const finish = () => {
@@ -10598,7 +10887,7 @@ async function waitForFileChangeOrTimeout(path, deadline, now, ready2 = () => fa
       resolved = true;
       watcher?.close();
       clearTimeout(timer);
-      resolve8();
+      resolve9();
     };
     const timer = setTimeout(finish, remaining);
     try {
@@ -10678,7 +10967,7 @@ function isMainModule() {
   if (scriptPath === undefined) {
     return false;
   }
-  return fileURLToPath3(import.meta.url) === resolve8(scriptPath);
+  return fileURLToPath3(import.meta.url) === resolve9(scriptPath);
 }
 async function main(args) {
   const parsed = parseCommand(args);
@@ -10687,7 +10976,7 @@ async function main(args) {
       process.stdout.write(connectGuideText());
       return;
     case "version":
-      process.stdout.write(`linzumi 0.0.39-beta
+      process.stdout.write(`linzumi 0.0.41-beta
 `);
       return;
     case "auth":
@@ -10840,7 +11129,7 @@ function runPathsCommand(args) {
       if (pathValue === undefined || pathValue.trim() === "") {
         throw new Error("missing path for linzumi paths add");
       }
-      const trustedPath = realpathSync5(resolve8(expandUserPath(pathValue)));
+      const trustedPath = realpathSync6(resolve9(expandUserPath(pathValue)));
       addAllowedCwd(pathValue);
       process.stdout.write(`Trusted ${trustedPath}
 `);
@@ -11030,6 +11319,7 @@ async function parseStartRunnerArgs(args, deps = {
     kandanUrl,
     token: targetToken,
     runnerId: stringValue3(values, "runner-id") ?? `runner-${randomUUID3()}`,
+    workspaceSlug: target.workspaceSlug,
     cwd,
     codexBin,
     codexUrl: stringValue3(values, "codex-url"),
@@ -11042,6 +11332,7 @@ async function parseStartRunnerArgs(args, deps = {
     editorRuntime: editorRuntime.runtime,
     socketFactory: trustedWebSocketFactory(kandanTlsTrustFromEnv()),
     dependencyStatus,
+    runtimeDefaults: runnerRuntimeDefaultsFromValues(values),
     channelSession: {
       workspaceSlug: target.workspaceSlug,
       channelSlug: target.channelSlug,
@@ -11073,12 +11364,23 @@ async function parseAgentRunnerArgs(args, deps = {
   const tokenFilePath = stringValue3(values, "agent-token-file") ?? defaultAgentTokenFilePath();
   const tokenFile = readStoredAgentTokenFile(tokenFilePath, deps.readTextFile);
   const channelSlug = tokenFile.channelId;
-  const listenUser = channelSlug === undefined ? undefined : stringValue3(values, "listen-user") ?? requiredStoredOwnerUsername(tokenFile.ownerUsername);
+  rejectWorkspaceCommanderThreadFlags(values, channelSlug);
+  const channelSession = channelSlug === undefined ? undefined : {
+    workspaceSlug: tokenFile.workspaceId,
+    channelSlug,
+    kandanThreadId: stringValue3(values, "linzumi-thread-id"),
+    listenUser: stringValue3(values, "listen-user") ?? requiredStoredOwnerUsername(tokenFile.ownerUsername),
+    model: stringValue3(values, "model"),
+    reasoningEffort: stringValue3(values, "reasoning-effort"),
+    sandbox: stringValue3(values, "sandbox"),
+    approvalPolicy: stringValue3(values, "approval-policy"),
+    streamFlushMs: positiveIntegerValue(values, "stream-flush-ms")
+  };
   const kandanUrl = stringValue3(values, "linzumi-url") ?? agentApiUrlToKandanUrl(tokenFile.apiUrl);
   const requestedCwdValue = cwdArg ?? stringValue3(values, "cwd");
   const requestedCwd = resolveUserPath(requestedCwdValue ?? process.cwd());
-  const configuredAllowedCwdState = values.has("allowed-cwd") || requestedCwdValue !== undefined ? { allowedCwds: [], missingCwds: [] } : readConfiguredAllowedCwdState();
-  const allowedCwds = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(parseAllowedCwdList(stringValue3(values, "allowed-cwd"))) : requestedCwdValue === undefined ? configuredAllowedCwdState.allowedCwds : assertConfiguredAllowedCwds([requestedCwd]);
+  const configuredAllowedCwds2 = requestedCwdValue === undefined && !values.has("allowed-cwd") ? readConfiguredAllowedCwdDetails() : { allowedCwds: [], missingAllowedCwds: [] };
+  const allowedCwds = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(parseAllowedCwdList(stringValue3(values, "allowed-cwd"))) : requestedCwdValue === undefined ? configuredAllowedCwds2.allowedCwds.length > 0 ? [...configuredAllowedCwds2.allowedCwds] : assertConfiguredAllowedCwds([requestedCwd]) : assertConfiguredAllowedCwds([requestedCwd]);
   const cwd = allowedCwds[0] ?? requestedCwd;
   const codexBin = stringValue3(values, "codex-bin") ?? "codex";
   const customCodeServerBin = stringValue3(values, "code-server-bin");
@@ -11105,6 +11407,7 @@ async function parseAgentRunnerArgs(args, deps = {
     kandanUrl,
     token: tokenFile.commanderToken,
     runnerId: stringValue3(values, "runner-id") ?? `agent-runner-${randomUUID3()}`,
+    workspaceSlug: tokenFile.workspaceId,
     cwd,
     codexBin,
     codexUrl: stringValue3(values, "codex-url"),
@@ -11112,24 +11415,14 @@ async function parseAgentRunnerArgs(args, deps = {
     fast: values.get("fast") === true,
     logFile: stringValue3(values, "log-file"),
     allowedCwds,
-    missingConfiguredAllowedCwds: configuredAllowedCwdState.missingCwds,
+    missingAllowedCwds: configuredAllowedCwds2.missingAllowedCwds,
     allowedForwardPorts: parseAllowedPortList(stringValue3(values, "forward-port")),
     codeServerBin: editorRuntime.codeServerBin,
     editorRuntime: editorRuntime.runtime,
     socketFactory: trustedWebSocketFactory(kandanTlsTrustFromEnv()),
     dependencyStatus,
-    workspaceSlug: tokenFile.workspaceId,
-    channelSession: channelSlug === undefined || listenUser === undefined ? undefined : {
-      workspaceSlug: tokenFile.workspaceId,
-      channelSlug,
-      kandanThreadId: stringValue3(values, "linzumi-thread-id"),
-      listenUser,
-      model: stringValue3(values, "model"),
-      reasoningEffort: stringValue3(values, "reasoning-effort"),
-      sandbox: stringValue3(values, "sandbox"),
-      approvalPolicy: stringValue3(values, "approval-policy"),
-      streamFlushMs: positiveIntegerValue(values, "stream-flush-ms")
-    }
+    runtimeDefaults: runnerRuntimeDefaultsFromValues(values),
+    channelSession
   };
 }
 function readAgentTokenTextFile(path) {
@@ -11147,6 +11440,12 @@ function rejectAgentRunnerTargetingFlags(values) {
     throw new Error(`linzumi commander uses the claimed human Commander token scope; remove ${unsupportedFlags.map((flag) => `--${flag}`).join(", ")}.`);
   }
 }
+function rejectWorkspaceCommanderThreadFlags(values, channelSlug) {
+  if (channelSlug !== undefined || !values.has("linzumi-thread-id")) {
+    return;
+  }
+  throw new Error("linzumi commander cannot bind --linzumi-thread-id because the agent token file has no channelId");
+}
 function requiredStoredOwnerUsername(ownerUsername) {
   if (ownerUsername !== undefined) {
     return ownerUsername;
@@ -11203,7 +11502,7 @@ async function parseRunnerArgs(args, deps = {
     process.exit(0);
   }
   if (values.get("version") === true) {
-    process.stdout.write(`linzumi 0.0.39-beta
+    process.stdout.write(`linzumi 0.0.41-beta
 `);
     process.exit(0);
   }
@@ -11211,10 +11510,8 @@ async function parseRunnerArgs(args, deps = {
   const kandanUrl = required(values, "linzumi-url");
   const cwd = stringValue3(values, "cwd") ?? process.cwd();
   const cwdAllowedCwds = assertConfiguredAllowedCwds([cwd]);
-  const configuredAllowedCwdState = values.has("allowed-cwd") ? {
-    allowedCwds: assertConfiguredAllowedCwds(parseAllowedCwdList(stringValue3(values, "allowed-cwd"))),
-    missingCwds: []
-  } : readConfiguredAllowedCwdState();
+  const localConfiguredAllowedCwds = values.has("allowed-cwd") ? { allowedCwds: [], missingAllowedCwds: [] } : readConfiguredAllowedCwdDetails();
+  const configuredAllowedCwds2 = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(parseAllowedCwdList(stringValue3(values, "allowed-cwd"))) : [...localConfiguredAllowedCwds.allowedCwds];
   const codexBin = stringValue3(values, "codex-bin") ?? "codex";
   const customCodeServerBin = stringValue3(values, "code-server-bin");
   const explicitToken = stringValue3(values, "token");
@@ -11254,17 +11551,26 @@ async function parseRunnerArgs(args, deps = {
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
     logFile: stringValue3(values, "log-file"),
-    allowedCwds: Array.from(new Set([...cwdAllowedCwds, ...configuredAllowedCwdState.allowedCwds])),
-    missingConfiguredAllowedCwds: configuredAllowedCwdState.missingCwds,
+    allowedCwds: Array.from(new Set([...cwdAllowedCwds, ...configuredAllowedCwds2])),
+    missingAllowedCwds: localConfiguredAllowedCwds.missingAllowedCwds,
     allowedForwardPorts: parseAllowedPortList(stringValue3(values, "forward-port")),
     codeServerBin: editorRuntime.codeServerBin,
     editorRuntime: editorRuntime.runtime,
     socketFactory: trustedWebSocketFactory(kandanTlsTrustFromEnv()),
     dependencyStatus,
     workspaceSlug: channelSession?.workspaceSlug ?? singleWorkspaceScopeFromAccessToken(token),
+    runtimeDefaults: runnerRuntimeDefaultsFromValues(values),
     channelSession
   };
 }
+function runnerRuntimeDefaultsFromValues(values) {
+  return {
+    model: stringValue3(values, "model"),
+    reasoningEffort: stringValue3(values, "reasoning-effort"),
+    approvalPolicy: stringValue3(values, "approval-policy"),
+    sandbox: stringValue3(values, "sandbox")
+  };
+}
 function strictFlagValues(args, definitions = flagDefinitions) {
   const values = new Map;
   for (let index = 0;index < args.length; index += 1) {
@@ -11359,9 +11665,9 @@ function resolveUserPath(pathValue) {
     return homedir9();
   }
   if (pathValue.startsWith("~/")) {
-    return resolve8(homedir9(), pathValue.slice(2));
+    return resolve9(homedir9(), pathValue.slice(2));
   }
-  return resolve8(pathValue);
+  return resolve9(pathValue);
 }
 function parseChannelSession(values, token, target) {
   if (target === undefined) {
@@ -11645,10 +11951,10 @@ Usage:
 
 What it does:
   Starts this computer as the claimed human's scoped Linzumi Commander. The command
-  reads ~/.linzumi/agent-token.json, uses its workspace/channel scope, reads
-  trusted folders from ~/.linzumi/config.json when no folder is passed, and
-  listens only to the owning human recorded during claim unless --listen-user is
-  passed.
+  reads ~/.linzumi/agent-token.json, connects to its workspace even when no
+  channel is assigned, reads trusted folders from ~/.linzumi/config.json when no
+  folder is passed, and uses the token's channel scope for channel-bound startup
+  when one is present.
 
 Options:
   --agent-token-file <path>   Agent token cache, default ~/.linzumi/agent-token.json