@@ -116,7 +116,7 @@ export type AppLogProcessCommand =
       kind: 'android-adb';
       serial: string;
       args: readonly string[];
-      options?: Pick<HostCommandRequest, 'allowFailure' | 'cwd' | 'env' | 'timeoutMs'>;
+      options?: Pick<HostCommandRequest, 'allowFailure' | 'cwd' | 'env'>;
     }>;
 
 export type AppLogBackgroundProcessRequest = Readonly<{
 
@@ -3,6 +3,10 @@ import { test } from 'vitest';
 import { AppError } from '@agent-device/kernel/errors';
 import {
   runCmd,
+  runCmdBackground,
+  runCmdDetached,
+  runCmdStreaming,
+  runCmdSync,
   withCommandExecutorOverride,
   type CommandExecutorOverride,
 } from '@agent-device/host-kit/command';
@@ -28,3 +32,27 @@ test('fail-Nth executor drives one deterministic command failure without hiding
 
   assert.deepEqual(calls, [['first'], ['second'], ['third']]);
 });
+
+test('the override seam covers the foreground commands and no other spawn path', async () => {
+  const consulted: string[] = [];
+
+  await withCommandExecutorOverride(
+    (command) => {
+      consulted.push(command);
+      return undefined;
+    },
+    async () => {
+      runCmdSync(process.execPath, ['-e', 'process.stdout.write("sync")']);
+      const background = runCmdBackground(process.execPath, [
+        '-e',
+        'process.stdout.write("background")',
+      ]);
+      await background.wait;
+      runCmdDetached(process.execPath, ['-e', 'process.exit(0)']);
+      await runCmdStreaming(process.execPath, ['-e', 'process.stdout.write("streaming")']);
+      await runCmd(process.execPath, ['-e', 'process.stdout.write("foreground")']);
+    },
+  );
+
+  assert.deepEqual(consulted, [process.execPath, process.execPath]);
+});
@@ -0,0 +1,229 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { test } from 'vitest';
+import {
+  isCommandTimeoutError,
+  runCmd,
+  runCmdBackground,
+  runCmdStreaming,
+  type ExecBackgroundOptions,
+} from './exec.ts';
+import { shellQuote } from './shell-quote.ts';
+import { sleep } from './timeouts.ts';
+import { mkdtempForTestSync } from './tmp-dir.fixtures.ts';
+
+// A direct child can hand our stdout/stderr pipes to a descendant, and `close` waits
+// for those pipes to drain: a command this module killed stayed unsettled — holding
+// its request and the device lock it owns — until the descendant died by itself.
+// `sh` and `sleep` start in milliseconds, so the deadline never races a runtime
+// booting, and the leaked holder is a timer, not a runtime.
+
+const HOLDER_LIFETIME_SECONDS = 3;
+const DEADLINE_MS = 400;
+
+function pipeHolderShellScript(pidFilePath: string): string {
+  return `sleep ${HOLDER_LIFETIME_SECONDS} & printf %s $! > ${shellQuote(pidFilePath)}; wait`;
+}
+
+function holderPidFilePath(label: string): string {
+  return path.join(mkdtempForTestSync(`agent-device-exec-${label}-`), 'holder.pid');
+}
+
+function isProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM is a live process owned by someone else; only ESRCH is absence.
+    return (error as NodeJS.ErrnoException).code === 'EPERM';
+  }
+}
+
+async function readRecordedHolderPid(pidFilePath: string): Promise<number> {
+  const deadline = Date.now() + 2_000;
+  for (;;) {
+    try {
+      const recorded = fs.readFileSync(pidFilePath, 'utf8').trim();
+      if (recorded) return Number(recorded);
+    } catch {}
+    if (Date.now() > deadline) throw new Error('the pipe holder never recorded its pid');
+    await sleep(10);
+  }
+}
+
+async function waitForProcessToExit(pid: number): Promise<boolean> {
+  const deadline = Date.now() + 2_000;
+  while (isProcessRunning(pid)) {
+    if (Date.now() > deadline) return false;
+    await sleep(20);
+  }
+  return true;
+}
+
+function settledRejection<T>(promise: Promise<T>): Promise<{ error: unknown } | null> {
+  return promise.then(
+    () => null,
+    (error: unknown) => ({ error }),
+  );
+}
+
+test.runIf(process.platform !== 'win32')(
+  'runCmd killed at its deadline settles on the child exit, not on an inherited pipe',
+  async () => {
+    const pidFilePath = holderPidFilePath('timeout-holder');
+    const killed = runCmd('/bin/sh', ['-c', pipeHolderShellScript(pidFilePath)], {
+      timeoutMs: DEADLINE_MS,
+    });
+    const rejection = settledRejection(killed);
+
+    const holderPid = await readRecordedHolderPid(pidFilePath);
+    const outcome = await rejection;
+
+    assert.ok(outcome, 'a command killed at its deadline must not resolve');
+    assert.ok(isCommandTimeoutError(outcome.error));
+    assert.equal(
+      isProcessRunning(holderPid),
+      true,
+      'settled only once the pipe holder died, which is the wedge this settles before',
+    );
+  },
+);
+
+test.runIf(process.platform !== 'win32')(
+  'a deadline on a detached command kills the descendant that inherited the pipes',
+  async () => {
+    const pidFilePath = holderPidFilePath('detached-holder');
+    const killed = runCmd('/bin/sh', ['-c', pipeHolderShellScript(pidFilePath)], {
+      timeoutMs: DEADLINE_MS,
+      detached: true,
+    });
+    const rejection = settledRejection(killed);
+
+    const holderPid = await readRecordedHolderPid(pidFilePath);
+    const outcome = await rejection;
+
+    assert.ok(outcome);
+    assert.ok(isCommandTimeoutError(outcome.error));
+    assert.equal(
+      await waitForProcessToExit(holderPid),
+      true,
+      'the process-group kill left the inherited-pipe holder running',
+    );
+  },
+);
+
+test.runIf(process.platform !== 'win32')(
+  'runCmdBackground killed by request cancellation settles on the child exit',
+  async () => {
+    const pidFilePath = holderPidFilePath('abort-holder');
+    const controller = new AbortController();
+    const { wait } = runCmdBackground('/bin/sh', ['-c', pipeHolderShellScript(pidFilePath)], {
+      signal: controller.signal,
+      captureOutput: false,
+    });
+    const rejection = settledRejection(wait);
+
+    const holderPid = await readRecordedHolderPid(pidFilePath);
+    controller.abort();
+    const outcome = await rejection;
+
+    assert.ok(outcome, 'a canceled background command must not resolve');
+    assert.equal(
+      isProcessRunning(holderPid),
+      true,
+      'settled only once the pipe holder died, which is the wedge this settles before',
+    );
+    const details = (outcome.error as { details?: Record<string, unknown> }).details;
+    assert.equal(details?.reason, 'request_canceled');
+  },
+);
+
+test.runIf(process.platform !== 'win32')(
+  'a cancellation arriving after the child was reaped signals no process group',
+  async () => {
+    // The direct child exits at once and leaves `sleep 0.4` draining the streams.
+    // Its pid — and therefore its process-group id — is reusable from the moment it
+    // is reaped, so the cancellation must not address that group any more.
+    let childReaped: () => void = () => {};
+    const reaped = new Promise<void>((resolve) => {
+      childReaped = resolve;
+    });
+    const controller = new AbortController();
+    const running = runCmdStreaming('/bin/sh', ['-c', 'sleep 0.4 &'], {
+      signal: controller.signal,
+      detached: true,
+      onSpawn: (child) => {
+        child.once('exit', childReaped);
+      },
+    });
+    const rejection = settledRejection(running);
+
+    await reaped;
+    controller.abort();
+    const outcome = await rejection;
+
+    assert.ok(outcome, 'a canceled command must not resolve');
+    const details = (outcome.error as { details?: Record<string, unknown> }).details;
+    assert.equal(details?.reason, 'request_canceled');
+  },
+);
+
+test.runIf(process.platform !== 'win32')(
+  'runCmd that was never killed still drains output a descendant writes after its parent exited',
+  async () => {
+    const result = await runCmd('/bin/sh', ['-c', 'printf head; { sleep 0.2; printf tail; } &']);
+
+    assert.equal(result.stdout, 'headtail');
+  },
+);
+
+test('a killed command still fails with its deadline even when it allowed failure', async () => {
+  const outcome = await runCmd(process.execPath, ['-e', 'setTimeout(() => {}, 10_000)'], {
+    timeoutMs: 60,
+    allowFailure: true,
+  }).then(
+    () => null,
+    (error: unknown) => error,
+  );
+
+  assert.ok(isCommandTimeoutError(outcome));
+});
+
+test('binaryStdout returns every byte the command wrote', async () => {
+  const bytes = 4096;
+  const result = await runCmd(
+    process.execPath,
+    ['-e', 'process.stdout.write(Buffer.alloc(4096, 7))'],
+    { binaryStdout: true },
+  );
+
+  assert.equal(result.stdout, '');
+  assert.equal(result.stdoutBuffer?.length, bytes);
+});
+
+test('runCmdBackground captures the full stdout of a child that writes over a megabyte', async () => {
+  const bytes = 1_500_000;
+  const { wait } = runCmdBackground(process.execPath, [
+    '-e',
+    `process.stdout.write("a".repeat(${bytes}))`,
+  ]);
+
+  const result = await wait;
+
+  assert.equal(result.stdout.length, bytes);
+});
+
+test('background exec arms no deadline when timeoutMs crosses an unchecked options spread', async () => {
+  const leakedOptions = { timeoutMs: 20 } as unknown as ExecBackgroundOptions;
+
+  const { wait } = runCmdBackground(
+    process.execPath,
+    ['-e', 'setTimeout(() => process.exit(0), 150)'],
+    leakedOptions,
+  );
+
+  const result = await wait;
+
+  assert.equal(result.exitCode, 0);
+});