pi-better-subagents 0.10.0 → 0.12.0

package/README.md

@@ -36,9 +36,15 @@ Linux confinement requires a usable `bubblewrap` backend and Pi SDK 0.82.1 or ne
 ## Delegation Modes
 
 `config.json` sets `delegationMode` to `manual`, `adaptive` (default), or
-`coordinator`. `/subagents` displays the active mode, and
-`/subagents mode manual|adaptive|coordinator` changes it for the current
-session without changing config. Manual delegates only on explicit user or workflow request, even with a
+`coordinator`. `/subagents settings` (or `/subagents`) opens a settings page
+for delegation mode and the concurrent-subagent cap (default 4). Edits apply to
+this session; Save as defaults persists both, and Reset to defaults clears
+session overrides. `/subagents mode manual|adaptive|coordinator` and
+`/subagents cap <number>` are command equivalents; `/subagents save` persists
+both. Lowering the cap blocks new single and batch launches without stopping
+running work. The navigator's `main` row retains its mode-only controls:
+`m` cycles the session mode, `ctrl+s` saves that default, and `x`
+does not stop it. Manual delegates only on explicit user or workflow request, even with a
 plan. Adaptive delegates substantial independent work when useful. Coordinator
 uses `agents_catalog` to discover current role descriptions and delegates every
 nontrivial role-owned task, while the foreground coordinates, integrates, and

package/agent-commands.ts

