@cleocode/adapters 2026.6.14 → 2026.6.15

package/dist/providers/claude-code/spawn.d.ts

@@ -5,10 +5,12 @@
  * Migrated from src/core/spawn/adapters/claude-code-adapter.ts
  *
  * Uses the native `claude` CLI to spawn subagent processes with prompts
- * written to temporary files. Processes run detached and are tracked
- * by PID for listing and termination.
+ * written to temporary files. Processes run in per-session containment
+ * (systemd transient scope on Linux, or setsid process group as fallback)
+ * so that session end reaps the entire MCP suite tree.
  *
  * @task T5240
+ * @task T11998 — per-session scope/pgid suite containment
  */
 import type { AdapterSpawnProvider, SpawnContext, SpawnResult } from '@cleocode/contracts';
 /**
@@ -57,11 +59,25 @@ export declare class ClaudeCodeSpawnProvider implements AdapterSpawnProvider {
     /**
      * Terminate a running spawn by instance ID.
      *
-     * Sends SIGTERM to the tracked process. If the process is not found
-     * or has already exited, this is a no-op.
+     * Uses the suite-reaper to kill the entire process tree (root claude CLI +
+     * all MCP grandchildren) via the containment handle recorded at spawn time.
+     * Falls back to a direct SIGTERM on the tracked PID for legacy entries
+     * that pre-date T11998 and lack an ownership handle.
+     *
+     * Idempotent: no-op if the instance is not found or has already exited.
      *
      * @param instanceId - ID of the spawn instance to terminate
+     * @task T11998
      */
     terminate(instanceId: string): Promise<void>;
+    /**
+     * Terminate all tracked spawn instances on session end.
+     *
+     * Called by the session lifecycle when a CLEO session ends, ensuring
+     * no orphaned agent suites (root process + MCP children) remain.
+     *
+     * @task T11998
+     */
+    terminateAll(): Promise<void>;
 }
 //# sourceMappingURL=spawn.d.ts.map

package/dist/providers/claude-code/spawn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/spawn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAY3F;;;;;;;;;;;;;;GAcG;AACH,qBAAa,uBAAwB,YAAW,oBAAoB;IAClE,mDAAmD;IACnD,OAAO,CAAC,UAAU,CAAqC;IAEvD;;;;OAIG;IACG,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IASlC;;;;;;;;OAQG;IACG,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IA8GxD;;;;;;;OAOG;IACG,WAAW,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAqB3C;;;;;;;OAOG;IACG,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAWnD"}
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/spawn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,OAAO,KAAK,EACV,oBAAoB,EAEpB,YAAY,EACZ,WAAW,EACZ,MAAM,qBAAqB,CAAC;AAgB7B;;;;;;;;;;;;;;GAcG;AACH,qBAAa,uBAAwB,YAAW,oBAAoB;IAClE,mDAAmD;IACnD,OAAO,CAAC,UAAU,CAAqC;IAEvD;;;;OAIG;IACG,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IASlC;;;;;;;;OAQG;IACG,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IA2IxD;;;;;;;OAOG;IACG,WAAW,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAuB3C;;;;;;;;;;;;OAYG;IACG,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBlD;;;;;;;OAOG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;CAIpC"}

package/dist/providers/claude-code/suite-reaper.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Agent suite reaper — session-end cleanup for the per-session containment epic (T11998).
+ *
+ * Provides a single {@link reapAgentSuite} function that kills an agent's
+ * entire process tree (including indirectly-spawned MCP grandchildren) using
+ * whatever containment handle was recorded at spawn time.
+ *
+ * ## Reap strategy
+ *
+ * | mode     | primary kill                          | fallback                  |
+ * |----------|---------------------------------------|---------------------------|
+ * | systemd  | `systemctl --user stop <unitName>`    | negative-pgid SIGKILL     |
+ * | pgid     | `kill(-pgid, SIGTERM)` → grace → KILL | none (best-effort)        |
+ * | none     | no-op (janitor T11995 is backstop)    | —                         |
+ *
+ * All operations are idempotent: ESRCH, no-such-unit, and already-stopped
+ * conditions are treated as success (no-op).
+ *
+ * @module suite-reaper
+ * @task T11998
+ * @epic T11992
+ */
+import type { AgentSuiteOwnership } from '@cleocode/contracts';
+/**
+ * Reap an agent process suite.
+ *
+ * Stops the entire tree of processes associated with a spawned agent session:
+ * the root claude CLI process AND all MCP children that reparented under it.
+ *
+ * This function is called on:
+ *   - Normal session end (user runs `cleo session end`)
+ *   - `terminate(instanceId)` on the spawn provider
+ *   - Watchdog-declared death (future T11995 janitor call-back)
+ *
+ * @param ownership - The containment handle recorded at spawn time.
+ * @returns A promise that resolves when the reap attempt is complete.
+ *
+ * @task T11998
+ */
+export declare function reapAgentSuite(ownership: AgentSuiteOwnership): Promise<void>;
+//# sourceMappingURL=suite-reaper.d.ts.map

