fix: centralize scoped shutdown hints and touch probe liveness

Author: thymikee

src/daemon/interaction/internal/__tests__/interaction-touch-response.test.ts

@@ -161,9 +161,14 @@ test.each([false, true])('selector-touch observation after retirement=%s', async
   }
 });
 
-test.each([false, true])(
-  'point-touch publication after a held frame probe, retired=%s',
-  async (retired) => {
+test.each([
+  [false, false],
+  [false, true],
+  [true, false],
+  [true, true],
+])(
+  'point-touch publication after a held frame probe, retired=%s, fails=%s',
+  async (retired, fails) => {
     const sessionStore = makeSessionStore();
     const address = 'cwd:held-touch-response:default';
     const session = makeSession('default');
@@ -198,29 +203,38 @@ test.each([false, true])(
         },
       },
     };
-    const running = buildTargetedTouchResponsePayloads({
-      params: {
-        req: {
-          token: 't',
-          command: 'press',
-          positionals: ['10', '20'],
-          session: 'default',
-          flags: {},
-        },
-        sessionName: address,
-        sessionRef: ref,
-        sessionStore,
-        contextFromFlags,
-        captureSnapshotForSession: async () => {
-          startProbe();
-          await released;
-          return sessionStore.requireCurrent(ref).snapshot!;
-        },
+    const logPath = path.join(mkdtempForTestSync('held-point-'), 'request.log');
+    const running = withDiagnosticsScope(
+      { command: 'press', session: address, logPath, debug: true },
+      async () => {
+        const payloads = await buildTargetedTouchResponsePayloads({
+          params: {
+            req: {
+              token: 't',
+              command: 'press',
+              positionals: ['10', '20'],
+              session: 'default',
+              flags: {},
+            },
+            sessionName: address,
+            sessionRef: ref,
+            sessionStore,
+            contextFromFlags,
+            captureSnapshotForSession: async () => {
+              startProbe();
+              await released;
+              if (fails) throw new Error('frame capture failed');
+              return sessionStore.requireCurrent(ref).snapshot!;
+            },
+          },
+          result,
+          staleRefsWarning: undefined,
+          extra: {},
+        });
+        flushDiagnosticsToSessionFile({ force: true });
+        return payloads;
       },
-      result,
-      staleRefsWarning: undefined,
-      extra: {},
-    });
+    );
     await probing;
     let successor;
     if (retired) {
@@ -229,6 +243,8 @@ test.each([false, true])(
     }
     releaseProbe();
     const payloads = await running;
+    const diagnostics = fs.existsSync(logPath) ? fs.readFileSync(logPath, 'utf8') : '';
+    expect(diagnostics.includes('touch_reference_frame_resolve_failed')).toBe(!retired && fails);
     expect(payloads.responseData.x).toBe(10);
     if (retired) {
       expect(payloads.responseData.settle).toBeUndefined();

src/daemon/interaction/internal/interaction-touch-reference-frame.ts

@@ -18,7 +18,8 @@ async function resolveDirectTouchReferenceFrame(params: {
 }): Promise<GestureReferenceFrame | undefined> {
   const { ref, flags, sessionStore, contextFromFlags, captureSnapshotForSession, observation } =
     params;
-  const session = sessionStore.requireCurrent(ref);
+  const session = sessionStore.resolveCurrent(ref);
+  if (!session) return undefined;
   const recording = session.screenRecording?.handle;
   if (!recording) {
     return undefined;
@@ -68,13 +69,13 @@ export async function resolveDirectTouchReferenceFrameSafely(params: {
   try {
     return await resolveDirectTouchReferenceFrame(params);
   } catch (error) {
+    const current = params.sessionStore.resolveCurrent(params.ref);
+    if (!current) return undefined;
     emitDiagnostic({
       level: 'warn',
       phase: 'touch_reference_frame_resolve_failed',
       data: {
-        platform:
-          params.sessionStore.resolveCurrent(params.ref)?.device.platform ??
-          params.ref.session.device.platform,
+        platform: current.device.platform,
         error: error instanceof Error ? error.message : String(error),
       },
     });

src/daemon/interaction/internal/interaction-touch-response.ts

@@ -293,9 +293,8 @@ export async function buildTargetedTouchResponsePayloads(params: {
   extra: Record<string, unknown>;
 }): Promise<InteractionResponsePayloads> {
   const { params: handlerParams, result, publicData, extra } = params;
-  const liveBeforeProbe = handlerParams.sessionStore.resolveCurrent(handlerParams.sessionRef!);
   const probedFrame =
-    liveBeforeProbe && result.kind === 'point'
+    result.kind === 'point'
       ? await resolveDirectTouchReferenceFrameSafely({
           ref: handlerParams.sessionRef!,
           flags: handlerParams.req.flags,

src/daemon/server/daemon-runtime-lifecycle-shutdown.test.ts

@@ -46,7 +46,9 @@ vi.mock('../../provider-device-runtimes.ts', () => ({
   createDaemonProviderRuntimeComposition: async () => ({ runtimes: [], platformModules: [] }),
 }));
 
-import { startDaemonRuntime } from './daemon-runtime.ts';
+import { startDaemonRuntime, teardownDaemonSessionForShutdown } from './daemon-runtime.ts';
+import { makeIosSession } from '../../__tests__/test-utils/session-factories.ts';
+import { makeSessionStore } from '../../__tests__/test-utils/store-factory.ts';
 
 afterEach(() => {
   lifecycleEvents.length = 0;
@@ -108,3 +110,48 @@ test('a SIGTERM shutdown gives the handoff a diagnostics scope to write its reas
     fs.rmSync(stateDir, { recursive: true, force: true });
   }
 });
+
+test.each([false, true])(
+  'shutdown forwards only the addressed lifetime’s runtime hints, retired=%s',
+  async (retired) => {
+    const sessionStore = makeSessionStore('shutdown-scoped-hints-');
+    const address = 'cwd:shutdown-hints:default';
+    const ref = sessionStore.publish(address, makeIosSession('default'));
+    const publicRef = sessionStore.publish('default', makeIosSession('default'));
+    sessionStore.setRuntimeHints(address, { metroHost: 'scoped.example', metroPort: 8082 });
+    sessionStore.setRuntimeHints('default', { metroHost: 'public.example', metroPort: 8083 });
+    let successor;
+    if (retired) {
+      sessionStore.retire(ref);
+      successor = sessionStore.publish(address, makeIosSession('default'));
+      sessionStore.setRuntimeHints(address, { metroHost: 'successor.example', metroPort: 8084 });
+    }
+    const finalizeApplicationLifecycle = vi.fn(async () => {});
+
+    await teardownDaemonSessionForShutdown({
+      ref,
+      sessionStore,
+      stderr: { write: () => {} },
+      finalizeApplicationLifecycle,
+    });
+
+    expect(finalizeApplicationLifecycle).toHaveBeenCalledWith(
+      ref.session,
+      retired ? {} : { metroHost: 'scoped.example', metroPort: '8082' },
+    );
+    expect(sessionStore.resolveCurrent(publicRef)).toBe(publicRef.session);
+    expect(sessionStore.getRuntimeHints('default')).toEqual({
+      metroHost: 'public.example',
+      metroPort: 8083,
+    });
+    if (successor) {
+      expect(sessionStore.resolveCurrent(successor)).toBe(successor.session);
+      expect(sessionStore.getRuntimeHints(address)).toEqual({
+        metroHost: 'successor.example',
+        metroPort: 8084,
+      });
+    } else {
+      expect(sessionStore.lookup(address)).toBeUndefined();
+    }
+  },
+);

src/daemon/server/daemon-runtime.ts

@@ -36,6 +36,7 @@ import { runtimeHintValues } from '../session-runtime.ts';
 import { closeDaemonServers } from './server-shutdown.ts';
 import type { DaemonInvokeFn } from '../daemon-request.ts';
 import type { SessionRef, SessionState } from '../session-state.ts';
+import type { RuntimeHintValues } from '@agent-device/contracts/application-lifecycle-runtime';
 import { createDaemonIdleReap } from './daemon-idle-reap.ts';
 import { createSessionIdleExpiry } from './daemon-session-idle-expiry.ts';
 import { resolveSessionIdleExpiryMs } from '../session-idle-expiry.ts';
@@ -137,7 +138,10 @@ export async function teardownDaemonSessionForShutdown(params: {
   sessionStore: SessionStore;
   stateDir?: string;
   stderr: WritableOutput;
-  finalizeApplicationLifecycle?: (session: SessionState) => Promise<void>;
+  finalizeApplicationLifecycle?: (
+    session: SessionState,
+    runtimeHints: RuntimeHintValues,
+  ) => Promise<void>;
   beforeDelete?: (session: SessionState) => Promise<void>;
   afterSuccessfulTeardown?: (session: SessionState) => Promise<void>;
 }): Promise<void> {
@@ -150,7 +154,11 @@ export async function teardownDaemonSessionForShutdown(params: {
     beforeDelete,
     afterSuccessfulTeardown,
   } = params;
-  const session = sessionStore.resolveCurrent(ref) ?? ref.session;
+  const current = sessionStore.resolveCurrent(ref);
+  const session = current ?? ref.session;
+  const runtimeHints = runtimeHintValues(
+    current ? sessionStore.getRuntimeHints(ref.address) : undefined,
+  );
   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
@@ -182,7 +190,8 @@ export async function teardownDaemonSessionForShutdown(params: {
           session,
           stderr,
           resource: 'lifecycle',
-          teardown: async () => await finalizeApplicationLifecycle(sessionAfterAppLog),
+          teardown: async () =>
+            await finalizeApplicationLifecycle(sessionAfterAppLog, runtimeHints),
         })
       : true;
     return genericTeardownSucceeded && lifecycleTeardownSucceeded;
@@ -458,13 +467,12 @@ export async function startDaemonRuntime(
 
   const teardownDaemonSession = async (ref: SessionRef): Promise<void> => {
     const session = sessionStore.resolveCurrent(ref) ?? ref.session;
-    const runtimeHints = runtimeHintValues(sessionStore.getRuntimeHints(ref.address));
     try {
       await teardownDaemonSessionForShutdown({
         ref,
         sessionStore,
         stderr,
-        finalizeApplicationLifecycle: async (sessionToFinalize) =>
+        finalizeApplicationLifecycle: async (sessionToFinalize, runtimeHints) =>
           await finalizeDaemonSessionApplicationLifecycle({
             gateway: deviceRuntimeGateway,
             scope: createDaemonRecoveryPlatformScope(),