🤖 perf: bind xum server listener before startup recovery; stop per-task config.json reloads

src/cli/server.ts

@@ -95,11 +95,11 @@ async function main(): Promise<void> {
   launchProjectPath = null;
 
   // Keepalive interval to prevent premature process exit during async initialization.
-  // During startup, taskService.initialize() may resume running tasks by calling
-  // sendMessage(), which spawns background AI streams. Between the completion of
-  // serviceContainer.initialize() and the HTTP server starting to listen, there can
-  // be a brief moment where no ref'd handles exist, causing Node to exit with code 0.
-  // This interval ensures the event loop stays alive until the server is listening.
+  // During startup, initializeCore() may resume running tasks by calling sendMessage(),
+  // which spawns background AI streams. Between its completion and the HTTP server
+  // starting to listen, there can be a brief moment where no ref'd handles exist,
+  // causing Node to exit with code 0. This interval ensures the event loop stays alive
+  // until the server is listening.
   const startupKeepalive = setInterval(() => {
     // Intentionally empty - keeps event loop alive during startup
   }, 1000);
@@ -116,9 +116,9 @@ async function main(): Promise<void> {
   }
 
   // Early lockfile check: detect an existing server BEFORE initializing services.
-  // serviceContainer.initialize() resumes queued/running tasks (via TaskService),
-  // so we must fail fast here to avoid orphaned side effects when another server
-  // already holds the lock. ServerService.startServer() re-checks as defense-in-depth.
+  // initializeCore() resumes queued/running tasks (via TaskService), so we must fail fast
+  // here to avoid orphaned side effects when another server already holds the lock.
+  // ServerService.startServer() re-checks as defense-in-depth.
   const xumHome = getXumHome();
   const earlyLockfile = new ServerLockfile(xumHome);
   const existing = await earlyLockfile.read();
@@ -133,7 +133,10 @@ async function main(): Promise<void> {
   const serviceContainer = new ServiceContainer(stores);
   // Headless server has no interactive host-key dialog
   setOpenSSHHostKeyPolicyMode("headless-fallback");
-  await serviceContainer.initialize();
+  // Core init (including agent-task recovery, which must finish before any client can act on
+  // tasks) gates the listener; the housekeeping that scales with the number of workspaces runs
+  // in the background once the server is accepting connections.
+  await serviceContainer.initializeCore();
   serviceContainer.windowService.setMainWindow(mockWindow);
 
   if (ADD_PROJECT_PATH) {
@@ -163,6 +166,14 @@ async function main(): Promise<void> {
     allowHttpOrigin: ALLOW_HTTP_ORIGIN,
   });
 
+  // Housekeeping is best-effort background work; a failure must not take the listening server
+  // down. serviceContainer.dispose() cancels it at its next task/step boundary and waits
+  // (bounded) for the step in flight, so shutdown during housekeeping never starts periodic
+  // services against disposed dependencies.
+  void serviceContainer.runStartupHousekeeping().catch((error: unknown) => {
+    log.error("[startup] Background startup housekeeping failed", { error });
+  });
+
   // Server is now listening - clear the startup keepalive since httpServer keeps the loop alive
   clearInterval(startupKeepalive);
 

src/constants/startup.ts

@@ -0,0 +1,7 @@
+/**
+ * Startup passes that take longer than this are logged at warn level so slow deployments
+ * (thousands of workspaces, large session dirs) surface in logs without enabling debug output.
+ * Chosen well above a healthy cold start (seconds) but below the point where a health check
+ * would already have flagged the process.
+ */
+export const SLOW_STARTUP_WARN_THRESHOLD_MS = 30_000;

src/constants/terminationTimeouts.ts

@@ -22,3 +22,11 @@ export const APP_RUNTIME_DISPOSE_TIMEOUT_MS = 2 * 1000;
  * bound this fits inside the same 5 s quit budgets.
  */
 export const APP_FIBER_SCOPE_CLOSE_TIMEOUT_MS = 2 * 1000;
+
+/**
+ * Bounds how long `ServiceContainer.dispose()` waits for in-flight background
+ * startup housekeeping (server mode) to reach its cancellation checkpoint before
+ * tearing down the services it uses. Sized to leave the two bounds above room
+ * inside the same 5 s quit budgets.
+ */
+export const STARTUP_HOUSEKEEPING_JOIN_TIMEOUT_MS = 500;

src/node/services/agentSession.continueMessageAgentId.test.ts

@@ -150,7 +150,7 @@ describe("AgentSession continue-message agentId fallback", () => {
     historyCleanup = undefined;
   });
 
-  const createSession = async (messages: MuxMessage[] = []) => {
+  const createSession = async (messages: MuxMessage[] = [], config = createConfig()) => {
     const { historyService, cleanup } = await createTestHistoryService();
     historyCleanup = cleanup;
     for (const message of messages) {
@@ -159,7 +159,7 @@ describe("AgentSession continue-message agentId fallback", () => {
 
     const session = new AgentSession({
       workspaceId: "ws",
-      config: createConfig(),
+      config,
       historyService,
       aiService: createAiService(),
       initStateManager: createInitStateManager(),
@@ -289,6 +289,44 @@ describe("AgentSession continue-message agentId fallback", () => {
     expect(dispatchedOptions?.strictAgentResolution).toBe(true);
   });
 
+  test("dispatchPendingFollowUp leaves the follow-up pending when the workspace is archived on disk", async () => {
+    const archivedConfig = {
+      ...createConfig(),
+      loadConfigOrDefault: () => ({
+        projects: new Map([
+          [
+            "/tmp",
+            {
+              workspaces: [{ id: "ws", path: "/tmp/ws", archivedAt: "2026-01-01T00:00:00.000Z" }],
+            },
+          ],
+        ]),
+      }),
+    } as unknown as Config;
+    const { historyService, internals } = await createSession(
+      [
+        compactionSummaryMessage("summary-archived", {
+          text: "resume after compaction",
+          model: "openai:gpt-4o",
+          agentId: "exec",
+        }),
+      ],
+      archivedConfig
+    );
+    internals.sendMessage = mock(() => Promise.resolve({ success: true as const }));
+
+    const dispatched = await internals.dispatchPendingFollowUp();
+
+    expect(dispatched).toBe(false);
+    expect(internals.sendMessage).not.toHaveBeenCalled();
+    // Still pending for the next startup after an unarchive.
+    const lastMessages = await historyService.getLastMessages("ws", 1);
+    expect(lastMessages.success && lastMessages.data[0]?.metadata?.muxMetadata).toMatchObject({
+      type: "compaction-summary",
+      pendingFollowUp: { text: "resume after compaction" },
+    });
+  });
+
   test("dispatchPendingFollowUp skips idle-only follow-ups when queued user input exists", async () => {
     const { session, historyService, internals } = await createSession([
       compactionSummaryMessage("summary-idle-only", idleFollowUp()),

src/node/services/agentSession.startupAutoRetry.test.ts

@@ -50,7 +50,10 @@ interface SessionBundle {
   cleanup: () => Promise<void>;
 }
 
-async function createSessionBundle(workspaceId: string): Promise<SessionBundle> {
+async function createSessionBundle(
+  workspaceId: string,
+  aiServiceOverrides?: Partial<AgentSessionAIService>
+): Promise<SessionBundle> {
   const workspaceMetadata: WorkspaceMetadata = {
     id: workspaceId,
     name: workspaceId,
@@ -69,6 +72,7 @@ async function createSessionBundle(workspaceId: string): Promise<SessionBundle>
     workspaceId,
     aiServiceOverrides: {
       getWorkspaceMetadata: mock(() => Promise.resolve(Ok(workspaceMetadata))),
+      ...aiServiceOverrides,
     },
     initStateManagerOverrides: {
       replayInit: mock(() => Promise.resolve()),
@@ -141,6 +145,161 @@ describe("AgentSession startup auto-retry recovery", () => {
     session.dispose();
   });
 
+  test("startup auto-retry does not dispatch once the workspace is archived on disk", async () => {
+    const workspaceId = "startup-retry-archived";
+    const { session, config, historyService, events, cleanup } =
+      await createSessionBundle(workspaceId);
+    cleanups.push(cleanup);
+
+    const appendResult = await historyService.appendToHistory(
+      workspaceId,
+      createMuxMessage("user-1", "user", "Interrupted before the archive", {
+        timestamp: Date.now(),
+      })
+    );
+    expect(appendResult.success).toBe(true);
+
+    // The archive lands while the check is still reading history (a regular session the client
+    // created is not disposed by archive, so only the durable state can stop the dispatch).
+    const getLastMessages = historyService.getLastMessages.bind(historyService);
+    spyOn(historyService, "getLastMessages").mockImplementation(async (id, count) => {
+      const result = await getLastMessages(id, count);
+      await config.editConfig((cfg) => {
+        cfg.projects.set("/tmp/project", {
+          workspaces: [
+            {
+              id: workspaceId,
+              path: `/tmp/project/${workspaceId}`,
+              name: workspaceId,
+              archivedAt: new Date().toISOString(),
+            },
+          ],
+        });
+        return cfg;
+      });
+      return result;
+    });
+
+    const privateSession = session as unknown as {
+      startupAutoRetryCheckPromise: Promise<void> | null;
+      startupAutoRetryCheckScheduled: boolean;
+    };
+    session.ensureStartupAutoRetryCheck();
+    await privateSession.startupAutoRetryCheckPromise;
+
+    expect(events.some((event) => event.type === "auto-retry-scheduled")).toBe(false);
+    // Completed rather than deferred: nothing reruns the check for an archived workspace.
+    expect(privateSession.startupAutoRetryCheckScheduled).toBe(true);
+
+    session.dispose();
+  });
+
+  test("auto-retry abandons instead of resuming once the workspace is archived on disk", async () => {
+    const workspaceId = "startup-retry-archived-before-timer";
+    const { session, config, events, cleanup } = await createSessionBundle(workspaceId);
+    cleanups.push(cleanup);
+
+    const privateSession = session as unknown as RetryableSessionForTests;
+    privateSession.lastAutoRetryResumeRequest = {
+      options: { model: "anthropic:claude-sonnet-4-5", agentId: "exec" },
+    };
+    const resumeStreamMock = mock((_options: SendMessageOptions) =>
+      Promise.resolve({ success: true as const, data: { started: true } })
+    );
+    privateSession.resumeStream = resumeStreamMock;
+
+    // The archive lands during the backoff countdown; only the durable state can stop the timer.
+    await config.editConfig((cfg) => {
+      cfg.projects.set("/tmp/project", {
+        workspaces: [
+          {
+            id: workspaceId,
+            path: `/tmp/project/${workspaceId}`,
+            name: workspaceId,
+            archivedAt: new Date().toISOString(),
+          },
+        ],
+      });
+      return cfg;
+    });
+
+    await privateSession.retryActiveStream();
+
+    expect(resumeStreamMock).not.toHaveBeenCalled();
+    const abandonedReasons = events
+      .filter(
+        (event): event is Extract<WorkspaceChatMessage, { type: "auto-retry-abandoned" }> =>
+          event.type === "auto-retry-abandoned"
+      )
+      .map((event) => event.reason);
+    expect(abandonedReasons).toEqual(["workspace_archived"]);
+
+    session.dispose();
+  });
+
+  test("beginShutdown cancels the pending retry and stops re-arming or streaming", async () => {
+    const workspaceId = "startup-retry-shutdown";
+    const streamMessage = mock(() => Promise.resolve(Ok(createStartedTurnHandle("assistant-1"))));
+    const { session, historyService, events, cleanup } = await createSessionBundle(workspaceId, {
+      streamMessage: streamMessage as unknown as AgentSessionAIService["streamMessage"],
+    });
+    cleanups.push(cleanup);
+
+    const privateSession = session as unknown as {
+      handleStreamFailureForAutoRetry: (error: { type: string; message?: string }) => Promise<void>;
+    };
+    await privateSession.handleStreamFailureForAutoRetry({ type: "unknown", message: "boom" });
+    expect(session.shouldRetainAfterStartupRecovery()).toBe(true);
+    const scheduledBefore = events.filter((event) => event.type === "auto-retry-scheduled").length;
+    expect(scheduledBefore).toBe(1);
+
+    session.beginShutdown();
+
+    expect(session.shouldRetainAfterStartupRecovery()).toBe(false);
+    await privateSession.handleStreamFailureForAutoRetry({ type: "unknown", message: "boom" });
+    expect(events.filter((event) => event.type === "auto-retry-scheduled").length).toBe(
+      scheduledBefore
+    );
+    // Not disposed, but sends are refused before any row lands: a follow-up row persisted here
+    // would read as a dispatched turn on the next startup while its stream never ran.
+    const sendResult = await session.sendMessage("hello", {
+      model: "anthropic:claude-sonnet-4-5",
+      agentId: "exec",
+    });
+    expect(sendResult.success).toBe(false);
+    expect(streamMessage).not.toHaveBeenCalled();
+    const history = await historyService.getHistoryFromLatestBoundary(workspaceId);
+    expect(history.success ? history.data : ["unexpected"]).toHaveLength(0);
+
+    session.dispose();
+  });
+
+  test("beginShutdown during pre-stream awaits stops the stream before the provider", async () => {
+    const workspaceId = "startup-retry-shutdown-mid-prepare";
+    const streamMessage = mock(() => Promise.resolve(Ok(createStartedTurnHandle("assistant-1"))));
+    const { session, historyService, cleanup } = await createSessionBundle(workspaceId, {
+      streamMessage: streamMessage as unknown as AgentSessionAIService["streamMessage"],
+    });
+    cleanups.push(cleanup);
+
+    // Shutdown lands while the stream start is already past its entry check, awaiting disk I/O.
+    const commitPartial = historyService.commitPartial.bind(historyService);
+    spyOn(historyService, "commitPartial").mockImplementation(async (id) => {
+      const result = await commitPartial(id);
+      session.beginShutdown();
+      return result;
+    });
+
+    const sendResult = await session.sendMessage("hello", {
+      model: "anthropic:claude-sonnet-4-5",
+      agentId: "exec",
+    });
+    expect(sendResult.success).toBe(true);
+    expect(streamMessage).not.toHaveBeenCalled();
+
+    session.dispose();
+  });
+
   test("visible completed subagent report cards do not schedule startup auto-retry", async () => {
     const workspaceId = "startup-retry-subagent-report-card";
     const { session, historyService, events, cleanup } = await createSessionBundle(workspaceId);