pi-crew 0.9.16 → 0.9.17

package/src/runtime/batch-barrier.ts

@@ -39,13 +39,7 @@ export interface BatchSnapshot {
 	notified: boolean;
 }
 
-const TERMINAL_STATUSES = new Set([
-	"completed",
-	"failed",
-	"cancelled",
-	"error",
-	"stopped",
-]);
+const TERMINAL_STATUSES = new Set(["completed", "failed", "cancelled", "error", "stopped"]);
 
 export function isTerminalStatus(status: string): boolean {
 	return TERMINAL_STATUSES.has(status);
@@ -65,7 +59,11 @@ export class BatchBarrier {
 	register(batchId: string, agentId: string, meta?: { description?: string; type?: string }): void {
 		let batch = this.batches.get(batchId);
 		if (!batch) {
-			batch = { members: new Map(), terminal: new Map(), notified: false };
+			batch = {
+				members: new Map(),
+				terminal: new Map(),
+				notified: false,
+			};
 			this.batches.set(batchId, batch);
 		}
 		if (!batch.members.has(agentId)) {
@@ -87,7 +85,11 @@ export class BatchBarrier {
 	markTerminal(batchId: string, member: BatchMember): BatchSnapshot {
 		let batch = this.batches.get(batchId);
 		if (!batch) {
-			batch = { members: new Map(), terminal: new Map(), notified: false };
+			batch = {
+				members: new Map(),
+				terminal: new Map(),
+				notified: false,
+			};
 			this.batches.set(batchId, batch);
 		}
 		// Ensure the member is known (auto-register for the defensive case).
@@ -97,11 +99,13 @@ export class BatchBarrier {
 		if (isTerminalStatus(member.status)) {
 			batch.terminal.set(member.id, { ...member });
 			const existing = batch.members.get(member.id);
-			if (existing) batch.members.set(member.id, { ...existing, status: member.status });
+			if (existing)
+				batch.members.set(member.id, {
+					...existing,
+					status: member.status,
+				});
 		}
-		const allDone =
-			batch.members.size > 0 &&
-			[...batch.members.keys()].every((id) => batch.terminal.has(id));
+		const allDone = batch.members.size > 0 && [...batch.members.keys()].every((id) => batch.terminal.has(id));
 		return {
 			batchId,
 			members: [...batch.members.values()],
@@ -130,9 +134,7 @@ export class BatchBarrier {
 			batchId,
 			members: [...batch.members.values()],
 			terminal: [...batch.terminal.values()],
-			allDone:
-				batch.members.size > 0 &&
-				[...batch.members.keys()].every((id) => batch.terminal.has(id)),
+			allDone: batch.members.size > 0 && [...batch.members.keys()].every((id) => batch.terminal.has(id)),
 			notified: batch.notified,
 		};
 	}

package/src/runtime/cancellation-token.ts

@@ -1,4 +1,4 @@
-import { CrewCancellationError, type CancellationReason, cancellationReasonFromUnknown } from "./cancellation.ts";
+import { type CancellationReason, CrewCancellationError, cancellationReasonFromUnknown } from "./cancellation.ts";
 
 export interface CancellationTokenState {
 	aborted: boolean;
@@ -28,11 +28,21 @@ export class CancellationToken {
 		else if (options.signal) options.signal.addEventListener("abort", () => this.abort(options.signal?.reason), { once: true });
 	}
 
-	get signal(): AbortSignal { return this.#controller.signal; }
-	get aborted(): boolean { return this.#controller.signal.aborted; }
-	get reason(): CancellationReason | undefined { return this.#reason; }
-	get lastHeartbeatAt(): string | undefined { return this.#lastHeartbeatAt; }
-	get lastHeartbeatStage(): string | undefined { return this.#lastHeartbeatStage; }
+	get signal(): AbortSignal {
+		return this.#controller.signal;
+	}
+	get aborted(): boolean {
+		return this.#controller.signal.aborted;
+	}
+	get reason(): CancellationReason | undefined {
+		return this.#reason;
+	}
+	get lastHeartbeatAt(): string | undefined {
+		return this.#lastHeartbeatAt;
+	}
+	get lastHeartbeatStage(): string | undefined {
+		return this.#lastHeartbeatStage;
+	}
 
 	heartbeat(stage?: string): CancellationTokenState {
 		this.throwIfCancelled();

package/src/runtime/cancellation.ts

@@ -1,6 +1,13 @@
 import type { OperationTerminalEvidence } from "../state/types.ts";
 
-export type CancellationReasonCode = "caller_cancelled" | "leader_interrupted" | "provider_timeout" | "worker_timeout" | "tool_timeout" | "shutdown" | "unknown";
+export type CancellationReasonCode =
+	| "caller_cancelled"
+	| "leader_interrupted"
+	| "provider_timeout"
+	| "worker_timeout"
+	| "tool_timeout"
+	| "shutdown"
+	| "unknown";
 
 export interface CancellationReason {
 	code: CancellationReasonCode;
@@ -13,10 +20,24 @@ export function buildSyntheticTerminalEvidence(
 	reason: CancellationReason,
 	startedAt?: string,
 ): OperationTerminalEvidence {
-	return { operation, status: "cancelled", startedAt, finishedAt: new Date().toISOString(), reason };
+	return {
+		operation,
+		status: "cancelled",
+		startedAt,
+		finishedAt: new Date().toISOString(),
+		reason,
+	};
 }
 
-const KNOWN_CODES: ReadonlySet<string> = new Set(["caller_cancelled", "leader_interrupted", "provider_timeout", "worker_timeout", "tool_timeout", "shutdown", "unknown"]);
+const KNOWN_CODES: ReadonlySet<string> = new Set([
+	"caller_cancelled",
+	"leader_interrupted",
+	"provider_timeout",
+	"worker_timeout",
+	"tool_timeout",
+	"shutdown",
+	"unknown",
+]);
 
 export class CrewCancellationError extends Error {
 	readonly reason: CancellationReason;
@@ -30,18 +51,35 @@ export class CrewCancellationError extends Error {
 
 function reasonFromString(value: string): CancellationReason {
 	const trimmed = value.trim();
-	if (KNOWN_CODES.has(trimmed)) return { code: trimmed as CancellationReasonCode, message: `Cancelled: ${trimmed}` };
-	return { code: "caller_cancelled", message: trimmed || "Cancelled by caller." };
+	if (KNOWN_CODES.has(trimmed))
+		return {
+			code: trimmed as CancellationReasonCode,
+			message: `Cancelled: ${trimmed}`,
+		};
+	return {
+		code: "caller_cancelled",
+		message: trimmed || "Cancelled by caller.",
+	};
 }
 
 export function cancellationReasonFromUnknown(value: unknown): CancellationReason {
 	if (value instanceof CrewCancellationError) return value.reason;
-	if (value instanceof Error) return { code: "caller_cancelled", message: value.message || "Cancelled by caller.", cause: value };
+	if (value instanceof Error)
+		return {
+			code: "caller_cancelled",
+			message: value.message || "Cancelled by caller.",
+			cause: value,
+		};
 	if (typeof value === "string") return reasonFromString(value);
 	if (value && typeof value === "object" && !Array.isArray(value)) {
-		const record = value as { code?: unknown; reason?: unknown; message?: unknown; cause?: unknown };
+		const record = value as {
+			code?: unknown;
+			reason?: unknown;
+			message?: unknown;
+			cause?: unknown;
+		};
 		const rawCode = typeof record.code === "string" ? record.code : typeof record.reason === "string" ? record.reason : undefined;
-		const code = rawCode && KNOWN_CODES.has(rawCode) ? rawCode as CancellationReasonCode : "caller_cancelled";
+		const code = rawCode && KNOWN_CODES.has(rawCode) ? (rawCode as CancellationReasonCode) : "caller_cancelled";
 		const message = typeof record.message === "string" && record.message.trim() ? record.message.trim() : `Cancelled: ${code}`;
 		return { code, message, cause: record.cause ?? value };
 	}

package/src/runtime/capability-inventory.ts

@@ -1,10 +1,10 @@
 import type { AgentConfig, ResourceSource } from "../agents/agent-config.ts";
 import { discoverAgents } from "../agents/discover-agents.ts";
-import { discoverTeams } from "../teams/discover-teams.ts";
-import { discoverWorkflows } from "../workflows/discover-workflows.ts";
+import type { PiTeamsConfig } from "../config/config.ts";
 import { discoverSkills, getLastDiscoveryDiagnostics } from "../skills/discover-skills.ts";
 import type { SkillValidationError } from "../skills/validate.ts";
-import type { PiTeamsConfig } from "../config/config.ts";
+import { discoverTeams } from "../teams/discover-teams.ts";
+import { discoverWorkflows } from "../workflows/discover-workflows.ts";
 
 export type CapabilityKind = "team" | "workflow" | "agent" | "skill" | "tool" | "runtime";
 export type CapabilitySource = "builtin" | "project" | "user" | "package" | "git";
@@ -105,7 +105,9 @@ export function buildCapabilityInventory(cwd: string, config?: PiTeamsConfig): C
 	];
 
 	// Mark shadowed resources: project/user items with same kind:name as a builtin
-	const builtinNames = new Set(items.filter((item) => item.source === "builtin" || item.source === "package").map((item) => `${item.kind}:${item.name}`));
+	const builtinNames = new Set(
+		items.filter((item) => item.source === "builtin" || item.source === "package").map((item) => `${item.kind}:${item.name}`),
+	);
 	for (const item of items) {
 		if (item.source !== "builtin" && item.source !== "package" && builtinNames.has(`${item.kind}:${item.name}`)) {
 			item.state = "shadowed";

package/src/runtime/chain-parser.ts

@@ -48,19 +48,39 @@ function tokenize(input: string): Token[] {
 
 	while (i < input.length) {
 		// Skip whitespace
-		if (/\s/.test(input[i]!)) { i++; continue; }
+		if (/\s/.test(input[i]!)) {
+			i++;
+			continue;
+		}
 
 		// Arrow ->
 		if (input[i] === "-" && input[i + 1] === ">") {
 			tokens.push({ type: "ARROW", value: "->" });
-			i += 2; continue;
+			i += 2;
+			continue;
 		}
 
 		// Punctuation
-		if (input[i] === "(") { tokens.push({ type: "LPAREN", value: "(" }); i++; continue; }
-		if (input[i] === ")") { tokens.push({ type: "RPAREN", value: ")" }); i++; continue; }
-		if (input[i] === ",") { tokens.push({ type: "COMMA", value: "," }); i++; continue; }
-		if (input[i] === ":") { tokens.push({ type: "COLON", value: ":" }); i++; continue; }
+		if (input[i] === "(") {
+			tokens.push({ type: "LPAREN", value: "(" });
+			i++;
+			continue;
+		}
+		if (input[i] === ")") {
+			tokens.push({ type: "RPAREN", value: ")" });
+			i++;
+			continue;
+		}
+		if (input[i] === ",") {
+			tokens.push({ type: "COMMA", value: "," });
+			i++;
+			continue;
+		}
+		if (input[i] === ":") {
+			tokens.push({ type: "COLON", value: ":" });
+			i++;
+			continue;
+		}
 
 		// Quoted argument
 		if (input[i] === '"' || input[i] === "'") {
@@ -68,8 +88,12 @@ function tokenize(input: string): Token[] {
 			let str = "";
 			i++; // skip opening quote
 			while (i < input.length && input[i] !== quote) {
-				if (input[i] === "\\" && i + 1 < input.length) { i++; str += input[i]; }
-				else { str += input[i]!; }
+				if (input[i] === "\\" && i + 1 < input.length) {
+					i++;
+					str += input[i];
+				} else {
+					str += input[i]!;
+				}
 				i++;
 			}
 			if (i >= input.length) throw new Error("Unclosed quoted string in chain DSL");
@@ -82,7 +106,10 @@ function tokenize(input: string): Token[] {
 		if (input[i] === "-" && input[i + 1] === "-") {
 			let flag = "";
 			i += 2;
-			while (i < input.length && /[a-zA-Z0-9_-]/.test(input[i]!)) { flag += input[i]; i++; }
+			while (i < input.length && /[a-zA-Z0-9_-]/.test(input[i]!)) {
+				flag += input[i];
+				i++;
+			}
 			tokens.push({ type: "FLAG", value: flag });
 			continue;
 		}
@@ -90,7 +117,10 @@ function tokenize(input: string): Token[] {
 		// Number
 		if (/[0-9]/.test(input[i]!)) {
 			let num = "";
-			while (i < input.length && /[0-9]/.test(input[i]!)) { num += input[i]; i++; }
+			while (i < input.length && /[0-9]/.test(input[i]!)) {
+				num += input[i];
+				i++;
+			}
 			tokens.push({ type: "NUMBER", value: num });
 			continue;
 		}
@@ -98,7 +128,10 @@ function tokenize(input: string): Token[] {
 		// Name
 		if (/[a-zA-Z_]/.test(input[i]!)) {
 			let name = "";
-			while (i < input.length && /[a-zA-Z0-9_.-]/.test(input[i]!)) { name += input[i]; i++; }
+			while (i < input.length && /[a-zA-Z0-9_.-]/.test(input[i]!)) {
+				name += input[i];
+				i++;
+			}
 			tokens.push({ type: "NAME", value: name });
 			continue;
 		}

package/src/runtime/chain-runner.ts

@@ -1,18 +1,18 @@
 /**
  * ChainRunner - Execute sequential chains with `->` syntax support.
- * 
+ *
  * Based on pi-boomerang's parseChain pattern:
  * - Parses "teamA -> teamB -> teamC" syntax
  * - Supports per-step overrides for model, skill, thinking
  * - Accumulates handoffs between steps
  * - Executes steps sequentially with context passing
- * 
+ *
  * @see docs/pi-boomerang-integration-plan.md
  */
 
-import type { HandoffSummary, HandoffManager, TaskPacket, TaskResult } from "./handoff-manager.ts";
-import { parseChainDSL } from "./chain-parser.ts";
 import type { ChainStep as DSLChainStep } from "./chain-parser.ts";
+import { parseChainDSL } from "./chain-parser.ts";
+import type { HandoffManager, HandoffSummary, TaskPacket, TaskResult } from "./handoff-manager.ts";
 
 /**
  * Single step in a chain.
@@ -109,32 +109,29 @@ export class ChainRunner {
 	private taskRunner: ChainTaskRunner;
 	private handoffManager: HandoffManager;
 
-	constructor(
-		taskRunner: ChainTaskRunner,
-		handoffManager: HandoffManager,
-	) {
+	constructor(taskRunner: ChainTaskRunner, handoffManager: HandoffManager) {
 		this.taskRunner = taskRunner;
 		this.handoffManager = handoffManager;
 	}
 
 	/**
 	 * Parse chain syntax: step1 -> step2 -> step3
-	 * 
+	 *
 	 * Supports multiple syntaxes:
 	 * - Team reference: @teamName
 	 * - Workflow reference: workflow:name
 	 * - Template reference: template:name
 	 * - Inline goal: "goal description"
-	 * 
+	 *
 	 * @example
 	 * parseChain("@research -> @implement -> @review")
 	 * parseChain('"Research AI trends" -> "Analyze findings"')
 	 * parseChain("@step1 --model claude-opus-3 -> @step2")
-	 * 
+	 *
 	 * Also supports DSL syntax from chain-parser for advanced constructs:
 	 * parseChain("step1 -> parallel(step2, step3) -> step4")
 	 * parseChain("step1:3 -> step2 --with-context -> step3")
-	 * 
+	 *
 	 * @param chainString - The chain string to parse
 	 * @returns Parsed chain specification
 	 */
@@ -150,7 +147,7 @@ export class ChainRunner {
 			}
 		}
 
-		const stepStrings = chainString.split("->").map(s => s.trim());
+		const stepStrings = chainString.split("->").map((s) => s.trim());
 
 		const steps: ChainStep[] = stepStrings.map((step, index) => {
 			return this.parseStep(step, index);
@@ -174,17 +171,13 @@ export class ChainRunner {
 	/**
 	 * Execute chain sequentially.
 	 * Each step receives handoff from previous step.
-	 * 
+	 *
 	 * @param spec - Parsed chain specification
 	 * @param initialContext - Initial context for the chain
 	 * @param eventsPath - Optional event log path for events
 	 * @returns Final chain result
 	 */
-	async runChain(
-		spec: ChainSpec,
-		initialContext: Record<string, unknown> = {},
-		eventsPath?: string
-	): Promise<ChainResult> {
+	async runChain(spec: ChainSpec, initialContext: Record<string, unknown> = {}, eventsPath?: string): Promise<ChainResult> {
 		const stepResults: ChainStepResult[] = [];
 		let accumulatedContext = { ...initialContext };
 		const startTime = Date.now();
@@ -200,10 +193,7 @@ export class ChainRunner {
 				const effectiveConfig = this.getEffectiveConfig(step, spec);
 
 				// Enrich context with previous handoffs
-				const stepContext = this.enrichContextFromHandoffs(
-					accumulatedContext,
-					stepResults
-				);
+				const stepContext = this.enrichContextFromHandoffs(accumulatedContext, stepResults);
 
 				// Execute step
 				const result = await this.executeStep(effectiveConfig, stepContext);
@@ -214,10 +204,7 @@ export class ChainRunner {
 				}
 
 				// Generate handoff for next step
-				const handoff = await this.handoffManager.generateSummary(
-					this.createMinimalPacket(step, i),
-					result
-				);
+				const handoff = await this.handoffManager.generateSummary(this.createMinimalPacket(step, i), result);
 
 				stepResults.push({
 					step: i + 1,
@@ -228,7 +215,9 @@ export class ChainRunner {
 					duration: Date.now() - stepStart,
 				});
 
-				if (handoff !== null) { allHandoffs.push(handoff); }
+				if (handoff !== null) {
+					allHandoffs.push(handoff);
+				}
 
 				// Update accumulated context on success
 				if (result.outcome === "success") {
@@ -246,7 +235,7 @@ export class ChainRunner {
 
 				// Emit progress event if eventsPath provided
 				if (eventsPath) {
-		// LAZY: defer dynamic import of ../state/event-log.ts to its call site.
+					// LAZY: defer dynamic import of ../state/event-log.ts to its call site.
 					const { appendEventAsync } = await import("../state/event-log.ts");
 					await appendEventAsync(eventsPath, {
 						type: "chain.step_completed",
@@ -260,7 +249,6 @@ export class ChainRunner {
 						},
 					});
 				}
-
 			} catch (error) {
 				const errorMessage = error instanceof Error ? error.message : String(error);
 
@@ -282,7 +270,7 @@ export class ChainRunner {
 		return {
 			steps: stepResults,
 			totalDuration: Date.now() - startTime,
-			success: stepResults.every(s => s.outcome !== "failure"),
+			success: stepResults.every((s) => s.outcome !== "failure"),
 			totalTokens: totalTokens > 0 ? totalTokens : undefined,
 			totalHandoffs: allHandoffs,
 		};
@@ -306,9 +294,7 @@ export class ChainRunner {
 		const inlineMatch = step.match(/"([^"]{1,10000})"/);
 
 		const nameParts = step.split(/\s+/);
-		const name = (nameParts[0] && nameParts[0].length > 0 && nameParts[0].length <= 100)
-			? nameParts[0]
-			: `step-${index}`;
+		const name = nameParts[0] && nameParts[0].length > 0 && nameParts[0].length <= 100 ? nameParts[0] : `step-${index}`;
 
 		const parsed: ChainStep = {
 			name,
@@ -366,9 +352,7 @@ export class ChainRunner {
 	 * DSL features: parallel(...), :loopCount, --with-context flag
 	 */
 	private hasDSLConstructs(chainString: string): boolean {
-		return /\bparallel\s*\(/.test(chainString) ||
-			/\w+:\d+\b/.test(chainString) ||
-			/--with-context/.test(chainString);
+		return /\bparallel\s*\(/.test(chainString) || /\w+:\d+\b/.test(chainString) || /--with-context/.test(chainString);
 	}
 
 	/**
@@ -381,13 +365,22 @@ export class ChainRunner {
 				return {
 					name: dslStep.name,
 					context: {
-						parallel: dslStep.parallel.map(p => ({ name: p.name, loopCount: p.loopCount, withContext: p.withContext, args: p.args })),
+						parallel: dslStep.parallel.map((p) => ({
+							name: p.name,
+							loopCount: p.loopCount,
+							withContext: p.withContext,
+							args: p.args,
+						})),
 					},
 					loopCount: dslStep.loopCount,
 				};
 			}
 			const step: ChainStep = { name: dslStep.name };
-			if (dslStep.loopCount) step.context = { ...step.context, loopCount: dslStep.loopCount };
+			if (dslStep.loopCount)
+				step.context = {
+					...step.context,
+					loopCount: dslStep.loopCount,
+				};
 			if (dslStep.withContext) step.context = { ...step.context, withContext: true };
 			if (dslStep.args && dslStep.args.length > 0) step.context = { ...step.context, args: dslStep.args };
 			return step;
@@ -399,14 +392,20 @@ export class ChainRunner {
 		const globalThinking = this.extractGlobalFlag(chainString, "global-thinking") as "fast" | "standard" | "deep" | undefined;
 		const continueOnError = this.extractGlobalFlag(chainString, "continue-on-error") === "true";
 
-		return { steps, globalModel, globalSkill, globalThinking, continueOnError };
+		return {
+			steps,
+			globalModel,
+			globalSkill,
+			globalThinking,
+			continueOnError,
+		};
 	}
 
 	/**
 	 * Sanitize identifier to prevent injection.
 	 */
 	private sanitizeIdentifier(value: string): string {
-		return value.replace(/[^a-zA-Z0-9_]/g, '_').substring(0, 100);
+		return value.replace(/[^a-zA-Z0-9_]/g, "_").substring(0, 100);
 	}
 
 	/**
@@ -414,7 +413,7 @@ export class ChainRunner {
 	 */
 	private sanitizeInlineGoal(value: string): string {
 		// Remove control characters and limit length
-		return value.replace(/[\x00-\x1F\x7F]/g, '').substring(0, 10000);
+		return value.replace(/[\x00-\x1F\x7F]/g, "").substring(0, 10000);
 	}
 
 	/**
@@ -444,7 +443,7 @@ export class ChainRunner {
 	 */
 	private extractFlag(input: string, flag: string): string | undefined {
 		// Escape regex special characters in flag name to prevent injection
-		const escapedFlag = flag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+		const escapedFlag = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 		const match = input.match(new RegExp(`--${escapedFlag}\\s+(\\S+)`));
 		return match?.[1];
 	}
@@ -456,13 +455,13 @@ export class ChainRunner {
 	 */
 	private extractGlobalFlag(input: string, flag: string): string | undefined {
 		// Escape regex special characters in flag name to prevent injection
-		const escapedFlag = flag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-		const patternEq = '--' + escapedFlag + '=\\s*(\\S+)';
-		const match = input.match(new RegExp(patternEq, 'i'));
+		const escapedFlag = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const patternEq = "--" + escapedFlag + "=\\s*(\\S+)";
+		const match = input.match(new RegExp(patternEq, "i"));
 		if (match) return match[1];
 
-		const patternNoEq = '--' + escapedFlag + '\\s+(\\S+)';
-		const matchNoEq = input.match(new RegExp(patternNoEq, 'i'));
+		const patternNoEq = "--" + escapedFlag + "\\s+(\\S+)";
+		const matchNoEq = input.match(new RegExp(patternNoEq, "i"));
 		if (matchNoEq) return matchNoEq[1];
 
 		return undefined;
@@ -484,13 +483,8 @@ export class ChainRunner {
 	 * Enrich context with previous handoffs.
 	 * Limits history size to prevent memory leaks.
 	 */
-	private enrichContextFromHandoffs(
-		context: Record<string, unknown>,
-		previousResults: ChainStepResult[]
-	): Record<string, unknown> {
-		const handoffs = previousResults
-			.filter(r => r.handoff)
-			.map(r => r.handoff!);
+	private enrichContextFromHandoffs(context: Record<string, unknown>, previousResults: ChainStepResult[]): Record<string, unknown> {
+		const handoffs = previousResults.filter((r) => r.handoff).map((r) => r.handoff!);
 
 		if (handoffs.length === 0) {
 			return context;
@@ -504,24 +498,28 @@ export class ChainRunner {
 		let limitedHandoffs = handoffs;
 		if (handoffs.length > ChainRunner.MAX_CHAIN_HISTORY_SIZE) {
 			const dropped = handoffs.length - ChainRunner.MAX_CHAIN_HISTORY_SIZE;
-			notes.push(`[chain history limited to last ${ChainRunner.MAX_CHAIN_HISTORY_SIZE} entries; ${dropped} older entr${dropped === 1 ? "y" : "ies"} omitted]`);
+			notes.push(
+				`[chain history limited to last ${ChainRunner.MAX_CHAIN_HISTORY_SIZE} entries; ${dropped} older entr${dropped === 1 ? "y" : "ies"} omitted]`,
+			);
 			limitedHandoffs = handoffs.slice(-ChainRunner.MAX_CHAIN_HISTORY_SIZE);
 		}
 
 		// Limit per-entry size to prevent memory issues from large artifacts.
-		const filteredHandoffs = limitedHandoffs.filter(h => {
+		const filteredHandoffs = limitedHandoffs.filter((h) => {
 			const size = JSON.stringify(h).length;
 			return size <= ChainRunner.MAX_HANDOFF_ENTRY_SIZE;
 		});
 		const oversizedDropped = limitedHandoffs.length - filteredHandoffs.length;
 		if (oversizedDropped > 0) {
-			notes.push(`[${oversizedDropped} handoff entr${oversizedDropped === 1 ? "y" : "ies"} omitted (> ${ChainRunner.MAX_HANDOFF_ENTRY_SIZE} bytes each)]`);
+			notes.push(
+				`[${oversizedDropped} handoff entr${oversizedDropped === 1 ? "y" : "ies"} omitted (> ${ChainRunner.MAX_HANDOFF_ENTRY_SIZE} bytes each)]`,
+			);
 		}
 
 		// Track array-cap drops so capped lists do not vanish silently. Each field
 		// over its cap records the full count so a reader knows data was elided.
 		const arrayCapNotes: string[] = [];
-		const mapped = filteredHandoffs.map(h => {
+		const mapped = filteredHandoffs.map((h) => {
 			const over: string[] = [];
 			if (h.filesCreated && h.filesCreated.length > 50) over.push(`filesCreated=${h.filesCreated.length}`);
 			if (h.filesModified && h.filesModified.length > 50) over.push(`filesModified=${h.filesModified.length}`);
@@ -550,10 +548,7 @@ export class ChainRunner {
 	/**
 	 * Execute a single step.
 	 */
-	private async executeStep(
-		config: ChainStep,
-		context: Record<string, unknown>
-	): Promise<TaskResult> {
+	private async executeStep(config: ChainStep, context: Record<string, unknown>): Promise<TaskResult> {
 		// Pass step config (team/workflow/model) into the packet context so the
 		// concrete ChainTaskRunner can resolve which team/workflow to run. Without
 		// this, a step parsed to a @teamName reference would lose its team because
@@ -592,10 +587,7 @@ export class ChainRunner {
 /**
  * Create a ChainRunner with default dependencies.
  */
-export function createChainRunner(
-	taskRunner: ChainTaskRunner,
-	handoffManager: HandoffManager
-): ChainRunner {
+export function createChainRunner(taskRunner: ChainTaskRunner, handoffManager: HandoffManager): ChainRunner {
 	return new ChainRunner(taskRunner, handoffManager);
 }
 
@@ -604,8 +596,10 @@ export function createChainRunner(
  */
 export function parseChainString(chainString: string): ChainSpec {
 	const runner = new ChainRunner(
-		{ runTask: () => Promise.reject(new Error("Not initialized")) } as ChainTaskRunner,
-		{} as HandoffManager
+		{
+			runTask: () => Promise.reject(new Error("Not initialized")),
+		} as ChainTaskRunner,
+		{} as HandoffManager,
 	);
 	return runner.parseChain(chainString);
 }