test: guard the daemon-owned-process arm in CI on the live web lane

Re-review of ce9f0ee: moving that arm to a manual probe left the two failures
B1 exists to prevent detectable only by hand, and a fixture test proves regexes
recognize synthetic rows, not that the shipped route reaps what it spawned.

Restore the arm to the shipped oracle (the three files return byte-identical to
3a5b9be) and give it a lane that can execute it: smoke-web-platform is the one
CI route whose daemon owns real children — the managed agent-browser daemon and
its Chrome fleet. After the normal smoke it reopens a session, stops the daemon
with that session still open (the #1109 shape: an ordinary close reaps the fleet,
so only an unclosed session can strand it), and requires that nothing owned
outlives the browser idle window.

Proven both ways locally: green in 59s, and red when the fleet is stranded
(browser idle window raised past the settle budget) with the oracle naming 15
owned processes — the #1109 signature, in a lane that runs on every PR.

Also: daemon-replace-exit-flush cleared `info` before the oracle ran, so a failed
stop would skip the `finally` retry and remove the state dir while the daemon was
still alive. Clear it only once the checkpoint passes.

Refs #1781 #1431 #1882

Author: thymikee

.fallowrc.json

@@ -24,10 +24,6 @@
     // subprocess (test/integration/daemon-replace-exit-flush.test.ts), so
     // dependency analysis cannot follow the runCmdSync string path to it.
     "test/integration/support/exit-after-flush.ts",
-    // #1781 B1: the manual red-proof probe for daemon-owned child processes. It
-    // is run by hand (and produced the #1109/#1324 evidence), so nothing imports
-    // it; see its header for why that arm cannot assert from a device-free lane.
-    "test/integration/support/daemon-owned-process-probe.ts",
     "src/utils/update-check-entry.ts",
     "examples/sdk/client-session.ts",
     "examples/sdk/metro-runtime.ts",

test/integration/daemon-replace-exit-flush.test.ts

@@ -78,10 +78,13 @@ test('daemon replace mid-command returns a structured, parseable error and exits
       killTimeoutMs: 1_500,
       expectedStartTime: info.processStartTime,
     });
-    info = null;
     // #1781 B1: neither the SIGKILLed daemon nor its replacement may leave owned
-    // processes or unclassified state-dir residue once both are gone.
+    // processes or unclassified state-dir residue once both are gone. `info`
+    // stays set until this passes: `stopProcessForTakeover` is best-effort, so a
+    // failed stop must still reach the `finally` retry below rather than have
+    // the state dir removed out from under a daemon that is still running.
     await assertNoDaemonLeaks({ stateDir, daemonPids, phase: 'after-shutdown' });
