fix(agent-core, kimi-code): handle stale closed sessions during resume

apps/kimi-code/src/tui/kimi-tui.ts

@@ -9,15 +9,17 @@ import {
   Spacer,
 } from '@earendil-works/pi-tui';
 import type { DeviceAuthorization } from '@moonshot-ai/kimi-code-oauth';
-import type {
-  ApprovalRequest,
-  ApprovalResponse,
-  BackgroundTaskInfo,
-  CreateSessionOptions,
-  KimiHarness,
-  PermissionMode,
-  PromptPart,
-  Session,
+import {
+  ErrorCodes,
+  isKimiError,
+  type ApprovalRequest,
+  type ApprovalResponse,
+  type BackgroundTaskInfo,
+  type CreateSessionOptions,
+  type KimiHarness,
+  type PermissionMode,
+  type PromptPart,
+  type Session,
 } from '@moonshot-ai/kimi-code-sdk';
 import type { MigrationPlan } from '@moonshot-ai/migration-legacy';
 import { resolve } from 'pathe';
@@ -1217,16 +1219,29 @@ export class KimiTUI {
   // setPermission is idempotent and needs no such guard.
   private async applyStartupModesToResumedSession(session: Session): Promise<void> {
     const { startup } = this.options;
-    if (startup.auto) {
-      await session.setPermission('auto');
-    } else if (startup.yolo) {
-      await session.setPermission('yolo');
-    }
-    if (startup.plan) {
-      const status = await session.getStatus();
-      if (!status.planMode) {
-        await session.setPlanMode(true);
+    try {
+      if (startup.auto) {
+        await session.setPermission('auto');
+      } else if (startup.yolo) {
+        await session.setPermission('yolo');
       }
+      if (startup.plan) {
+        const status = await session.getStatus();
+        if (!status.planMode) {
+          await session.setPlanMode(true);
+        }
+      }
+    } catch (error) {
+      if (isKimiError(error) && error.code === ErrorCodes.SESSION_NOT_FOUND) {
+        this.showError(
+          `Session disappeared during startup. ` +
+            `This usually means the session was closed while initialization was still running ` +
+            `(for example, an MCP server failed to start). ` +
+            `Try running the command again, or start a fresh session.`,
+        );
+        return;
+      }
+      throw error;
     }
   }
 

packages/agent-core/src/rpc/core-impl.ts

@@ -374,7 +374,14 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
       ...localWorkspaceDirs.additionalDirs,
       ...callerAdditionalDirs,
     ]);
-    const active = this.sessions.get(summary.id);
+    let active = this.sessions.get(summary.id);
+    if (active !== undefined && active.closed) {
+      // The session object is still in the map but has already been closed
+      // (e.g. by an earlier failed initialization or crash). Remove it so
+      // we can build a fresh session from persisted state.
+      this.sessions.delete(summary.id);
+      active = undefined;
+    }
     if (active !== undefined) {
       if (overrides.kaos !== undefined) {
         active.setToolKaos(overrides.kaos.withCwd(summary.workDir));
@@ -954,6 +961,15 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
         details: { sessionId },
       });
     }
+    if (session.closed) {
+      throw new KimiError(
+        ErrorCodes.SESSION_NOT_FOUND,
+        `Session "${sessionId}" has been closed. ` +
+          `This can happen when session initialization fails (for example, an MCP server could not start). ` +
+          `Try resuming the session again, or start a fresh session.`,
+        { details: { sessionId } },
+      );
+    }
     return session;
   }
 

packages/agent-core/src/session/index.ts

@@ -171,6 +171,11 @@ export class Session {
   };
   private writeMetadataPromise = Promise.resolve();
   private agentsMdWarning: string | undefined;
+  private isClosed = false;
+
+  get closed(): boolean {
+    return this.isClosed;
+  }
 
   constructor(public readonly options: SessionOptions) {
     // Attach the per-session log sink up front so the constructor's
@@ -316,6 +321,8 @@ export class Session {
   }
 
   async close(): Promise<void> {
+    if (this.isClosed) return;
+    this.isClosed = true;
     try {
       await Promise.allSettled(
         Array.from(this.readyAgents(), async (agent) => agent.cron?.stop()),
@@ -334,6 +341,8 @@ export class Session {
   }
 
   async closeForReload(): Promise<void> {
+    if (this.isClosed) return;
+    this.isClosed = true;
     try {
       await Promise.allSettled(
         Array.from(this.readyAgents(), async (agent) => agent.cron?.stop()),