pi-subagents 0.28.0 → 0.30.0

package/src/agents/proactive-skills.ts

@@ -0,0 +1,191 @@
+import type { AgentConfig, ChainConfig, ChainStepConfig } from "./agents.ts";
+import type { ProactiveSkillSubagentsConfig } from "../shared/types.ts";
+
+const SUBAGENT_ORCHESTRATION_SKILL = "pi-subagents";
+const DEFAULT_MIN_REFERENCES = 2;
+const DEFAULT_MAX_RECOMMENDATIONS = 3;
+const DEFAULT_PREFERRED_AGENT = "reviewer";
+const FALLBACK_AGENT_ORDER = ["reviewer", "context-builder", "delegate"];
+const MAX_RECOMMENDATION_CAP = 5;
+
+export interface ResolvedProactiveSkillSubagentsConfig {
+	enabled: boolean;
+	minReferences: number;
+	maxRecommendations: number;
+	preferredAgent: string;
+}
+
+export interface ProactiveSkillSubagentRecommendation {
+	skill: string;
+	agent: string;
+	references: number;
+	sources: string[];
+	description?: string;
+	reason: string;
+}
+
+export interface AvailableSkill {
+	name: string;
+	description?: string;
+}
+
+function positiveInteger(value: unknown): number | undefined {
+	if (typeof value !== "number") return undefined;
+	if (!Number.isInteger(value) || !Number.isFinite(value) || value < 1) return undefined;
+	return value;
+}
+
+export function resolveProactiveSkillSubagentsConfig(
+	config?: ProactiveSkillSubagentsConfig | false,
+): ResolvedProactiveSkillSubagentsConfig {
+	if (config === false) {
+		return {
+			enabled: false,
+			minReferences: DEFAULT_MIN_REFERENCES,
+			maxRecommendations: DEFAULT_MAX_RECOMMENDATIONS,
+			preferredAgent: DEFAULT_PREFERRED_AGENT,
+		};
+	}
+
+	const maxRecommendations = positiveInteger(config?.maxRecommendations) ?? DEFAULT_MAX_RECOMMENDATIONS;
+	return {
+		enabled: config?.enabled ?? true,
+		minReferences: positiveInteger(config?.minReferences) ?? DEFAULT_MIN_REFERENCES,
+		maxRecommendations: Math.min(maxRecommendations, MAX_RECOMMENDATION_CAP),
+		preferredAgent: typeof config?.preferredAgent === "string" && config.preferredAgent.trim()
+			? config.preferredAgent.trim()
+			: DEFAULT_PREFERRED_AGENT,
+	};
+}
+
+function normalizeSkillNames(value: unknown): string[] {
+	if (value === false || value === true || value === undefined || value === null) return [];
+	if (Array.isArray(value)) {
+		return [...new Set(value.filter((entry): entry is string => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean))];
+	}
+	if (typeof value === "string") {
+		return [...new Set(value.split(",").map((entry) => entry.trim()).filter(Boolean))];
+	}
+	return [];
+}
+
+function collectStepSkills(step: ChainStepConfig, out: Set<string>): void {
+	for (const skill of normalizeSkillNames(step.skills ?? (step as { skill?: unknown }).skill)) {
+		out.add(skill);
+	}
+
+	const parallel = step.parallel;
+	if (!parallel) return;
+	if (Array.isArray(parallel)) {
+		for (const child of parallel) {
+			if (child && typeof child === "object" && !Array.isArray(child)) {
+				collectStepSkills(child as ChainStepConfig, out);
+			}
+		}
+		return;
+	}
+	if (typeof parallel === "object") {
+		collectStepSkills(parallel as ChainStepConfig, out);
+	}
+}
+
+function chooseRecommendationAgent(agents: AgentConfig[], preferredAgent: string): string | undefined {
+	const enabled = agents.filter((agent) => !agent.disabled);
+	if (enabled.some((agent) => agent.name === preferredAgent)) return preferredAgent;
+	for (const name of FALLBACK_AGENT_ORDER) {
+		if (enabled.some((agent) => agent.name === name)) return name;
+	}
+	return enabled[0]?.name;
+}
+
+function addSource(counts: Map<string, Set<string>>, skill: string, source: string): void {
+	if (skill === SUBAGENT_ORCHESTRATION_SKILL) return;
+	const sources = counts.get(skill) ?? new Set<string>();
+	sources.add(source);
+	counts.set(skill, sources);
+}
+
+export function recommendProactiveSkillSubagents(input: {
+	agents: AgentConfig[];
+	chains?: ChainConfig[];
+	availableSkills?: AvailableSkill[];
+	config?: ProactiveSkillSubagentsConfig | false;
+}): ProactiveSkillSubagentRecommendation[] {
+	const config = resolveProactiveSkillSubagentsConfig(input.config);
+	if (!config.enabled) return [];
+
+	const agent = chooseRecommendationAgent(input.agents, config.preferredAgent);
+	if (!agent) return [];
+
+	const availableByName = input.availableSkills
+		? new Map(input.availableSkills.map((skill) => [skill.name, skill]))
+		: undefined;
+	const counts = new Map<string, Set<string>>();
+
+	for (const candidate of input.agents) {
+		if (candidate.disabled) continue;
+		for (const skill of candidate.skills ?? []) {
+			addSource(counts, skill, `agent:${candidate.name}`);
+		}
+	}
+
+	for (const chain of input.chains ?? []) {
+		const chainSkills = new Set<string>();
+		for (const step of chain.steps) {
+			collectStepSkills(step, chainSkills);
+		}
+		for (const skill of chainSkills) {
+			addSource(counts, skill, `chain:${chain.name}`);
+		}
+	}
+
+	return [...counts.entries()]
+		.filter(([skill, sources]) => sources.size >= config.minReferences && (!availableByName || availableByName.has(skill)))
+		.map(([skill, sources]) => ({
+			skill,
+			agent,
+			references: sources.size,
+			sources: [...sources].sort((a, b) => a.localeCompare(b)),
+			description: availableByName?.get(skill)?.description,
+			reason: `referenced by ${sources.size} configured agents/chains`,
+		}))
+		.sort((a, b) => b.references - a.references || a.skill.localeCompare(b.skill))
+		.slice(0, config.maxRecommendations);
+}
+
+export function formatProactiveSkillSubagentRecommendations(
+	recommendations: ProactiveSkillSubagentRecommendation[],
+): string[] {
+	if (recommendations.length === 0) return [];
+	return [
+		"Proactive skill subagent suggestions:",
+		...recommendations.map((recommendation) => {
+			const sampleSources = recommendation.sources.slice(0, 3).join(", ");
+			const extra = recommendation.sources.length > 3 ? `, +${recommendation.sources.length - 3} more` : "";
+			const description = recommendation.description ? ` - ${recommendation.description}` : "";
+			return `- ${recommendation.skill} via ${recommendation.agent} (${recommendation.reason}; ${sampleSources}${extra})${description}`;
+		}),
+		"Guardrails: use these for broad tasks where a skill-specialist pass is useful; keep fanout small, use fresh context unless private/session context is explicitly needed, and skip when the user asks for a direct answer.",
+	];
+}
+
+export function buildProactiveSkillSubagentRecommendationLines(input: {
+	agents: AgentConfig[];
+	chains?: ChainConfig[];
+	config?: ProactiveSkillSubagentsConfig | false;
+	discoverAvailableSkills: () => AvailableSkill[];
+}): string[] {
+	if (!resolveProactiveSkillSubagentsConfig(input.config).enabled) return [];
+	let availableSkills: AvailableSkill[];
+	try {
+		availableSkills = input.discoverAvailableSkills();
+	} catch {
+		availableSkills = [];
+	}
+	return formatProactiveSkillSubagentRecommendations(recommendProactiveSkillSubagents({
+		agents: input.agents,
+		chains: input.chains,
+		availableSkills,
+		config: input.config,
+	}));
+}

