@@ -1,6 +1,6 @@
+import { expect, test, vi } from 'vitest';
 import fs from 'node:fs';
 import path from 'node:path';
-import { expect, test } from 'vitest';
 import { mkdtempForTestSync } from '@agent-device/test-kit';
 import { screenRecordingResourceStore } from '@agent-device/capture-kit/screen-recording-resource-store';
 import {
@@ -9,6 +9,65 @@ import {
   recordingResourcePath,
 } from './record-runtime.fixtures.ts';
 
+// The stop lane that runs WITHOUT a held session resolves its device through the selection
+// dispatch. The daemon-restart tests below pin that lane, so the dispatch answers with the
+// harness device here; the live-handle tests never reach it because their session is held.
+const RESTART_SELECTED_DEVICE = {
+  platform: 'android',
+  id: 'emulator-5554',
+  name: 'Pixel',
+  kind: 'emulator',
+} as const;
+vi.mock('@agent-device/device-selection/dispatch-resolve', () => ({
+  resolveTargetDevice: vi.fn(async () => ({ ...RESTART_SELECTED_DEVICE })),
+}));
+
+test('record stop after a daemon restart replays the completed export for the named session', async () => {
+  // The #3674 state itself: sessions are memory-only, so a restart drops `recording`, while the
+  // on-disk manifest survives. The caller still names the session (the only address that finds
+  // the manifest at all), and `help record` promises the completed recording on that stop.
+  const harness = makeRecordRuntimeHarness('record-runtime-restart-stop-');
+  const outPath = path.join(
+    mkdtempForTestSync('record-runtime-restart-stop-output-'),
+    'capture.mp4',
+  );
+  fs.writeFileSync(outPath, 'mp4');
+  await harness.run(['start', outPath]);
+  await harness.run(['stop']);
+  const ref = harness.sessionStore.lookup(harness.sessionName);
+  if (!ref) throw new Error('Expected the stopped recording session');
+  harness.sessionStore.retire(ref);
+
+  const recovered = await harness.run(['stop'], { sessionExplicit: true });
+
+  expect(recovered).toMatchObject({
+    ok: true,
+    data: { recording: 'stopped', outPath, recordingBackend: 'adb screenrecord' },
+  });
+});
+
+test('record start after a daemon restart still refuses the named missing session', async () => {
+  // The sibling direction of the restart pair: start has no manifest to recover, so the
+  // named-session refusal keeps its priority for it.
+  const harness = makeRecordRuntimeHarness('record-runtime-restart-start-');
+  const outPath = path.join(
+    mkdtempForTestSync('record-runtime-restart-start-output-'),
+    'capture.mp4',
+  );
+  await harness.run(['start', outPath]);
+  const ref = harness.sessionStore.lookup(harness.sessionName);
+  if (!ref) throw new Error('Expected the live recording session');
+  harness.sessionStore.retire(ref);
+
+  const response = await harness.run(['start', outPath], { sessionExplicit: true });
+
+  expect(response).toMatchObject({
+    ok: false,
+    error: { code: 'SESSION_NOT_FOUND', details: { reason: 'named_session_not_found' } },
+  });
+  expect(harness.runtime.start).toHaveBeenCalledOnce();
+});
+
 test('record stop with a live handle binds no runtime and terminalizes the durable record', async () => {
   const harness = makeRecordRuntimeHarness('record-runtime-live-stop-');
   const outPath = path.join(mkdtempForTestSync('record-runtime-live-stop-output-'), 'capture.mp4');
 
@@ -99,9 +99,14 @@ async function handleRecordCommandUnsafe(
   const { req, sessionName, sessionStore } = params;
   const existingRef = sessionStore.lookup(sessionName);
   const existingSession = existingRef?.session;
-  // Ordered before every record-specific refusal: a named missing session answers on the
-  // session. Only that branch pays the function-scoped import (ADR-0019 loading shape).
-  if (!existingSession) {
+  const { plan, scope } = resolveRecordPlan(req, existingSession);
+  // Only the start half can be answered on a device, so only it answers on the session: a named
+  // missing session refuses before any device is chosen, ahead of the record-specific refusals.
+  // The stop half must reach the durable manifest first — after a daemon restart the memory-only
+  // session is gone for exactly the callers whose manifest the named session addresses, and the
+  // recovery lane proves the manifest's session and device before serving anything.
+  // Only that branch pays the function-scoped import (ADR-0019 loading shape).
+  if (!existingSession && plan.kind === 'start') {
     const { requireNamedSessionHoldsDevice } =
       await import('../../core/explicit-session-resolution.ts');
     requireNamedSessionHoldsDevice({
@@ -110,7 +115,6 @@ async function handleRecordCommandUnsafe(
       session: existingSession,
     });
   }
-  const { plan, scope } = resolveRecordPlan(req, existingSession);
   if (plan.kind === 'start' && !isWholeScreenRecordingScope(scope) && !existingSession) {
     return missingAppSessionResponse(req);
   }
 
@@ -485,7 +485,7 @@ Read-only commands such as `get`, `snapshot`, and `wait` report `no`, and so do
 These refusals carry `dispatched: no` and a typed `error.details.reason`, so branch on the reason, not the message:
 
 - `session_or_device_selector_required`: the request had neither an active session nor a device selector. Open a session or pass `--platform`. Commands that require a session or a device selector before they read the request's target (`boot`, `clipboard`, `push`, `apps`, and siblings) answer this even when the request named a session the daemon does not hold.
-- `named_session_not_found`: the request named a session this daemon does not hold, with no device selector to fall back on (or no selector it can answer without the session — `appstate` on an Apple target refuses this even with an explicit device). The daemon lost its sessions (replaced or restarted), or the name is wrong; `agent-device session list` shows what it holds.
+- `named_session_not_found`: the request named a session this daemon does not hold, with no device selector to fall back on (or no selector it can answer without the session — `appstate` on an Apple target refuses this even with an explicit device). The daemon lost its sessions (replaced or restarted), or the name is wrong; `agent-device session list` shows what it holds. Commands that require a session before they read anything else (interactions, `find` clicks, RN tooling) answer the same event as `SESSION_NOT_FOUND` with no reason; treat a reasonless `SESSION_NOT_FOUND` on a named session as this one.
 - `session_app_required`: a per-app setting was requested but the session binds no app and none was named. Run `open <app>`, or name the app on the request for a setting that takes one (`settings clear-app-state com.example.app`).
 - `app_not_installed`: the named app resolves to no installed app on the target. Run `apps --all` for the exact bundle id or package, or install the app, then retry.
 - `webdriver_route_unsupported`: on a WebDriver-backed device cloud, the driver does not implement the route; the limit is the cloud's driver, not the device. A command with a second route (`orientation` has two) tries it before failing. After an ambiguous failure on that transport, only read-only requests are resent.