fix: resolve recording teardown session keys

Author: thymikee

src/daemon/handlers/__tests__/session-close-shutdown.test.ts

@@ -543,6 +543,33 @@ test('close finalizes an active iOS simulator recording before deleting the sess
   );
 });
 
+test('close resolves a recording resource through the effective session key', async () => {
+  const sessionStore = makeSessionStore();
+  const effectiveSessionName = 'cwd:0123456789abcdef:default';
+  const session = makeIosSimulatorRecordingSession(sessionStore, effectiveSessionName);
+  session.name = 'default';
+  const finish = recordingFinishMock(session);
+  sessionStore.set(effectiveSessionName, session);
+
+  const response = await handleSessionCommands({
+    req: {
+      token: 't',
+      session: 'default',
+      command: 'close',
+      positionals: [],
+      flags: {},
+    },
+    sessionName: effectiveSessionName,
+    logPath: path.join(os.tmpdir(), 'daemon.log'),
+    sessionStore,
+    invoke: noopInvoke,
+  });
+
+  expect(response?.ok).toBe(true);
+  expect(finish).toHaveBeenCalledOnce();
+  expect(sessionStore.get(effectiveSessionName)).toBeUndefined();
+});
+
 test('close surfaces a recording finalization failure through the cleanup-failure channel', async () => {
   const sessionStore = makeSessionStore();
   const sessionName = 'ios-recording-close-failure-session';

src/daemon/handlers/session-close.ts

@@ -107,7 +107,7 @@ async function runSessionCloseTeardown(params: {
     }
   };
   const retainAppleRunner = shouldRetainAppleRunnerAfterClose(req, session);
-  await stopBestEffortSessionResources(session, sessionStore, attemptCleanup);
+  await stopBestEffortSessionResources(session, sessionName, sessionStore, attemptCleanup);
   const platformCloseError = repairArmed
     ? undefined
     : await dispatchTargetedPlatformClose({ req, session, logPath });
@@ -126,21 +126,22 @@ type CleanupRunner = (step: string, run: () => Promise<void>) => Promise<void>;
 
 async function stopBestEffortSessionResources(
   session: SessionState,
+  sessionName: string,
   sessionStore: SessionStore,
   attemptCleanup: CleanupRunner,
 ): Promise<void> {
   // Recording overlay finalization needs the Apple runner.
-  const currentSession = sessionStore.get(session.name) ?? session;
+  const currentSession = sessionStore.get(sessionName) ?? session;
   if (currentSession.screenRecording) {
     await attemptCleanup('recording', () =>
       finishSessionScreenRecording({
         session: currentSession,
-        sessionName: session.name,
+        sessionName,
         sessionStore,
       }),
     );
   }
-  await attemptCleanup('app_log', () => stopSessionAppLog({ session, sessionStore }));
+  await attemptCleanup('app_log', () => stopSessionAppLog({ session, sessionName, sessionStore }));
   await attemptCleanup('audio_probe', async () => {
     await stopSessionAudioProbe(session, 'session-close');
   });

src/daemon/server/daemon-runtime-recording-teardown.test.ts

@@ -127,3 +127,38 @@ test('daemon shutdown awaits durable recording finalization inside its extended
   expect(stderrChunks.join('')).not.toMatch(/timed out/);
   expect(sessionStore.get(session.name)).toBeUndefined();
 });
+
+test('daemon shutdown resolves durable recording resources through the effective session key', async () => {
+  const root = mkdtempForTestSync('agent-device-shutdown-effective-session-');
+  const sessionStore = new SessionStore(path.join(root, 'sessions'));
+  const effectiveSessionName = 'cwd:0123456789abcdef:default';
+  const session = makeRecordingSession({
+    name: effectiveSessionName,
+    sessionStore,
+    finish: async () => ({
+      status: 'completed' as const,
+      result: {
+        backend: 'simctl recordVideo',
+        outPath: path.join(root, 'recording.mp4'),
+        startedAt: 1,
+        completedAt: 2,
+        scope: 'app' as const,
+        showTouches: false,
+        recordOnlySession: false,
+      },
+    }),
+  });
+  session.name = 'default';
+  sessionStore.set(effectiveSessionName, session);
+  const stderrChunks: string[] = [];
+
+  await teardownDaemonSessionForShutdown({
+    session,
+    sessionStore,
+    stateDir: root,
+    stderr: { write: (chunk) => stderrChunks.push(chunk) },
+  });
+
+  expect(stderrChunks.join('')).not.toMatch(/resource record is missing/);
+  expect(sessionStore.get(effectiveSessionName)).toBeUndefined();
+});

src/daemon/server/daemon-runtime.ts

@@ -107,11 +107,16 @@ export async function teardownDaemonSessionForShutdown(params: {
   afterSuccessfulTeardown?: (session: SessionState) => Promise<void>;
 }): Promise<void> {
   const { session, sessionStore, stateDir, stderr, beforeDelete, afterSuccessfulTeardown } = params;
+  const sessionName = sessionStore.resolveStoredSessionName(session);
   const timeoutMs = resolveDaemonSessionTeardownTimeoutMs(session);
   // The ownership-fenced app-log side effect must settle while this process
   // still owns the daemon lock. It is intentionally outside the generic
   // teardown race so lock release and runtime shutdown cannot overtake it.
-  const appLogTeardownSucceeded = await stopSessionAppLog({ session, sessionStore }).then(
+  const appLogTeardownSucceeded = await stopSessionAppLog({
+    session,
+    sessionName,
+    sessionStore,
+  }).then(
     () => true,
     (error) => {
       stderr.write(
@@ -122,11 +127,11 @@ export async function teardownDaemonSessionForShutdown(params: {
       return false;
     },
   );
-  const sessionAfterAppLog = sessionStore.get(session.name) ?? session;
+  const sessionAfterAppLog = sessionStore.get(sessionName) ?? session;
   const teardown = teardownSessionResources({
     appLog: 'already-settled',
     session: sessionAfterAppLog,
-    sessionName: session.name,
+    sessionName,
     sessionStore,
     stateDir,
   }).then(
@@ -154,7 +159,7 @@ export async function teardownDaemonSessionForShutdown(params: {
   sessionStore.finalizeRepairTeardown(session);
   await beforeDelete?.(session);
   if (teardownSucceeded) await afterSuccessfulTeardown?.(session);
-  sessionStore.delete(session.name);
+  sessionStore.delete(sessionName);
 }
 
 export type DaemonRuntimeOptions = {

src/daemon/session-store.ts

@@ -309,7 +309,11 @@ export class SessionStore {
     return expandSessionPath(filePath, cwd);
   }
 
-  private resolveStoredSessionName(session: SessionState): string {
+  /**
+   * Resolve the map key for a live session object. SessionState.name is the
+   * public session name, while the map key may include cwd/tenant isolation.
+   */
+  resolveStoredSessionName(session: SessionState): string {
     for (const [name, value] of this.sessions) {
       if (value === session) return name;
     }

src/daemon/session-teardown.ts

@@ -43,15 +43,16 @@ export async function stopAppleRunnerForClose(session: SessionState): Promise<vo
 
 export async function stopSessionAppLog(params: {
   session: SessionState;
+  sessionName: string;
   sessionStore: SessionStore;
 }): Promise<void> {
-  const { session, sessionStore } = params;
+  const { session, sessionName, sessionStore } = params;
   if (!session.appLog) return;
   await forceCleanupSessionAppLog({
     session,
-    sessionName: session.name,
+    sessionName,
     sessionStore,
-    resourcePath: appLogResourceStore.resolvePath(sessionStore.resolveSessionDir(session.name)),
+    resourcePath: appLogResourceStore.resolvePath(sessionStore.resolveSessionDir(sessionName)),
   });
 }
 
@@ -170,7 +171,7 @@ export async function teardownSessionResources(
       ? [
           {
             step: 'app_log',
-            run: () => stopSessionAppLog({ session, sessionStore }),
+            run: () => stopSessionAppLog({ session, sessionName, sessionStore }),
           },
         ]
       : [];