pi-crew 0.9.41 → 0.9.44

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

@@ -10,7 +10,6 @@ import { atomicWriteJson } from "../../state/atomic-write.ts";
 import { createRunManifest, loadRunManifestById, updateRunStatus } from "../../state/state-store.ts";
 import { allTeams, discoverTeams } from "../../teams/discover-teams.ts";
 import { allWorkflows, discoverWorkflows } from "../../workflows/discover-workflows.ts";
-import { validateWorkflowForTeam } from "../../workflows/validate-workflow.ts";
 import { assertCleanLeaderAsync, findGitRootAsync } from "../../worktree/worktree-manager.ts";
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars -- type-only import for TS inference
@@ -29,10 +28,10 @@ async function executeTeamRun(...args: Parameters<typeof ExecuteTeamRunFn>): Pro
 	return _cachedExecuteTeamRun(...args);
 }
 
-import { expandParallelResearchWorkflow } from "../../runtime/parallel-research.ts";
 import { resolveCrewRuntime, runtimeResolutionState } from "../../runtime/runtime-resolver.ts";
-import { normalizeSkillOverride } from "../../runtime/skill-instructions.ts";
 import { appendEventAsync, readEvents } from "../../state/event-log.ts";
+import type { RunMetrics } from "../../state/run-metrics.ts";
+import type { RuntimeResolutionState, TeamRunManifest, TeamTaskState } from "../../state/types.ts";
 import { spawnBackgroundTeamRun } from "../../subagents/async-entry.ts";
 
 /**
@@ -197,6 +196,182 @@ function resolveAnalysisText(
 	return { text: sanitized, source: "inline" };
 }
 
+/**
+ * Options for {@link formatRunResult} (EXT-2 refactor).
+ */
+export interface FormatRunResultOptions {
+	/** Task states for the completed run (used to render the per-task summary in "waited" mode). */
+	tasks: TeamTaskState[];
+	/** Pre-computed run metrics snapshot; omitted when the run finished before metrics were recorded. */
+	metrics: RunMetrics | undefined;
+	/** Goal text — truncated to 100 chars in the "waited" banner. */
+	goal: string;
+	/** Team name (for the banner). */
+	team: string;
+	/** Workflow name (for the scaffold banner). */
+	workflow: string;
+	/** Optional workspace identifier (session id / cwd) — surfaced in `details.data` for traceability. */
+	workspaceId?: string;
+	/** Runtime resolution — required for `mode: "scaffold"`, optional otherwise. */
+	runtime?: RuntimeResolutionState;
+	/** Output mode:
+	 *  - `"waited"` (default) — detailed per-task summary after `waitForRun` resolved
+	 *    (replaces the former async + foreground completion blocks).
+	 *  - `"scaffold"` — concise "Created pi-crew run" banner for runs that completed
+	 *    without worker execution (scaffold mode / `executeWorkers=false`).
+	 */
+	mode?: "waited" | "scaffold";
+}
+
+/**
+ * Format the text + {@link PiTeamsToolResult} for a completed team run.
+ *
+ * Replaces three near-identical inline blocks in `handleRun` (EXT-2 finding):
+ *   1. Async-spawned run completion (after `waitForRun`).
+ *   2. Foreground-run completion (after `waitForRun`).
+ *   3. Scaffold / no-executeWorkers completion (after `executeTeamRun` returns
+ *      synchronously without launching workers).
+ *
+ * The output is byte-identical to the prior inline implementations when
+ * `workspaceId` is unset. When `workspaceId` is provided it is included in
+ * `details.data.workspaceId` so downstream consumers (TUI widgets, audit logs)
+ * can attribute the result to the originating session/cwd.
+ */
+function formatRunResult(manifest: TeamRunManifest, options: FormatRunResultOptions): PiTeamsToolResult {
+	const { tasks, metrics, goal, team, workflow, workspaceId, runtime, mode = "waited" } = options;
+
+	if (mode === "scaffold") {
+		// Scaffold / no-worker banner. `runtime` is required in this mode — callers
+		// must provide it so we can render the runtime kind + explanation.
+		const runtimeLine = runtime
+			? `Runtime: ${runtime.kind}${runtime.fallback ? ` (fallback from ${runtime.requestedMode})` : ""}${runtime.reason ? ` - ${runtime.reason}` : ""}`
+			: "Runtime: unknown";
+		const runtimeExplanation = !runtime
+			? ""
+			: runtime.kind === "child-process"
+				? "Child Pi worker execution is enabled by default; each task is launched as a separate Pi process. Set runtime.mode=scaffold or executeWorkers=false only for dry runs."
+				: runtime.kind === "live-session"
+					? "Experimental live-session worker execution was enabled."
+					: "Safe scaffold mode: child Pi workers were not launched because runtime.mode=scaffold or executeWorkers=false was configured.";
+		const text = [
+			`Created pi-crew run ${manifest.runId}.`,
+			`Team: ${team}`,
+			`Workflow: ${workflow}`,
+			`Status: ${manifest.status}`,
+			`Tasks: ${tasks.length}`,
+			`State: ${manifest.stateRoot}`,
+			`Artifacts: ${manifest.artifactsRoot}`,
+			"",
+			runtimeLine,
+			runtimeExplanation,
+		]
+			.filter((line) => line !== "")
+			.join("\n");
+		const isError = manifest.status === "failed";
+		return result(
+			text,
+			{
+				action: "run",
+				status: isError ? "error" : "ok",
+				runId: manifest.runId,
+				artifactsRoot: manifest.artifactsRoot,
+				metrics,
+				...(workspaceId ? { data: { workspaceId } } : {}),
+			},
+			isError,
+		);
+	}
+
+	// mode === "waited" — detailed per-task summary.
+	const lines: string[] = [`pi-crew run ${manifest.status}: ${manifest.runId} (${team})`, `Goal: ${goal.slice(0, 100)}`];
+	if (metrics) {
+		lines.push("");
+		lines.push(
+			`Metrics: ${metrics.completedCount}/${metrics.taskCount} tasks, ${metrics.totalTokens} tokens, ${metrics.durationMs}ms, consistency=${metrics.consistencyScore}`,
+		);
+	}
+
+	if (tasks.length > 0) {
+		// Read run-level summary artifact if present
+		let summaryContent: string | undefined;
+		const summaryArtifact = manifest.artifacts?.find((a: { kind?: string }) => a.kind === "summary");
+		if (summaryArtifact) {
+			try {
+				const sumPath = path.join(manifest.artifactsRoot, summaryArtifact.path);
+				summaryContent = fs.readFileSync(sumPath, "utf-8").trim().slice(0, 4000);
+			} catch {
+				/* summary unavailable */
+			}
+		}
+
+		const taskLines: string[] = [];
+		let failedCount = 0;
+		const failedIds: string[] = [];
+		for (const task of tasks) {
+			let resultExcerpt = "";
+			if (task.resultArtifact?.path) {
+				try {
+					// H-3 fix (code-review 2026-06-23): resolve the result artifact path
+					// inside artifactsRoot via the project's safe-path primitive. Rejects
+					// absolute paths (/etc/passwd) and ../ traversal that the old
+					// path.isAbsolute shortcut + bare path.join allowed.
+					const resPath = resolveRealContainedPath(manifest.artifactsRoot, task.resultArtifact.path);
+					resultExcerpt = fs.readFileSync(resPath, "utf-8").trim().slice(0, 2000);
+				} catch {
+					resultExcerpt = "(result unavailable)";
+				}
+			}
+			const shortResult = resultExcerpt.slice(0, 500);
+			const statusTag = task.status === "completed" ? "✓" : task.status === "failed" ? "✗" : task.status === "cancelled" ? "⊘" : "·";
+			taskLines.push(
+				`- ${statusTag} ${task.id} [${task.role}]: ${task.status}${shortResult ? " — " + shortResult : ""}${task.error ? ` | Error: ${task.error.slice(0, 200)}` : ""}`,
+			);
+			if (task.status === "failed" || task.status === "needs_attention") {
+				failedCount++;
+				failedIds.push(task.id);
+			}
+		}
+
+		lines.push("");
+		lines.push(`Tasks (${tasks.length}):`);
+		lines.push(...taskLines);
+
+		if (summaryContent) {
+			lines.push("");
+			lines.push("Summary:");
+			lines.push(summaryContent.slice(0, 2000));
+		}
+
+		if (failedCount === 0) {
+			lines.push("");
+			lines.push("All tasks completed successfully.");
+		} else {
+			lines.push("");
+			lines.push(`${failedCount} task(s) failed: ${failedIds.join(", ")}. Consider retrying.`);
+		}
+	} else {
+		lines.push(
+			manifest.status === "completed"
+				? "Run completed with no task results."
+				: `The run ended with status: ${manifest.status}. Check the run artifacts for details.`,
+		);
+	}
+
+	const runFailed = manifest.status === "failed" || manifest.status === "blocked";
+	return result(
+		lines.join("\n"),
+		{
+			action: "run",
+			status: runFailed ? "error" : "ok",
+			runId: manifest.runId,
+			artifactsRoot: manifest.artifactsRoot,
+			metrics,
+			...(workspaceId ? { data: { workspaceId } } : {}),
+		},
+		runFailed,
+	);
+}
+
 export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
 	// CHAIN DISPATCH: runs before goal validation since a chain has no top-level
 	// goal. The injected handleRun reference breaks the run.ts ↔ chain-dispatch.ts