@@ -123,7 +123,7 @@ interface ParsedArgs {
 
 export function registerAgentCommands(pi: Pick<ExtensionAPI, "registerCommand">, deps: AgentCommandDeps = {}): void {
     pi.registerCommand("agents", {
-        description: "List, inspect, create, reload, or import Codex agent definitions",
+        description: "[list|show|create|reload|import-codex] — List, inspect, create, reload, or import agent definitions",
         getArgumentCompletions(prefix: string) {
             const commands = ["list", "inspect", "show", "create", "reload", "import-codex", "help"];
             const first = prefix.trim().split(/\s+/)[0] ?? "";

package/config.ts

@@ -8,12 +8,12 @@
  * `defaultTools` absent → the built-in SAFE_DEFAULT_TOOLS.
  */
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { SELF_SPEC } from "./extensions.ts";
-import type { DelegationMode } from "./delegation.ts";
+import { isDelegationMode, type DelegationMode } from "./delegation.ts";
 import type { TimingSettings } from "./timing.ts";
 
 export interface SubagentConfig extends TimingSettings {
@@ -21,7 +21,7 @@ export interface SubagentConfig extends TimingSettings {
     delegationMode?: DelegationMode | null;
     defaultModel?: string | null;
     defaultTools?: string | null;
-    /** Max subagents allowed to run at once. */
+    /** Default concurrency cap; /subagents cap overrides it for the current session. */
     maxConcurrent?: number | null;
     /**
      * Tool name → extension package(s) that provide it. Drives which extension
@@ -74,30 +74,82 @@ export interface SubagentConfig extends TimingSettings {
 /** Concurrency cap when config.json sets none. */
 export const DEFAULT_MAX_CONCURRENT = 4;
 
+export function isConcurrencyCap(value: unknown): value is number {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+
+export function normalizeConcurrencyCap(value: unknown): number {
+    return isConcurrencyCap(value) ? value : DEFAULT_MAX_CONCURRENT;
+}
+
 /** Built-in default tool set when config.json sets nothing. */
 export const SAFE_DEFAULT_TOOLS = "read, bash, edit, write, web_search, web_fetch";
 /** Safe default for a hermetic (clean) child where extension tools don't exist. */
 export const SAFE_CLEAN_TOOLS = "read, bash";
 
 let cached: SubagentConfig | undefined;
+let configPathForTests: string | undefined;
 
 /** Test seam. Pass undefined to reload config.json on the next loadConfig call. */
 export function setConfigForTests(next: SubagentConfig | undefined): void {
     cached = next;
 }
 
+/** Test seam. Save and load use this file instead of the package config.json. */
+export function setConfigPathForTests(path: string | undefined): void {
+    configPathForTests = path;
+    cached = undefined;
+}
+
+export function configPath(): string {
+    return configPathForTests ?? join(dirname(fileURLToPath(import.meta.url)), "config.json");
+}
+
 /** Load config.json from the extension directory. Missing/invalid → {}. */
 export function loadConfig(): SubagentConfig {
     if (cached) return cached;
     try {
-        const dir = dirname(fileURLToPath(import.meta.url));
-        cached = JSON.parse(readFileSync(join(dir, "config.json"), "utf-8")) as SubagentConfig;
+        cached = JSON.parse(readFileSync(configPath(), "utf-8")) as SubagentConfig;
     } catch {
         cached = {};
     }
     return cached;
 }
 
+/** Write delegationMode into config.json, preserving every other key. */
+export function writeDelegationMode(mode: DelegationMode, path = configPath()): void {
+    if (!isDelegationMode(mode)) throw new Error(`Invalid delegation mode: ${String(mode)}`);
+    let current: SubagentConfig = {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8")) as unknown;
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) current = parsed as SubagentConfig;
+    } catch { /* missing file starts as an empty config */ }
+    current.delegationMode = mode;
+    const pending = `${path}.${process.pid}.tmp`;
+    writeFileSync(pending, `${JSON.stringify(current, null, 2)}\n`);
+    renameSync(pending, path);
+    if (path === configPath()) cached = current;
+}
+
+/** Save human-facing defaults together, preserving unrelated configuration. */
+export function writeSubagentSettings(settings: { delegationMode: DelegationMode; maxConcurrent: number }, path = configPath()): void {
+    if (!isDelegationMode(settings.delegationMode)) throw new Error("Invalid delegation mode.");
+    if (!isConcurrencyCap(settings.maxConcurrent)) throw new Error("Concurrent subagents must be a positive whole number.");
+    let current: Record<string, unknown> = {};
+    try {
+        const parsed: unknown = JSON.parse(readFileSync(path, "utf-8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Config must be a JSON object.");
+        current = parsed as Record<string, unknown>;
+    } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+    Object.assign(current, settings);
+    const pending = `${path}.${process.pid}.tmp`;
+    writeFileSync(pending, `${JSON.stringify(current, null, 2)}\n`);
+    renameSync(pending, path);
+    if (path === configPath()) cached = current as SubagentConfig;
+}
+
 /** Normalize a comma/space tool list to pi's bare comma form: "a, b" → "a,b". */
 export function normalizeTools(list: string): string {
     return list.split(",").map((t) => t.trim()).filter(Boolean).join(",");

package/delegation.ts

@@ -1,5 +1,7 @@
 export type DelegationMode = "manual" | "adaptive" | "coordinator";
 
+export const DELEGATION_MODES = ["manual", "adaptive", "coordinator"] as const;
+
 export const DELEGATION_MODE_REQUEST = "pi-better-subagents:delegation-mode-request";
 
 export function isDelegationMode(value: unknown): value is DelegationMode {

package/docs/usage.md

@@ -16,11 +16,33 @@ launch is the result · completion triggers fetch · the foreground never blocks
 
 Set `delegationMode` in this package's `config.json` to `manual`, `adaptive`, or
 `coordinator` (default `adaptive`). This controls foreground delegation guidance,
-not child permissions or catalog definitions. `/subagents` reports the active
-mode; `/subagents mode manual|adaptive|coordinator` overrides it for the current
-session without editing config. Other arguments show usage. `/reload` retains
-this override; new sessions use config, while resuming a session restores that
-session's override.
+not child permissions or catalog definitions. `/subagents settings` (or simply
+`/subagents`) opens the terminal settings page with mode and concurrent-subagent
+cap controls, saved defaults, Save as defaults, and Reset to defaults. Changes
+apply immediately to this session; Escape closes the page without undoing them.
+Enter edits the cap as a positive whole number; Escape cancels an unfinished edit.
+Ctrl+S saves both settings as defaults. Sandbox permissions remain in `/sandbox`.
+
+Command equivalents also work outside the terminal UI:
+
+```text
+/subagents mode manual|adaptive|coordinator
+/subagents cap 6
+/subagents save
+/subagents reset
+```
+
+The cap defaults to 4 and applies to both single and batch launches. Lowering it
+below the running count leaves existing work untouched and blocks new admissions
+until capacity becomes available. Slots already reserved by an in-flight launch
+remain admitted. Settings apply to this parent Pi process, not
+all Pi sessions on the machine. Saving preserves unrelated config keys and
+clears both session overrides. The command form asks for confirmation when a UI
+is available. Reset restores saved defaults without changing config.
+
+`/reload` retains session overrides; new sessions use config, while resuming or
+navigating a branch restores its settings. On the navigator `main` sheet, `m`
+cycles the session mode and `ctrl+s` saves only that mode default.
 
 - **Manual:** no proactive delegation, including in plan mode. A user request or
   explicit workflow requirement may still delegate.
@@ -380,8 +402,12 @@ top.
   foreground model).
 - `delegationMode` — foreground policy (`manual`, `adaptive`, or `coordinator`;
   default `adaptive`). `/subagents mode ...` changes only the current session.
-- `maxConcurrent` — how many subagents may run at once (**default 4**). A spawn
-  past the cap is rejected until a running one finishes.
+  `/subagents save` saves mode and cap together as config defaults.
+- `maxConcurrent` — positive whole-number concurrency cap (**default 4**).
+  `/subagents cap <number>` overrides it for this session. Both single and batch
+  admissions respect the cap; existing runs are never stopped by a cap change.
+  Use `/subagents settings` to edit both controls or `/subagents reset` to return
+  to saved defaults.
 
 ## The allowlist also decides what LOADS
 
@@ -517,9 +543,11 @@ is unchanged in every mode.
 - While the main-window list is focused, the title hint changes to
   `Enter to view · x to stop`; the selected row is marked with `›`. Press
   `↓` from the bottom row to return to the input line.
-- The Subagents lane pins an informational `main` row above child runs. It
-  shows the foreground model, effort, active tool, context tokens, and active
-  elapsed time. It is not selectable and can never become an `x` stop target.
+- The Subagents lane pins a `main` row above child runs. It shows the
+  foreground model, effort, active tool, context tokens, elapsed time, and
+  delegation mode. Enter opens its detail sheet. `m` cycles the session mode.
+  `ctrl+s` saves that mode as the config default. `x` still stops
+  a child run; it never stops main.
 - `↑` moves to the previous row when multiple running rows are shown. `↓`
   moves toward the input line, returning to normal input from the bottom row.
 - `Enter` opens the selected run's live detail view. `x` stops the selected
@@ -637,6 +665,10 @@ health model:
   orphaned, lost, and degraded running runs; #65 orphaned/lost result bodies kept.
 - **Passive live widget** — healthy/quiet unchanged; degraded (and orphaned) may
   show a short suffix. Still `setWidget` only — never focusable.
+- **Navigator** — lifecycle status and operational health facts remain visible;
+  child tool/model incident summaries and history are omitted from rows and detail
+  chrome. Tool labels show just their name (for example, `bash`). The original
+  transcript, including error results, and transcript-read diagnostics remain available.
 - **`callback:false`** suppresses coordinator follow-up only; human `ui.notify` and
   TUI/passive visibility remain.
 

package/health-surface.mjs

@@ -162,6 +162,7 @@ export function formatNavigatorHealthFacts(obs) {
     if (!obs || !isActionableHealth(obs)) return [];
     const facts = [];
     for (const f of surfaceableCompactFacts(obs)) {
+        if (obs.model?.state === "error" && f === obs.model.listWarning) continue;
         if (f && f !== obs.status && !facts.includes(f)) facts.push(f);
     }
     if (obs.activity === "stale" && !facts.some((f) => /\bstale\b/i.test(f))) {

package/index.ts

@@ -35,7 +35,8 @@ import {
 import { spawnDetached, type SpawnResult } from "./spawn.ts";
 import { parseRun, readRunTranscript, resetParseRunCursor, type Usage } from "./parse.ts";
 import { finalizeRun as finalizeRunCore } from "./finalization.ts";
-import { loadConfig, normalizeTools, resolveExtensionPath, selfDir, SAFE_DEFAULT_TOOLS, SAFE_CLEAN_TOOLS, DEFAULT_MAX_CONCURRENT } from "./config.ts";
+import { loadConfig, writeDelegationMode, writeSubagentSettings, isConcurrencyCap, normalizeConcurrencyCap, normalizeTools, resolveExtensionPath, selfDir, SAFE_DEFAULT_TOOLS, SAFE_CLEAN_TOOLS } from "./config.ts";
+import { createSubagentSettingsPage } from "./settings-page.ts";
 import { STEER_FILE_ENV, readSteerReceipt } from "./child-steer.ts";
 import {
     decideTiming,
@@ -52,7 +53,7 @@ import {
     type TimingStopReason,
 } from "./timing.ts";
 import { readAppendedLines, type LogCursor } from "./log-cursor.ts";
-import { DELEGATION_MODE_REQUEST, delegationPrompt, isDelegationMode, normalizeDelegationMode, type DelegationMode } from "./delegation.ts";
+import { DELEGATION_MODES, DELEGATION_MODE_REQUEST, delegationPrompt, isDelegationMode, normalizeDelegationMode, type DelegationMode } from "./delegation.ts";
 import { resolveExtensions, extensionArgs } from "./extensions.ts";
 import { prepareTaskRuntime } from "./task-policy.ts";
 import { canonicalizePath, takeRecoverySnapshot } from "./shared-sandbox-core.ts";
@@ -117,7 +118,7 @@ import {
 import { buildHealthCallbackDelivery } from "./completion.ts";
 import { cancelCallbackBatch, getCallbackBatcher } from "./shared-callback-batcher.ts";
 import { completionCallbackFields, failureAttentionFields, healthCallbackFields } from "./callback-fields.ts";
-import { collectRunFailures, failurePath, failureView, markFailureAttentionDelivered, pendingFailureAttention, prependFailureSummary } from "./failures.ts";
+import { collectRunFailures, failurePath, markFailureAttentionDelivered, pendingFailureAttention } from "./failures.ts";
 import { failureAttentionHandled, observeFailures } from "./shared-failure-observations.ts";
 import {
     text,
@@ -162,9 +163,13 @@ import {
 import { defaultUserRoot, type CatalogSnapshot } from "./catalog-store.ts";
 
 const SUBAGENT_MODE_ACTIONS: readonly AutocompleteItem[] = [
+    { value: "settings", label: "settings", description: "Open delegation mode and concurrency settings" },
+    { value: "cap", label: "cap <number>", description: "Set a positive concurrent subagent limit for this session" },
+    { value: "reset", label: "reset", description: "Reset session mode and cap to saved defaults" },
     { value: "mode manual", label: "mode manual", description: "Delegate only when explicitly requested" },
     { value: "mode adaptive", label: "mode adaptive", description: "Delegate substantial independent work" },
     { value: "mode coordinator", label: "mode coordinator", description: "Delegate role-owned work by default" },
+    { value: "save", label: "save", description: "Save the current mode and cap as defaults" },
 ];
 
 export function subagentsArgumentCompletions(argumentPrefix: string): AutocompleteItem[] | null {
@@ -1149,9 +1154,6 @@ function subagentWorkRows(now: number): BackgroundWorkRow[] {
         if (row.model) bits.push(row.effort ? `${row.model} ${row.effort}` : row.model);
         if (row.tool) bits.push(row.tool);
         if (row.spend) bits.push(row.spend);
-        const failure = failureView(row.id, metaById.get(row.id)?.cwd ?? "", row.status !== "running" && row.status !== "orphaned");
-        // Only a failure that needs action replaces the row's columns; history stays in the detail view.
-        const firstFailure = failure.actionable ? failure.text.split("\n")[0] || "" : "";
         return {
             providerId: "subagents",
             id: row.id,
@@ -1164,9 +1166,8 @@ function subagentWorkRows(now: number): BackgroundWorkRow[] {
             statusTone: statusTone(row.status),
             kind: "subagent",
             elapsed: row.elapsed,
-            primary: firstFailure || bits.join(" · ") || "subagent run",
-            secondary: firstFailure ? bits.join(" · ") : undefined,
-            facts: [firstFailure, ...row.healthFacts].filter(Boolean).slice(0, 2),
+            primary: bits.join(" · ") || "subagent run",
+            facts: row.healthFacts,
             sortStartedAt: metaById.get(row.id)?.startedAt ?? now,
             expiresAt: (() => {
                 const meta = metaById.get(row.id);
@@ -1179,6 +1180,15 @@ function subagentWorkRows(now: number): BackgroundWorkRow[] {
     });
 }
 
+const DELEGATION_BLURB: Record<DelegationMode, string> = {
+    manual: "only when you or a workflow asks",
+    adaptive: "substantial independent work",
+    coordinator: "every role-owned task",
+};
+let readDelegation = (): { mode: DelegationMode; source: "session" | "config" } => ({ mode: "adaptive", source: "config" });
+let cycleDelegation = (): void => {};
+let saveDelegationDefault: (mode: DelegationMode) => { ok: boolean; message: string } = () => ({ ok: false, message: "Saving the delegation default is unavailable." });
+
 function mainAgentWorkRow(now: number): BackgroundWorkRow {
     let running = mainAgentStartedAt !== undefined;
     try { running ||= uiCtx?.isIdle() === false; } catch { /* use event state */ }
@@ -1188,10 +1198,12 @@ function mainAgentWorkRow(now: number): BackgroundWorkRow {
     let contextTokens: number | null | undefined;
     try { contextTokens = uiCtx?.getContextUsage()?.tokens; } catch { contextTokens = undefined; }
     const tokens = typeof contextTokens === "number" ? `${fmtTokens(contextTokens)} tok` : undefined;
+    const delegation = readDelegation();
     const bits = [
         effort ? `${model} ${effort}` : model,
-        tool ? `tool ${tool}` : undefined,
+        tool,
         tokens,
+        delegation.source === "session" ? `${delegation.mode} · session` : delegation.mode,
     ].filter((bit): bit is string => Boolean(bit));
     return {
         providerId: "subagents",
@@ -1210,15 +1222,43 @@ function mainAgentWorkRow(now: number): BackgroundWorkRow {
     };
 }
 
+function mainAgentWorkDetail(now: number): BackgroundWorkDetail {
+    const row = mainAgentWorkRow(now);
+    const delegation = readDelegation();
+    return {
+        providerId: "subagents",
+        id: "main",
+        title: "main",
+        status: row.status,
+        statusTone: row.statusTone,
+        subtitle: row.primary,
+        metadata: [
+            { label: "kind", value: "main agent" },
+            { label: "model", value: row.effort ? `${row.model} · effort ${row.effort}` : (row.model || "-") },
+            { label: "tool", value: row.tool || "-" },
+            { label: "context", value: row.tokens || "-" },
+            { label: "elapsed", value: row.elapsed },
+            { label: "mode", value: `${delegation.mode} · ${delegation.source}` },
+        ],
+        evidence: {
+            label: "delegation",
+            text: [
+                `${delegation.mode}: ${DELEGATION_BLURB[delegation.mode]}.`,
+                "m cycles this session. ctrl+s saves that mode as the next session's default.",
+                "x does not stop the main agent.",
+            ].filter(Boolean).join(" "),
+        },
+        footerActions: ["m mode", "ctrl+s save"],
+    };
+}
+
 function subagentWorkDetail(id: string, now: number, options?: { logTailLines?: number }): BackgroundWorkDetail | null {
+    if (id === "main") return mainAgentWorkDetail(now);
     const detail = navigatorDetail(id, now);
     if (!detail) return null;
     void options;
     const transcript = readRunTranscript(id);
-    const view = failureView(id, readMeta(id)?.cwd ?? "", detail.status !== "running" && detail.status !== "orphaned");
-    const failure = view.text;
     const metadata = [
-        ...(failure ? [{ label: "failure", value: failure.split("\n")[0]! }] : []),
         { label: "provider", value: "Subagents" },
         { label: "id", value: detail.id },
         ...(detail.role ? [{ label: "role", value: String(detail.role) }] : []),
@@ -1235,11 +1275,11 @@ function subagentWorkDetail(id: string, now: number, options?: { logTailLines?:
         title: detail.name || detail.id,
         status: detail.status,
         statusTone: statusTone(detail.status),
-        subtitle: (view.actionable && failure.split("\n")[0]) || (detail.currentTool ? `current tool ${detail.currentTool}` : undefined),
+        subtitle: detail.currentTool || undefined,
         metadata,
-        evidence: { label: "transcript", text: prependFailureSummary(detail.output || "(no transcript yet)", failure) },
+        evidence: { label: "transcript", text: detail.output || "(no transcript yet)" },
         transcript: transcript.entries,
-        transcriptDiagnostic: failure ? prependFailureSummary(transcript.diagnostic ?? "", failure) : transcript.diagnostic,
+        transcriptDiagnostic: transcript.diagnostic,
         footerActions: [detail.status === "running" || detail.status === "orphaned" ? "x stop" : "x dismiss"],
     };
 }
@@ -1307,6 +1347,16 @@ function ensureSubagentProvider(): void {
         parentRow: (now) => mainAgentWorkRow(now),
         listRows: (now) => subagentWorkRows(now),
         detail: (id, now, options) => subagentWorkDetail(id, now, options),
+        handleDetailInput: (id, data) => {
+            if (id !== "main") return false;
+            if (data === "m") {
+                cycleDelegation();
+                return true;
+            }
+            if (data !== "ctrl+s") return false;
+            saveDelegationDefault(readDelegation().mode);
+            return true;
+        },
         armCloseLabel: (row) => row.status === "running" || row.status === "orphaned" ? "x again to stop" : "x again to dismiss",
         close: (id) => {
             const outcome = navigatorCloseRun(id) as { action: string; id: string; status?: string };
@@ -1449,15 +1499,70 @@ function catalogRoleSchema(purpose: string) {
 
 export default function (pi: ExtensionAPI) {
     let delegationOverride: DelegationMode | undefined;
+    let capOverride: number | undefined;
+    const activeConcurrencyCap = (): number => capOverride ?? normalizeConcurrencyCap(loadConfig().maxConcurrent);
+    const changeCap = (cap: number): void => {
+        if (!isConcurrencyCap(cap)) throw new Error("Concurrent subagents must be a positive whole number.");
+        capOverride = cap;
+        pi.appendEntry("pi-better-subagents-cap", { version: 1, maxConcurrent: cap });
+    };
+    const changeMode = (mode: DelegationMode): void => {
+        delegationOverride = mode;
+        pi.appendEntry("pi-better-subagents-delegation", { version: 1, mode });
+    };
+    const resetSettings = (): void => {
+        capOverride = undefined;
+        delegationOverride = undefined;
+        pi.appendEntry("pi-better-subagents-cap", { version: 1, maxConcurrent: null });
+        pi.appendEntry("pi-better-subagents-delegation", { version: 1, mode: null });
+    };
     const activeDelegationMode = (): DelegationMode => delegationOverride ?? normalizeDelegationMode(loadConfig().delegationMode);
+    const saveSettings = (): { ok: boolean; message: string } => {
+        try {
+            writeSubagentSettings({ delegationMode: activeDelegationMode(), maxConcurrent: activeConcurrencyCap() });
+            resetSettings();
+            return { ok: true, message: "Subagent defaults saved." };
+        } catch (error) {
+            return { ok: false, message: `Could not save subagent defaults: ${error instanceof Error ? error.message : String(error)}` };
+        }
+    };
+    readDelegation = () => ({
+        mode: activeDelegationMode(),
+        source: delegationOverride ? "session" : "config",
+    });
+    cycleDelegation = () => {
+        const current = activeDelegationMode();
+        const next = DELEGATION_MODES[(DELEGATION_MODES.indexOf(current) + 1) % DELEGATION_MODES.length]!;
+        changeMode(next);
+    };
+    saveDelegationDefault = (mode) => {
+        try {
+            writeDelegationMode(mode);
+        } catch (error) {
+            return { ok: false, message: `Could not save the delegation default: ${error instanceof Error ? error.message : String(error)}` };
+        }
+        delegationOverride = undefined;
+        pi.appendEntry("pi-better-subagents-delegation", { version: 1, mode: null });
+        return { ok: true, message: `Delegation default saved: ${mode}.` };
+    };
     const restoreDelegationMode = (ctx: ExtensionContext): void => {
         delegationOverride = undefined;
+        capOverride = undefined;
         const branch = ctx.sessionManager?.getBranch?.();
         if (!Array.isArray(branch)) return;
         for (const entry of branch) {
+            if (entry.type === "custom" && entry.customType === "pi-better-subagents-cap") {
+                const data = entry.data as { version?: unknown; maxConcurrent?: unknown } | null;
+                if (data?.version === 1) {
+                    if (data.maxConcurrent === null) capOverride = undefined;
+                    else if (isConcurrencyCap(data.maxConcurrent)) capOverride = data.maxConcurrent;
+                }
+            }
             if (entry.type !== "custom" || entry.customType !== "pi-better-subagents-delegation") continue;
             const data = entry.data as { version?: unknown; mode?: unknown } | null;
-            if (data?.version === 1 && isDelegationMode(data.mode)) delegationOverride = data.mode;
+            if (data?.version !== 1) continue;
+            if (data.mode === null) delegationOverride = undefined;
+            else if (isDelegationMode(data.mode)) delegationOverride = data.mode;
         }
     };
     const unsubscribeDelegationRequest = pi.events?.on?.(DELEGATION_MODE_REQUEST, (data: unknown) => {
@@ -1836,8 +1941,7 @@ export default function (pi: ExtensionAPI) {
             const blankSelector = blankCatalogSelector(p);
             if (blankSelector) throw new Error(blankSelector);
 
-            const cfg = loadConfig();
-            const maxConcurrent = cfg.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+            const maxConcurrent = activeConcurrencyCap();
             const countRunning = () =>
                 listActiveMetasForParent(process.pid).filter((m) => effectiveStatus(m) === "running").length;
             // Shared with batch-spawn: reserve before any async work so an interleaved
@@ -1857,7 +1961,7 @@ export default function (pi: ExtensionAPI) {
                 }
                 if (catalog.jobs.length > 1) {
                     const extra = catalog.jobs.length - 1;
-                    if (extra > 0 && !gate.tryReserve(extra, maxConcurrent)) {
+                    if (extra > 0 && !gate.tryReserve(extra, activeConcurrencyCap())) {
                         gate.release(1);
                         reserved = 0;
                         throw new Error(`Choosing split needs ${catalog.jobs.length} subagent slots, but only one was free. Nothing was launched.`);
@@ -1975,7 +2079,6 @@ export default function (pi: ExtensionAPI) {
             };
 
             const cfg = loadConfig();
-            const maxConcurrent = cfg.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
             const countRunning = () =>
                 listActiveMetasForParent(process.pid).filter((m) => effectiveStatus(m) === "running").length;
             const launchAvailable = p.onCapacity === "launch-available";
@@ -2018,6 +2121,7 @@ export default function (pi: ExtensionAPI) {
             // until each job commits (or the unused remainder is released) closes the
             // interleaving oversubscribe class — a stale plan alone is not enough.
             if (!launchAvailable) {
+                const maxConcurrent = activeConcurrencyCap();
                 // planBatchLaunches still produces the public error text (incl. pending).
                 planBatchLaunches({
                     jobs: p.jobs,
@@ -2053,7 +2157,7 @@ export default function (pi: ExtensionAPI) {
                 const merged = mergeJobOptions(p.shared, job);
 
                 if (launchAvailable) {
-                    if (!gate.tryReserve(1, maxConcurrent)) {
+                    if (!gate.tryReserve(1, activeConcurrencyCap())) {
                         for (let j = i; j < p.jobs.length; j++) {
                             skipped.push({ job: j + 1, name: names[j] });
                         }
@@ -2166,22 +2270,53 @@ export default function (pi: ExtensionAPI) {
     if (typeof pi.registerCommand === "function") {
         agentOperations.registerCommands(pi);
         pi.registerCommand("subagents", {
-            description: "Show or change the current-session delegation mode",
+            description: "[settings|mode manual|adaptive|coordinator|cap <number>|save|reset] — Subagent settings",
             getArgumentCompletions: subagentsArgumentCompletions,
             async handler(args, ctx) {
                 const tokens = args.trim().split(/\s+/).filter(Boolean);
-                if (tokens.length === 0) {
-                    ctx.ui.notify(`Delegation mode: ${activeDelegationMode()}.`, "info");
+                if (tokens.length === 0 || (tokens.length === 1 && tokens[0] === "settings")) {
+                    if (ctx.mode === "tui" && ctx.hasUI && typeof ctx.ui.custom === "function") {
+                        await ctx.ui.custom<void>((tui, theme, _kb, done) => createSubagentSettingsPage(theme, {
+                            get: () => ({
+                                mode: activeDelegationMode(), maxConcurrent: activeConcurrencyCap(),
+                                modeSource: delegationOverride ? "session" : "config",
+                                capSource: capOverride !== undefined ? "session" : "config",
+                                defaultMode: normalizeDelegationMode(loadConfig().delegationMode),
+                                defaultCap: normalizeConcurrencyCap(loadConfig().maxConcurrent),
+                            }),
+                            changeMode, changeCap, save: saveSettings, reset: resetSettings,
+                        }, () => { refreshBackgroundWorkNavigator(ctx); tui.requestRender(); }, () => done()));
+                    } else {
+                        ctx.ui.notify(`Delegation mode: ${activeDelegationMode()}. Concurrent subagents: ${activeConcurrencyCap()}. Use /subagents mode <mode> or /subagents cap <number>; /subagents save persists both.`, "info");
+                    }
                     return;
                 }
                 const requested = tokens[1];
-                if (tokens.length === 2 && tokens[0] === "mode" && isDelegationMode(requested)) {
-                    delegationOverride = requested;
-                    pi.appendEntry("pi-better-subagents-delegation", { version: 1, mode: delegationOverride });
-                    ctx.ui.notify(`Delegation mode: ${delegationOverride} (current session).`, "info");
+                if (tokens.length === 1 && tokens[0] === "save") {
+                    if (ctx.hasUI && !(await ctx.ui.confirm("Save subagent defaults?", `Future sessions will start in ${activeDelegationMode()} with a cap of ${activeConcurrencyCap()}.`))) {
+                        ctx.ui.notify("Subagent defaults unchanged.", "info");
+                        return;
+                    }
+                    const saved = saveSettings();
+                    ctx.ui.notify(saved.message, saved.ok ? "info" : "warning");
+                } else if (tokens.length === 1 && tokens[0] === "reset") {
+                    resetSettings();
+                    ctx.ui.notify("Session subagent settings reset to saved defaults.", "info");
+                } else if (tokens.length === 2 && tokens[0] === "mode" && isDelegationMode(requested)) {
+                    changeMode(requested);
+                    ctx.ui.notify(`Delegation mode: ${activeDelegationMode()} (current session).`, "info");
+                } else if (tokens.length === 2 && tokens[0] === "cap") {
+                    const cap = /^\d+$/.test(requested!) ? Number(requested) : NaN;
+                    if (!isConcurrencyCap(cap)) {
+                        ctx.ui.notify("Concurrent subagents must be a positive whole number. Nothing changed.", "warning");
+                        return;
+                    }
+                    changeCap(cap);
+                    ctx.ui.notify(`Concurrent subagents: ${cap} (current session). Running subagents are unchanged.`, "info");
                 } else {
-                    ctx.ui.notify("Usage: /subagents [mode manual|adaptive|coordinator]", "warning");
+                    ctx.ui.notify("Usage: /subagents [settings|mode manual|adaptive|coordinator|cap <number>|save|reset]", "warning");
                 }
+                refreshBackgroundWorkNavigator(ctx);
             },
         });
     }

package/navigator.mjs

@@ -543,7 +543,6 @@ export function buildDetailLines(detail, opts = {}) {
             const bits = [];
             if (c.last.reason) bits.push(c.last.reason);
             if (c.last.aborted) bits.push("aborted");
-            if (c.last.errorMessage) bits.push(c.last.errorMessage);
             if (bits.length) lines.push(`   last ${bits.join(" · ")}`);
         }
     } else {
@@ -566,28 +565,17 @@ export function buildDetailLines(detail, opts = {}) {
         lines.push("   idle");
     }
 
-    // Model call / error, separate from tool state.
+    // Model activity only; incident summaries stay in result tools and logs.
     lines.push(sectionRule("model", width));
     if (h?.model) {
         const m = h.model;
-        lines.push(`   state ${m.state}`);
-        if (m.listWarning) lines.push(`   warning ${m.listWarning}`);
+        if (m.state !== "error") lines.push(`   state ${m.state}`);
+        if (m.state !== "error" && m.listWarning) lines.push(`   warning ${m.listWarning}`);
         if (m.retry) {
             const a = m.retry.attempt != null ? String(m.retry.attempt) : "?";
             const max = m.retry.maxAttempts != null ? String(m.retry.maxAttempts) : "?";
             lines.push(`   retry ${a}/${max}`);
         }
-        if (m.lastError) {
-            const age = m.lastError.at != null ? ` · ${fmtDetailTs(m.lastError.at, now)}` : "";
-            lines.push(`   last error ${m.lastError.message}${age}`);
-        }
-        if (Array.isArray(m.errorHistory) && m.errorHistory.length > 0) {
-            const recent = m.errorHistory.slice(-3);
-            for (const e of recent) {
-                const age = e.at != null ? ` · ${fmtDetailTs(e.at, now)}` : "";
-                lines.push(`   history ${e.message}${age}`);
-            }
-        }
         if (m.longModelCall) {
             const age = m.longModelCall.ageMs != null ? ` · ${fmtDetailAge(m.longModelCall.ageMs)}` : "";
             lines.push(`   long call${age}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-subagents",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Pi extension for detached, sandboxed subagent runs that keep the foreground session free.",
   "license": "MIT",
   "type": "module",

package/settings-page.ts

@@ -0,0 +1,128 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import * as Tui from "@earendil-works/pi-tui";
+import { isConcurrencyCap } from "./config.ts";
+import { DELEGATION_MODES, type DelegationMode } from "./delegation.ts";
+
+export interface SubagentSettingsSnapshot {
+    mode: DelegationMode;
+    maxConcurrent: number;
+    modeSource: "session" | "config";
+    capSource: "session" | "config";
+    defaultMode: DelegationMode;
+    defaultCap: number;
+}
+
+export interface SubagentSettingsHandlers {
+    get(): SubagentSettingsSnapshot;
+    changeMode(mode: DelegationMode): void;
+    changeCap(cap: number): void;
+    save(): { ok: boolean; message: string };
+    reset(): void;
+}
+
+const labels = ["Delegation mode", "Concurrent subagents", "Save as defaults", "Reset to defaults"];
+
+export function createSubagentSettingsPage(
+    theme: Theme,
+    handlers: SubagentSettingsHandlers,
+    requestRender: () => void,
+    close: () => void,
+): Tui.Component & Tui.Focusable {
+    const input = new Tui.Input();
+    let focused = false;
+    let row = 0;
+    let editing = false;
+    let message = "";
+    let error = false;
+    function report(text: string, failed = false): void {
+        message = text;
+        error = failed;
+        requestRender();
+    }
+    function action(): void {
+        try {
+            const settings = handlers.get();
+            if (row === 0) {
+                const next = DELEGATION_MODES[(DELEGATION_MODES.indexOf(settings.mode) + 1) % DELEGATION_MODES.length]!;
+                handlers.changeMode(next);
+                report("Session mode updated.");
+            } else if (row === 1) {
+                editing = true;
+                input.setValue(String(settings.maxConcurrent));
+                input.handleInput("\x05");
+                input.focused = focused;
+                report("");
+            } else if (row === 2) {
+                const result = handlers.save();
+                report(result.message, !result.ok);
+            } else {
+                handlers.reset();
+                report("Session settings reset to saved defaults.");
+            }
+        } catch (cause) {
+            report(cause instanceof Error ? cause.message : String(cause), true);
+        }
+    }
+    input.onSubmit = (value) => {
+        const cap = /^\d+$/.test(value.trim()) ? Number(value.trim()) : NaN;
+        if (!isConcurrencyCap(cap)) {
+            report("Enter a positive whole number.", true);
+            return;
+        }
+        try {
+            handlers.changeCap(cap);
+            editing = false;
+            input.focused = false;
+            report("Session cap updated.");
+        } catch (cause) {
+            report(cause instanceof Error ? cause.message : String(cause), true);
+        }
+    };
+    input.onEscape = () => {
+        editing = false;
+        input.focused = false;
+        report("");
+    };
+    return {
+        get focused() { return focused; },
+        set focused(value: boolean) { focused = value; input.focused = editing && value; },
+        invalidate() { input.invalidate(); },
+        handleInput(data: string) {
+            if (editing) {
+                input.handleInput(data);
+                requestRender();
+                return;
+            }
+            if (Tui.matchesKey(data, Tui.Key.escape)) close();
+            else if (Tui.matchesKey(data, Tui.Key.up)) row = Math.max(0, row - 1);
+            else if (Tui.matchesKey(data, Tui.Key.down)) row = Math.min(labels.length - 1, row + 1);
+            else if (Tui.matchesKey(data, Tui.Key.enter) || data === " ") action();
+            else if (Tui.matchesKey(data, "ctrl+s")) {
+                const selected = row;
+                row = 2;
+                action();
+                row = selected;
+            }
+            requestRender();
+        },
+        render(width: number) {
+            const settings = handlers.get();
+            const values = [
+                `${settings.mode} (${settings.modeSource})`,
+                `${settings.maxConcurrent} (${settings.capSource})`,
+                "",
+                "",
+            ];
+            const lines = [theme.fg("accent", theme.bold("Subagent settings")), ""];
+            labels.forEach((label, index) => {
+                const text = `${index === row ? ">" : " "} ${label}${values[index] ? `: ${values[index]}` : ""}`;
+                lines.push(index === row ? theme.fg("accent", theme.bold(text)) : text);
+            });
+            if (editing) lines.push("", ...input.render(Math.max(1, width)));
+            lines.push("", theme.fg("muted", `Saved defaults: ${settings.defaultMode}, cap ${settings.defaultCap}`));
+            if (message) lines.push(theme.fg(error ? "error" : "success", message));
+            lines.push("", theme.fg("dim", editing ? "Enter apply  Esc cancel" : "Up/Down select  Enter change  Ctrl+S save  Esc close"));
+            return lines.map((line) => Tui.truncateToWidth(line, Math.max(1, width), ""));
+        },
+    };
+}

package/shared-navigator.ts

@@ -66,6 +66,8 @@ export type BackgroundWorkProvider = {
   detail(id: string, now: number, options?: { logTailLines?: number }): BackgroundWorkDetail | null;
   armCloseLabel(row: BackgroundWorkRow): string;
   close(id: string): BackgroundWorkCloseOutcome;
+  /** Return true when this detail handled the key. The navigator refreshes the sheet. */
+  handleDetailInput?(id: string, data: string): boolean;
   onVisibleChanged?(notify: () => void): () => void;
 };
 
@@ -559,7 +561,7 @@ function rowSummary(row: InternalRow): string {
     const parts: string[] = [];
     if (row.statusTone !== "running" && row.kind !== "main agent") parts.push(singleLine(row.status));
     if (row.model) parts.push(row.effort ? `${singleLine(row.model)} ${singleLine(row.effort)}` : singleLine(row.model));
-    if (row.tool) parts.push(`tool ${singleLine(row.tool)}`);
+    if (row.tool) parts.push(singleLine(row.tool));
     if (row.tokens) parts.push(singleLine(row.tokens));
     else if (row.primary) parts.push(singleLine(row.primary));
     if (parts.length) return parts.join(" · ");
@@ -703,12 +705,7 @@ function handleMainListInput(data: string, deps: HostDeps): boolean {
     return true;
   }
   if (deps.matchKey(data, "enter")) {
-    const selected = selectedMainListRow();
-    if (selected?.parentRow) {
-      unfocusMainList();
-      dismissOverlay();
-    }
-    else openNavigator();
+    openNavigator();
     return true;
   }
   if (data === "x" || data === "X" || deps.matchKey(data, "x") || deps.matchKey(data, "X")) {
@@ -851,7 +848,8 @@ function createOverlayComponent(
   let logTailRows: number = DEFAULT_LOG_TAIL_ROWS;
   const expandedSections = new Set<string>();
   let detailId: string = initialDetailId;
-  let detail: BackgroundWorkDetail | null = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? null;
+  const initialRow = initialRows.find((row) => row.navigatorId === detailId);
+  let detail: BackgroundWorkDetail | null = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? (initialRow ? fallbackDetail(initialRow) : null);
   applyDefaultExpandedSections(detail, expandedSections);
   {
     const idx = overlayState.rows.findIndex((row) => row.navigatorId === detailId);
@@ -891,8 +889,7 @@ function createOverlayComponent(
   }
 
   function activateSelectedRow(): void {
-    if (selectedRow()?.parentRow) close();
-    else openDetail();
+    openDetail();
   }
 
   function clearCloseArm(): void {
@@ -922,10 +919,6 @@ function createOverlayComponent(
   function openDetail(): void {
     const row = selectedRow();
     if (!row) return;
-    if (row.parentRow) {
-      close();
-      return;
-    }
     clearCloseArm();
     detailId = row.navigatorId;
     expandedSections.clear();
@@ -1073,6 +1066,15 @@ function createOverlayComponent(
           requestRender();
         }
       }
+      else if (data === "m" || data === "M" || data === "\x13" || deps.matchKey(data, "ctrl+s")) {
+        const row = selectedRow();
+        const provider = row ? state().providers.get(row.providerId) : undefined;
+        const key = data === "m" || data === "M" ? "m" : "ctrl+s";
+        if (!row || !provider?.handleDetailInput?.(row.id, key)) return;
+        detail = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? detail;
+        refreshMainListWidget();
+        requestRender();
+      }
       else if (data === "l" || data === "L") {
         logTailRows = cycleLogTailRows(logTailRows);
         if (detailId) detail = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? detail;
@@ -1091,8 +1093,7 @@ function createOverlayComponent(
       if (idx < 0) return;
       overlayState.selected = idx;
       state().mainListSelectedId = navigatorId;
-      if (overlayState.rows[idx]!.parentRow) close();
-      else openDetail();
+      openDetail();
     },
     /** Close the overlay (done), e.g. when the navigator is disposed. */
     dismiss() { close(); },
@@ -1150,7 +1151,11 @@ function buildTranscriptDetailLines(
     ...detail.metadata.map((item) => `   ${item.label.padEnd(8, " ").slice(0, 8)} ${item.value}`),
   ];
   const transcriptHeader = ["", dim(section(`transcript · latest ${tailRows} rows`, width), fg)];
-  if (detail.transcriptDiagnostic) transcriptHeader.push(`   ${dim(detail.transcriptDiagnostic, fg)}`);
+  if (detail.transcriptDiagnostic) {
+    for (const diagnosticRow of detail.transcriptDiagnostic.split(/\r\n|\r|\n/)) {
+      transcriptHeader.push(`   ${dim(diagnosticRow, fg)}`);
+    }
+  }
   // Metadata always renders; the transcript tail takes only the rows left over (the tail size is a cap, not a guarantee).
   lines.push(...optionalMetadata);
   if (options.maxRows !== undefined) {

package/shared-task-sandbox.ts

@@ -6,6 +6,8 @@ const { createBashToolDefinition, createReadToolDefinition, createWriteToolDefin
     createEditToolDefinition, createLocalBashOperations, getShellConfig } = PiCodingAgent;
 import { pathToFileURL } from "node:url";
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { unlink } from "node:fs/promises";
 import { accessSync, constants, lstatSync, mkdirSync, mkdtempSync, readlinkSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, parse, resolve, sep } from "node:path";
@@ -117,42 +119,51 @@ export function createTaskBashOperations(
             const scratch = plan.policy.runtimeWrite?.[0];
             const taskEnv = { ...process.env, ...options.env,
                 ...(scratch ? { TMPDIR: scratch, TMP: scratch, TEMP: scratch } : {}) };
-            const wrapped = maybeBuildSandboxCommand({
-                policy: plan.policy, profilePath: plan.profilePath,
-                execPath: "/usr/bin/env", execArgs: ["-i", "--", ...Object.entries(taskEnv)
-                    .filter((entry): entry is [string, string] => entry[1] !== undefined)
-                    .map(([key, value]) => `${key}=${value}`), shell.shell, ...shell.args, command],
-            }, { sandboxEnabled: true, explicitSandbox: true });
-            if (!wrapped) throw new Error("Sandbox: no task execution backend is available.");
-            for (const line of wrapped.notices ?? []) options.onData(Buffer.from(`${line}\n`));
             if (options.signal?.aborted) throw new Error("aborted");
             if (options.timeout !== undefined && (!Number.isFinite(options.timeout) || options.timeout <= 0 || options.timeout * 1000 > 2147483647)) {
                 throw new Error("Invalid timeout: must be a positive, supported number of seconds");
             }
-            // No shell or caller-controlled loader environment runs before the boundary.
-            return new Promise((resolve, reject) => {
-                const child = spawn(wrapped.file, wrapped.fileArgs, { cwd, detached: true,
-                    env: { PATH: "/usr/bin:/bin", HOME: plan.policy.home }, stdio: ["ignore", "pipe", "pipe"] });
-                let timedOut = false;
-                const kill = () => { if (child.pid) { try { process.kill(-child.pid, "SIGKILL"); } catch { child.kill("SIGKILL"); } } };
-                const timer = options.timeout === undefined ? undefined : setTimeout(() => { timedOut = true; kill(); }, options.timeout * 1000);
-                if (child.pid) trackDetachedChildPid(child.pid);
-                const cleanup = () => {
-                    if (child.pid) untrackDetachedChildPid(child.pid);
-                    if (timer) clearTimeout(timer);
-                    options.signal?.removeEventListener("abort", kill);
-                };
-                child.stdout.on("data", options.onData);
-                child.stderr.on("data", options.onData);
-                options.signal?.addEventListener("abort", kill, { once: true });
-                if (options.signal?.aborted) kill();
-                void waitForChildProcess(child).then((exitCode: number | null) => {
-                    cleanup();
-                    if (options.signal?.aborted) reject(new Error("aborted"));
-                    else if (timedOut) reject(new Error(`timeout:${options.timeout}`));
-                    else resolve({ exitCode });
-                }, (error: unknown) => { cleanup(); reject(error); });
-            });
+            // A sibling launch must never rewrite a profile another process is reading.
+            const profilePath = `${plan.profilePath}.${randomUUID()}.bash.sb`;
+            try {
+                const wrapped = maybeBuildSandboxCommand({
+                    policy: plan.policy, profilePath,
+                    execPath: "/usr/bin/env", execArgs: ["-i", "--", ...Object.entries(taskEnv)
+                        .filter((entry): entry is [string, string] => entry[1] !== undefined)
+                        .map(([key, value]) => `${key}=${value}`), shell.shell, ...shell.args, command],
+                }, { sandboxEnabled: true, explicitSandbox: true });
+                if (!wrapped) throw new Error("Sandbox: no task execution backend is available.");
+                for (const line of wrapped.notices ?? []) options.onData(Buffer.from(`${line}\n`));
+                if (options.signal?.aborted) throw new Error("aborted");
+                // No shell or caller-controlled loader environment runs before the boundary.
+                return await new Promise<{ exitCode: number | null }>((resolve, reject) => {
+                    const child = spawn(wrapped.file, wrapped.fileArgs, { cwd, detached: true,
+                        env: { PATH: "/usr/bin:/bin", HOME: plan.policy.home }, stdio: ["ignore", "pipe", "pipe"] });
+                    let timedOut = false;
+                    const kill = () => { if (child.pid) { try { process.kill(-child.pid, "SIGKILL"); } catch { child.kill("SIGKILL"); } } };
+                    const timer = options.timeout === undefined ? undefined : setTimeout(() => { timedOut = true; kill(); }, options.timeout * 1000);
+                    if (child.pid) trackDetachedChildPid(child.pid);
+                    const cleanup = () => {
+                        if (child.pid) untrackDetachedChildPid(child.pid);
+                        if (timer) clearTimeout(timer);
+                        options.signal?.removeEventListener("abort", kill);
+                    };
+                    child.stdout.on("data", options.onData);
+                    child.stderr.on("data", options.onData);
+                    options.signal?.addEventListener("abort", kill, { once: true });
+                    if (options.signal?.aborted) kill();
+                    void waitForChildProcess(child).then((exitCode: number | null) => {
+                        cleanup();
+                        if (options.signal?.aborted) reject(new Error("aborted"));
+                        else if (timedOut) reject(new Error(`timeout:${options.timeout}`));
+                        else resolve({ exitCode });
+                    }, (error: unknown) => { cleanup(); reject(error); });
+                });
+            } finally {
+                await unlink(profilePath).catch((error: NodeJS.ErrnoException) => {
+                    if (error.code !== "ENOENT") throw error;
+                });
+            }
         },
     };
 }