@linzumi/cli 0.0.90-beta → 0.0.92-beta

package/dist/index.js

@@ -5470,6 +5470,19 @@ function handleCodexNotification(state, event, deps, effects) {
     failTurn(state, turn, failureOutcome, failureReason(params), effects, deps);
     return;
   }
+  if (method === "error") {
+    const upstreamReason = upstreamErrorReason(params);
+    if (upstreamReason !== void 0) {
+      turn.lastUpstreamErrorReason = upstreamReason;
+      effects.push(
+        log("codex.upstream_error_captured", {
+          turn_id: turn.turnId,
+          reason: upstreamReason
+        })
+      );
+    }
+    return;
+  }
   if (method === "item/completed" || method === "response_item") {
     handleItemCompleted(turn, params, deps, effects);
     return;
@@ -5520,6 +5533,7 @@ function createTurn(state, turnId, sourceSeq) {
     sourceSeq,
     phase: "active",
     protocolFailureReason: void 0,
+    lastUpstreamErrorReason: void 0,
     items: []
   };
   state.turns.set(turnId, turn);
@@ -5905,7 +5919,7 @@ function handleSnapshot(state, turnId, snapshot, deps, effects) {
   const assistantResponseSeen = turn.items.some(
     (item) => item.identity.streamKind === "assistant" && item.posted
   ) || projected.some((proj) => proj.streamKind === "assistant");
-  const terminalFailureReason = turn.protocolFailureReason ?? (assistantResponseSeen ? void 0 : completedWithoutAssistantOutputReason);
+  const terminalFailureReason = turn.protocolFailureReason ?? (assistantResponseSeen ? void 0 : turn.lastUpstreamErrorReason ?? completedWithoutAssistantOutputReason);
   if (turn.protocolFailureReason !== void 0) {
     effects.push(
       log("codex.turn_completed_with_protocol_failure", {
@@ -6024,6 +6038,25 @@ function nextStreamSnapshotIndex(item) {
 function failureReason(params) {
   return stringValue(params.reason) ?? stringValue(params.message) ?? stringValue(objectValue(params.error)?.message) ?? stringValue(params.error) ?? "codex_turn_aborted";
 }
+function upstreamErrorReason(params) {
+  const summaryRaw = stringValue(params.diagnostic_summary) ?? stringValue(objectValue(objectValue(params.diagnostic_payload)?.error)?.message);
+  if (summaryRaw === void 0) {
+    return void 0;
+  }
+  const cleaned = summaryRaw.replace(/<[^>]*>/g, " ").replace(/data:[^"' )]+/g, "").replace(/\s+/g, " ").trim().slice(0, 180);
+  if (cleaned.length === 0) {
+    return void 0;
+  }
+  const status = upstreamErrorHttpStatus(params);
+  return status === void 0 ? `Model gateway error: ${cleaned}` : `Model gateway error (HTTP ${status}): ${cleaned}`;
+}
+function upstreamErrorHttpStatus(params) {
+  const error = objectValue(objectValue(params.diagnostic_payload)?.error);
+  const info = objectValue(error?.codexErrorInfo);
+  const disconnected = objectValue(info?.responseStreamDisconnected);
+  const code = disconnected?.httpStatusCode;
+  return typeof code === "number" ? code : void 0;
+}
 function log(event, fields) {
   return { type: "log", event, fields };
 }
@@ -6057,6 +6090,7 @@ var init_transition = __esm({
       "turn/aborted",
       "turn/canceled",
       "turn/cancelled",
+      "error",
       "item/agentMessage/delta",
       "item/reasoning/textDelta",
       "item/commandExecution/outputDelta",
@@ -11665,6 +11699,233 @@ var init_channelSession = __esm({
   }
 });
 
+// src/runnerThreadSessionRegistry.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, renameSync, writeFileSync } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { dirname as dirname3, join as join6 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+function runnerThreadSessionRegistryDir() {
+  const override = process.env.LINZUMI_SESSION_REGISTRY_DIR?.trim();
+  if (override !== void 0 && override !== "") {
+    return override;
+  }
+  return join6(homedir5(), ".linzumi", "session-registry");
+}
+function runnerThreadSessionRegistryPath(runnerId) {
+  const sanitized = runnerId.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, 80);
+  const digest = createHash4("sha256").update(runnerId).digest("hex").slice(0, 8);
+  const stem = sanitized === "" ? "runner" : sanitized;
+  return join6(runnerThreadSessionRegistryDir(), `${stem}.${digest}.json`);
+}
+function asString(value) {
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function asAgentProvider(value) {
+  return value === "codex" || value === "claude-code" ? value : void 0;
+}
+function parseRecord(value) {
+  if (!isJsonObject(value)) {
+    return void 0;
+  }
+  const workspace = asString(value.workspace);
+  const channel = asString(value.channel);
+  const kandanThreadId = asString(value.kandanThreadId);
+  const codexThreadId = asString(value.codexThreadId);
+  const cwd = asString(value.cwd);
+  const agentProvider = asAgentProvider(value.agentProvider);
+  const control = isJsonObject(value.control) ? value.control : void 0;
+  const updatedAtMs = typeof value.updatedAtMs === "number" && Number.isFinite(value.updatedAtMs) ? value.updatedAtMs : void 0;
+  if (workspace === void 0 || channel === void 0 || kandanThreadId === void 0 || codexThreadId === void 0 || cwd === void 0 || agentProvider === void 0 || control === void 0 || updatedAtMs === void 0) {
+    return void 0;
+  }
+  return {
+    workspace,
+    channel,
+    kandanThreadId,
+    codexThreadId,
+    cwd,
+    agentProvider,
+    control,
+    updatedAtMs
+  };
+}
+function readRegistryFile(path2, log2) {
+  const records = /* @__PURE__ */ new Map();
+  let raw;
+  try {
+    raw = readFileSync5(path2, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return records;
+    }
+    log2("session_registry.read_failed", {
+      path: path2,
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return records;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    log2("session_registry.parse_failed", {
+      path: path2,
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return records;
+  }
+  if (!isJsonObject(parsed) || parsed.version !== registryFileVersion || !isJsonObject(parsed.sessions)) {
+    return records;
+  }
+  for (const [key, value] of Object.entries(parsed.sessions)) {
+    const record = parseRecord(value);
+    if (record !== void 0 && record.kandanThreadId === key) {
+      records.set(key, record);
+    }
+  }
+  return records;
+}
+function createRunnerThreadSessionRegistryStore(path2, log2) {
+  const records = readRegistryFile(path2, log2);
+  const writeNow = () => {
+    const sessions = {};
+    for (const [key, record] of records) {
+      sessions[key] = {
+        workspace: record.workspace,
+        channel: record.channel,
+        kandanThreadId: record.kandanThreadId,
+        codexThreadId: record.codexThreadId,
+        cwd: record.cwd,
+        agentProvider: record.agentProvider,
+        control: record.control,
+        updatedAtMs: record.updatedAtMs
+      };
+    }
+    try {
+      mkdirSync2(dirname3(path2), { recursive: true });
+      const tmpPath = `${path2}.tmp`;
+      writeFileSync(
+        tmpPath,
+        `${JSON.stringify({ version: registryFileVersion, sessions })}
+`,
+        "utf8"
+      );
+      renameSync(tmpPath, path2);
+    } catch (error) {
+      log2("session_registry.write_failed", {
+        path: path2,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
+  return {
+    list: () => [...records.values()],
+    upsert: (record) => {
+      records.set(record.kandanThreadId, record);
+      writeNow();
+    },
+    remove: (kandanThreadId) => {
+      if (records.delete(kandanThreadId)) {
+        writeNow();
+      }
+    }
+  };
+}
+async function rehydrateThreadSessions(args) {
+  let rehydrated = 0;
+  let retiredDrained = 0;
+  let retiredStale = 0;
+  let retiredUnattachable = 0;
+  let failed = 0;
+  for (const record of args.records) {
+    const ageMs = args.nowMs - record.updatedAtMs;
+    if (ageMs > args.maxAgeMs) {
+      args.retire(record);
+      retiredStale += 1;
+      args.log("session_registry.retired_stale", {
+        workspace: record.workspace,
+        channel: record.channel,
+        thread_id: record.kandanThreadId,
+        age_ms: ageMs
+      });
+      continue;
+    }
+    const pendingRows = args.pendingDurableRowCount(record);
+    if (pendingRows <= 0) {
+      args.retire(record);
+      retiredDrained += 1;
+      args.log("session_registry.retired_drained", {
+        workspace: record.workspace,
+        channel: record.channel,
+        thread_id: record.kandanThreadId
+      });
+      continue;
+    }
+    args.log("session_registry.outbox_replay_started", {
+      workspace: record.workspace,
+      channel: record.channel,
+      thread_id: record.kandanThreadId,
+      codex_thread_id: record.codexThreadId,
+      pending_rows: pendingRows
+    });
+    let result;
+    try {
+      result = await args.attach(record);
+    } catch (error) {
+      args.log("session_registry.outbox_replay_failed", {
+        workspace: record.workspace,
+        channel: record.channel,
+        thread_id: record.kandanThreadId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      failed += 1;
+      continue;
+    }
+    if (result === "attached") {
+      rehydrated += 1;
+      args.log("session_registry.boot_rehydrated", {
+        workspace: record.workspace,
+        channel: record.channel,
+        thread_id: record.kandanThreadId,
+        codex_thread_id: record.codexThreadId,
+        pending_rows: pendingRows
+      });
+    } else if (result === "retire") {
+      args.retire(record);
+      retiredUnattachable += 1;
+      args.log("session_registry.retired_unattachable", {
+        workspace: record.workspace,
+        channel: record.channel,
+        thread_id: record.kandanThreadId
+      });
+    } else {
+      failed += 1;
+      args.log("session_registry.outbox_replay_failed", {
+        workspace: record.workspace,
+        channel: record.channel,
+        thread_id: record.kandanThreadId,
+        message: "attach_failed"
+      });
+    }
+  }
+  return {
+    rehydrated,
+    retiredDrained,
+    retiredStale,
+    retiredUnattachable,
+    failed
+  };
+}
+var registryFileVersion, defaultThreadSessionRehydrationMaxAgeMs;
+var init_runnerThreadSessionRegistry = __esm({
+  "src/runnerThreadSessionRegistry.ts"() {
+    "use strict";
+    init_protocol();
+    registryFileVersion = 1;
+    defaultThreadSessionRehydrationMaxAgeMs = 24 * 60 * 60 * 1e3;
+  }
+});
+
 // src/claudeCodePipeline.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
@@ -12434,11 +12695,11 @@ var init_claudeCodePlanMirror = __esm({
 // src/runnerLogger.ts
 import { appendFileSync, openSync as openSync2 } from "node:fs";
 import { createWriteStream } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname3, join as join6 } from "node:path";
-import { mkdirSync as mkdirSync2 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname4, join as join7 } from "node:path";
+import { mkdirSync as mkdirSync3 } from "node:fs";
 function createRunnerLogger(logFile, consoleReporter) {
-  mkdirSync2(dirname3(logFile), { recursive: true });
+  mkdirSync3(dirname4(logFile), { recursive: true });
   const fd = openSync2(logFile, "a");
   const stream = createWriteStream("", { fd, flags: "a", autoClose: true });
   const logger = ((event, payload) => {
@@ -12458,7 +12719,7 @@ function createRunnerLogger(logFile, consoleReporter) {
 function writeCliAuditEvent(event, payload, options = {}) {
   const logFile = options.logFile ?? defaultCliAuditLogFile();
   try {
-    mkdirSync2(dirname3(logFile), { recursive: true });
+    mkdirSync3(dirname4(logFile), { recursive: true });
     appendFileSync(
       logFile,
       `${JSON.stringify({
@@ -12476,10 +12737,10 @@ function writeCliAuditEvent(event, payload, options = {}) {
 }
 function defaultCliAuditLogFile() {
   const override = process.env.LINZUMI_CLI_AUDIT_LOG?.trim();
-  return override === void 0 || override === "" ? join6(homedir5(), ".linzumi", "logs", "command-events.jsonl") : override;
+  return override === void 0 || override === "" ? join7(homedir6(), ".linzumi", "logs", "command-events.jsonl") : override;
 }
 function defaultRunnerLogFile() {
-  return join6(homedir5(), ".linzumi", "logs", "linzumi-runner.log");
+  return join7(homedir6(), ".linzumi", "logs", "linzumi-runner.log");
 }
 function redactForCliLog(value) {
   return redactObject(value);
@@ -12755,12 +13016,12 @@ var init_engineChildReaper = __esm({
 
 // src/claudeCodeLiveBashOutput.ts
 import {
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   rmSync,
-  writeFileSync,
+  writeFileSync as writeFileSync2,
   promises as fsPromises
 } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 function shellSingleQuoted(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
@@ -12885,13 +13146,13 @@ function createClaudeCodeLiveBashCapture(host) {
     isClaudeLiveBashWrappedCommand(command)) {
       return void 0;
     }
-    const file = join7(
+    const file = join8(
       host.captureDir,
       `${toolUseId.replaceAll(/[^\w-]/g, "_")}.out`
     );
     try {
-      mkdirSync3(host.captureDir, { recursive: true });
-      writeFileSync(file, "");
+      mkdirSync4(host.captureDir, { recursive: true });
+      writeFileSync2(file, "");
     } catch (error) {
       host.log?.("claude_live_bash.capture_file_failed", {
         tool_use_id: toolUseId,
@@ -13052,9 +13313,9 @@ var init_claudeCodeTurnStallWatchdog = __esm({
 });
 
 // src/claudeCodeSession.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join9 } from "node:path";
 function claudeCodeSettingSources() {
   return ["user", "project", "local"];
 }
@@ -13198,7 +13459,7 @@ function claudeCodeRateLimitSummaryText(rateLimit, nowMs) {
 async function probeClaudeCodeAvailability(args) {
   if (!hasClaudeCodeAuthHint(process.env, {
     cwd: args.cwd,
-    homeDir: homedir6(),
+    homeDir: homedir7(),
     platform: process.platform,
     fileExists: existsSync4,
     readTextFile: readTextFileIfPresent
@@ -13231,7 +13492,7 @@ async function probeClaudeCodeAvailability(args) {
   }
 }
 function hasClaudeCodeAuthHint(env, deps) {
-  const configDir = env.CLAUDE_CONFIG_DIR ?? join8(deps.homeDir, ".claude");
+  const configDir = env.CLAUDE_CONFIG_DIR ?? join9(deps.homeDir, ".claude");
   return hasAnthropicCredentialEnv(env) || hasClaudeCloudProviderEnv(env) || hasClaudeCodeFileCredential(configDir, deps) || hasClaudeCodeApiKeyHelper(configDir, deps) || hasMacClaudeCodeKeychainAnchor(deps);
 }
 function claudeCodePolicyDeferHooks() {
@@ -13266,14 +13527,14 @@ function hasClaudeCloudProviderEnv(env) {
   return trueishEnv(env.CLAUDE_CODE_USE_BEDROCK) || trueishEnv(env.CLAUDE_CODE_USE_VERTEX) || trueishEnv(env.CLAUDE_CODE_USE_FOUNDRY) || trueishEnv(env.CLAUDE_CODE_USE_ANTHROPIC_AWS) || trueishEnv(env.CLAUDE_CODE_USE_MANTLE);
 }
 function hasClaudeCodeFileCredential(configDir, deps) {
-  return deps.fileExists(join8(configDir, ".credentials.json")) || deps.fileExists(join8(configDir, ".claude.json")) || deps.fileExists(join8(deps.homeDir, ".claude.json"));
+  return deps.fileExists(join9(configDir, ".credentials.json")) || deps.fileExists(join9(configDir, ".claude.json")) || deps.fileExists(join9(deps.homeDir, ".claude.json"));
 }
 function hasClaudeCodeApiKeyHelper(configDir, deps) {
   return [
-    join8(configDir, "settings.json"),
-    join8(configDir, "settings.local.json"),
-    join8(deps.cwd, ".claude", "settings.json"),
-    join8(deps.cwd, ".claude", "settings.local.json")
+    join9(configDir, "settings.json"),
+    join9(configDir, "settings.local.json"),
+    join9(deps.cwd, ".claude", "settings.json"),
+    join9(deps.cwd, ".claude", "settings.local.json")
   ].some((path2) => settingsFileHasApiKeyHelper(path2, deps));
 }
 function settingsFileHasApiKeyHelper(path2, deps) {
@@ -13293,14 +13554,14 @@ function hasMacClaudeCodeKeychainAnchor(deps) {
     return false;
   }
   return [
-    join8(deps.homeDir, "Library", "Application Support", "claude-cli-nodejs"),
-    join8(deps.homeDir, "Library", "Application Support", "Claude"),
-    join8(deps.homeDir, "Library", "Preferences", "claude-cli-nodejs")
+    join9(deps.homeDir, "Library", "Application Support", "claude-cli-nodejs"),
+    join9(deps.homeDir, "Library", "Application Support", "Claude"),
+    join9(deps.homeDir, "Library", "Preferences", "claude-cli-nodejs")
   ].some((path2) => deps.fileExists(path2));
 }
 function readTextFileIfPresent(path2) {
   try {
-    return readFileSync5(path2, "utf8");
+    return readFileSync6(path2, "utf8");
   } catch (_error) {
     return void 0;
   }
@@ -14214,10 +14475,10 @@ var init_engineParentDeathWatchdog = __esm({
 import {
   spawn as spawn2
 } from "node:child_process";
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 import { createServer } from "node:net";
-import { homedir as homedir7 } from "node:os";
-import { join as join9 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { join as join10 } from "node:path";
 import { WebSocket as NodeWebSocket } from "ws";
 async function chooseLoopbackPort() {
   return new Promise((resolve12, reject) => {
@@ -14423,6 +14684,7 @@ function codexAppServerArgs(listenUrl, options = {}) {
 }
 function codexConfigArgs(options) {
   return [
+    ...codexDisableAppsConfigArgs,
     ...options.model === void 0 ? [] : ["-c", `model=${JSON.stringify(options.model)}`],
     ...options.reasoningEffort === void 0 ? [] : [
       "-c",
@@ -14467,10 +14729,10 @@ function resolveForwardableOpenAiApiKey(env = process.env) {
     return fromEnv;
   }
   const codexHomeRaw = env.CODEX_HOME?.trim();
-  const codexHome = codexHomeRaw !== void 0 && codexHomeRaw !== "" ? codexHomeRaw : join9(homedir7(), ".codex");
+  const codexHome = codexHomeRaw !== void 0 && codexHomeRaw !== "" ? codexHomeRaw : join10(homedir8(), ".codex");
   let raw;
   try {
-    raw = readFileSync6(join9(codexHome, "auth.json"), "utf8");
+    raw = readFileSync7(join10(codexHome, "auth.json"), "utf8");
   } catch (_error) {
     return void 0;
   }
@@ -14795,7 +15057,7 @@ function readyzUrlForWebsocket(websocketUrl) {
   parsed.hash = "";
   return parsed.toString();
 }
-var codexAppServerWatchdogPollMs, blockedCodexAppServerEnvKeys;
+var codexAppServerWatchdogPollMs, blockedCodexAppServerEnvKeys, codexDisableAppsConfigArgs;
 var init_codexAppServer = __esm({
   "src/codexAppServer.ts"() {
     "use strict";
@@ -14809,28 +15071,32 @@ var init_codexAppServer = __esm({
       "LINZUMI_MCP_ACCESS_TOKEN",
       "LINZUMI_MCP_OWNER_USERNAME"
     ];
+    codexDisableAppsConfigArgs = [
+      "-c",
+      "features.apps=false"
+    ];
   }
 });
 
 // src/codexProjectTrust.ts
 import {
   existsSync as existsSync5,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync7,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync8,
   realpathSync,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join10, resolve as resolve3 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { join as join11, resolve as resolve3 } from "node:path";
 function ensureCodexProjectTrusted(projectPath, options = {}) {
   const trustedPath = realpathSync(resolve3(projectPath));
-  const configHome = options.configHome ?? process.env.CODEX_HOME ?? join10(homedir8(), ".codex");
-  const configPath = join10(configHome, "config.toml");
-  const currentConfig = existsSync5(configPath) ? readFileSync7(configPath, "utf8") : "";
+  const configHome = options.configHome ?? process.env.CODEX_HOME ?? join11(homedir9(), ".codex");
+  const configPath = join11(configHome, "config.toml");
+  const currentConfig = existsSync5(configPath) ? readFileSync8(configPath, "utf8") : "";
   const nextConfig = codexConfigWithTrustedProject(currentConfig, trustedPath);
   if (nextConfig !== currentConfig) {
-    mkdirSync4(configHome, { recursive: true });
-    writeFileSync2(configPath, nextConfig);
+    mkdirSync5(configHome, { recursive: true });
+    writeFileSync3(configPath, nextConfig);
   }
   return trustedPath;
 }
@@ -15175,7 +15441,7 @@ var init_codexNotificationConsoleStats = __esm({
 
 // src/localCapabilities.ts
 import { realpathSync as realpathSync2 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
+import { homedir as homedir10 } from "node:os";
 import { isAbsolute as isAbsolute3, relative as relative2, resolve as resolve4 } from "node:path";
 function parseAllowedCwdList(value) {
   if (value === void 0) {
@@ -15224,7 +15490,7 @@ function expandUserPath(pathValue) {
 }
 function currentHomeDirectory() {
   const configuredHome = process.env.HOME;
-  return configuredHome === void 0 || configuredHome.trim() === "" ? homedir9() : configuredHome;
+  return configuredHome === void 0 || configuredHome.trim() === "" ? homedir10() : configuredHome;
 }
 function resolveAllowedCwd(requestedCwd, allowedRoots) {
   if (requestedCwd === void 0 || requestedCwd.trim() === "") {
@@ -15782,17 +16048,17 @@ import {
   chmodSync,
   existsSync as existsSync6,
   linkSync,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync8,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync9,
   realpathSync as realpathSync3,
   unlinkSync,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { basename as basename5, dirname as dirname4, join as join11, resolve as resolve5 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { basename as basename5, dirname as dirname5, join as join12, resolve as resolve5 } from "node:path";
 function localConfigPath(env = process.env) {
   const override = env.LINZUMI_CONFIG_FILE;
-  return override !== void 0 && override.trim() !== "" ? resolve5(expandUserPath(override)) : resolve5(homedir10(), ".linzumi", "config.json");
+  return override !== void 0 && override.trim() !== "" ? resolve5(expandUserPath(override)) : resolve5(homedir11(), ".linzumi", "config.json");
 }
 function localConfigScopeKey(linzumiUrl) {
   const normalizedUrl = kandanHttpBaseUrl(linzumiUrl);
@@ -15873,21 +16139,21 @@ function ensureLocalRunnerId(path2 = localConfigPath(), createRunnerId = default
 }
 function localMachineIdSeedPath(configPath = localConfigPath(), linzumiUrl) {
   if (linzumiUrl !== void 0 && localConfigScopeKey(linzumiUrl) !== prodConfigScope) {
-    return join11(
-      dirname4(configPath),
+    return join12(
+      dirname5(configPath),
       `${basename5(configPath)}.${localConfigScopeFileStem(linzumiUrl)}.machine-id`
     );
   }
-  return join11(dirname4(configPath), `${basename5(configPath)}.machine-id`);
+  return join12(dirname5(configPath), `${basename5(configPath)}.machine-id`);
 }
 function localRunnerIdSeedPath(configPath = localConfigPath(), linzumiUrl) {
   if (linzumiUrl !== void 0 && localConfigScopeKey(linzumiUrl) !== prodConfigScope) {
-    return join11(
-      dirname4(configPath),
+    return join12(
+      dirname5(configPath),
       `${basename5(configPath)}.${localConfigScopeFileStem(linzumiUrl)}.runner-id`
     );
   }
-  return join11(dirname4(configPath), `${basename5(configPath)}.runner-id`);
+  return join12(dirname5(configPath), `${basename5(configPath)}.runner-id`);
 }
 function readConfiguredAllowedCwdDetailsForLinzumiUrl(linzumiUrl, path2 = localConfigPath()) {
   return readConfiguredAllowedCwdDetailsFromConfig(
@@ -16017,7 +16283,7 @@ function writeLocalSignupAuth(auth, path2 = localConfigPath()) {
     version: 1,
     signupAuth: nextSignupAuth
   };
-  mkdirSync5(dirname4(path2), { recursive: true });
+  mkdirSync6(dirname5(path2), { recursive: true });
   writeLocalConfigJson(path2, next);
   return signupAuthFromJson(nextSignupAuth);
 }
@@ -16025,7 +16291,7 @@ function writeLocalConfigJson(path2, payload) {
   if (existsSync6(path2)) {
     chmodSync(path2, localConfigFileMode);
   }
-  writeFileSync3(path2, `${JSON.stringify(payload, null, 2)}
+  writeFileSync4(path2, `${JSON.stringify(payload, null, 2)}
 `, {
     encoding: "utf8",
     mode: localConfigFileMode
@@ -16052,7 +16318,7 @@ function readLocalConfigFile(path2) {
   if (!existsSync6(path2)) {
     return { version: 1, allowedCwds: [] };
   }
-  const parsed = JSON.parse(readFileSync8(path2, "utf8"));
+  const parsed = JSON.parse(readFileSync9(path2, "utf8"));
   if (!isConfigPayload(parsed)) {
     throw new Error(`invalid Linzumi config: ${path2}`);
   }
@@ -16081,7 +16347,7 @@ function writeLocalConfigSection(config, path2, linzumiUrl) {
     version: 1,
     [scopeKey]: nextSection
   };
-  mkdirSync5(dirname4(path2), { recursive: true });
+  mkdirSync6(dirname5(path2), { recursive: true });
   writeLocalConfigJson(path2, next);
 }
 function isConfigPayload(value) {
@@ -16156,12 +16422,12 @@ function ensureLocalMachineIdSeed(configPath, createMachineId, linzumiUrl) {
   if (!machineIdValid(machineId)) {
     throw new Error(`invalid generated Linzumi machine id: ${machineId}`);
   }
-  mkdirSync5(dirname4(seedPath), { recursive: true });
-  const tempPath = join11(
-    dirname4(seedPath),
+  mkdirSync6(dirname5(seedPath), { recursive: true });
+  const tempPath = join12(
+    dirname5(seedPath),
     `.${basename5(seedPath)}.${process.pid}.${randomUUID2()}.tmp`
   );
-  writeFileSync3(tempPath, `${machineId}
+  writeFileSync4(tempPath, `${machineId}
 `, { encoding: "utf8", flag: "wx" });
   try {
     linkSync(tempPath, seedPath);
@@ -16184,12 +16450,12 @@ function ensureLocalRunnerIdSeed(configPath, createRunnerId, linzumiUrl) {
   if (!runnerIdValid(runnerId)) {
     throw new Error(`invalid generated Linzumi runner id: ${runnerId}`);
   }
-  mkdirSync5(dirname4(seedPath), { recursive: true });
-  const tempPath = join11(
-    dirname4(seedPath),
+  mkdirSync6(dirname5(seedPath), { recursive: true });
+  const tempPath = join12(
+    dirname5(seedPath),
     `.${basename5(seedPath)}.${process.pid}.${randomUUID2()}.tmp`
   );
-  writeFileSync3(tempPath, `${runnerId}
+  writeFileSync4(tempPath, `${runnerId}
 `, { encoding: "utf8", flag: "wx" });
   try {
     linkSync(tempPath, seedPath);
@@ -16204,14 +16470,14 @@ function ensureLocalRunnerIdSeed(configPath, createRunnerId, linzumiUrl) {
   }
 }
 function readMachineIdSeed(seedPath) {
-  const machineId = readFileSync8(seedPath, "utf8").trim();
+  const machineId = readFileSync9(seedPath, "utf8").trim();
   if (!machineIdValid(machineId)) {
     throw new Error(`invalid Linzumi machine id seed: ${seedPath}`);
   }
   return machineId;
 }
 function readRunnerIdSeed(seedPath) {
-  const runnerId = readFileSync8(seedPath, "utf8").trim();
+  const runnerId = readFileSync9(seedPath, "utf8").trim();
   if (!runnerIdValid(runnerId)) {
     throw new Error(`invalid Linzumi runner id seed: ${seedPath}`);
   }
@@ -16510,8 +16776,8 @@ var init_remoteCodexExecutionContext = __esm({
 });
 
 // src/helloLinzumiProject.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname5, join as join12, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync10, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname6, join as join13, resolve as resolve6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function createHelloLinzumiProject(input = {}) {
   const options = typeof input === "string" ? { rootPath: input } : input;
@@ -16520,9 +16786,9 @@ function createHelloLinzumiProject(input = {}) {
   const host = normalizeHost(options.host);
   assertTcpPort(port);
   assertWritableDemoRoot(root, options.reset === true);
-  mkdirSync6(join12(root, "src"), { recursive: true });
+  mkdirSync7(join13(root, "src"), { recursive: true });
   for (const file of demoFiles({ root, port, host })) {
-    writeFileSync4(join12(root, file.path), file.content, "utf8");
+    writeFileSync5(join13(root, file.path), file.content, "utf8");
   }
   return {
     root,
@@ -16566,8 +16832,8 @@ function assertWritableDemoRoot(root, reset) {
   if (!existsSync7(root)) {
     return;
   }
-  const markerPath = join12(root, markerFile);
-  const isDemoRoot = existsSync7(markerPath) && readFileSync9(markerPath, "utf8").trim() === "hello-linzumi";
+  const markerPath = join13(root, markerFile);
+  const isDemoRoot = existsSync7(markerPath) && readFileSync10(markerPath, "utf8").trim() === "hello-linzumi";
   if (isDemoRoot && reset) {
     rmSync2(root, { recursive: true, force: true });
     return;
@@ -16601,8 +16867,8 @@ var init_helloLinzumiProject = __esm({
     defaultHelloLinzumiPort = 8787;
     defaultHelloLinzumiHost = "0.0.0.0";
     markerFile = ".linzumi-demo-project";
-    moduleDir = dirname5(fileURLToPath2(import.meta.url));
-    linzumiLogoSvg = readFileSync9(join12(moduleDir, "assets", "linzumi-logo.svg"), "utf8");
+    moduleDir = dirname6(fileURLToPath2(import.meta.url));
+    linzumiLogoSvg = readFileSync10(join13(moduleDir, "assets", "linzumi-logo.svg"), "utf8");
     packageJson = `${JSON.stringify(
       {
         name: "hello-linzumi",
@@ -17404,14 +17670,14 @@ import {
   copyFileSync,
   cpSync,
   existsSync as existsSync8,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync8,
   mkdtempSync,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   realpathSync as realpathSync4,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { basename as basename6, delimiter, dirname as dirname6, join as join13 } from "node:path";
+import { basename as basename6, delimiter, dirname as dirname7, join as join14 } from "node:path";
 function isStartLocalEditorControl(control) {
   return control.type === "start_local_editor";
 }
@@ -17629,24 +17895,24 @@ function codeServerArgs(port, cwd, userDataDir, extensionsDir) {
 }
 function prepareCodeServerProfile(collaboration, editorRuntime) {
   try {
-    const userDataDir = mkdtempSync(join13(tmpdir(), "kandan-local-editor-"));
-    const extensionsDir = join13(userDataDir, "extensions");
-    const collaborationServerDir = join13(userDataDir, "collaboration-server");
-    const tempDir = join13(userDataDir, "tmp");
-    const userSettingsDir = join13(userDataDir, "User");
-    mkdirSync7(userSettingsDir, { recursive: true });
-    mkdirSync7(extensionsDir, { recursive: true });
-    mkdirSync7(collaborationServerDir, { recursive: true });
-    mkdirSync7(tempDir, { recursive: true });
+    const userDataDir = mkdtempSync(join14(tmpdir(), "kandan-local-editor-"));
+    const extensionsDir = join14(userDataDir, "extensions");
+    const collaborationServerDir = join14(userDataDir, "collaboration-server");
+    const tempDir = join14(userDataDir, "tmp");
+    const userSettingsDir = join14(userDataDir, "User");
+    mkdirSync8(userSettingsDir, { recursive: true });
+    mkdirSync8(extensionsDir, { recursive: true });
+    mkdirSync8(collaborationServerDir, { recursive: true });
+    mkdirSync8(tempDir, { recursive: true });
     if (editorRuntime !== void 0) {
       ensureCodeServerBrowserExtensionAssets(editorRuntime);
       installDirectory(
         editorRuntime.assets.documentStateExtensionDir,
-        join13(extensionsDir, "kandan.document-state-telemetry")
+        join14(extensionsDir, "kandan.document-state-telemetry")
       );
     }
-    writeFileSync5(
-      join13(userSettingsDir, "settings.json"),
+    writeFileSync6(
+      join14(userSettingsDir, "settings.json"),
       JSON.stringify(codeServerSettings(collaboration), null, 2)
     );
     return { ok: true, userDataDir, extensionsDir, collaborationServerDir };
@@ -17658,14 +17924,14 @@ function ensureCodeServerBrowserExtensionAssets(runtime) {
   const vscodeRoot = codeServerVscodeRoot(runtime);
   const repairs = [
     {
-      source: join13(
+      source: join14(
         vscodeRoot,
         "extensions",
         "git-base",
         "dist",
         "extension.js"
       ),
-      target: join13(
+      target: join14(
         vscodeRoot,
         "extensions",
         "git-base",
@@ -17676,14 +17942,14 @@ function ensureCodeServerBrowserExtensionAssets(runtime) {
       required: true
     },
     {
-      source: join13(
+      source: join14(
         vscodeRoot,
         "extensions",
         "git-base",
         "dist",
         "extension.js.map"
       ),
-      target: join13(
+      target: join14(
         vscodeRoot,
         "extensions",
         "git-base",
@@ -17694,14 +17960,14 @@ function ensureCodeServerBrowserExtensionAssets(runtime) {
       required: false
     },
     {
-      source: join13(
+      source: join14(
         vscodeRoot,
         "extensions",
         "merge-conflict",
         "dist",
         "mergeConflictMain.js"
       ),
-      target: join13(
+      target: join14(
         vscodeRoot,
         "extensions",
         "merge-conflict",
@@ -17712,14 +17978,14 @@ function ensureCodeServerBrowserExtensionAssets(runtime) {
       required: true
     },
     {
-      source: join13(
+      source: join14(
         vscodeRoot,
         "extensions",
         "merge-conflict",
         "dist",
         "mergeConflictMain.js.map"
       ),
-      target: join13(
+      target: join14(
         vscodeRoot,
         "extensions",
         "merge-conflict",
@@ -17737,7 +18003,7 @@ function ensureCodeServerBrowserExtensionAssets(runtime) {
       case (!required3 && !existsSync8(source)):
         return;
       default:
-        mkdirSync7(dirname6(target), { recursive: true });
+        mkdirSync8(dirname7(target), { recursive: true });
         copyFileSync(source, target);
         return;
     }
@@ -17745,10 +18011,10 @@ function ensureCodeServerBrowserExtensionAssets(runtime) {
 }
 function codeServerVscodeRoot(runtime) {
   const roots = uniquePaths([
-    join13(runtime.root, "lib", "vscode"),
-    join13(dirname6(dirname6(runtime.codeServerBin)), "lib", "vscode"),
+    join14(runtime.root, "lib", "vscode"),
+    join14(dirname7(dirname7(runtime.codeServerBin)), "lib", "vscode"),
     ...wrappedCodeServerBin(runtime.codeServerBin).map(
-      (codeServerBin) => join13(dirname6(dirname6(codeServerBin)), "lib", "vscode")
+      (codeServerBin) => join14(dirname7(dirname7(codeServerBin)), "lib", "vscode")
     )
   ]);
   const rootWithRequiredAssets = roots.find(
@@ -17764,7 +18030,7 @@ function codeServerVscodeRoot(runtime) {
 }
 function wrappedCodeServerBin(codeServerBin) {
   try {
-    const script = readFileSync10(codeServerBin, "utf8");
+    const script = readFileSync11(codeServerBin, "utf8");
     const match = script.match(
       /exec\s+(?:"([^"]+)"|'([^']+)'|([^\s]+))\s+"\$@"/u
     );
@@ -17776,8 +18042,8 @@ function wrappedCodeServerBin(codeServerBin) {
 }
 function codeServerBrowserAssetSources(vscodeRoot) {
   return [
-    join13(vscodeRoot, "extensions", "git-base", "dist", "extension.js"),
-    join13(
+    join14(vscodeRoot, "extensions", "git-base", "dist", "extension.js"),
+    join14(
       vscodeRoot,
       "extensions",
       "merge-conflict",
@@ -17856,10 +18122,10 @@ function prepareLinuxCodeServerLaunch(options) {
     options.cwd,
     "--setenv",
     "XDG_DATA_HOME",
-    join13(options.userDataDir, "data"),
+    join14(options.userDataDir, "data"),
     "--setenv",
     "XDG_CONFIG_HOME",
-    join13(options.userDataDir, "config"),
+    join14(options.userDataDir, "config"),
     ...readOnlyRoots.flatMap((path2) => ["--ro-bind-try", path2, path2]),
     "--bind",
     options.cwd,
@@ -17900,12 +18166,12 @@ function resolveCodeServerExecutable(command, envPath) {
     if (directory.trim() === "") {
       continue;
     }
-    const candidate = join13(directory, command);
+    const candidate = join14(directory, command);
     if (!existsSync8(candidate)) {
       continue;
     }
     const realpath2 = realpathSync4(candidate);
-    return { ok: true, command: realpath2, directory: dirname6(realpath2) };
+    return { ok: true, command: realpath2, directory: dirname7(realpath2) };
   }
   return { ok: false };
 }
@@ -17914,10 +18180,10 @@ function hasPathSeparator(path2) {
 }
 function safeRealpathDir(path2) {
   try {
-    const directory = dirname6(realpathSync4(path2));
+    const directory = dirname7(realpathSync4(path2));
     return directory === "/" ? void 0 : directory;
   } catch (_error) {
-    const directory = dirname6(path2);
+    const directory = dirname7(path2);
     return directory === "." || directory === "/" ? void 0 : directory;
   }
 }
@@ -17986,7 +18252,7 @@ async function startCollaborationSidecar(collaboration, profile, editorRuntime,
     ]);
     const command = nodeRuntimeExecutable();
     const args = [
-      join13(
+      join14(
         profile.collaborationServerDir,
         "open-collaboration-server",
         "bundle",
@@ -18081,11 +18347,11 @@ function nodeRuntimeExecutable(env = process.env, execPath = process.execPath) {
   return basename6(execPath).toLowerCase().includes("bun") ? "node" : execPath;
 }
 async function installLocalTarball(archivePath, destinationDir) {
-  mkdirSync7(destinationDir, { recursive: true });
+  mkdirSync8(destinationDir, { recursive: true });
   await runProcess("tar", ["-xzf", archivePath, "-C", destinationDir]);
 }
 function installDirectory(sourceDir, destinationDir) {
-  mkdirSync7(dirname6(destinationDir), { recursive: true });
+  mkdirSync8(dirname7(destinationDir), { recursive: true });
   cpSync(sourceDir, destinationDir, { recursive: true });
 }
 function codeServerEnv(env, cwd, userDataDir, collaboration) {
@@ -18103,7 +18369,7 @@ function codeServerEnv(env, cwd, userDataDir, collaboration) {
     KANDAN_EDITOR_COLLABORATION_ENTRY_MODE: "kandan_auto_host_or_join",
     KANDAN_EDITOR_COLLABORATION_ROOM_ID: collaboration.roomId,
     KANDAN_EDITOR_COLLABORATION_SERVER_URL: collaboration.bootstrapServerUrl,
-    KANDAN_EDITOR_COLLABORATION_AUTO_HOST_CLAIM_PATH: join13(
+    KANDAN_EDITOR_COLLABORATION_AUTO_HOST_CLAIM_PATH: join14(
       userDataDir,
       "kandan-oct-auto-host.lock"
     )
@@ -18307,20 +18573,20 @@ var init_localEditor = __esm({
 
 // src/localEditorRuntime.ts
 import { spawn as spawn5 } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import {
   createReadStream,
   createWriteStream as createWriteStream2,
   existsSync as existsSync9,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync11,
-  renameSync,
+  readFileSync as readFileSync12,
+  renameSync as renameSync2,
   rmSync as rmSync3,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { dirname as dirname7, join as join14, resolve as resolve7 } from "node:path";
+import { homedir as homedir12 } from "node:os";
+import { dirname as dirname8, join as join15, resolve as resolve7 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 async function resolveEditorRuntime(options) {
@@ -18511,14 +18777,14 @@ function normalizeRuntimeAssets(value) {
 }
 function installedRuntime(cacheRoot, manifest) {
   const runtimeRoot = runtimeInstallRoot(cacheRoot, manifest);
-  const manifestPath = join14(runtimeRoot, manifest.manifestPath);
-  const codeServerBin = join14(runtimeRoot, manifest.codeServerBinPath);
+  const manifestPath = join15(runtimeRoot, manifest.manifestPath);
+  const codeServerBin = join15(runtimeRoot, manifest.codeServerBinPath);
   const assets = verifiedRuntimeAssetPaths(runtimeRoot, manifest);
   if (!existsSync9(manifestPath) || !existsSync9(codeServerBin) || assets === void 0) {
     return { ok: false };
   }
   try {
-    const installed = JSON.parse(readFileSync11(manifestPath, "utf8"));
+    const installed = JSON.parse(readFileSync12(manifestPath, "utf8"));
     if (isJsonObject(installed) && installed.version === manifest.version && installed.platform === manifest.platform && (installed.archiveSha256 === void 0 || installed.archiveSha256 === manifest.archiveSha256)) {
       return {
         ok: true,
@@ -18536,10 +18802,10 @@ function installedRuntime(cacheRoot, manifest) {
   return { ok: false };
 }
 async function installRuntime(args) {
-  mkdirSync8(args.cacheRoot, { recursive: true });
-  const tempRoot = mkdtempSync2(join14(args.cacheRoot, ".install-"));
-  const archivePath = join14(tempRoot, "runtime.tar.gz");
-  const extractRoot = join14(tempRoot, "runtime");
+  mkdirSync9(args.cacheRoot, { recursive: true });
+  const tempRoot = mkdtempSync2(join15(args.cacheRoot, ".install-"));
+  const archivePath = join15(tempRoot, "runtime.tar.gz");
+  const extractRoot = join15(tempRoot, "runtime");
   try {
     const downloaded = await downloadArchive({
       kandanUrl: args.kandanUrl,
@@ -18551,7 +18817,7 @@ async function installRuntime(args) {
     if (!downloaded.ok) {
       return downloaded;
     }
-    mkdirSync8(extractRoot, { recursive: true });
+    mkdirSync9(extractRoot, { recursive: true });
     if (!await args.extractArchive(archivePath, extractRoot)) {
       return { ok: false, reason: "archive_extract_failed" };
     }
@@ -18564,14 +18830,14 @@ async function installRuntime(args) {
     if (!assetsInstalled) {
       return { ok: false, reason: "install_failed" };
     }
-    const manifestPath = join14(extractRoot, args.manifest.manifestPath);
-    const codeServerBin = join14(extractRoot, args.manifest.codeServerBinPath);
+    const manifestPath = join15(extractRoot, args.manifest.manifestPath);
+    const codeServerBin = join15(extractRoot, args.manifest.codeServerBinPath);
     const assets = verifiedRuntimeAssetPaths(extractRoot, args.manifest);
     if (!existsSync9(codeServerBin) || assets === void 0) {
       return { ok: false, reason: "invalid_archive" };
     }
-    mkdirSync8(dirname7(manifestPath), { recursive: true });
-    writeFileSync6(
+    mkdirSync9(dirname8(manifestPath), { recursive: true });
+    writeFileSync7(
       manifestPath,
       JSON.stringify(
         {
@@ -18589,28 +18855,28 @@ async function installRuntime(args) {
     );
     const targetRoot = runtimeInstallRoot(args.cacheRoot, args.manifest);
     rmSync3(targetRoot, { recursive: true, force: true });
-    mkdirSync8(dirname7(targetRoot), { recursive: true });
-    renameSync(extractRoot, targetRoot);
+    mkdirSync9(dirname8(targetRoot), { recursive: true });
+    renameSync2(extractRoot, targetRoot);
     return {
       ok: true,
       runtime: {
         mode: "server_managed",
         root: targetRoot,
-        codeServerBin: join14(targetRoot, args.manifest.codeServerBinPath),
+        codeServerBin: join15(targetRoot, args.manifest.codeServerBinPath),
         assets: {
-          collaborationExtensionTarball: join14(
+          collaborationExtensionTarball: join15(
             targetRoot,
             "kandan",
             "editor_extensions",
             "typefox.open-collaboration-tools.tar.gz"
           ),
-          collaborationServerTarball: join14(
+          collaborationServerTarball: join15(
             targetRoot,
             "kandan",
             "editor_servers",
             "open-collaboration-server.tar.gz"
           ),
-          documentStateExtensionDir: join14(
+          documentStateExtensionDir: join15(
             targetRoot,
             "kandan",
             "editor_extensions",
@@ -18627,7 +18893,7 @@ async function installRuntime(args) {
 }
 async function materializeRuntimeAssets(args) {
   for (const asset of args.manifest.assets) {
-    const targetPath = join14(args.runtimeRoot, asset.path);
+    const targetPath = join15(args.runtimeRoot, asset.path);
     try {
       const bytes = await runtimeAssetBytes({
         kandanUrl: args.kandanUrl,
@@ -18637,8 +18903,8 @@ async function materializeRuntimeAssets(args) {
       if (bytes === void 0) {
         continue;
       }
-      mkdirSync8(dirname7(targetPath), { recursive: true });
-      writeFileSync6(targetPath, bytes);
+      mkdirSync9(dirname8(targetPath), { recursive: true });
+      writeFileSync7(targetPath, bytes);
     } catch (_error) {
       return false;
     }
@@ -18717,7 +18983,7 @@ function extractTarGz(archivePath, destination) {
 }
 function fileSha256(path2) {
   return new Promise((resolveHash, rejectHash) => {
-    const hash = createHash4("sha256");
+    const hash = createHash5("sha256");
     const stream = createReadStream(path2);
     stream.on("error", rejectHash);
     stream.on("data", (chunk) => hash.update(chunk));
@@ -18728,19 +18994,19 @@ function runtimeInstallRoot(cacheRoot, manifest) {
   return resolve7(cacheRoot, manifest.platform, manifest.archiveSha256);
 }
 function verifiedRuntimeAssetPaths(runtimeRoot, manifest) {
-  const collaborationExtensionTarball = join14(
+  const collaborationExtensionTarball = join15(
     runtimeRoot,
     "kandan",
     "editor_extensions",
     "typefox.open-collaboration-tools.tar.gz"
   );
-  const collaborationServerTarball = join14(
+  const collaborationServerTarball = join15(
     runtimeRoot,
     "kandan",
     "editor_servers",
     "open-collaboration-server.tar.gz"
   );
-  const documentStateExtensionDir = join14(
+  const documentStateExtensionDir = join15(
     runtimeRoot,
     "kandan",
     "editor_extensions",
@@ -18749,7 +19015,7 @@ function verifiedRuntimeAssetPaths(runtimeRoot, manifest) {
   const codeServerRoot = codeServerRuntimeRoot(manifest.codeServerBinPath);
   const requiredPaths = [
     manifest.codeServerBinPath,
-    join14(
+    join15(
       codeServerRoot,
       "lib",
       "vscode",
@@ -18759,7 +19025,7 @@ function verifiedRuntimeAssetPaths(runtimeRoot, manifest) {
       "web",
       "vsda.js"
     ),
-    join14(
+    join15(
       codeServerRoot,
       "lib",
       "vscode",
@@ -18780,7 +19046,7 @@ function verifiedRuntimeAssetPaths(runtimeRoot, manifest) {
     if (expectedSha256 === void 0 && relativePath !== manifest.codeServerBinPath) {
       return void 0;
     }
-    const absolutePath = join14(runtimeRoot, relativePath);
+    const absolutePath = join15(runtimeRoot, relativePath);
     if (!existsSync9(absolutePath)) {
       return void 0;
     }
@@ -18799,7 +19065,7 @@ function verifiedRuntimeAssetPaths(runtimeRoot, manifest) {
 }
 function codeServerRuntimeRoot(codeServerBinPath) {
   const normalized = codeServerBinPath.replaceAll("\\", "/");
-  return normalized === "bin/code-server" ? "." : normalized.endsWith("/bin/code-server") ? normalized.slice(0, -"/bin/code-server".length) || "." : dirname7(normalized);
+  return normalized === "bin/code-server" ? "." : normalized.endsWith("/bin/code-server") ? normalized.slice(0, -"/bin/code-server".length) || "." : dirname8(normalized);
 }
 function manifestAssetChecksums(assets) {
   const checksums = /* @__PURE__ */ new Map();
@@ -18809,10 +19075,10 @@ function manifestAssetChecksums(assets) {
   return checksums;
 }
 function fileSha256Sync(path2) {
-  return createHash4("sha256").update(readFileSync11(path2)).digest("hex");
+  return createHash5("sha256").update(readFileSync12(path2)).digest("hex");
 }
 function defaultEditorRuntimeCacheRoot() {
-  return join14(homedir11(), ".linzumi", "editor-runtimes");
+  return join15(homedir12(), ".linzumi", "editor-runtimes");
 }
 function nonEmptyString(value) {
   return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
@@ -18832,7 +19098,7 @@ var init_localEditorRuntime = __esm({
 
 // src/dependencyStatus.ts
 import { spawn as spawn6, spawnSync as spawnSync4 } from "node:child_process";
-import { delimiter as delimiter2, dirname as dirname8, join as join15 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname9, join as join16 } from "node:path";
 function probeTool(command, cwd) {
   return new Promise((resolve12) => {
     const args = ["--version"];
@@ -18989,8 +19255,8 @@ function voltaCommandCandidates(args) {
     new Set(
       [
         voltaBinBesideCodexShim(args.codexBin),
-        env.VOLTA_HOME === void 0 ? void 0 : join15(env.VOLTA_HOME, "bin", "volta"),
-        env.HOME === void 0 ? void 0 : join15(env.HOME, ".volta", "bin", "volta"),
+        env.VOLTA_HOME === void 0 ? void 0 : join16(env.VOLTA_HOME, "bin", "volta"),
+        env.HOME === void 0 ? void 0 : join16(env.HOME, ".volta", "bin", "volta"),
         ...pathVoltaCandidates(env.PATH)
       ].filter((candidate) => candidate !== void 0)
     )
@@ -18998,10 +19264,10 @@ function voltaCommandCandidates(args) {
 }
 function voltaBinBesideCodexShim(codexBin) {
   const normalizedCodexBin = codexBin.replaceAll("\\", "/");
-  return normalizedCodexBin.endsWith("/.volta/bin/codex") ? join15(dirname8(codexBin), "volta") : void 0;
+  return normalizedCodexBin.endsWith("/.volta/bin/codex") ? join16(dirname9(codexBin), "volta") : void 0;
 }
 function pathVoltaCandidates(pathValue) {
-  return pathValue === void 0 ? [] : pathValue.split(delimiter2).filter((entry) => entry !== "").map((entry) => join15(entry, "volta"));
+  return pathValue === void 0 ? [] : pathValue.split(delimiter2).filter((entry) => entry !== "").map((entry) => join16(entry, "volta"));
 }
 function codeServerDependencyStatus(args) {
   switch (args.editorRuntime?.status) {
@@ -19110,7 +19376,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.90-beta";
+    linzumiCliVersion = "0.0.92-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -19119,21 +19385,21 @@ var init_version = __esm({
 import {
   closeSync as closeSync2,
   existsSync as existsSync10,
-  mkdirSync as mkdirSync9,
+  mkdirSync as mkdirSync10,
   openSync as openSync3,
-  readFileSync as readFileSync12,
-  renameSync as renameSync2,
+  readFileSync as readFileSync13,
+  renameSync as renameSync3,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync7,
+  writeFileSync as writeFileSync8,
   writeSync
 } from "node:fs";
-import { dirname as dirname9, join as join16 } from "node:path";
+import { dirname as dirname10, join as join17 } from "node:path";
 function isRunnerLockHeldError(error) {
   return error instanceof RunnerLockHeldError || error instanceof Error && error.name === runnerLockHeldErrorName && "lockPath" in error && "heldBy" in error;
 }
 function runnerLockPath(machineId, configPath = localConfigPath(), linzumiUrl) {
   const lockName = linzumiUrl === void 0 ? encodeURIComponent(machineId) : localConfigScopeFileStem(linzumiUrl);
-  return join16(dirname9(configPath), "runners", `${lockName}.lock`);
+  return join17(dirname10(configPath), "runners", `${lockName}.lock`);
 }
 function acquireRunnerLock(options) {
   const path2 = runnerLockPath(
@@ -19201,9 +19467,9 @@ function stampRunnerLockHeartbeat(path2, record, now) {
       heartbeatAt: now().toISOString()
     };
     const tmpPath = `${path2}.tmp`;
-    writeFileSync7(tmpPath, `${JSON.stringify(next, null, 2)}
+    writeFileSync8(tmpPath, `${JSON.stringify(next, null, 2)}
 `, "utf8");
-    renameSync2(tmpPath, path2);
+    renameSync3(tmpPath, path2);
   } catch (_error) {
   }
 }
@@ -19313,7 +19579,7 @@ function writeLockOrHandleExisting(path2, record, isPidAlive, now, killPid, onTa
   });
 }
 function tryCreateLock(path2, record) {
-  mkdirSync9(dirname9(path2), { recursive: true });
+  mkdirSync10(dirname10(path2), { recursive: true });
   try {
     const fd = openSync3(path2, "wx");
     try {
@@ -19369,7 +19635,7 @@ function withStaleReplacementLock(path2, isPidAlive, callback) {
 function readReplacementLockPidIfPresent(path2) {
   let value;
   try {
-    value = readFileSync12(path2, "utf8").trim();
+    value = readFileSync13(path2, "utf8").trim();
   } catch (error) {
     if (isNodeErrorCode2(error, "ENOENT")) {
       return void 0;
@@ -19412,7 +19678,7 @@ function readRunnerLockIfPresent(path2) {
   }
 }
 function readRunnerLock(path2) {
-  const parsed = JSON.parse(readFileSync12(path2, "utf8"));
+  const parsed = JSON.parse(readFileSync13(path2, "utf8"));
   if (!isRunnerLockRecord(parsed)) {
     throw new Error(`invalid Linzumi runner lock: ${path2}`);
   }
@@ -21329,8 +21595,8 @@ var init_runnerConsoleReporter = __esm({
 });
 
 // src/telemetry.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname10, basename as basename7, join as join17 } from "node:path";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname11, basename as basename7, join as join18 } from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 function peekFlagValue(args, flags) {
   for (let index = 0; index < args.length; index += 1) {
@@ -21369,12 +21635,12 @@ function telemetryBaseUrl(apiUrl, env = process.env) {
   }
 }
 function telemetryInstallIdPath(env = process.env) {
-  return join17(dirname10(localConfigPath(env)), "install-id");
+  return join18(dirname11(localConfigPath(env)), "install-id");
 }
 function ensureTelemetryInstallId(env = process.env) {
   const path2 = telemetryInstallIdPath(env);
   try {
-    const existing = readFileSync13(path2, "utf8").trim();
+    const existing = readFileSync14(path2, "utf8").trim();
     if (existing !== "" && existing.length <= 128) {
       return existing;
     }
@@ -21382,8 +21648,8 @@ function ensureTelemetryInstallId(env = process.env) {
   }
   const installId = randomUUID3();
   try {
-    mkdirSync10(dirname10(path2), { recursive: true });
-    writeFileSync8(path2, `${installId}
+    mkdirSync11(dirname11(path2), { recursive: true });
+    writeFileSync9(path2, `${installId}
 `, { mode: 384 });
   } catch {
   }
@@ -21576,17 +21842,17 @@ var init_linzumiApiClient = __esm({
 });
 
 // src/authCache.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync9 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
-import { dirname as dirname11, join as join18 } from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync12, readFileSync as readFileSync15, writeFileSync as writeFileSync10 } from "node:fs";
+import { homedir as homedir13 } from "node:os";
+import { dirname as dirname12, join as join19 } from "node:path";
 function defaultAuthFilePath() {
-  return join18(homedir12(), ".linzumi", "auth.json");
+  return join19(homedir13(), ".linzumi", "auth.json");
 }
 function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePath()) {
   if (!existsSync11(authFilePath)) {
     return void 0;
   }
-  const authFile = parseAuthFile(readFileSync14(authFilePath, "utf8"));
+  const authFile = parseAuthFile(readFileSync15(authFilePath, "utf8"));
   const kandanBaseUrl = kandanHttpBaseUrl(kandanUrl);
   const entry = authFile.local_codex_runner?.[kandanBaseUrl];
   if (entry === void 0 || entry.access_token.trim() === "") {
@@ -21608,7 +21874,7 @@ function readPersonalAgentDelegationToken(authFilePath) {
       `missing personal-agent delegation auth file: ${authFilePath}`
     );
   }
-  const authFile = parseAuthFile(readFileSync14(authFilePath, "utf8"));
+  const authFile = parseAuthFile(readFileSync15(authFilePath, "utf8"));
   const entry = authFile.personal_agent_delegation;
   if (entry === void 0 || entry.access_token.trim() === "") {
     throw new Error(
@@ -21626,7 +21892,7 @@ function readPersonalAgentDelegationToken(authFilePath) {
 }
 function writeCachedLocalRunnerToken(args) {
   const authFilePath = args.authFilePath ?? defaultAuthFilePath();
-  const existing = existsSync11(authFilePath) ? parseAuthFile(readFileSync14(authFilePath, "utf8")) : { version: 1 };
+  const existing = existsSync11(authFilePath) ? parseAuthFile(readFileSync15(authFilePath, "utf8")) : { version: 1 };
   const kandanBaseUrl = kandanHttpBaseUrl(args.kandanUrl);
   const issuedAt = /* @__PURE__ */ new Date();
   const expiresAt = args.expiresInSeconds === void 0 ? void 0 : new Date(
@@ -21644,8 +21910,8 @@ function writeCachedLocalRunnerToken(args) {
       }
     }
   };
-  mkdirSync11(dirname11(authFilePath), { recursive: true });
-  writeFileSync9(authFilePath, `${JSON.stringify(next, null, 2)}
+  mkdirSync12(dirname12(authFilePath), { recursive: true });
+  writeFileSync10(authFilePath, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   return {
     accessToken: args.accessToken,
@@ -22090,9 +22356,9 @@ var init_threadCodexWorkerIpc = __esm({
 
 // src/signupTaskSuggestions.ts
 import { spawn as spawn7 } from "node:child_process";
-import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync15, rmSync as rmSync4, writeFileSync as writeFileSync10 } from "node:fs";
+import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, rmSync as rmSync4, writeFileSync as writeFileSync11 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 async function suggestSignupTasksWithCodex(args) {
   const attempts = 2;
   let previousResponse;
@@ -22114,11 +22380,11 @@ async function suggestSignupTasksWithCodex(args) {
   );
 }
 async function runCodexTaskSuggestion(args) {
-  const tempRoot = mkdtempSync3(join19(tmpdir2(), "linzumi-signup-codex-tasks-"));
-  const schemaPath = join19(tempRoot, "task-suggestions.schema.json");
-  const outputPath = join19(tempRoot, "task-suggestions.json");
+  const tempRoot = mkdtempSync3(join20(tmpdir2(), "linzumi-signup-codex-tasks-"));
+  const schemaPath = join20(tempRoot, "task-suggestions.schema.json");
+  const outputPath = join20(tempRoot, "task-suggestions.json");
   const prompt = taskSuggestionPrompt(args.previousResponse);
-  writeFileSync10(
+  writeFileSync11(
     schemaPath,
     `${JSON.stringify(taskSuggestionJsonSchema(), null, 2)}
 `,
@@ -22135,7 +22401,7 @@ async function runCodexTaskSuggestion(args) {
         prompt
       })
     );
-    return readFileSync15(outputPath, "utf8");
+    return readFileSync16(outputPath, "utf8");
   } finally {
     rmSync4(tempRoot, { recursive: true, force: true });
   }
@@ -22308,7 +22574,7 @@ var init_signupTaskSuggestions = __esm({
 // src/remoteCodexSandboxRunner.ts
 import { spawn as spawn8 } from "node:child_process";
 import { existsSync as existsSync12, realpathSync as realpathSync5 } from "node:fs";
-import { dirname as dirname12, isAbsolute as isAbsolute4 } from "node:path";
+import { dirname as dirname13, isAbsolute as isAbsolute4 } from "node:path";
 function createConfiguredRemoteCodexSandboxRunner(args) {
   const kind = normalizedSandboxKind(args.env.LINZUMI_REMOTE_CODEX_SANDBOX);
   if (kind === void 0) {
@@ -22423,8 +22689,8 @@ function bubblewrapArgs(sandboxBin, request, exists) {
   ]);
   const readOnlyBindArgs = uniqueStrings3([
     ...linuxReadOnlyRoots,
-    ...isAbsolute4(request.command) ? [dirname12(request.command)] : [],
-    dirname12(sandboxBin)
+    ...isAbsolute4(request.command) ? [dirname13(request.command)] : [],
+    dirname13(sandboxBin)
   ]).flatMap((path2) => exists(path2) ? ["--ro-bind", path2, path2] : []);
   const cwdParentDirs = parentDirs(request.cwd).flatMap((path2) => [
     "--dir",
@@ -22457,7 +22723,7 @@ function bubblewrapArgs(sandboxBin, request, exists) {
 function macosSeatbeltProfile(request, exists) {
   const readableRoots = uniqueStrings3([
     ...macosReadOnlyRoots,
-    ...isAbsolute4(request.command) ? [dirname12(request.command)] : []
+    ...isAbsolute4(request.command) ? [dirname13(request.command)] : []
   ]).filter(exists);
   const readableRules = readableRoots.map((path2) => `(allow file-read* (subpath ${sandboxString(path2)}))`).join("\n");
   const writableTempRules = macosWritableTempRoots.filter(exists).flatMap((path2) => [
@@ -22580,31 +22846,31 @@ var init_remoteCodexSandboxRunner = __esm({
 
 // src/runner.ts
 import { spawn as spawn9, spawnSync as spawnSync5 } from "node:child_process";
-import { createHash as createHash5, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID4 } from "node:crypto";
 import {
   chmodSync as chmodSync2,
   existsSync as existsSync13,
   lstatSync,
-  mkdirSync as mkdirSync12,
+  mkdirSync as mkdirSync13,
   mkdtempSync as mkdtempSync4,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   realpathSync as realpathSync6,
-  renameSync as renameSync3,
+  renameSync as renameSync4,
   rmSync as rmSync5,
   statSync as statSync3,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
 import { createServer as createServer3 } from "node:http";
-import { homedir as homedir13, hostname as hostname2, tmpdir as tmpdir3 } from "node:os";
+import { homedir as homedir14, hostname as hostname2, tmpdir as tmpdir3 } from "node:os";
 import { createInterface } from "node:readline";
 import {
   basename as basename8,
-  dirname as dirname13,
+  dirname as dirname14,
   extname as extname2,
   isAbsolute as isAbsolute5,
-  join as join20,
+  join as join21,
   resolve as resolve8
 } from "node:path";
 async function runLocalCodexRunner(options) {
@@ -22883,6 +23149,10 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     { discardSeqsOnFirstEpochAdoption: true }
   );
   cleanup.actions.push(() => appliedStartTurnStore.flush());
+  const threadSessionRegistry = createRunnerThreadSessionRegistryStore(
+    runnerThreadSessionRegistryPath(options.runnerId),
+    log2
+  );
   const controlEpochStore = createRunnerControlEpochStore(
     controlCursorStore,
     appliedStartTurnStore,
@@ -23765,6 +24035,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     kandan.onReconnect(() => channelSession.handleKandanReconnect());
   }
   const dynamicChannelSessions = /* @__PURE__ */ new Map();
+  const dynamicChannelSessionAttachInFlight = /* @__PURE__ */ new Map();
   const dynamicChannelSessionCodexClients = /* @__PURE__ */ new Map();
   const codexTurnFailureGuards = /* @__PURE__ */ new Map();
   const lossReportPushes = [];
@@ -23886,90 +24157,120 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     if (existingSession !== void 0) {
       return existingSession;
     }
-    const listenUser = options.channelSession?.listenUser ?? identityFromAccessToken(options.token).actorUsername;
-    if (listenUser === void 0) {
-      throw new Error(
-        "missing listen user for Commander-started Codex session"
-      );
+    const alreadyAttaching = dynamicChannelSessionAttachInFlight.get(codexThreadId);
+    if (alreadyAttaching !== void 0) {
+      return await alreadyAttaching;
     }
-    const runtimeSettings = startInstanceRuntimeSettings(options, control);
-    const session = await attachChannelSession({
-      kandan,
-      codex: sessionCodex,
-      topic,
-      instanceId,
-      options: {
-        kandanUrl: options.kandanUrl,
-        token: options.token,
-        runnerId: options.runnerId,
-        cwd,
-        codexBin: options.codexBin,
-        fetch: options.fetch,
-        fast: control.fast ?? options.fast,
-        launchTui: false,
-        pipelinePersistDir: commanderOutboxPersistDir(),
-        enablePortForwardWatch: true,
-        initialForwardPorts: allowedForwardPorts,
-        portForwardWatcher: channelSessionPortForwardWatcherOptions({
-          rootPid: portForwardWatcherRootPid,
-          start: options.portForwardWatcher,
-          commanderBoundPids: args.commanderBoundPids,
-          commanderBoundPorts: args.commanderBoundPorts
-        }),
-        suppressedForwardPorts,
-        onForwardPortApproved: (port, attribution) => {
-          liveForwardPorts.add(port);
-          setForwardPortAttribution(port, {
-            ...attribution,
-            agentProvider: "codex"
-          });
-          return capabilitiesPayload();
-        },
-        onForwardPortRevoked: (port) => {
-          liveForwardPorts.delete(port);
-          clearForwardPortAttribution(port);
-          return capabilitiesPayload();
+    const attachPromise = (async () => {
+      const listenUser = options.channelSession?.listenUser ?? identityFromAccessToken(options.token).actorUsername;
+      if (listenUser === void 0) {
+        throw new Error(
+          "missing listen user for Commander-started Codex session"
+        );
+      }
+      const runtimeSettings = startInstanceRuntimeSettings(options, control);
+      const session = await attachChannelSession({
+        kandan,
+        codex: sessionCodex,
+        topic,
+        instanceId,
+        options: {
+          kandanUrl: options.kandanUrl,
+          token: options.token,
+          runnerId: options.runnerId,
+          cwd,
+          codexBin: options.codexBin,
+          fetch: options.fetch,
+          fast: control.fast ?? options.fast,
+          launchTui: false,
+          pipelinePersistDir: commanderOutboxPersistDir(),
+          enablePortForwardWatch: true,
+          initialForwardPorts: allowedForwardPorts,
+          portForwardWatcher: channelSessionPortForwardWatcherOptions({
+            rootPid: portForwardWatcherRootPid,
+            start: options.portForwardWatcher,
+            commanderBoundPids: args.commanderBoundPids,
+            commanderBoundPorts: args.commanderBoundPorts
+          }),
+          suppressedForwardPorts,
+          onForwardPortApproved: (port, attribution) => {
+            liveForwardPorts.add(port);
+            setForwardPortAttribution(port, {
+              ...attribution,
+              agentProvider: "codex"
+            });
+            return capabilitiesPayload();
+          },
+          onForwardPortRevoked: (port) => {
+            liveForwardPorts.delete(port);
+            clearForwardPortAttribution(port);
+            return capabilitiesPayload();
+          },
+          channelSession: {
+            workspaceSlug,
+            channelSlug,
+            kandanThreadId,
+            rootSeq: integerValue(control.rootSeq),
+            codexThreadId,
+            linzumiContext: control.linzumiContext,
+            listenUser,
+            model: runtimeSettings.model,
+            reasoningEffort: runtimeSettings.reasoningEffort,
+            sandbox: runtimeSettings.sandbox,
+            approvalPolicy: runtimeSettings.approvalPolicy,
+            allowPortForwardingByDefault: runtimeSettings.allowPortForwardingByDefault
+          }
         },
-        channelSession: {
+        log: log2
+      });
+      dynamicChannelSessions.set(codexThreadId, session);
+      dynamicChannelSessionCodexClients.set(codexThreadId, sessionCodex);
+      threadSessionRegistry.upsert({
+        workspace: workspaceSlug,
+        channel: channelSlug,
+        kandanThreadId,
+        codexThreadId,
+        cwd,
+        agentProvider: "codex",
+        control: rehydrationControlSnapshot({
           workspaceSlug,
           channelSlug,
           kandanThreadId,
-          rootSeq: integerValue(control.rootSeq),
           codexThreadId,
-          linzumiContext: control.linzumiContext,
-          listenUser,
-          model: runtimeSettings.model,
-          reasoningEffort: runtimeSettings.reasoningEffort,
-          sandbox: runtimeSettings.sandbox,
-          approvalPolicy: runtimeSettings.approvalPolicy,
-          allowPortForwardingByDefault: runtimeSettings.allowPortForwardingByDefault
-        }
-      },
-      log: log2
-    });
-    dynamicChannelSessions.set(codexThreadId, session);
-    dynamicChannelSessionCodexClients.set(codexThreadId, sessionCodex);
-    if (sessionCodex !== codex) {
-      sessionCodex.onNotification((notification) => {
-        seq.value += 1;
-        const params = notification.params ?? {};
-        log2(
-          "codex.notification",
-          codexNotificationConsoleLogPayload(notification.method, params)
-        );
-        codexTurnFailureGuardFor(sessionCodex).observeNotification(
-          notification.method,
-          params
-        );
-        dispatchCodexNotificationToSession(
-          session,
-          notification.method,
-          params,
-          log2
-        );
+          cwd,
+          rootSeq: integerValue(control.rootSeq),
+          runtimeSettings
+        }),
+        updatedAtMs: Date.now()
       });
+      if (sessionCodex !== codex) {
+        sessionCodex.onNotification((notification) => {
+          seq.value += 1;
+          const params = notification.params ?? {};
+          log2(
+            "codex.notification",
+            codexNotificationConsoleLogPayload(notification.method, params)
+          );
+          codexTurnFailureGuardFor(sessionCodex).observeNotification(
+            notification.method,
+            params
+          );
+          dispatchCodexNotificationToSession(
+            session,
+            notification.method,
+            params,
+            log2
+          );
+        });
+      }
+      return session;
+    })();
+    dynamicChannelSessionAttachInFlight.set(codexThreadId, attachPromise);
+    try {
+      return await attachPromise;
+    } finally {
+      dynamicChannelSessionAttachInFlight.delete(codexThreadId);
     }
-    return session;
   };
   const attachThreadSession = async (control, cwd, codexThreadId) => {
     return await attachThreadSessionWithCodex({
@@ -23980,6 +24281,69 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
       portForwardWatcherRootPid: started?.process.pid
     });
   };
+  const rehydrateThreadSessionsOnBoot = async () => {
+    const records = threadSessionRegistry.list();
+    if (records.length === 0) {
+      return;
+    }
+    const summary = await rehydrateThreadSessions({
+      records,
+      nowMs: Date.now(),
+      maxAgeMs: defaultThreadSessionRehydrationMaxAgeMs,
+      pendingDurableRowCount: (record) => recoverOutboxJournal(
+        outboxJournalPath(
+          commanderOutboxPersistDir(),
+          channelSessionPipelineThreadKey(
+            { workspaceSlug: record.workspace, channelSlug: record.channel },
+            record.kandanThreadId,
+            instanceId
+          )
+        ),
+        log2
+      ).pendingEntries.length,
+      attach: async (record) => {
+        if (cleanup.closePromise !== void 0) {
+          log2("session_registry.rehydrate_aborted_shutdown", {
+            thread_id: record.kandanThreadId
+          });
+          return "failed";
+        }
+        const cwd = resolveAllowedCwd(record.cwd, allowedCwds.value);
+        if (!cwd.ok) {
+          log2("session_registry.rehydrate_cwd_rejected", {
+            thread_id: record.kandanThreadId,
+            cwd: record.cwd,
+            reason: cwd.reason
+          });
+          return "retire";
+        }
+        const session = await attachThreadSession(
+          rehydrationReconnectControl(record),
+          cwd.cwd,
+          record.codexThreadId
+        );
+        return session !== void 0 ? "attached" : "failed";
+      },
+      retire: (record) => threadSessionRegistry.remove(record.kandanThreadId),
+      log: log2
+    });
+    log2("session_registry.rehydrate_complete", {
+      records: records.length,
+      rehydrated: summary.rehydrated,
+      retired_drained: summary.retiredDrained,
+      retired_stale: summary.retiredStale,
+      retired_unattachable: summary.retiredUnattachable,
+      failed: summary.failed
+    });
+  };
+  const threadSessionRehydration = rehydrateThreadSessionsOnBoot().catch(
+    (error) => {
+      log2("session_registry.rehydrate_failed", {
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  );
+  cleanup.actions.push(() => threadSessionRehydration);
   const startThreadRunnerProcess = async (control, cwd) => {
     if (options.threadProcess?.role === "thread") {
       return void 0;
@@ -24644,14 +25008,14 @@ function commanderOutboxPersistDir() {
   if (override !== void 0 && override !== "") {
     return override;
   }
-  return join20(homedir13(), ".linzumi", "commander-outbox");
+  return join21(homedir14(), ".linzumi", "commander-outbox");
 }
 function controlCursorStorePath(runnerId) {
   const sanitized = runnerId.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, 80);
-  const digest = createHash5("sha256").update(runnerId).digest("hex").slice(0, 8);
+  const digest = createHash6("sha256").update(runnerId).digest("hex").slice(0, 8);
   const stem = sanitized === "" ? "runner" : sanitized;
-  return join20(
-    homedir13(),
+  return join21(
+    homedir14(),
     ".linzumi",
     "control-cursors",
     `${stem}.${digest}.json`
@@ -24659,10 +25023,10 @@ function controlCursorStorePath(runnerId) {
 }
 function appliedStartTurnStorePath(runnerId) {
   const sanitized = runnerId.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, 80);
-  const digest = createHash5("sha256").update(runnerId).digest("hex").slice(0, 8);
+  const digest = createHash6("sha256").update(runnerId).digest("hex").slice(0, 8);
   const stem = sanitized === "" ? "runner" : sanitized;
-  return join20(
-    homedir13(),
+  return join21(
+    homedir14(),
     ".linzumi",
     "control-cursors",
     `${stem}.${digest}.start-turn.json`
@@ -24784,9 +25148,9 @@ function createControlCursorFileStore(path2, log2, options) {
     }
     dirty = false;
     try {
-      mkdirSync12(dirname13(path2), { recursive: true });
+      mkdirSync13(dirname14(path2), { recursive: true });
       const tmpPath = `${path2}.tmp`;
-      writeFileSync11(
+      writeFileSync12(
         tmpPath,
         `${JSON.stringify({
           ...epoch === void 0 ? {} : { [controlCursorEpochKey]: epoch },
@@ -24795,7 +25159,7 @@ function createControlCursorFileStore(path2, log2, options) {
 `,
         "utf8"
       );
-      renameSync3(tmpPath, path2);
+      renameSync4(tmpPath, path2);
     } catch (error) {
       log2("control_cursor_store.write_failed", {
         path: path2,
@@ -24894,7 +25258,7 @@ function readControlCursorFile(path2, log2) {
   const cursors = /* @__PURE__ */ new Map();
   let raw;
   try {
-    raw = readFileSync16(path2, "utf8");
+    raw = readFileSync17(path2, "utf8");
   } catch (error) {
     if (!isErrnoCode2(error, "ENOENT")) {
       log2("control_cursor_store.read_failed", {
@@ -27188,7 +27552,7 @@ async function startClaudeCodeProviderInstance(args) {
     log: args.log
   });
   const liveBashCapture = args.options.claudeCodeRunner === void 0 && claudeLiveBashCaptureEnabled(process.env) ? createClaudeCodeLiveBashCapture({
-    captureDir: join20(
+    captureDir: join21(
       tmpdir3(),
       `linzumi-claude-live-bash-${args.instanceId}`
     ),
@@ -28020,6 +28384,48 @@ function startInstanceRuntimeSettings(options, control) {
     allowPortForwardingByDefault: true
   };
 }
+function rehydrationControlSnapshot(args) {
+  const { runtimeSettings } = args;
+  return {
+    type: "reconnect_thread",
+    workspace: args.workspaceSlug,
+    channel: args.channelSlug,
+    threadId: args.kandanThreadId,
+    codexThreadId: args.codexThreadId,
+    cwd: args.cwd,
+    agentProvider: "codex",
+    ...args.rootSeq === void 0 ? {} : { rootSeq: args.rootSeq },
+    ...runtimeSettings.model === void 0 ? {} : { model: runtimeSettings.model },
+    ...runtimeSettings.reasoningEffort === void 0 ? {} : { reasoningEffort: runtimeSettings.reasoningEffort },
+    ...runtimeSettings.sandbox === void 0 ? {} : { sandbox: runtimeSettings.sandbox },
+    ...runtimeSettings.approvalPolicy === void 0 ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
+    ...runtimeSettings.fast === void 0 ? {} : { fast: runtimeSettings.fast }
+  };
+}
+function rehydrationReconnectControl(record) {
+  const snapshot = record.control;
+  const rootSeq = integerValue(snapshot.rootSeq);
+  const model = stringValue(snapshot.model);
+  const reasoningEffort = stringValue(snapshot.reasoningEffort);
+  const sandbox = stringValue(snapshot.sandbox);
+  const approvalPolicy = stringValue(snapshot.approvalPolicy);
+  const fast = typeof snapshot.fast === "boolean" ? snapshot.fast : void 0;
+  return {
+    type: "reconnect_thread",
+    workspace: record.workspace,
+    channel: record.channel,
+    threadId: record.kandanThreadId,
+    codexThreadId: record.codexThreadId,
+    cwd: record.cwd,
+    agentProvider: "codex",
+    ...rootSeq === void 0 ? {} : { rootSeq },
+    ...model === void 0 ? {} : { model },
+    ...reasoningEffort === void 0 ? {} : { reasoningEffort },
+    ...sandbox === void 0 ? {} : { sandbox },
+    ...approvalPolicy === void 0 ? {} : { approvalPolicy },
+    ...fast === void 0 ? {} : { fast }
+  };
+}
 function channelSessionPortForwardWatcherOptions(args) {
   if (args.rootPid === void 0 && args.start === void 0) {
     return void 0;
@@ -28993,8 +29399,8 @@ function onboardingConversationOfficeImport(response) {
   return objectValue(metadata?.office_channel_import);
 }
 function onboardingConversationImportClientMessageId(importKey, itemKey) {
-  const importHash = createHash5("sha256").update(importKey).digest("hex");
-  const itemHash = createHash5("sha256").update(itemKey).digest("hex");
+  const importHash = createHash6("sha256").update(importKey).digest("hex");
+  const itemHash = createHash6("sha256").update(itemKey).digest("hex");
   return `onboarding-import:${importHash.slice(0, 32)}:${itemHash.slice(0, 24)}`;
 }
 async function uploadLocalConversationAttachments(args) {
@@ -29092,7 +29498,7 @@ async function localConversationAttachmentFile(candidatePath, attachment) {
       };
     }
     case "path": {
-      const path2 = isAbsolute5(attachment.path) ? attachment.path : resolve8(dirname13(candidatePath), attachment.path);
+      const path2 = isAbsolute5(attachment.path) ? attachment.path : resolve8(dirname14(candidatePath), attachment.path);
       try {
         const bytes = await readFile2(path2);
         return {
@@ -29482,9 +29888,9 @@ function mcpOwnerUsername(options) {
   return options.channelSession?.listenUser ?? identityFromAccessToken(options.token).actorUsername;
 }
 function writeEphemeralMcpAuthFile(options) {
-  const directory = mkdtempSync4(join20(tmpdir3(), "linzumi-mcp-auth-"));
+  const directory = mkdtempSync4(join21(tmpdir3(), "linzumi-mcp-auth-"));
   chmodSync2(directory, 448);
-  const path2 = join20(directory, "auth.json");
+  const path2 = join21(directory, "auth.json");
   writeCachedLocalRunnerToken({
     kandanUrl: options.kandanUrl,
     accessToken: options.token,
@@ -29560,7 +29966,7 @@ function configuredAllowedCwds(values, options = {}) {
     const absolutePath = resolve8(expandUserPath(value));
     try {
       if (options.createMissing === true) {
-        mkdirSync12(absolutePath, { recursive: true });
+        mkdirSync13(absolutePath, { recursive: true });
       }
       const realPath = realpathSync6(absolutePath);
       allowedCwds.push(
@@ -29597,7 +30003,7 @@ function allowedCwdProjects(allowedCwds) {
   });
 }
 function isGitProjectDirectory(cwd) {
-  const gitPath = join20(cwd, ".git");
+  const gitPath = join21(cwd, ".git");
   try {
     const gitPathStats = statSync3(gitPath);
     return gitPathStats.isDirectory() || gitPathStats.isFile();
@@ -29620,9 +30026,9 @@ function browseRunnerDirectory(control, options) {
         error: "not_directory"
       };
     }
-    const parent = dirname13(currentPath);
+    const parent = dirname14(currentPath);
     const entries = readdirSync4(currentPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => visibleRunnerDirectoryEntryName(entry.name)).map((entry) => {
-      const path2 = join20(currentPath, entry.name);
+      const path2 = join21(currentPath, entry.name);
       return {
         name: entry.name,
         path: path2,
@@ -29663,7 +30069,7 @@ function projectDirectoryName(name) {
 function availableProjectDirectoryName(projectsRoot, baseName, suffix = 0) {
   for (let nextSuffix = suffix; ; nextSuffix += 1) {
     const candidate = nextSuffix === 0 ? baseName : `${baseName}-${nextSuffix}`;
-    if (!projectPathExists(join20(projectsRoot, candidate))) {
+    if (!projectPathExists(join21(projectsRoot, candidate))) {
       return candidate;
     }
   }
@@ -29691,9 +30097,9 @@ function createRunnerProject(control, options, allowedCwds) {
       error: "invalid_project_template"
     };
   }
-  const projectsRoot = join20(currentHomeDirectory(), "linzumi");
+  const projectsRoot = join21(currentHomeDirectory(), "linzumi");
   const resolvedProjectDirName = template === "hello_linzumi_demo" ? availableProjectDirectoryName(projectsRoot, projectDirName) : projectDirName;
-  const projectPath = join20(projectsRoot, resolvedProjectDirName);
+  const projectPath = join21(projectsRoot, resolvedProjectDirName);
   let createdProjectPath = false;
   try {
     if (template !== "hello_linzumi_demo" && projectPathExists(projectPath)) {
@@ -29705,7 +30111,7 @@ function createRunnerProject(control, options, allowedCwds) {
         error: "project_directory_exists"
       };
     }
-    mkdirSync12(projectsRoot, { recursive: true });
+    mkdirSync13(projectsRoot, { recursive: true });
     if (template === "hello_linzumi_demo") {
       createdProjectPath = true;
       createHelloLinzumiProject({
@@ -29713,7 +30119,7 @@ function createRunnerProject(control, options, allowedCwds) {
         name: resolvedProjectDirName
       });
     } else {
-      mkdirSync12(projectPath, { recursive: false });
+      mkdirSync13(projectPath, { recursive: false });
       createdProjectPath = true;
     }
     const git = spawnSync5("git", ["init"], {
@@ -29831,6 +30237,8 @@ var init_runner = __esm({
   "src/runner.ts"() {
     "use strict";
     init_channelSession();
+    init_runnerThreadSessionRegistry();
+    init_outboxJournal();
     init_channelSessionSupport();
     init_commanderAttachments();
     init_claudeCodePipeline();
@@ -29901,7 +30309,7 @@ var init_runner = __esm({
 });
 
 // src/kandanTls.ts
-import { existsSync as existsSync14, readFileSync as readFileSync17 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync18 } from "node:fs";
 import { Agent } from "undici";
 import WsWebSocket from "ws";
 function kandanTlsTrustFromEnv() {
@@ -29915,7 +30323,7 @@ function kandanTlsTrustFromCaFile(caFile) {
   if (!existsSync14(trimmed)) {
     throw new Error(`KANDAN_TLS_CA_FILE does not exist: ${trimmed}`);
   }
-  const ca = readFileSync17(trimmed, "utf8");
+  const ca = readFileSync18(trimmed, "utf8");
   return {
     caFile: trimmed,
     ca,
@@ -48699,7 +49107,7 @@ var init_RemoveFileError = __esm({
 
 // ../../node_modules/@inquirer/external-editor/dist/esm/index.js
 import { spawn as spawn11, spawnSync as spawnSync6 } from "child_process";
-import { readFileSync as readFileSync20, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "fs";
+import { readFileSync as readFileSync21, unlinkSync as unlinkSync3, writeFileSync as writeFileSync15 } from "fs";
 import path from "node:path";
 import os from "node:os";
 import { randomUUID as randomUUID5 } from "node:crypto";
@@ -48816,14 +49224,14 @@ var init_esm5 = __esm({
           if (Object.prototype.hasOwnProperty.call(this.fileOptions, "mode")) {
             opt.mode = this.fileOptions.mode;
           }
-          writeFileSync14(this.tempFile, this.text, opt);
+          writeFileSync15(this.tempFile, this.text, opt);
         } catch (createFileError) {
           throw new CreateFileError(createFileError);
         }
       }
       readTemporaryFile() {
         try {
-          const tempFileBuffer = readFileSync20(this.tempFile);
+          const tempFileBuffer = readFileSync21(this.tempFile);
           if (tempFileBuffer.length === 0) {
             this.text = "";
           } else {
@@ -50192,17 +50600,17 @@ import { spawn as spawn12, spawnSync as spawnSync7 } from "node:child_process";
 import {
   existsSync as existsSync17,
   constants as fsConstants,
-  mkdirSync as mkdirSync15,
-  mkdtempSync as mkdtempSync5,
-  readFileSync as readFileSync21,
+  mkdirSync as mkdirSync16,
+  mkdtempSync as mkdtempSync6,
+  readFileSync as readFileSync22,
   readdirSync as readdirSync5,
-  rmSync as rmSync6,
+  rmSync as rmSync7,
   statSync as statSync4,
-  writeFileSync as writeFileSync15
+  writeFileSync as writeFileSync16
 } from "node:fs";
 import { access } from "node:fs/promises";
-import { homedir as homedir16, tmpdir as tmpdir4 } from "node:os";
-import { delimiter as delimiter3, dirname as dirname16, join as join23, resolve as resolve10 } from "node:path";
+import { homedir as homedir17, tmpdir as tmpdir5 } from "node:os";
+import { delimiter as delimiter3, dirname as dirname18, join as join25, resolve as resolve10 } from "node:path";
 import { stdin as defaultStdin, stdout as defaultStdout } from "node:process";
 import { emitKeypressEvents } from "node:readline";
 function signupHelpText() {
@@ -50323,7 +50731,7 @@ function defaultSignupDraftStore(serviceUrl) {
       }
       let parsed;
       try {
-        parsed = JSON.parse(readFileSync21(path2, "utf8"));
+        parsed = JSON.parse(readFileSync22(path2, "utf8"));
       } catch (_error) {
         return void 0;
       }
@@ -50333,21 +50741,21 @@ function defaultSignupDraftStore(serviceUrl) {
       return comparableServiceUrl(parsed.serviceUrl) === comparableServiceUrl(serviceUrl) ? parsed : void 0;
     },
     write: (draft) => {
-      mkdirSync15(dirname16(path2), { recursive: true });
-      writeFileSync15(path2, `${JSON.stringify(draft, null, 2)}
+      mkdirSync16(dirname18(path2), { recursive: true });
+      writeFileSync16(path2, `${JSON.stringify(draft, null, 2)}
 `, {
         encoding: "utf8",
         mode: 384
       });
     },
     clear: () => {
-      rmSync6(path2, { force: true });
+      rmSync7(path2, { force: true });
     }
   };
 }
 function defaultSignupDraftPath(serviceUrl) {
-  return join23(
-    dirname16(localConfigPath()),
+  return join25(
+    dirname18(localConfigPath()),
     `signup-draft.${localConfigScopeFileStem(serviceUrl)}.json`
   );
 }
@@ -50381,8 +50789,8 @@ function defaultSignupTaskCacheStore(serviceUrl) {
           }
         }
       };
-      mkdirSync15(dirname16(path2), { recursive: true });
-      writeFileSync15(path2, `${JSON.stringify(next, null, 2)}
+      mkdirSync16(dirname18(path2), { recursive: true });
+      writeFileSync16(path2, `${JSON.stringify(next, null, 2)}
 `, {
         encoding: "utf8",
         mode: 384
@@ -50391,8 +50799,8 @@ function defaultSignupTaskCacheStore(serviceUrl) {
   };
 }
 function defaultSignupTaskCachePath(serviceUrl) {
-  return join23(
-    dirname16(localConfigPath()),
+  return join25(
+    dirname18(localConfigPath()),
     `signup-task-cache.${localConfigScopeFileStem(serviceUrl)}.json`
   );
 }
@@ -50402,7 +50810,7 @@ function readSignupTaskCache(path2) {
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync21(path2, "utf8"));
+    parsed = JSON.parse(readFileSync22(path2, "utf8"));
   } catch (_error) {
     return { version: 1, entries: {} };
   }
@@ -52287,7 +52695,7 @@ function autocompletePathSuggestions(pathInput) {
   try {
     const showHidden = prefix.startsWith(".");
     const currentPath = directoryExists(normalizedInput) ? [normalizedInput.replace(/\/$/, "") || "/"] : [];
-    const childPaths = readdirSync5(directoryPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => showHidden || !entry.name.startsWith(".")).map((entry) => join23(directoryPath, entry.name)).map((path2) => ({
+    const childPaths = readdirSync5(directoryPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => showHidden || !entry.name.startsWith(".")).map((entry) => join25(directoryPath, entry.name)).map((path2) => ({
       path: path2,
       score: fuzzyPathSegmentScore(path2.split("/").at(-1) ?? path2, prefix)
     })).filter((candidate) => candidate.score !== void 0).sort((left, right) => {
@@ -52533,7 +52941,7 @@ async function runSignupPreflights(runtime) {
 function defaultPreflightRuntime() {
   return {
     cwd: process.cwd(),
-    homeDir: homedir16(),
+    homeDir: homedir17(),
     probeTool,
     readGitEmail,
     discoverCodeRoots,
@@ -52678,13 +53086,13 @@ async function suggestTasksWithCodex(projectPath, retryPolicy) {
   );
 }
 async function runCodexTaskSuggestion2(projectPath, previousResponse, retryPolicy) {
-  const tempRoot = mkdtempSync5(join23(tmpdir4(), "linzumi-signup-codex-tasks-"));
-  const schemaPath = join23(tempRoot, "task-suggestions.schema.json");
-  const outputPath = join23(tempRoot, "task-suggestions.json");
+  const tempRoot = mkdtempSync6(join25(tmpdir5(), "linzumi-signup-codex-tasks-"));
+  const schemaPath = join25(tempRoot, "task-suggestions.schema.json");
+  const outputPath = join25(tempRoot, "task-suggestions.json");
   const model = process.env.LINZUMI_SIGNUP_TASK_MODEL ?? "gpt-5.4-mini";
   const prompt = taskSuggestionPrompt2(previousResponse);
   const codexCommand = await resolveSignupCodexCommand();
-  writeFileSync15(
+  writeFileSync16(
     schemaPath,
     `${JSON.stringify(taskSuggestionJsonSchema2(), null, 2)}
 `,
@@ -52705,9 +53113,9 @@ async function runCodexTaskSuggestion2(projectPath, previousResponse, retryPolic
       ),
       retryPolicy
     );
-    return readFileSync21(outputPath, "utf8");
+    return readFileSync22(outputPath, "utf8");
   } finally {
-    rmSync6(tempRoot, { recursive: true, force: true });
+    rmSync7(tempRoot, { recursive: true, force: true });
   }
 }
 function codexTaskSuggestionProcess2(args) {
@@ -52742,7 +53150,7 @@ function codexTaskSuggestionProcess2(args) {
 function signupCodexTaskSuggestionProcessForTest(args) {
   return codexTaskSuggestionProcess2(args);
 }
-async function resolveSignupCodexCommand(env = process.env, homeDir = homedir16(), executableExists = fileIsExecutable) {
+async function resolveSignupCodexCommand(env = process.env, homeDir = homedir17(), executableExists = fileIsExecutable) {
   const override = firstConfiguredValue([
     env.LINZUMI_SIGNUP_CODEX_BIN,
     env.LINZUMI_CODEX_BIN
@@ -52797,7 +53205,7 @@ function resolveHomePath(path2, homeDir) {
     return homeDir;
   }
   if (path2.startsWith("~/")) {
-    return join23(homeDir, path2.slice(2));
+    return join25(homeDir, path2.slice(2));
   }
   return resolve10(path2);
 }
@@ -52810,9 +53218,9 @@ function commandLooksPathLike(command) {
 }
 function homeManagedCodexCandidates(homeDir) {
   return [
-    join23(homeDir, ".volta", "bin", "codex"),
-    join23(homeDir, ".local", "bin", "codex"),
-    join23(homeDir, "bin", "codex")
+    join25(homeDir, ".volta", "bin", "codex"),
+    join25(homeDir, ".local", "bin", "codex"),
+    join25(homeDir, "bin", "codex")
   ];
 }
 async function firstExecutablePath(paths, executableExists) {
@@ -52827,7 +53235,7 @@ function commandPathCandidates(path2) {
   if (path2 === void 0 || path2.trim() === "") {
     return [];
   }
-  return path2.split(delimiter3).filter((entry) => entry.trim() !== "").map((entry) => join23(entry, "codex"));
+  return path2.split(delimiter3).filter((entry) => entry.trim() !== "").map((entry) => join25(entry, "codex"));
 }
 async function fileIsExecutable(path2) {
   try {
@@ -53060,11 +53468,11 @@ function codexPreflightLocation(command, homeDir) {
   switch (command) {
     case "codex":
       return "on PATH";
-    case join23(homeDir, ".volta", "bin", "codex"):
+    case join25(homeDir, ".volta", "bin", "codex"):
       return "via Volta";
-    case join23(homeDir, ".local", "bin", "codex"):
+    case join25(homeDir, ".local", "bin", "codex"):
       return "via ~/.local/bin";
-    case join23(homeDir, "bin", "codex"):
+    case join25(homeDir, "bin", "codex"):
       return "via ~/bin";
     default:
       return "from configured path";
@@ -53223,7 +53631,7 @@ function probeToolWithArgs(command, args, cwd) {
 }
 async function discoverCodeRoots(homeDir) {
   const candidates = ["src", "code", "projects"].map(
-    (name) => join23(homeDir, name)
+    (name) => join25(homeDir, name)
   );
   return candidates.filter((path2) => existsSync17(path2)).flatMap((path2) => discoveredProjectNames(path2));
 }
@@ -53277,7 +53685,7 @@ function discoverProjectsFromCurrentDirectory(cwd) {
 }
 function discoverProjectsFromGuessedRoots(homeDir) {
   const guessedRoots = ["src", "code", "projects"].map(
-    (name) => join23(homeDir, name)
+    (name) => join25(homeDir, name)
   );
   const projects = guessedRoots.flatMap(
     (root) => discoverProjectsUnderRoot(root)
@@ -53329,25 +53737,25 @@ function looksLikeProject(path2) {
     "pnpm-lock.yaml",
     "yarn.lock",
     "package-lock.json"
-  ].some((name) => existsSync17(join23(path2, name)));
+  ].some((name) => existsSync17(join25(path2, name)));
 }
 function detectProjectLanguage(path2) {
-  if (existsSync17(join23(path2, "pyproject.toml")) || existsSync17(join23(path2, "requirements.txt"))) {
+  if (existsSync17(join25(path2, "pyproject.toml")) || existsSync17(join25(path2, "requirements.txt"))) {
     return "Python";
   }
-  if (existsSync17(join23(path2, "Cargo.toml"))) {
+  if (existsSync17(join25(path2, "Cargo.toml"))) {
     return "Rust";
   }
-  if (existsSync17(join23(path2, "go.mod"))) {
+  if (existsSync17(join25(path2, "go.mod"))) {
     return "Go";
   }
-  if (existsSync17(join23(path2, "mix.exs"))) {
+  if (existsSync17(join25(path2, "mix.exs"))) {
     return "Elixir";
   }
-  if (existsSync17(join23(path2, "tsconfig.json")) || packageJsonMentionsTypeScript(path2)) {
+  if (existsSync17(join25(path2, "tsconfig.json")) || packageJsonMentionsTypeScript(path2)) {
     return "TypeScript";
   }
-  if (existsSync17(join23(path2, "package.json"))) {
+  if (existsSync17(join25(path2, "package.json"))) {
     return "JavaScript";
   }
   return "Project";
@@ -53355,7 +53763,7 @@ function detectProjectLanguage(path2) {
 function packageJsonMentionsTypeScript(path2) {
   try {
     const packageJson2 = JSON.parse(
-      readFileSync21(join23(path2, "package.json"), "utf8")
+      readFileSync22(join25(path2, "package.json"), "utf8")
     );
     return packageJson2.dependencies?.typescript !== void 0 || packageJson2.devDependencies?.typescript !== void 0;
   } catch {
@@ -53363,11 +53771,11 @@ function packageJsonMentionsTypeScript(path2) {
   }
 }
 function hasGitMetadata(path2) {
-  return existsSync17(join23(path2, ".git"));
+  return existsSync17(join25(path2, ".git"));
 }
 function childDirectories(root) {
   try {
-    return readdirSync5(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join23(root, entry.name));
+    return readdirSync5(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join25(root, entry.name));
   } catch {
     return [];
   }
@@ -53393,10 +53801,10 @@ function directoryExists(path2) {
 }
 function expandHomePath(path2) {
   if (path2 === "~") {
-    return homedir16();
+    return homedir17();
   }
   if (path2.startsWith("~/")) {
-    return join23(homedir16(), path2.slice(2));
+    return join25(homedir17(), path2.slice(2));
   }
   return resolve10(path2);
 }
@@ -53487,8 +53895,8 @@ init_runner();
 init_runnerLockTakeover();
 init_claudeCodeSession();
 init_authCache();
-import { existsSync as existsSync18, readFileSync as readFileSync22, realpathSync as realpathSync7 } from "node:fs";
-import { homedir as homedir17 } from "node:os";
+import { existsSync as existsSync18, readFileSync as readFileSync23, realpathSync as realpathSync7 } from "node:fs";
+import { homedir as homedir18 } from "node:os";
 import { resolve as resolve11 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
@@ -53583,9 +53991,9 @@ init_kandanTls();
 init_protocol();
 init_json();
 init_defaultUrls();
-import { existsSync as existsSync15, mkdirSync as mkdirSync13, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname14, join as join21 } from "node:path";
-import { homedir as homedir14 } from "node:os";
+import { existsSync as existsSync15, mkdirSync as mkdirSync14, readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname15, join as join22 } from "node:path";
+import { homedir as homedir15 } from "node:os";
 async function runAgentCliCommand(args, deps = {
   fetchImpl: fetch,
   stdout: process.stdout,
@@ -54293,7 +54701,7 @@ function agentTokenFile(flags) {
   return flags.get("agent-token-file") ?? defaultAgentTokenFilePath();
 }
 function defaultAgentTokenFilePath() {
-  return join21(homedir14(), ".linzumi", "agent-token.json");
+  return join22(homedir15(), ".linzumi", "agent-token.json");
 }
 function normalizedApiUrl(apiUrl) {
   return apiUrl.endsWith("/") ? apiUrl : `${apiUrl}/`;
@@ -54302,11 +54710,11 @@ function authorizationHeaders(token) {
   return { authorization: `Bearer ${token}` };
 }
 function readOptionalTextFile(path2) {
-  return existsSync15(path2) ? readFileSync18(path2, "utf8") : void 0;
+  return existsSync15(path2) ? readFileSync19(path2, "utf8") : void 0;
 }
 function writeTextFile(path2, content) {
-  mkdirSync13(dirname14(path2), { recursive: true });
-  writeFileSync12(path2, content);
+  mkdirSync14(dirname15(path2), { recursive: true });
+  writeFileSync13(path2, content);
 }
 function readStoredAgentTokenFile(path2, readTextFile = readOptionalTextFile) {
   const content = readTextFile(path2);
@@ -54395,25 +54803,25 @@ init_runnerLogger();
 import {
   existsSync as existsSync16,
   closeSync as closeSync3,
-  mkdirSync as mkdirSync14,
+  mkdirSync as mkdirSync15,
   openSync as openSync4,
-  readFileSync as readFileSync19,
+  readFileSync as readFileSync20,
   watch,
-  writeFileSync as writeFileSync13
+  writeFileSync as writeFileSync14
 } from "node:fs";
-import { homedir as homedir15 } from "node:os";
-import { dirname as dirname15, join as join22, resolve as resolve9 } from "node:path";
+import { homedir as homedir16 } from "node:os";
+import { dirname as dirname16, join as join23, resolve as resolve9 } from "node:path";
 import { execFileSync, spawn as spawn10 } from "node:child_process";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var connectedMarkers = ["Connected to Linzumi", "Runner connected:"];
 function commanderStatusDir() {
-  return join22(homedir15(), ".linzumi", "commanders");
+  return join23(homedir16(), ".linzumi", "commanders");
 }
 function commanderStatusFile(runnerId, statusDir = commanderStatusDir()) {
-  return join22(statusDir, `${safeRunnerId(runnerId)}.json`);
+  return join23(statusDir, `${safeRunnerId(runnerId)}.json`);
 }
 function defaultCommanderLogFile(runnerId) {
-  return join22(homedir15(), ".linzumi", "logs", `${safeRunnerId(runnerId)}.log`);
+  return join23(homedir16(), ".linzumi", "logs", `${safeRunnerId(runnerId)}.log`);
 }
 function commanderLogIsConnected(log2) {
   return connectedMarkers.some((marker) => log2.includes(marker));
@@ -54434,8 +54842,8 @@ function startCommanderDaemon(options) {
     "--log-file",
     logFile
   ];
-  mkdirSync14(statusDir, { recursive: true });
-  mkdirSync14(dirname15(logFile), { recursive: true });
+  mkdirSync15(statusDir, { recursive: true });
+  mkdirSync15(dirname16(logFile), { recursive: true });
   const out = openSync4(logFile, "a");
   const err = openSync4(logFile, "a");
   writeCliAuditEvent(
@@ -54481,7 +54889,7 @@ function startCommanderDaemon(options) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     command: [nodeBin, ...command]
   };
-  writeFileSync13(statusFile, `${JSON.stringify(record, null, 2)}
+  writeFileSync14(statusFile, `${JSON.stringify(record, null, 2)}
 `);
   return record;
 }
@@ -54490,12 +54898,12 @@ function commanderDaemonStatus(runnerId, statusDir = commanderStatusDir(), proce
   if (!existsSync16(statusFile)) {
     return { status: "missing", runnerId, statusFile };
   }
-  const record = parseRecord(readFileSync19(statusFile, "utf8"));
+  const record = parseRecord2(readFileSync20(statusFile, "utf8"));
   return processIsRunning(record.pid) && processMatchesRecord(record, processIdentityReader) ? { status: "running", record } : { status: "stopped", record };
 }
 async function waitForCommanderDaemon(options) {
   const now = options.now ?? (() => Date.now());
-  const readTextFile = options.readTextFile ?? ((path2) => existsSync16(path2) ? readFileSync19(path2, "utf8") : void 0);
+  const readTextFile = options.readTextFile ?? ((path2) => existsSync16(path2) ? readFileSync20(path2, "utf8") : void 0);
   const statusImpl = options.statusImpl ?? commanderDaemonStatus;
   const deadline = now() + options.timeoutMs;
   while (now() <= deadline) {
@@ -54559,7 +54967,7 @@ function currentEntrypoint() {
   }
   return fileURLToPath3(import.meta.url);
 }
-function parseRecord(content) {
+function parseRecord2(content) {
   const parsed = JSON.parse(content);
   const record = typeof parsed === "object" && parsed !== null ? parsed : {};
   const pid = typeof record.pid === "number" ? record.pid : void 0;
@@ -67377,13 +67785,18 @@ function required(values, key) {
 }
 
 // src/remoteCodexHarnessWorker.ts
+init_authCache();
 init_channelSession();
 init_codexAppServer();
 init_localCapabilities();
+init_mcpConfig();
 init_phoenix();
 init_runnerLogger();
 init_userFacingErrors();
 init_version();
+import { chmodSync as chmodSync3, mkdtempSync as mkdtempSync5, rmSync as rmSync6 } from "node:fs";
+import { tmpdir as tmpdir4 } from "node:os";
+import { basename as basename9, dirname as dirname17, join as join24 } from "node:path";
 var configEnvKey = "LINZUMI_REMOTE_CODEX_HARNESS_CONFIG_B64";
 var remoteHarnessEnvironmentId = "linzumi-remote-codex-harness";
 async function runRemoteCodexHarnessWorkerFromEnv(env = process.env) {
@@ -67400,17 +67813,42 @@ async function runRemoteCodexHarnessWorker(config, deps = {}) {
     log: writeCliAuditEvent,
     ...deps
   };
-  const started = await resolvedDeps.startCodexAppServer(
-    config.codexBin,
-    config.workerCwd,
-    {
-      model: config.model,
-      reasoningEffort: config.reasoningEffort,
-      fast: config.fast,
-      inheritEnv: false,
-      env: remoteHarnessCodexEnv(process.env, config.execServerUrl)
-    }
+  const mcpAuth = writeEphemeralMcpAuthFile2(config);
+  const mcpCommand = linzumiMcpCommandForProcess(
+    process.execPath,
+    resolveLinzumiCliEntrypoint(process.argv[1]),
+    process.execArgv
   );
+  let started;
+  try {
+    started = await resolvedDeps.startCodexAppServer(
+      config.codexBin,
+      config.workerCwd,
+      {
+        model: config.model,
+        reasoningEffort: config.reasoningEffort,
+        fast: config.fast,
+        inheritEnv: false,
+        env: remoteHarnessCodexEnv(process.env, config.execServerUrl),
+        mcpServers: [
+          linzumiMcpServerConfig({
+            command: mcpCommand.command,
+            argsPrefix: mcpCommand.argsPrefix,
+            kandanUrl: config.kandanUrl,
+            authFilePath: mcpAuth.path,
+            ownerUsername: config.listenUser,
+            operatingMode: "text",
+            cwd: config.cwd,
+            threadId: config.kandanThreadId
+          })
+        ]
+      }
+    );
+  } catch (error) {
+    mcpAuth.cleanup();
+    throw error;
+  }
+  started.process.once("exit", () => mcpAuth.cleanup());
   let kandan;
   let codex;
   let session;
@@ -67419,6 +67857,7 @@ async function runRemoteCodexHarnessWorker(config, deps = {}) {
     codex?.close();
     kandan?.close();
     started.stop();
+    mcpAuth.cleanup();
   };
   const cleanupOnce = onceAsync(cleanup);
   try {
@@ -67581,6 +68020,50 @@ function assertJsonRpcOk(response, method) {
     throw new Error(`${method} failed: ${response.error.message}`);
   }
 }
+function resolveLinzumiCliEntrypoint(entrypoint) {
+  if (entrypoint === void 0 || entrypoint.trim() === "") {
+    return entrypoint;
+  }
+  const base = basename9(entrypoint);
+  switch (base) {
+    case "remote-codex-harness-worker.js":
+    case "remote-codex-harness-worker.mjs":
+    case "remote-codex-harness-worker.cjs":
+      return join24(dirname17(entrypoint), "linzumi.js");
+    case "remoteCodexHarnessWorkerEntrypoint.ts":
+    case "remoteCodexHarnessWorkerEntrypoint.js":
+      return join24(dirname17(entrypoint), "index.ts");
+    default:
+      return entrypoint;
+  }
+}
+function writeEphemeralMcpAuthFile2(options) {
+  const directory = mkdtempSync5(join24(tmpdir4(), "linzumi-mcp-auth-"));
+  chmodSync3(directory, 448);
+  const path2 = join24(directory, "auth.json");
+  try {
+    writeCachedLocalRunnerToken({
+      kandanUrl: options.kandanUrl,
+      accessToken: options.token,
+      authFilePath: path2
+    });
+    chmodSync3(path2, 384);
+  } catch (error) {
+    rmSync6(directory, { recursive: true, force: true });
+    throw error;
+  }
+  let cleaned = false;
+  return {
+    path: path2,
+    cleanup: () => {
+      if (cleaned) {
+        return;
+      }
+      cleaned = true;
+      rmSync6(directory, { recursive: true, force: true });
+    }
+  };
+}
 function remoteHarnessCodexEnv(sourceEnv, execServerUrl) {
   const env = {
     CODEX_EXEC_SERVER_URL: execServerUrl,
@@ -68504,7 +68987,7 @@ async function parseAgentRunnerArgs(args, deps = {
   };
 }
 function readAgentTokenTextFile(path2) {
-  return existsSync18(path2) ? readFileSync22(path2, "utf8") : void 0;
+  return existsSync18(path2) ? readFileSync23(path2, "utf8") : void 0;
 }
 function rejectAgentRunnerTargetingFlags(values) {
   const unsupportedFlags = [
@@ -68818,10 +69301,10 @@ function rejectStartTargetingFlags(values) {
 }
 function resolveUserPath(pathValue) {
   if (pathValue === "~") {
-    return homedir17();
+    return homedir18();
   }
   if (pathValue.startsWith("~/")) {
-    return resolve11(homedir17(), pathValue.slice(2));
+    return resolve11(homedir18(), pathValue.slice(2));
   }
   return resolve11(pathValue);
 }