package/dist/providers/claude-code/suite-reaper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suite-reaper.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/suite-reaper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAU/D;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,cAAc,CAAC,SAAS,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsBlF"}

package/dist/providers/shared/agent-spawn-wrapper.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Adapter-local spawn-args builder for per-session suite containment (T11998).
+ *
+ * This module provides a self-contained copy of the systemd-run argv builder
+ * for use inside `packages/adapters/`, which cannot import from
+ * `packages/core/` (that would create a circular dependency since core depends
+ * on adapters).
+ *
+ * ## Relationship to `packages/core/src/resources/spawn-wrapper.ts`
+ *
+ * The canonical SSoT for systemd-run argv construction is in core (T11993).
+ * This module is a DELIBERATE LOCAL COPY scoped to the adapter layer, kept
+ * in sync by the skill-drift gate.  It follows the same design decisions:
+ *   - `cleo.slice` placement
+ *   - `MemoryMax=32G` hard cap (P1 staged value)
+ *   - `MemorySwapMax=0`
+ *   - Selective `ManagedOOMPreference=avoid` (daemon/db only)
+ *   - Core suppression via `ulimit -c 0` (NOT LimitCORE=0 — invalid on scopes)
+ *   - `_forceSystemdRunAvailable()` test hook
+ *
+ * When the core SSoT changes, update this file in the same PR.
+ *
+ * ## Why a copy?
+ *
+ * The dependency direction is `core → adapters`.  Adding `core` to adapters'
+ * deps would create a cycle.  Extracting to a third package is a separate
+ * refactor task; for P1 the local copy is the right trade-off.
+ *
+ * @module agent-spawn-wrapper
+ * @task T11998
+ * @epic T11992
+ * @see packages/core/src/resources/spawn-wrapper.ts (canonical SSoT)
+ */
+import type { AgentSuiteOwnership } from '@cleocode/contracts';
+/** The systemd user slice that all cleo agent scope sessions are placed under. */
+export declare const CLEO_SLICE: "cleo.slice";
+/**
+ * Force the cached systemd-run availability for tests.
+ *
+ * @param available - `true` = systemd path, `false` = pgid fallback.
+ */
+export declare function _forceSystemdRunAvailable(available: boolean): void;
+/**
+ * Result of building the spawn argv for an agent session.
+ *
+ * Carries both the launch command/args AND the ownership handle that must
+ * be persisted in the tracking record for use by {@link reapAgentSuite}.
+ */
+export interface AgentSpawnArgs {
+    /** Command to execute (e.g. `'systemd-run'` or `'sh'` or the real binary). */
+    command: string;
+    /** Full argument list. */
+    args: string[];
+    /**
+     * Ownership handle to persist in the session tracking record.
+     *
+     * Pass this to {@link reapAgentSuite} on session end.
+     */
+    ownership: AgentSuiteOwnership;
+}
+/**
+ * Build the argv for spawning a claude agent session with containment.
+ *
+ * When systemd is available the agent is placed in a transient scope under
+ * `cleo.slice`.  Otherwise it falls back to a setsid process-group spawn
+ * (the caller is responsible for passing `{ detached: true }` to
+ * `child_process.spawn` so a new pgid is created).
+ *
+ * Core suppression is applied via `ulimit -c 0` (NOT `LimitCORE=0` — that is
+ * a service-unit EXEC property and is rejected by `systemd-run --scope`).
+ *
+ * @param command - The executable to run (e.g. `'claude'`).
+ * @param args - Arguments for the executable.
+ * @param scopeId - Optional discriminator appended to the unit name (e.g. a
+ *   task ID or instance ID) so concurrent sessions are addressable.
+ * @returns Build result with spawn command/args and the ownership handle.
+ */
+export declare function buildAgentSpawnArgs(command: string, args: readonly string[], scopeId?: string): AgentSpawnArgs;
+//# sourceMappingURL=agent-spawn-wrapper.d.ts.map