package/src/extension/doctor.ts

@@ -81,7 +81,7 @@ function formatExistingDirectory(label: string, dirPath: string): string {
 }
 
 function formatSourceCounts(counts: Record<AgentSource, number>): string {
-	return `builtin ${counts.builtin}, user ${counts.user}, project ${counts.project}`;
+	return `builtin ${counts.builtin}, package ${counts.package}, user ${counts.user}, project ${counts.project}`;
 }
 
 function formatSkillSourceCounts(skills: Array<{ source: SkillSource }>): string {
@@ -132,15 +132,16 @@ function formatDiscovery(input: DoctorReportInput, deps: DoctorDeps): string[] {
 			const discovered = deps.discoverAgentsAll(input.cwd);
 			const agentCounts = {
 				builtin: discovered.builtin.length,
+				package: discovered.package?.length ?? 0,
 				user: discovered.user.length,
 				project: discovered.project.length,
 			};
 			const chainCounts = discovered.chains.reduce<Record<AgentSource, number>>((counts, chain) => {
 				counts[chain.source] += 1;
 				return counts;
-			}, { builtin: 0, user: 0, project: 0 });
+			}, { builtin: 0, package: 0, user: 0, project: 0 });
 			return [
-				`- agents: total ${agentCounts.builtin + agentCounts.user + agentCounts.project} (${formatSourceCounts(agentCounts)})`,
+				`- agents: total ${agentCounts.builtin + agentCounts.package + agentCounts.user + agentCounts.project} (${formatSourceCounts(agentCounts)})`,
 				`- chains: total ${discovered.chains.length} (${formatSourceCounts(chainCounts)})`,
 			].join("\n");
 		}),

