@bastani/atomic 0.9.12 → 0.9.13-alpha.1

package/dist/builtin/subagents/README.md

@@ -162,9 +162,9 @@ Workflow invocations receive a stable, non-`default` Intercom group automaticall
 
 Foreground runs stream progress in the conversation while they run.
 
-Background runs keep working after control returns to you. The launch acknowledgement says `launched` and `completion pending`: the `subagent` launch tool call itself is finished, while the detached child is not. Inspect active runs with `subagent({ action: "status" })`, or a specific run with `subagent({ action: "status", id: "..." })`.
+`async: true` means **do not wait**. Atomic admits an in-process child, returns its canonical child path immediately, and tracks the live child through the jobs widget. **Async work does not survive parent exit:** the live child is owned by the parent process and ends when Atomic quits; only its canonical identity and session file remain for a later cold resume.
 
-They also show a compact async widget with the same launch/pending distinction and send completion notifications. Parallel background runs show per-agent progress instead of fake chain steps. Chains with parallel groups keep their grouped shape in progress and results, so failed or paused agents stay visible next to completed ones.
+The jobs widget shows the live status-watch state and sends one terminal completion notification. Parallel background runs show per-agent progress, and chains with parallel groups keep their grouped shape in progress and results. There is no detached runner process or PID polling loop.
 
 You can also ask naturally:
 
@@ -238,7 +238,7 @@ The child can use one dedicated coordination tool:
 
 - `contact_supervisor`: the child contacts the parent/supervisor session that delegated the task. Use `reason: "need_decision"` for blocking decisions or clarification, and `reason: "progress_update"` for short non-blocking updates when a discovery changes the plan. Do not ask for clarification when the only conflict is review-only/no-edit versus progress-writing or artifact-writing instructions; no-edit wins.
 
-Child-side routine completion handoffs are still not expected. With the intercom bridge active, parent-side `pi-subagents` sends grouped completion results through `pi-intercom`: one grouped message per foreground parent `subagent` run and one per completed async result file. Intercom-confirmed foreground delivery returns a compact receipt with artifact/session paths; without that confirmation, the normal full output is preserved. Grouped messages include child intercom targets and full child summaries. The separate in-process completion event keeps its legacy synchronous semantics: emission is accepted unless a listener explicitly rejects it during the call, and no listener is not treated as an error.
+Child-side routine completion handoffs are still not expected. With the intercom bridge active, parent-side Atomic sends grouped completion results through `pi-intercom`: one grouped message per foreground parent `subagent` run and one per completed async terminal result. Intercom-confirmed foreground delivery returns a compact receipt with artifact/session paths; without that confirmation, the normal full output is preserved. Grouped messages include child intercom targets and full child summaries.
 When the companion is enabled and available, the bridge gives eligible children deterministic Intercom identities and coordination tools without connecting them automatically. Parent and child connections remain tool-driven: if a child may need live coordination, the parent model should invoke `intercom({ action: "status" })` before launch, and the child connects when it invokes `contact_supervisor` or `intercom`. Foreground/background launch and management-only actions do not force Intercom loading or broker startup.
 
 For foreground runs, Intercom uses a targeted probe/reservation before delivery: only the exact live child can claim its message. Atomic then commits detach for that child and waits for its acknowledgement before placing claimed asks, sends, decisions, interviews, and progress updates in the parent's model-visible steering queue, so cancellation between phases cannot surface an orphaned request. Blocking calls remain alive for an exact threaded reply and then resume; fire-and-forget calls create no waiter. The retained child later replaces its detached status and artifacts with the real result. Cancellation/replacement invalidates stale handshakes, duplicate delivery cannot recommit, and background or unmatched messages retain queued-until-idle behavior.
