@ferris1225/pi-subagents 4.1.2 → 4.1.3

package/src/monitor.ts

@@ -19,6 +19,7 @@ import type { IsolationMode, WorktreeFinalizationStatus } from "./worktree.ts";
 // ---------------------------------------------------------------------------
 
 export type RunStatus = "queued" | "running" | "steering" | "interrupting" | "parked" | "done" | "failed";
+export type ContinuationKind = "resume-retained" | "resume-appended" | "fork-retained" | "fork-appended" | "retarget";
 
 export function isRunActiveStatus(status: RunStatus): boolean {
 	return status === "queued" || status === "running" || status === "steering" || status === "interrupting";
@@ -45,16 +46,25 @@ export interface RunView {
 	usage: UsageStats;
 	/** Concise current activity ("thinking", "read src/index.ts"); last writer wins. */
 	activity?: string;
-	/** Epoch ms when the run started executing (set on first "running" status). */
+	/** Epoch ms when this logical run first started executing. */
 	startedAt?: number;
-	/** Epoch ms when the run finished (set on "done"/"failed"). */
+	/** Epoch ms when the current active segment started. */
+	activeSince?: number;
+	/** Cumulative active execution time from closed segments; parked time is excluded. */
+	elapsedMs: number;
+	/** Epoch ms when the latest active segment stopped. */
 	endedAt?: number;
+	/** Why this generation reused retained context, shown in the widget/status. */
+	continuationKind?: ContinuationKind;
 	/** When set, this is an internal managed-workflow step. */
 	groupId?: string;
 	/** Human-readable role within a chain, e.g. "fix round 1" or "re-review round 1". */
 	relationLabel?: string;
 	/** Stable owning run whose row represents the whole managed workflow. */
 	parentRunId?: number;
+	/** This stable top-level row currently owns a multi-stage managed workflow.
+	 * Its elapsed time is workflow-wide; active child rows own stage telemetry. */
+	managedWorkflow?: boolean;
 }
 
 /** Optional metadata for documenter/reviewer/fix children of a stable parent run. */
@@ -64,6 +74,7 @@ export interface RunChainMeta {
 	parentRunId?: number;
 	isolation?: IsolationMode;
 	forkedFromRunId?: number;
+	continuationKind?: ContinuationKind;
 }
 
 // ---------------------------------------------------------------------------
@@ -276,10 +287,32 @@ export function formatDuration(ms: number): string {
 	return `${hours}h${String(minutes % 60).padStart(2, "0")}m`;
 }
 
-/** Elapsed wall time of a run: live while running, final once finished. */
+/** Cumulative active time across generations; parked gaps never count. */
+export function elapsedMilliseconds(run: RunView, now: number = Date.now()): number {
+	let elapsed = run.elapsedMs ?? 0;
+	if (run.activeSince !== undefined) elapsed += Math.max(0, now - run.activeSince);
+	// Keep formatting tolerant of older/synthetic RunView values that predate
+	// segmented timing and carry only startedAt/endedAt.
+	if (elapsed === 0 && run.startedAt !== undefined && run.activeSince === undefined) {
+		elapsed = Math.max(0, (run.endedAt ?? now) - run.startedAt);
+	}
+	return elapsed;
+}
+
 export function formatElapsed(run: RunView, now: number = Date.now()): string {
-	if (run.startedAt === undefined) return "";
-	return formatDuration((run.endedAt ?? now) - run.startedAt);
+	if (run.startedAt === undefined && run.elapsedMs <= 0) return "";
+	return formatDuration(elapsedMilliseconds(run, now));
+}
+
+export function continuationLabel(kind: ContinuationKind | undefined, sourceRunId?: number): string | undefined {
+	switch (kind) {
+		case "resume-retained": return "resume: current objective";
+		case "resume-appended": return "resume: appended objective";
+		case "fork-retained": return `fork${sourceRunId === undefined ? "" : ` #${sourceRunId}`}: current objective`;
+		case "fork-appended": return `fork${sourceRunId === undefined ? "" : ` #${sourceRunId}`}: appended objective`;
+		case "retarget": return "retarget: replacement objective";
+		default: return undefined;
+	}
 }
 
 /** Max length of the argument target inside a formatted activity line. */
@@ -409,11 +442,13 @@ export class MonitorStore {
 			thinking,
 			status: "queued",
 			usage: emptyUsage(),
+			elapsedMs: 0,
 			...(meta?.groupId ? { groupId: meta.groupId } : {}),
 			...(meta?.relationLabel ? { relationLabel: meta.relationLabel } : {}),
 			...(meta?.parentRunId !== undefined ? { parentRunId: meta.parentRunId } : {}),
 			...(meta?.isolation ? { isolation: meta.isolation, integrationStatus: meta.isolation === "worktree" ? "pending" : undefined } : {}),
 			...(meta?.forkedFromRunId !== undefined ? { forkedFromRunId: meta.forkedFromRunId } : {}),
+			...(meta?.continuationKind ? { continuationKind: meta.continuationKind } : {}),
 		});
 		this.notify();
 		return id;
