@linzumi/cli 0.0.84-beta → 0.0.85-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.84-beta --version
+npx -y @linzumi/cli@0.0.85-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -9822,7 +9822,11 @@ async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext
       seq: event.seq,
       actor_slug: event.actorSlug ?? null,
       actor_user_id: event.actorUserId ?? null,
-      reason: "different_thread"
+      reason: "different_thread",
+      thread_id: event.threadId ?? null,
+      bound_thread_id: state.kandanThreadId ?? null,
+      codex_thread_id: state.codexThreadId ?? null,
+      body_preview: runnerConsoleBodyPreview(event.body)
     });
     return;
   }
@@ -12440,87 +12444,83 @@ async function startClaudeCodeSession(options) {
     assistantTextByKey: /* @__PURE__ */ new Map(),
     usage: void 0,
     startedSessionIds: /* @__PURE__ */ new Set(),
-    completedTurnCount: 0
+    completedTurnCount: 0,
+    lastCompletedTurnBody: void 0
   };
   const streamUsageTracker = createClaudeCodeStreamUsageTracker();
-  for await (const message of runner(options)) {
-    state.sessionId = state.sessionId ?? extractClaudeSessionId(message);
-    const sessionId = extractClaudeSessionId(message) ?? state.sessionId;
-    if (sessionId !== void 0 && !state.startedSessionIds.has(sessionId)) {
-      state.startedSessionIds.add(sessionId);
-      await options.onTranscriptEvent?.({ type: "session_started", sessionId });
-    }
-    for (const event of transcriptEventsForClaudeMessage(
-      message,
-      sessionId,
-      streamUsageTracker
-    )) {
-      if (event.type === "assistant_message") {
-        recordClaudeAssistantAggregate(state, event);
-      }
-      if (event.type === "usage") {
-        state.usage = event.usage;
-      }
-      await options.onTranscriptEvent?.(event);
-    }
-    const resultOutcome = extractClaudeResultOutcome(message);
-    switch (resultOutcome.type) {
-      case "success": {
-        if (resultOutcome.text !== void 0) {
-          state.resultText = resultOutcome.text;
-        }
-        state.usage = extractClaudeUsage(message) ?? state.usage;
-        state.completedTurnCount += 1;
-        const queuedTurnCountBeforeTranscript = options.streamingInput === void 0 ? void 0 : options.streamingInput.queuedTurnCount();
-        if (options.streamingInput !== void 0) {
-          await emitClaudeCodeTurnCompleted(options, state);
-        }
-        if (options.streamingInput !== void 0 && queuedTurnCountBeforeTranscript !== void 0 && state.completedTurnCount >= Math.max(
-          queuedTurnCountBeforeTranscript,
-          options.streamingInput.queuedTurnCount()
-        )) {
-          options.streamingInput.close();
-          return completeClaudeCodeSession(options, state);
-        }
-        if (options.streamingInput !== void 0) {
-          await options.onTurnCompleted?.();
-          resetClaudeAssistantAggregate(state);
-          state.resultText = void 0;
+  try {
+    for await (const message of runner(options)) {
+      state.sessionId = state.sessionId ?? extractClaudeSessionId(message);
+      const sessionId = extractClaudeSessionId(message) ?? state.sessionId;
+      if (sessionId !== void 0 && !state.startedSessionIds.has(sessionId)) {
+        state.startedSessionIds.add(sessionId);
+        await options.onTranscriptEvent?.({
+          type: "session_started",
+          sessionId
+        });
+      }
+      for (const event of transcriptEventsForClaudeMessage(
+        message,
+        sessionId,
+        streamUsageTracker
+      )) {
+        if (event.type === "assistant_message") {
+          recordClaudeAssistantAggregate(state, event);
         }
-        break;
+        if (event.type === "usage") {
+          state.usage = event.usage;
+        }
+        await options.onTranscriptEvent?.(event);
       }
-      case "interrupted": {
-        state.completedTurnCount += 1;
-        if (state.sessionId !== void 0) {
-          await options.onTranscriptEvent?.({
-            type: "turn_interrupted",
-            sessionId: state.sessionId
-          });
+      const resultOutcome = extractClaudeResultOutcome(message);
+      switch (resultOutcome.type) {
+        case "success": {
+          if (resultOutcome.text !== void 0) {
+            state.resultText = resultOutcome.text;
+          }
+          state.usage = extractClaudeUsage(message) ?? state.usage;
+          state.completedTurnCount += 1;
+          if (options.streamingInput !== void 0) {
+            await emitClaudeCodeTurnCompleted(options, state);
+            state.lastCompletedTurnBody = state.resultText ?? nonEmptyText(claudeAssistantAggregateText(state)) ?? "";
+            await options.onTurnCompleted?.();
+            resetClaudeAssistantAggregate(state);
+            state.resultText = void 0;
+          }
+          break;
         }
-        if (options.streamingInput !== void 0) {
-          await options.onTurnCompleted?.();
-          resetClaudeAssistantAggregate(state);
-          state.resultText = void 0;
+        case "interrupted": {
+          state.completedTurnCount += 1;
+          if (state.sessionId !== void 0) {
+            await options.onTranscriptEvent?.({
+              type: "turn_interrupted",
+              sessionId: state.sessionId
+            });
+          }
+          if (options.streamingInput !== void 0) {
+            await options.onTurnCompleted?.();
+            resetClaudeAssistantAggregate(state);
+            state.resultText = void 0;
+          }
+          break;
         }
-        break;
+        case "error":
+          return await failClaudeCodeSession(
+            options,
+            state.sessionId,
+            `Claude Code failed: ${resultOutcome.reason}`
+          );
+        case "none":
+          break;
       }
-      case "error":
-        return await failClaudeCodeSession(
-          options,
-          state.sessionId,
-          `Claude Code failed: ${resultOutcome.reason}`
-        );
-      case "none":
-        break;
     }
+  } finally {
+    options.streamingInput?.close();
   }
   return completeClaudeCodeSession(options, state);
 }
 async function emitClaudeCodeTurnCompleted(options, state) {
-  const body = state.resultText ?? nonEmptyText(claudeAssistantAggregateText(state));
-  if (body === void 0) {
-    return;
-  }
+  const body = state.resultText ?? nonEmptyText(claudeAssistantAggregateText(state)) ?? "";
   if (state.sessionId === void 0) {
     return;
   }
@@ -12532,7 +12532,7 @@ async function emitClaudeCodeTurnCompleted(options, state) {
   });
 }
 async function completeClaudeCodeSession(options, state) {
-  const body = state.resultText ?? nonEmptyText(claudeAssistantAggregateText(state));
+  const body = state.resultText ?? nonEmptyText(claudeAssistantAggregateText(state)) ?? state.lastCompletedTurnBody;
   if (body === void 0) {
     return await failClaudeCodeSession(
       options,
@@ -18127,7 +18127,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.84-beta";
+    linzumiCliVersion = "0.0.85-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -19250,7 +19250,9 @@ function ignoredMessage(payload) {
     `reason=${text(payload.reason)}`,
     optionalField("type", payload.type),
     optionalField("thread", payload.thread_id),
+    optionalField("bound_thread", payload.bound_thread_id),
     optionalField("body_chars", payload.body_length),
+    optionalField("body", payload.body_preview),
     optionalField("attachments", payload.attachment_count),
     optionalField("local_event", payload.local_runner_event_type)
   ].filter((part) => part !== void 0).join(" ");
@@ -22592,7 +22594,29 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     );
     dynamicChannelSessions.clear();
     dynamicChannelSessionCodexClients.clear();
-    for (const session of activeClaudeCodeSessions.values()) {
+    const claudeSessions = [...activeClaudeCodeSessions.values()];
+    for (const session of claudeSessions) {
+      try {
+        session.closeInput();
+      } catch (error) {
+        log2("claude_code.session_input_close_failed", {
+          linzumi_thread_id: session.threadId,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    await Promise.race([
+      Promise.allSettled(
+        claudeSessions.flatMap((session) => {
+          const work = session.sessionWork();
+          return work === void 0 ? [] : [work];
+        })
+      ),
+      new Promise((resolve12) => {
+        setTimeout(resolve12, 1e4).unref?.();
+      })
+    ]);
+    for (const session of claudeSessions) {
       session.abortController.abort(new Error("local runner stopped"));
     }
     activeClaudeCodeSessions.clear();
@@ -24449,10 +24473,28 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
             };
           }
           try {
-            activeSession.enqueueInput({
+            const enqueueResult = activeSession.enqueueInput({
               content: contentResult.content,
               sourceSeq
             });
+            if (enqueueResult === "duplicate") {
+              log2("claude_code.message_duplicate_ignored", {
+                linzumi_thread_id: optionalThreadControlField(control, "threadId") ?? null,
+                claude_session_id: codexThreadId,
+                body_preview: claudeConsoleBodyPreview(workDescription),
+                source_seq: sourceSeq ?? null
+              });
+              return {
+                instanceId,
+                controlType: control.type,
+                agentProvider: "claude-code",
+                cwd: cwd.cwd,
+                matchedRoot: cwd.matchedRoot,
+                codexThreadId,
+                queuedInput: true,
+                duplicate: true
+              };
+            }
             log2("claude_code.message_queued", {
               linzumi_thread_id: optionalThreadControlField(control, "threadId") ?? null,
               claude_session_id: codexThreadId,
@@ -24956,7 +24998,24 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
       };
     }
     case "stop_instance":
-    case "kill_instance":
+    case "kill_instance": {
+      const controlThreadId2 = "threadId" in control && typeof control.threadId === "string" ? control.threadId : void 0;
+      const activeSession = controlThreadId2 === void 0 ? void 0 : activeClaudeCodeSessions.get(controlThreadId2);
+      if (activeSession !== void 0) {
+        await activeSession.interruptTurn("Claude Code stopped by Linzumi");
+        activeSession.abortController.abort(
+          new Error("Claude Code stopped by Linzumi")
+        );
+        return {
+          instanceId,
+          controlType: control.type,
+          agentProvider: "claude-code",
+          threadId: controlThreadId2,
+          stopped: true
+        };
+      }
+      return { instanceId, controlType: control.type, skipped: true };
+    }
     case "resolve_port_forward_request":
     case "update_thread_interaction_access":
     case "set_port_forward_enabled":
@@ -25456,10 +25515,10 @@ function createClaudeCodeInputQueue(input) {
     claudeCodeUserInputMessage(input.content)
   ];
   const pendingSourceSeqs = [input.sourceSeq];
+  const deferredFollowUps = [];
   const waiters = [];
   const state = {
-    closed: false,
-    queuedTurnCount: 1
+    closed: false
   };
   const drainClosedWaiters = () => {
     while (state.closed) {
@@ -25470,19 +25529,25 @@ function createClaudeCodeInputQueue(input) {
       waiter({ done: true, value: void 0 });
     }
   };
+  const deliverNow = (message, sourceSeq) => {
+    pendingSourceSeqs.push(sourceSeq);
+    const waiter = waiters.shift();
+    if (waiter === void 0) {
+      pendingMessages.push(message);
+      return;
+    }
+    waiter({ done: false, value: message });
+  };
   const enqueue = (next) => {
     if (state.closed) {
       throw new Error("Claude Code streaming input is closed");
     }
     const message = claudeCodeUserInputMessage(next.content);
-    pendingSourceSeqs.push(next.sourceSeq);
-    state.queuedTurnCount += 1;
-    const waiter = waiters.shift();
-    if (waiter === void 0) {
-      pendingMessages.push(message);
+    if (pendingSourceSeqs.length > 0) {
+      deferredFollowUps.push({ message, sourceSeq: next.sourceSeq });
       return;
     }
-    waiter({ done: false, value: message });
+    deliverNow(message, next.sourceSeq);
   };
   const enqueueSteer = (content) => {
     if (state.closed) {
@@ -25520,14 +25585,30 @@ function createClaudeCodeInputQueue(input) {
         };
       }
     },
-    queuedTurnCount: () => state.queuedTurnCount,
     close: () => {
+      if (pendingSourceSeqs.length === 0) {
+        while (deferredFollowUps.length > 0) {
+          const followUp = deferredFollowUps.shift();
+          if (followUp !== void 0) {
+            deliverNow(followUp.message, followUp.sourceSeq);
+          }
+        }
+      }
       state.closed = true;
       drainClosedWaiters();
     },
     enqueue,
     enqueueSteer,
-    completeTurn: () => pendingSourceSeqs.shift(),
+    completeTurn: () => {
+      const completed = pendingSourceSeqs.shift();
+      if (!state.closed && pendingSourceSeqs.length === 0) {
+        const nextFollowUp = deferredFollowUps.shift();
+        if (nextFollowUp !== void 0) {
+          deliverNow(nextFollowUp.message, nextFollowUp.sourceSeq);
+        }
+      }
+      return completed;
+    },
     currentSourceSeq: () => pendingSourceSeqs[0]
   };
 }
@@ -25775,6 +25856,11 @@ async function startClaudeCodeProviderInstance(args) {
     codexVersion: void 0
   };
   const abortController = new AbortController();
+  const acceptedSourceSeqs = new Set(
+    sourceSeq === void 0 ? [] : [sourceSeq]
+  );
+  const sessionWorkHandle = { value: void 0 };
+  let startControlResponded = false;
   let activeSessionId;
   let sessionControls;
   const planMirrorClient = createLinzumiMcpApiClient({
@@ -25909,7 +25995,7 @@ async function startClaudeCodeProviderInstance(args) {
     rootSeq,
     log: args.log
   };
-  let lastRateLimitSignature;
+  const lastRateLimitSignatureByWindow = /* @__PURE__ */ new Map();
   const reportClaudeCodeRateLimit = async (event) => {
     const nowMs = Date.now();
     const summary = claudeCodeRateLimitSummaryText(event.rateLimit, nowMs);
@@ -25925,13 +26011,13 @@ async function startClaudeCodeProviderInstance(args) {
       utilization_percent: event.rateLimit.utilizationPercent ?? null,
       resets_at_ms: event.rateLimit.resetsAtMs ?? null
     });
+    const windowKey = event.rateLimit.rateLimitType ?? "account";
     const signature = claudeRateLimitSignature(event.rateLimit);
-    if (signature === lastRateLimitSignature) {
+    if (signature === lastRateLimitSignatureByWindow.get(windowKey)) {
       return;
     }
-    lastRateLimitSignature = signature;
     try {
-      await postClaudeCodeRateLimitMessage({
+      await publishClaudeCodeRateLimitState({
         kandan: args.kandan,
         topic: args.topic,
         workspace,
@@ -25940,6 +26026,7 @@ async function startClaudeCodeProviderInstance(args) {
         claudeSessionId: event.sessionId ?? activeSessionId,
         rateLimit: event.rateLimit
       });
+      lastRateLimitSignatureByWindow.set(windowKey, signature);
     } catch (error) {
       args.log("claude_code.rate_limit_post_failed", {
         thread_id: threadId,
@@ -25947,6 +26034,10 @@ async function startClaudeCodeProviderInstance(args) {
       });
     }
   };
+  let settleFirstTurn = () => void 0;
+  const firstTurnSettled = new Promise((resolve12) => {
+    settleFirstTurn = resolve12;
+  });
   const onTranscriptEvent = async (event) => {
     try {
       await mirrorClaudeSessionStoreAppend(mirrorArgs, event);
@@ -25969,7 +26060,19 @@ async function startClaudeCodeProviderInstance(args) {
         channel,
         threadId,
         currentSourceSeq: inputQueue.currentSourceSeq,
-        enqueueInput: inputQueue.enqueue,
+        enqueueInput: (input) => {
+          if (input.sourceSeq !== void 0 && acceptedSourceSeqs.has(input.sourceSeq)) {
+            return "duplicate";
+          }
+          inputQueue.enqueue(input);
+          if (input.sourceSeq !== void 0) {
+            acceptedSourceSeqs.add(input.sourceSeq);
+          }
+          return "queued";
+        },
+        closeInput: inputQueue.close,
+        hasActiveTurn: () => adapter.activeTurnId() !== void 0,
+        sessionWork: () => sessionWorkHandle.value,
         steerTurn: inputQueue.enqueueSteer,
         interruptTurn: async (reason) => {
           const aborted = adapter.interruptActiveTurn(reason);
@@ -26025,6 +26128,10 @@ async function startClaudeCodeProviderInstance(args) {
         claude_session_id: event.sessionId,
         body_preview: claudeConsoleBodyPreview(event.body)
       });
+      settleFirstTurn();
+    }
+    if (event.type === "turn_interrupted") {
+      settleFirstTurn();
     }
     if (event.type === "rate_limit") {
       await reportClaudeCodeRateLimit(event);
@@ -26071,80 +26178,97 @@ async function startClaudeCodeProviderInstance(args) {
     request,
     signal
   });
-  let result;
-  try {
+  const runSession = async () => {
+    let result2;
     try {
-      result = await startClaudeCodeSession({
-        cwd: args.cwd,
-        prompt: workDescription,
-        developerInstructions: commanderDeveloperInstructions({
+      try {
+        result2 = await startClaudeCodeSession({
           cwd: args.cwd,
-          agentLabel: "Claude Code",
-          planTool: "todo-write",
-          developerPrompt,
-          linzumiContext
-        }),
-        model: claudeCodeModelForRuntimeModel(runtimeSettings.model),
-        resumeSessionId: args.resumeSessionId,
-        abortController,
-        streamingInput: inputQueue,
-        runner: args.options.claudeCodeRunner,
-        canUseTool,
-        ...mcpServers === void 0 ? {} : { mcpServers },
-        ...liveBashCapture === void 0 ? {} : {
-          preToolUseHookMatchers: liveBashCapture.hookMatchers,
-          wrapApprovedToolInput: (toolUseId, toolName2, input) => toolName2 === "Bash" ? liveBashCapture.wrapApprovedTool(toolUseId, input) : void 0
-        },
-        env: sessionEnv,
-        // The built-in Linzumi MCP is trusted like the codex side: its tools
-        // run without an approval round-trip. SDK allowedTools matches MCP
-        // tools as mcp__<server>__<tool>; the __* suffix covers the server.
-        allowedTools: ["mcp__linzumi__*"],
-        onSessionControls: (controls) => {
-          sessionControls = controls;
-        },
-        onTurnCompleted: () => {
-          inputQueue.completeTurn();
-        },
-        onTranscriptEvent
-      });
-    } finally {
-      inputQueue.close();
-      mcpAuthCleanup?.();
-      liveBashCapture?.close();
-      if (activeSessionId !== void 0) {
-        args.activeClaudeCodeSessions.delete(activeSessionId);
-        await args.disposeClaudeCodeForwardPortSession?.(activeSessionId);
+          prompt: workDescription,
+          developerInstructions: commanderDeveloperInstructions({
+            cwd: args.cwd,
+            agentLabel: "Claude Code",
+            planTool: "todo-write",
+            developerPrompt,
+            linzumiContext
+          }),
+          model: claudeCodeModelForRuntimeModel(runtimeSettings.model),
+          resumeSessionId: args.resumeSessionId,
+          abortController,
+          streamingInput: inputQueue,
+          runner: args.options.claudeCodeRunner,
+          canUseTool,
+          ...mcpServers === void 0 ? {} : { mcpServers },
+          ...liveBashCapture === void 0 ? {} : {
+            preToolUseHookMatchers: liveBashCapture.hookMatchers,
+            wrapApprovedToolInput: (toolUseId, toolName2, input) => toolName2 === "Bash" ? liveBashCapture.wrapApprovedTool(toolUseId, input) : void 0
+          },
+          env: sessionEnv,
+          // The built-in Linzumi MCP is trusted like the codex side: its tools
+          // run without an approval round-trip. SDK allowedTools matches MCP
+          // tools as mcp__<server>__<tool>; the __* suffix covers the server.
+          allowedTools: ["mcp__linzumi__*"],
+          onSessionControls: (controls) => {
+            sessionControls = controls;
+          },
+          onTurnCompleted: () => {
+            inputQueue.completeTurn();
+            settleFirstTurn();
+          },
+          onTranscriptEvent
+        });
+      } finally {
+        inputQueue.close();
+        mcpAuthCleanup?.();
+        liveBashCapture?.close();
+        if (activeSessionId !== void 0) {
+          args.activeClaudeCodeSessions.delete(activeSessionId);
+          await args.disposeClaudeCodeForwardPortSession?.(activeSessionId);
+        }
       }
+    } catch (error) {
+      adapter.submitLifecycle(
+        "codexDied",
+        error instanceof Error ? error.message : String(error)
+      );
+      await adapter.close(5e3).catch(() => void 0);
+      await Promise.race([
+        planMirror.settle().catch(() => void 0),
+        new Promise((resolve12) => {
+          setTimeout(resolve12, 5e3).unref?.();
+        })
+      ]);
+      logStartFailureTerminal(
+        error instanceof Error ? error.message : String(error)
+      );
+      if (!startControlResponded) {
+        args.setStartupStage("claude_code_session_failed");
+      }
+      throw error;
     }
-  } catch (error) {
-    adapter.submitLifecycle(
-      "codexDied",
-      error instanceof Error ? error.message : String(error)
-    );
-    await adapter.close(5e3).catch(() => void 0);
+    if (!startControlResponded) {
+      args.setStartupStage("posting_claude_code_output");
+    }
+    await adapter.awaitTurnsSettled(3e4);
+    await adapter.close(3e4);
     await Promise.race([
-      planMirror.settle().catch(() => void 0),
+      planMirror.settle(),
       new Promise((resolve12) => {
-        setTimeout(resolve12, 5e3).unref?.();
+        setTimeout(resolve12, 1e4).unref?.();
       })
     ]);
-    logStartFailureTerminal(
-      error instanceof Error ? error.message : String(error)
-    );
-    args.setStartupStage("claude_code_session_failed");
-    throw error;
-  }
-  args.setStartupStage("posting_claude_code_output");
-  await adapter.awaitTurnsSettled(3e4);
-  await adapter.close(3e4);
-  await Promise.race([
-    planMirror.settle(),
-    new Promise((resolve12) => {
-      setTimeout(resolve12, 1e4).unref?.();
-    })
+    return result2;
+  };
+  const sessionWork = runSession();
+  sessionWorkHandle.value = sessionWork;
+  const settled = await Promise.race([
+    sessionWork.then((result2) => ({
+      type: "session_ended",
+      result: result2
+    })),
+    firstTurnSettled.then(() => ({ type: "first_turn_settled" }))
   ]);
-  return {
+  const respondWithSessionId = (sessionId) => ({
     controlResponse: {
       instanceId: args.instanceId,
       controlType: args.control.type,
@@ -26152,16 +26276,52 @@ async function startClaudeCodeProviderInstance(args) {
       cwd: args.cwd,
       matchedRoot: args.matchedRoot,
       response: {
-        session: { id: result.sessionId }
+        session: { id: sessionId }
       }
     },
     providerSession: {
       provider: "claude-code",
       cwd: args.cwd,
       matchedRoot: args.matchedRoot,
-      sessionId: result.sessionId
+      sessionId
     }
-  };
+  });
+  if (settled.type === "session_ended") {
+    return respondWithSessionId(settled.result.sessionId);
+  }
+  args.setStartupStage("posting_claude_code_output");
+  startControlResponded = true;
+  await adapter.awaitTurnsSettled(3e4);
+  try {
+    await adapter.flush(3e4);
+  } catch (error) {
+    args.log("claude_code.first_turn_flush_timeout", {
+      linzumi_thread_id: threadId,
+      claude_session_id: activeSessionId ?? null,
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+  void sessionWork.then(
+    () => {
+      args.log("claude_code.session_loop_ended", {
+        linzumi_thread_id: threadId,
+        claude_session_id: activeSessionId ?? null
+      });
+    },
+    (error) => {
+      args.log("claude_code.session_loop_failed", {
+        linzumi_thread_id: threadId,
+        claude_session_id: activeSessionId ?? null,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  );
+  const liveSessionId = activeSessionId ?? args.resumeSessionId;
+  if (liveSessionId !== void 0) {
+    return respondWithSessionId(liveSessionId);
+  }
+  const result = await sessionWork;
+  return respondWithSessionId(result.sessionId);
 }
 function claudePermissionModeForApprovalPolicy(approvalPolicy) {
   switch (approvalPolicy) {
@@ -26403,50 +26563,26 @@ function claudeRateLimitSignature(rateLimit) {
     rateLimit.resetsAtMs ?? "na"
   ].join(":");
 }
-async function postClaudeCodeRateLimitMessage(args) {
-  const nowMs = Date.now();
-  const summary = claudeCodeRateLimitSummaryText(args.rateLimit, nowMs);
-  const headline = `Claude Code rate limit: ${summary}`;
-  const resetLabel = claudeCodeRateLimitResetLabel(
-    args.rateLimit.resetsAtMs,
-    nowMs
-  );
-  const richUi = args.rateLimit.utilizationPercent === void 0 ? [{ primitive: "label", label: headline }] : [
-    {
-      primitive: "progress",
-      value: Math.min(
-        100,
-        Math.max(0, Math.round(args.rateLimit.utilizationPercent))
-      ),
-      max: 100,
-      label: `Claude Code rate limit${resetLabel === void 0 ? "" : ` - ${resetLabel}`}`
-    }
-  ];
-  await args.kandan.push(args.topic, "session:post_thread_message", {
+async function publishClaudeCodeRateLimitState(args) {
+  await args.kandan.push(args.topic, "claude_rate_limit_state", {
     workspace: args.workspace,
     channel: args.channel,
     thread_id: args.threadId,
-    body: headline,
-    payload: {
-      rich_ui: richUi,
-      metadata: {
-        local_codex_runner: {
-          event_type: "claude_code_rate_limit",
-          agent_provider: "claude-code",
-          ...args.claudeSessionId === void 0 ? {} : { claude_session_id: args.claudeSessionId }
-        }
-      }
+    agent_provider: "claude-code",
+    ...args.claudeSessionId === void 0 ? {} : { claude_session_id: args.claudeSessionId },
+    // "account" mirrors the server-side default for SDK frames that omit a
+    // window type; sending it explicitly keeps the wire contract obvious.
+    rate_limit_type: args.rateLimit.rateLimitType ?? "account",
+    status: args.rateLimit.status ?? "allowed",
+    ...args.rateLimit.utilizationPercent === void 0 ? {} : {
+      utilization_percent: Math.min(
+        100,
+        Math.max(0, Math.round(args.rateLimit.utilizationPercent))
+      )
     },
-    client_message_id: claudeRateLimitClientMessageId(
-      args.threadId,
-      args.rateLimit
-    )
+    ...args.rateLimit.resetsAtMs === void 0 ? {} : { resets_at_ms: args.rateLimit.resetsAtMs }
   });
 }
-function claudeRateLimitClientMessageId(threadId, rateLimit) {
-  const digest = createHash5("sha256").update(`${threadId}:${claudeRateLimitSignature(rateLimit)}`).digest("hex").slice(0, 32);
-  return `claude-rate-limit-${digest}`;
-}
 async function publishStartInstanceMessageState(kandan, topic, control, status, reason, diagnostics = {}) {
   const payload = startInstanceMessageStatePayload(
     control,

package/package.json

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