pi-crew 0.1.45 → 0.1.46

package/src/extension/registration/subagent-helpers.ts

@@ -81,6 +81,13 @@ export function subagentToolResult(text: string, details: Record<string, unknown
 	return { content: [{ type: "text" as const, text }], details, isError };
 }
 
+function parseSkillParam(value: unknown): string | string[] | false | undefined {
+	if (value === false) return false;
+	if (typeof value === "string") return value;
+	if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) return value;
+	return undefined;
+}
+
 export function __test__subagentSpawnParams(params: Record<string, unknown>, ctx: Pick<ExtensionContext, "cwd">): SubagentSpawnOptions {
 	return {
 		cwd: ctx.cwd,
@@ -89,6 +96,7 @@ export function __test__subagentSpawnParams(params: Record<string, unknown>, ctx
 		prompt: typeof params.prompt === "string" ? params.prompt : "",
 		background: params.run_in_background === true,
 		model: typeof params.model === "string" && params.model.trim() ? params.model.trim() : undefined,
+		skill: parseSkillParam(params.skill),
 		maxTurns: typeof params.max_turns === "number" && Number.isFinite(params.max_turns) ? params.max_turns : undefined,
 	};
 }

package/src/extension/registration/subagent-tools.ts

@@ -1,148 +1,149 @@
-import type { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
-import { Type } from "typebox";
-import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import { handleTeamTool } from "../team-tool.ts";
-import { checkSubagentSpawnPermission, currentCrewRole } from "../../runtime/role-permission.ts";
-import { readPersistedSubagentRecord, savePersistedSubagentRecord, type SubagentManager, type SubagentSpawnOptions } from "../../subagents/manager.ts";
-import { loadConfig } from "../../config/config.ts";
-import { logInternalError } from "../../utils/internal-error.ts";
-import { __test__subagentSpawnParams, formatSubagentRecord, readSubagentRunResult, refreshPersistedSubagentRecord, subagentToolResult } from "./subagent-helpers.ts";
-import { t } from "../../i18n.ts";
-
-export interface SubagentToolRegistrationOptions {
-	ownerSessionGeneration?: () => number;
-}
-
-export function registerSubagentTools(pi: ExtensionAPI, subagentManager: SubagentManager, options: SubagentToolRegistrationOptions = {}): void {
-	const agentTool: ToolDefinition = {
-		name: "Agent",
-		label: "Agent",
-		description: "Launch a real pi-crew subagent. Uses pi-crew's durable child-process runtime by default; set run_in_background=true for parallel/background work, then use get_subagent_result.",
-		promptSnippet: "Use Agent to delegate focused work to a real pi-crew subagent. Use run_in_background=true for parallel work and get_subagent_result to join results.",
-		promptGuidelines: [
-			"Use Agent for independent exploration, review, verification, or implementation subtasks instead of doing all work in the parent turn.",
-			"For parallel work, launch multiple Agent calls with run_in_background=true, then call get_subagent_result for each result.",
-			"Available pi-crew subagent types include explorer, planner, analyst, executor, reviewer, verifier, writer, security-reviewer, and test-engineer.",
-		],
-		parameters: Type.Object({
-			prompt: Type.String({ description: "The task for the subagent to perform." }),
-			description: Type.String({ description: "Short 3-5 word task description." }),
-			subagent_type: Type.String({ description: "pi-crew agent name, e.g. explorer, planner, executor, reviewer, verifier, writer, security-reviewer, test-engineer." }),
-			model: Type.Optional(Type.String({ description: "Optional model override. If omitted, pi-crew uses Pi-configured model fallback." })),
-			max_turns: Type.Optional(Type.Number({ description: "Reserved for live-session subagents; child-process runtime may ignore this." })),
-			run_in_background: Type.Optional(Type.Boolean({ description: "Run in background and return an agent ID immediately." })),
-		}) as never,
-		async execute(_id, params, signal, _onUpdate, ctx) {
-			const currentRole = currentCrewRole();
-			const permission = checkSubagentSpawnPermission(currentRole);
-			if (!permission.allowed) return subagentToolResult(permission.reason ?? "Current role cannot spawn subagents.", { role: currentRole, mode: permission.mode }, true);
-			const spawnOptions = __test__subagentSpawnParams(params as Record<string, unknown>, ctx);
-			spawnOptions.ownerSessionGeneration = options.ownerSessionGeneration?.();
-			if (!spawnOptions.prompt.trim()) return subagentToolResult(t("agent.requiresPrompt"), {}, true);
-			const runner = async (currentOptions: SubagentSpawnOptions, childSignal?: AbortSignal) => handleTeamTool({ action: "run", agent: currentOptions.type, goal: currentOptions.prompt, model: currentOptions.model, async: currentOptions.background, config: currentOptions.maxTurns ? { runtime: { maxTurns: currentOptions.maxTurns } } : undefined } as TeamToolParamsValue, currentOptions.background ? { ...ctx, signal: childSignal } : { ...ctx, signal: childSignal });
-			const record = subagentManager.spawn(spawnOptions, runner, spawnOptions.background ? undefined : signal);
-			if (spawnOptions.background || record.status === "queued") {
-				// Phase 1.1a: Terminate turn for background queued — no LLM follow-up needed.
-				// Phase 1.6: Record was terminated for telemetry.
-				record.terminated = true;
-				savePersistedSubagentRecord(ctx.cwd, record);
-				return { ...subagentToolResult([t("agent.started", { state: record.status === "queued" ? "queued" : "started" }), t("agent.id", { id: record.id }), t("agent.type", { type: record.type }), t("agent.description", { description: record.description }), t("agent.retrieveHint")].join("\n"), { agentId: record.id, status: record.status }), terminate: true };
-			}
-			await record.promise;
-			const output = readSubagentRunResult(ctx, record) ?? record.result ?? t("agent.noOutput");
-			const foregroundResult = subagentToolResult([t("agent.foregroundStatus", { id: record.id, status: record.status }), "", output].join("\n"), { agentId: record.id, runId: record.runId, status: record.status }, record.status === "failed" || record.status === "error");
-			if (loadConfig(ctx.cwd).config.tools?.terminateOnForeground === true) {
-				record.terminated = true;
-				savePersistedSubagentRecord(ctx.cwd, record);
-				return { ...foregroundResult, terminate: true };
-			}
-			return foregroundResult;
-		},
-	};
-
-	const getSubagentResultTool: ToolDefinition = {
-		name: "get_subagent_result",
-		label: "Get Agent Result",
-		description: "Check status and retrieve results from a pi-crew background subagent.",
-		parameters: Type.Object({ agent_id: Type.String({ description: "Agent ID returned by Agent." }), wait: Type.Optional(Type.Boolean({ description: "Wait for completion before returning." })), verbose: Type.Optional(Type.Boolean({ description: "Include status metadata before output." })) }) as never,
-		async execute(_id, params, signal, _onUpdate, ctx) {
-			const p = params as { agent_id?: string; wait?: boolean; verbose?: boolean };
-			if (!p.agent_id) return subagentToolResult(t("result.requiresAgentId"), {}, true);
-			const inMemory = subagentManager.getRecord(p.agent_id);
-			const record = inMemory ?? readPersistedSubagentRecord(ctx.cwd, p.agent_id);
-			if (!record) return subagentToolResult(t("result.notFound", { id: p.agent_id }), {}, true);
-			let current = refreshPersistedSubagentRecord(ctx, record);
-			if (inMemory && current !== inMemory) Object.assign(inMemory, current);
-			if (!inMemory && !current.runId && (current.status === "running" || current.status === "queued")) {
-				current = { ...current, status: "error", error: t("result.unrecoverable"), completedAt: current.completedAt ?? Date.now() };
-				savePersistedSubagentRecord(ctx.cwd, current);
-			}
-			if (p.wait && (current.status === "running" || current.status === "queued")) {
-				const waited = await subagentManager.waitForRecord(current.id);
-				if (waited) current = waited;
-				if (current.status === "blocked") {
-					current.resultConsumed = false;
-					if (inMemory) inMemory.resultConsumed = false;
-					savePersistedSubagentRecord(ctx.cwd, current);
-				} else {
-					const waitStartMs = Date.now();
-					const maxWaitMs = 300_000; // 5 minutes
-					while (current.status === "running" || current.status === "queued") {
-						if (signal?.aborted) {
-							current = { ...current, status: "error", error: t("result.waitAborted"), completedAt: Date.now() };
-							savePersistedSubagentRecord(ctx.cwd, current);
-							break;
-						}
-						if (Date.now() - waitStartMs > maxWaitMs) {
-							current = { ...current, status: "error", error: t("result.waitTimeout"), completedAt: Date.now() };
-							savePersistedSubagentRecord(ctx.cwd, current);
-							break;
-						}
-						await new Promise((resolve) => setTimeout(resolve, 1000));
-						current = refreshPersistedSubagentRecord(ctx, current);
-						if (!current.runId) break;
-					}
-				}
-			}
-			const output = readSubagentRunResult(ctx, current);
-			if (current.status !== "running" && current.status !== "queued" && current.status !== "blocked") {
-				current.resultConsumed = true;
-				if (inMemory) inMemory.resultConsumed = true;
-				savePersistedSubagentRecord(ctx.cwd, current);
-			}
-			const text = [p.verbose ? formatSubagentRecord(current) : undefined, output ? `${p.verbose ? "\n" : ""}${output}` : current.status === "running" || current.status === "queued" ? t("result.stillRunning") : current.error ?? t("agent.noOutput")].filter((line): line is string => Boolean(line)).join("\n");
-			return subagentToolResult(text, { agentId: current.id, runId: current.runId, status: current.status }, current.status === "failed" || current.status === "error");
-		},
-	};
-
-	const steerSubagentTool: ToolDefinition = {
-		name: "steer_subagent",
-		label: "Steer Agent",
-		description: "Send a steering note to a running pi-crew subagent. Live-session steering is planned; child-process runs expose durable status and can be cancelled if needed.",
-		parameters: Type.Object({ agent_id: Type.String(), message: Type.String() }) as never,
-		async execute(_id, params, _signal, _onUpdate, ctx) {
-			const p = params as { agent_id?: string; message?: string };
-			const record = p.agent_id ? subagentManager.getRecord(p.agent_id) ?? readPersistedSubagentRecord(ctx.cwd, p.agent_id) : undefined;
-			if (!record) return subagentToolResult(t("result.notFound", { id: p.agent_id ?? "" }), {}, true);
-			return subagentToolResult([t("steer.noted", { id: record.id }), t("steer.unavailable"), record.runId ? t("steer.cancelHint", { runId: record.runId }) : undefined].filter((line): line is string => Boolean(line)).join("\n"), { agentId: record.id, runId: record.runId, status: record.status });
-		},
-	};
-
-	const crewAgentTool: ToolDefinition = { ...agentTool, name: "crew_agent", label: "Crew Agent", description: "Launch a real pi-crew subagent using a conflict-safe pi-crew-specific tool name.", promptSnippet: "Use crew_agent when you need pi-crew subagents and another extension may own the generic Agent tool." };
-	const crewAgentResultTool: ToolDefinition = { ...getSubagentResultTool, name: "crew_agent_result", label: "Get Crew Agent Result", description: "Check status and retrieve results from a pi-crew subagent using the conflict-safe tool name." };
-	const crewAgentSteerTool: ToolDefinition = { ...steerSubagentTool, name: "crew_agent_steer", label: "Steer Crew Agent", description: "Send a steering note to a pi-crew subagent using the conflict-safe tool name." };
-	const toolConfig = loadConfig(process.cwd()).config.tools;
-	const enableSteer = toolConfig?.enableSteer !== false;
-	const enableClaudeStyleAliases = toolConfig?.enableClaudeStyleAliases !== false;
-
-	for (const extraTool of enableSteer ? [crewAgentTool, crewAgentResultTool, crewAgentSteerTool] : [crewAgentTool, crewAgentResultTool]) pi.registerTool(extraTool);
-	if (enableClaudeStyleAliases) {
-		for (const extraTool of enableSteer ? [agentTool, getSubagentResultTool, steerSubagentTool] : [agentTool, getSubagentResultTool]) {
-			try {
-				pi.registerTool(extraTool);
-			} catch (error) {
-				logInternalError("register.duplicate-tool", error, `tool=${extraTool.name}`);
-			}
-		}
-	}
-}
+import type { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { Type } from "typebox";
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import { handleTeamTool } from "../team-tool.ts";
+import { checkSubagentSpawnPermission, currentCrewRole } from "../../runtime/role-permission.ts";
+import { readPersistedSubagentRecord, savePersistedSubagentRecord, type SubagentManager, type SubagentSpawnOptions } from "../../subagents/manager.ts";
+import { loadConfig } from "../../config/config.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { __test__subagentSpawnParams, formatSubagentRecord, readSubagentRunResult, refreshPersistedSubagentRecord, subagentToolResult } from "./subagent-helpers.ts";
+import { t } from "../../i18n.ts";
+
+export interface SubagentToolRegistrationOptions {
+	ownerSessionGeneration?: () => number;
+}
+
+export function registerSubagentTools(pi: ExtensionAPI, subagentManager: SubagentManager, options: SubagentToolRegistrationOptions = {}): void {
+	const agentTool: ToolDefinition = {
+		name: "Agent",
+		label: "Agent",
+		description: "Launch a real pi-crew subagent. Uses pi-crew's durable child-process runtime by default; set run_in_background=true for parallel/background work, then use get_subagent_result.",
+		promptSnippet: "Use Agent to delegate focused work to a real pi-crew subagent. Use run_in_background=true for parallel work and get_subagent_result to join results.",
+		promptGuidelines: [
+			"Use Agent for independent exploration, review, verification, or implementation subtasks instead of doing all work in the parent turn.",
+			"For parallel work, launch multiple Agent calls with run_in_background=true, then call get_subagent_result for each result.",
+			"Available pi-crew subagent types include explorer, planner, analyst, executor, reviewer, verifier, writer, security-reviewer, and test-engineer.",
+		],
+		parameters: Type.Object({
+			prompt: Type.String({ description: "The task for the subagent to perform." }),
+			description: Type.String({ description: "Short 3-5 word task description." }),
+			subagent_type: Type.String({ description: "pi-crew agent name, e.g. explorer, planner, executor, reviewer, verifier, writer, security-reviewer, test-engineer." }),
+			model: Type.Optional(Type.String({ description: "Optional model override. If omitted, pi-crew uses Pi-configured model fallback." })),
+			skill: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String()), Type.Boolean()], { description: "Skill name(s) to inject for this subagent, or false to disable selected/default skills." })),
+			max_turns: Type.Optional(Type.Number({ description: "Reserved for live-session subagents; child-process runtime may ignore this." })),
+			run_in_background: Type.Optional(Type.Boolean({ description: "Run in background and return an agent ID immediately." })),
+		}) as never,
+		async execute(_id, params, signal, _onUpdate, ctx) {
+			const currentRole = currentCrewRole();
+			const permission = checkSubagentSpawnPermission(currentRole);
+			if (!permission.allowed) return subagentToolResult(permission.reason ?? "Current role cannot spawn subagents.", { role: currentRole, mode: permission.mode }, true);
+			const spawnOptions = __test__subagentSpawnParams(params as Record<string, unknown>, ctx);
+			spawnOptions.ownerSessionGeneration = options.ownerSessionGeneration?.();
+			if (!spawnOptions.prompt.trim()) return subagentToolResult(t("agent.requiresPrompt"), {}, true);
+			const runner = async (currentOptions: SubagentSpawnOptions, childSignal?: AbortSignal) => handleTeamTool({ action: "run", agent: currentOptions.type, goal: currentOptions.prompt, model: currentOptions.model, skill: currentOptions.skill, async: currentOptions.background, config: currentOptions.maxTurns ? { runtime: { maxTurns: currentOptions.maxTurns } } : undefined } as TeamToolParamsValue, currentOptions.background ? { ...ctx, signal: childSignal } : { ...ctx, signal: childSignal });
+			const record = subagentManager.spawn(spawnOptions, runner, spawnOptions.background ? undefined : signal);
+			if (spawnOptions.background || record.status === "queued") {
+				// Phase 1.1a: Terminate turn for background queued — no LLM follow-up needed.
+				// Phase 1.6: Record was terminated for telemetry.
+				record.terminated = true;
+				savePersistedSubagentRecord(ctx.cwd, record);
+				return { ...subagentToolResult([t("agent.started", { state: record.status === "queued" ? "queued" : "started" }), t("agent.id", { id: record.id }), t("agent.type", { type: record.type }), t("agent.description", { description: record.description }), t("agent.retrieveHint")].join("\n"), { agentId: record.id, status: record.status }), terminate: true };
+			}
+			await record.promise;
+			const output = readSubagentRunResult(ctx, record) ?? record.result ?? t("agent.noOutput");
+			const foregroundResult = subagentToolResult([t("agent.foregroundStatus", { id: record.id, status: record.status }), "", output].join("\n"), { agentId: record.id, runId: record.runId, status: record.status }, record.status === "failed" || record.status === "error");
+			if (loadConfig(ctx.cwd).config.tools?.terminateOnForeground === true) {
+				record.terminated = true;
+				savePersistedSubagentRecord(ctx.cwd, record);
+				return { ...foregroundResult, terminate: true };
+			}
+			return foregroundResult;
+		},
+	};
+
+	const getSubagentResultTool: ToolDefinition = {
+		name: "get_subagent_result",
+		label: "Get Agent Result",
+		description: "Check status and retrieve results from a pi-crew background subagent.",
+		parameters: Type.Object({ agent_id: Type.String({ description: "Agent ID returned by Agent." }), wait: Type.Optional(Type.Boolean({ description: "Wait for completion before returning." })), verbose: Type.Optional(Type.Boolean({ description: "Include status metadata before output." })) }) as never,
+		async execute(_id, params, signal, _onUpdate, ctx) {
+			const p = params as { agent_id?: string; wait?: boolean; verbose?: boolean };
+			if (!p.agent_id) return subagentToolResult(t("result.requiresAgentId"), {}, true);
+			const inMemory = subagentManager.getRecord(p.agent_id);
+			const record = inMemory ?? readPersistedSubagentRecord(ctx.cwd, p.agent_id);
+			if (!record) return subagentToolResult(t("result.notFound", { id: p.agent_id }), {}, true);
+			let current = refreshPersistedSubagentRecord(ctx, record);
+			if (inMemory && current !== inMemory) Object.assign(inMemory, current);
+			if (!inMemory && !current.runId && (current.status === "running" || current.status === "queued")) {
+				current = { ...current, status: "error", error: t("result.unrecoverable"), completedAt: current.completedAt ?? Date.now() };
+				savePersistedSubagentRecord(ctx.cwd, current);
+			}
+			if (p.wait && (current.status === "running" || current.status === "queued")) {
+				const waited = await subagentManager.waitForRecord(current.id);
+				if (waited) current = waited;
+				if (current.status === "blocked") {
+					current.resultConsumed = false;
+					if (inMemory) inMemory.resultConsumed = false;
+					savePersistedSubagentRecord(ctx.cwd, current);
+				} else {
+					const waitStartMs = Date.now();
+					const maxWaitMs = 300_000; // 5 minutes
+					while (current.status === "running" || current.status === "queued") {
+						if (signal?.aborted) {
+							current = { ...current, status: "error", error: t("result.waitAborted"), completedAt: Date.now() };
+							savePersistedSubagentRecord(ctx.cwd, current);
+							break;
+						}
+						if (Date.now() - waitStartMs > maxWaitMs) {
+							current = { ...current, status: "error", error: t("result.waitTimeout"), completedAt: Date.now() };
+							savePersistedSubagentRecord(ctx.cwd, current);
+							break;
+						}
+						await new Promise((resolve) => setTimeout(resolve, 1000));
+						current = refreshPersistedSubagentRecord(ctx, current);
+						if (!current.runId) break;
+					}
+				}
+			}
+			const output = readSubagentRunResult(ctx, current);
+			if (current.status !== "running" && current.status !== "queued" && current.status !== "blocked") {
+				current.resultConsumed = true;
+				if (inMemory) inMemory.resultConsumed = true;
+				savePersistedSubagentRecord(ctx.cwd, current);
+			}
+			const text = [p.verbose ? formatSubagentRecord(current) : undefined, output ? `${p.verbose ? "\n" : ""}${output}` : current.status === "running" || current.status === "queued" ? t("result.stillRunning") : current.error ?? t("agent.noOutput")].filter((line): line is string => Boolean(line)).join("\n");
+			return subagentToolResult(text, { agentId: current.id, runId: current.runId, status: current.status }, current.status === "failed" || current.status === "error");
+		},
+	};
+
+	const steerSubagentTool: ToolDefinition = {
+		name: "steer_subagent",
+		label: "Steer Agent",
+		description: "Send a steering note to a running pi-crew subagent. Live-session steering is planned; child-process runs expose durable status and can be cancelled if needed.",
+		parameters: Type.Object({ agent_id: Type.String(), message: Type.String() }) as never,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const p = params as { agent_id?: string; message?: string };
+			const record = p.agent_id ? subagentManager.getRecord(p.agent_id) ?? readPersistedSubagentRecord(ctx.cwd, p.agent_id) : undefined;
+			if (!record) return subagentToolResult(t("result.notFound", { id: p.agent_id ?? "" }), {}, true);
+			return subagentToolResult([t("steer.noted", { id: record.id }), t("steer.unavailable"), record.runId ? t("steer.cancelHint", { runId: record.runId }) : undefined].filter((line): line is string => Boolean(line)).join("\n"), { agentId: record.id, runId: record.runId, status: record.status });
+		},
+	};
+
+	const crewAgentTool: ToolDefinition = { ...agentTool, name: "crew_agent", label: "Crew Agent", description: "Launch a real pi-crew subagent using a conflict-safe pi-crew-specific tool name.", promptSnippet: "Use crew_agent when you need pi-crew subagents and another extension may own the generic Agent tool." };
+	const crewAgentResultTool: ToolDefinition = { ...getSubagentResultTool, name: "crew_agent_result", label: "Get Crew Agent Result", description: "Check status and retrieve results from a pi-crew subagent using the conflict-safe tool name." };
+	const crewAgentSteerTool: ToolDefinition = { ...steerSubagentTool, name: "crew_agent_steer", label: "Steer Crew Agent", description: "Send a steering note to a pi-crew subagent using the conflict-safe tool name." };
+	const toolConfig = loadConfig(process.cwd()).config.tools;
+	const enableSteer = toolConfig?.enableSteer !== false;
+	const enableClaudeStyleAliases = toolConfig?.enableClaudeStyleAliases !== false;
+
+	for (const extraTool of enableSteer ? [crewAgentTool, crewAgentResultTool, crewAgentSteerTool] : [crewAgentTool, crewAgentResultTool]) pi.registerTool(extraTool);
+	if (enableClaudeStyleAliases) {
+		for (const extraTool of enableSteer ? [agentTool, getSubagentResultTool, steerSubagentTool] : [agentTool, getSubagentResultTool]) {
+			try {
+				pi.registerTool(extraTool);
+			} catch (error) {
+				logInternalError("register.duplicate-tool", error, `tool=${extraTool.name}`);
+			}
+		}
+	}
+}