@@ -422,17 +457,33 @@ export class MonitorStore {
 	setStatus(id: number, status: RunStatus): void {
 		const run = this.find(id);
 		if (!run) return;
+		const previousStatus = run.status;
+		const wasExecuting = previousStatus === "running" || previousStatus === "steering" || previousStatus === "interrupting";
+		const isExecuting = status === "running" || status === "steering" || status === "interrupting";
+		const now = Date.now();
 		run.status = status;
-		if (status === "running" || status === "steering" || status === "interrupting") {
-			if (run.startedAt === undefined) run.startedAt = Date.now();
-			// A selected-to-main handoff or resumed generation restarts the clock; a
-			// stale endedAt would freeze the elapsed display at the first attempt.
-			if (run.endedAt !== undefined) run.endedAt = undefined;
-		} else if ((status === "parked" || status === "done" || status === "failed") && run.endedAt === undefined) {
-			run.endedAt = Date.now();
+		if (isExecuting && !wasExecuting) {
+			run.startedAt ??= now;
+			run.activeSince = now;
+			run.endedAt = undefined;
+		} else if (!isExecuting && wasExecuting && run.activeSince !== undefined) {
+			run.elapsedMs += Math.max(0, now - run.activeSince);
+			run.activeSince = undefined;
 		}
+		if ((status === "parked" || status === "done" || status === "failed") && run.endedAt === undefined) {
+			run.endedAt = now;
+		}
+		this.notify();
+	}
+	/** Switch a stable top-level row from one model run to workflow ownership.
+	 * The original role remains for identity; child rows show stage telemetry. */
+	setManagedWorkflow(id: number, active: boolean): void {
+		const run = this.find(id);
+		if (!run) return;
+		run.managedWorkflow = active || undefined;
 		this.notify();
 	}
+
 	setUsage(id: number, usage: UsageStats, model?: string): void {
 		const run = this.find(id);
 		if (!run) return;
@@ -503,26 +554,38 @@ export class MonitorStore {
 		this.notify();
 	}
 
-	/** Reflect the currently owned internal stage when a managed parent is parked
-	 * or inspected between children; the stable id and original task stay intact. */
-	setAgent(id: number, agent: string): void {
+	/** Update the objective shown for a queued retarget or resumed generation. */
+	setTask(id: number, task: string): void {
 		const run = this.find(id);
 		if (!run) return;
-		run.agent = agent;
+		run.task = task;
+		run.label = runLabel(task);
 		this.notify();
 	}
 
-	/** Update the objective shown for a queued retarget or resumed generation. */
-	setTask(id: number, task: string): void {
+	setContinuationKind(id: number, kind: ContinuationKind): void {
 		const run = this.find(id);
 		if (!run) return;
-		run.task = task;
-		run.label = runLabel(task);
+		run.continuationKind = kind;
 		this.notify();
 	}
 
-	/** Reuse a stable logical run id for a resumed generation. */
-	restartRun(id: number, agent: string, task: string, model?: string, thinking?: string, isolation?: IsolationMode): void {
+	getElapsedMs(id: number, now: number = Date.now()): number | undefined {
+		const run = this.find(id);
+		return run ? elapsedMilliseconds(run, now) : undefined;
+	}
+
+	/** Reuse a stable logical run id for a resumed generation without discarding
+	 * active time accumulated by earlier generations. */
+	restartRun(
+		id: number,
+		agent: string,
+		task: string,
+		model?: string,
+		thinking?: string,
+		isolation?: IsolationMode,
+		meta?: { elapsedMs?: number; continuationKind?: ContinuationKind },
+	): void {
 		const run = this.find(id);
 		if (!run) {
 			this.runs.push({
@@ -535,6 +598,8 @@ export class MonitorStore {
 				...(isolation ? { isolation, integrationStatus: isolation === "worktree" ? "pending" as const : undefined } : {}),
 				status: "queued",
 				usage: emptyUsage(),
+				elapsedMs: meta?.elapsedMs ?? 0,
+				continuationKind: meta?.continuationKind,
 			});
 			this.notify();
 			return;
@@ -549,8 +614,11 @@ export class MonitorStore {
 		run.status = "queued";
 		run.usage = emptyUsage();
 		run.activity = undefined;
-		run.startedAt = undefined;
+		run.managedWorkflow = undefined;
+		run.activeSince = undefined;
 		run.endedAt = undefined;
+		run.elapsedMs = Math.max(run.elapsedMs, meta?.elapsedMs ?? 0);
+		run.continuationKind = meta?.continuationKind;
 		this.notify();
 	}
 
@@ -589,12 +657,14 @@ export class MonitorStore {
 
 	summarize(run: RunView): string {
 		const usage = formatUsageCompact(run.usage);
-		const parts = [run.agent];
+		const parts = [run.managedWorkflow ? `${run.agent} workflow` : run.agent];
+		const continuation = continuationLabel(run.continuationKind, run.forkedFromRunId);
+		if (continuation) parts.push(continuation);
 		if (run.relationLabel) parts.push(run.relationLabel);
-		if (run.model) parts.push(run.model);
-		if (run.thinking) parts.push(`thinking ${run.thinking}`);
+		if (!run.managedWorkflow && run.model) parts.push(run.model);
+		if (!run.managedWorkflow && run.thinking) parts.push(`thinking ${run.thinking}`);
 		if (run.isolation === "worktree") parts.push(`worktree ${run.integrationStatus ?? "active"}`);
-		if (usage) parts.push(usage);
+		if (!run.managedWorkflow && usage) parts.push(usage);
 		const elapsed = formatElapsed(run);
 		if (elapsed) parts.push(elapsed);
 		return parts.join(" · ");

package/src/recovery.ts

@@ -1,145 +1,145 @@
-/** Durable handoff for worktree integration/cleanup failures across sessions. */
-
-import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
-import { existsSync } from "node:fs";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { stripVTControlCharacters } from "node:util";
-import type { WorktreeFinalization } from "./worktree.ts";
-
-export const RECOVERY_MANIFEST_FILE_NAME = "pi-subagents-recovery.json";
-const RECOVERY_MANIFEST_VERSION = 1;
-
-export interface RecoveryRecord {
-	runId: number;
-	createdAt: number;
-	integrated: boolean;
-	worktreePath?: string;
-	patchPath?: string;
-	error?: string;
-}
-
-interface RecoveryManifest {
-	version: number;
-	records: RecoveryRecord[];
-}
-
-export function getRecoveryManifestPath(configPath: string): string {
-	return join(dirname(configPath), RECOVERY_MANIFEST_FILE_NAME);
-}
-
-function normalizeRecord(value: unknown): RecoveryRecord | undefined {
-	if (!value || typeof value !== "object") return undefined;
-	const raw = value as Record<string, unknown>;
-	if (typeof raw.runId !== "number" || !Number.isInteger(raw.runId) || raw.runId < 1) return undefined;
-	if (typeof raw.createdAt !== "number" || !Number.isFinite(raw.createdAt)) return undefined;
-	return {
-		runId: raw.runId,
-		createdAt: raw.createdAt,
-		integrated: raw.integrated === true,
-		...(typeof raw.worktreePath === "string" && raw.worktreePath ? { worktreePath: raw.worktreePath } : {}),
-		...(typeof raw.patchPath === "string" && raw.patchPath ? { patchPath: raw.patchPath } : {}),
-		...(typeof raw.error === "string" && raw.error ? { error: raw.error } : {}),
-	};
-}
-
-export async function readRecoveryRecords(configPath: string): Promise<RecoveryRecord[]> {
-	try {
-		const parsed = JSON.parse(await readFile(getRecoveryManifestPath(configPath), "utf8")) as {
-			records?: unknown;
-		};
-		if (!Array.isArray(parsed.records)) return [];
-		return parsed.records.flatMap((record) => {
-			const normalized = normalizeRecord(record);
-			return normalized ? [normalized] : [];
-		});
-	} catch {
-		return [];
-	}
-}
-
-function recoveryKey(record: RecoveryRecord): string {
-	return `${record.runId}\0${record.worktreePath ?? ""}\0${record.patchPath ?? ""}\0${record.error ?? ""}`;
-}
-
-async function writeManifest(path: string, records: readonly RecoveryRecord[]): Promise<void> {
-	if (records.length === 0) {
-		await rm(path, { force: true });
-		return;
-	}
-	await mkdir(dirname(path), { recursive: true });
-	const temporaryPath = `${path}.${process.pid}.${Date.now()}.tmp`;
-	try {
-		const manifest: RecoveryManifest = {
-			version: RECOVERY_MANIFEST_VERSION,
-			records: [...records],
-		};
-		await writeFile(temporaryPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
-		await rename(temporaryPath, path);
-	} finally {
-		await rm(temporaryPath, { force: true }).catch(() => undefined);
-	}
-}
-
-/** Merge retained artifacts into the durable manifest. */
-export async function persistRecoveryRecords(
-	configPath: string,
-	records: readonly RecoveryRecord[],
-): Promise<void> {
-	if (records.length === 0) return;
-	const path = getRecoveryManifestPath(configPath);
-	await withFileMutationQueue(path, async () => {
-		const merged = new Map<string, RecoveryRecord>();
-		for (const record of await readRecoveryRecords(configPath)) merged.set(recoveryKey(record), record);
-		for (const record of records) merged.set(recoveryKey(record), record);
-		await writeManifest(path, [...merged.values()]);
-	});
-}
-
-export function recoveryRecordFromFinalization(
-	runId: number,
-	finalization: WorktreeFinalization,
-	now = Date.now(),
-): RecoveryRecord {
-	return {
-		runId,
-		createdAt: now,
-		integrated: finalization.integrated,
-		...(finalization.worktreePath ? { worktreePath: finalization.worktreePath } : {}),
-		...(finalization.patchPath ? { patchPath: finalization.patchPath } : {}),
-		...(finalization.error ? { error: finalization.error } : {}),
-	};
-}
-
-/** Show retained recovery paths on every later session start until the user
- * removes the artifacts. Stale records are pruned automatically. */
-export async function announceRecoveryRecords(
-	configPath: string,
-	ctx: {
-		hasUI?: boolean;
-		ui: { notify(message: string, kind: "info" | "warning" | "error"): void };
-	},
-): Promise<void> {
-	if (ctx.hasUI === false) return;
-	const records = await readRecoveryRecords(configPath);
-	if (records.length === 0) return;
-	const live = records.filter((record) =>
-		(record.worktreePath ? existsSync(record.worktreePath) : false) ||
-		(record.patchPath ? existsSync(record.patchPath) : false),
-	);
-	if (live.length !== records.length) {
-		const path = getRecoveryManifestPath(configPath);
-		await withFileMutationQueue(path, () => writeManifest(path, live)).catch(() => undefined);
-	}
-	for (const record of live) {
-		const paths = [
-			record.worktreePath ? `worktree ${stripVTControlCharacters(record.worktreePath)}` : undefined,
-			record.patchPath ? `patch ${stripVTControlCharacters(record.patchPath)}` : undefined,
-		].filter(Boolean).join(" · ");
-		const reason = record.error ? ` · ${stripVTControlCharacters(record.error)}` : "";
-		ctx.ui.notify(
-			`pi-subagents recovery for run #${record.runId}: ${record.integrated ? "changes were applied but cleanup failed" : "integration failed"}${paths ? ` · retained ${paths}` : ""}${reason}`,
-			"error",
-		);
-	}
-}
+/** Durable handoff for worktree integration/cleanup failures across sessions. */
+
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { stripVTControlCharacters } from "node:util";
+import type { WorktreeFinalization } from "./worktree.ts";
+
+export const RECOVERY_MANIFEST_FILE_NAME = "pi-subagents-recovery.json";
+const RECOVERY_MANIFEST_VERSION = 1;
+
+export interface RecoveryRecord {
+	runId: number;
+	createdAt: number;
+	integrated: boolean;
+	worktreePath?: string;
+	patchPath?: string;
+	error?: string;
+}
+
+interface RecoveryManifest {
+	version: number;
+	records: RecoveryRecord[];
+}
+
+export function getRecoveryManifestPath(configPath: string): string {
+	return join(dirname(configPath), RECOVERY_MANIFEST_FILE_NAME);
+}
+
+function normalizeRecord(value: unknown): RecoveryRecord | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const raw = value as Record<string, unknown>;
+	if (typeof raw.runId !== "number" || !Number.isInteger(raw.runId) || raw.runId < 1) return undefined;
+	if (typeof raw.createdAt !== "number" || !Number.isFinite(raw.createdAt)) return undefined;
+	return {
+		runId: raw.runId,
+		createdAt: raw.createdAt,
+		integrated: raw.integrated === true,
+		...(typeof raw.worktreePath === "string" && raw.worktreePath ? { worktreePath: raw.worktreePath } : {}),
+		...(typeof raw.patchPath === "string" && raw.patchPath ? { patchPath: raw.patchPath } : {}),
+		...(typeof raw.error === "string" && raw.error ? { error: raw.error } : {}),
+	};
+}
+
+export async function readRecoveryRecords(configPath: string): Promise<RecoveryRecord[]> {
+	try {
+		const parsed = JSON.parse(await readFile(getRecoveryManifestPath(configPath), "utf8")) as {
+			records?: unknown;
+		};
+		if (!Array.isArray(parsed.records)) return [];
+		return parsed.records.flatMap((record) => {
+			const normalized = normalizeRecord(record);
+			return normalized ? [normalized] : [];
+		});
+	} catch {
+		return [];
+	}
+}
+
+function recoveryKey(record: RecoveryRecord): string {
+	return `${record.runId}\0${record.worktreePath ?? ""}\0${record.patchPath ?? ""}\0${record.error ?? ""}`;
+}
+
+async function writeManifest(path: string, records: readonly RecoveryRecord[]): Promise<void> {
+	if (records.length === 0) {
+		await rm(path, { force: true });
+		return;
+	}
+	await mkdir(dirname(path), { recursive: true });
+	const temporaryPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+	try {
+		const manifest: RecoveryManifest = {
+			version: RECOVERY_MANIFEST_VERSION,
+			records: [...records],
+		};
+		await writeFile(temporaryPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+		await rename(temporaryPath, path);
+	} finally {
+		await rm(temporaryPath, { force: true }).catch(() => undefined);
+	}
+}
+
+/** Merge retained artifacts into the durable manifest. */
+export async function persistRecoveryRecords(
+	configPath: string,
+	records: readonly RecoveryRecord[],
+): Promise<void> {
+	if (records.length === 0) return;
+	const path = getRecoveryManifestPath(configPath);
+	await withFileMutationQueue(path, async () => {
+		const merged = new Map<string, RecoveryRecord>();
+		for (const record of await readRecoveryRecords(configPath)) merged.set(recoveryKey(record), record);
+		for (const record of records) merged.set(recoveryKey(record), record);
+		await writeManifest(path, [...merged.values()]);
+	});
+}
+
+export function recoveryRecordFromFinalization(
+	runId: number,
+	finalization: WorktreeFinalization,
+	now = Date.now(),
+): RecoveryRecord {
+	return {
+		runId,
+		createdAt: now,
+		integrated: finalization.integrated,
+		...(finalization.worktreePath ? { worktreePath: finalization.worktreePath } : {}),
+		...(finalization.patchPath ? { patchPath: finalization.patchPath } : {}),
+		...(finalization.error ? { error: finalization.error } : {}),
+	};
+}
+
+/** Show retained recovery paths on every later session start until the user
+ * removes the artifacts. Stale records are pruned automatically. */
+export async function announceRecoveryRecords(
+	configPath: string,
+	ctx: {
+		hasUI?: boolean;
+		ui: { notify(message: string, kind: "info" | "warning" | "error"): void };
+	},
+): Promise<void> {
+	if (ctx.hasUI === false) return;
+	const records = await readRecoveryRecords(configPath);
+	if (records.length === 0) return;
+	const live = records.filter((record) =>
+		(record.worktreePath ? existsSync(record.worktreePath) : false) ||
+		(record.patchPath ? existsSync(record.patchPath) : false),
+	);
+	if (live.length !== records.length) {
+		const path = getRecoveryManifestPath(configPath);
+		await withFileMutationQueue(path, () => writeManifest(path, live)).catch(() => undefined);
+	}
+	for (const record of live) {
+		const paths = [
+			record.worktreePath ? `worktree ${stripVTControlCharacters(record.worktreePath)}` : undefined,
+			record.patchPath ? `patch ${stripVTControlCharacters(record.patchPath)}` : undefined,
+		].filter(Boolean).join(" · ");
+		const reason = record.error ? ` · ${stripVTControlCharacters(record.error)}` : "";
+		ctx.ui.notify(
+			`pi-subagents recovery for run #${record.runId}: ${record.integrated ? "changes were applied but cleanup failed" : "integration failed"}${paths ? ` · retained ${paths}` : ""}${reason}`,
+			"error",
+		);
+	}
+}

package/src/rpc-run.ts

@@ -14,7 +14,7 @@ import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import type { Message } from "@earendil-works/pi-ai";
-import type { AgentConfig } from "./agents.ts";
+import { SUBAGENT_TOOL_NAMES, type AgentConfig } from "./agents.ts";
 import type { ThinkingLevel } from "./config.ts";
 import type { IsolationMode, WorktreeFinalizationStatus } from "./worktree.ts";
 
@@ -469,7 +469,7 @@ export interface RunRpcAttemptOptions {
 /** Run one persistent RPC child until a stable `agent_settled` or control action. */
 export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise<RpcSingleResult> {
 	const { agent, agentName, task, thinkingLevel, idleTimeoutMs, signal, onLive, control } = options;
-	const args: string[] = ["--mode", "rpc", "--exclude-tools", "subagent,subagent_control"];
+	const args: string[] = ["--mode", "rpc", "--exclude-tools", SUBAGENT_TOOL_NAMES.join(",")];
 	if (options.sessionDir && options.sessionId) {
 		args.push("--session-dir", options.sessionDir);
 		args.push(sessionExists(options.sessionDir, options.sessionId) ? "--session" : "--session-id", options.sessionId);
@@ -478,7 +478,10 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 	}
 	if (agent.model) args.push("--model", agent.model);
 	args.push("--thinking", thinkingLevel);
-	if (agent.tools && agent.tools.length > 0) args.push("--tools", agent.tools.join(","));
+	if (agent.tools) {
+		if (agent.tools.length > 0) args.push("--tools", agent.tools.join(","));
+		else args.push("--no-tools");
+	}
 
 	let tmpPromptDir: string | null = null;
 	let tmpPromptPath: string | null = null;

package/src/runtime.ts

@@ -67,6 +67,8 @@ export interface SubagentThread {
 	lifecycleOperation?: ThreadLifecycleOperation;
 	sessionId?: string;
 	sessionDir?: string;
+	/** Active execution time accumulated across retained resume generations. */
+	elapsedMs: number;
 	/** Most recent generation result, retained for parked destructive-stop output. */
 	lastResult?: SingleResult;
 	/** A destructive stop retires context even if the active child settles later. */
@@ -92,6 +94,8 @@ export interface SubagentThread {
 export interface SubagentRuntime {
 	configPath: string;
 	backgroundQueue: BackgroundTaskQueue;
+	/** Live parent tool names from ExtensionAPI, read again for each child launch. */
+	getActiveTools: () => string[];
 	/** False after session_shutdown; guards delivery and queue work. */
 	sessionActive: boolean;
 	/** Deliver a batch of completion messages to the main window, waking it only
@@ -128,6 +132,7 @@ export function createRuntime(pi: ExtensionAPI, configPath: string): SubagentRun
 	const runtime: SubagentRuntime = {
 		configPath,
 		backgroundQueue,
+		getActiveTools: () => pi.getActiveTools(),
 		sessionActive: true,
 		sendCompletionGroup: (items) => {
 			if (!runtime.sessionActive || items.length === 0) return;