@linzumi/cli 0.0.98-beta → 0.0.99-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.98-beta --version
+npx -y @linzumi/cli@0.0.99-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -19803,7 +19803,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.98-beta";
+    linzumiCliVersion = "0.0.99-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -24579,6 +24579,17 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
   }
   const dynamicChannelSessions = /* @__PURE__ */ new Map();
   const dynamicChannelSessionAttachInFlight = /* @__PURE__ */ new Map();
+  const dynamicChannelSessionAttachWaiters = /* @__PURE__ */ new Map();
+  const resolveDynamicChannelSessionAttachWaiters = (codexThreadId, session) => {
+    const waiters = dynamicChannelSessionAttachWaiters.get(codexThreadId);
+    if (waiters === void 0) {
+      return;
+    }
+    dynamicChannelSessionAttachWaiters.delete(codexThreadId);
+    for (const waiter of waiters) {
+      waiter(session);
+    }
+  };
   const dynamicChannelSessionCodexClients = /* @__PURE__ */ new Map();
   const codexTurnFailureGuards = /* @__PURE__ */ new Map();
   const lossReportPushes = [];
@@ -24640,6 +24651,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     );
     dynamicChannelSessions.clear();
     dynamicChannelSessionCodexClients.clear();
+    dynamicChannelSessionAttachWaiters.clear();
     const claudeSessions = [...activeClaudeCodeSessions.values()];
     for (const session of claudeSessions) {
       try {
@@ -24716,6 +24728,28 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     }
     return true;
   };
+  const resolveLiveDynamicChannelSession = async (codexThreadId, options2 = {}) => {
+    const existing = dynamicChannelSessions.get(codexThreadId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const inFlight = dynamicChannelSessionAttachInFlight.get(codexThreadId);
+    if (inFlight !== void 0) {
+      const attached = await inFlight;
+      if (attached !== void 0) {
+        return attached;
+      }
+    }
+    const settled = dynamicChannelSessions.get(codexThreadId);
+    if (settled !== void 0 || options2.waitForSiblingSpawn !== true) {
+      return settled;
+    }
+    return await new Promise((resolve12) => {
+      const waiters = dynamicChannelSessionAttachWaiters.get(codexThreadId) ?? [];
+      waiters.push(resolve12);
+      dynamicChannelSessionAttachWaiters.set(codexThreadId, waiters);
+    });
+  };
   const attachThreadSessionWithCodex = async (args) => {
     const { control, cwd, codexThreadId, sessionCodex } = args;
     const portForwardWatcherRootPid = args.portForwardWatcherRootPid;
@@ -24769,20 +24803,42 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
             ...runtimeSettings.approvalPolicy === void 0 ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
             ...runtimeSettings.fast === void 0 ? {} : { fast: runtimeSettings.fast }
           };
-          const liveSession = dynamicChannelSessions.get(
-            rebuildArgs.codexThreadId
-          );
+          const replayOntoLiveSession = async (options2) => {
+            const liveSession = await withCodexStartRequestTimeout(
+              "thread/attach",
+              resolveLiveDynamicChannelSession(rebuildArgs.codexThreadId, {
+                waitForSiblingSpawn: options2.waitForSiblingSpawn
+              })
+            );
+            if (liveSession === void 0) {
+              throw new Error(
+                `dead-worker rebuild could not resolve a live session for codex thread ${rebuildArgs.codexThreadId}`
+              );
+            }
+            await liveSession.startThreadMessageTurn({
+              seq: message.seq,
+              body: message.body,
+              actorSlug: message.actorSlug,
+              actorUserId: message.actorUserId,
+              boundStartTimeout: true
+            });
+          };
           try {
-            if (liveSession !== void 0 && rebuilt) {
-              await liveSession.startThreadMessageTurn({
-                seq: message.seq,
-                body: message.body,
-                actorSlug: message.actorSlug,
-                actorUserId: message.actorUserId,
-                boundStartTimeout: true
-              });
+            if (rebuilt) {
+              await replayOntoLiveSession({ waitForSiblingSpawn: false });
             } else {
-              await startThreadRunnerProcess(reconnectControl, cwd);
+              const startResult = await startThreadRunnerProcess(
+                reconnectControl,
+                cwd
+              );
+              if (threadStartDelegatedToSibling(startResult)) {
+                log2("runner.thread_dead_worker_rebuild_replay_on_sibling", {
+                  codex_thread_id: rebuildArgs.codexThreadId,
+                  kandan_thread_id: rebuildArgs.kandanThreadId,
+                  seq: message.seq
+                });
+                await replayOntoLiveSession({ waitForSiblingSpawn: true });
+              }
             }
             rebuilt = true;
           } catch (error) {
@@ -24854,6 +24910,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
       });
       dynamicChannelSessions.set(codexThreadId, session);
       dynamicChannelSessionCodexClients.set(codexThreadId, sessionCodex);
+      resolveDynamicChannelSessionAttachWaiters(codexThreadId, session);
       threadSessionRegistry.upsert({
         workspace: workspaceSlug,
         channel: channelSlug,
@@ -25973,6 +26030,9 @@ function controlTargetsInstance(control, instanceId) {
 function controlInstanceId(control) {
   return "instanceId" in control ? control.instanceId : void 0;
 }
+function threadStartDelegatedToSibling(startResult) {
+  return startResult !== void 0 && startResult.delegated === true && startResult.threadProcess === "already_started";
+}
 function shouldUseThreadProcesses(options) {
   if (options.threadProcess?.role === "thread") {
     return false;
@@ -27119,7 +27179,10 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
         ensureCodexProjectTrusted(cwd.cwd);
       }
       const runtimeSettings = startInstanceRuntimeSettings(options, control);
-      const startedThreadSession = onStartedThread === void 0 ? void 0 : await onStartedThread(control, cwd.cwd, codexThreadId);
+      const startedThreadSession = onStartedThread === void 0 ? void 0 : await withCodexStartRequestTimeout(
+        "thread/attach",
+        onStartedThread(control, cwd.cwd, codexThreadId)
+      );
       if (workDescription !== void 0) {
         const rootSeq = integerValue(control.rootSeq);
         const sourceSeq = integerValue(control.sourceSeq) ?? rootSeq;
@@ -27811,10 +27874,9 @@ async function startCodexProviderInstance(args) {
   let startedThreadSession;
   if (codexThreadId !== void 0 && args.onStartedThread !== void 0) {
     args.setStartupStage("binding_kandan_thread");
-    startedThreadSession = await args.onStartedThread(
-      args.control,
-      args.cwd,
-      codexThreadId
+    startedThreadSession = await withCodexStartRequestTimeout(
+      "thread/attach",
+      args.onStartedThread(args.control, args.cwd, codexThreadId)
     );
   }
   if (codexThreadId !== void 0 && workDescription !== void 0) {

package/package.json

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