pi-crew 0.9.16 → 0.9.18

package/src/extension/team-tool/auto-summarize.ts

@@ -3,14 +3,10 @@
  * Provides on/off/status commands for auto-summarization.
  */
 
+import { type AutoSummarizeService, createAutoSummarizeService, DEFAULT_AUTO_SUMMARIZE_CONFIG } from "../../runtime/auto-summarize.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { result, type TeamContext } from "./context.ts";
-import {
-	AutoSummarizeService,
-	createAutoSummarizeService,
-	DEFAULT_AUTO_SUMMARIZE_CONFIG,
-} from "../../runtime/auto-summarize.ts";
 
 // Global auto-summarize service instance for CLI usage
 let globalAutoSummarize: AutoSummarizeService | null = null;
@@ -22,10 +18,7 @@ function getAutoSummarize(): AutoSummarizeService {
 	return globalAutoSummarize;
 }
 
-export function handleAutoSummarizeOn(
-	params: TeamToolParamsValue,
-	ctx: TeamContext,
-): PiTeamsToolResult {
+export function handleAutoSummarizeOn(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
 	const service = getAutoSummarize();
 	const cfg = params.config ?? {};
 
@@ -61,24 +54,18 @@ export function handleAutoSummarizeOn(
 	);
 }
 
-export function handleAutoSummarizeOff(
-	params: TeamToolParamsValue,
-	ctx: TeamContext,
-): PiTeamsToolResult {
+export function handleAutoSummarizeOff(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
 	const service = getAutoSummarize();
 
 	service.disable();
 
-	return result(
-		"Auto-summarize disabled.",
-		{ action: "auto-summarize", status: "ok" },
-	);
+	return result("Auto-summarize disabled.", {
+		action: "auto-summarize",
+		status: "ok",
+	});
 }
 
-export function handleAutoSummarizeStatus(
-	params: TeamToolParamsValue,
-	ctx: TeamContext,
-): PiTeamsToolResult {
+export function handleAutoSummarizeStatus(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
 	const service = getAutoSummarize();
 	const config = service.getConfig();
 	const isEnabled = service.isEnabled();
@@ -103,15 +90,16 @@ export function handleAutoSummarizeStatus(
 	);
 }
 
-export function handleAutoSummarizeConfig(
-	params: TeamToolParamsValue,
-	ctx: TeamContext,
-): PiTeamsToolResult {
+export function handleAutoSummarizeConfig(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
 	const service = getAutoSummarize();
 	const cfg = params.config ?? {};
 
 	// Parse config options
-	const updates: { threshold?: number; minTools?: number; collapseContext?: boolean } = {};
+	const updates: {
+		threshold?: number;
+		minTools?: number;
+		collapseContext?: boolean;
+	} = {};
 
 	if (cfg.threshold !== undefined) {
 		const threshold = typeof cfg.threshold === "number" ? cfg.threshold : parseInt(String(cfg.threshold), 10);

package/src/extension/team-tool/cache-control.ts

@@ -10,11 +10,7 @@ export interface CacheControlDeps {
  * a runEventBus event so the render scheduler coalescer fires immediately.
  * Call this after any state mutation that changes task/agent status.
  */
-export function invalidateSnapshot(
-	runId: string,
-	runCwd: string,
-	deps: CacheControlDeps,
-): void {
+export function invalidateSnapshot(runId: string, runCwd: string, deps: CacheControlDeps): void {
 	// 1. Invalidate snapshot cache entry
 	deps.getRunSnapshotCache(runCwd).invalidate(runId);
 

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

@@ -1,20 +1,20 @@
-import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import { withRunLockSync } from "../../state/locks.ts";
-import { loadRunManifestById, saveRunTasks, updateRunStatus } from "../../state/state-store.ts";
-import { saveCrewAgents, recordFromTask } from "../../runtime/crew-agent-records.ts";
+import { appendHookEvent, executeHook } from "../../hooks/registry.ts";
+import { buildSyntheticTerminalEvidence, type CancellationReason, cancellationReasonFromUnknown } from "../../runtime/cancellation.ts";
+import { killProcessPid } from "../../runtime/child-pi.ts";
+import { recordFromTask, saveCrewAgents } from "../../runtime/crew-agent-records.ts";
 import { writeForegroundInterruptRequest } from "../../runtime/foreground-control.ts";
-import { cancellationReasonFromUnknown, buildSyntheticTerminalEvidence, type CancellationReason } from "../../runtime/cancellation.ts";
 import { terminateLiveAgentsForRun } from "../../runtime/live-agent-manager.ts";
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { appendEvent } from "../../state/event-log.ts";
-import { killProcessPid } from "../../runtime/child-pi.ts";
+import { withRunLockSync } from "../../state/locks.ts";
+import { loadRunManifestById, saveRunTasks, updateRunStatus } from "../../state/state-store.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
-import { executeHook, appendHookEvent } from "../../hooks/registry.ts";
-import type { PiTeamsToolResult } from "../tool-result.ts";
 import { locateRunCwd } from "../team-tool.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { type CacheControlDeps, invalidateSnapshot } from "./cache-control.ts";
 import { result, type TeamContext } from "./context.ts";
-import { RUN_NOT_FOUND_HINT } from "./run-not-found.ts";
 import { enforceDestructiveIntent, intentFromConfig } from "./intent-policy.ts";
-import { invalidateSnapshot, type CacheControlDeps } from "./cache-control.ts";
+import { RUN_NOT_FOUND_HINT } from "./run-not-found.ts";
 
 export interface AbortOwnedResult {
 	abortedIds: string[];
@@ -34,18 +34,17 @@ export interface AbortOwnedResult {
  * the ownerSessionId comes from the context. Foreign detection compares
  * the requesting session against the run's creating session.
  */
-export function abortOwned(
-	runId: string,
-	taskIds: string[] | undefined,
-	ctx: TeamContext,
-	force?: boolean,
-): AbortOwnedResult {
+export function abortOwned(runId: string, taskIds: string[] | undefined, ctx: TeamContext, force?: boolean): AbortOwnedResult {
 	const runCwd = locateRunCwd(runId, ctx.cwd);
 	if (!runCwd) return { abortedIds: [], missingIds: taskIds ?? [], foreignIds: [] };
 	const loaded = loadRunManifestById(runCwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return { abortedIds: [], missingIds: taskIds ?? [], foreignIds: [] };
 
-	const result: AbortOwnedResult = { abortedIds: [], missingIds: [], foreignIds: [] };
+	const result: AbortOwnedResult = {
+		abortedIds: [],
+		missingIds: [],
+		foreignIds: [],
+	};
 	const taskMap = new Map(loaded.tasks.map((t) => [t.id, t] as const));
 	const targetIds = taskIds ?? loaded.tasks.map((t) => t.id);
 	const foreignRun = typeof loaded.manifest.ownerSessionId === "string" && loaded.manifest.ownerSessionId !== ctx.sessionId;
@@ -74,7 +73,13 @@ function configFromParams(params: TeamToolParamsValue): Record<string, unknown>
 function cancelReasonFromParams(params: TeamToolParamsValue): CancellationReason {
 	const config = configFromParams(params);
 	const rawReason = config?.reason ?? config?.cancelReason;
-	const reason = rawReason === undefined ? { code: "caller_cancelled" as const, message: "Run cancelled by user request." } : cancellationReasonFromUnknown(rawReason);
+	const reason =
+		rawReason === undefined
+			? {
+					code: "caller_cancelled" as const,
+					message: "Run cancelled by user request.",
+				}
+			: cancellationReasonFromUnknown(rawReason);
 	return { code: reason.code, message: reason.message };
 }
 
@@ -88,14 +93,25 @@ export async function handleRetry(params: TeamToolParamsValue, ctx: TeamContext,
 	// Pre-lock ownership check: reject foreign-owned runs unless force is set
 	const foreignRun = typeof loaded.manifest.ownerSessionId === "string" && loaded.manifest.ownerSessionId !== ctx.sessionId;
 	if (foreignRun && !params.force) {
-		return result(`Run ${loaded.manifest.runId} belongs to another session. Use force: true to override.`, { action: "retry", status: "error", runId: loaded.manifest.runId }, true);
+		return result(
+			`Run ${loaded.manifest.runId} belongs to another session. Use force: true to override.`,
+			{ action: "retry", status: "error", runId: loaded.manifest.runId },
+			true,
+		);
 	}
 
 	// Execute before_retry hook after ownership confirmed, before mutation lock
-	const hookReport = await executeHook("before_retry", { runId: loaded.manifest.runId, cwd: ctx.cwd });
+	const hookReport = await executeHook("before_retry", {
+		runId: loaded.manifest.runId,
+		cwd: ctx.cwd,
+	});
 	appendHookEvent(loaded.manifest, hookReport);
 	if (hookReport.outcome === "block") {
-		return result(`Retry blocked by hook: ${hookReport.reason ?? "before_retry hook blocked the operation."}`, { action: "retry", status: "error", runId: loaded.manifest.runId }, true);
+		return result(
+			`Retry blocked by hook: ${hookReport.reason ?? "before_retry hook blocked the operation."}`,
+			{ action: "retry", status: "error", runId: loaded.manifest.runId },
+			true,
+		);
 	}
 
 	const targetTaskId = typeof params.taskId === "string" ? params.taskId : undefined;
@@ -109,7 +125,15 @@ export async function handleRetry(params: TeamToolParamsValue, ctx: TeamContext,
 		});
 
 		if (matchingTasks.length === 0) {
-			return result(targetTaskId ? `Task '${targetTaskId}' is not failed/cancelled; nothing to retry.` : "No failed/cancelled tasks to retry.", { action: "retry", status: "error", runId: loaded.manifest.runId }, true);
+			return result(
+				targetTaskId ? `Task '${targetTaskId}' is not failed/cancelled; nothing to retry.` : "No failed/cancelled tasks to retry.",
+				{
+					action: "retry",
+					status: "error",
+					runId: loaded.manifest.runId,
+				},
+				true,
+			);
 		}
 
 		const retriedIds = new Set(matchingTasks.map((t) => t.id));
@@ -120,14 +144,22 @@ export async function handleRetry(params: TeamToolParamsValue, ctx: TeamContext,
 		});
 		saveRunTasks(loaded.manifest, tasks);
 		try {
-			saveCrewAgents(loaded.manifest, tasks.map((task) => recordFromTask(loaded.manifest, task, "child-process")));
+			saveCrewAgents(
+				loaded.manifest,
+				tasks.map((task) => recordFromTask(loaded.manifest, task, "child-process")),
+			);
 		} catch (error) {
 			logInternalError("team-tool.handleRetry.crewAgents", error, `runId=${loaded.manifest.runId}`);
 		}
 
 		const retriedTaskIds = [...retriedIds];
 		for (const taskId of retriedTaskIds) {
-			appendEvent(loaded.manifest.eventsPath, { type: "task.retried", runId: loaded.manifest.runId, taskId, message: `Task ${taskId} queued for retry.` });
+			appendEvent(loaded.manifest.eventsPath, {
+				type: "task.retried",
+				runId: loaded.manifest.runId,
+				taskId,
+				message: `Task ${taskId} queued for retry.`,
+			});
 		}
 
 		if (deps) invalidateSnapshot(loaded.manifest.runId, runCwd, deps);
@@ -153,14 +185,30 @@ export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext
 	// Pre-lock ownership check: reject foreign-owned runs unless force is set
 	const preCheck = abortOwned(loaded.manifest.runId, undefined, ctx, params.force);
 	if (preCheck.abortedIds.length === 0 && preCheck.foreignIds.length > 0 && !params.force) {
-		return result(`Run ${loaded.manifest.runId} belongs to another session. Use force: true to override.`, { action: "cancel", status: "error", runId: loaded.manifest.runId, foreignIds: preCheck.foreignIds }, true);
+		return result(
+			`Run ${loaded.manifest.runId} belongs to another session. Use force: true to override.`,
+			{
+				action: "cancel",
+				status: "error",
+				runId: loaded.manifest.runId,
+				foreignIds: preCheck.foreignIds,
+			},
+			true,
+		);
 	}
 
 	// Execute before_cancel hook after ownership confirmed, before mutation lock
-	const hookReport = await executeHook("before_cancel", { runId: loaded.manifest.runId, cwd: ctx.cwd });
+	const hookReport = await executeHook("before_cancel", {
+		runId: loaded.manifest.runId,
+		cwd: ctx.cwd,
+	});
 	appendHookEvent(loaded.manifest, hookReport);
 	if (hookReport.outcome === "block") {
-		return result(`Cancel blocked by hook: ${hookReport.reason ?? "before_cancel hook blocked the operation."}`, { action: "cancel", status: "error", runId: loaded.manifest.runId }, true);
+		return result(
+			`Cancel blocked by hook: ${hookReport.reason ?? "before_cancel hook blocked the operation."}`,
+			{ action: "cancel", status: "error", runId: loaded.manifest.runId },
+			true,
+		);
 	}
 	await terminateLiveAgentsForRun(loaded.manifest.runId, "cancelled", appendEvent, loaded.manifest.eventsPath);
 
@@ -170,19 +218,42 @@ export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext
 	if (asyncPid !== undefined && asyncPid > 0) {
 		try {
 			killProcessPid(asyncPid);
-			appendEvent(loaded.manifest.eventsPath, { type: "async.kill_requested", runId: loaded.manifest.runId, message: "Sent SIGTERM to background runner process.", data: { pid: asyncPid } });
+			appendEvent(loaded.manifest.eventsPath, {
+				type: "async.kill_requested",
+				runId: loaded.manifest.runId,
+				message: "Sent SIGTERM to background runner process.",
+				data: { pid: asyncPid },
+			});
 		} catch (error) {
 			logInternalError("team-tool.handleCancel.killAsync", error, `runId=${loaded.manifest.runId},pid=${asyncPid}`);
 		}
 	}
 
 	return withRunLockSync(loaded.manifest, () => {
-		if ((loaded.manifest.status === "completed" || loaded.manifest.status === "cancelled") && !params.force) return result(`Run ${loaded.manifest.runId} is already ${loaded.manifest.status}; nothing to cancel. Use force: true to mark it cancelled anyway.`, { action: "cancel", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+		if ((loaded.manifest.status === "completed" || loaded.manifest.status === "cancelled") && !params.force)
+			return result(
+				`Run ${loaded.manifest.runId} is already ${loaded.manifest.status}; nothing to cancel. Use force: true to mark it cancelled anyway.`,
+				{
+					action: "cancel",
+					status: "ok",
+					runId: loaded.manifest.runId,
+					artifactsRoot: loaded.manifest.artifactsRoot,
+				},
+			);
 
 		// Classify tasks for foreign-aware cancellation
 		const abortResult = abortOwned(loaded.manifest.runId, undefined, ctx, params.force);
 		if (abortResult.abortedIds.length === 0 && abortResult.foreignIds.length > 0 && !params.force) {
-			return result(`Run ${loaded.manifest.runId} belongs to another session. Use force: true to override.`, { action: "cancel", status: "error", runId: loaded.manifest.runId, foreignIds: abortResult.foreignIds }, true);
+			return result(
+				`Run ${loaded.manifest.runId} belongs to another session. Use force: true to override.`,
+				{
+					action: "cancel",
+					status: "error",
+					runId: loaded.manifest.runId,
+					foreignIds: abortResult.foreignIds,
+				},
+				true,
+			);
 		}
 		const cancellableIds = new Set(abortResult.abortedIds);
 		const cancelReason = cancelReasonFromParams(params);
@@ -192,9 +263,20 @@ export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext
 
 		const tasks = loaded.tasks.map((task) => {
 			if (cancellableIds.has(task.id) && (task.status === "queued" || task.status === "running" || task.status === "waiting")) {
-				const base = { ...task, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: cancelMessage };
+				const base = {
+					...task,
+					status: "cancelled" as const,
+					finishedAt: new Date().toISOString(),
+					error: cancelMessage,
+				};
 				if (task.status === "running") {
-					return { ...base, terminalEvidence: [...(task.terminalEvidence ?? []), buildSyntheticTerminalEvidence("worker", cancelReason, task.startedAt)] };
+					return {
+						...base,
+						terminalEvidence: [
+							...(task.terminalEvidence ?? []),
+							buildSyntheticTerminalEvidence("worker", cancelReason, task.startedAt),
+						],
+					};
 				}
 				return base;
 			}
@@ -202,7 +284,10 @@ export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext
 		});
 		saveRunTasks(loaded.manifest, tasks);
 		try {
-			saveCrewAgents(loaded.manifest, tasks.map((task) => recordFromTask(loaded.manifest, task, loaded.manifest.runtimeResolution?.kind ?? "child-process")));
+			saveCrewAgents(
+				loaded.manifest,
+				tasks.map((task) => recordFromTask(loaded.manifest, task, loaded.manifest.runtimeResolution?.kind ?? "child-process")),
+			);
 		} catch (error) {
 			logInternalError("team-tool.handleCancel.crewAgents", error, `runId=${loaded.manifest.runId}`);
 		}
@@ -213,14 +298,29 @@ export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext
 		}
 		ctx.abortForegroundRun?.(loaded.manifest.runId);
 		for (const taskId of abortResult.abortedIds) {
-			appendEvent(loaded.manifest.eventsPath, { type: "task.cancelled", runId: loaded.manifest.runId, taskId, message: cancelMessage, data: cancelData });
+			appendEvent(loaded.manifest.eventsPath, {
+				type: "task.cancelled",
+				runId: loaded.manifest.runId,
+				taskId,
+				message: cancelMessage,
+				data: cancelData,
+			});
 		}
-		const updated = updateRunStatus(loaded.manifest, "cancelled", `${cancelMessage} Already-finished worker processes are not retroactively changed.`, { data: cancelData });
+		const updated = updateRunStatus(
+			loaded.manifest,
+			"cancelled",
+			`${cancelMessage} Already-finished worker processes are not retroactively changed.`,
+			{ data: cancelData },
+		);
 
 		// Build descriptive message including foreign/missing info
 		const parts = [`Cancelled run ${updated.runId}.`];
-		if (abortResult.foreignIds.length > 0) parts.push(` ${abortResult.foreignIds.length} task(s) belong to another session and were not cancelled: ${abortResult.foreignIds.join(", ")}.`);
-		if (abortResult.missingIds.length > 0) parts.push(` ${abortResult.missingIds.length} task ID(s) not found: ${abortResult.missingIds.join(", ")}.`);
+		if (abortResult.foreignIds.length > 0)
+			parts.push(
+				` ${abortResult.foreignIds.length} task(s) belong to another session and were not cancelled: ${abortResult.foreignIds.join(", ")}.`,
+			);
+		if (abortResult.missingIds.length > 0)
+			parts.push(` ${abortResult.missingIds.length} task ID(s) not found: ${abortResult.missingIds.join(", ")}.`);
 
 		if (deps) invalidateSnapshot(updated.runId, runCwd, deps);
 		return result(parts.join(""), {
@@ -234,4 +334,4 @@ export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext
 			intent: cancelIntent,
 		});
 	});
-}
+}

package/src/extension/team-tool/chain-dispatch.ts

@@ -15,10 +15,10 @@
 
 import { ChainRunner, parseChainString } from "../../runtime/chain-runner.ts";
 import { HandoffManager } from "../../runtime/handoff-manager.ts";
-import { ChainTeamRunExecutor, type HandleRunFn } from "./chain-executor.ts";
-import { result, type TeamContext } from "./context.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
+import { ChainTeamRunExecutor, type HandleRunFn } from "./chain-executor.ts";
+import { result, type TeamContext } from "./context.ts";
 
 /**
  * Execute a chain expression (`"a -> b -> c"`). Each step runs a real team run
@@ -30,11 +30,7 @@ import type { PiTeamsToolResult } from "../tool-result.ts";
  * @param ctx     - The team tool context (cwd is used to load run manifests).
  * @param handleRun - The run.ts `handleRun` function reference (injected).
  */
-export async function handleChainRun(
-	params: TeamToolParamsValue,
-	ctx: TeamContext,
-	handleRun: HandleRunFn,
-): Promise<PiTeamsToolResult> {
+export async function handleChainRun(params: TeamToolParamsValue, ctx: TeamContext, handleRun: HandleRunFn): Promise<PiTeamsToolResult> {
 	const chainString = params.chain;
 	if (!chainString || chainString.trim().length === 0) {
 		return result("Chain expression is empty.", { action: "run", status: "error" }, true);
@@ -43,7 +39,7 @@ export async function handleChainRun(
 	const spec = parseChainString(chainString);
 	if (spec.steps.length === 0) {
 		return result(
-			"Chain must contain at least one step. Use the form: \"step1 -> step2 -> step3\".",
+			'Chain must contain at least one step. Use the form: "step1 -> step2 -> step3".',
 			{ action: "run", status: "error" },
 			true,
 		);
@@ -72,11 +68,7 @@ export async function handleChainRun(
 	];
 	for (const s of chainResult.steps) {
 		const runId = executor.stepRunIds[s.step - 1];
-		const tag =
-			s.outcome === "success" ? "✓"
-			: s.outcome === "failure" ? "✗"
-			: s.outcome === "partial" ? "≈"
-			: "⊘";
+		const tag = s.outcome === "success" ? "✓" : s.outcome === "failure" ? "✗" : s.outcome === "partial" ? "≈" : "⊘";
 		lines.push(
 			`${tag} Step ${s.step} [${s.name}]: ${s.outcome} (${s.duration}ms)${runId ? ` runId=${runId}` : ""}${s.error ? ` | ${s.error}` : ""}`,
 		);

package/src/extension/team-tool/chain-executor.ts

@@ -24,27 +24,24 @@
  * @see src/extension/team-tool/run.ts (handleRun — the reused machinery)
  */
 
+import * as fs from "node:fs";
+import * as path from "node:path";
 import type { ChainTaskRunner } from "../../runtime/chain-runner.ts";
-import type { TaskPacket, TaskResult, Decision } from "../../runtime/handoff-manager.ts";
-import { loadRunManifestById, createRunPaths } from "../../state/state-store.ts";
+import type { Decision, TaskPacket, TaskResult } from "../../runtime/handoff-manager.ts";
 import { readIfSmallWithTee } from "../../runtime/task-output-context.ts";
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import { createRunPaths, loadRunManifestById } from "../../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { textFromToolResult } from "../tool-result.ts";
-import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import type { TeamContext } from "./context.ts";
-import * as fs from "node:fs";
-import * as path from "node:path";
 
 /**
  * Signature of `handleRun`, declared locally (type-only) to break the
  * import cycle with run.ts. Structurally identical to
  * `(params, ctx) => Promise<PiTeamsToolResult>`.
  */
-export type HandleRunFn = (
-	params: TeamToolParamsValue,
-	ctx: TeamContext,
-) => Promise<PiTeamsToolResult>;
+export type HandleRunFn = (params: TeamToolParamsValue, ctx: TeamContext) => Promise<PiTeamsToolResult>;
 
 /** Per-step team/workflow/model overrides forwarded from the chain invocation. */
 export interface ChainExecutorOverrides {
@@ -94,8 +91,8 @@ export function formatChainHistory(context: Record<string, unknown>): string {
 		if (entry.decisions?.length) {
 			lines.push("Decisions:");
 			for (const d of entry.decisions) {
-				const rationale = (d && typeof d === "object" && "rationale" in d) ? String(d.rationale) : "(undocumented)";
-				const decisionOutcome = (d && typeof d === "object" && "outcome" in d) ? String(d.outcome) : "";
+				const rationale = d && typeof d === "object" && "rationale" in d ? String(d.rationale) : "(undocumented)";
+				const decisionOutcome = d && typeof d === "object" && "outcome" in d ? String(d.outcome) : "";
 				lines.push(`- ${rationale}${decisionOutcome ? ` → ${decisionOutcome}` : ""}`);
 			}
 		}
@@ -133,19 +130,12 @@ export function formatChainHistory(context: Record<string, unknown>): string {
  *
  * Extracted as a pure function for unit testability (acceptance criterion 6b).
  */
-export function mapRunToTaskResult(
-	manifest: TeamRunManifest,
-	tasks: TeamTaskState[],
-): TaskResult {
+export function mapRunToTaskResult(manifest: TeamRunManifest, tasks: TeamTaskState[]): TaskResult {
 	// Determine outcome from manifest status.
 	let outcome: TaskResult["outcome"];
 	if (manifest.status === "completed") {
 		outcome = "success";
-	} else if (
-		manifest.status === "failed" ||
-		manifest.status === "blocked" ||
-		manifest.status === "cancelled"
-	) {
+	} else if (manifest.status === "failed" || manifest.status === "blocked" || manifest.status === "cancelled") {
 		outcome = "failure";
 	} else {
 		// queued / planning / running → not terminal yet
@@ -196,10 +186,7 @@ export function mapRunToTaskResult(
  *
  * Returns the concatenated output text, or undefined if no artifacts were readable.
  */
-export function readChainStepOutput(
-	manifest: TeamRunManifest,
-	tasks: TeamTaskState[],
-): string | undefined {
+export function readChainStepOutput(manifest: TeamRunManifest, tasks: TeamTaskState[]): string | undefined {
 	const parts: string[] = [];
 	for (const t of tasks) {
 		if (t.status !== "completed" || !t.resultArtifact?.path) continue;
@@ -247,21 +234,12 @@ export class ChainTeamRunExecutor implements ChainTaskRunner {
 		// 1. Format chain history into the goal — this is how context reaches the worker.
 		//    Mirrors the parentContext pattern in child-pi.ts (parent context + task delimiter).
 		const historyPrefix = formatChainHistory(context);
-		const enrichedGoal = historyPrefix
-			? `${historyPrefix}\n\n---\n# Current Chain Step\n${packet.goal}`
-			: packet.goal;
+		const enrichedGoal = historyPrefix ? `${historyPrefix}\n\n---\n# Current Chain Step\n${packet.goal}` : packet.goal;
 
 		// 2. Resolve team/workflow/model: step config (set by executeStep) → overrides → default.
-		const stepTeam =
-			(context.__chainStepTeam as string | undefined) ??
-			this.overrides.team ??
-			"default";
-		const stepWorkflow =
-			(context.__chainStepWorkflow as string | undefined) ??
-			this.overrides.workflow;
-		const stepModel =
-			(context.__chainStepModel as string | undefined) ??
-			this.overrides.model;
+		const stepTeam = (context.__chainStepTeam as string | undefined) ?? this.overrides.team ?? "default";
+		const stepWorkflow = (context.__chainStepWorkflow as string | undefined) ?? this.overrides.workflow;
+		const stepModel = (context.__chainStepModel as string | undefined) ?? this.overrides.model;
 
 		// 3. Call handleRun for the heavy lifting. async:false forces each step to
 		//    complete synchronously (overrides asyncByDefault) so the chain is sequential.
@@ -341,22 +319,22 @@ export function writeRunFixture(
 			retention: "run" as const,
 		};
 		if (!tasks || tasks.length === 0) {
-			tasks = [{
-				id: taskId,
-				runId,
-				role: "executor",
-				agent: "executor",
-				title: "(chain step fixture)",
-				status: "completed",
-				dependsOn: [],
-				cwd,
-				resultArtifact,
-			}];
+			tasks = [
+				{
+					id: taskId,
+					runId,
+					role: "executor",
+					agent: "executor",
+					title: "(chain step fixture)",
+					status: "completed",
+					dependsOn: [],
+					cwd,
+					resultArtifact,
+				},
+			];
 		} else {
 			// Attach resultArtifact to the first task if it doesn't have one.
-			tasks = tasks.map((t, i) => i === 0 && !t.resultArtifact
-				? { ...t, resultArtifact }
-				: t);
+			tasks = tasks.map((t, i) => (i === 0 && !t.resultArtifact ? { ...t, resultArtifact } : t));
 		}
 	}
 

package/src/extension/team-tool/config-patch.ts

@@ -1,4 +1,4 @@
-import { effectiveAutonomousConfig, parseConfig, type PiTeamsAutonomousConfig, type PiTeamsConfig } from "../../config/config.ts";
+import { effectiveAutonomousConfig, type PiTeamsAutonomousConfig, type PiTeamsConfig, parseConfig } from "../../config/config.ts";
 
 const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);