@@ -344,7 +344,7 @@ You can combine them in either order:
 /run reviewer "review this diff" --bg --fork
 ```
 
-Background runs are detached. A successful acknowledgement explicitly means the run was launched and child completion is pending; it is a terminal result for the launch tool, not a claim that the child has finished. If the parent agent has other independent work, it should keep working. If it has nothing useful to do until the background result arrives, it should end the turn instead of running sleep or status-polling loops. Pi will deliver the completion when the run finishes.
+Background runs use the same in-process continuation as foreground detach. A successful acknowledgement means the canonical child path was returned and completion is pending; the live child remains owned by the parent process and the jobs widget tracks it. **`async: true` does not survive parent exit.** If the parent exits, the in-flight run ends; its persisted identity/session can be listed and resumed later.
 
 The `oracle` and `worker` builtins are designed for an explicit decision loop. A typical pattern is to ask `oracle` for diagnosis and a recommended execution prompt, then only run `worker` after the main agent approves that direction.
 
@@ -356,7 +356,7 @@ The human slash commands remain on their separate parsing and event-bridge path,
 
 ## Agents and chains
 
-Agents are markdown files with YAML frontmatter and a system prompt body. They define the specialist that will run in the child Atomic process.
+Agents are markdown files with YAML frontmatter and a system prompt body. They define the specialist that will run in a child Atomic session.
 
 Agent locations, lowest to highest priority:
 
@@ -837,7 +837,7 @@ subagent({ action: "resume", id: "<run-id>", index: 1, message: "follow-up for c
 subagent({ action: "doctor" })
 ```
 
-`resume` sends the follow-up directly when an async child is still reachable over intercom. After completion, it revives the child by starting a new async child from the stored child session file. Multi-child async runs and remembered foreground single, parallel, or chain runs can be revived by passing `index` to choose the child. Revive starts a new child process from the old session context; it does not restart the same OS process, and it requires the chosen child to have a persisted `.jsonl` session file.
+`resume` sends the follow-up directly when a child is still reachable. After completion or eviction, it cold-reloads the same canonical child identity from the stored session file. Multi-child async runs and remembered foreground single, parallel, or chain runs can be revived by passing `index` to choose the child; no new OS process is created.
 
 ## Worktree isolation
 
@@ -919,7 +919,7 @@ Session directory precedence is: `params.sessionDir`, then `config.defaultSessio
 { "maxSubagentDepth": 1 }
 ```
 
-Controls nested delegation when no inherited `ATOMIC_SUBAGENT_MAX_DEPTH` (or legacy `PI_SUBAGENT_MAX_DEPTH`) is already in effect. Accepted values are `0` through `5`; higher values are clamped to the hard ceiling. Per-agent `maxSubagentDepth` can tighten the limit for that agent’s child runs, but cannot relax an inherited stricter limit.
+Controls nested delegation through typed admission policy. Accepted values are `0` through `5`; higher values are refused at the hard ceiling. Per-agent `maxSubagentDepth` can tighten the limit for that agent’s child runs, but cannot relax an inherited stricter limit.
 
 ### `intercomBridge`
 
@@ -979,25 +979,24 @@ Debug artifacts live under `{sessionDir}/subagent-artifacts/` or a user-scoped t
 - `{runId}_{agent}.jsonl`
 - `{runId}_{agent}_meta.json`
 
-Metadata records timing, usage, exit code, final model, attempted models, and fallback attempt outcomes.
+Metadata records timing, usage, typed status, termination cause, final model, attempted models, and fallback attempt outcomes.
 
-Session files are stored under a per-run session directory. With `context: "fork"`, each child starts with `--session <branched-session-file>` produced from the parent’s current leaf. That is a real session fork, not an injected summary.
+Session files are stored under a per-run session directory. With `context: "fork"`, each child starts from the parent’s current leaf through the session manager; this is a real session fork, not an injected summary.
 
-Async completions notify only the originating session. The result watcher emits `subagent:async-complete`, and the extension consumes that event to render completion notifications.
+Async completions notify only the originating session. The in-process status watch emits live lifecycle updates, and the extension consumes the terminal event to render completion notifications.
 
-Async runs write:
+Async runs persist their durable session and user-facing artifacts beside the parent session:
 
 ```text
-<tmpdir>/atomic-subagents-<scope>/async-subagent-runs/<id>/
-  status.json
-  events.jsonl
-  output-<n>.log
-  subagent-log-<id>.md
+{parent-session-dir}/subagent-artifacts/
+  {runId}_{agent}_input.md
+  {runId}_{agent}_output.md
+  {runId}_{agent}.jsonl
+  {runId}_{agent}_meta.json
+  run-history.jsonl
 ```
 
