@duckmind/dm-darwin-x64 0.43.2 → 0.43.8

package/extensions/dm-subagents/src/runs/background/notify.ts

@@ -1,225 +0,0 @@
-/**
- * Subagent completion notifications.
- *
- * Successful (completed) async results are held briefly and emitted as a
- * single grouped message when sibling jobs finish within a short window (see
- * `completion-batcher.ts`). Failed and paused results bypass grouping and fire
- * immediately, flushing any held successes first, so failure and attention
- * signals are never delayed.
- */
-
-import type { ExtensionAPI } from "@duckmind/dm-coding-agent";
-import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "./completion-dedupe.ts";
-import {
-	type CompletionBatchConfig,
-	type CompletionBatcher,
-	createCompletionBatcher,
-	resolveCompletionBatchConfig,
-} from "./completion-batcher.ts";
-import { SUBAGENT_ASYNC_COMPLETE_EVENT, type SubagentState } from "../../shared/types.ts";
-
-interface ChainStepResult {
-	agent: string;
-	output: string;
-	success: boolean;
-}
-
-export interface SubagentNotifyDetails {
-	agent: string;
-	status: "completed" | "failed" | "paused";
-	taskInfo?: string;
-	resultPreview: string;
-	durationMs?: number;
-	sessionLabel?: string;
-	sessionValue?: string;
-}
-
-interface SubagentResult {
-	id: string | null;
-	agent: string | null;
-	success: boolean;
-	summary: string;
-	exitCode?: number;
-	state?: string;
-	timestamp: number;
-	durationMs?: number;
-	cwd?: string;
-	sessionFile?: string;
-	shareUrl?: string;
-	gistUrl?: string;
-	shareError?: string;
-	results?: ChainStepResult[];
-	taskIndex?: number;
-	totalTasks?: number;
-	sessionId?: string | null;
-}
-
-interface NotifyTimerApi {
-	setTimeout(handler: () => void, delayMs: number): unknown;
-	clearTimeout(handle: unknown): void;
-}
-
-export interface RegisterSubagentNotifyOptions {
-	batchConfig?: CompletionBatchConfig;
-	timers?: NotifyTimerApi;
-	now?: () => number;
-}
-
-function formatSessionLine(details: SubagentNotifyDetails): string | undefined {
-	if (!details.sessionValue) return undefined;
-	return details.sessionLabel ? `${details.sessionLabel}: ${details.sessionValue}` : details.sessionValue;
-}
-
-export function formatSingleCompletion(details: SubagentNotifyDetails): string {
-	const sessionLine = formatSessionLine(details);
-	return [
-		`Background task ${details.status}: **${details.agent}**${details.taskInfo ?? ""}`,
-		"",
-		details.resultPreview.trim() ? details.resultPreview : "(no output)",
-		sessionLine ? "" : undefined,
-		sessionLine,
-	]
-		.filter((line) => line !== undefined)
-		.join("\n");
-}
-
-export function formatGroupedCompletion(details: SubagentNotifyDetails[]): string {
-	const header = `Background tasks completed (${details.length}): ${details.map((d) => `**${d.agent}**${d.taskInfo ?? ""}`).join(", ")}`;
-	const blocks: string[] = [header, ""];
-	for (let index = 0; index < details.length; index++) {
-		const detail = details[index];
-		if (!detail) continue;
-		const sessionLine = formatSessionLine(detail);
-		blocks.push(`${index + 1}. ${detail.agent}${detail.taskInfo ?? ""}`);
-		blocks.push(detail.resultPreview.trim() ? detail.resultPreview : "(no output)");
-		if (sessionLine) blocks.push(sessionLine);
-		blocks.push("");
-	}
-	return blocks.join("\n").trimEnd();
-}
-
-function sendCompletion(pi: Pick<ExtensionAPI, "sendMessage">, details: SubagentNotifyDetails[]): void {
-	if (details.length === 0) return;
-	const content = details.length === 1
-		? formatSingleCompletion(details[0]!)
-		: formatGroupedCompletion(details);
-	pi.sendMessage(
-		{
-			customType: "subagent-notify",
-			content,
-			display: true,
-		},
-		{ triggerTurn: true },
-	);
-}
-
-function completionBatchKey(result: SubagentResult): string {
-	const sessionId = typeof result.sessionId === "string" ? result.sessionId.trim() : "";
-	if (sessionId) return `session:${sessionId}`;
-	const cwd = typeof result.cwd === "string" ? result.cwd.trim() : "";
-	return cwd ? `cwd:${cwd}` : "unknown";
-}
-
-export function buildCompletionDetails(result: SubagentResult): SubagentNotifyDetails {
-	const agent = result.agent ?? "unknown";
-	const summary = typeof result.summary === "string" ? result.summary : "";
-	const paused = !result.success && (
-		result.exitCode === 0
-		|| result.state === "paused"
-		|| summary.startsWith("Paused after interrupt.")
-	);
-	const status = paused ? "paused" : result.success ? "completed" : "failed";
-
-	const taskInfo =
-		result.taskIndex !== undefined && result.totalTasks !== undefined
-			? ` (${result.taskIndex + 1}/${result.totalTasks})`
-			: undefined;
-
-	const session =
-		result.shareUrl
-			? { label: "Session", value: result.shareUrl }
-			: result.shareError
-				? { label: "Session share error", value: result.shareError }
-				: result.sessionFile
-					? { label: "Session file", value: result.sessionFile }
-					: undefined;
-
-	return {
-		agent,
-		status,
-		...(taskInfo ? { taskInfo } : {}),
-		resultPreview: summary,
-		...(typeof result.durationMs === "number" ? { durationMs: result.durationMs } : {}),
-		...(session ? { sessionLabel: session.label, sessionValue: session.value } : {}),
-	};
-}
-
-export default function registerSubagentNotify(
-	pi: ExtensionAPI,
-	state: Pick<SubagentState, "currentSessionId">,
-	options: RegisterSubagentNotifyOptions = {},
-): void {
-	const unsubscribeStoreKey = "__pi_subagents_notify_unsubscribe__";
-	const batcherStoreKey = "__pi_subagents_notify_batcher__";
-	const globalStore = globalThis as Record<string, unknown>;
-	const previousUnsubscribe = globalStore[unsubscribeStoreKey];
-	if (typeof previousUnsubscribe === "function") {
-		try {
-			previousUnsubscribe();
-		} catch {
-			// Best effort cleanup for stale handlers from an older reload.
-		}
-	}
-	const previousBatcher = globalStore[batcherStoreKey];
-	if (previousBatcher && typeof (previousBatcher as { dispose?: () => void }).dispose === "function") {
-		try {
-			(previousBatcher as { dispose: () => void }).dispose();
-		} catch {
-			// Best effort cleanup for a stale batcher from an older reload.
-		}
-	}
-
-	const seen = getGlobalSeenMap("__pi_subagents_notify_seen__");
-	const ttlMs = 10 * 60 * 1000;
-	const nowFn = options.now ?? Date.now;
-	const batchConfig = resolveCompletionBatchConfig(options.batchConfig);
-	const batchers = new Map<string, CompletionBatcher<SubagentNotifyDetails>>();
-	globalStore[batcherStoreKey] = {
-		dispose() {
-			for (const batcher of batchers.values()) batcher.dispose();
-			batchers.clear();
-		},
-	};
-
-	const handleComplete = (data: unknown) => {
-		const result = data as SubagentResult;
-		if (typeof result.sessionId !== "string" || result.sessionId !== state.currentSessionId) return;
-		const now = nowFn();
-		const key = buildCompletionKey(result, "notify");
-		if (markSeenWithTtl(seen, key, now, ttlMs)) return;
-
-		const details = buildCompletionDetails(result);
-		const batchKey = completionBatchKey(result);
-		let batcher = batchers.get(batchKey);
-		if (!batcher) {
-			batcher = createCompletionBatcher<SubagentNotifyDetails>({
-				config: batchConfig,
-				emit: (items) => sendCompletion(pi, items),
-				...(options.timers ? { timers: options.timers } : {}),
-				now: nowFn,
-			});
-			batchers.set(batchKey, batcher);
-		}
-		if (details.status !== "completed") {
-			// Failures and paused runs bypass grouping. Flush any held
-			// successes for the same owner first so they are not stranded
-			// behind this signal, then emit the non-completion result immediately.
-			batcher.flush();
-			sendCompletion(pi, [details]);
-			return;
-		}
-		batcher.push(details);
-	};
-
-	globalStore[unsubscribeStoreKey] = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
-}