package/src/extension/registration/team-tool.ts

@@ -1,5 +1,4 @@
 import * as fs from "node:fs";
-import * as path from "node:path";
 import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
 import { loadConfig } from "../../config/config.ts";
 import { TeamToolParams, type TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
@@ -9,7 +8,9 @@ import { updatePiCrewPowerbar } from "../../ui/powerbar-publisher.ts";
 import type { createManifestCache } from "../../runtime/manifest-cache.ts";
 import type { createRunSnapshotCache } from "../../ui/run-snapshot-cache.ts";
 import type { MetricRegistry } from "../../observability/metric-registry.ts";
+import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
 import { handleTeamTool } from "../team-tool.ts";
+import { withSessionId } from "../team-tool/context.ts";
 import { toolResult } from "../tool-result.ts";
 
 export interface RegisterTeamToolDeps {
@@ -23,15 +24,16 @@ export interface RegisterTeamToolDeps {
 	onJsonEvent?: (taskId: string, runId: string, event: unknown) => void;
 }
 
-function resolveCwdOverride(baseCwd: string, override: string | undefined): { ok: true; cwd: string } | { ok: false; error: string } {
+export function resolveCwdOverride(baseCwd: string, override: string | undefined): { ok: true; cwd: string } | { ok: false; error: string } {
 	if (!override) return { ok: true, cwd: baseCwd };
-	const resolved = path.resolve(baseCwd, override);
 	try {
+		const resolved = resolveRealContainedPath(baseCwd, override);
 		const stat = fs.statSync(resolved);
 		if (!stat.isDirectory()) return { ok: false, error: `cwd override is not a directory: ${resolved}` };
 		return { ok: true, cwd: resolved };
-	} catch {
-		return { ok: false, error: `cwd override does not exist: ${resolved}` };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return { ok: false, error: `Invalid cwd override: ${message}` };
 	}
 }
 
@@ -51,7 +53,7 @@ export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps):
 				const resolved = params as TeamToolParamsValue;
 				const cwdOverride = resolveCwdOverride(ctx.cwd, resolved.cwd);
 				if (!cwdOverride.ok) return toolResult(cwdOverride.error, { action: resolved.action ?? "list", status: "error" }, true);
-				const toolCtx = { ...ctx, cwd: cwdOverride.cwd };
+				const toolCtx = withSessionId({ ...ctx, cwd: cwdOverride.cwd });
 				// Phase 1.5: Auto-set session name from team run context
 				if (resolved.action === "run" && resolved.goal && !pi.getSessionName()) {
 					const runLabel = resolved.team ?? resolved.agent ?? "direct";

package/src/extension/run-bundle-schema.ts

@@ -1,89 +1,89 @@
-import { isTeamRunStatus, isTeamTaskStatus } from "../state/contracts.ts";
-import type { TeamRunManifest, TeamTaskState, ArtifactDescriptor } from "../state/types.ts";
-import type { TeamEvent } from "../state/event-log.ts";
-import type { ExportedRunBundle } from "./run-export.ts";
-
-export interface BundleValidationResult {
-	ok: boolean;
-	errors: string[];
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-function validateArtifact(value: unknown, index: number, errors: string[]): value is ArtifactDescriptor {
-	if (!isRecord(value)) {
-		errors.push(`manifest.artifacts[${index}] must be an object.`);
-		return false;
-	}
-	const before = errors.length;
-	if (typeof value.kind !== "string") errors.push(`manifest.artifacts[${index}].kind must be a string.`);
-	if (typeof value.path !== "string") errors.push(`manifest.artifacts[${index}].path must be a string.`);
-	if (typeof value.createdAt !== "string") errors.push(`manifest.artifacts[${index}].createdAt must be a string.`);
-	if (typeof value.producer !== "string") errors.push(`manifest.artifacts[${index}].producer must be a string.`);
-	if (value.retention !== "run" && value.retention !== "project" && value.retention !== "temporary") errors.push(`manifest.artifacts[${index}].retention is invalid.`);
-	return errors.length === before;
-}
-
-function validateManifest(value: unknown, errors: string[]): value is TeamRunManifest {
-	if (!isRecord(value)) {
-		errors.push("manifest must be an object.");
-		return false;
-	}
-	const before = errors.length;
-	if (value.schemaVersion !== 1) errors.push("manifest.schemaVersion must be 1.");
-	for (const field of ["runId", "team", "goal", "createdAt", "updatedAt", "cwd", "stateRoot", "artifactsRoot", "tasksPath", "eventsPath"] as const) {
-		if (typeof value[field] !== "string") errors.push(`manifest.${field} must be a string.`);
-	}
-	if (!isTeamRunStatus(value.status)) errors.push("manifest.status is invalid.");
-	if (value.workspaceMode !== "single" && value.workspaceMode !== "worktree") errors.push("manifest.workspaceMode must be single or worktree.");
-	if (!Array.isArray(value.artifacts)) errors.push("manifest.artifacts must be an array.");
-	else value.artifacts.forEach((artifact, index) => validateArtifact(artifact, index, errors));
-	return errors.length === before;
-}
-
-function validateTask(value: unknown, index: number, errors: string[]): value is TeamTaskState {
-	if (!isRecord(value)) {
-		errors.push(`tasks[${index}] must be an object.`);
-		return false;
-	}
-	const before = errors.length;
-	for (const field of ["id", "runId", "role", "agent", "title", "cwd"] as const) {
-		if (typeof value[field] !== "string") errors.push(`tasks[${index}].${field} must be a string.`);
-	}
-	if (!isTeamTaskStatus(value.status)) errors.push(`tasks[${index}].status is invalid.`);
-	if (!Array.isArray(value.dependsOn)) errors.push(`tasks[${index}].dependsOn must be an array.`);
-	return errors.length === before;
-}
-
-function validateEvent(value: unknown, index: number, errors: string[]): value is TeamEvent {
-	if (!isRecord(value)) {
-		errors.push(`events[${index}] must be an object.`);
-		return false;
-	}
-	const before = errors.length;
-	for (const field of ["time", "type", "runId"] as const) {
-		if (typeof value[field] !== "string") errors.push(`events[${index}].${field} must be a string.`);
-	}
-	return errors.length === before;
-}
-
-export function validateRunBundle(value: unknown): BundleValidationResult {
-	const errors: string[] = [];
-	if (!isRecord(value)) return { ok: false, errors: ["bundle must be an object."] };
-	if (value.schemaVersion !== 1) errors.push("schemaVersion must be 1.");
-	if (typeof value.exportedAt !== "string") errors.push("exportedAt must be a string.");
-	validateManifest(value.manifest, errors);
-	if (!Array.isArray(value.tasks)) errors.push("tasks must be an array.");
-	else value.tasks.forEach((task, index) => validateTask(task, index, errors));
-	if (!Array.isArray(value.events)) errors.push("events must be an array.");
-	else value.events.forEach((event, index) => validateEvent(event, index, errors));
-	if (!Array.isArray(value.artifactPaths) || !value.artifactPaths.every((item) => typeof item === "string")) errors.push("artifactPaths must be an array of strings.");
-	return { ok: errors.length === 0, errors };
-}
-
-export function assertRunBundle(value: unknown): asserts value is ExportedRunBundle {
-	const validation = validateRunBundle(value);
-	if (!validation.ok) throw new Error(`File is not a valid pi-crew exported run bundle:\n${validation.errors.map((error) => `- ${error}`).join("\n")}`);
-}
+import { isTeamRunStatus, isTeamTaskStatus } from "../state/contracts.ts";
+import type { TeamRunManifest, TeamTaskState, ArtifactDescriptor } from "../state/types.ts";
+import type { TeamEvent } from "../state/event-log.ts";
+import type { ExportedRunBundle } from "./run-export.ts";
+
+export interface BundleValidationResult {
+	ok: boolean;
+	errors: string[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function validateArtifact(value: unknown, index: number, errors: string[]): value is ArtifactDescriptor {
+	if (!isRecord(value)) {
+		errors.push(`manifest.artifacts[${index}] must be an object.`);
+		return false;
+	}
+	const before = errors.length;
+	if (typeof value.kind !== "string") errors.push(`manifest.artifacts[${index}].kind must be a string.`);
+	if (typeof value.path !== "string") errors.push(`manifest.artifacts[${index}].path must be a string.`);
+	if (typeof value.createdAt !== "string") errors.push(`manifest.artifacts[${index}].createdAt must be a string.`);
+	if (typeof value.producer !== "string") errors.push(`manifest.artifacts[${index}].producer must be a string.`);
+	if (value.retention !== "run" && value.retention !== "project" && value.retention !== "temporary") errors.push(`manifest.artifacts[${index}].retention is invalid.`);
+	return errors.length === before;
+}
+
+function validateManifest(value: unknown, errors: string[]): value is TeamRunManifest {
+	if (!isRecord(value)) {
+		errors.push("manifest must be an object.");
+		return false;
+	}
+	const before = errors.length;
+	if (value.schemaVersion !== 1) errors.push("manifest.schemaVersion must be 1.");
+	for (const field of ["runId", "team", "goal", "createdAt", "updatedAt", "cwd", "stateRoot", "artifactsRoot", "tasksPath", "eventsPath"] as const) {
+		if (typeof value[field] !== "string") errors.push(`manifest.${field} must be a string.`);
+	}
+	if (!isTeamRunStatus(value.status)) errors.push("manifest.status is invalid.");
+	if (value.workspaceMode !== "single" && value.workspaceMode !== "worktree") errors.push("manifest.workspaceMode must be single or worktree.");
+	if (!Array.isArray(value.artifacts)) errors.push("manifest.artifacts must be an array.");
+	else value.artifacts.forEach((artifact, index) => validateArtifact(artifact, index, errors));
+	return errors.length === before;
+}
+
+function validateTask(value: unknown, index: number, errors: string[]): value is TeamTaskState {
+	if (!isRecord(value)) {
+		errors.push(`tasks[${index}] must be an object.`);
+		return false;
+	}
+	const before = errors.length;
+	for (const field of ["id", "runId", "role", "agent", "title", "cwd"] as const) {
+		if (typeof value[field] !== "string") errors.push(`tasks[${index}].${field} must be a string.`);
+	}
+	if (!isTeamTaskStatus(value.status)) errors.push(`tasks[${index}].status is invalid.`);
+	if (!Array.isArray(value.dependsOn)) errors.push(`tasks[${index}].dependsOn must be an array.`);
+	return errors.length === before;
+}
+
+function validateEvent(value: unknown, index: number, errors: string[]): value is TeamEvent {
+	if (!isRecord(value)) {
+		errors.push(`events[${index}] must be an object.`);
+		return false;
+	}
+	const before = errors.length;
+	for (const field of ["time", "type", "runId"] as const) {
+		if (typeof value[field] !== "string") errors.push(`events[${index}].${field} must be a string.`);
+	}
+	return errors.length === before;
+}
+
+export function validateRunBundle(value: unknown): BundleValidationResult {
+	const errors: string[] = [];
+	if (!isRecord(value)) return { ok: false, errors: ["bundle must be an object."] };
+	if (value.schemaVersion !== 1) errors.push("schemaVersion must be 1.");
+	if (typeof value.exportedAt !== "string") errors.push("exportedAt must be a string.");
+	validateManifest(value.manifest, errors);
+	if (!Array.isArray(value.tasks)) errors.push("tasks must be an array.");
+	else value.tasks.forEach((task, index) => validateTask(task, index, errors));
+	if (!Array.isArray(value.events)) errors.push("events must be an array.");
+	else value.events.forEach((event, index) => validateEvent(event, index, errors));
+	if (!Array.isArray(value.artifactPaths) || !value.artifactPaths.every((item) => typeof item === "string")) errors.push("artifactPaths must be an array of strings.");
+	return { ok: errors.length === 0, errors };
+}
+
+export function assertRunBundle(value: unknown): asserts value is ExportedRunBundle {
+	const validation = validateRunBundle(value);
+	if (!validation.ok) throw new Error(`File is not a valid pi-crew exported run bundle:\n${validation.errors.map((error) => `- ${error}`).join("\n")}`);
+}

package/src/extension/run-index.ts

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import type { TeamRunManifest } from "../state/types.ts";
 import { DEFAULT_PATHS } from "../config/defaults.ts";
 import { findRepoRoot, projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
+import { activeRunEntries } from "../state/active-run-registry.ts";
 import { isSafePathId, resolveRealContainedPath } from "../utils/safe-paths.ts";
 
 function readManifest(filePath: string): TeamRunManifest | undefined {
@@ -40,20 +41,27 @@ function mergeRuns(runSets: TeamRunManifest[][], max?: number): TeamRunManifest[
 }
 
 function scopedRunRoots(cwd: string): string[] {
-	const roots: string[] = [userCrewRoot()];
+	const roots = new Set<string>();
+	roots.add(userCrewRoot());
 	const projectRoot = findRepoRoot(cwd);
-	if (projectRoot) roots.unshift(projectCrewRoot(cwd));
-	return roots;
+	if (projectRoot) roots.add(projectCrewRoot(cwd));
+	return [...roots];
+}
+
+function collectActiveRuns(): TeamRunManifest[] {
+	return activeRunEntries()
+		.map((entry) => readManifest(entry.manifestPath))
+		.filter((manifest): manifest is TeamRunManifest => manifest !== undefined);
 }
 
 export function listRuns(cwd: string): TeamRunManifest[] {
 	const roots = scopedRunRoots(cwd);
-	return mergeRuns(roots.map((root) => collectRuns(root)));
+	return mergeRuns([...roots.map((root) => collectRuns(root)), collectActiveRuns()]);
 }
 
 export function listRecentRuns(cwd: string, max = 20): TeamRunManifest[] {
 	const roots = scopedRunRoots(cwd);
-	return mergeRuns(roots.map((root) => collectRuns(root, max)), max);
+	return mergeRuns([...roots.map((root) => collectRuns(root, max)), collectActiveRuns()], max);
 }
 
 /**