@linzumi/cli 0.0.93-beta → 0.0.95-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.93-beta --version
+npx -y @linzumi/cli@0.0.95-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -112,6 +112,14 @@ import { spawnSync } from "node:child_process";
 import { homedir } from "node:os";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
+function projectScanBudgetMs() {
+  const raw = process.env.LINZUMI_ONBOARDING_PROJECT_SCAN_BUDGET_MS?.trim();
+  if (raw === void 0 || raw === "") {
+    return defaultProjectScanBudgetMs;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultProjectScanBudgetMs;
+}
 function discoverCurrentGitProject(args) {
   const startedAtMs = args.nowMs ?? Date.now();
   const responsiveness = args.placeResponsiveness;
@@ -136,7 +144,19 @@ function discoverCurrentGitProject(args) {
   });
   const sourceRoots = args.sourceRoots ?? defaultLocalProjectSourceRoots(args.cwd);
   let placesSearched = 1;
+  const scanBudgetMs = projectScanBudgetMs();
   for (const sourceRoot of sourceRoots) {
+    if (Date.now() - startedAtMs >= scanBudgetMs) {
+      searchStats.push({
+        place: sourceRoot,
+        source: "git",
+        duration_ms: 0,
+        result_count: 0,
+        skipped_scan_budget_exceeded: true
+      });
+      placesSearched += 1;
+      continue;
+    }
     const sourceRootStartedAtMs = Date.now();
     const rootResponsive = isPlaceResponsive(sourceRoot, responsiveness);
     if (!rootResponsive) {
@@ -296,6 +316,9 @@ function isGitWorktreeRoot(path2) {
   return existsSync(join(path2, ".git"));
 }
 function defaultLocalProjectSourceRoots(cwd) {
+  if (cwd === dirname(cwd)) {
+    return [];
+  }
   return uniqueStrings([
     ...ancestorSourceRoots(cwd),
     ...homeSourceRoots(),
@@ -409,13 +432,14 @@ function compactJsonObject(value) {
     })
   );
 }
-var worktreePathSampleLimit, gitSpawnTimeoutMs;
+var worktreePathSampleLimit, gitSpawnTimeoutMs, defaultProjectScanBudgetMs;
 var init_onboardingProjectDiscovery = __esm({
   "src/onboardingProjectDiscovery.ts"() {
     "use strict";
     init_onboardingPlaceResponsiveness();
     worktreePathSampleLimit = 25;
     gitSpawnTimeoutMs = 4e3;
+    defaultProjectScanBudgetMs = 2e4;
   }
 });
 
@@ -8437,6 +8461,38 @@ var init_userFacingErrors = __esm({
 
 // src/channelSession.ts
 import { createHash as createHash3, randomUUID } from "node:crypto";
+function codexStartRequestTimeoutMs() {
+  const raw = process.env.LINZUMI_CODEX_START_REQUEST_TIMEOUT_MS?.trim();
+  if (raw === void 0 || raw === "") {
+    return CODEX_START_REQUEST_TIMEOUT_MS;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : CODEX_START_REQUEST_TIMEOUT_MS;
+}
+function isCodexStartRequestTimeoutError(error) {
+  return error instanceof CodexStartRequestTimeoutError;
+}
+function withCodexStartRequestTimeout(method, request, timeoutMs = codexStartRequestTimeoutMs()) {
+  if (!(timeoutMs > 0)) {
+    return request;
+  }
+  return new Promise((resolve12, reject) => {
+    const timer = setTimeout(() => {
+      reject(new CodexStartRequestTimeoutError(method, timeoutMs));
+    }, timeoutMs);
+    timer.unref?.();
+    request.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve12(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
 async function attachChannelSession(args) {
   const session = args.options.channelSession;
   const chatTopic = `chat:${session.workspaceSlug}:${session.channelSlug}`;
@@ -8941,6 +8997,7 @@ function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThread
     failedSeqs: /* @__PURE__ */ new Map(),
     drainInFlight: false,
     drainRequested: false,
+    boundStartTimeout: false,
     fusedQueuedSeqs: /* @__PURE__ */ new Map(),
     reconnectRetryTimer: void 0,
     reconnectRetryAttempts: 0,
@@ -10295,6 +10352,9 @@ async function startThreadMessageTurn(args, state, payloadContext, message) {
   if (state.kandanThreadId === void 0 || state.codexThreadId === void 0) {
     throw new Error("cannot start a local Codex turn before thread binding");
   }
+  if (message.boundStartTimeout === true) {
+    state.boundStartTimeout = true;
+  }
   const queued = {
     seq: message.seq,
     actorSlug: message.actorSlug,
@@ -10558,7 +10618,9 @@ async function drainKandanMessageQueueOnce(args, state, payloadContext) {
     if (state.kandanThreadId !== void 0) {
       startCodexTypingHeartbeat(args, state, state.kandanThreadId);
     }
-    const started = await args.codex.request("turn/start", {
+    const boundStartTimeout = state.boundStartTimeout;
+    state.boundStartTimeout = false;
+    const turnStartRequest = args.codex.request("turn/start", {
       threadId: codexThreadId,
       input: await codexInputItemsForQueuedKandanMessage(
         args,
@@ -10569,6 +10631,7 @@ async function drainKandanMessageQueueOnce(args, state, payloadContext) {
         runtimeOptionsForSettings(args.options, state.runtimeSettings)
       )
     });
+    const started = boundStartTimeout ? await withCodexStartRequestTimeout("turn/start", turnStartRequest) : await turnStartRequest;
     const turnId = extractTurnIdFromResponse(started);
     state.pendingReconnectContextInjection = void 0;
     const interruptAfterStart = state.turn.status === "starting" && state.turn.interruptAfterStart;
@@ -10641,6 +10704,9 @@ async function drainKandanMessageQueueOnce(args, state, payloadContext) {
       queued_seq: next.seq,
       message: error instanceof Error ? error.message : String(error)
     });
+    if (isCodexStartRequestTimeoutError(error)) {
+      throw error;
+    }
   }
 }
 function drainKandanMessageQueueBlocked(args, state) {
@@ -11654,7 +11720,7 @@ async function pushOptional(kandan, topic, event, payload, log2) {
     });
   }
 }
-var codexTypingHeartbeatMs, 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;
 var init_channelSession = __esm({
   "src/channelSession.ts"() {
     "use strict";
@@ -11679,6 +11745,15 @@ var init_channelSession = __esm({
     init_processNameCatalog();
     init_userFacingErrors();
     codexTypingHeartbeatMs = 5e3;
+    CODEX_START_REQUEST_TIMEOUT_MS = 12e4;
+    CodexStartRequestTimeoutError = class extends Error {
+      constructor(method, timeoutMs) {
+        super(
+          `Codex ${method} did not reply within ${timeoutMs}ms (start request timed out)`
+        );
+        this.name = "CodexStartRequestTimeoutError";
+      }
+    };
     maxTrackedFailedChatEventSeqs = 256;
     maxChatEventFailureAttempts = 5;
     maxForwardedTurnIds = 64;
@@ -19376,7 +19451,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.93-beta";
+    linzumiCliVersion = "0.0.95-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -19487,6 +19562,82 @@ function assessRunnerLockHolder(record, isPidAlive, now) {
   }
   return { state: "live" };
 }
+function shouldAutoTakeOverForUpdate(existing, myVersion, myLaunchSource, holderState) {
+  if (myLaunchSource !== electronAutoConnectLaunchSource) {
+    return false;
+  }
+  if (existing.launchSource !== electronAutoConnectLaunchSource) {
+    return false;
+  }
+  if (holderState.state !== "live") {
+    return true;
+  }
+  return compareCliVersions(myVersion, existing.cliVersion) > 0;
+}
+function compareCliVersions(a, b) {
+  const pa = parseCliVersion(a);
+  const pb = parseCliVersion(b);
+  for (let i = 0; i < 3; i++) {
+    if (pa.core[i] !== pb.core[i]) {
+      return pa.core[i] > pb.core[i] ? 1 : -1;
+    }
+  }
+  if (pa.prerelease.length === 0 && pb.prerelease.length === 0) {
+    return 0;
+  }
+  if (pa.prerelease.length === 0) {
+    return 1;
+  }
+  if (pb.prerelease.length === 0) {
+    return -1;
+  }
+  return comparePrerelease(pa.prerelease, pb.prerelease);
+}
+function parseCliVersion(value) {
+  const trimmed = value.trim().replace(/^v/i, "").split("+", 1)[0] ?? "";
+  const hyphen = trimmed.indexOf("-");
+  const coreText = hyphen === -1 ? trimmed : trimmed.slice(0, hyphen);
+  const prereleaseText = hyphen === -1 ? "" : trimmed.slice(hyphen + 1);
+  const parts = coreText.split(".");
+  const core = [
+    parseCoreNumber(parts[0]),
+    parseCoreNumber(parts[1]),
+    parseCoreNumber(parts[2])
+  ];
+  const prerelease = prereleaseText === "" ? [] : prereleaseText.split(".").filter((id) => id !== "");
+  return { core, prerelease };
+}
+function parseCoreNumber(value) {
+  const parsed = Number.parseInt(value ?? "", 10);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : 0;
+}
+function comparePrerelease(a, b) {
+  const length = Math.max(a.length, b.length);
+  for (let i = 0; i < length; i++) {
+    if (i >= a.length) {
+      return -1;
+    }
+    if (i >= b.length) {
+      return 1;
+    }
+    const idA = a[i];
+    const idB = b[i];
+    const numA = Number.parseInt(idA, 10);
+    const numB = Number.parseInt(idB, 10);
+    const aIsNum = numA.toString() === idA;
+    const bIsNum = numB.toString() === idB;
+    if (aIsNum && bIsNum) {
+      if (numA !== numB) {
+        return numA > numB ? 1 : -1;
+      }
+    } else if (aIsNum !== bIsNum) {
+      return aIsNum ? -1 : 1;
+    } else if (idA !== idB) {
+      return idA > idB ? 1 : -1;
+    }
+  }
+  return 0;
+}
 function takeOverWedgedHolder(lockPath, holder, reason, killPid, onTakeover) {
   try {
     killPid(holder.pid);
@@ -19754,7 +19905,7 @@ function displayLinzumiUrl(linzumiUrl) {
 function isNodeErrorCode2(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
-var runnerLockHeartbeatIntervalMs, runnerLockTakeoverAfterMs, runnerLockHeldErrorName, RunnerLockHeldError;
+var runnerLockHeartbeatIntervalMs, runnerLockTakeoverAfterMs, runnerLockHeldErrorName, RunnerLockHeldError, electronAutoConnectLaunchSource;
 var init_runnerLock = __esm({
   "src/runnerLock.ts"() {
     "use strict";
@@ -19775,6 +19926,7 @@ var init_runnerLock = __esm({
         this.heldBy = heldBy;
       }
     };
+    electronAutoConnectLaunchSource = "electron_auto_connect";
   }
 });
 
@@ -22958,6 +23110,34 @@ async function runThreadCodexWorker(options) {
 async function openLocalCodexRunner(options, log2, cleanup, close) {
   const agentProviders = availableRunnerAgentProviders(options);
   const localCodexAppServerAvailable = hasLocalCodexAppServerCapability(options);
+  const dependencyStatusRef = {
+    value: options.dependencyStatus
+  };
+  const refreshDependencyStatus = async () => {
+    if (dependencyStatusRef.value === void 0) {
+      return;
+    }
+    try {
+      const refreshed = await buildRunnerDependencyStatus({
+        cwd: options.cwd,
+        codexBin: options.codexBin,
+        codeServerBin: options.codeServerBin,
+        editorRuntime: dependencyStatusRef.value?.editorRuntime
+      });
+      const previousCodexAvailable = dependencyStatusRef.value?.codex.available;
+      dependencyStatusRef.value = refreshed;
+      log2("runner.dependency_status_reprobed", {
+        runnerId: options.runnerId,
+        codex_available: refreshed.codex.available,
+        codex_available_changed: previousCodexAvailable !== refreshed.codex.available
+      });
+    } catch (error) {
+      log2("runner.dependency_status_reprobe_failed", {
+        runnerId: options.runnerId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
   const allowedForwardPorts = options.allowedForwardPorts ?? [];
   const liveForwardPorts = new Set(allowedForwardPorts);
   const managedForwardPorts = /* @__PURE__ */ new Set();
@@ -23130,8 +23310,8 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     ),
     forwardedPortAttributions: buildForwardPortAttributionPayload(),
     pendingEditorForwardPortRequests: pendingEditorForwardPortRequests(),
-    toolStatus: options.dependencyStatus === void 0 ? null : dependencyStatusPayload(options.dependencyStatus),
-    editorRuntime: options.dependencyStatus?.editorRuntime === void 0 ? null : dependencyStatusPayload(options.dependencyStatus).editorRuntime,
+    toolStatus: dependencyStatusRef.value === void 0 ? null : dependencyStatusPayload(dependencyStatusRef.value),
+    editorRuntime: dependencyStatusRef.value?.editorRuntime === void 0 ? null : dependencyStatusPayload(dependencyStatusRef.value).editorRuntime,
     ...localEditorCapabilities(
       options.editorRuntime,
       allowedCwds.value,
@@ -24994,14 +25174,15 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     log2,
     pendingControls,
     controlDispatcher,
-    dispatchControl
+    dispatchControl,
+    refreshDependencyStatus
   );
   return { instanceId, codexUrl, close };
 }
-function finishRunnerStartup(options, log2, pendingControls, controlDispatcher, dispatchControl) {
+function finishRunnerStartup(options, log2, pendingControls, controlDispatcher, dispatchControl, onOnboardingDiscoveryComplete) {
   controlDispatcher.value = dispatchControl;
   pendingControls.splice(0).forEach(({ control, ack }) => dispatchControl(control, ack));
-  startOnboardingDiscoveryAgents(options, log2);
+  startOnboardingDiscoveryAgents(options, log2, onOnboardingDiscoveryComplete);
 }
 function commanderOutboxPersistDir() {
   const override = process.env.LINZUMI_COMMANDER_OUTBOX_DIR?.trim();
@@ -25632,6 +25813,43 @@ async function acquireRunnerLockWithConflictResolution(acquire, options, log2) {
       lockPath: error.lockPath
     });
     const lockTakeover = options.lockTakeover;
+    const autoTakeoverDeps = resolveRunnerLockTakeoverDeps(
+      error.lockPath,
+      lockTakeover?.takeover,
+      log2
+    );
+    const holderState = assessRunnerLockHolder(
+      error.heldBy,
+      autoTakeoverDeps.isPidAlive,
+      () => new Date(autoTakeoverDeps.now())
+    );
+    if (shouldAutoTakeOverForUpdate(
+      error.heldBy,
+      linzumiCliVersion,
+      options.launchSource,
+      holderState
+    )) {
+      log2("runner.lock_auto_takeover_for_update", {
+        runnerId: options.runnerId,
+        heldByRunnerId: error.heldBy.runnerId,
+        heldByPid: error.heldBy.pid,
+        lockPath: error.lockPath,
+        fromVersion: error.heldBy.cliVersion,
+        toVersion: linzumiCliVersion,
+        launchSource: electronAutoConnectLaunchSource,
+        holderState: holderState.state
+      });
+      const autoPromptDeps = lockTakeover?.prompt ?? defaultRunnerLockTakeoverPromptDeps(lockTakeover);
+      await resolveRunnerLockConflict({
+        holder: error.heldBy,
+        lockPath: error.lockPath,
+        baseMessage: error.message,
+        takeOverWithoutPrompt: true,
+        prompt: autoPromptDeps,
+        takeover: autoTakeoverDeps
+      });
+      return acquire();
+    }
     if (!shouldResolveRunnerLockConflict(lockTakeover)) {
       throw error;
     }
@@ -25848,6 +26066,32 @@ async function resumeCodexThreadForReconnect(codex, codexThreadId, resumeOverrid
     );
   }
 }
+async function applyCodexUnavailableControl(kandan, topic, instanceId, control, log2) {
+  const error = "agent_provider_unavailable:codex";
+  log2("kandan.start_instance_codex_app_server_unavailable", {
+    controlType: control.type,
+    thread_id: controlThreadId(control) ?? null,
+    instanceId
+  });
+  if (control.type === "start_instance" || control.type === "reconnect_thread") {
+    try {
+      await publishStartInstanceMessageState(
+        kandan,
+        topic,
+        control,
+        "failed",
+        error,
+        { instanceId }
+      );
+    } catch (publishError) {
+      log2("kandan.start_instance_unavailable_state_push_failed", {
+        agent_provider: "codex",
+        message: publishError instanceof Error ? publishError.message : String(publishError)
+      });
+    }
+  }
+  throw new Error(error);
+}
 async function applyControl(codex, kandan, topic, instanceId, options, agentProviders, allowedCwds, remoteCodexSandboxRunner, activeRemoteCodexExecRequests, activeClaudeCodeSessions, pendingClaudeCodeApprovals, ensureClaudeCodeForwardPortSession, disposeClaudeCodeForwardPortSession, control, log2, onStartedThread, onThreadProcessStart) {
   if (codex === void 0) {
     switch (control.type) {
@@ -25861,6 +26105,43 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
           activeRemoteCodexExecRequests,
           log2
         );
+      // PROD WEDGE (coding jobs down on the shipped CLI beta): a runner whose
+      // cached dependencyStatus.codex.available was `false` at connect (the
+      // `codex --version` probe timed out during the blocking onboarding scan
+      // and was never re-probed) never started its SHARED codex app-server, so
+      // this `codex` is undefined. But a start_instance / reconnect_thread runs
+      // in its OWN thread worker that spawns its OWN codex app-server - it does
+      // NOT need the shared client. The old `default` arm returned
+      // `agent_provider_unavailable:codex` HERE, before delegating, and only as
+      // a bare codex_response: no thread-worker spawn, no
+      // `runner.thread_process_starting` log, no message_state - a SILENT no-op
+      // that left the user's job stuck in `coding` (prod thread 99d5808e,
+      // control_seq 13). When a thread worker IS available (onThreadProcessStart
+      // wired), fall through to the normal switch so the control delegates to
+      // the worker; the worker's own start surfaces any genuine engine failure.
+      // When NO thread worker exists, codex genuinely cannot run the job, so
+      // fail LOUD (log + failed message_state + throw -> codex_error) instead of
+      // leaving it silently stuck. This loud path is SCOPED to start_instance /
+      // reconnect_thread only.
+      case "start_instance":
+      case "reconnect_thread":
+        if (onThreadProcessStart !== void 0) {
+          break;
+        }
+        return await applyCodexUnavailableControl(
+          kandan,
+          topic,
+          instanceId,
+          control,
+          log2
+        );
+      // Every OTHER control type that reaches here is a request/response control
+      // that does NOT need the shared codex app-server to fail gracefully
+      // (browse_directory, create_project, suggest_tasks,
+      // list_claude_code_sessions, interrupt, cancel_turn, ...). Preserve the
+      // original behavior: return a bare `agent_provider_unavailable:codex`
+      // codex_response - NO throw, NO failed message_state, NO start_instance
+      // log - so onboarding/UI features keep working while codex is unavailable.
       default:
         return {
           instanceId,
@@ -26998,22 +27279,25 @@ async function startCodexProviderInstance(args) {
     args.options,
     args.control
   );
-  const response = await args.codex.request("thread/start", {
-    cwd: args.cwd,
-    serviceName: "kandan-local-runner",
-    personality: "pragmatic",
-    developerInstructions: commanderDeveloperInstructions({
+  const response = await withCodexStartRequestTimeout(
+    "thread/start",
+    args.codex.request("thread/start", {
       cwd: args.cwd,
-      planTool: "linzumi-mcp",
-      developerPrompt,
-      linzumiContext
-    }),
-    ...runtimeSettings.model === void 0 ? {} : { model: runtimeSettings.model },
-    ...runtimeSettings.reasoningEffort === void 0 ? {} : { reasoningEffort: runtimeSettings.reasoningEffort },
-    ...runtimeSettings.approvalPolicy === void 0 ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
-    ...runtimeSettings.sandbox === void 0 ? {} : { sandbox: runtimeSettings.sandbox },
-    ...runtimeSettings.fast === true ? { serviceTier: "fast" } : {}
-  });
+      serviceName: "kandan-local-runner",
+      personality: "pragmatic",
+      developerInstructions: commanderDeveloperInstructions({
+        cwd: args.cwd,
+        planTool: "linzumi-mcp",
+        developerPrompt,
+        linzumiContext
+      }),
+      ...runtimeSettings.model === void 0 ? {} : { model: runtimeSettings.model },
+      ...runtimeSettings.reasoningEffort === void 0 ? {} : { reasoningEffort: runtimeSettings.reasoningEffort },
+      ...runtimeSettings.approvalPolicy === void 0 ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
+      ...runtimeSettings.sandbox === void 0 ? {} : { sandbox: runtimeSettings.sandbox },
+      ...runtimeSettings.fast === true ? { serviceTier: "fast" } : {}
+    })
+  );
   const codexThreadId = extractStartedThreadId(response);
   args.setStartedCodexThreadId(codexThreadId);
   const workDescription = normalizedWorkDescription(
@@ -27047,13 +27331,17 @@ async function startCodexProviderInstance(args) {
         seq: sourceSeq,
         body: workDescription,
         actorSlug: identity.actorUsername,
-        actorUserId: identity.actorUserId
+        actorUserId: identity.actorUserId,
+        boundStartTimeout: true
       });
     } else {
-      await args.codex.request("turn/start", {
-        threadId: codexThreadId,
-        input: [{ type: "text", text: workDescription }]
-      });
+      await withCodexStartRequestTimeout(
+        "turn/start",
+        args.codex.request("turn/start", {
+          threadId: codexThreadId,
+          input: [{ type: "text", text: workDescription }]
+        })
+      );
     }
   }
   return {
@@ -28953,9 +29241,10 @@ function redactedThreadRunnerCliArgs(args) {
 function optionalCliValue(flag, value) {
   return value === void 0 || value === "" ? [] : [flag, value];
 }
-function startOnboardingDiscoveryAgents(options, log2) {
+function startOnboardingDiscoveryAgents(options, log2, onOnboardingDiscoveryComplete) {
   const workspaceSlug = runnerWorkspaceSlug(options);
   if (!shouldStartOnboardingDiscoveryAgents(options, workspaceSlug)) {
+    void onOnboardingDiscoveryComplete?.();
     return;
   }
   const startKey = onboardingDiscoveryAgentStartKey(options, workspaceSlug);
@@ -29013,6 +29302,7 @@ function startOnboardingDiscoveryAgents(options, log2) {
       workers_completed: 2,
       successful_write_count: successfulWriteCount
     });
+    await onOnboardingDiscoveryComplete?.();
   });
 }
 function withSuccessfulWriteCount(report, successfulPostStartWriteCount) {
@@ -68863,7 +69153,7 @@ async function parseStartRunnerArgs(args, deps = {
     cwd,
     codexBin,
     codexUrl: stringValue8(values, "codex-url"),
-    launchSource: electronAutoConnectLaunchSource(),
+    launchSource: electronAutoConnectLaunchSource2(),
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
     logFile: stringValue8(values, "log-file"),
@@ -68968,7 +69258,7 @@ async function parseAgentRunnerArgs(args, deps = {
     cwd,
     codexBin,
     codexUrl: stringValue8(values, "codex-url"),
-    launchSource: electronAutoConnectLaunchSource(),
+    launchSource: electronAutoConnectLaunchSource2(),
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
     logFile: stringValue8(values, "log-file"),
@@ -69143,7 +69433,7 @@ async function parseRunnerArgs(args, deps = {
     cwd,
     codexBin,
     codexUrl: stringValue8(values, "codex-url"),
-    launchSource: electronAutoConnectLaunchSource(),
+    launchSource: electronAutoConnectLaunchSource2(),
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
     logFile: stringValue8(values, "log-file"),
@@ -69178,11 +69468,11 @@ function runnerRuntimeDefaultsFromValues(values) {
     allowPortForwardingByDefault: true
   };
 }
-function electronAutoConnectLaunchSource() {
+function electronAutoConnectLaunchSource2() {
   return process.env.LINZUMI_ELECTRON_AUTO_CONNECT_RUNNER === "1" ? "electron_auto_connect" : void 0;
 }
 function connectLaunchSourceTelemetryValue() {
-  return electronAutoConnectLaunchSource() ?? "cli";
+  return electronAutoConnectLaunchSource2() ?? "cli";
 }
 function workspaceTelemetryAttribute(workspace) {
   return workspace === void 0 ? {} : { workspace };

package/package.json

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