package/extensions/dm-subagents/src/runs/background/parallel-groups.ts

@@ -1,45 +0,0 @@
-import type { AsyncParallelGroupStatus } from "../../shared/types.ts";
-
-function isValidParallelGroup(group: unknown, stepCount: number, chainStepCount: number): group is AsyncParallelGroupStatus {
-	if (typeof group !== "object" || group === null) return false;
-	const { start, count, stepIndex } = group as Partial<AsyncParallelGroupStatus>;
-	return typeof start === "number"
-		&& typeof count === "number"
-		&& typeof stepIndex === "number"
-		&& Number.isInteger(start)
-		&& Number.isInteger(count)
-		&& Number.isInteger(stepIndex)
-		&& start >= 0
-		&& count > 0
-		&& stepIndex >= 0
-		&& stepIndex < chainStepCount
-		&& start + count <= stepCount;
-}
-
-export function normalizeParallelGroups(groups: unknown, stepCount: number, chainStepCount: number): AsyncParallelGroupStatus[] {
-	if (!Array.isArray(groups)) return [];
-	return groups
-		.filter((group): group is AsyncParallelGroupStatus => isValidParallelGroup(group, stepCount, chainStepCount))
-		.sort((left, right) => left.stepIndex - right.stepIndex || left.start - right.start);
-}
-
-export function flatToLogicalStepIndex(flatIndex: number, chainStepCount: number, groups: AsyncParallelGroupStatus[]): number {
-	let logicalIndex = 0;
-	let cursor = 0;
-	for (const group of groups) {
-		while (cursor < group.start && logicalIndex < chainStepCount) {
-			if (cursor === flatIndex) return logicalIndex;
-			cursor++;
-			logicalIndex++;
-		}
-		if (flatIndex >= group.start && flatIndex < group.start + group.count) return group.stepIndex;
-		cursor = group.start + group.count;
-		logicalIndex = group.stepIndex + 1;
-	}
-	while (cursor <= flatIndex && logicalIndex < chainStepCount) {
-		if (cursor === flatIndex) return logicalIndex;
-		cursor++;
-		logicalIndex++;
-	}
-	return Math.max(0, chainStepCount - 1);
-}