-`status.json` powers the widget and `subagent({ action: "status" })` output. `events.jsonl` contains wrapper events plus bounded child telemetry annotated with run and step metadata: streaming deltas keep compact incremental metadata rather than cumulative partial-message snapshots, and raw child stdout/stderr consume the same byte budget. One truncation marker records exhaustion, while the full finalized `message_end` and later control/lifecycle/terminal events remain available. Writer reacquisition uses a bounded identity/fingerprint cache so unchanged or append-only journals avoid full rescans while same-inode rewrites, truncate/regrow cycles, replacements, and externally appended markers reset state correctly. `output-<n>.log` is a live human-readable tail. Fallback information is persisted so background runs are debuggable after completion.
-
-The result watcher waits for modern run status to become terminal using capped exponential rechecks, so a late repaired status still delivers without a fixed-rate polling loop. Intercom confirmation and local synchronous acceptance are tracked as separate phases; a successful phase is not replayed when another phase retries or the watcher is replaced. Equivalent result aliases coalesce by canonical run identity, but aliases with different user-visible output or parent targets are retained under collision-resistant names in the non-scanned `<results>/.undelivered/` directory. The same directory retains a still-owned result after a finite no-progress retry budget, and Atomic logs the retained path instead of retrying forever, overwriting earlier evidence, or deleting the payload.
+The Rust registry and status watch power the widget and `subagent({ action: "status" })` output. Terminal delivery is an in-memory bounded envelope persisted once with typed `status`, `cause`, and `stats`; there is no `status.json`, `events.jsonl`, PID reconciler, result watcher, or claim pipeline.
 
 ## Completion and output
 
@@ -1039,17 +1038,10 @@ By default, nesting is capped at five delegated subagent levels below the main s
 
 Configure a lower or equal limit with:
 
-1. `ATOMIC_SUBAGENT_MAX_DEPTH` (or legacy `PI_SUBAGENT_MAX_DEPTH`) before starting Atomic; values above `5` are clamped to `5`
-2. `config.maxSubagentDepth`
-3. `maxSubagentDepth` in agent frontmatter, which can only tighten the inherited limit
-
-```bash
-export ATOMIC_SUBAGENT_MAX_DEPTH=5
-export ATOMIC_SUBAGENT_MAX_DEPTH=3
-export ATOMIC_SUBAGENT_MAX_DEPTH=0
-```
+1. `config.maxSubagentDepth`
+2. `maxSubagentDepth` in agent frontmatter, which can only tighten the admitted limit
 
-`ATOMIC_SUBAGENT_DEPTH` is internal and propagated automatically. Do not set it manually. Legacy `PI_SUBAGENT_MAX_DEPTH` and `PI_SUBAGENT_DEPTH` are still read for compatibility.
+The depth policy is typed admission state and is not inherited through an environment variable.
 
 ## Events
 
@@ -1063,7 +1055,7 @@ Intercom delivery events:
 - `subagent:control-intercom`
 - `subagent:result-intercom`
 
