fix: harden owned child cleanup identities

Author: thymikee

src/platform-runtime-screen-recording-apple-simulator-host.test.ts

@@ -155,6 +155,25 @@ test('post-publication abort does not kill the adopted process', async () => {
   await expect(process.wait).resolves.toMatchObject({ exitCode: 0 });
 });
 
+test('publishes the post-exec simulator identity after readiness', async () => {
+  const root = mkdtempForTestSync('agent-device-recording-post-exec-');
+  const outputPath = path.join(root, 'capture.mp4');
+  const running = background(47, `xcrun simctl io ${simulator.id} recordVideo ${outputPath}`);
+  const postExecCommand = `/Library/Developer/PrivateFrameworks/CoreSimulator.framework/Versions/A/Resources/bin/simctl io ${simulator.id} recordVideo ${outputPath}`;
+  setTimeout(() => {
+    processes.commands.set(47, postExecCommand);
+    fs.writeFileSync(outputPath, 'recording');
+  }, 25);
+
+  const process = await withTransport(
+    running.process,
+    async () => await startAppleSimulatorRecording(simulator, outputPath),
+  );
+
+  expect(process.markers?.[0]).toMatchObject({ pid: 47, command: postExecCommand });
+  await expect(process.terminate()).resolves.toBeUndefined();
+});
+
 test('stops a locally launched simulator recorder after xcrun execs the simctl binary', async () => {
   const root = mkdtempForTestSync('agent-device-recording-xcrun-exec-');
   const outputPath = path.join(root, 'capture.mp4');

src/platform-runtime-screen-recording-apple-simulator-host.ts

@@ -74,7 +74,12 @@ export async function startAppleSimulatorRecording(
   }
   try {
     await waitForReadiness(outputPath, background.wait, signal);
-    const markers = await resolveManagedProcessTree(rootMarker);
+    // `runCmdBackground('xcrun', ...)` may briefly expose its shell wrapper before that
+    // process execs CoreSimulator's `simctl`. Read the root identity again after the output
+    // proves the recorder is ready so the durable descriptor and generic startup reaper share
+    // the stable post-exec identity already used by the live Apple matcher.
+    const postExecRootMarker = (await resolveManagedProcessIdentity(rootMarker.pid)) ?? rootMarker;
+    const markers = await resolveManagedProcessTree(postExecRootMarker);
     return createAppleSimulatorProcess(background, markers);
   } catch (error) {
     await terminateManagedProcessSet(

src/platforms/web/agent-browser-provider.test.ts

@@ -168,6 +168,35 @@ test('agent-browser close failure does not clear the daemon-owned record', async
   expect(ownedProcessRecords.clear).not.toHaveBeenCalled();
 });
 
+test('agent-browser semantic close failure does not clear the daemon-owned record', async () => {
+  const ownedProcessRecords: OwnedProcessRecordStore = {
+    replace: vi.fn(),
+    clear: vi.fn(),
+    read: vi.fn(() => []),
+  };
+
+  await withManagedAgentBrowserProvider(
+    {
+      session: 'web-session',
+      openWebSessionNames: () => ['web-session'],
+      ownedProcessRecords,
+    },
+    async (provider) => {
+      await withCommandExecutorOverride(
+        async () =>
+          jsonResult({
+            success: false,
+            code: 'CLOSE_FAILED',
+            error: 'browser stayed open',
+          }),
+        async () => await assert.rejects(async () => await provider.close()),
+      );
+    },
+  );
+
+  expect(ownedProcessRecords.clear).not.toHaveBeenCalled();
+});
+
 test('agent-browser provider ignores provider-startup cleanup failures', async () => {
   const calls: AgentBrowserCall[] = [];
   mockProviderStartupCleanup.mockRejectedValue(new Error('ps failed'));

src/platforms/web/agent-browser-provider.ts

@@ -28,8 +28,8 @@ import {
 import type { OwnedProcessRecordStore } from '../../utils/owned-process-record.ts';
 
 const AGENT_BROWSER = 'agent-browser';
-// Exported so WEB_BROWSER_SESSION_TEARDOWN_BUDGET_MS (daemon/server/daemon-runtime.ts) can be
-// pinned to it instead of drifting out of sync with a copied number.
+// Exported so daemon shutdown can pin its web-close budget to the ceiling enforced for one
+// `agent-browser` CLI call instead of copying a number that can drift.
 export const AGENT_BROWSER_TIMEOUT_MS = 30_000;
 const AGENT_BROWSER_DOCTOR_HINT =
   'Run `agent-device web setup` to install the managed web backend.';
@@ -238,24 +238,28 @@ async function runAgentBrowserJson(
 ): Promise<unknown> {
   const { session, options, signal } = params;
   const cliArgs = [...args, '--json', ...(session ? ['--session', session] : [])];
-  const result = await runAgentBrowserCommand(cliArgs, options, signal);
-  const parsed = parseAgentBrowserJson(result.stdout, result.stderr, cliArgs, result.exitCode);
-  return unwrapAgentBrowserJson(parsed, result, cliArgs);
+  return await runAgentBrowserCommand(
+    cliArgs,
+    options,
+    (result) => {
+      const parsed = parseAgentBrowserJson(result.stdout, result.stderr, cliArgs, result.exitCode);
+      return unwrapAgentBrowserJson(parsed, result, cliArgs);
+    },
+    signal,
+  );
 }
 
 async function runAgentBrowserCommand(
   cliArgs: string[],
   options: AgentBrowserProviderOptions,
+  interpret: (result: { stdout: string; stderr: string; exitCode: number }) => unknown,
   signal?: AbortSignal,
-): Promise<{
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}> {
+): Promise<unknown> {
   let stdout = '';
   let stderr = '';
   let exitCode = 0;
   let commandCompleted = false;
+  let semanticSuccess = false;
   const status = getManagedAgentBrowserStatus({ stateDir: options.stateDir });
   try {
     await cleanupProviderStartupOrphans(options);
@@ -271,24 +275,39 @@ async function runAgentBrowserCommand(
     exitCode = result.exitCode;
     commandCompleted = true;
   } catch (error) {
+    await finalizeAgentBrowserProcessRecord({
+      cliArgs,
+      commandCompleted,
+      exitCode,
+      semanticSuccess,
+      options,
+      status,
+    });
     throw mapAgentBrowserRunError(error, cliArgs);
+  }
+
+  try {
+    const result = { stdout, stderr, exitCode };
+    const output = interpret(result);
+    semanticSuccess = true;
+    return output;
   } finally {
     await finalizeAgentBrowserProcessRecord({
       cliArgs,
       commandCompleted,
       exitCode,
+      semanticSuccess,
       options,
       status,
     });
   }
-
-  return { stdout, stderr, exitCode };
 }
 
 async function finalizeAgentBrowserProcessRecord(params: {
   cliArgs: string[];
   commandCompleted: boolean;
   exitCode: number;
+  semanticSuccess: boolean;
   options: AgentBrowserProviderOptions;
   status: ReturnType<typeof getManagedAgentBrowserStatus>;
 }): Promise<void> {
@@ -315,12 +334,13 @@ async function finalizeAgentBrowserProcessRecord(params: {
 function canClearAgentBrowserRecord(
   params: Pick<
     Parameters<typeof finalizeAgentBrowserProcessRecord>[0],
-    'cliArgs' | 'commandCompleted' | 'exitCode'
+    'cliArgs' | 'commandCompleted' | 'exitCode' | 'semanticSuccess'
   >,
   otherOpenSessionCount: number,
 ): boolean {
   return (
     params.commandCompleted &&
+    params.semanticSuccess &&
     params.cliArgs[0] === 'close' &&
     params.exitCode === 0 &&
     otherOpenSessionCount === 0