package/extensions/dm-subagents/src/runs/background/result-watcher.ts

@@ -1,315 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { buildCompletionKey, markSeenWithTtl } from "./completion-dedupe.ts";
-import { createFileCoalescer } from "../../shared/file-coalescer.ts";
-import {
-	SUBAGENT_ASYNC_COMPLETE_EVENT,
-	type IntercomEventBus,
-	type NestedRunSummary,
-	type SubagentResultIntercomChild,
-	type SubagentState,
-} from "../../shared/types.ts";
-import {
-	attachNestedChildrenToResultChildren,
-	buildSubagentResultIntercomPayload,
-	compactNestedResultChildren,
-	deliverSubagentResultIntercomEvent,
-	resolveSubagentResultStatus,
-} from "../../intercom/result-intercom.ts";
-import { projectNestedRegistryForRoot, sanitizeSummary } from "../shared/nested-events.ts";
-
-const WATCHER_RESTART_DELAY_MS = 3000;
-const POLL_INTERVAL_MS = 3000;
-
-type ResultWatcherFs = Pick<typeof fs, "existsSync" | "readFileSync" | "unlinkSync" | "readdirSync" | "mkdirSync" | "realpathSync" | "watch">;
-
-type ResultWatcherTimers = {
-	setTimeout: typeof setTimeout;
-	clearTimeout: typeof clearTimeout;
-	setInterval: typeof setInterval;
-	clearInterval: typeof clearInterval;
-};
-
-type ResultWatcherDeps = {
-	fs?: ResultWatcherFs;
-	timers?: ResultWatcherTimers;
-};
-
-type ResultFileChild = {
-	agent?: string;
-	output?: string;
-	error?: string;
-	success?: boolean;
-	sessionFile?: string;
-	artifactPaths?: { outputPath?: string };
-	intercomTarget?: string;
-	children?: unknown;
-};
-
-type ResultFileData = {
-	id?: string;
-	runId?: string;
-	agent?: string;
-	success?: boolean;
-	state?: string;
-	mode?: string;
-	summary?: string;
-	results?: ResultFileChild[];
-	nestedChildren?: unknown;
-	sessionId?: string;
-	cwd?: string;
-	sessionFile?: string;
-	asyncDir?: string;
-	intercomTarget?: string;
-};
-
-function sanitizeNestedResultChildren(value: unknown, resultPath: string, label: string): NestedRunSummary[] | undefined {
-	if (value === undefined) return undefined;
-	if (!Array.isArray(value)) {
-		console.error(`Ignoring invalid nested children in subagent result file '${resultPath}' at ${label}: expected an array.`);
-		return undefined;
-	}
-	const children = value.map((child) => sanitizeSummary(child)).filter((child): child is NestedRunSummary => Boolean(child));
-	if (children.length !== value.length) {
-		console.error(`Ignoring ${value.length - children.length} invalid nested child record(s) in subagent result file '${resultPath}' at ${label}.`);
-	}
-	return children.length ? children : undefined;
-}
-
-function getErrorCode(error: unknown): string | undefined {
-	return typeof error === "object" && error !== null && "code" in error
-		? (error as NodeJS.ErrnoException).code
-		: undefined;
-}
-
-function isNotFoundError(error: unknown): boolean {
-	return getErrorCode(error) === "ENOENT";
-}
-
-function shouldFallBackToPolling(error: unknown): boolean {
-	const code = getErrorCode(error);
-	return code === "EMFILE" || code === "ENOSPC";
-}
-
-function resolveNativeWatchDir(fsApi: ResultWatcherFs, resultsDir: string): string {
-	try {
-		return fsApi.realpathSync.native(resultsDir);
-	} catch {
-		return resultsDir;
-	}
-}
-
-export function createResultWatcher(
-	pi: { events: IntercomEventBus },
-	state: SubagentState,
-	resultsDir: string,
-	completionTtlMs: number,
-	deps: ResultWatcherDeps = {},
-): {
-	startResultWatcher: () => void;
-	primeExistingResults: () => void;
-	stopResultWatcher: () => void;
-} {
-	const fsApi = deps.fs ?? fs;
-	const timers = deps.timers ?? { setTimeout, clearTimeout, setInterval, clearInterval };
-
-	const handleResult = async (file: string) => {
-		const resultPath = path.join(resultsDir, file);
-		if (!fsApi.existsSync(resultPath)) return;
-		try {
-			const data = JSON.parse(fsApi.readFileSync(resultPath, "utf-8")) as ResultFileData;
-			if (typeof data.sessionId !== "string" || data.sessionId !== state.currentSessionId) return;
-
-			const runId = data.runId ?? data.id ?? file.replace(/\.json$/i, "");
-			const hasExplicitNestedChildren = data.nestedChildren !== undefined;
-			let nestedChildren = compactNestedResultChildren(sanitizeNestedResultChildren(data.nestedChildren, resultPath, "nestedChildren"));
-			if (!nestedChildren?.length && !hasExplicitNestedChildren) {
-				try {
-					nestedChildren = compactNestedResultChildren(projectNestedRegistryForRoot(runId)?.children);
-				} catch (error) {
-					console.error(`Failed to enrich subagent result file '${resultPath}' with nested registry children; will retry later:`, error);
-					return;
-				}
-			}
-			const now = Date.now();
-			const completionKey = buildCompletionKey(data, `result:${file}`);
-			if (markSeenWithTtl(state.completionSeen, completionKey, now, completionTtlMs)) {
-				fsApi.unlinkSync(resultPath);
-				return;
-			}
-
-			const hasResultChildren = Array.isArray(data.results) && data.results.length > 0;
-			const resultChildren = hasResultChildren
-				? data.results!
-				: [{
-					agent: data.agent,
-					output: data.summary,
-					success: data.success,
-				}];
-			const normalizedChildren = attachNestedChildrenToResultChildren(runId, resultChildren.map((result = {}, index): SubagentResultIntercomChild => {
-				const baseOutput = result.output ?? data.summary;
-				const hasRealOutput = typeof baseOutput === "string" && baseOutput.trim().length > 0;
-				const output = hasRealOutput ? baseOutput : "(no output)";
-				const summary = result.success === false && result.error
-					? `${result.error}${hasRealOutput ? `\n\nOutput:\n${baseOutput}` : ""}`
-					: output;
-				const sessionPath = result.sessionFile ?? (resultChildren.length === 1 ? data.sessionFile : undefined);
-				const childNestedChildren = sanitizeNestedResultChildren(result.children, resultPath, `results[${index}].children`);
-				return {
-					agent: result.agent ?? data.agent ?? `step-${index + 1}`,
-					status: resolveSubagentResultStatus({
-						success: result.success,
-						state: data.state === "paused" || typeof result.success !== "boolean" ? data.state : undefined,
-					}),
-					summary,
-					index,
-					artifactPath: result.artifactPaths?.outputPath,
-					...(typeof sessionPath === "string" && fsApi.existsSync(sessionPath) ? { sessionPath } : {}),
-					...(result.intercomTarget ? { intercomTarget: result.intercomTarget } : {}),
-					...(childNestedChildren ? { children: childNestedChildren } : {}),
-				};
-			}), nestedChildren);
-
-			const intercomTarget = data.intercomTarget?.trim();
-			if (intercomTarget) {
-				const mode = data.mode === "single" || data.mode === "parallel" || data.mode === "chain"
-					? data.mode
-					: resultChildren.length > 1 ? "chain" : "single";
-				const payload = buildSubagentResultIntercomPayload({
-					to: intercomTarget,
-					runId,
-					mode,
-					source: "async",
-					children: normalizedChildren,
-					asyncId: data.id,
-					asyncDir: data.asyncDir,
-				});
-				const delivered = await deliverSubagentResultIntercomEvent(pi.events, payload);
-				if (!delivered) {
-					console.error(`Subagent async grouped result intercom delivery was not acknowledged for '${resultPath}'.`);
-				}
-			}
-
-			pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
-				...data,
-				runId,
-				...(nestedChildren?.length ? { nestedChildren } : {}),
-				...(Array.isArray(data.results) ? {
-					results: hasResultChildren
-						? normalizedChildren.map((child, index) => ({
-							...data.results![index],
-							agent: child.agent,
-							status: child.status,
-							summary: child.summary,
-							index: child.index,
-							artifactPath: child.artifactPath,
-							sessionPath: child.sessionPath,
-							children: child.children,
-						}))
-						: [],
-				} : {}),
-			});
-			fsApi.unlinkSync(resultPath);
-		} catch (error) {
-			if (isNotFoundError(error)) return;
-			console.error(`Failed to process subagent result file '${resultPath}':`, error);
-		}
-	};
-
-	state.resultFileCoalescer = createFileCoalescer((file) => {
-		void handleResult(file);
-	}, 50);
-
-	const primeExistingResults = () => {
-		try {
-			fsApi.readdirSync(resultsDir)
-				.filter((f) => f.endsWith(".json"))
-				.forEach((file) => state.resultFileCoalescer.schedule(file, 0));
-		} catch (error) {
-			if (isNotFoundError(error)) return;
-			console.error(`Failed to scan subagent result directory '${resultsDir}':`, error);
-		}
-	};
-
-	const startPollingFallback = (reason: unknown) => {
-		state.watcher?.close();
-		state.watcher = null;
-		if (state.watcherRestartTimer) return;
-
-		console.error(
-			`Subagent result watcher for '${resultsDir}' fell back to polling because native fs.watch is unavailable (${getErrorCode(reason) ?? "unknown error"}).`,
-		);
-		primeExistingResults();
-		state.watcherRestartTimer = timers.setInterval(primeExistingResults, POLL_INTERVAL_MS);
-		state.watcherRestartTimer.unref?.();
-	};
-
-	const scheduleRestart = () => {
-		if (state.watcherRestartTimer) return;
-		state.watcherRestartTimer = timers.setTimeout(() => {
-			state.watcherRestartTimer = null;
-			try {
-				fsApi.mkdirSync(resultsDir, { recursive: true });
-				startResultWatcher();
-			} catch (error) {
-				if (shouldFallBackToPolling(error)) {
-					startPollingFallback(error);
-					return;
-				}
-				console.error(`Failed to restart subagent result watcher for '${resultsDir}':`, error);
-				scheduleRestart();
-			}
-		}, WATCHER_RESTART_DELAY_MS);
-		state.watcherRestartTimer.unref?.();
-	};
-
-	const startResultWatcher = () => {
-		if (state.watcher) return;
-		if (state.watcherRestartTimer) {
-			timers.clearTimeout(state.watcherRestartTimer);
-			timers.clearInterval(state.watcherRestartTimer);
-			state.watcherRestartTimer = null;
-		}
-		try {
-			const watchDir = resolveNativeWatchDir(fsApi, resultsDir);
-			state.watcher = fsApi.watch(watchDir, (ev, file) => {
-				if (ev !== "rename" || !file) return;
-				const fileName = file.toString();
-				if (!fileName.endsWith(".json")) return;
-				state.resultFileCoalescer.schedule(fileName);
-			});
-			state.watcher.on("error", (error) => {
-				if (shouldFallBackToPolling(error)) {
-					startPollingFallback(error);
-					return;
-				}
-				console.error(`Subagent result watcher failed for '${resultsDir}':`, error);
-				state.watcher?.close();
-				state.watcher = null;
-				scheduleRestart();
-			});
-			state.watcher.unref?.();
-		} catch (error) {
-			if (shouldFallBackToPolling(error)) {
-				startPollingFallback(error);
-				return;
-			}
-			console.error(`Failed to start subagent result watcher for '${resultsDir}':`, error);
-			state.watcher = null;
-			scheduleRestart();
-		}
-	};
-
-	const stopResultWatcher = () => {
-		state.watcher?.close();
-		state.watcher = null;
-		if (state.watcherRestartTimer) {
-			timers.clearTimeout(state.watcherRestartTimer);
-			timers.clearInterval(state.watcherRestartTimer);
-		}
-		state.watcherRestartTimer = null;
-		state.resultFileCoalescer.clear();
-	};
-
-	return { startResultWatcher, primeExistingResults, stopResultWatcher };
-}

