fix(cli): Recover sessions across archive races

packages/cli/src/serve/acp-http/dispatch.ts

@@ -1842,44 +1842,32 @@ export class AcpDispatcher {
             // of a caller id contends on one key), so the request spelling
             // alone covers the raw-spelled batch delete/archive/unarchive
             // locks (parity with the REST restore handler).
-            const guardSessionService = new SessionService(cwd, {
-              runtimeBaseDir: sessionRuntime.sessionRuntimeBaseDir,
-            });
-            let persistedGuardId: string | undefined;
-            try {
-              persistedGuardId =
-                await guardSessionService.findSessionIdIgnoringCase(sessionId);
-            } catch (error) {
-              if (
-                error instanceof SessionIdCaseConflictError &&
-                (await guardSessionService.getSessionLocation(
-                  error.candidateSessionId ?? sessionId,
-                )) === 'conflict'
-              ) {
-                throw new SessionConflictError(sessionId);
-              }
-              throw error;
-            }
             const restored = await this.archiveCoordinator.runSharedMany(
               [sessionId],
               async () => {
                 assertGenerationOpen?.();
                 const sessionService = new SessionService(cwd, {
                   runtimeBaseDir: sessionRuntime.sessionRuntimeBaseDir,
                 });
-                let storageSessionId = persistedGuardId ?? sessionId;
+                let storageSessionId = sessionId;
                 let persistedSessionId: string | undefined;
                 try {
                   persistedSessionId =
                     await sessionService.findSessionIdIgnoringCase(sessionId);
                 } catch (error) {
-                  if (
-                    error instanceof SessionIdCaseConflictError &&
-                    (await sessionService.getSessionLocation(
-                      error.candidateSessionId ?? sessionId,
-                    )) === 'conflict'
-                  ) {
-                    throw new SessionConflictError(sessionId);
+                  if (error instanceof SessionIdCaseConflictError) {
+                    let bothStates = false;
+                    try {
+                      bothStates =
+                        (await sessionService.getSessionLocation(
+                          error.candidateSessionId ?? sessionId,
+                        )) === 'conflict';
+                    } catch {
+                      // This recheck only refines the response; preserve the known
+                      // conflict when storage cannot classify it a second time.
+                      throw error;
+                    }
+                    if (bothStates) throw new SessionConflictError(sessionId);
                   }
                   throw error;
                 }

packages/cli/src/serve/acp-http/transport.test.ts

@@ -4609,7 +4609,7 @@ describe('ACP Streamable HTTP transport (over the wire)', () => {
     },
   );
 
-  it('session/load rejects active/archive conflicts', async () => {
+  it('session/load restores an active/archive conflicted session from its active copy', async () => {
     await withRuntimeDir(async () => {
       const sessionId = '550e8400-e29b-41d4-a716-446655440321';
       await writeStoredSession(sessionId);
@@ -4628,18 +4628,14 @@ describe('ACP Streamable HTTP transport (over the wire)', () => {
 
       const [frame] = (await got) as Array<{
         id: number;
-        error: {
-          code: number;
-          message: string;
-          data?: { errorKind?: string };
-        };
+        result?: unknown;
+        error?: { code: number; message: string };
       }>;
+      // Loads read the active copy (CLI resume parity): a session left in
+      // both states by a crashed archive stays loadable over ACP.
       expect(frame.id).toBe(212);
-      expect(frame.error.code).toBe(-32603);
-      expect(frame.error.message).toContain(
-        'Delete the session with POST /sessions/delete',
-      );
-      expect(frame.error.data?.errorKind).toBe('session_conflict');
+      expect(frame.error).toBeUndefined();
+      expect(frame.result).toEqual(expect.any(Object));
     });
   });
 
@@ -5058,7 +5054,7 @@ describe('ACP Streamable HTTP transport (over the wire)', () => {
   );
 
   it.each(['session/load', 'session/resume'] as const)(
-    '%s converts a pre-guard both-states conflict to actionable session conflict',
+    '%s restores a case twin persisted in both states from its active copy',
     async (method) => {
       await withRuntimeDir(async () => {
         const sessionId =
@@ -5078,14 +5074,11 @@ describe('ACP Streamable HTTP transport (over the wire)', () => {
           method,
           params: { sessionId },
         });
+        // Loads read the active copy regardless of which spelling resolves,
+        // so the verdict cannot flip with the filesystem's case sensitivity.
         expect(await reader.next()).toMatchObject({
           id: 231,
-          error: {
-            message: expect.stringContaining(
-              'Delete the session with POST /sessions/delete',
-            ),
-            data: expect.objectContaining({ errorKind: 'session_conflict' }),
-          },
+          result: expect.any(Object),
         });
         reader.close();
       });
@@ -5107,7 +5100,6 @@ describe('ACP Streamable HTTP transport (over the wire)', () => {
         );
         const findSessionId = vi
           .spyOn(SessionService.prototype, 'findSessionIdIgnoringCase')
-          .mockResolvedValueOnce(storageSessionId)
           .mockRejectedValue(conflict);
         const getSessionLocation = vi
           .spyOn(SessionService.prototype, 'getSessionLocation')
@@ -5146,6 +5138,58 @@ describe('ACP Streamable HTTP transport (over the wire)', () => {
     },
   );
 
+  it.each(['session/load', 'session/resume'] as const)(
+    '%s preserves an in-guard conflict when its classification recheck fails',
+    async (method) => {
+      await withRuntimeDir(async () => {
+        const sessionId =
+          method === 'session/load'
+            ? '550e8400-e29b-41d4-a716-44665544014d'
+            : '550e8400-e29b-41d4-a716-44665544014e';
+        const storageSessionId = sessionId.toUpperCase();
+        const conflict = new SessionIdCaseConflictError(
+          sessionId,
+          storageSessionId,
+        );
+        const findSessionId = vi
+          .spyOn(SessionService.prototype, 'findSessionIdIgnoringCase')
+          .mockRejectedValue(conflict);
+        const getSessionLocation = vi
+          .spyOn(SessionService.prototype, 'getSessionLocation')
+          .mockRejectedValue(
+            Object.assign(new Error('read failed'), { code: 'EIO' }),
+          );
+
+        try {
+          const connId = await initialize();
+          const stream = await openStream(connId);
+          const reader = frameReader(stream);
+          await post(connId, {
+            jsonrpc: '2.0',
+            id: 233,
+            method,
+            params: { sessionId },
+          });
+          expect(await reader.next()).toMatchObject({
+            id: 233,
+            error: {
+              message: conflict.message,
+              data: expect.objectContaining({
+                errorKind: 'session_conflict',
+                sessionId,
+              }),
+            },
+          });
+          reader.close();
+          expect(getSessionLocation).toHaveBeenCalledWith(storageSessionId);
+        } finally {
+          getSessionLocation.mockRestore();
+          findSessionId.mockRestore();
+        }
+      });
+    },
+  );
+
   it('keeps the bridge key canonical while isolating mixed-case storage', async () => {
     const sessionId = '550e8400-e29b-41d4-a716-446655440135';
     const storageSessionId = sessionId.toUpperCase();

packages/cli/src/serve/conversations/conversation-workspace.test.ts

@@ -27,6 +27,7 @@ import {
 import { ConversationDirectoryIdentityError } from '../../utils/conversation-directory-identity.js';
 
 const plantOnExpectedInspect = vi.hoisted(() => ({ armed: false }));
+const enoentOnInspect = vi.hoisted(() => ({ armed: false }));
 
 vi.mock(
   '../../utils/conversation-directory-identity.js',
@@ -40,6 +41,14 @@ vi.mock(
       inspectConversationDirectoryIdentity: async (
         ...args: Parameters<typeof actual.inspectConversationDirectoryIdentity>
       ) => {
+        if (enoentOnInspect.armed) {
+          enoentOnInspect.armed = false;
+          throw new actual.ConversationDirectoryIdentityError(
+            'root',
+            'io_error',
+            Object.assign(new Error('root vanished'), { code: 'ENOENT' }),
+          );
+        }
         const identity = await actual.inspectConversationDirectoryIdentity(
           ...args,
         );
@@ -272,6 +281,21 @@ describe('Live conversation workspace root', () => {
     expect((await lstat(occupied)).isDirectory()).toBe(true);
   });
 
+  it('treats a root that vanishes mid-inspection as already discarded', async () => {
+    const home = await tempHome();
+    const workspace = new ConversationWorkspace({ homeDir: home });
+    await workspace.materializeConversationDirectory('empty-racy');
+
+    enoentOnInspect.armed = true;
+    try {
+      await expect(
+        workspace.discardEmptyConversationDirectory('empty-racy'),
+      ).resolves.toBe(false);
+    } finally {
+      enoentOnInspect.armed = false;
+    }
+  });
+
   it('prepares only a new or reusable empty standalone child', async () => {
     const home = await tempHome();
     const workspace = new ConversationWorkspace({ homeDir: home });

packages/cli/src/serve/conversations/conversation-workspace.ts

@@ -204,6 +204,16 @@ export class ConversationWorkspace {
         this.directoryKey(sessionId),
       );
     } catch (error) {
+      // A root that vanished mid-inspection means there is nothing left to
+      // discard: keep the ENOENT-race → `false` contract instead of
+      // reporting an identity violation.
+      if (
+        error instanceof ConversationDirectoryIdentityError &&
+        error.reason === 'io_error' &&
+        (error.cause as NodeJS.ErrnoException | undefined)?.code === 'ENOENT'
+      ) {
+        return false;
+      }
       liveIdentityError(error);
     }
     if (!identity) return false;