pi-subagents 0.21.1 → 0.21.2

package/{schemas.ts → src/extension/schemas.ts}

@@ -3,9 +3,9 @@
  */
 
 import { Type } from "typebox";
+import { SUBAGENT_ACTIONS } from "../shared/types.ts";
 
 const SkillOverride = Type.Unsafe({
-	type: ["string", "array", "boolean"],
 	anyOf: [
 		{ type: "array", items: { type: "string" } },
 		{ type: "boolean" },
@@ -15,12 +15,14 @@ const SkillOverride = Type.Unsafe({
 });
 
 const OutputOverride = Type.Unsafe({
-	type: ["string", "boolean"],
+	anyOf: [
+		{ type: "string" },
+		{ type: "boolean" },
+	],
 	description: "Output filename/path (string), or false to disable file output",
 });
 
 const ReadsOverride = Type.Unsafe({
-	type: ["array", "boolean"],
 	anyOf: [
 		{ type: "array", items: { type: "string" } },
 		{ type: "boolean" },
@@ -40,20 +42,6 @@ const TaskItem = Type.Object({
 	skill: Type.Optional(SkillOverride),
 });
 
-// Sequential chain step (single agent)
-const SequentialStepSchema = Type.Object({
-	agent: Type.String(),
-	task: Type.Optional(Type.String({ 
-		description: "Task template with variables: {task}=original request, {previous}=prior step's text response, {chain_dir}=shared folder. Required for first step, defaults to '{previous}' for subsequent steps." 
-	})),
-	cwd: Type.Optional(Type.String()),
-	output: Type.Optional(OutputOverride),
-	reads: Type.Optional(ReadsOverride),
-	progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking in {chain_dir}" })),
-	skill: Type.Optional(SkillOverride),
-	model: Type.Optional(Type.String({ description: "Override model for this step" })),
-});
-
 // Parallel task item (within a parallel step)
 const ParallelTaskSchema = Type.Object({
 	agent: Type.String(),
@@ -67,17 +55,7 @@ const ParallelTaskSchema = Type.Object({
 	model: Type.Optional(Type.String({ description: "Override model for this task" })),
 });
 
-// Parallel chain step (multiple agents running concurrently)
-const ParallelStepSchema = Type.Object({
-	parallel: Type.Array(ParallelTaskSchema, { minItems: 1, description: "Tasks to run in parallel" }),
-	concurrency: Type.Optional(Type.Number({ description: "Max concurrent tasks (default: 4)" })),
-	failFast: Type.Optional(Type.Boolean({ description: "Stop on first failure (default: false)" })),
-	worktree: Type.Optional(Type.Boolean({
-		description: "Create isolated git worktrees for each parallel task."
-	})),
-});
-
-// Flattened so providers that reject anyOf/oneOf can still accept either sequential or parallel steps.
+// Flattened so chain steps do not need an object-shape anyOf/oneOf union.
 const ChainItem = Type.Object({
 	agent: Type.Optional(Type.String({ description: "Sequential step agent name" })),
 	task: Type.Optional(Type.String({
@@ -100,9 +78,9 @@ const ChainItem = Type.Object({
 const ControlOverrides = Type.Object({
 	enabled: Type.Optional(Type.Boolean({ description: "Enable/disable subagent control attention tracking for this run" })),
 	needsAttentionAfterMs: Type.Optional(Type.Integer({ minimum: 1, description: "No-observed-activity window before a run needs attention" })),
-	activeNoticeAfterMs: Type.Optional(Type.Integer({ minimum: 1, description: "Active-long-running notice threshold by elapsed ms (default: 300000)" })),
-	activeNoticeAfterTurns: Type.Optional(Type.Integer({ minimum: 1, description: "Active-long-running notice threshold by assistant turns (default: 15)" })),
-	activeNoticeAfterTokens: Type.Optional(Type.Integer({ minimum: 1, description: "Active-long-running notice threshold by total tokens (default: 150000)" })),
+	activeNoticeAfterMs: Type.Optional(Type.Integer({ minimum: 1, description: "Active-long-running notice threshold by elapsed ms (default: 240000)" })),
+	activeNoticeAfterTurns: Type.Optional(Type.Integer({ minimum: 1, description: "Optional active-long-running notice threshold by assistant turns (disabled by default)" })),
+	activeNoticeAfterTokens: Type.Optional(Type.Integer({ minimum: 1, description: "Optional active-long-running notice threshold by total tokens (disabled by default)" })),
 	failedToolAttemptsBeforeAttention: Type.Optional(Type.Integer({ minimum: 1, description: "Consecutive mutating-tool failures before escalating to needs_attention (default: 3)" })),
 	notifyOn: Type.Optional(Type.Array(Type.String({ enum: ["active_long_running", "needs_attention"] }), {
 		description: "Control event types that should notify the parent/orchestrator. Defaults to active_long_running and needs_attention.",
@@ -117,26 +95,31 @@ export const SubagentParams = Type.Object({
 	task: Type.Optional(Type.String({ description: "Task (SINGLE mode, optional for self-contained agents)" })),
 	// Management action (when present, tool operates in management mode)
 	action: Type.Optional(Type.String({
-		description: "Action: 'list', 'get', 'create', 'update', 'delete', 'status', 'interrupt', or 'doctor' diagnostics. Omit for execution mode."
+		enum: [...SUBAGENT_ACTIONS],
+		description: "Management/control action. Omit for execution mode."
 	})),
 	id: Type.Optional(Type.String({
-		description: "Run id or prefix for action='status' or action='interrupt'."
+		description: "Run id or prefix for action='status', action='interrupt', or action='resume'."
 	})),
 	runId: Type.Optional(Type.String({
-		description: "Target run ID for action='interrupt'. Defaults to the most recently active controllable run in this session. Prefer id for new calls."
+		description: "Target run ID for action='interrupt' or action='resume'. Defaults to the most recently active controllable run for interrupt. Prefer id for new calls."
 	})),
 	dir: Type.Optional(Type.String({
-		description: "Async run directory for action='status'."
+		description: "Async run directory for action='status' or action='resume'."
 	})),
+	index: Type.Optional(Type.Integer({ minimum: 0, description: "Zero-based child index for actions that target a specific child." })),
+	message: Type.Optional(Type.String({ description: "Follow-up message for action='resume'." })),
 	// Chain identifier for management (can't reuse 'chain' — that's the execution array)
 	chainName: Type.Optional(Type.String({
 		description: "Chain name for get/update/delete management actions"
 	})),
 	// Agent/chain configuration for create/update (nested to avoid conflicts with execution fields)
 	config: Type.Optional(Type.Unsafe({
-		type: ["object", "string"],
-		additionalProperties: true,
-		description: "Agent or chain config for create/update. Agent: name, description, scope ('user'|'project', default 'user'), systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, defaultContext ('fresh'|'fork'), model, tools (comma-separated), extensions (comma-separated), skills (comma-separated), thinking, output, reads, progress, maxSubagentDepth. Chain: name, description, scope, steps (array of {agent, task?, output?, reads?, model?, skills?, progress?}). Presence of 'steps' creates a chain instead of an agent. String values must be valid JSON."
+		anyOf: [
+			{ type: "object", additionalProperties: true },
+			{ type: "string" },
+		],
+		description: "Agent or chain config for create/update. Agent: name, description, scope ('user'|'project', default 'user'), systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, defaultContext ('fresh'|'fork'), model, tools (comma-separated), extensions (comma-separated), skills (comma-separated), thinking, output, reads, progress, maxSubagentDepth. Chain: name, description, scope, steps (array of {agent, task?, output?, reads?, model?, skill?, progress?}). Presence of 'steps' creates a chain instead of an agent. String values must be valid JSON."
 	})),
 	tasks: Type.Optional(Type.Array(TaskItem, { description: "PARALLEL mode: [{agent, task, count?, output?, reads?, progress?}, ...]" })),
 	concurrency: Type.Optional(Type.Integer({ minimum: 1, description: "Top-level PARALLEL mode only: max concurrent tasks. Defaults to config.parallel.concurrency or 4." })),
@@ -165,7 +148,10 @@ export const SubagentParams = Type.Object({
 	control: Type.Optional(ControlOverrides),
 	// Solo agent overrides
 	output: Type.Optional(Type.Unsafe({
-		type: ["string", "boolean"],
+		anyOf: [
+			{ type: "string" },
+			{ type: "boolean" },
+		],
 		description: "Output file for single agent (string), or false to disable. Relative paths resolve against cwd.",
 	})),
 	skill: Type.Optional(SkillOverride),

package/{intercom-bridge.ts → src/intercom/intercom-bridge.ts}

@@ -1,8 +1,8 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import type { AgentConfig } from "./agents.ts";
-import type { ExtensionConfig, IntercomBridgeConfig, IntercomBridgeMode } from "./types.ts";
+import type { AgentConfig } from "../agents/agents.ts";
+import type { ExtensionConfig, IntercomBridgeConfig, IntercomBridgeMode } from "../shared/types.ts";
 
 function defaultIntercomExtensionDir(): string {
 	return path.join(os.homedir(), ".pi", "agent", "extensions", "pi-intercom");

package/{result-intercom.ts → src/intercom/result-intercom.ts}

@@ -8,7 +8,7 @@ import {
 	type SubagentResultStatus,
 	SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,
 	SUBAGENT_RESULT_INTERCOM_EVENT,
-} from "./types.ts";
+} from "../shared/types.ts";
 
 export function resolveSubagentResultStatus(input: {
 	exitCode?: number;
@@ -69,10 +69,24 @@ interface GroupedResultIntercomMessageInput {
 	chainSteps?: number;
 }
 
+function asyncResumeGuidance(input: {
+	source: "foreground" | "async";
+	children: SubagentResultIntercomChild[];
+	asyncId?: string;
+}): string | undefined {
+	if (input.source !== "async" || !input.asyncId) return undefined;
+	if (input.children.length === 1 && typeof input.children[0]?.sessionPath === "string") {
+		return `Revive: subagent({ action: "resume", id: "${input.asyncId}", message: "..." })`;
+	}
+	if (input.children.length > 1) return "Resume: unsupported for multi-child async runs until per-child session files are persisted.";
+	return "Resume: unavailable; no single child session file was persisted.";
+}
+
 function formatSubagentResultIntercomMessage(input: {
 	runId: string;
 	mode: "single" | "parallel" | "chain";
 	status: SubagentResultStatus;
+	source: "foreground" | "async";
 	children: SubagentResultIntercomChild[];
 	asyncId?: string;
 	asyncDir?: string;
@@ -92,16 +106,20 @@ function formatSubagentResultIntercomMessage(input: {
 	}
 	if (input.asyncId) lines.push(`Async id: ${input.asyncId}`);
 	if (input.asyncDir) lines.push(`Async dir: ${input.asyncDir}`);
+	const resumeGuidance = asyncResumeGuidance(input);
+	if (resumeGuidance) lines.push(resumeGuidance);
 	if (input.children.some((child) => child.intercomTarget)) {
 		lines.push("");
-		lines.push("Intercom targets below identify child sessions used while they were running; completed child sessions may no longer be reachable. Inspect artifacts or session logs for follow-up.");
+		lines.push(input.source === "async"
+			? "Previous intercom targets below identify child sessions used while they were running. Inspect artifacts or session logs if resume is unavailable."
+			: "Intercom targets below identify child sessions used while they were running; completed child sessions may no longer be reachable. Inspect artifacts or session logs for follow-up.");
 	}
 
 	for (let index = 0; index < input.children.length; index++) {
 		const child = input.children[index]!;
 		lines.push("");
 		lines.push(`${index + 1}. ${child.agent} — ${child.status}`);
-		if (child.intercomTarget) lines.push(`Run intercom target: ${child.intercomTarget}`);
+		if (child.intercomTarget) lines.push(`${input.source === "async" ? "Previous intercom target" : "Run intercom target"}: ${child.intercomTarget}`);
 		if (child.artifactPath) lines.push(`Output artifact: ${child.artifactPath}`);
 		if (child.sessionPath) lines.push(`Session: ${child.sessionPath}`);
 		lines.push("Summary:");
@@ -144,9 +162,19 @@ export async function deliverSubagentResultIntercomEvent(
 	events: IntercomEventBus,
 	payload: SubagentResultIntercomPayload,
 	timeoutMs = 500,
+): Promise<boolean> {
+	return deliverSubagentIntercomMessageEvent(events, payload.to, payload.message, timeoutMs, payload);
+}
+
+export async function deliverSubagentIntercomMessageEvent(
+	events: IntercomEventBus,
+	to: string,
+	message: string,
+	timeoutMs = 500,
+	extra: Record<string, unknown> = {},
 ): Promise<boolean> {
 	if (typeof events.on !== "function" || typeof events.emit !== "function") return false;
-	const requestId = payload.requestId ?? randomUUID();
+	const requestId = typeof extra.requestId === "string" ? extra.requestId : randomUUID();
 	return new Promise((resolve) => {
 		let settled = false;
 		let unsubscribe: (() => void) | undefined;
@@ -166,7 +194,7 @@ export async function deliverSubagentResultIntercomEvent(
 		});
 		timer = setTimeout(() => finish(false), timeoutMs);
 		try {
-			events.emit(SUBAGENT_RESULT_INTERCOM_EVENT, { ...payload, requestId });
+			events.emit(SUBAGENT_RESULT_INTERCOM_EVENT, { ...extra, to, message, requestId });
 		} catch {
 			finish(false);
 		}

package/{agent-manager-chain-detail.ts → src/manager-ui/agent-manager-chain-detail.ts}

@@ -1,8 +1,8 @@
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import { matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
-import type { ChainConfig, ChainStepConfig } from "./agents.ts";
-import { row, renderFooter, renderHeader, formatPath, formatScrollInfo } from "./render-helpers.ts";
-import { isParallelStep, type ChainStep } from "./settings.ts";
+import type { ChainConfig, ChainStepConfig } from "../agents/agents.ts";
+import { row, renderFooter, renderHeader, formatPath, formatScrollInfo } from "../tui/render-helpers.ts";
+import { isParallelStep, type ChainStep } from "../shared/settings.ts";
 
 export interface ChainDetailState {
 	scrollOffset: number;

package/{agent-manager-detail.ts → src/manager-ui/agent-manager-detail.ts}

@@ -1,12 +1,12 @@
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import { matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
-import type { AgentConfig } from "./agents.ts";
-import { formatDuration } from "./formatters.ts";
-import type { RunEntry } from "./run-history.ts";
-import { buildSkillInjection, resolveSkills } from "./skills.ts";
-import { ensureCursorVisible, getCursorDisplayPos, renderEditor, wrapText } from "./text-editor.ts";
-import type { TextEditorState } from "./text-editor.ts";
-import { pad, row, renderHeader, renderFooter, formatPath, formatScrollInfo } from "./render-helpers.ts";
+import type { AgentConfig } from "../agents/agents.ts";
+import { formatDuration } from "../shared/formatters.ts";
+import type { RunEntry } from "../runs/shared/run-history.ts";
+import { buildSkillInjection, resolveSkills } from "../agents/skills.ts";
+import { ensureCursorVisible, getCursorDisplayPos, renderEditor, wrapText } from "../tui/text-editor.ts";
+import type { TextEditorState } from "../tui/text-editor.ts";
+import { pad, row, renderHeader, renderFooter, formatPath, formatScrollInfo } from "../tui/render-helpers.ts";
 
 export interface DetailState {
 	resolved: boolean;

package/{agent-manager-edit.ts → src/manager-ui/agent-manager-edit.ts}

@@ -1,9 +1,9 @@
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import { matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
-import { defaultSystemPromptMode, type AgentConfig, type AgentDefaultContext, type BuiltinAgentOverrideBase } from "./agents.ts";
-import { createEditorState, ensureCursorVisible, getCursorDisplayPos, handleEditorInput, renderEditor, wrapText } from "./text-editor.ts";
-import type { TextEditorState } from "./text-editor.ts";
-import { pad, row, renderHeader, renderFooter, formatScrollInfo } from "./render-helpers.ts";
+import { defaultSystemPromptMode, type AgentConfig, type AgentDefaultContext, type BuiltinAgentOverrideBase } from "../agents/agents.ts";
+import { createEditorState, ensureCursorVisible, getCursorDisplayPos, handleEditorInput, renderEditor, wrapText } from "../tui/text-editor.ts";
+import type { TextEditorState } from "../tui/text-editor.ts";
+import { pad, row, renderHeader, renderFooter, formatScrollInfo } from "../tui/render-helpers.ts";
 
 export interface ModelInfo { provider: string; id: string; fullId: string; }
 export interface SkillInfo { name: string; source: string; description?: string; }

package/{agent-manager-list.ts → src/manager-ui/agent-manager-list.ts}

@@ -1,7 +1,7 @@
 import type { Theme } from "@mariozechner/pi-coding-agent";
-import type { AgentSource } from "./agents.ts";
+import type { AgentSource } from "../agents/agents.ts";
 import { matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
-import { pad, row, renderHeader, renderFooter, fuzzyFilter, formatScrollInfo } from "./render-helpers.ts";
+import { pad, row, renderHeader, renderFooter, fuzzyFilter, formatScrollInfo } from "../tui/render-helpers.ts";
 
 export interface ListAgent {
 	id: string;

package/{agent-manager-parallel.ts → src/manager-ui/agent-manager-parallel.ts}

@@ -1,8 +1,8 @@
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import { matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
-import type { TextEditorState } from "./text-editor.ts";
-import { createEditorState, handleEditorInput, renderEditor, wrapText, getCursorDisplayPos, ensureCursorVisible } from "./text-editor.ts";
-import { pad, row, renderHeader, renderFooter, fuzzyFilter } from "./render-helpers.ts";
+import type { TextEditorState } from "../tui/text-editor.ts";
+import { createEditorState, handleEditorInput, renderEditor, wrapText, getCursorDisplayPos, ensureCursorVisible } from "../tui/text-editor.ts";
+import { pad, row, renderHeader, renderFooter, fuzzyFilter } from "../tui/render-helpers.ts";
 
 interface ParallelSlot {
 	agentName: string;

package/{agent-manager.ts → src/manager-ui/agent-manager.ts}

@@ -14,20 +14,20 @@ import {
 	type AgentConfig,
 	type BuiltinAgentOverrideBase,
 	type ChainConfig,
-} from "./agents.ts";
-import { serializeAgent } from "./agent-serializer.ts";
-import { TEMPLATE_ITEMS, type AgentTemplate, type TemplateItem } from "./agent-templates.ts";
-import { parseChain, serializeChain } from "./chain-serializer.ts";
+} from "../agents/agents.ts";
+import { serializeAgent } from "../agents/agent-serializer.ts";
+import { TEMPLATE_ITEMS, type AgentTemplate, type TemplateItem } from "../agents/agent-templates.ts";
+import { parseChain, serializeChain } from "../agents/chain-serializer.ts";
 import { DEFAULT_AGENT_MANAGER_NEW_SHORTCUT, renderList, handleListInput, type ListAgent, type ListShortcuts, type ListState, type ListAction } from "./agent-manager-list.ts";
 import { createParallelState, handleParallelInput, renderParallel, formatParallelTitle, type ParallelState, type AgentOption } from "./agent-manager-parallel.ts";
 import { renderDetail, handleDetailInput, renderTaskInput, type DetailState, type DetailAction, type LaunchToggleState } from "./agent-manager-detail.ts";
 import { renderChainDetail, handleChainDetailInput, type ChainDetailAction, type ChainDetailState } from "./agent-manager-chain-detail.ts";
 import { createEditState, handleEditInput, renderEdit, type EditField, type EditScreen, type EditState, type ModelInfo, type SkillInfo } from "./agent-manager-edit.ts";
-import { createEditorState, ensureCursorVisible, getCursorDisplayPos, handleEditorInput, renderEditor, wrapText } from "./text-editor.ts";
-import type { TextEditorState } from "./text-editor.ts";
-import { loadRunsForAgent } from "./run-history.ts";
-import { pad, row, renderHeader, renderFooter } from "./render-helpers.ts";
-import { isParallelStep, type ChainStep } from "./settings.ts";
+import { createEditorState, ensureCursorVisible, getCursorDisplayPos, handleEditorInput, renderEditor, wrapText } from "../tui/text-editor.ts";
+import type { TextEditorState } from "../tui/text-editor.ts";
+import { loadRunsForAgent } from "../runs/shared/run-history.ts";
+import { pad, row, renderHeader, renderFooter } from "../tui/render-helpers.ts";
+import { isParallelStep, type ChainStep } from "../shared/settings.ts";
 
 export type ManagerResult =
 	| { action: "launch"; agent: string; task: string; skipClarify?: boolean; fork?: boolean; background?: boolean }

package/{async-execution.ts → src/runs/background/async-execution.ts}

@@ -9,16 +9,16 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import type { AgentConfig } from "./agents.ts";
-import { applyThinkingSuffix } from "./pi-args.ts";
-import { injectSingleOutputInstruction, resolveSingleOutputPath } from "./single-output.ts";
-import { buildChainInstructions, isParallelStep, resolveStepBehavior, writeInitialProgressFile, type ChainStep, type ResolvedStepBehavior, type SequentialStep, type StepOverrides } from "./settings.ts";
-import type { RunnerStep } from "./parallel-utils.ts";
-import { resolvePiPackageRoot } from "./pi-spawn.ts";
-import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "./skills.ts";
-import { resolveChildCwd } from "./utils.ts";
-import { buildModelCandidates, resolveModelCandidate, type AvailableModelInfo } from "./model-fallback.ts";
-import { resolveExpectedWorktreeAgentCwd } from "./worktree.ts";
+import type { AgentConfig } from "../../agents/agents.ts";
+import { applyThinkingSuffix } from "../shared/pi-args.ts";
+import { injectSingleOutputInstruction, resolveSingleOutputPath } from "../shared/single-output.ts";
+import { buildChainInstructions, isParallelStep, resolveStepBehavior, writeInitialProgressFile, type ChainStep, type ResolvedStepBehavior, type SequentialStep, type StepOverrides } from "../../shared/settings.ts";
+import type { RunnerStep } from "../shared/parallel-utils.ts";
+import { resolvePiPackageRoot } from "../shared/pi-spawn.ts";
+import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "../../agents/skills.ts";
+import { resolveChildCwd } from "../../shared/utils.ts";
+import { buildModelCandidates, resolveModelCandidate, type AvailableModelInfo } from "../shared/model-fallback.ts";
+import { resolveExpectedWorktreeAgentCwd } from "../shared/worktree.ts";
 import {
 	type ArtifactConfig,
 	type Details,
@@ -30,7 +30,7 @@ import {
 	TEMP_ROOT_DIR,
 	getAsyncConfigPath,
 	resolveChildMaxSubagentDepth,
-} from "./types.ts";
+} from "../../shared/types.ts";
 
 const require = createRequire(import.meta.url);
 const piPackageRoot = resolvePiPackageRoot();

package/{async-job-tracker.ts → src/runs/background/async-job-tracker.ts}

@@ -1,8 +1,8 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { renderWidget } from "./render.ts";
-import { formatControlNoticeMessage } from "./subagent-control.ts";
+import { renderWidget } from "../../tui/render.ts";
+import { formatControlNoticeMessage } from "../shared/subagent-control.ts";
 import {
 	type AsyncJobState,
 	type AsyncParallelGroupStatus,
@@ -10,10 +10,12 @@ import {
 	type ControlEvent,
 	type SubagentState,
 	POLL_INTERVAL_MS,
+	RESULTS_DIR,
 	SUBAGENT_CONTROL_EVENT,
 	SUBAGENT_CONTROL_INTERCOM_EVENT,
-} from "./types.ts";
-import { readStatus } from "./utils.ts";
+} from "../../shared/types.ts";
+import { readStatus } from "../../shared/utils.ts";
+import { reconcileAsyncRun } from "./stale-run-reconciler.ts";
 
 
 function isValidParallelGroup(group: AsyncParallelGroupStatus, stepCount: number, chainStepCount: number): boolean {
@@ -35,6 +37,9 @@ function normalizeParallelGroups(groups: AsyncParallelGroupStatus[] | undefined,
 interface AsyncJobTrackerOptions {
 	completionRetentionMs?: number;
 	pollIntervalMs?: number;
+	resultsDir?: string;
+	kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
+	now?: () => number;
 }
 
 export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: SubagentState, asyncDirRoot: string, options: AsyncJobTrackerOptions = {}): {
@@ -45,6 +50,7 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 } {
 	const completionRetentionMs = options.completionRetentionMs ?? 10000;
 	const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
+	const resultsDir = options.resultsDir ?? RESULTS_DIR;
 	const rerenderWidget = (ctx: ExtensionContext, jobs = Array.from(state.asyncJobs.values())) => {
 		renderWidget(ctx, jobs);
 		ctx.ui.requestRender?.();
@@ -132,7 +138,20 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 			for (const job of state.asyncJobs.values()) {
 				try {
 					emitNewControlEvents(job);
-					const status = readStatus(job.asyncDir);
+					const reconciliation = reconcileAsyncRun(job.asyncDir, {
+						resultsDir,
+						kill: options.kill,
+						now: options.now,
+						startedRun: {
+							runId: job.asyncId,
+							pid: job.pid,
+							mode: job.mode,
+							agents: job.agents,
+							startedAt: job.startedAt,
+							sessionFile: job.sessionFile,
+						},
+					});
+					const status = reconciliation.status ?? readStatus(job.asyncDir);
 					if (status) {
 						const previousStatus = job.status;
 						job.status = status.state;
@@ -167,7 +186,7 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 						job.outputFile = status.outputFile ?? job.outputFile;
 						job.totalTokens = status.totalTokens ?? job.totalTokens;
 						job.sessionFile = status.sessionFile ?? job.sessionFile;
-						if ((job.status === "complete" || job.status === "failed" || job.status === "paused") && previousStatus !== job.status) {
+						if ((job.status === "complete" || job.status === "failed" || job.status === "paused") && (previousStatus !== job.status || !state.cleanupTimers.has(job.asyncId))) {
 							scheduleCleanup(job.asyncId);
 						}
 						continue;
@@ -178,6 +197,9 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 					console.error(`Failed to read async status for '${job.asyncDir}':`, error);
 					job.status = "failed";
 					job.updatedAt = Date.now();
+					if (!state.cleanupTimers.has(job.asyncId)) {
+						scheduleCleanup(job.asyncId);
+					}
 				}
 			}
 
@@ -202,6 +224,7 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 			asyncId: info.id,
 			asyncDir,
 			status: "queued",
+			pid: typeof info.pid === "number" ? info.pid : undefined,
 			mode: info.chain ? "chain" : "single",
 			agents,
 			stepsTotal: firstGroupCount ?? agents?.length,