@@ -319,6 +494,17 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	// LAZY: dodge the jiti ESM/CJS interop TDZ race on the static `import { expandParallelResearchWorkflow }` above (issue #28, RFC 17). At call time the module body has fully evaluated, so the dynamic import returns a live binding. Multi-line form breaks scripts/check-lazy-imports.mjs (which does `lines[lineNum - 2]`), so keep destructuring + await import on one line.
 	const { expandParallelResearchWorkflow: expandParallelResearch } = await import("../../runtime/parallel-research.ts");
 	const workflow = directAgent ? baseWorkflow : expandParallelResearch(baseWorkflow, resolvedCtx.cwd);
+	const isDynamicWorkflow =
+		!directAgent && (workflow as import("../../workflows/workflow-config.ts").WorkflowConfig).runtime === "dynamic";
+	const effectiveRunKind = isDynamicWorkflow ? params.runKind : undefined;
+	if (params.runKind !== undefined && !isDynamicWorkflow) {
+		logInternalError(
+			"team-tool.run.runKindIgnored",
+			new Error(`Ignoring runKind='${params.runKind}' because workflow '${workflow.name}' is not dynamic.`),
+			undefined,
+			"warn",
+		);
+	}
 
 	// PREFLIGHT (advisory only, since v0.9.15): classify workflow topology and emit
 	// informational notes per the rule in .crew/knowledge.md "pi-crew USAGE THRESHOLD