package/src/extension/fanout-child.ts

@@ -156,9 +156,7 @@ export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI):
 		label: "Subagent",
 		description: [
 			"Delegate to subagents from child-safe fanout mode.",
-			"For goal-style requests such as /goal, goal, active goal, or work until evidence says done, use explicit acceptance on the delegated run: criteria for the target, evidence/verify for proof, stopRules for constraints, and maxFinalizationTurns for the bounded loop.",
-			"For implementation handoffs from a plan, PRD, spec, issue, or broad fix, put implementation instructions and plan paths in task, and put the definition of done, evidence, verification commands, constraints, and loop cap in acceptance.",
-			"Allowed management/control actions: list, get, status, interrupt, resume, doctor.",
+			"Allowed management/control actions: list, get, status, interrupt, resume, append-step, doctor.",
 			"Agent config mutation actions create, update, and delete are blocked in this mode.",
 		].join("\n"),
 		parameters: SubagentParams,

package/src/extension/index.ts

@@ -33,8 +33,7 @@ import { registerSlashSubagentBridge } from "../slash/slash-bridge.ts";
 import { clearSlashSnapshots, getSlashRenderableSnapshot, resolveSlashMessageDetails, restoreSlashFinalSnapshots, type SlashMessageDetails } from "../slash/slash-live-state.ts";
 import { inspectSubagentStatus } from "../runs/background/run-status.ts";
 import registerSubagentNotify, { type SubagentNotifyDetails } from "../runs/background/notify.ts";