-The result watcher emits `subagent:async-complete`; `src/extension/index.ts` registers the notification handler that consumes it. Control/attention events are surfaced as visible parent notices and persisted for async runs. With `pi-intercom`, needs-attention notices and grouped parent-side subagent result deliveries can reach the orchestrator over intercom.
+The in-process status watch emits `subagent:async-complete`; `src/extension/index.ts` registers the notification handler that consumes it. Control/attention events are surfaced as visible parent notices, and typed terminal records carry the canonical path, status, cause, and session statistics. With `pi-intercom`, needs-attention notices and grouped parent-side subagent result deliveries can reach the orchestrator over intercom.
 
 ## Prompt-template integration
 

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.12",
+  "version": "0.9.13-alpha.1",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with chains, parallel execution, and background runs. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [

package/dist/builtin/subagents/src/extension/doctor.ts

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { type AgentSource, discoverAgentsAll } from "../agents/agents.ts";
 import { discoverAvailableSkills, type SkillSource } from "../agents/skills.ts";
 import { diagnoseIntercomBridge, type IntercomBridgeDiagnostic } from "../intercom/intercom-bridge.ts";
-import { isAsyncAvailable } from "../runs/background/async-execution.ts";
+import { isAsyncAvailable } from "../runs/inprocess/background.ts";
 import {
 	ASYNC_DIR,
 	CHAIN_RUNS_DIR,

package/dist/builtin/subagents/src/extension/fanout-child.ts

@@ -2,19 +2,20 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { ExtensionAPI, ToolDefinition } from "@bastani/atomic";
-import { APP_NAME, getEnvValue } from "@bastani/atomic";
+import { APP_NAME } from "@bastani/atomic";
 
 import { discoverAgents } from "../agents/agents.ts";
 import { resolveSubagentIntercomTarget } from "../intercom/intercom-bridge.ts";
 import { deliverSubagentIntercomMessageEvent } from "../intercom/result-intercom.ts";
 import { createSubagentExecutor, type SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
+import type { ChildModePolicy } from "../runs/inprocess/child-policy.ts";
+import { hasInProcessNestedRoute, subscribeInProcessControlRequests } from "../runs/inprocess/nested-routing.ts";
 import {
 	type NestedRoute,
 	readNestedControlRequests,
 	resolveNestedRouteFromEnv,
 	writeNestedControlResult,
-} from "../runs/shared/nested-events.ts";
-import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.ts";
+} from "../runs/inprocess/runtime-support/nested-api.ts";
 import { getArtifactsDir } from "../shared/artifacts.ts";
 import type { Details, SubagentState } from "../shared/types.ts";
 import { beginApiLifecycle } from "./api-lifecycle.ts";
@@ -63,8 +64,6 @@ const TRIMMED_SEEN_REQUEST_IDS = 512;
 const MAX_PENDING_RESULTS = 256;
 const MAX_PENDING_RESULT_ATTEMPTS = 10;
 const MAX_PENDING_RESULT_AGE_MS = 60_000;
-const NESTED_CONTROL_INBOX_TIMER_KEY = "fanout-child:nested-control-inbox";
-
 type NestedControlResultPayload = Parameters<typeof writeNestedControlResult>[1];
 
 interface PendingControlResult {
@@ -139,7 +138,15 @@ function buildNestedControlResult(
 	})();
 }
 
-export function startNestedControlInboxListener(pi: ExtensionAPI, state: SubagentState): NodeJS.Timeout | undefined {
+const nestedControlListenerCleanups = new WeakMap<ExtensionAPI, () => void>();
+
+export function stopNestedControlInboxListener(pi: ExtensionAPI): void {
+	nestedControlListenerCleanups.get(pi)?.();
+	nestedControlListenerCleanups.delete(pi);
+}
+
+export function startNestedControlInboxListener(pi: ExtensionAPI, state: SubagentState): (() => void) | undefined {
+	stopNestedControlInboxListener(pi);
 	let route: NestedRoute | undefined;
 	try {
 		route = resolveNestedRouteFromEnv();
@@ -150,70 +157,82 @@ export function startNestedControlInboxListener(pi: ExtensionAPI, state: Subagen
 	const seen = new Set<string>();
 	const inFlight = new Set<string>();
 	const pendingResults = new Map<string, PendingControlResult>();
-	const timer = setInterval(() => {
-		try {
-			for (const request of readNestedControlRequests(route)) {
-				if (seen.has(request.requestId) || inFlight.has(request.requestId)) continue;
-				inFlight.add(request.requestId);
-				void (async () => {
-					try {
-						const pending = pendingResults.get(request.requestId);
-						const result = pending?.result ?? (await buildNestedControlResult(pi, state, request));
-						try {
-							writeNestedControlResult(route, result);
-						} catch (error) {
-							const now = Date.now();
-							const nextPending: PendingControlResult = {
-								result,
-								firstFailureAt: pending?.firstFailureAt ?? now,
-								attempts: (pending?.attempts ?? 0) + 1,
-							};
-							pendingResults.set(request.requestId, nextPending);
-							if (shouldDropPendingResult(nextPending, pendingResults.size, now)) {
-								pendingResults.delete(request.requestId);
-								rememberSeenRequest(seen, request.requestId);
-								dropControlRequestFile(request.filePath, request.requestId);
-								console.error(
-									`Dropping nested control result for request '${request.requestId}' targeting '${request.targetRunId}' after ${nextPending.attempts} failed write attempts via inbox '${route.controlInbox}':`,
-									error,
-								);
-							} else if (nextPending.attempts === 1) {
-								console.error(
-									`Failed to write nested control result for request '${request.requestId}' targeting '${request.targetRunId}' via inbox '${route.controlInbox}'; keeping request for retry:`,
-									error,
-								);
-							}
-							return;
-						}
+	const processRequest = (request: ReturnType<typeof readNestedControlRequests>[number]): void => {
+		if (seen.has(request.requestId) || inFlight.has(request.requestId)) return;
+		inFlight.add(request.requestId);
+		void (async () => {
+			try {
+				const pending = pendingResults.get(request.requestId);
+				const result = pending?.result ?? (await buildNestedControlResult(pi, state, request));
+				try {
+					writeNestedControlResult(route!, result);
+				} catch (error) {
+					const now = Date.now();
+					const nextPending: PendingControlResult = {
+						result,
+						firstFailureAt: pending?.firstFailureAt ?? now,
+						attempts: (pending?.attempts ?? 0) + 1,
+					};
+					pendingResults.set(request.requestId, nextPending);
+					if (shouldDropPendingResult(nextPending, pendingResults.size, now)) {
 						pendingResults.delete(request.requestId);
 						rememberSeenRequest(seen, request.requestId);
 						dropControlRequestFile(request.filePath, request.requestId);
-					} finally {
-						inFlight.delete(request.requestId);
+						console.error(
+							`Dropping nested control result for request '${request.requestId}' targeting '${request.targetRunId}' after ${nextPending.attempts} failed writes via inbox '${route!.controlInbox}':`,
+							error,
+						);
+					} else if (nextPending.attempts === 1) {
+						console.error(
+							`Failed to write nested control result for request '${request.requestId}' targeting '${request.targetRunId}' via inbox '${route!.controlInbox}'; keeping request for retry:`,
+							error,
+						);
 					}
-				})();
+					return;
+				}
+				pendingResults.delete(request.requestId);
+				rememberSeenRequest(seen, request.requestId);
+				dropControlRequestFile(request.filePath, request.requestId);
+			} finally {
+				inFlight.delete(request.requestId);
 			}
+		})();
+	};
+	const processPending = (): void => {
+		for (const request of readNestedControlRequests(route!)) processRequest(request);
+	};
+	processPending();
+	const memoryCleanup = hasInProcessNestedRoute(route)
+		? subscribeInProcessControlRequests(route, processRequest)
+		: undefined;
+	let watcher: fs.FSWatcher | undefined;
+	if (!memoryCleanup) {
+		try {
+			watcher = fs.watch(route.controlInbox, { persistent: false }, () => processPending());
 		} catch (error) {
-			console.error(
-				`Failed to poll nested control inbox '${route.controlInbox}' for root '${route.rootRunId}':`,
-				error,
-			);
+			console.error(`Failed to watch nested control inbox '${route.controlInbox}':`, error);
 		}
-	}, 200);
-	timer.unref?.();
-	state.cleanupTimers.set(NESTED_CONTROL_INBOX_TIMER_KEY, timer);
-	return timer;
+	}
+	const cleanup = () => {
+		memoryCleanup?.();
+		watcher?.close();
+		if (nestedControlListenerCleanups.get(pi) === cleanup) nestedControlListenerCleanups.delete(pi);
+	};
+	nestedControlListenerCleanups.set(pi, cleanup);
+	return cleanup;
 }
 
-export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI): void {
-	if (getEnvValue(SUBAGENT_CHILD_ENV) !== "1" || getEnvValue(SUBAGENT_FANOUT_CHILD_ENV) !== "1") return;
+export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI, childPolicy?: ChildModePolicy): void {
+	if (!childPolicy?.fanoutAuthorized) return;
 
 	const lifecycle = beginApiLifecycle(pi);
 
 	try {
 		const config = loadConfig();
 		const state = createChildSafeState();
+		let nestedListenerCleanup: (() => void) | undefined;
 		lifecycle.setCleanup(() => {
+			nestedListenerCleanup?.();
 			for (const timer of state.cleanupTimers.values()) clearInterval(timer);
 			state.cleanupTimers.clear();
 		});
@@ -226,7 +245,8 @@ export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI):
 			getSubagentSessionRoot,
 			expandTilde,
 			discoverAgents,
-			allowMutatingManagementActions: false,
+			childPolicy,
+			allowMutatingManagementActions: childPolicy ? childPolicy.managementActions === "full" : false,
 		});
 
 		const tool: ToolDefinition<typeof SubagentParams, Details> = {
@@ -246,7 +266,7 @@ export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI):
 		};
 
 		pi.registerTool(tool);
-		startNestedControlInboxListener(pi, state);
+		nestedListenerCleanup = startNestedControlInboxListener(pi, state);
 		pi.on?.("session_shutdown", () => lifecycle.dispose());
 	} catch (error) {
 		lifecycle.dispose();

package/dist/builtin/subagents/src/extension/index.ts

@@ -6,7 +6,6 @@ import {
 	APP_NAME,
 	type ExtensionAPI,
 	type ExtensionContext,
-	getEnvValue,
 	keyHintIfBound,
 	type ToolDefinition,
 } from "@bastani/atomic";
@@ -25,7 +24,6 @@ import { discoverAgents } from "../agents/agents.ts";
 import { createAsyncJobTracker } from "../runs/background/async-job-tracker.ts";
 import registerSubagentNotify, { type SubagentNotifyDetails } from "../runs/background/notify.ts";
 import { createSubagentExecutor, type SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
-import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.ts";
 import { getArtifactsDir } from "../shared/artifacts.ts";
 import { formatDuration, shortenPath } from "../shared/formatters.ts";
 import { resolveCurrentSessionId } from "../shared/session-identity.ts";
@@ -48,7 +46,6 @@ import {
 	stopWidgetAnimation,
 } from "../tui/render.ts";
 import { loadConfig } from "./config.ts";
-import registerFanoutChildSubagentExtension from "./fanout-child.ts";
 import { parseSubagentNotifyContent } from "./notification-content.ts";
 import { DEFAULT_PROMPT_GUIDANCE } from "./prompt-guidance.ts";
 import { SubagentParams } from "./schemas.ts";
@@ -60,7 +57,6 @@ import {
 	ASYNC_DIR,
 	DEFAULT_ARTIFACT_CONFIG,
 	type Details,
-	RESULTS_DIR,
 	SLASH_RESULT_TYPE,
 	SUBAGENT_ASYNC_COMPLETE_EVENT,
 	SUBAGENT_ASYNC_STARTED_EVENT,
@@ -90,18 +86,6 @@ function getSubagentSessionRoot(parentSessionFile: string | null): string {
 function expandTilde(p: string): string {
 	return p.startsWith("~/") ? path.join(os.homedir(), p.slice(2)) : p;
 }
-function ensureAccessibleDir(dirPath: string): void {
-	fs.mkdirSync(dirPath, { recursive: true });
-	try {
-		fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
-	} catch {
-		try {
-			fs.rmSync(dirPath, { recursive: true, force: true });
-		} catch {}
-		fs.mkdirSync(dirPath, { recursive: true });
-		fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
-	}
-}
 function isSlashResultRunning(result: { details?: Details }): boolean {
 	return (
 		result.details?.progress?.some((entry) => entry.status === "running") ||
@@ -111,7 +95,7 @@ function isSlashResultRunning(result: { details?: Details }): boolean {
 }
 function isSlashResultError(result: { details?: Details }): boolean {
 	return (
-		result.details?.results.some((entry) => entry.exitCode !== 0 && entry.progress?.status !== "running") || false
+		result.details?.results.some((entry) => entry.status === "error" && entry.progress?.status !== "running") || false
 	);
 }
 type SubagentToolRenderState = SubagentResultRenderState;
@@ -221,16 +205,10 @@ class SubagentControlNoticeComponent implements Component {
 }
 
 export default function registerSubagentExtension(pi: ExtensionAPI): void {
-	if (getEnvValue(SUBAGENT_CHILD_ENV) === "1") {
-		if (getEnvValue(SUBAGENT_FANOUT_CHILD_ENV) === "1") registerFanoutChildSubagentExtension(pi);
-		return;
-	}
 	const lifecycle = beginApiLifecycle(pi);
 	const registrationFailureCleanups: Array<() => void> = [];
 	let runtimeCleanupInstalled = false;
 	try {
-		ensureAccessibleDir(RESULTS_DIR);
-		ensureAccessibleDir(ASYNC_DIR);
 		const config = loadConfig();
 		const asyncByDefault = config.asyncByDefault === true;
 		const tempArtifactsDir = getArtifactsDir(null);
@@ -254,18 +232,14 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 				clear: () => {},
 			},
 		};
-		const maintenance = createSubagentStartupMaintenance(pi, state, {
-			resultsDir: RESULTS_DIR,
+		const maintenance = createSubagentStartupMaintenance(state, {
 			artifactCleanupDays: DEFAULT_ARTIFACT_CONFIG.cleanupDays,
-			resultTtlMs: 10 * 60 * 1000,
 		});
 		maintenance.scheduleStartupCleanup();
 		registrationFailureCleanups.push(() => maintenance.stop());
-		maintenance.startResultWatcherDeferred();
-		maintenance.primeExistingResultsDeferred();
 		const { ensurePoller, handleStarted, handleComplete, resetJobs, hydrateActiveJobsDeferred } =
 			createAsyncJobTracker(pi, state, ASYNC_DIR);
-		const executor = createSubagentExecutor({
+		const executorDeps = {
 			pi,
 			state,
 			config,
@@ -274,7 +248,23 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 			getSubagentSessionRoot,
 			expandTilde,
 			discoverAgents,
-		});
+		};
+		const executor = createSubagentExecutor(executorDeps);
+		const childExecutors = new Map<string, ReturnType<typeof createSubagentExecutor>>();
+		const executorForContext = (ctx: ExtensionContext): ReturnType<typeof createSubagentExecutor> => {
+			const policy = ctx.subagentPolicy;
+			if (!policy) return executor;
+			const key = `${policy.managementActions}:${policy.fanoutAuthorized ? "fanout" : "no-fanout"}`;
+			const cached = childExecutors.get(key);
+			if (cached) return cached;
+			const childExecutor = createSubagentExecutor({
+				...executorDeps,
+				childPolicy: policy,
+				allowMutatingManagementActions: policy.managementActions === "full",
+			});
+			childExecutors.set(key, childExecutor);
+			return childExecutor;
+		};
 		pi.registerMessageRenderer<SlashMessageDetails>(SLASH_RESULT_TYPE, (message, options, theme) => {
 			const details = resolveSlashMessageDetails(message.details);
 			if (!details) return undefined;
@@ -304,7 +294,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 				state.lastUiContext = ctx;
 				ctx.ui.setToolsExpanded(false);
 			}
-			return executor.execute(id, params, signal, onUpdate, ctx);
+			return executorForContext(ctx).execute(id, params, signal, onUpdate, ctx);
 		};
 		const slashBridge = registerSlashSubagentBridge({
 			events: pi.events,
@@ -454,6 +444,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 				...Array.from(state.cleanupTimers.values(), (timer) => () => clearTimeout(timer)),
 				() => state.cleanupTimers.clear(),
 				() => state.asyncJobs.clear(),
+				() => childExecutors.clear(),
 				() => clearSlashSnapshots(pi),
 				() => slashBridge.cancelAll(),
 				() => slashBridge.dispose(),
@@ -489,7 +480,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 			resetJobs(ctx);
 			hydrateActiveJobsDeferred(ctx);
 			restoreSlashFinalSnapshots(ctx.sessionManager.getEntries(), pi);
-			maintenance.primeExistingResultsDeferred();
+			restoreSlashFinalSnapshots(ctx.sessionManager.getEntries(), pi);
 		};
 		pi.on("session_start", (_event, ctx) => {
 			if (lifecycle.isCurrent()) resetSessionState(ctx);

package/dist/builtin/subagents/src/extension/startup-maintenance.ts

@@ -1,15 +1,12 @@
 import * as path from "node:path";
-import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
-import { createResultWatcher } from "../runs/background/result-watcher.ts";
-import { cleanupOldNestedRuntimeDirs } from "../runs/shared/nested-events.ts";
+import type { ExtensionContext } from "@bastani/atomic";
+import { cleanupOldNestedRuntimeDirs } from "../runs/inprocess/runtime-support/nested-api.ts";
 import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.ts";
 import { cleanupOldChainDirs } from "../shared/settings.ts";
 import type { SubagentState } from "../shared/types.ts";
 
 export interface SubagentStartupMaintenance {
 	scheduleStartupCleanup(): void;
-	startResultWatcherDeferred(): void;
-	primeExistingResultsDeferred(): void;
 	cleanupSessionArtifactsDeferred(ctx: ExtensionContext): void;
 	stop(): void;
 }
@@ -47,54 +44,48 @@ function swallowCleanup(task: () => void): void {
 	} catch {}
 }
 
+interface StartupMaintenanceOptions {
+	artifactCleanupDays: number;
+	resultsDir?: string;
+	resultTtlMs?: number;
+	scheduleMacrotask?: (task: () => void) => () => void;
+	scheduleDelayed?: (task: () => void, delayMs: number) => () => void;
+}
+
+export function createSubagentStartupMaintenance(
+	state: SubagentState,
+	options: StartupMaintenanceOptions,
+): SubagentStartupMaintenance;
 export function createSubagentStartupMaintenance(
-	pi: ExtensionAPI,
+	_pi: unknown,
 	state: SubagentState,
-	options: {
-		resultsDir: string;
-		artifactCleanupDays: number;
-		resultTtlMs: number;
-		scheduleMacrotask?: (task: () => void) => () => void;
-		scheduleDelayed?: (task: () => void, delayMs: number) => () => void;
-	},
+	options: StartupMaintenanceOptions,
+): SubagentStartupMaintenance;
+export function createSubagentStartupMaintenance(
+	_first: SubagentState | unknown,
+	second: StartupMaintenanceOptions | SubagentState,
+	third?: StartupMaintenanceOptions,
 ): SubagentStartupMaintenance {
-	const { startResultWatcher, primeExistingResults, stopResultWatcher } = createResultWatcher(
-		pi,
-		state,
-		options.resultsDir,
-		options.resultTtlMs,
-	);
+	const options = third ?? (second as StartupMaintenanceOptions);
 	const cancelTasks = new Set<() => void>();
-	// The sessions root derived from a host-provided (non-default, e.g. isolated
-	// programmatic agentDir) session directory. When set, the global artifact scan
-	// stays inside it instead of touching the real global/legacy sessions roots.
-	// A custom session dir that does not follow the <agentDir>/sessions/<safe-cwd>
-	// layout (the default layout the SDK derives for a programmatic agentDir, with
-	// <safe-cwd> encoding the current working directory) yields no roots at all, so
-	// cleanup never broadens into an arbitrary directory's siblings.
 	let contextSessionsRoots: readonly string[] | undefined;
 	const noteSessionContext = (ctx: ExtensionContext): void => {
 		try {
 			if (ctx.sessionManager.usesDefaultSessionDir()) {
-				// Only a valid default-session context intentionally restores the
-				// env/global cleanup roots.
 				contextSessionsRoots = undefined;
 				return;
 			}
 			const sessionDir = ctx.sessionManager.getSessionDir();
-			// A partial or throwing context keeps the last validated root: destructive
-			// cleanup must never broaden from an isolated root to the global roots on
-			// the strength of an unusable context.
 			if (!sessionDir) return;
 			const parent = path.dirname(sessionDir);
 			const safeCwd = `--${path
 				.resolve(ctx.cwd)
 				.replace(/^[/\\]/, "")
 				.replace(/[/\\:]/g, "-")}--`;
-			const followsAgentDirLayout = path.basename(parent) === "sessions" && path.basename(sessionDir) === safeCwd;
-			contextSessionsRoots = followsAgentDirLayout ? [parent] : [];
+			contextSessionsRoots =
+				path.basename(parent) === "sessions" && path.basename(sessionDir) === safeCwd ? [parent] : [];
 		} catch {
-			// A stale or partial context leaves cleanup on the env/global fallback.
+			// A stale or partial context leaves cleanup on the last validated root.
 		}
 	};
 	const schedule = (task: () => void): void => {
@@ -117,21 +108,12 @@ export function createSubagentStartupMaintenance(
 			schedule(() => {
 				swallowCleanup(cleanupOldChainDirs);
 				swallowCleanup(() => cleanupOldNestedRuntimeDirs(options.artifactCleanupDays));
-				// The global session-artifact scan can touch thousands of historical session
-				// directories, so it waits until well after startup instead of running on the
-				// activation macrotask.
 				scheduleDelayed(
 					() => swallowCleanup(() => cleanupAllArtifactDirs(options.artifactCleanupDays, contextSessionsRoots)),
 					STARTUP_ARTIFACT_SCAN_DELAY_MS,
 				);
 			});
 		},
-		startResultWatcherDeferred() {
-			schedule(startResultWatcher);
-		},
-		primeExistingResultsDeferred() {
-			schedule(primeExistingResults);
-		},
 		cleanupSessionArtifactsDeferred(ctx) {
 			noteSessionContext(ctx);
 			let sessionFile: string | null | undefined;
@@ -148,7 +130,6 @@ export function createSubagentStartupMaintenance(
 		stop() {
 			for (const cancel of cancelTasks) cancel();
 			cancelTasks.clear();
-			stopResultWatcher();
 		},
 	};
 }