@@ -396,7 +582,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		goal,
 		workspaceMode: params.workspaceMode,
 		ownerSessionId: ctx.sessionId,
-		runKind: params.runKind,
+		runKind: effectiveRunKind,
 		args: params.args,
 	});
 	const goalArtifact = writeArtifact(paths.artifactsRoot, {
@@ -431,7 +617,10 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	// run it via runDynamicWorkflow instead of the static executeTeamRun path. The script
 	// orchestrates subagents via ctx.agent(); only ctx.setResult() reaches the main context.
 	// Placed AFTER manifest creation so runId/paths/artifactsRoot are available.
-	if (!directAgent && (workflow as import("../../workflows/workflow-config.ts").DynamicWorkflowConfig).runtime === "dynamic") {
+	if (isDynamicWorkflow) {
+		console.warn(
+			`[pi-crew SECURITY] Dynamic workflow '${workflow.name}' executes as trusted Node.js code with full process/require/import access; run only reviewed .dwf.ts files.`,
+		);
 		// LAZY: defer dynamic import of ../../runtime/dynamic-workflow-runner.ts to its call site.
 		const { runDynamicWorkflow } = await import("../../runtime/dynamic-workflow-runner.ts");
 		// Re-synthesize a dynamic-team (§0c C9) for role resolution.
@@ -658,97 +847,14 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		// Wait for the async run to complete and return actual results.
 		try {
 			const completed = await waitForRun(updatedManifest.runId, resolvedCtx.cwd, { timeoutMs: 3600000 });
-			const metrics = collectRunMetrics(resolvedCtx.cwd, completed.manifest.runId);
-			const lines: string[] = [
-				`pi-crew run ${completed.manifest.status}: ${completed.manifest.runId} (${team.name})`,
-				`Goal: ${goal.slice(0, 100)}`,
-			];
-			if (metrics) {
-				lines.push("");
-				lines.push(
-					`Metrics: ${metrics.completedCount}/${metrics.taskCount} tasks, ${metrics.totalTokens} tokens, ${metrics.durationMs}ms, consistency=${metrics.consistencyScore}`,
-				);
-			}
-
-			if (completed.tasks.length > 0) {
-				// Read run-level summary artifact if present
-				let summaryContent: string | undefined;
-				const summaryArtifact = completed.manifest.artifacts?.find((a: { kind?: string }) => a.kind === "summary");
-				if (summaryArtifact) {
-					try {
-						const sumPath = path.join(completed.manifest.artifactsRoot, summaryArtifact.path);
-						summaryContent = fs.readFileSync(sumPath, "utf-8").trim().slice(0, 4000);
-					} catch {
-						/* summary unavailable */
-					}
-				}
-
-				const taskLines: string[] = [];
-				let failedCount = 0;
-				const failedIds: string[] = [];
-				for (const task of completed.tasks) {
-					let resultExcerpt = "";
-					if (task.resultArtifact?.path) {
-						try {
-							// H-3 fix (code-review 2026-06-23): resolve the result artifact path
-							// inside artifactsRoot via the project's safe-path primitive. Rejects
-							// absolute paths (/etc/passwd) and ../ traversal that the old
-							// path.isAbsolute shortcut + bare path.join allowed.
-							const resPath = resolveRealContainedPath(completed.manifest.artifactsRoot, task.resultArtifact.path);
-							resultExcerpt = fs.readFileSync(resPath, "utf-8").trim().slice(0, 2000);
-						} catch {
-							resultExcerpt = "(result unavailable)";
-						}
-					}
-					const shortResult = resultExcerpt.slice(0, 500);
-					const statusTag =
-						task.status === "completed" ? "✓" : task.status === "failed" ? "✗" : task.status === "cancelled" ? "⊘" : "·";
-					taskLines.push(
-						`- ${statusTag} ${task.id} [${task.role}]: ${task.status}${shortResult ? " — " + shortResult : ""}${task.error ? ` | Error: ${task.error.slice(0, 200)}` : ""}`,
-					);
-					if (task.status === "failed" || task.status === "needs_attention") {
-						failedCount++;
-						failedIds.push(task.id);
-					}
-				}
-
-				lines.push("");
-				lines.push(`Tasks (${completed.tasks.length}):`);
-				lines.push(...taskLines);
-
-				if (summaryContent) {
-					lines.push("");
-					lines.push("Summary:");
-					lines.push(summaryContent.slice(0, 2000));
-				}
-
-				if (failedCount === 0) {
-					lines.push("");
-					lines.push("All tasks completed successfully.");
-				} else {
-					lines.push("");
-					lines.push(`${failedCount} task(s) failed: ${failedIds.join(", ")}. Consider retrying.`);
-				}
-			} else {
-				lines.push(
-					completed.manifest.status === "completed"
-						? "Run completed with no task results."
-						: `The run ended with status: ${completed.manifest.status}. Check the run artifacts for details.`,
-				);
-			}
-
-			const runFailed = completed.manifest.status === "failed" || completed.manifest.status === "blocked";
-			return result(
-				lines.join("\n"),
-				{
-					action: "run",
-					status: runFailed ? "error" : "ok",
-					runId: completed.manifest.runId,
-					artifactsRoot: completed.manifest.artifactsRoot,
-					metrics,
-				},
-				runFailed,
-			);
+			return formatRunResult(completed.manifest, {
+				tasks: completed.tasks,
+				metrics: collectRunMetrics(resolvedCtx.cwd, completed.manifest.runId),
+				goal,
+				team: team.name,
+				workflow: workflow.name,
+				workspaceId: ctx.sessionId ?? ctx.cwd,
+			});
 		} catch (waitError: unknown) {
 			const errorMessage = waitError instanceof Error ? waitError.message : String(waitError);
 			return result(
@@ -855,97 +961,14 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		// Wait for the foreground run to complete and return actual results.
 		try {
 			const completed = await waitForRun(updatedManifest.runId, resolvedCtx.cwd, { timeoutMs: 3600000 });
-			const metrics = collectRunMetrics(resolvedCtx.cwd, completed.manifest.runId);
-			const lines: string[] = [
-				`pi-crew run ${completed.manifest.status}: ${completed.manifest.runId} (${team.name})`,
-				`Goal: ${goal.slice(0, 100)}`,
-			];
-			if (metrics) {
-				lines.push("");
-				lines.push(
-					`Metrics: ${metrics.completedCount}/${metrics.taskCount} tasks, ${metrics.totalTokens} tokens, ${metrics.durationMs}ms, consistency=${metrics.consistencyScore}`,
-				);
-			}
-
-			if (completed.tasks.length > 0) {
-				// Read run-level summary artifact if present
-				let summaryContent: string | undefined;
-				const summaryArtifact = completed.manifest.artifacts?.find((a: { kind?: string }) => a.kind === "summary");
-				if (summaryArtifact) {
-					try {
-						const sumPath = path.join(completed.manifest.artifactsRoot, summaryArtifact.path);
-						summaryContent = fs.readFileSync(sumPath, "utf-8").trim().slice(0, 4000);
-					} catch {
-						/* summary unavailable */
-					}
-				}
-
-				const taskLines: string[] = [];
-				let failedCount = 0;
-				const failedIds: string[] = [];
-				for (const task of completed.tasks) {
-					let resultExcerpt = "";
-					if (task.resultArtifact?.path) {
-						try {
-							// H-3 fix (code-review 2026-06-23): resolve the result artifact path
-							// inside artifactsRoot via the project's safe-path primitive. Rejects
-							// absolute paths (/etc/passwd) and ../ traversal that the old
-							// path.isAbsolute shortcut + bare path.join allowed.
-							const resPath = resolveRealContainedPath(completed.manifest.artifactsRoot, task.resultArtifact.path);
-							resultExcerpt = fs.readFileSync(resPath, "utf-8").trim().slice(0, 2000);
-						} catch {
-							resultExcerpt = "(result unavailable)";
-						}
-					}
-					const shortResult = resultExcerpt.slice(0, 500);
-					const statusTag =
-						task.status === "completed" ? "✓" : task.status === "failed" ? "✗" : task.status === "cancelled" ? "⊘" : "·";
-					taskLines.push(
-						`- ${statusTag} ${task.id} [${task.role}]: ${task.status}${shortResult ? " — " + shortResult : ""}${task.error ? ` | Error: ${task.error.slice(0, 200)}` : ""}`,
-					);
-					if (task.status === "failed" || task.status === "needs_attention") {
-						failedCount++;
-						failedIds.push(task.id);
-					}
-				}
-
-				lines.push("");
-				lines.push(`Tasks (${completed.tasks.length}):`);
-				lines.push(...taskLines);
-
-				if (summaryContent) {
-					lines.push("");
-					lines.push("Summary:");
-					lines.push(summaryContent.slice(0, 2000));
-				}
-
-				if (failedCount === 0) {
-					lines.push("");
-					lines.push("All tasks completed successfully.");
-				} else {
-					lines.push("");
-					lines.push(`${failedCount} task(s) failed: ${failedIds.join(", ")}. Consider retrying.`);
-				}
-			} else {
-				lines.push(
-					completed.manifest.status === "completed"
-						? "Run completed with no task results."
-						: `The run ended with status: ${completed.manifest.status}. Check the run artifacts for details.`,
-				);
-			}
-
-			const runFailed = completed.manifest.status === "failed" || completed.manifest.status === "blocked";
-			return result(
-				lines.join("\n"),
-				{
-					action: "run",
-					status: runFailed ? "error" : "ok",
-					runId: completed.manifest.runId,
-					artifactsRoot: completed.manifest.artifactsRoot,
-					metrics,
-				},
-				runFailed,
-			);
+			return formatRunResult(completed.manifest, {
+				tasks: completed.tasks,
+				metrics: collectRunMetrics(resolvedCtx.cwd, completed.manifest.runId),
+				goal,
+				team: team.name,
+				workflow: workflow.name,
+				workspaceId: ctx.sessionId ?? ctx.cwd,
+			});
 		} catch (waitError: unknown) {
 			const errorMessage = waitError instanceof Error ? waitError.message : String(waitError);
 			return result(
@@ -998,31 +1021,14 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	} finally {
 		unregisterActiveRun(updatedManifest.runId);
 	}
-	const text = [
-		`Created pi-crew run ${executed.manifest.runId}.`,
-		`Team: ${team.name}`,
-		`Workflow: ${workflow.name}`,
-		`Status: ${executed.manifest.status}`,
-		`Tasks: ${executed.tasks.length}`,
-		`State: ${executed.manifest.stateRoot}`,
-		`Artifacts: ${executed.manifest.artifactsRoot}`,
-		"",
-		`Runtime: ${runtime.kind}${runtime.fallback ? ` (fallback from ${runtime.requestedMode})` : ""}${runtime.reason ? ` - ${runtime.reason}` : ""}`,
-		runtime.kind === "child-process"
-			? "Child Pi worker execution is enabled by default; each task is launched as a separate Pi process. Set runtime.mode=scaffold or executeWorkers=false only for dry runs."
-			: runtime.kind === "live-session"
-				? "Experimental live-session worker execution was enabled."
-				: "Safe scaffold mode: child Pi workers were not launched because runtime.mode=scaffold or executeWorkers=false was configured.",
-	].join("\n");
-	return result(
-		text,
-		{
-			action: "run",
-			status: executed.manifest.status === "failed" ? "error" : "ok",
-			runId: executed.manifest.runId,
-			artifactsRoot: executed.manifest.artifactsRoot,
-			metrics: collectRunMetrics(resolvedCtx.cwd, executed.manifest.runId),
-		},
-		executed.manifest.status === "failed",
-	);
+	return formatRunResult(executed.manifest, {
+		tasks: executed.tasks,
+		metrics: collectRunMetrics(resolvedCtx.cwd, executed.manifest.runId),
+		goal,
+		team: team.name,
+		workflow: workflow.name,
+		workspaceId: ctx.cwd,
+		runtime: runtimeResolutionState(runtime),
+		mode: "scaffold",
+	});
 }

package/src/extension/team-tool/workflow-manage.ts

@@ -15,7 +15,7 @@
  */
 
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
+import { dirname, join } from "node:path";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { packageRoot, projectCrewRoot, userPiRoot } from "../../utils/paths.ts";

package/src/extension/team-tool.ts

@@ -8,13 +8,14 @@ import { loadConfig, updateAutonomousConfig, updateConfig } from "../config/conf
 import type { executeTeamRun as _executeTeamRunFn } from "../runtime/team-runner.ts";
 import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
+import { TEAM_TERMINAL_TASK_STATUSES } from "../state/contracts.ts";
 import { appendEvent, appendEventFireAndForget } from "../state/event-log.ts";
 import { withRunLock } from "../state/locks.ts";
 import { replayPendingMailboxMessages } from "../state/mailbox.ts";
 import { loadRunManifestById, saveRunManifestAsync, saveRunTasks, updateRunStatus } from "../state/state-store.ts";
 import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
-import { assertSafePathId } from "../utils/safe-paths.ts";
+import { assertSafePathId, resolveContainedPath } from "../utils/safe-paths.ts";
 import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
 import { piTeamsHelp } from "./help.ts";
 import { handleCreate, handleDelete, handleUpdate } from "./management.ts";
@@ -250,8 +251,8 @@ async function recoverCheckpointedTasks(
 				if (files.length > 0) {
 					// Sort by attempt index descending to get the most recent
 					files.sort((a, b) => {
-						const idxA = parseInt(a.match(/\.attempt-(\d+)\./)?.[1] ?? "0");
-						const idxB = parseInt(b.match(/\.attempt-(\d+)\./)?.[1] ?? "0");
+						const idxA = parseInt(a.match(/\.attempt-(\d+)\./)?.[1] ?? "0", 10);
+						const idxB = parseInt(b.match(/\.attempt-(\d+)\./)?.[1] ?? "0", 10);
 						return idxB - idxA;
 					});
 					transcriptPath = path.join(transcriptsDir, files[0]);
@@ -501,6 +502,10 @@ export function handleSteer(params: TeamToolParamsValue, ctx: TeamContext): PiTe
 	const task = loaded.tasks.find((t) => t.id === taskId);
 	if (!task) return result(`Task '${taskId}' not found`, { action: "steer", status: "error" }, true);
 	if (!task.pendingSteers) task.pendingSteers = [];
+	// T-S1: do not allow steering a task that has already reached a terminal status.
+	if (TEAM_TERMINAL_TASK_STATUSES.has(task.status)) {
+		return result(`Task '${taskId}' is ${task.status}; cannot steer.`, { action: "steer", status: "error" }, true);
+	}
 	// HIGH-04: Cap pendingSteers array to prevent unbounded memory growth
 	const MAX_PENDING_STEERS = 100;
 	if (task.pendingSteers.length >= MAX_PENDING_STEERS) {
@@ -523,10 +528,12 @@ export function handleSteer(params: TeamToolParamsValue, ctx: TeamContext): PiTe
 	try {
 		const steeringDir = `${loaded.manifest.artifactsRoot}/steering`;
 		fs.mkdirSync(steeringDir, { recursive: true });
-		fs.appendFileSync(
-			`${steeringDir}/${taskId}.jsonl`,
-			JSON.stringify({ type: "steer", message, ts: new Date().toISOString() }) + "\n",
-		);
+		// AUDIT-08 defense-in-depth: validate the steering-file path is contained
+		// within steeringDir. taskId is currently sanitized via createTaskId, but this
+		// guards against future changes to task-id generation (e.g. if it ever
+		// accepted user input).
+		const safeSteeringPath = resolveContainedPath(steeringDir, `${taskId}.jsonl`);
+		fs.appendFileSync(safeSteeringPath, JSON.stringify({ type: "steer", message, ts: new Date().toISOString() }) + "\n");
 	} catch {
 		// Best-effort: file write failure doesn't block the steer from pending array
 	}
@@ -1042,19 +1049,65 @@ function getCrewGlobalRegistry(): CrewRegistry | undefined {
 	return (globalThis as Record<symbol | string, unknown>)[CREW_REGISTRY_KEY] as CrewRegistry | undefined;
 }
 
-/** Create and install the global CrewRegistry singleton. Call once at extension init. */
-export function installCrewGlobalRegistry(): void {
-	registerCrewGlobalRegistry({
+/** Manifest cache shape needed to construct the global registry's read-side. */
+interface ManifestCacheForRegistry {
+	get: (runId: string) => TeamRunManifest | undefined;
+	list: (limit: number) => TeamRunManifest[];
+}
+
+/**
+ * Build and install the global CrewRegistry singleton in a single atomic step.
+ *
+ * EXT-7 (Round 3): The previous design called `installCrewGlobalRegistry()` to
+ * install stubs, then patched the manifest-backed methods asynchronously inside
+ * `register.ts`. That left a window where cross-extension consumers could observe
+ * the stub object on `globalThis[Symbol.for("pi-crew:registry")]`. By taking the
+ * real dependencies up-front, we install the registry once with no stub phase —
+ * callers see either no registry (pre-init) or the fully-real registry.
+ */
+export function installCrewGlobalRegistry(deps?: { manifestCache: ManifestCacheForRegistry; cwdProvider: () => string }): void {
+	const manifestCache = deps?.manifestCache;
+	const cwdProvider = deps?.cwdProvider ?? ((): string => process.cwd());
+	const registry: CrewRegistry = {
 		version: 2,
-		getRecord: (runId: string) => undefined as unknown as TeamRunManifest,
-		listRuns: () => [],
-		appendEvent: () => {},
-		waitForAll: async () => {},
-		hasRunning: () => false,
+		getRecord: (runId: string) => manifestCache?.get(runId),
+		listRuns: () =>
+			manifestCache
+				? manifestCache.list(100).map((m) => ({ runId: m.runId, status: m.status, goal: m.goal }))
+				: ([] as Array<{ runId: string; status: string; goal: string }>),
+		appendEvent: (runId: string, event: Record<string, unknown>) => {
+			if (!manifestCache) return;
+			const manifest = manifestCache.get(runId);
+			if (manifest) {
+				// LAZY: event-log is already loaded at module top, so use the
+				// pre-resolved appendEventFireAndForget instead of re-importing.
+				appendEventFireAndForget(manifest.eventsPath, event as Parameters<typeof appendEventFireAndForget>[1]);
+			}
+		},
+		waitForAll: async (runId: string) => {
+			if (!manifestCache) return;
+			// LAZY: state-store is already loaded at module top; use the pre-resolved loadRunManifestById.
+			const check = (): boolean => {
+				const loaded = loadRunManifestById(cwdProvider(), runId);
+				if (!loaded) return true;
+				return !loaded.tasks.some((t: { status: string }) => t.status === "running" || t.status === "queued");
+			};
+			while (!check()) await new Promise((resolve) => setTimeout(resolve, 500));
+		},
+		hasRunning: (runId: string) => {
+			if (!manifestCache) return false;
+			const manifest = manifestCache.get(runId);
+			if (!manifest) return false;
+			// LAZY: state-store is already loaded at module top; use the pre-resolved loadRunManifestById.
+			const loaded = loadRunManifestById(cwdProvider(), runId);
+			if (!loaded) return false;
+			return loaded.tasks.some((t: { status: string }) => t.status === "running" || t.status === "queued");
+		},
 		registerAgent: registerDynamicAgent,
 		unregisterAgent: unregisterDynamicAgent,
 		listDynamicAgents,
-	});
+	};
+	registerCrewGlobalRegistry(registry);
 }
 
 /** Remove the global CrewRegistry singleton. Call during session cleanup. */

package/src/hooks/registry.ts

@@ -141,8 +141,13 @@ export async function executeHook(name: HookName, ctx: HookContext): Promise<Hoo
 				};
 			}
 			if (result.outcome === "modify" && result.data) {
-				Object.assign(ctx, sanitizeMergeData(result.data));
-				capturedModifications = { ...result.data };
+				// EXT-13 (Round 3): Deep-clone hook result.data so subsequent hooks
+				// (or the same hook if reused) cannot mutate shared ctx via shared
+				// nested-object references. sanitizeMergeData already produces a
+				// fresh top-level object, but nested values would still alias.
+				const clonedData = sanitizeMergeData(result.data);
+				Object.assign(ctx, clonedData);
+				capturedModifications = clonedData;
 			}
 		} catch (error) {
 			const message = sanitizeErrorMessage(error instanceof Error ? error.message : String(error));