@linzumi/cli 0.0.96-beta → 0.0.98-beta

package/README.md

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

package/dist/index.js

@@ -125,25 +125,31 @@ function discoverCurrentGitProject(args) {
   const responsiveness = args.placeResponsiveness;
   const candidates = /* @__PURE__ */ new Map();
   const searchStats = [];
-  const cwdResponsive = isPlaceResponsive(args.cwd, responsiveness);
-  const gitStartedAtMs = Date.now();
-  const topLevel = cwdResponsive ? gitOutput(args.cwd, ["rev-parse", "--show-toplevel"]) : void 0;
-  const gitDurationMs = Date.now() - gitStartedAtMs;
-  if (topLevel !== void 0) {
-    mergeCandidate(
-      candidates,
-      projectCandidateFromWorktree(topLevel, "local_current_git", topLevel)
-    );
-  }
-  searchStats.push({
-    place: args.cwd,
-    source: "git",
-    duration_ms: gitDurationMs,
-    result_count: topLevel === void 0 ? 0 : 1,
-    skipped_unresponsive: cwdResponsive ? void 0 : true
+  const selectedScanRoots = uniqueStrings(args.selectedScanRoots ?? []);
+  const selectedScanRootSet = new Set(selectedScanRoots);
+  const sourceRoots = args.sourceRoots ?? defaultLocalProjectSourceRoots({
+    cwd: args.cwd,
+    homeDir: args.homeDir,
+    selectedScanRoots
+  });
+  const sourceRootMaxDepth = normalizeSourceRootMaxDepth(
+    args.sourceRootMaxDepth
+  );
+  const sourceRootScanDeadlineMs = Date.now() + normalizeSourceRootScanBudgetMs(args.sourceRootScanBudgetMs);
+  const createSourceRootScanBudget = () => ({
+    deadlineMs: sourceRootScanDeadlineMs,
+    maxDirectoryVisits: normalizeSourceRootMaxDirectoryVisits(
+      args.sourceRootMaxDirectoryVisits
+    ),
+    maxProjectEnrichments: normalizeSourceRootMaxProjectEnrichments(
+      args.sourceRootMaxProjectEnrichments
+    ),
+    directoryVisits: 0,
+    projectEnrichments: 0,
+    exhausted: false
   });
-  const sourceRoots = args.sourceRoots ?? defaultLocalProjectSourceRoots(args.cwd);
-  let placesSearched = 1;
+  const defaultSourceRootScanBudget = createSourceRootScanBudget();
+  let placesSearched = 0;
   const scanBudgetMs = projectScanBudgetMs();
   for (const sourceRoot of sourceRoots) {
     if (Date.now() - startedAtMs >= scanBudgetMs) {
@@ -158,6 +164,19 @@ function discoverCurrentGitProject(args) {
       continue;
     }
     const sourceRootStartedAtMs = Date.now();
+    const isSelectedScanRoot = selectedScanRootSet.has(sourceRoot);
+    const sourceRootScanBudget = isSelectedScanRoot ? createSourceRootScanBudget() : defaultSourceRootScanBudget;
+    if (isSourceRootScanBudgetExhausted(sourceRootScanBudget)) {
+      searchStats.push({
+        place: sourceRoot,
+        source: "git",
+        duration_ms: Date.now() - sourceRootStartedAtMs,
+        result_count: 0,
+        scan_budget_exhausted: true
+      });
+      placesSearched += 1;
+      continue;
+    }
     const rootResponsive = isPlaceResponsive(sourceRoot, responsiveness);
     if (!rootResponsive) {
       searchStats.push({
@@ -170,25 +189,60 @@ function discoverCurrentGitProject(args) {
       placesSearched += 1;
       continue;
     }
-    if (!isDirectory(sourceRoot)) {
+    const directoryExists2 = isDirectory(sourceRoot);
+    if (!directoryExists2) {
+      if (isSelectedScanRoot) {
+        searchStats.push({
+          place: sourceRoot,
+          source: "git",
+          duration_ms: Date.now() - sourceRootStartedAtMs,
+          result_count: 0,
+          missing_directory: true
+        });
+        placesSearched += 1;
+      }
       continue;
     }
-    const foundInRoot = discoverGitWorktreesInSourceRoot(sourceRoot);
-    for (const worktreePath of foundInRoot) {
-      mergeCandidate(
+    const foundInRoot = discoverGitWorktreesInSourceRoot(
+      sourceRoot,
+      sourceRootMaxDepth,
+      responsiveness,
+      sourceRootScanBudget
+    );
+    const enrichedProjectCount = enrichSourceRootProjects(
+      candidates,
+      foundInRoot,
+      sourceRootScanBudget
+    );
+    searchStats.push({
+      place: sourceRoot,
+      source: "git",
+      duration_ms: Date.now() - sourceRootStartedAtMs,
+      result_count: enrichedProjectCount,
+      scan_budget_exhausted: sourceRootScanBudget.exhausted ? true : void 0
+    });
+    placesSearched += 1;
+    if (sourceRootScanBudget.exhausted) {
+      continue;
+    }
+  }
+  if (args.includeRuntimeCwdHint !== false) {
+    const cwdResponsive = isPlaceResponsive(args.cwd, responsiveness);
+    const gitStartedAtMs = Date.now();
+    const topLevel = cwdResponsive ? gitOutput(args.cwd, ["rev-parse", "--show-toplevel"]) : void 0;
+    const gitDurationMs = Date.now() - gitStartedAtMs;
+    if (topLevel !== void 0) {
+      mergeRuntimeCwdCandidate(
         candidates,
-        projectCandidateFromWorktree(
-          worktreePath,
-          "local_source_root",
-          topLevel
-        )
+        projectCandidateFromWorktree(topLevel, "runtime_cwd_hint", topLevel)
       );
     }
     searchStats.push({
-      place: sourceRoot,
+      place: args.cwd,
       source: "git",
-      duration_ms: Date.now() - sourceRootStartedAtMs,
-      result_count: foundInRoot.length
+      duration_ms: gitDurationMs,
+      result_count: topLevel === void 0 ? 0 : 1,
+      skipped_unresponsive: cwdResponsive ? void 0 : true
     });
     placesSearched += 1;
   }
@@ -261,16 +315,60 @@ function mergeCandidate(candidates, candidate) {
   const existing = candidates.get(candidate.importKey);
   if (existing === void 0 || shouldReplaceCandidate(existing, candidate)) {
     candidates.set(candidate.importKey, candidate);
+    return;
+  }
+  const currentWorktreePath = candidate.metadata.current_worktree_path;
+  if (existing.metadata.current_worktree_path === void 0 && typeof currentWorktreePath === "string") {
+    candidates.set(candidate.importKey, {
+      ...existing,
+      metadata: {
+        ...existing.metadata,
+        current_worktree_path: currentWorktreePath
+      }
+    });
+  }
+}
+function mergeRuntimeCwdCandidate(candidates, candidate) {
+  if (candidate === void 0) {
+    return;
+  }
+  const existing = candidates.get(candidate.importKey);
+  if (existing !== void 0 && existing.metadata.discovery_method === "local_source_root" && existing.path !== candidate.path) {
+    candidates.set(candidate.importKey, {
+      ...candidate,
+      metadata: {
+        ...candidate.metadata,
+        discovery_method: "local_source_root"
+      }
+    });
+    return;
   }
+  mergeCandidate(candidates, candidate);
+}
+function enrichSourceRootProjects(candidates, worktreePaths, scanBudget) {
+  return worktreePaths.reduce((enrichedCount, worktreePath) => {
+    if (!consumeSourceRootProjectEnrichmentBudget(scanBudget)) {
+      return enrichedCount;
+    }
+    const candidate = projectCandidateFromWorktree(
+      worktreePath,
+      "local_source_root"
+    );
+    if (candidate === void 0) {
+      return enrichedCount;
+    }
+    mergeCandidate(candidates, candidate);
+    return enrichedCount + 1;
+  }, 0);
 }
 function shouldReplaceCandidate(existing, candidate) {
   const existingMethod = existing.metadata.discovery_method;
   const candidateMethod = candidate.metadata.discovery_method;
-  if (existingMethod === "local_current_git") {
-    return false;
+  if (existingMethod === "runtime_cwd_hint") {
+    return candidateMethod !== "runtime_cwd_hint";
   }
-  if (candidateMethod === "local_current_git") {
-    return true;
+  if (candidateMethod === "runtime_cwd_hint") {
+    return false;
   }
   const existingActivity = Date.parse(existing.activityAt ?? "");
   const candidateActivity = Date.parse(candidate.activityAt ?? "");
@@ -296,32 +394,91 @@ function compareProjectCandidates(left, right) {
   }
   return left.displayName.localeCompare(right.displayName);
 }
-function discoverGitWorktreesInSourceRoot(sourceRoot) {
+function discoverGitWorktreesInSourceRoot(sourceRoot, maxDepth, responsiveness, scanBudget) {
   if (!isDirectory(sourceRoot)) {
     return [];
   }
+  return uniqueStrings(
+    discoverGitWorktreesBelow(sourceRoot, maxDepth, responsiveness, scanBudget)
+  ).sort();
+}
+function discoverGitWorktreesBelow(directory, depthRemaining, responsiveness, scanBudget) {
+  if (!consumeSourceRootScanBudget(scanBudget)) {
+    return [];
+  }
+  if (depthRemaining < 0) {
+    return [];
+  }
+  if (isGitWorktreeRoot(directory)) {
+    return [directory];
+  }
+  if (depthRemaining === 0) {
+    return [];
+  }
+  let entries;
   try {
-    return readdirSync(sourceRoot, { withFileTypes: true }).flatMap((entry) => {
-      if (!entry.isDirectory()) {
-        return [];
-      }
-      const candidatePath = join(sourceRoot, entry.name);
-      return isGitWorktreeRoot(candidatePath) ? [candidatePath] : [];
-    }).sort();
+    entries = readdirSync(directory, { withFileTypes: true });
   } catch (_error) {
     return [];
   }
+  return entries.flatMap((entry) => {
+    if (!entry.isDirectory()) {
+      return [];
+    }
+    if (ignoredSourceRootDirectoryNames.has(entry.name)) {
+      return [];
+    }
+    const childPath = join(directory, entry.name);
+    if (isSourceRootScanBudgetExhausted(scanBudget)) {
+      return [];
+    }
+    if (!isPlaceResponsive(childPath, responsiveness)) {
+      return [];
+    }
+    return discoverGitWorktreesBelow(
+      childPath,
+      depthRemaining - 1,
+      responsiveness,
+      scanBudget
+    );
+  });
+}
+function consumeSourceRootScanBudget(scanBudget) {
+  if (isSourceRootScanBudgetExhausted(scanBudget)) {
+    return false;
+  }
+  scanBudget.directoryVisits += 1;
+  return true;
+}
+function consumeSourceRootProjectEnrichmentBudget(scanBudget) {
+  if (Date.now() >= scanBudget.deadlineMs || scanBudget.projectEnrichments >= scanBudget.maxProjectEnrichments) {
+    scanBudget.exhausted = true;
+    return false;
+  }
+  scanBudget.projectEnrichments += 1;
+  return true;
+}
+function isSourceRootScanBudgetExhausted(scanBudget) {
+  if (scanBudget.exhausted) {
+    return true;
+  }
+  if (Date.now() >= scanBudget.deadlineMs || scanBudget.directoryVisits >= scanBudget.maxDirectoryVisits || scanBudget.projectEnrichments >= scanBudget.maxProjectEnrichments) {
+    scanBudget.exhausted = true;
+    return true;
+  }
+  return false;
 }
 function isGitWorktreeRoot(path2) {
   return existsSync(join(path2, ".git"));
 }
-function defaultLocalProjectSourceRoots(cwd) {
-  if (cwd === dirname(cwd)) {
+function defaultLocalProjectSourceRoots(args) {
+  if (args.cwd === dirname(args.cwd)) {
     return [];
   }
   return uniqueStrings([
-    ...ancestorSourceRoots(cwd),
-    ...homeSourceRoots(),
+    ...homeSourceRoots(args.homeDir),
+    ...args.selectedScanRoots ?? [],
+    ...ancestorSourceRoots(args.cwd),
     ...externalVolumeSourceRoots()
   ]);
 }
@@ -344,8 +501,8 @@ function ancestorSourceRoots(cwd) {
   }
   return roots;
 }
-function homeSourceRoots() {
-  const home = homedir();
+function homeSourceRoots(homeDir) {
+  const home = homeDir ?? homedir();
   return [
     "code",
     "src",
@@ -385,6 +542,42 @@ function isDirectory(path2) {
     return false;
   }
 }
+function normalizeSourceRootMaxDepth(value) {
+  if (value === void 0) {
+    return defaultSourceRootMaxDepth;
+  }
+  if (!Number.isFinite(value) || value < 0) {
+    return defaultSourceRootMaxDepth;
+  }
+  return Math.floor(value);
+}
+function normalizeSourceRootScanBudgetMs(value) {
+  if (value === void 0) {
+    return defaultSourceRootScanBudgetMs;
+  }
+  if (!Number.isFinite(value) || value <= 0) {
+    return defaultSourceRootScanBudgetMs;
+  }
+  return Math.floor(value);
+}
+function normalizeSourceRootMaxDirectoryVisits(value) {
+  if (value === void 0) {
+    return defaultSourceRootMaxDirectoryVisits;
+  }
+  if (!Number.isFinite(value) || value <= 0) {
+    return defaultSourceRootMaxDirectoryVisits;
+  }
+  return Math.floor(value);
+}
+function normalizeSourceRootMaxProjectEnrichments(value) {
+  if (value === void 0) {
+    return defaultSourceRootMaxProjectEnrichments;
+  }
+  if (!Number.isFinite(value) || value <= 0) {
+    return defaultSourceRootMaxProjectEnrichments;
+  }
+  return Math.floor(value);
+}
 function uniqueStrings(values) {
   return Array.from(new Set(values));
 }
@@ -432,13 +625,29 @@ function compactJsonObject(value) {
     })
   );
 }
-var worktreePathSampleLimit, gitSpawnTimeoutMs, defaultProjectScanBudgetMs;
+var worktreePathSampleLimit, gitSpawnTimeoutMs, defaultSourceRootMaxDepth, defaultSourceRootScanBudgetMs, defaultSourceRootMaxDirectoryVisits, defaultSourceRootMaxProjectEnrichments, ignoredSourceRootDirectoryNames, defaultProjectScanBudgetMs;
 var init_onboardingProjectDiscovery = __esm({
   "src/onboardingProjectDiscovery.ts"() {
     "use strict";
     init_onboardingPlaceResponsiveness();
     worktreePathSampleLimit = 25;
     gitSpawnTimeoutMs = 4e3;
+    defaultSourceRootMaxDepth = 4;
+    defaultSourceRootScanBudgetMs = 2e4;
+    defaultSourceRootMaxDirectoryVisits = 5e3;
+    defaultSourceRootMaxProjectEnrichments = 100;
+    ignoredSourceRootDirectoryNames = /* @__PURE__ */ new Set([
+      ".cache",
+      ".git",
+      ".next",
+      ".pnpm-store",
+      ".turbo",
+      "build",
+      "dist",
+      "Library",
+      "node_modules",
+      "target"
+    ]);
     defaultProjectScanBudgetMs = 2e4;
   }
 });
@@ -1115,7 +1324,27 @@ async function runOnboardingDiscoveryChildRole(kind, stdin, stdout) {
   if (kind === "projects") {
     const { discoverCurrentGitProject: discoverCurrentGitProject2 } = await Promise.resolve().then(() => (init_onboardingProjectDiscovery(), onboardingProjectDiscovery_exports));
     const cwd = typeof args.cwd === "string" ? args.cwd : process.cwd();
-    stdout.write(JSON.stringify(discoverCurrentGitProject2({ cwd })));
+    const homeDir = typeof args.homeDir === "string" ? args.homeDir : void 0;
+    const sourceRoots = Array.isArray(args.sourceRoots) ? args.sourceRoots.filter(
+      (path2) => typeof path2 === "string"
+    ) : void 0;
+    const selectedScanRoots = Array.isArray(args.selectedScanRoots) ? args.selectedScanRoots.filter(
+      (path2) => typeof path2 === "string"
+    ) : void 0;
+    const sourceRootMaxDepth = typeof args.sourceRootMaxDepth === "number" ? args.sourceRootMaxDepth : void 0;
+    const includeRuntimeCwdHint = typeof args.includeRuntimeCwdHint === "boolean" ? args.includeRuntimeCwdHint : void 0;
+    stdout.write(
+      JSON.stringify(
+        discoverCurrentGitProject2({
+          cwd,
+          homeDir,
+          sourceRoots,
+          selectedScanRoots,
+          includeRuntimeCwdHint,
+          sourceRootMaxDepth
+        })
+      )
+    );
     return 0;
   }
   if (kind === "conversations") {
@@ -7269,6 +7498,18 @@ function dequeuePendingKandanMessage(queue) {
   compactPendingKandanMessageQueue(queue);
   return message;
 }
+function drainAllPendingKandanMessages(queue) {
+  const drained = [];
+  for (let index = queue.head; index < queue.items.length; index += 1) {
+    const message = queue.items[index];
+    if (message !== void 0) {
+      drained.push(message);
+    }
+  }
+  queue.items = [];
+  queue.head = 0;
+  return drained;
+}
 function requeuePendingKandanMessageFront(queue, message) {
   if (queue.head > 0) {
     queue.head = queue.head - 1;
@@ -7278,7 +7519,10 @@ function requeuePendingKandanMessageFront(queue, message) {
   queue.items.unshift(message);
 }
 function interruptPendingKandanMessages(queue, throughSeq) {
-  const result = interruptQueuedMessages(pendingKandanMessages(queue), throughSeq);
+  const result = interruptQueuedMessages(
+    pendingKandanMessages(queue),
+    throughSeq
+  );
   if (result.ok) {
     replacePendingKandanMessages(queue, result.queue);
   }
@@ -8997,6 +9241,7 @@ function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThread
     failedSeqs: /* @__PURE__ */ new Map(),
     drainInFlight: false,
     drainRequested: false,
+    deadWorkerRebuildAttempts: 0,
     boundStartTimeout: false,
     fusedQueuedSeqs: /* @__PURE__ */ new Map(),
     reconnectRetryTimer: void 0,
@@ -10568,6 +10813,9 @@ async function drainKandanMessageQueue(args, state, payloadContext) {
   }
 }
 async function drainKandanMessageQueueOnce(args, state, payloadContext) {
+  if (await rebuildIfCodexWorkerDead(args, state)) {
+    return;
+  }
   if (drainKandanMessageQueueBlocked(args, state)) {
     return;
   }
@@ -10649,6 +10897,14 @@ async function drainKandanMessageQueueOnce(args, state, payloadContext) {
       await drainKandanMessageQueue(args, state, payloadContext);
     }
   } catch (error) {
+    if (codexWorkerIsDead(args)) {
+      await stopCodexTyping(args, state);
+      requeuePendingKandanMessageFront(state.queue, next);
+      state.turn = { status: "idle" };
+      clearActiveProcessingState(state, next.seq);
+      await rebuildIfCodexWorkerDead(args, state);
+      return;
+    }
     if (isRecoverableCodexThreadError(error) && state.kandanThreadId !== void 0) {
       const oldCodexThreadId = state.codexThreadId;
       try {
@@ -10709,6 +10965,83 @@ async function drainKandanMessageQueueOnce(args, state, payloadContext) {
     }
   }
 }
+function codexWorkerIsDead(args) {
+  return args.codex.isClosed?.() === true;
+}
+async function rebuildIfCodexWorkerDead(args, state) {
+  if (!codexWorkerIsDead(args)) {
+    return false;
+  }
+  const pending = drainAllPendingKandanMessages(state.queue);
+  if (pending.length === 0) {
+    return false;
+  }
+  const { codexThreadId, kandanThreadId } = state;
+  const rebuild = args.options.rebuildOnDeadCodexWorker;
+  args.log("kandan.queue_drain_dead_worker_rebuild", {
+    codex_thread_id: codexThreadId ?? null,
+    kandan_thread_id: kandanThreadId ?? null,
+    pending_count: pending.length,
+    attempt: state.deadWorkerRebuildAttempts + 1,
+    rebuild_available: rebuild !== void 0
+  });
+  const failPending = async (reason) => {
+    for (const message of pending) {
+      try {
+        await publishQueuedMessageState(args, state, message, {
+          status: "failed",
+          reason
+        });
+      } catch (error) {
+        args.log("kandan.queue_drain_dead_worker_fail_publish_failed", {
+          codex_thread_id: codexThreadId ?? null,
+          seq: message.seq,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+  if (rebuild === void 0 || codexThreadId === void 0 || kandanThreadId === void 0) {
+    await failPending(
+      "Codex worker for this thread exited and could not be respawned to resume the conversation."
+    );
+    return true;
+  }
+  if (state.deadWorkerRebuildAttempts >= maxDeadWorkerRebuildAttempts) {
+    args.log("kandan.queue_drain_dead_worker_rebuild_exhausted", {
+      codex_thread_id: codexThreadId,
+      kandan_thread_id: kandanThreadId,
+      attempts: state.deadWorkerRebuildAttempts
+    });
+    await failPending(
+      "Codex worker for this thread kept exiting on resume; giving up after several respawn attempts."
+    );
+    return true;
+  }
+  state.deadWorkerRebuildAttempts += 1;
+  state.closed = true;
+  let rebuilt = false;
+  try {
+    rebuilt = await rebuild({
+      codexThreadId,
+      kandanThreadId,
+      pendingMessages: pending
+    });
+  } catch (error) {
+    args.log("kandan.queue_drain_dead_worker_rebuild_failed", {
+      codex_thread_id: codexThreadId,
+      kandan_thread_id: kandanThreadId,
+      message: error instanceof Error ? error.message : String(error)
+    });
+    rebuilt = false;
+  }
+  if (!rebuilt) {
+    await failPending(
+      "Codex worker for this thread exited and could not be respawned to resume the conversation."
+    );
+  }
+  return true;
+}
 function drainKandanMessageQueueBlocked(args, state) {
   if (state.closed) {
     logQueuedDrainBlocked(args, state, "session_closed");
@@ -11720,7 +12053,7 @@ async function pushOptional(kandan, topic, event, payload, log2) {
     });
   }
 }
-var codexTypingHeartbeatMs, CODEX_START_REQUEST_TIMEOUT_MS, CodexStartRequestTimeoutError, maxTrackedFailedChatEventSeqs, maxChatEventFailureAttempts, maxForwardedTurnIds, maxClaimedKandanMessageKeys, claimedKandanMessageKeys, nextChatJoinRegistrationSerial, defaultReconnectHandlingRetryDelaysMs, defaultTuiInputMirrorRetryDelaysMs, pipelineCloseTimeoutMs;
+var codexTypingHeartbeatMs, CODEX_START_REQUEST_TIMEOUT_MS, CodexStartRequestTimeoutError, maxTrackedFailedChatEventSeqs, maxChatEventFailureAttempts, maxForwardedTurnIds, maxClaimedKandanMessageKeys, claimedKandanMessageKeys, nextChatJoinRegistrationSerial, defaultReconnectHandlingRetryDelaysMs, defaultTuiInputMirrorRetryDelaysMs, pipelineCloseTimeoutMs, maxDeadWorkerRebuildAttempts;
 var init_channelSession = __esm({
   "src/channelSession.ts"() {
     "use strict";
@@ -11771,6 +12104,7 @@ var init_channelSession = __esm({
       15e3
     ];
     pipelineCloseTimeoutMs = 1e4;
+    maxDeadWorkerRebuildAttempts = 3;
   }
 });
 
@@ -14371,7 +14705,16 @@ function linzumiMcpServerConfig(options) {
       ...options.toolScope === void 0 || options.toolScope === "all" ? [] : ["--tool-scope", options.toolScope]
     ],
     env: {
-      ...options.accessToken === void 0 ? {} : { LINZUMI_MCP_ACCESS_TOKEN: options.accessToken }
+      ...options.accessToken === void 0 ? {} : { LINZUMI_MCP_ACCESS_TOKEN: options.accessToken },
+      // The Linzumi metadata MCP is launched by codex as a STDIO child whose
+      // `command` may be the Electron app binary. That binary only behaves as a
+      // plain Node process (and thus boots the MCP server instead of a GUI
+      // shell) when ELECTRON_RUN_AS_NODE=1 is present in its env. Newer codex
+      // sanitizes MCP-child env to an allowlist that drops ELECTRON_RUN_AS_NODE,
+      // so we both (a) pin it here and (b) explicitly forward it via
+      // codexMcpConfigArgs / codexMcpConfigToml below. For a real Node `command`
+      // this flag is a harmless no-op, so we always include it.
+      ELECTRON_RUN_AS_NODE: "1"
     }
   };
 }
@@ -14380,7 +14723,16 @@ function codexMcpConfigArgs(config) {
     "-c",
     `mcp_servers.${config.name}.command=${JSON.stringify(config.command)}`,
     "-c",
-    `mcp_servers.${config.name}.args=${tomlStringArray(config.args)}`
+    `mcp_servers.${config.name}.args=${tomlStringArray(config.args)}`,
+    // Explicitly forward the server env (ELECTRON_RUN_AS_NODE,
+    // LINZUMI_MCP_ACCESS_TOKEN, …) so codex passes it to the stdio child
+    // regardless of its env-forwarding/sanitization allowlist. Without this,
+    // newer codex strips ELECTRON_RUN_AS_NODE and the Electron-binary `command`
+    // boots a GUI shell that pollutes the MCP stdout JSON-RPC framing.
+    ...Object.entries(config.env).flatMap(([key, value]) => [
+      "-c",
+      `mcp_servers.${config.name}.env.${key}=${JSON.stringify(value)}`
+    ])
   ];
 }
 function linzumiMcpCommandForProcess(processExecPath, scriptPath, execArgv = []) {
@@ -19451,7 +19803,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.96-beta";
+    linzumiCliVersion = "0.0.98-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -23211,6 +23563,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
   const missingAllowedCwds = {
     value: normalizeAllowedCwds(options.missingAllowedCwds ?? [])
   };
+  const projectDiscoveryCwdIsSelectedRootFromSyncedConfig = { value: false };
   const applyRunnerConfigSync = (config, syncOptions) => {
     const persistedAllowedCwds = replaceAllowedCwdsForLinzumiUrl(
       config.allowedCwds,
@@ -23219,6 +23572,10 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     const updatedAllowedCwds = configuredAllowedCwds(persistedAllowedCwds, {
       createMissing: true
     });
+    projectDiscoveryCwdIsSelectedRootFromSyncedConfig.value = projectDiscoveryCwdIsSelectedRootFromSyncedConfig.value || allowedCwdsContainAny(updatedAllowedCwds.allowedCwds, [
+      options.cwd,
+      ...startupAllowedCwds
+    ]);
     allowedCwds.value = normalizeAllowedCwds([
       ...syncOptions.includeStartupAllowedCwds ? startupAllowedCwds : [],
       ...updatedAllowedCwds.allowedCwds
@@ -23305,6 +23662,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
       allowedCwds.value
     ),
     allowedCwdProjects: allowedCwdProjects(allowedCwds.value),
+    onboardingSelectedFolderScan: true,
     portForwarding: liveForwardPorts.size > 0,
     tcpForwarding: true,
     linzumiMcp: true,
@@ -24386,6 +24744,59 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
         );
       }
       const runtimeSettings = startInstanceRuntimeSettings(options, control);
+      const rebuildOnDeadCodexWorker = shouldUseThreadProcesses(options) ? async (rebuildArgs) => {
+        await evictStaleDynamicChannelSession(rebuildArgs.codexThreadId);
+        let rebuilt = false;
+        for (const message of rebuildArgs.pendingMessages) {
+          const reconnectControl = {
+            type: "reconnect_thread",
+            workspace: workspaceSlug,
+            channel: channelSlug,
+            threadId: rebuildArgs.kandanThreadId,
+            codexThreadId: rebuildArgs.codexThreadId,
+            cwd,
+            // Carry the conversation context through the rebuild-replay so
+            // the respawned worker's developer instructions match what the
+            // server would have replayed (parity with the live reconnect
+            // control built above at channelSession.linzumiContext).
+            ...control.linzumiContext === void 0 ? {} : { linzumiContext: control.linzumiContext },
+            ...integerValue(control.rootSeq) === void 0 ? {} : { rootSeq: integerValue(control.rootSeq) },
+            sourceSeq: message.seq,
+            workDescription: message.body,
+            ...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 }
+          };
+          const liveSession = dynamicChannelSessions.get(
+            rebuildArgs.codexThreadId
+          );
+          try {
+            if (liveSession !== void 0 && rebuilt) {
+              await liveSession.startThreadMessageTurn({
+                seq: message.seq,
+                body: message.body,
+                actorSlug: message.actorSlug,
+                actorUserId: message.actorUserId,
+                boundStartTimeout: true
+              });
+            } else {
+              await startThreadRunnerProcess(reconnectControl, cwd);
+            }
+            rebuilt = true;
+          } catch (error) {
+            log2("runner.thread_dead_worker_rebuild_failed", {
+              codex_thread_id: rebuildArgs.codexThreadId,
+              kandan_thread_id: rebuildArgs.kandanThreadId,
+              seq: message.seq,
+              message: error instanceof Error ? error.message : String(error)
+            });
+            return false;
+          }
+        }
+        return rebuilt;
+      } : void 0;
       const session = await attachChannelSession({
         kandan,
         codex: sessionCodex,
@@ -24400,6 +24811,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
           fetch: options.fetch,
           fast: control.fast ?? options.fast,
           launchTui: false,
+          rebuildOnDeadCodexWorker,
           pipelinePersistDir: commanderOutboxPersistDir(),
           enablePortForwardWatch: true,
           initialForwardPorts: allowedForwardPorts,
@@ -25115,6 +25527,29 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
         }
       );
     }
+    if (control.type === "scan_onboarding_projects") {
+      const selectedScanRoots = onboardingProjectScanRoots(control.paths);
+      return runLocalOnboardingProjectDiscovery(options, log2, {
+        workspaceSlug: stringValue(control.workspace),
+        selectedScanRoots,
+        sourceRoots: selectedScanRoots,
+        workerId: "projects-selected-folders",
+        workerLabel: "Selected folders",
+        startingMessage: "Checking selected folders",
+        emptyMessage: "No Git projects found in selected folders",
+        foundMessage: "Selected folder projects found",
+        failedMessage: "Selected folder project scan failed",
+        currentPlace: selectedScanRoots[0] ?? options.cwd,
+        requireTerminalStatusWrite: true,
+        includeRuntimeCwdHint: false
+      }).catch((error) => {
+        log2("onboarding.project_scan_failed", {
+          runnerId: options.runnerId,
+          message: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      });
+    }
     if (control.type === "start_instance") {
       const staleAgeMs = staleStartInstanceAgeMs(control, Date.now());
       if (staleAgeMs !== void 0) {
@@ -25219,7 +25654,12 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     settleControlDispatch(control.type, () => handleControl(control), ack, log2);
   };
   finishRunnerStartup(
-    options,
+    onboardingDiscoveryRunnerOptions(
+      options,
+      allowedCwds.value,
+      missingAllowedCwds.value,
+      projectDiscoveryCwdIsSelectedRootFromSyncedConfig.value
+    ),
     log2,
     pendingControls,
     controlDispatcher,
@@ -26090,7 +26530,10 @@ async function resumeCodexThreadForReconnect(codex, codexThreadId, resumeOverrid
     threadId: codexThreadId,
     ...resumeOverrides
   };
-  const resumeResponse = await codex.request("thread/resume", resumeParams);
+  const resumeResponse = await withCodexStartRequestTimeout(
+    "thread/resume",
+    codex.request("thread/resume", resumeParams)
+  );
   if (!("error" in resumeResponse)) {
     return;
   }
@@ -26108,7 +26551,10 @@ async function resumeCodexThreadForReconnect(codex, codexThreadId, resumeOverrid
       `failed to prepare Codex thread before reconnect: ${injected.error.message}`
     );
   }
-  const verified = await codex.request("thread/resume", resumeParams);
+  const verified = await withCodexStartRequestTimeout(
+    "thread/resume",
+    codex.request("thread/resume", resumeParams)
+  );
   if ("error" in verified) {
     throw new Error(
       `failed to verify Codex thread before reconnect: ${verified.error.message}`
@@ -26699,7 +27145,8 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
           seq: sourceSeq,
           body: workDescription,
           actorSlug: identity.actorUsername,
-          actorUserId: identity.actorUserId
+          actorUserId: identity.actorUserId,
+          boundStartTimeout: true
         });
       }
       return {
@@ -29585,6 +30032,14 @@ function onboardingConversationImportSources(value) {
     )
   ).sort();
 }
+function onboardingProjectScanRoots(value) {
+  return normalizeAllowedCwds(
+    (arrayValue(value) ?? []).flatMap((path2) => {
+      const normalizedPath = stringValue(path2)?.trim();
+      return normalizedPath === void 0 || normalizedPath === "" ? [] : [normalizedPath];
+    })
+  );
+}
 async function replayLocalOnboardingConversation(args) {
   let replayedChunkCount = 0;
   for (const message of args.messages) {
@@ -30011,27 +30466,42 @@ async function runLocalOnboardingConversationDiscovery(options, log2) {
     );
   }
 }
-async function runLocalOnboardingProjectDiscovery(options, log2) {
-  const workspaceSlug = runnerWorkspaceSlug(options);
+async function runLocalOnboardingProjectDiscovery(options, log2, args = {}) {
+  const workspaceSlug = args.workspaceSlug ?? runnerWorkspaceSlug(options);
+  const selectedScanRoots = args.selectedScanRoots ?? selectedProjectDiscoveryScanRoots(options);
   if (workspaceSlug === void 0) {
     return;
   }
+  const workerId = args.workerId ?? "projects-local-filesystem";
+  const workerLabel = args.workerLabel ?? "Local Git projects";
+  const currentPlace = args.currentPlace ?? selectedScanRoots[0] ?? options.cwd;
   await reportOnboardingDiscoveryStatus(options, log2, {
     phase: "projects",
     status: "starting",
     placesSearched: 0,
-    message: "Checking current Git project",
-    currentPlace: options.cwd,
+    message: args.startingMessage ?? "Searching local Git projects",
+    currentPlace,
     currentSource: "git",
+    workspaceSlug,
     metadata: {
-      worker_id: "projects-local-current",
-      worker_label: "Current Git project"
+      worker_id: workerId,
+      worker_label: workerLabel,
+      ...selectedScanRoots.length === 0 ? {} : { selected_scan_roots: selectedScanRoots }
     }
   });
   let successfulPostStartWriteCount = 0;
   try {
-    const summary = await options.localProjectDiscovery?.() ?? await discoverCurrentGitProjectInChildProcess(
-      { cwd: options.cwd },
+    const summary = await options.localProjectDiscovery?.({
+      selectedScanRoots,
+      sourceRoots: args.sourceRoots,
+      includeRuntimeCwdHint: args.includeRuntimeCwdHint
+    }) ?? await discoverCurrentGitProjectInChildProcess(
+      {
+        cwd: options.cwd,
+        selectedScanRoots,
+        sourceRoots: args.sourceRoots,
+        includeRuntimeCwdHint: args.includeRuntimeCwdHint
+      },
       { log: (event, payload) => log2(event, payload) }
     );
     const client = createLinzumiMcpApiClient({
@@ -30061,22 +30531,31 @@ async function runLocalOnboardingProjectDiscovery(options, log2) {
       phase: "projects",
       status: "completed",
       placesSearched: summary.placesSearched,
-      message: summary.candidates.length === 0 ? "Current folder is not a Git project" : "Current Git project found",
-      currentPlace: options.cwd,
+      message: summary.candidates.length === 0 ? args.emptyMessage ?? "No local Git projects found" : args.foundMessage ?? "Local Git projects found",
+      currentPlace,
       currentSource: "git",
+      workspaceSlug,
       metadata: {
-        worker_id: "projects-local-current",
-        worker_label: "Current Git project",
+        worker_id: workerId,
+        worker_label: workerLabel,
         duration_ms: summary.durationMs,
         reported_count: summary.candidates.length,
         failed_report_count: failedReportCount,
+        ...selectedScanRoots.length === 0 ? {} : { selected_scan_roots: selectedScanRoots },
         search_stats: summary.searchStats
       }
     };
-    successfulPostStartWriteCount = await addStatusWriteResult(
-      successfulPostStartWriteCount,
-      reportOnboardingDiscoveryStatus(options, log2, completedReport)
+    const completedStatusWritten = await reportOnboardingDiscoveryStatus(
+      options,
+      log2,
+      completedReport
     );
+    if (!completedStatusWritten && args.requireTerminalStatusWrite === true) {
+      throw new Error(
+        "onboarding project discovery terminal status write failed"
+      );
+    }
+    successfulPostStartWriteCount = completedStatusWritten ? successfulPostStartWriteCount + 1 : successfulPostStartWriteCount;
     log2("onboarding.local_project_discovery_completed", {
       runnerId: options.runnerId,
       workspace: workspaceSlug,
@@ -30094,19 +30573,26 @@ async function runLocalOnboardingProjectDiscovery(options, log2) {
       phase: "projects",
       status: "failed",
       placesSearched: 0,
-      message: "Current Git project scan failed",
-      currentPlace: options.cwd,
+      message: args.failedMessage ?? "Local Git project scan failed",
+      currentPlace,
       currentSource: "git",
       lastError: message,
+      workspaceSlug,
       metadata: {
-        worker_id: "projects-local-current",
-        worker_label: "Current Git project"
+        worker_id: workerId,
+        worker_label: workerLabel,
+        ...selectedScanRoots.length === 0 ? {} : { selected_scan_roots: selectedScanRoots }
       }
     };
-    successfulPostStartWriteCount = await addStatusWriteResult(
-      successfulPostStartWriteCount,
-      reportOnboardingDiscoveryStatus(options, log2, failedReport)
+    const failedStatusWritten = await reportOnboardingDiscoveryStatus(
+      options,
+      log2,
+      failedReport
     );
+    if (!failedStatusWritten && args.requireTerminalStatusWrite === true) {
+      throw error;
+    }
+    successfulPostStartWriteCount = failedStatusWritten ? successfulPostStartWriteCount + 1 : successfulPostStartWriteCount;
     log2("onboarding.local_project_discovery_failed", {
       runnerId: options.runnerId,
       workspace: workspaceSlug,
@@ -30118,11 +30604,45 @@ async function runLocalOnboardingProjectDiscovery(options, log2) {
     );
   }
 }
+function selectedProjectDiscoveryScanRoots(options) {
+  const cwd = options.cwd.trim();
+  const implicitCwdAliases = new Set(implicitCwdStringAliases(cwd));
+  for (const alias of options.projectDiscoveryImplicitCwdAliases ?? []) {
+    implicitCwdAliases.add(alias);
+  }
+  const allowedCwds = options.projectDiscoveryCwdIsSelectedRoot === true ? options.allowedCwds : options.allowedCwds.filter(
+    (allowedCwd) => !implicitCwdAliases.has(allowedCwd)
+  );
+  return normalizeAllowedCwds([
+    ...allowedCwds,
+    ...options.missingAllowedCwds ?? []
+  ]);
+}
+function implicitCwdStringAliases(cwd) {
+  if (cwd === "") {
+    return [];
+  }
+  return normalizeAllowedCwds([cwd, resolve8(expandUserPath(cwd))]);
+}
+function onboardingDiscoveryRunnerOptions(options, allowedCwds, missingAllowedCwds, projectDiscoveryCwdIsSelectedRootFromSyncedConfig) {
+  return {
+    ...options,
+    allowedCwds,
+    missingAllowedCwds,
+    projectDiscoveryCwdIsSelectedRoot: options.projectDiscoveryCwdIsSelectedRoot === true || projectDiscoveryCwdIsSelectedRootFromSyncedConfig
+  };
+}
+function allowedCwdsContainAny(allowedCwds, candidates) {
+  const allowed = new Set(normalizeAllowedCwds(allowedCwds));
+  return normalizeAllowedCwds(candidates).some(
+    (candidate) => allowed.has(candidate)
+  );
+}
 function shouldStartOnboardingDiscoveryAgents(options, workspaceSlug = runnerWorkspaceSlug(options)) {
   return workspaceSlug !== void 0 && options.threadProcess === void 0 && options.onboardingDiscovery === "start";
 }
 async function reportOnboardingDiscoveryStatus(options, log2, args) {
-  const workspaceSlug = runnerWorkspaceSlug(options);
+  const workspaceSlug = args.workspaceSlug ?? runnerWorkspaceSlug(options);
   if (workspaceSlug === void 0) {
     return false;
   }
@@ -69207,6 +69727,7 @@ async function parseStartRunnerArgs(args, deps = {
     fast: values.get("fast") === true,
     logFile: stringValue8(values, "log-file"),
     allowedCwds,
+    projectDiscoveryCwdIsSelectedRoot: true,
     allowedForwardPorts: parseAllowedPortList(
       stringValue8(values, "forward-port")
     ),
@@ -69274,6 +69795,7 @@ async function parseAgentRunnerArgs(args, deps = {
     parseAllowedCwdList(stringValue8(values, "allowed-cwd"))
   ) : requestedCwdValue === void 0 ? configuredAllowedCwds2.allowedCwds.length > 0 ? [...configuredAllowedCwds2.allowedCwds] : assertConfiguredAllowedCwds([requestedCwd]) : assertConfiguredAllowedCwds([requestedCwd]);
   const cwd = allowedCwds[0] ?? requestedCwd;
+  const projectDiscoveryCwdIsSelectedRoot = values.has("allowed-cwd") || requestedCwdValue === void 0 && configuredAllowedCwds2.allowedCwds.length > 0;
   const requestedCodexBin = stringValue8(values, "codex-bin") ?? "codex";
   const customCodeServerBin = stringValue8(values, "code-server-bin");
   const initialDependencyStatus = await deps.buildDependencyStatus({
@@ -69313,6 +69835,8 @@ async function parseAgentRunnerArgs(args, deps = {
     logFile: stringValue8(values, "log-file"),
     allowedCwds,
     missingAllowedCwds: configuredAllowedCwds2.missingAllowedCwds,
+    projectDiscoveryCwdIsSelectedRoot,
+    projectDiscoveryImplicitCwdAliases: projectDiscoveryCwdIsSelectedRoot ? void 0 : allowedCwds,
     allowedForwardPorts: parseAllowedPortList(
       stringValue8(values, "forward-port")
     ),
@@ -69436,6 +69960,9 @@ async function parseRunnerArgs(args, deps = {
   const configuredAllowedCwds2 = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(
     parseAllowedCwdList(stringValue8(values, "allowed-cwd"))
   ) : [...localConfiguredAllowedCwds.allowedCwds];
+  const projectDiscoveryCwdIsSelectedRoot = cwdAllowedCwds.some(
+    (cwdAllowedCwd) => configuredAllowedCwds2.includes(cwdAllowedCwd)
+  );
   const requestedCodexBin = stringValue8(values, "codex-bin") ?? "codex";
   const customCodeServerBin = stringValue8(values, "code-server-bin");
   const onboardingDiscovery = values.get("no-onboarding-discovery") === true ? void 0 : "start";
@@ -69490,6 +70017,8 @@ async function parseRunnerArgs(args, deps = {
       /* @__PURE__ */ new Set([...cwdAllowedCwds, ...configuredAllowedCwds2])
     ),
     missingAllowedCwds: localConfiguredAllowedCwds.missingAllowedCwds,
+    projectDiscoveryCwdIsSelectedRoot,
+    projectDiscoveryImplicitCwdAliases: projectDiscoveryCwdIsSelectedRoot ? void 0 : cwdAllowedCwds,
     allowedForwardPorts: parseAllowedPortList(
       stringValue8(values, "forward-port")
     ),

package/package.json

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