-import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.ts";
-import registerFanoutChildSubagentExtension from "./fanout-child.ts";
+import { SUBAGENT_CHILD_ENV } from "../runs/shared/pi-args.ts";
 import { formatDuration, shortenPath } from "../shared/formatters.ts";
 import { loadConfig } from "./config.ts";
 import {
@@ -209,7 +208,6 @@ class SubagentControlNoticeComponent implements Component {
 
 export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	if (process.env[SUBAGENT_CHILD_ENV] === "1") {
-		if (process.env[SUBAGENT_FANOUT_CHILD_ENV] === "1") registerFanoutChildSubagentExtension(pi);
 		return;
 	}
 	const globalStore = globalThis as Record<string, unknown>;
@@ -394,10 +392,8 @@ EXECUTION (use exactly ONE mode):
 • SINGLE: { agent, task? } - one task; omit task for self-contained agents
 • CHAIN: { chain: [{agent:"agent-a"}, {parallel:[{agent:"agent-b",count:3}]}] } - sequential pipeline with optional parallel fan-out
 • PARALLEL: { tasks: [{agent,task,count?,output?,reads?,progress?}, ...], concurrency?: number, worktree?: true } - concurrent execution (worktree: isolate each task in a git worktree)
-• Foreground timeout: { timeoutMs } or { maxRuntimeMs } - wall-clock limit for foreground single, parallel, and chain runs. Timed-out children return timedOut:true with completed sibling/prior results preserved. Not for async/background runs.
 • Optional context: { context: "fresh" | "fork" } (default: if any requested agent has defaultContext: "fork", the whole invocation uses fork; otherwise "fresh"; inspect agent defaults via { action: "list" })
-• Goal-style requests: when the user says “/goal”, “goal”, “active goal”, “work until evidence says done”, or “verify against a goal”, model that as explicit acceptance. Use acceptance.criteria for the target, acceptance.evidence/verify for proof, acceptance.stopRules for constraints, and acceptance.maxFinalizationTurns for the bounded loop.
-• Plan/spec implementation handoffs: when delegating a plan, PRD, spec, issue, or broad fix to an editing-capable child, prefer structured acceptance instead of burying validation requirements in task prose. Put the implementation instructions and plan paths in task; put the definition of done, evidence, verification commands, constraints, and loop cap in acceptance.
+• If { action: "list" } shows proactive skill subagent suggestions, consider a small fresh-context fanout for broad tasks where one of those skills would materially help
 
 CHAIN TEMPLATE VARIABLES (use in task strings):
 • {task} - The original task/request from the user
@@ -409,15 +405,16 @@ Example: { chain: [{agent:"agent-a", task:"Analyze {task}"}, {agent:"agent-b", t
 MANAGEMENT (use action field, omit agent/task/chain/tasks):
 • { action: "list" } - discover executable agents/chains
 • { action: "get", agent: "name" } - full detail; packaged agents use dotted runtime names like "package.agent"
-• { action: "create", config: { name: "custom-agent", package: "code-analysis", systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, defaultContext, maxExecutionTimeMs, maxTokens, ... } }
-• { action: "update", agent: "code-analysis.custom-agent", config: { package: "analysis", maxExecutionTimeMs, maxTokens, ... } } - merge
+• { action: "create", config: { name: "custom-agent", package: "code-analysis", systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, defaultContext, ... } }
+• { action: "update", agent: "code-analysis.custom-agent", config: { package: "analysis", ... } } - merge
 • { action: "delete", agent: "code-analysis.custom-agent" }
 • Use chainName for chain operations; packaged chains also use dotted runtime names
 
 CONTROL:
 • { action: "status", id: "..." } - inspect an async/background run by id or prefix
 • { action: "interrupt", id?: "..." } - soft-interrupt the current child turn and leave the run paused
-• { action: "resume", id: "...", message: "...", index?: 0 } - follow up with a live async child or revive a completed async/foreground child from its session
+• { action: "resume", id: "...", message: "...", index?: 0 } - interrupt then follow up with a live async child, or revive a completed async/foreground child from its session
+• { action: "append-step", id: "...", chain: [{agent:"agent-c", task:"Use {previous}"}] } - append one step to the tail of a running async chain
 
 DIAGNOSTICS:
 • { action: "doctor" } - read-only report for runtime paths, discovery, sessions, and intercom`,

package/src/extension/schemas.ts

@@ -5,6 +5,31 @@
 import { Type } from "typebox";
 import { SUBAGENT_ACTIONS } from "../shared/types.ts";
 
+function keepTopLevelParameterDescriptions<T>(schema: T): T {
+	return pruneNestedDescriptions(schema, []) as T;
+}
+
+function pruneNestedDescriptions(value: unknown, path: string[]): unknown {
+	if (!value || typeof value !== "object") return value;
+
+	const result = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value));
+	for (const key of Reflect.ownKeys(value)) {
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		if (!descriptor) continue;
+		if (key === "description" && !isTopLevelParameterDescription(path)) continue;
+		if ("value" in descriptor) {
+			const nextPath = typeof key === "string" ? [...path, key] : path;
+			descriptor.value = pruneNestedDescriptions(descriptor.value, nextPath);
+		}
+		Object.defineProperty(result, key, descriptor);
+	}
+	return result;
+}
+
+function isTopLevelParameterDescription(path: string[]): boolean {
+	return path.length === 2 && path[0] === "properties";
+}
+
 const SkillOverride = Type.Unsafe({
 	anyOf: [
 		{ type: "array", items: { type: "string" } },
@@ -78,30 +103,42 @@ const AcceptanceReviewGateSchema = Type.Object({
 }, { additionalProperties: false });
 
 const AcceptanceOverride = Type.Unsafe({
-	type: "object",
-	properties: {
-		criteria: {
-			type: "array",
-			items: {
-				anyOf: [
-					{ type: "string" },
-					AcceptanceGateSchema,
-				],
+	anyOf: [
+		{ type: "string", enum: ["auto", "none", "attested", "checked", "verified", "reviewed"] },
+		{ const: false },
+		{
+			type: "object",
+			properties: {
+				level: { type: "string", enum: ["auto", "none", "attested", "checked", "verified", "reviewed"] },
+				criteria: {
+					type: "array",
+					items: {
+						anyOf: [
+							{ type: "string" },
+							AcceptanceGateSchema,
+						],
+					},
+				},
+				evidence: { type: "array", items: AcceptanceEvidenceKind },
+				verify: { type: "array", items: AcceptanceVerifyCommandSchema },
+				review: {
+					anyOf: [
+						{ const: false },
+						AcceptanceReviewGateSchema,
+					],
+				},
+				stopRules: { type: "array", items: { type: "string" } },
+				reason: { type: "string" },
 			},
+			additionalProperties: false,
 		},
-		evidence: { type: "array", items: AcceptanceEvidenceKind },
-		verify: { type: "array", items: AcceptanceVerifyCommandSchema },
-		review: AcceptanceReviewGateSchema,
-		stopRules: { type: "array", items: { type: "string" } },
-		maxFinalizationTurns: { type: "integer", minimum: 1, maximum: 10 },
-	},
-	additionalProperties: false,
-	description: "Optional acceptance contract. Use this for goal-style requests and for implementation handoffs from plans, PRDs, specs, issues, or broad fixes. Put implementation instructions and plan paths in task; put the definition of done in criteria, proof in evidence/verify, constraints in stopRules, and the bounded loop budget in maxFinalizationTurns. Runtime validation still requires at least one of criteria, evidence, verify, review, or stopRules. When present, the child must complete a same-session self-review/repair loop before acceptance is evaluated.",
+	],
+	description: "Optional acceptance policy. Omitted means auto-inferred; verified requires configured runtime commands.",
 });
 
 const TaskItem = Type.Object({
-	agent: Type.String(),
-	task: Type.String(),
+	agent: Type.String(), 
+	task: Type.String(), 
 	cwd: Type.Optional(Type.String()),
 	count: Type.Optional(Type.Integer({ minimum: 1, description: "Repeat this parallel task N times with the same settings." })),
 	output: Type.Optional(OutputOverride),
@@ -221,7 +258,7 @@ const ControlOverrides = Type.Object({
 	})),
 });
 
-export const SubagentParams = Type.Object({
+const SubagentParamsSchema = Type.Object({
 	agent: Type.Optional(Type.String({ description: "Agent name (SINGLE mode) or target for management get/update/delete" })),
 	task: Type.Optional(Type.String({ description: "Task (SINGLE mode, optional for self-contained agents)" })),
 	// Management action (when present, tool operates in management mode)
@@ -230,10 +267,10 @@ export const SubagentParams = Type.Object({
 		description: "Management/control action. Omit for execution mode."
 	})),
 	id: Type.Optional(Type.String({
-		description: "Run id or prefix for action='status', action='interrupt', or action='resume'."
+		description: "Run id or prefix for action='status', action='interrupt', action='resume', or action='append-step'."
 	})),
 	runId: Type.Optional(Type.String({
-		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."
+		description: "Target run ID for action='interrupt', action='resume', or action='append-step'. 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' or action='resume'."
@@ -250,18 +287,16 @@ export const SubagentParams = Type.Object({
 			{ type: "object", additionalProperties: true },
 			{ type: "string" },
 		],
-		description: "Agent or chain config for create/update. Agent: name, package (optional namespace; runtime name becomes package.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, maxExecutionTimeMs, maxTokens. Chain: name, package, description, scope, steps (array of {agent, task?, output?, outputMode?, reads?, model?, skill?, progress?}). Presence of 'steps' creates a chain instead of an agent. String values must be valid JSON."
+		description: "Agent or chain config for create/update. Agent: name, package (optional namespace; runtime name becomes package.name), description, scope ('user'|'project', default 'user'), systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, defaultContext ('fresh'|'fork'), model, tools (comma-separated), extensions (comma-separated), subagentOnlyExtensions (comma-separated child-only extension paths), skills (comma-separated), thinking, output, reads, progress, maxSubagentDepth. Chain: name, package, description, scope, steps (array of {agent, task?, output?, outputMode?, 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?, outputMode?, 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." })),
-	timeoutMs: Type.Optional(Type.Integer({ minimum: 1, description: "Foreground execution wall-clock timeout in milliseconds. When it expires, running children are soft-interrupted and timed-out results are returned. Foreground only; async/background runs ignore this field." })),
-	maxRuntimeMs: Type.Optional(Type.Integer({ minimum: 1, description: "Alias for timeoutMs. Use only one unless both values are identical." })),
 	worktree: Type.Optional(Type.Boolean({
 		description: "Create isolated git worktrees for each parallel task. " +
 			"Prevents filesystem conflicts. Requires clean git state. " +
 			"Per-worktree diffs included in output."
 	})),
-	chain: Type.Optional(Type.Array(ChainItem, { description: "CHAIN mode: sequential pipeline where each step's response becomes {previous} for the next. Use {task}, {previous}, {chain_dir} in task templates." })),
+	chain: Type.Optional(Type.Array(ChainItem, { description: "CHAIN mode: sequential pipeline where each step's response becomes {previous} for the next. With action='append-step', provide exactly one step to append to an active async chain; it can use {previous}, {chain_dir}, and existing {outputs.name} references." })),
 	context: Type.Optional(Type.String({
 		enum: ["fresh", "fork"],
 		description: "'fresh' or 'fork' to branch from parent session. If omitted, any requested agent with defaultContext: 'fork' makes the whole invocation forked; otherwise the default is 'fresh'.",
@@ -292,3 +327,5 @@ export const SubagentParams = Type.Object({
 	model: Type.Optional(Type.String({ description: "Override model for single agent (e.g. 'anthropic/claude-sonnet-4')" })),
 	acceptance: Type.Optional(AcceptanceOverride),
 });
+
+export const SubagentParams = keepTopLevelParameterDescriptions(SubagentParamsSchema);

package/src/intercom/intercom-bridge.ts

@@ -17,6 +17,16 @@ function defaultIntercomExtensionDir(agentDir = defaultAgentDir()): string {
 	return path.join(agentDir, "extensions", PI_INTERCOM_PACKAGE_NAME);
 }
 
+export const INTERCOM_EXTENSION_DIR_ENV = "PI_INTERCOM_EXTENSION_DIR";
+
+// Launcher-provided override for the pi-intercom package directory. Lets a hermetic
+// wrapper point the subagent intercom bridge at a read-only install (e.g. a Nix-store
+// path) instead of seeding the package into the writable agent dir.
+function envIntercomExtensionDir(): string | undefined {
+	const dir = process.env[INTERCOM_EXTENSION_DIR_ENV]?.trim();
+	return dir ? dir : undefined;
+}
+
 function defaultIntercomConfigPath(agentDir = defaultAgentDir()): string {
 	return path.join(agentDir, "intercom", "config.json");
 }
@@ -224,7 +234,7 @@ function configuredPiIntercomPackageDir(input: ResolveIntercomBridgeInput, agent
 }
 
 function resolveIntercomExtensionDir(input: ResolveIntercomBridgeInput, agentDir: string): string {
-	const legacyDir = path.resolve(input.extensionDir ?? defaultIntercomExtensionDir(agentDir));
+	const legacyDir = path.resolve(input.extensionDir ?? envIntercomExtensionDir() ?? defaultIntercomExtensionDir(agentDir));
 	if (fs.existsSync(legacyDir)) return legacyDir;
 	return configuredPiIntercomPackageDir(input, agentDir) ?? legacyDir;
 }

package/src/intercom/result-intercom.ts

@@ -20,10 +20,8 @@ export function resolveSubagentResultStatus(input: {
 	state?: string;
 	interrupted?: boolean;
 	detached?: boolean;
-	timedOut?: boolean;
 }): SubagentResultStatus {
 	if (input.detached) return "detached";
-	if (input.timedOut || input.state === "timed-out") return "timed-out";
 	if (input.interrupted || input.state === "paused") return "paused";
 	if (typeof input.success === "boolean") return input.success ? "completed" : "failed";
 	if (input.state === "complete") return "completed";
@@ -38,7 +36,6 @@ function countStatuses(children: SubagentResultIntercomChild[]): Record<Subagent
 		failed: 0,
 		paused: 0,
 		detached: 0,
-		"timed-out": 0,
 	};
 	for (const child of children) {
 		counts[child.status] += 1;
@@ -52,7 +49,6 @@ function formatStatusCounts(counts: Record<SubagentResultStatus, number>): strin
 		counts.failed ? `${counts.failed} failed` : undefined,
 		counts.paused ? `${counts.paused} paused` : undefined,
 		counts.detached ? `${counts.detached} detached` : undefined,
-		counts["timed-out"] ? `${counts["timed-out"]} timed out` : undefined,
 	].filter((part): part is string => Boolean(part));
 	return parts.length ? parts.join(", ") : "0 results";
 }
@@ -60,7 +56,6 @@ function formatStatusCounts(counts: Record<SubagentResultStatus, number>): strin
 function resolveGroupedStatus(children: SubagentResultIntercomChild[]): SubagentResultStatus {
 	const counts = countStatuses(children);
 	if (counts.failed > 0) return "failed";
-	if (counts["timed-out"] > 0) return "timed-out";
 	if (counts.paused > 0) return "paused";
 	if (counts.completed > 0) return "completed";
 	if (counts.detached > 0) return "detached";