package/extensions/dm-subagents/src/runs/background/run-id-resolver.ts

@@ -1,84 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { ASYNC_DIR, RESULTS_DIR, type SubagentState } from "../../shared/types.ts";
-import { findAsyncRunPrefixMatches, type AsyncRunLocation } from "./async-resume.ts";
-import { assertSafeNestedId, findNestedRunMatchesById, type NestedRoute, type NestedRunMatch, type NestedRunResolutionScope } from "../shared/nested-events.ts";
-
-export type ResolvedSubagentRunId =
-	| { kind: "foreground"; id: string }
-	| { kind: "async"; id: string; location: AsyncRunLocation }
-	| { kind: "nested"; id: string; match: NestedRunMatch };
-
-export interface ResolveSubagentRunIdDeps {
-	state?: SubagentState;
-	asyncDirRoot?: string;
-	resultsDir?: string;
-	nested?: NestedRunResolutionScope;
-}
-
-function exactAsyncLocation(id: string, asyncDirRoot: string, resultsDir: string): AsyncRunLocation | undefined {
-	const asyncDir = path.join(asyncDirRoot, id);
-	const resultPath = path.join(resultsDir, `${id}.json`);
-	if (!fs.existsSync(asyncDir) && !fs.existsSync(resultPath)) return undefined;
-	return {
-		asyncDir: fs.existsSync(asyncDir) ? asyncDir : null,
-		resultPath: fs.existsSync(resultPath) ? resultPath : null,
-		resolvedId: id,
-	};
-}
-
-function foregroundIds(state: SubagentState | undefined): string[] {
-	if (!state) return [];
-	return [...new Set([...state.foregroundControls.keys(), ...(state.foregroundRuns?.keys() ?? [])])];
-}
-
-function nestedScopeFromState(state: SubagentState | undefined): NestedRunResolutionScope | undefined {
-	if (!state) return undefined;
-	const routes: NestedRoute[] = [];
-	const seen = new Set<string>();
-	const add = (route: NestedRoute | undefined) => {
-		if (!route) return;
-		const key = `${route.rootRunId}:${route.eventSink}:${route.controlInbox}`;
-		if (seen.has(key)) return;
-		seen.add(key);
-		routes.push(route);
-	};
-	for (const control of state.foregroundControls.values()) add(control.nestedRoute as NestedRoute | undefined);
-	for (const job of state.asyncJobs.values()) add(job.nestedRoute as NestedRoute | undefined);
-	return { routes };
-}
-
-function asyncPrefixMatches(prefix: string, asyncDirRoot: string, resultsDir: string): Array<{ id: string; location: AsyncRunLocation }> {
-	return findAsyncRunPrefixMatches(prefix, asyncDirRoot, resultsDir);
-}
-
-export function resolveSubagentRunId(id: string, deps: ResolveSubagentRunIdDeps = {}): ResolvedSubagentRunId | undefined {
-	assertSafeNestedId("id", id);
-	const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
-	const resultsDir = deps.resultsDir ?? RESULTS_DIR;
-
-	const nestedScope = deps.nested ?? nestedScopeFromState(deps.state);
-	if (deps.state?.foregroundControls.has(id) || deps.state?.foregroundRuns?.has(id)) return { kind: "foreground", id };
-	const exactAsync = exactAsyncLocation(id, asyncDirRoot, resultsDir);
-	if (exactAsync) return { kind: "async", id, location: exactAsync };
-	const exactNested = findNestedRunMatchesById(id, nestedScope ? { scope: nestedScope } : {});
-	if (exactNested.length > 1) throw new Error(`Nested run id '${id}' is ambiguous across authorized registries. Provide the full id after stale registries are cleaned up.`);
-	if (exactNested[0]) return { kind: "nested", id, match: exactNested[0] };
-
-	const matches: ResolvedSubagentRunId[] = [];
-	for (const foregroundId of foregroundIds(deps.state).filter((candidate) => candidate.startsWith(id))) {
-		matches.push({ kind: "foreground", id: foregroundId });
-	}
-	for (const match of asyncPrefixMatches(id, asyncDirRoot, resultsDir)) {
-		matches.push({ kind: "async", id: match.id, location: match.location });
-	}
-	for (const match of findNestedRunMatchesById(id, nestedScope ? { prefix: true, scope: nestedScope } : { prefix: true })) {
-		matches.push({ kind: "nested", id: match.run.id, match });
-	}
-	const unique = new Map(matches.map((match) => [`${match.kind}:${match.id}`, match]));
-	const values = [...unique.values()];
-	if (values.length > 1) {
-		throw new Error(`Ambiguous subagent run id prefix '${id}' matched: ${values.map((match) => `${match.kind}:${match.id}`).join(", ")}. Provide a longer id.`);
-	}
-	return values[0];
-}