@@ -107,7 +107,16 @@ enough for this boundary.
 On consumption, a script without `close` preserves the existing replay behavior: the named session stays
 active and the successful `ReplayCommandResult` returns its `session` id. The caller binds subsequent
 commands to that returned id. Replay reports success only after the destination guard completes; the
-absence of `close` changes neither action dispatch nor the success response shape.
+absence of `close` changes neither action dispatch nor when replay reports success.
+
+**Response shape (issue #1384).** `ReplayCommandResult` carries a required `sessionActive: boolean`,
+computed from whether `session` still exists in the daemon's own store when the response is built — never
+by re-parsing the script for `close`. This is what lets the real CLI/IPC client (not just the in-process
+handler) actually honor "the session stays active": without an explicit signal in the response, the
+client's one-shot `replay`/`test` teardown had no way to distinguish a still-active handoff from a
+finished one, and tore the owning daemon down regardless (`src/daemon/client/daemon-client-lifecycle.ts`).
+`sessionActive` is `true` for every close-less run (including a `--from` resume) and `false` once the
+script's terminal `close` — or a repair-armed run's deferred equivalent — has executed.
 
 ### Sensitive inputs
 
 
@@ -45,6 +45,61 @@ test('a successful replay prints one line with the step count and wall time', as
   expect(data.message).toMatch(/^Replayed 2 steps in \d+\.\ds$/);
 });
 
+// --- ADR 0016 / issue #1384: `sessionActive` is derived from the REAL
+// producer (`completeReplayRun`'s `sessionStore.get(sessionName)` check), not
+// asserted against a hand-crafted fixture — deleting that line would fail
+// these, unlike the client-lifecycle tests in
+// `src/utils/__tests__/daemon-client-lifecycle.test.ts`, which only prove the
+// CLIENT'S reaction to a `sessionActive` value it is handed. ---
+
+test('a close-less replay reports sessionActive: true (real producer, session still in the store)', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-session-active-'));
+  const sessionStore = new SessionStore(path.join(root, 'sessions'));
+  const sessionName = 'default';
+  sessionStore.set(sessionName, makeIosSession(sessionName));
+  const filePath = writeReplayFile(root, ['open "Demo"', 'click "Save"']);
+
+  const response = await runReplayScriptFile({
+    req: baseReq({ positionals: [filePath] }),
+    sessionName,
+    logPath: path.join(root, 'daemon.log'),
+    sessionStore,
+    invoke: async () => ({ ok: true, data: {} }),
+  });
+
+  expect(response.ok).toBe(true);
+  if (!response.ok) return;
+  expect(sessionStore.get(sessionName)).toBeDefined();
+  expect((response.data as { sessionActive: boolean }).sessionActive).toBe(true);
+});
+
+test('a replay whose terminal close removes the session reports sessionActive: false', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-session-closed-'));
+  const sessionStore = new SessionStore(path.join(root, 'sessions'));
+  const sessionName = 'default';
+  sessionStore.set(sessionName, makeIosSession(sessionName));
+  const filePath = writeReplayFile(root, ['open "Demo"', 'close']);
+
+  const response = await runReplayScriptFile({
+    req: baseReq({ positionals: [filePath] }),
+    sessionName,
+    logPath: path.join(root, 'daemon.log'),
+    sessionStore,
+    // Mirrors the one real effect of `handleCloseCommand` this test needs:
+    // removing the session from the store. Every other command is a no-op,
+    // same as the rest of this file's `invoke` stubs.
+    invoke: async (req) => {
+      if (req.command === 'close') sessionStore.delete(sessionName);
+      return { ok: true, data: {} };
+    },
+  });
+
+  expect(response.ok).toBe(true);
+  if (!response.ok) return;
+  expect(sessionStore.get(sessionName)).toBeUndefined();
+  expect((response.data as { sessionActive: boolean }).sessionActive).toBe(false);
+});
+
 test('Maestro YAML uses the typed engine while .ad remains generic', async () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-typed-maestro-route-'));
   const sessionStore = new SessionStore(path.join(root, 'sessions'));
@@ -94,6 +149,31 @@ test('Maestro YAML uses the typed engine while .ad remains generic', async () =>
   expect(commands).toEqual(['open']);
 });
 
+test('ADR 0016 / #1384: a Maestro replay reports sessionActive: true (real producer, no fake HTTP)', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-maestro-session-active-'));
+  const sessionStore = new SessionStore(path.join(root, 'sessions'));
+  const sessionName = 'default';
+  sessionStore.set(sessionName, makeIosSession(sessionName));
+  const yamlPath = path.join(root, 'flow.yaml');
+  fs.writeFileSync(yamlPath, 'appId: com.example.app\n---\n- launchApp\n');
+
+  const response = await runReplayScriptFile({
+    req: baseReq({
+      positionals: [yamlPath],
+      flags: { replayBackend: 'maestro', platform: 'ios' },
+    }),
+    sessionName,
+    logPath: path.join(root, 'daemon.log'),
+    sessionStore,
+    invoke: async () => ({ ok: true, data: {} }),
+  });
+
+  expect(response.ok).toBe(true);
+  if (!response.ok) return;
+  expect(sessionStore.get(sessionName)).toBeDefined();
+  expect((response.data as { sessionActive: boolean }).sessionActive).toBe(true);
+});
+
 test('typed Maestro nested commands receive the runtime hints bound into the plan', async () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-maestro-runtime-envelope-'));
   const sessionStore = new SessionStore(path.join(root, 'sessions'));
 
@@ -607,11 +607,14 @@ export const COMMAND_OUTPUT_SCHEMAS = {
       replayed: numberSchema(),
       healed: numberSchema(),
       session: stringSchema(),
+      sessionActive: booleanSchema(
+        'True iff the session is still active — the script had no terminal close.',
+      ),
       artifactPaths: stringArraySchema,
       snapshotDiagnostics: looseObjectSchema(),
       message: stringSchema(),
     },
-    ['replayed', 'healed', 'session', 'artifactPaths', 'message'],
+    ['replayed', 'healed', 'session', 'sessionActive', 'artifactPaths', 'message'],
   ),
   test: objectSchema(
     {
 
@@ -34,7 +34,15 @@ test('provider route publishes and replays an open-to-destination script with a
       await client.sessions.close();
 
       const replay = await world.daemon.callCommand('replay', [scriptPath], world.selection);
-      assert.equal(assertRpcOk<{ session?: string }>(replay).session, 'default');
+      const replayData = assertRpcOk<{ session?: string; sessionActive?: boolean }>(replay);
+      assert.equal(replayData.session, 'default');
+      // ADR 0016 / #1384: the published script has no terminal `close`, so the
+      // real (not test-fixture-injected) daemon response reports the session
+      // still active — this is the exact producer line the client-lifecycle
+      // tests in daemon-client-lifecycle.test.ts assume but cannot themselves
+      // exercise, since they inject sessionActive via a fake HTTP fixture.
+      assert.equal(replayData.sessionActive, true);
+      assert.ok(world.daemon.session(), 'a close-less replay must not tear down the session');
       const replaySnapshot = await client.capture.snapshot({ interactiveOnly: true });
       assert.ok(replaySnapshot.nodes.some((node) => node.label === 'Search'));
       await client.sessions.close();