@cuongtran001/kanna 1.2.0 → 1.3.1

package/src/server/agent-deps-builders.ts

@@ -0,0 +1,425 @@
+/**
+ * Builder functions for all 18 *Deps objects used by AgentCoordinator.
+ *
+ * Each function takes the coordinator instance and returns the typed *Deps
+ * object that the corresponding functional module expects. Using
+ * `import type { AgentCoordinator }` avoids a circular runtime dependency
+ * (the import is erased at compile time).
+ *
+ * **Visibility requirement:** All AgentCoordinator fields and methods accessed
+ * here must be declared `readonly` (not `private readonly`) so TypeScript
+ * allows external access.
+ */
+
+import type { AgentCoordinator } from "./agent-coordinator"
+import { ensureFreshMcpToken } from "./mcp-oauth.adapter"
+import { realpathAdapter } from "./paths-fs.adapter"
+import { ensureTrackingFile } from "./loop-template-io.adapter"
+import { homedir } from "node:os"
+import { providerUsesSdkSession } from "../shared/types"
+import { isClaudeSdkProvider } from "./provider-catalog"
+
+import type { ClaudeSessionConfigHelpersDeps } from "./claude-session-config-helpers"
+import type { SessionLifecycleDeps } from "./claude-session-lifecycle"
+import type { SessionErrorHandlerDeps } from "./claude-session-error-handler"
+import type { AutoContinueCommandDeps } from "./claude-autocontinue-commands"
+import type { LoopOrchCommandDeps } from "./claude-loop-orch-commands"
+import type { CancelHandlerDeps } from "./claude-cancel-handler"
+import type { ChatManagementDeps } from "./claude-chat-management"
+import type { SendCommandDeps } from "./claude-send-command"
+import type { SubagentWiringDeps } from "./claude-subagent-wiring"
+import type { SlashCommandsDeps } from "./claude-slash-commands"
+import type { SubagentToolResponseDeps } from "./claude-subagent-tool-response"
+import type { ToolRespondDeps } from "./claude-tool-respond"
+import type { SessionStateQueryDeps } from "./claude-session-state-queries"
+import type { StartTurnDeps } from "./claude-turn-starter"
+import type { SessionRebuildDeps } from "./claude-session-rebuild"
+import type { SpawnClaudeTurnDeps } from "./claude-session-spawner"
+import type { RunClaudeSessionDeps } from "./claude-session-runner"
+import type { RunTurnDeps } from "./claude-turn-runner"
+
+// ---------------------------------------------------------------------------
+// 1. Session config helpers
+// ---------------------------------------------------------------------------
+
+export function buildClaudeSessionConfigHelpersDeps(agent: AgentCoordinator): ClaudeSessionConfigHelpersDeps {
+  return {
+    getAppSettingsSnapshot: () => agent.getAppSettingsSnapshot(),
+    chatPolicy: agent.chatPolicy,
+    store: agent.store,
+    ptyInstanceRegistry: agent.ptyInstanceRegistry,
+    ensureFreshToken: (server, opts) => ensureFreshMcpToken(server, opts),
+    persistOAuthState: agent.persistOAuthStateFn,
+    killProcessTree: async (pid) => {
+      const { killProcessTree } = await import("./claude-pty/pid-registry.adapter")
+      await killProcessTree(pid)
+    },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 2. Session lifecycle
+// ---------------------------------------------------------------------------
+
+export function buildSessionLifecycleDeps(agent: AgentCoordinator): SessionLifecycleDeps {
+  return {
+    getAppSettingsSnapshot: () => agent.getAppSettingsSnapshot(),
+    defaultIdleMs: agent.claudeSessionLifecycle.idleMs,
+    defaultMaxResidentSessions: agent.claudeSessionLifecycle.maxResidentSessions,
+    claudeSessions: agent.claudeSessions,
+    activeTurns: agent.activeTurns,
+    oauthPool: agent.oauthPool,
+    workflowRegistry: agent.workflowRegistry,
+    resolveClaudeDriverPreference: () => agent.resolveClaudeDriverPreference(),
+    emitStateChange: (chatId: string) => { agent.emitStateChange(chatId) },
+    store: agent.store,
+    homeDir: homedir(),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 3. Session error handler
+// ---------------------------------------------------------------------------
+
+export function buildSessionErrorHandlerDeps(agent: AgentCoordinator): SessionErrorHandlerDeps {
+  return {
+    tokenRotationDedupe: agent.tokenRotationDedupe,
+    claudeSessions: agent.claudeSessions,
+    activeTurns: agent.activeTurns,
+    oauthPool: agent.oauthPool,
+    store: agent.store,
+    resolveAutoResumeFor: (chatId: string) => agent.resolveAutoResumeFor(chatId),
+    emitAutoContinueEvent: (event) => agent.emitAutoContinueEvent(event),
+    closeClaudeSession: (chatId, session, opts?) =>
+      agent.closeClaudeSession(chatId, session, opts),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 4. Auto-continue commands
+// ---------------------------------------------------------------------------
+
+export function buildAutoContinueCommandDeps(agent: AgentCoordinator): AutoContinueCommandDeps {
+  return {
+    autoResumeByChat: agent.autoResumeByChat,
+    getAutoResumePreference: () => agent.getAutoResumePreference(),
+    store: agent.store,
+    scheduleManager: agent.scheduleManager,
+    emitStateChange: (chatId: string) => { agent.emitStateChange(chatId) },
+    enqueueMessage: (chatId, content, attachments, options) =>
+      agent.enqueueMessage(chatId, content, attachments, options),
+    maybeStartNextQueuedMessage: (chatId) => agent.maybeStartNextQueuedMessage(chatId),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 5. Loop / orch commands
+// ---------------------------------------------------------------------------
+
+export function buildLoopOrchCommandDeps(agent: AgentCoordinator): LoopOrchCommandDeps {
+  return {
+    store: agent.store,
+    orchestrationQueue: agent.getOrchestrationQueue(),
+    claudeSessions: agent.claudeSessions,
+    activeTurns: agent.activeTurns,
+    getSubagents: () => agent.getSubagents(),
+    getAppSettingsSnapshot: () => agent.getAppSettingsSnapshot(),
+    buildSubagentProviderRunForChat: (args) => agent.buildSubagentProviderRunForChat(args),
+    closeClaudeSession: (chatId, session) => agent.closeClaudeSession(chatId, session),
+    emitAutoContinueEvent: (event) => agent.emitAutoContinueEvent(event),
+    ensureTrackingFile,
+    isLoopArmed: (chatId) => agent.isLoopArmed(chatId),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 6. Cancel handler
+// ---------------------------------------------------------------------------
+
+export function buildCancelHandlerDeps(agent: AgentCoordinator): CancelHandlerDeps {
+  return {
+    drainingStreams: agent.drainingStreams,
+    rejectPendingResolversForChat: (chatId) => agent.rejectPendingResolversForChat(chatId),
+    cancelChatInOrchestrator: (chatId) => agent.getSubagentOrchestrator().cancelChat(chatId),
+    activeTurns: agent.activeTurns,
+    store: agent.store,
+    claudeSessions: agent.claudeSessions,
+    emitStateChange: (chatId) => agent.emitStateChange(chatId),
+    resolveClaudeDriverPreference: () => agent.resolveClaudeDriverPreference(),
+    closeClaudeSession: (chatId, session) => agent.closeClaudeSession(chatId, session),
+    maybeStartNextQueuedMessage: async (chatId) => { await agent.maybeStartNextQueuedMessage(chatId) },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 7. Chat management
+// ---------------------------------------------------------------------------
+
+export function buildChatManagementDeps(agent: AgentCoordinator): ChatManagementDeps {
+  return {
+    activeTurns: agent.activeTurns,
+    drainingStreams: agent.drainingStreams,
+    claudeSessions: agent.claudeSessions,
+    autoResumeByChat: agent.autoResumeByChat,
+    store: agent.store,
+    analytics: agent.analytics,
+    cancel: (chatId, options) => agent.cancel(chatId, options),
+    closeClaudeSession: (chatId, session, opts) => agent.closeClaudeSession(chatId, session, opts),
+    emitStateChange: (chatId) => agent.emitStateChange(chatId),
+    generateTitle: (messageContent, cwd) => agent.generateTitle(messageContent, cwd),
+    reportBackgroundError: agent.reportBackgroundError,
+    dequeueAndStartQueuedMessage: (chatId, queuedMessage, options) =>
+      agent.dequeueAndStartQueuedMessage(chatId, queuedMessage, options),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 8. Send command
+// ---------------------------------------------------------------------------
+
+export function buildSendCommandDeps(agent: AgentCoordinator): SendCommandDeps {
+  return {
+    store: agent.store,
+    activeTurns: agent.activeTurns,
+    claudeSessions: agent.claudeSessions,
+    autoResumeByChat: agent.autoResumeByChat,
+    analytics: agent.analytics,
+    getAppSettingsSnapshot: () => agent.getAppSettingsSnapshot(),
+    stopLoop: (chatId, reason) => agent.stopLoop(chatId, reason),
+    emitStateChange: (chatId) => agent.emitStateChange(chatId),
+    startTurnForChat: (args) => agent.startTurnForChat(args),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 9. Subagent wiring
+// ---------------------------------------------------------------------------
+
+export function buildSubagentWiringDeps(agent: AgentCoordinator): SubagentWiringDeps {
+  return {
+    store: agent.store,
+    startClaudeSessionFn: agent.startClaudeSessionFn,
+    startClaudeSessionPTYFn: agent.startClaudeSessionPTYFn,
+    toolCallback: agent.toolCallback,
+    tunnelGateway: agent.tunnelGateway,
+    claudePtyRegistry: agent.claudePtyRegistry,
+    ptyInstanceRegistry: agent.ptyInstanceRegistry,
+    workflowRegistry: agent.workflowRegistry,
+    subagentOrchestrator: agent.getSubagentOrchestrator(),
+    codexManager: agent.codexManager,
+    oauthPool: agent.oauthPool,
+    subagentPendingResolvers: agent.subagentPendingResolvers,
+    realpath: realpathAdapter,
+    resolveClaudeDriverPreference: () => agent.resolveClaudeDriverPreference(),
+    getEnabledCustomMcpServers: () => agent.getEnabledCustomMcpServers(),
+    buildOAuthBearers: (servers) => agent.buildOAuthBearers(servers),
+    resolveChatPolicy: (chatId) => agent.resolveChatPolicy(chatId),
+    emitStateChange: (chatId) => { agent.emitStateChange(chatId) },
+    buildPoolUnavailableMessage: (reservedFor, scopeSuffix) =>
+      agent.buildPoolUnavailableMessage(reservedFor, scopeSuffix),
+    getAppSettingsSnapshot: () => agent.getAppSettingsSnapshot(),
+    readLlmProvider: () => agent.readLlmProvider(),
+    subagentPendingKey: (chatId, runId, toolUseId) =>
+      agent.subagentPendingKey(chatId, runId, toolUseId),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 10. Slash commands
+// ---------------------------------------------------------------------------
+
+export function buildSlashCommandsDeps(agent: AgentCoordinator): SlashCommandsDeps {
+  return {
+    store: agent.store,
+    claudeSessions: agent.claudeSessions,
+    oauthPool: agent.oauthPool,
+    slashCommandsInFlight: agent.slashCommandsInFlight,
+    emitStateChange: (chatId) => { agent.emitStateChange(chatId) },
+    resolveClaudeDriverPreference: () => agent.resolveClaudeDriverPreference(),
+    startClaudeSessionPTY: agent.startClaudeSessionPTYFn,
+    startClaudeSessionSDK: agent.startClaudeSessionFn,
+    getSubagents: () => agent.getSubagents(),
+    getGlobalPromptAppend: () => agent.getAppSettingsSnapshot().globalPromptAppend,
+    getEnabledCustomMcpServers: () => agent.getEnabledCustomMcpServers(),
+    claudePtyRegistry: agent.claudePtyRegistry,
+    ptyInstanceRegistry: agent.ptyInstanceRegistry,
+    workflowRegistry: agent.workflowRegistry,
+    subagentTranscriptRegistry: agent.subagentTranscriptRegistry,
+    localCatalog: agent.localCatalog,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 11. Subagent tool response
+// ---------------------------------------------------------------------------
+
+export function buildSubagentToolResponseDeps(agent: AgentCoordinator): SubagentToolResponseDeps {
+  return {
+    subagentPendingResolvers: agent.subagentPendingResolvers,
+    store: agent.store,
+    subagentOrchestrator: agent.getSubagentOrchestrator(),
+    emitStateChange: (chatId) => { agent.emitStateChange(chatId) },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 12. Tool respond
+// ---------------------------------------------------------------------------
+
+export function buildToolRespondDeps(agent: AgentCoordinator): ToolRespondDeps {
+  return {
+    activeTurns: agent.activeTurns,
+    store: agent.store,
+    emitStateChange: (chatId) => { agent.emitStateChange(chatId) },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 13. Session state queries
+// ---------------------------------------------------------------------------
+
+export function buildSessionStateQueryDeps(agent: AgentCoordinator): SessionStateQueryDeps {
+  return {
+    activeTurns: agent.activeTurns,
+    claudeSessions: agent.claudeSessions,
+    drainingStreams: agent.drainingStreams,
+    slashCommandsInFlight: agent.slashCommandsInFlight,
+    isClaudeSdkProvider: (provider) => isClaudeSdkProvider(provider),
+    hasPendingBackgroundTask: (session, now) => agent.hasPendingBackgroundTask(session, now),
+    resolveClaudeIdleMs: () => agent.resolveClaudeIdleMs(),
+    hasLiveWorkflow: (chatId) => agent.hasLiveWorkflow(chatId),
+    closeClaudeSession: (chatId, session) => { agent.closeClaudeSession(chatId, session) },
+    emitStateChange: (chatId) => { agent.emitStateChange(chatId) },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 14. Start turn
+// ---------------------------------------------------------------------------
+
+export function buildStartTurnDeps(agent: AgentCoordinator): StartTurnDeps {
+  return {
+    activeTurns: agent.activeTurns,
+    claudeSessions: agent.claudeSessions,
+    drainingStreams: agent.drainingStreams,
+    mentionedSubagentIdsByChat: agent.mentionedSubagentIdsByChat,
+    store: agent.store,
+    codexManager: agent.codexManager,
+    subagentOrchestrator: agent.getSubagentOrchestrator(),
+    clearDrainingStream: (chatId) => agent.clearDrainingStream(chatId),
+    emitStateChange: (chatId, opts) => agent.emitStateChange(chatId, opts),
+    resolveClaudeDriverPreference: () => agent.resolveClaudeDriverPreference(),
+    getSubagents: () => agent.getSubagents(),
+    getAppSettingsSnapshot: () => agent.getAppSettingsSnapshot(),
+    generateTitleInBackground: (chatId, content, localPath, optimisticTitle) =>
+      agent.generateTitleInBackground(chatId, content, localPath, optimisticTitle),
+    recreateActiveTurnFromSession: (args) => agent.recreateActiveTurnFromSession(args),
+    startClaudeTurn: (args) => agent.startClaudeTurn(args),
+    findLastUserMessageId: (chatId) => agent.findLastUserMessageId(chatId),
+    runTurn: (active) => agent.runTurn(active),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 15. Session rebuild
+// ---------------------------------------------------------------------------
+
+export function buildSessionRebuildDeps(agent: AgentCoordinator): SessionRebuildDeps {
+  return {
+    claudeSessions: agent.claudeSessions,
+    activeTurns: agent.activeTurns,
+    providerUsesSdkSession: (provider) => providerUsesSdkSession(provider),
+    getMessages: (chatId) => agent.store.getMessages(chatId),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 16. Spawn Claude turn
+// ---------------------------------------------------------------------------
+
+export function buildSpawnClaudeTurnDeps(agent: AgentCoordinator): SpawnClaudeTurnDeps {
+  return {
+    claudeSessions: agent.claudeSessions,
+    activeTurns: agent.activeTurns,
+    mentionedSubagentIdsByChat: agent.mentionedSubagentIdsByChat,
+    oauthPool: agent.oauthPool,
+    store: agent.store,
+    startClaudeSessionFn: agent.startClaudeSessionFn,
+    startClaudeSessionPTYFn: agent.startClaudeSessionPTYFn,
+    subagentOrchestrator: agent.getSubagentOrchestrator(),
+    toolCallback: agent.toolCallback,
+    tunnelGateway: agent.tunnelGateway,
+    claudePtyRegistry: agent.claudePtyRegistry,
+    ptyInstanceRegistry: agent.ptyInstanceRegistry,
+    workflowRegistry: agent.workflowRegistry,
+    subagentTranscriptRegistry: agent.subagentTranscriptRegistry,
+    resolveClaudeDriverPreference: () => agent.resolveClaudeDriverPreference(),
+    isLoopArmed: (chatId) => agent.isLoopArmed(chatId),
+    closeClaudeSession: (chatId, session) => agent.closeClaudeSession(chatId, session),
+    enforceClaudeSessionBudget: (protectedChatId?) => agent.enforceClaudeSessionBudget(protectedChatId),
+    readLlmProvider: () => agent.readLlmProvider(),
+    buildPoolUnavailableMessage: (reservedFor, scopeSuffix) =>
+      agent.buildPoolUnavailableMessage(reservedFor, scopeSuffix),
+    listOpenRouterModelsFn: agent.listOpenRouterModelsFn,
+    getSubagents: () => agent.getSubagents(),
+    getAppSettingsSnapshot: () => agent.getAppSettingsSnapshot(),
+    getEnabledCustomMcpServers: () => agent.getEnabledCustomMcpServers(),
+    buildOAuthBearers: (servers) => agent.buildOAuthBearers(servers),
+    setupLoop: (chatId, input) => agent.setupLoop({ chatId, input }),
+    stopLoop: (chatId, reason) => agent.stopLoop(chatId, reason),
+    runOrchestration: (chatId, input) => agent.runOrchestration(chatId, input),
+    cancelOrchRun: (runId) => agent.cancelOrchRun(runId),
+    getOrchRunDetail: (runId) => agent.getOrchRunDetail(runId),
+    resolveChatPolicy: (chatId) => agent.resolveChatPolicy(chatId),
+    runClaudeSession: (session) => { void agent.runClaudeSession(session) },
+    mergeLocalCatalog: (commands, cwd) => agent.mergeLocalCatalog(commands, cwd),
+    emitStateChange: (chatId) => { agent.emitStateChange(chatId) },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 17. Run Claude session
+// ---------------------------------------------------------------------------
+
+export function buildRunClaudeSessionDeps(agent: AgentCoordinator): RunClaudeSessionDeps {
+  return {
+    openrouterFirstEntryTimeoutMs: agent.openrouterFirstEntryTimeoutMs,
+    claudeSessions: agent.claudeSessions,
+    activeTurns: agent.activeTurns,
+    oauthPool: agent.oauthPool,
+    claudeLimitDetector: agent.claudeLimitDetector,
+    claudeAuthErrorDetector: agent.claudeAuthErrorDetector,
+    throwOnClaudeSessionStart: agent.throwOnClaudeSessionStart,
+    store: agent.store,
+    emitStateChange: (chatId?) => { agent.emitStateChange(chatId) },
+    handleLimitDetection: (chatId, detection) => agent.handleLimitDetection(chatId, detection),
+    maybeRegisterSdkWorkflowsDir: (session) => { agent.maybeRegisterSdkWorkflowsDir(session) },
+    getSubagents: () => agent.getSubagents(),
+    resolveBackgroundTaskMaxMs: () => agent.resolveBackgroundTaskMaxMs(),
+    mergeLocalCatalog: (commands, cwd) => agent.mergeLocalCatalog(commands, cwd),
+    handleLimitError: (chatId, detector, error) => agent.handleLimitError(chatId, detector, error),
+    handleAuthFailure: (session, detection) => agent.handleAuthFailure(session, detection),
+    closeClaudeSession: (chatId, session) => { agent.closeClaudeSession(chatId, session) },
+    maybeStartNextQueuedMessage: (chatId) => agent.maybeStartNextQueuedMessage(chatId),
+    resolveClaudeDriverPreference: () => agent.resolveClaudeDriverPreference(),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 18. Run turn
+// ---------------------------------------------------------------------------
+
+export function buildRunTurnDeps(agent: AgentCoordinator): RunTurnDeps {
+  return {
+    store: agent.store,
+    activeTurns: agent.activeTurns,
+    drainingStreams: agent.drainingStreams,
+    oauthPool: agent.oauthPool,
+    codexLimitDetector: agent.codexLimitDetector,
+    handleLimitError: (chatId, detector, error) => agent.handleLimitError(chatId, detector, error),
+    emitStateChange: (chatId) => { agent.emitStateChange(chatId) },
+    clearDrainingStream: (chatId) => { agent.clearDrainingStream(chatId) },
+    startTurnForChat: (args) => agent.startTurnForChat(args),
+    maybeStartNextQueuedMessage: (chatId) => agent.maybeStartNextQueuedMessage(chatId),
+  }
+}

package/src/server/agent.oauth-rotation.test.ts

@@ -928,4 +928,105 @@ describe("AgentCoordinator OAuth rotation", () => {
     },
     10_000,
   )
+
+  test(
+    "errored rate-limit RESULT with no matching active turn still schedules a resume (loop silent-death regression)",
+    async () => {
+      // Regression for the 9h autonomous-loop stall: a synthetic 429 `result`
+      // arriving when the pending prompt-seq queue is already drained (observed
+      // on an auto-continue wake turn) fails the
+      // `completedClaudePromptSeq === active.claudePromptSeq` gate, so the entire
+      // error-handling block — INCLUDING limit detection — was skipped and the
+      // loop died with NO resume schedule (no proposal, no accept). It only
+      // recovered when the user manually typed "resume" hours later. A
+      // recognizable rate-limit result must schedule a resume even when the seq
+      // gate misses. Idempotent: handleLimitDetection dedupes on a live schedule.
+      let tokens: OAuthTokenEntry[] = [makeToken("a")] // single token → no rotation target
+      const pool = new OAuthTokenPool(
+        () => tokens,
+        (id, patch) => {
+          tokens = tokens.map((t) => (t.id === id ? { ...t, ...patch } : t))
+        },
+      )
+
+      const events = new AsyncEventQueue<HarnessEvent>()
+      const store = createFakeStore()
+      const coordinator = new AgentCoordinator({
+        store: store as never,
+        onStateChange: () => {},
+        oauthPool: pool,
+        // auto-resume preference defaults to OFF → the resume is a *proposal*,
+        // respecting the user's setting (not a silent forced accept).
+        startClaudeSession: async () => ({
+          provider: "claude",
+          stream: events,
+          getAccountInfo: async () => null,
+          interrupt: async () => {},
+          close: () => {},
+          setModel: async () => {},
+          setPermissionMode: async () => {},
+          getSupportedCommands: async () => [],
+          sendPrompt: async () => {
+            // Turn 1 finalizes normally, draining the pending prompt-seq…
+            events.push({
+              type: "transcript",
+              entry: {
+                _id: "result-ok",
+                createdAt: Date.now(),
+                kind: "result",
+                subtype: "success",
+                isError: false,
+                durationMs: 10,
+                result: "",
+              } as never,
+            })
+            // …then a synthetic 429 result arrives with the seq queue empty and
+            // no active turn — the gate misses. Pre-fix this was silently dropped.
+            events.push({
+              type: "transcript",
+              entry: {
+                _id: "result-429",
+                createdAt: Date.now(),
+                kind: "result",
+                subtype: "error",
+                isError: true,
+                durationMs: 0,
+                result: "You've hit your limit · resets 4:10am (Asia/Saigon)",
+              } as never,
+            })
+            events.close()
+          },
+        }),
+      })
+
+      await coordinator.send({
+        type: "chat.send",
+        chatId: "chat-1",
+        provider: "claude",
+        content: "test",
+        model: "claude-opus-4-7",
+      })
+
+      await waitFor(
+        () =>
+          store
+            .getAutoContinueEvents("chat-1")
+            .some(
+              (e) => e.kind === "auto_continue_proposed" || e.kind === "auto_continue_accepted",
+            ),
+        4000,
+        "unmatched rate-limit result schedules a resume instead of silent death",
+      )
+
+      const schedule = store
+        .getAutoContinueEvents("chat-1")
+        .find(
+          (e) => e.kind === "auto_continue_proposed" || e.kind === "auto_continue_accepted",
+        )
+      expect(schedule).toBeDefined()
+      // Single-token pool → no rotation; auto-resume off → a proposal (respects setting).
+      expect(schedule!.kind).toBe("auto_continue_proposed")
+    },
+    10_000,
+  )
 })

package/src/server/agent.test.ts

@@ -23,6 +23,7 @@ import type { ChatPermissionPolicy } from "../shared/permission-policy"
 import { POLICY_DEFAULT } from "../shared/permission-policy"
 import type { HarnessTurn } from "./harness-types"
 import type { ChatAttachment, McpServerConfig, SlashCommand, TranscriptEntry } from "../shared/types"
+import { AUTO_CONTINUE_EVENT_VERSION } from "./auto-continue/events"
 import type { AutoContinueEvent } from "./auto-continue/events"
 import type { WorkflowRegistry } from "./workflow-registry"
 import { AsyncEventQueue } from "./test-helpers/async-event-queue"
@@ -1213,13 +1214,19 @@ describe("AgentCoordinator codex integration", () => {
       content: "run something with a background task",
     })
 
-    // Wait for the result message to be persisted
-    await waitFor(() => store.messages.some((entry) => entry.kind === "result"))
+    // Wait for the active turn to be removed — this happens synchronously
+    // right after recordTurnFinished resolves, which is itself after
+    // appendMessage(result). Using this as the waitFor condition avoids a
+    // microtask-gap race: waiting for messages.some("result") fires one await
+    // before activeTurns.delete, so the assertion would see the turn still set.
+    await waitFor(() => !coordinator.getActiveStatuses().has("chat-1"))
 
     // The active turn should be removed even though the stream is still open.
     // This is the key assertion: the UI should show idle (not "Running...")
     // so the user can send new messages without hitting stop.
     expect(coordinator.getActiveStatuses().has("chat-1")).toBe(false)
+    // Result must have been appended (that's what triggers the removal).
+    expect(store.messages.some((entry) => entry.kind === "result")).toBe(true)
     expect(store.turnFinishedCount).toBe(1)
 
     // The stream is still open, so it should be draining
@@ -3600,7 +3607,7 @@ describe("AgentCoordinator claude integration", () => {
 
     // Pin the armed state to the test toggle — the send() takeover path would
     // otherwise disarm before the spawn check ever sees an armed loop.
-    coordinator.isLoopArmed = () => (armed ? { subagentId: "sa-1", prompt: "loop prompt" } : null)
+    coordinator.isLoopArmed = () => (armed ? { subagentId: "sa-1", prompt: "loop prompt", armedAt: 0 } : null)
 
     const sendTurn = async (content: string, expectedFinished: number) => {
       await coordinator.send({
@@ -3681,7 +3688,7 @@ describe("AgentCoordinator claude integration", () => {
       },
     })
 
-    coordinator.isLoopArmed = () => (armed ? { subagentId: "sa-1", prompt: "loop prompt" } : null)
+    coordinator.isLoopArmed = () => (armed ? { subagentId: "sa-1", prompt: "loop prompt", armedAt: 0 } : null)
 
     const sendTurn = async (content: string, expectedFinished: number) => {
       await coordinator.send({
@@ -4369,12 +4376,21 @@ describe("AgentCoordinator.deliverSubagentToMain (notification-driven /clear)",
 
   test("armed loop: notification omits <result> (PROGRESS.md is the contract) and the full loop prompt follows", async () => {
     const store = createFakeStore()
+    // Pre-arm the loop via store events so isLoopArmed() returns the armed state.
+    store.autoContinueEvents.push({
+      v: AUTO_CONTINUE_EVENT_VERSION,
+      timestamp: 0,
+      chatId: "chat-1",
+      scheduleId: "loop-schedule-1",
+      kind: "loop_armed",
+      subagentId: "sa-loop",
+      prompt: "LOOP DISCIPLINE PROMPT",
+    })
     const coordinator = new AgentCoordinator({
       store: store as never,
       onStateChange: () => {},
       startClaudeSession: async () => { throw new Error("not needed") },
     })
-    coordinator.isLoopArmed = () => ({ subagentId: "sa-loop", prompt: "LOOP DISCIPLINE PROMPT" })
 
     await (coordinator as unknown as { deliverSubagentToMain: DeliverFn }).deliverSubagentToMain(
       "chat-1",
@@ -4382,9 +4398,9 @@ describe("AgentCoordinator.deliverSubagentToMain (notification-driven /clear)",
       { status: "completed", runId: "run-loop", text: "iteration output that must not leak" },
     )
 
-    const events = store.getAutoContinueEvents("chat-1")
-    expect(events).toHaveLength(1)
-    const ev = events[0]
+    const acEvents = store.getAutoContinueEvents("chat-1").filter((e) => e.kind === "auto_continue_accepted")
+    expect(acEvents).toHaveLength(1)
+    const ev = acEvents[0]
     expect(ev.kind).toBe("auto_continue_accepted")
     if (ev.kind === "auto_continue_accepted") {
       expect(ev.prompt).toContain("<task-notification>")