package/dist/providers/shared/agent-spawn-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-spawn-wrapper.d.ts","sourceRoot":"","sources":["../../../src/providers/shared/agent-spawn-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAIH,OAAO,KAAK,EAAwB,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAMrF,kFAAkF;AAClF,eAAO,MAAM,UAAU,EAAG,YAAqB,CAAC;AAmChD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAElE;AAyBD;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,8EAA8E;IAC9E,OAAO,EAAE,MAAM,CAAC;IAChB,0BAA0B;IAC1B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;;;OAIG;IACH,SAAS,EAAE,mBAAmB,CAAC;CAChC;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,CAAC,EAAE,MAAM,GACf,cAAc,CAmEhB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cleocode/adapters",
-  "version": "2026.6.14",
+  "version": "2026.6.15",
   "description": "Unified provider adapters for CLEO (Claude Code, OpenCode, Cursor)",
   "type": "module",
   "main": "dist/index.js",
@@ -15,9 +15,9 @@
     "@ai-sdk/anthropic": "^3.0.69",
     "@ai-sdk/openai": "^2.0.53",
     "ai": "^6.0.168",
-    "@cleocode/contracts": "2026.6.14",
-    "@cleocode/caamp": "2026.6.14",
-    "@cleocode/paths": "2026.6.14"
+    "@cleocode/caamp": "2026.6.15",
+    "@cleocode/contracts": "2026.6.15",
+    "@cleocode/paths": "2026.6.15"
   },
   "license": "MIT",
   "engines": {
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@types/node": "^22.19.15",
     "vitest": "^4.1.4",
-    "@cleocode/playbooks": "2026.6.14"
+    "@cleocode/playbooks": "2026.6.15"
   },
   "repository": {
     "type": "git",

package/src/__tests__/suite-containment.test.ts

@@ -0,0 +1,347 @@
+/**
+ * Integration test: per-session suite containment (T11998).
+ *
+ * ## Acceptance criterion
+ *
+ * > An integration test spawns a stand-in agent that forks grandchildren,
+ * > ends the session, and asserts zero surviving processes.
+ *
+ * ## CI-runnable design
+ *
+ * The test uses `_forceSystemdRunAvailable(false)` to run in the **pgid path**
+ * so it does not require a user systemd bus.  A separate `describe.skipIf`
+ * block exercises the systemd path when `systemd-run --user` is actually
+ * available on the test host.
+ *
+ * ### Stand-in agent script
+ *
+ * A small shell script is launched that immediately forks two `sleep 60`
+ * grandchildren, simulating an MCP server suite:
+ *
+ * ```sh
+ * #!/bin/sh
+ * sleep 60 &
+ * sleep 60 &
+ * wait
+ * ```
+ *
+ * After the reaper is called, we assert that neither the root process nor
+ * any `sleep 60` grandchild is still alive.
+ *
+ * @task T11998
+ * @epic T11992
+ */
+
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { AgentSuiteOwnership } from '@cleocode/contracts';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { reapAgentSuite } from '../providers/claude-code/suite-reaper.js';
+import {
+  _forceSystemdRunAvailable,
+  buildAgentSpawnArgs,
+} from '../providers/shared/agent-spawn-wrapper.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Write a stand-in agent script to a temp file.
+ * The script spawns two sleep grandchildren then waits.
+ */
+function writeStandInScript(): string {
+  const scriptPath = join(tmpdir(), `cleo-test-agent-${process.pid}-${Date.now()}.sh`);
+  writeFileSync(scriptPath, '#!/bin/sh\nsleep 60 &\nsleep 60 &\nwait\n', { mode: 0o755 });
+  return scriptPath;
+}
+
+/**
+ * Check whether a PID is still alive via kill(pid, 0).
+ */
+function isAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Wait up to `timeoutMs` for a condition to become true.
+ */
+async function waitForCondition(
+  condition: () => boolean,
+  timeoutMs = 5_000,
+  pollMs = 100,
+): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (condition()) return true;
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  return condition();
+}
+
+/**
+ * Find child PIDs of a given parent PID using /proc (Linux only).
+ * Returns empty array on non-Linux or when /proc is unavailable.
+ */
+function getChildPids(parentPid: number): number[] {
+  if (process.platform !== 'linux') return [];
+  try {
+    const result = spawnSync('pgrep', ['-P', String(parentPid)], { encoding: 'utf8' });
+    if (result.status !== 0 || !result.stdout) return [];
+    return result.stdout
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .map(Number)
+      .filter((n) => !Number.isNaN(n));
+  } catch {
+    return [];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Reset forced availability after each test
+// ---------------------------------------------------------------------------
+
+afterEach(() => {
+  _forceSystemdRunAvailable(false);
+});
+
+// ---------------------------------------------------------------------------
+// pgid path — CI-runnable (forced: no systemd)
+// ---------------------------------------------------------------------------
+
+describe('suite-containment — pgid path (forced, no systemd required)', () => {
+  let scriptPath: string | undefined;
+
+  beforeEach(() => {
+    scriptPath = writeStandInScript();
+  });
+
+  afterEach(() => {
+    if (scriptPath && existsSync(scriptPath)) {
+      try {
+        unlinkSync(scriptPath);
+      } catch {
+        // ignore
+      }
+    }
+  });
+
+  it('buildAgentSpawnArgs returns mode=pgid when systemd-run is forced unavailable', () => {
+    _forceSystemdRunAvailable(false);
+    const result = buildAgentSpawnArgs('sh', ['-c', 'echo hi'], 'T11998-test');
+    expect(result.ownership.mode).toBe('pgid');
+    expect(result.ownership.unitName).toBeUndefined();
+    // Command is 'sh' wrapping ulimit
+    expect(result.command).toBe('sh');
+    expect(result.args).toContain('ulimit -c 0; exec "$@"');
+  });
+
+  it('reapAgentSuite (pgid): zero surviving processes after reap', async () => {
+    _forceSystemdRunAvailable(false);
+
+    if (process.platform !== 'linux') {
+      // pgid kill requires POSIX — skip on non-Linux CI
+      return;
+    }
+
+    if (!scriptPath) throw new Error('scriptPath not set');
+
+    // Spawn the stand-in agent with detached:true so it gets its own pgid.
+    // The agent script itself spawns two sleep grandchildren.
+    const child = spawn('sh', [scriptPath], {
+      detached: true,
+      stdio: 'ignore',
+    });
+    child.unref();
+
+    const rootPid = child.pid;
+    if (!rootPid) throw new Error('Failed to spawn stand-in agent');
+
+    // Give the stand-in time to fork its grandchildren.
+    await new Promise((r) => setTimeout(r, 300));
+
+    // Collect grandchild PIDs before reap.
+    const grandchildren = getChildPids(rootPid);
+    // We should have at least the root alive.
+    expect(isAlive(rootPid)).toBe(true);
+
+    // Build an ownership handle with the root's PID as pgid leader.
+    const ownership: AgentSuiteOwnership = {
+      mode: 'pgid',
+      pgid: rootPid,
+      pid: rootPid,
+    };
+
+    // Reap the suite.
+    await reapAgentSuite(ownership);
+
+    // Wait for all processes to die (up to 5s).
+    const allGone = await waitForCondition(() => {
+      if (isAlive(rootPid)) return false;
+      return grandchildren.every((pid) => !isAlive(pid));
+    });
+
+    expect(allGone).toBe(true);
+
+    // Verify individually for a clear failure message.
+    expect(isAlive(rootPid)).toBe(false);
+    for (const gPid of grandchildren) {
+      expect(isAlive(gPid)).toBe(false);
+    }
+  }, 10_000); // 10s timeout (SIGTERM grace = 3s + buffer)
+
+  it('reapAgentSuite (pgid, none): is a no-op for mode=none', async () => {
+    const ownership: AgentSuiteOwnership = { mode: 'none' };
+    // Should not throw.
+    await expect(reapAgentSuite(ownership)).resolves.toBeUndefined();
+  });
+
+  it('reapAgentSuite (pgid): ESRCH is a no-op (already-gone group)', async () => {
+    // Use a known-dead PID (extremely high number, likely not in use).
+    const ownership: AgentSuiteOwnership = {
+      mode: 'pgid',
+      pgid: 2_000_000_000,
+      pid: 2_000_000_000,
+    };
+    // Should resolve cleanly (ESRCH is treated as success).
+    await expect(reapAgentSuite(ownership)).resolves.toBeUndefined();
+  });
+
+  it('abnormal agent exit leaves no processes reparented after reap', async () => {
+    if (process.platform !== 'linux') return;
+    if (!scriptPath) throw new Error('scriptPath not set');
+
+    // Spawn stand-in, kill the root immediately (simulating abnormal exit),
+    // then assert the reaper still handles the orphaned grandchildren.
+    const child = spawn('sh', [scriptPath], {
+      detached: true,
+      stdio: 'ignore',
+    });
+    child.unref();
+
+    const rootPid = child.pid;
+    if (!rootPid) throw new Error('Failed to spawn stand-in agent');
+
+    // Give grandchildren time to start.
+    await new Promise((r) => setTimeout(r, 300));
+    const grandchildren = getChildPids(rootPid);
+
+    // Kill the root abnormally (simulate crash).
+    try {
+      process.kill(rootPid, 'SIGKILL');
+    } catch {
+      // Already dead — fine.
+    }
+
+    // Wait a tick for grandchildren to potentially reparent.
+    await new Promise((r) => setTimeout(r, 100));
+
+    // Now reap whatever is left via pgid.
+    const ownership: AgentSuiteOwnership = {
+      mode: 'pgid',
+      pgid: rootPid,
+      pid: rootPid,
+    };
+    await reapAgentSuite(ownership);
+
+    // After reap, all grandchildren must be gone.
+    const allGone = await waitForCondition(() => grandchildren.every((pid) => !isAlive(pid)));
+    expect(allGone).toBe(true);
+  }, 10_000);
+});
+
+// ---------------------------------------------------------------------------
+// systemd path — only when systemd-run is actually available
+// ---------------------------------------------------------------------------
+
+const systemdAvailable =
+  process.platform === 'linux' &&
+  spawnSync('systemd-run', ['--version'], { stdio: 'ignore' }).status === 0 &&
+  // Also check for a live user bus (DBUS_SESSION_BUS_ADDRESS or XDG_RUNTIME_DIR).
+  (!!process.env['DBUS_SESSION_BUS_ADDRESS'] || !!process.env['XDG_RUNTIME_DIR']);
+
+describe.skipIf(!systemdAvailable)(
+  'suite-containment — systemd path (requires live user bus)',
+  () => {
+    let scriptPath: string | undefined;
+
+    beforeEach(() => {
+      scriptPath = writeStandInScript();
+      // Do NOT force availability — use the real probe.
+      _forceSystemdRunAvailable(true);
+    });
+
+    afterEach(() => {
+      _forceSystemdRunAvailable(false);
+      if (scriptPath && existsSync(scriptPath)) {
+        try {
+          unlinkSync(scriptPath);
+        } catch {
+          // ignore
+        }
+      }
+    });
+
+    it('buildAgentSpawnArgs returns mode=systemd with a unit name', () => {
+      const result = buildAgentSpawnArgs('sh', ['-c', 'echo hi'], 'T11998-systemd');
+      expect(result.ownership.mode).toBe('systemd');
+      expect(result.ownership.unitName).toMatch(/^cleo-agent-session-T11998-systemd\.scope$/);
+      expect(result.command).toBe('systemd-run');
+      expect(result.args).toContain('--scope');
+      expect(result.args).toContain(`--slice=cleo.slice`);
+    });
+
+    it('reapAgentSuite (systemd): stops the scope and all grandchildren', async () => {
+      if (!scriptPath) throw new Error('scriptPath not set');
+
+      const spawnBuild = buildAgentSpawnArgs('sh', [scriptPath], 'T11998-reap-test');
+      expect(spawnBuild.ownership.mode).toBe('systemd');
+      const { unitName } = spawnBuild.ownership;
+      if (!unitName) throw new Error('unitName must be set in systemd mode');
+
+      // Launch via systemd-run.
+      const child = spawn(spawnBuild.command, spawnBuild.args, {
+        stdio: 'ignore',
+      });
+
+      const rootPid = child.pid;
+      if (!rootPid) throw new Error('Failed to spawn stand-in agent via systemd-run');
+
+      // Give systemd-run time to activate the scope and let grandchildren start.
+      await new Promise((r) => setTimeout(r, 600));
+
+      const ownership: AgentSuiteOwnership = {
+        ...spawnBuild.ownership,
+        pid: rootPid,
+      };
+
+      // Reap the scope.
+      await reapAgentSuite(ownership);
+
+      // The scope should be gone — verify via systemctl show (exit non-zero = not found).
+      await new Promise((r) => setTimeout(r, 200));
+      const showResult = spawnSync(
+        'systemctl',
+        ['--user', 'show', '--property=ActiveState', unitName],
+        { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] },
+      );
+      // Either the unit is not found (exit 4) or its state is inactive/dead.
+      const isInactiveOrGone =
+        showResult.status !== 0 ||
+        showResult.stdout.includes('ActiveState=inactive') ||
+        showResult.stdout.includes('ActiveState=failed') ||
+        showResult.stdout.includes('ActiveState=dead') ||
+        !showResult.stdout.includes('ActiveState=active');
+      expect(isInactiveOrGone).toBe(true);
+    }, 15_000);
+  },
+);