+    info = null;
   } finally {
     if (info) {
       await stopProcessForTakeover(info.pid, {

test/integration/smoke-web-platform.test.ts

@@ -1,10 +1,12 @@
 import assert from 'node:assert/strict';
-import { mkdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { createServer, type Server } from 'node:http';
 import path from 'node:path';
 import test from 'node:test';
+import { stopProcessForTakeover } from '../../src/daemon/daemon-process.ts';
 import { type CliJsonResult, formatResultDebug, runBuiltCliJson } from './cli-json.ts';
 import { assertPngFile } from './provider-scenarios/assertions.ts';
+import { assertNoDaemonLeaks } from './support/daemon-leak-oracle.ts';
 
 const TEST_NAME = 'live web platform e2e smoke';
 const WEB_E2E_ENABLED = process.env.AGENT_DEVICE_WEB_E2E === '1';
@@ -25,10 +27,21 @@ type WebSmokeContext = {
   lastSnapshot?: any;
   screenshotPath: string;
   server: Server;
+  stateDir: string;
   stepHistory: StepRecord[];
   url: string;
 };
 
+// #1781 B1 / #1109: this is the one lane whose daemon owns real child processes
+// — the managed agent-browser daemon and its Chrome fleet — so it is where the
+// leak oracle's owned-process arm can actually fail. #1109's acceptance is that
+// a stopped daemon leaves zero agent-browser processes behind within the idle
+// window; the lane pins AGENT_BROWSER_IDLE_TIMEOUT_MS at 30s, so the settle
+// window here has to outlast it. Graceful daemon shutdown does not close web
+// sessions (#1868), so the fleet legitimately lives until that window elapses —
+// which is why the checkpoint waits it out rather than asserting immediately.
+const WEB_LEAK_SETTLE_MS = 90_000;
+
 test(
   TEST_NAME,
   {
@@ -82,6 +95,7 @@ async function createWebSmokeContext(): Promise<WebSmokeContext> {
     env,
     screenshotPath: path.join(artifactDir, 'web-smoke.png'),
     server: fixture.server,
+    stateDir,
     stepHistory: [],
     url: fixture.url,
   };
@@ -228,6 +242,11 @@ async function cleanupWebSmoke(context: WebSmokeContext, opened: boolean): Promi
       errors.push(error);
     }
   }
+  try {
+    await assertOrphanedWebSessionLeavesNothingOwned(context);
+  } catch (error) {
+    errors.push(error);
+  }
   try {
     await closeServer(context.server);
   } catch (error) {
@@ -241,6 +260,41 @@ async function cleanupWebSmoke(context: WebSmokeContext, opened: boolean): Promi
   }
 }
 
+// #1109's acceptance, as a lane assertion: a daemon that dies while a web
+// session is still open must leave zero agent-browser processes behind within
+// the idle window. That is the leak's real shape — an ordinary `close` reaps the
+// fleet, so only an unclosed session can strand it — and it is the one route in
+// CI where the oracle's owned-process arm has real children to find.
+async function assertOrphanedWebSessionLeavesNothingOwned(context: WebSmokeContext): Promise<void> {
+  await runStep(context, 'reopen for the orphan checkpoint', [
+    'open',
+    context.url,
+    ...context.common,
+  ]);
+  const infoPath = path.join(context.stateDir, 'daemon.json');
+  // Never skip silently: no daemon metadata after a live web session means the
+  // checkpoint would certify a daemon it never observed.
+  assert.ok(existsSync(infoPath), `expected daemon metadata at ${infoPath}`);
+  const info = JSON.parse(readFileSync(infoPath, 'utf8')) as {
+    pid: number;
+    processStartTime?: string;
+  };
+  assert.ok(Number.isInteger(info.pid) && info.pid > 0, `expected a daemon pid in ${infoPath}`);
+  // Stop the daemon with the session still open: the browser fleet is orphaned
+  // exactly as in #1109, and only its idle lifecycle can still reap it.
+  await stopProcessForTakeover(info.pid, {
+    termTimeoutMs: 5_000,
+    killTimeoutMs: 5_000,
+    expectedStartTime: info.processStartTime,
+  });
+  await assertNoDaemonLeaks({
+    stateDir: context.stateDir,
+    daemonPids: [info.pid],
+    phase: 'after-shutdown',
+    settleMs: WEB_LEAK_SETTLE_MS,
+  });
+}
+
 function recordStep(
   context: WebSmokeContext,
   step: string,

test/integration/support/daemon-leak-model.test.ts

@@ -6,12 +6,23 @@ import {
   type DaemonLeakObservation,
   type DaemonLeakObservationBase,
   type DaemonLeakPhaseSelection,
+  type HostProcess,
   type NonEmpty,
   type StateEntry,
 } from './daemon-leak-model.ts';
 
+// The lanes that call the oracle run device-free daemons, so the ownership rules
+// would otherwise only ever see an empty process set. These fixtures are the
+// real `ps` shapes captured during the #1109 and #1324 red-proofs (SHAs in the
+// #1781 B1 PR), so a regex or ordering edit that stops catching either leak
+// fails here instead of silently going quiet in CI.
 const STATE_DIR = '/tmp/agent-device-lane-abc';
 const DAEMON_PID = 4340;
+const OBSERVER_PID = 999;
+
+function proc(overrides: Partial<HostProcess> & Pick<HostProcess, 'pid'>): HostProcess {
+  return { ppid: 1, pgid: overrides.pid, command: 'unrelated', env: '', ...overrides };
+}
 
 // The phase and its identity arrive together: `after-close` cannot be requested
 // without naming the sessions that closed, so these helpers cannot construct the
@@ -24,6 +35,8 @@ function observe(
     stateDir: STATE_DIR,
     daemonPids: [DAEMON_PID],
     livePids: [],
+    processes: [],
+    excludedPids: [OBSERVER_PID],
     stateEntries: [],
     ...overrides,
     ...selection,
@@ -44,6 +57,72 @@ function file(entryPath: string, descriptorLifecycle?: string): StateEntry {
   return { path: entryPath, kind: 'file', ...(descriptorLifecycle ? { descriptorLifecycle } : {}) };
 }
 
+describe('owned-process rules', () => {
+  // #1324: `simctl io … recordVideo` reparents to launchd (ppid 1) but keeps the
+  // dead daemon's process group, and simctl only finalizes the mp4 on SIGINT.
+  test('flags a recorder orphaned into the dead daemon process group', () => {
+    const recorder = proc({
+      pid: 52420,
+      ppid: 1,
+      pgid: DAEMON_PID,
+      command: '/…/simctl io 416440AE recordVideo /tmp/out.mp4',
+    });
+    const snapshot = evaluateDaemonLeaks(observe({ processes: [recorder] }));
+
+    expect(snapshot.ownedProcesses).toEqual([
+      expect.objectContaining({ pid: 52420, reasons: ['process-group'] }),
+    ]);
+    expect(hasDaemonLeaks(snapshot)).toBe(true);
+  });
+
+  // #1109: the agent-browser daemon setsids away from the daemon's group, so
+  // only the inherited state-dir environment and its argv identify the fleet.
+  test('flags an agent-browser fleet by inherited state dir, including its children', () => {
+    const browserDaemon = proc({
+      pid: 47515,
+      ppid: 1,
+      pgid: 47515,
+      command: `${STATE_DIR}/tools/agent-browser/0.27.1/package/…/agent-browser-darwin-arm64`,
+      env: `HOME=/tmp AGENT_DEVICE_STATE_DIR=${STATE_DIR}`,
+    });
+    const chrome = proc({
+      pid: 47586,
+      ppid: 47515,
+      pgid: 47586,
+      command: 'Google Chrome for Testing',
+    });
+    const renderer = proc({
+      pid: 47953,
+      ppid: 47586,
+      pgid: 47586,
+      command: 'Chrome Helper (Renderer)',
+    });
+    const snapshot = evaluateDaemonLeaks(observe({ processes: [browserDaemon, chrome, renderer] }));
+
+    expect(snapshot.ownedProcesses.map((owned) => owned.pid)).toEqual([47515, 47586, 47953]);
+    expect(snapshot.ownedProcesses[0]?.reasons).toEqual(['state-dir-env', 'state-dir-argv']);
+    // The fleet below the matched root is owned transitively, not by its own argv.
+    expect(snapshot.ownedProcesses[1]?.reasons).toEqual(['descendant']);
+  });
+
+  test('ignores foreign processes, the observer chain, and the daemons themselves', () => {
+    const simulator = proc({ pid: 700, command: '/…/CoreSimulator … SimulatorTrampoline' });
+    const neighbourStateDir = proc({
+      pid: 701,
+      command: `node --state-dir ${STATE_DIR}-other/daemon.ts`,
+      env: `AGENT_DEVICE_STATE_DIR=${STATE_DIR}-other`,
+    });
+    const observer = proc({ pid: OBSERVER_PID, pgid: DAEMON_PID });
+    const daemon = proc({ pid: DAEMON_PID, pgid: DAEMON_PID });
+    const snapshot = evaluateDaemonLeaks(
+      observe({ processes: [simulator, neighbourStateDir, observer, daemon] }),
+    );
+
+    expect(snapshot.ownedProcesses).toEqual([]);
+    expect(hasDaemonLeaks(snapshot)).toBe(false);
+  });
+});
+
 describe('surviving-daemon rule', () => {
   // stopProcessForTakeover is best-effort void: it returns silently on identity
   // mismatch, signal failure, or kill timeout, so a daemon can outlive the stop.
@@ -54,9 +133,7 @@ describe('surviving-daemon rule', () => {
 
     expect(snapshot.liveDaemonPids).toEqual([DAEMON_PID]);
     expect(hasDaemonLeaks(snapshot)).toBe(true);
-    expect(formatDaemonLeakReport(snapshot)).toContain(
-      `daemons that outlived shutdown: ${DAEMON_PID}`,
-    );
+    expect(formatDaemonLeakReport(snapshot)).toContain('daemons that outlived shutdown: 1');
   });
 
   test('its metadata files stay stray rather than being excused by its own survival', () => {
@@ -190,7 +267,10 @@ describe('closed-session capture handles', () => {
 
 test('a clean shutdown reports no leak', () => {
   const snapshot = evaluateDaemonLeaks(
-    observe({ stateEntries: [file('daemon.log'), file('sessions/default/events.ndjson')] }),
+    observe({
+      processes: [proc({ pid: 700, command: 'unrelated' })],
+      stateEntries: [file('daemon.log'), file('sessions/default/events.ndjson')],
+    }),
   );
 
   expect(hasDaemonLeaks(snapshot)).toBe(false);