pi-crew 0.5.5 → 0.5.6

package/src/extension/register.ts

@@ -860,7 +860,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 							.then(({ stopWatchdog }) => {
 								stopWatchdog(runId);
 							})
-							.catch(() => {});
+							.catch((error) => logInternalError("register.foreground-watchdog", error, `runId=${runId}`));
 					}
 					const ownerCurrent = isContextCurrent(ctx, ownerGeneration);
 					if (ctx.hasUI) {
@@ -943,9 +943,11 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	function getPiEvents():
 		| Parameters<typeof registerPiCrewRpc>[0]
 		| undefined {
-		if (pi && typeof pi === "object" && "events" in pi)
-			return (pi as unknown as Record<string, unknown>)
-				.events as Parameters<typeof registerPiCrewRpc>[0];
+		if (pi && typeof pi === "object" && "events" in pi) {
+			// pi.events may not be typed in the original pi type, so cast through unknown
+			const events = (pi as { events?: Parameters<typeof registerPiCrewRpc>[0] }).events;
+			return events;
+		}
 		return undefined;
 	}
 	rpcHandle = registerPiCrewRpc(getPiEvents(), () => currentCtx);
@@ -1499,7 +1501,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			// Health notifications: only warn about genuinely running runs
 			// Filter to only current session's runs to prevent cross-session notification leakage
 			const currentSessionGen = sessionGeneration;
-			const currentSessionId = currentCtx ? (currentCtx as unknown as Record<string, unknown>).sessionId as string | undefined : undefined;
+			const currentSessionId = currentCtx ? (currentCtx as { sessionId?: string }).sessionId : undefined;
 			const sessionManifests = manifests.filter(
 				(run) =>
 					!run.ownerSessionId ||
@@ -1759,19 +1761,13 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	// AGENTS.md requires confirm=true for management deletes.
 	pi.on("tool_call", async (event, ctx) => {
 		if (event.toolName !== "team") return;
-		const input = (event as { input?: Record<string, unknown> }).input;
-		if (!input) return;
-		const action =
-			typeof input.action === "string" ? input.action : undefined;
-		const destructiveActions = new Set([
-			"delete",
-			"forget",
-			"prune",
-			"cleanup",
-		]);
+		const rawInput = event.input;
+		if (!rawInput || typeof rawInput !== "object") return;
+		const input = rawInput as { action?: unknown; confirm?: unknown; force?: unknown };
+		const action = typeof input.action === "string" ? input.action : undefined;
+		const destructiveActions = new Set(["delete", "forget", "prune", "cleanup"]);
 		if (!action || !destructiveActions.has(action)) return;
-		const forceBypassesReferenceChecks =
-			action === "delete" && input.force === true;
+		const forceBypassesReferenceChecks = action === "delete" && input.force === true;
 		if (input.confirm === true || forceBypassesReferenceChecks) return;
 		return {
 			block: true,

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

@@ -56,7 +56,7 @@ export function registerSubagentTools(pi: ExtensionAPI, subagentManager: Subagen
 		async execute(_id, params, signal, onUpdate, ctx) {
 			// Diagnostic: detect pre-aborted signal before spawn
 			if (signal?.aborted) {
-				logInternalError("subagent-tools.pre-aborted-signal", undefined, `params=${JSON.stringify(params).slice(0, 200)}`);
+				logInternalError("subagent-tools.pre-aborted-signal", undefined, `aborted=true paramsKeys=${Object.keys(params as object).join(",")}`);
 				return subagentToolResult("Agent tool signal was already aborted before execution started. This usually means Pi cancelled the tool call before it ran.", { action: "agent", status: "error" }, true);
 			}
 			const currentRole = currentCrewRole();

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

@@ -0,0 +1,201 @@
+/**
+ * Anchor commands for team tool.
+ * Provides set/clear/status commands for anchor points.
+ */
+
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { result, type TeamContext } from "./context.ts";
+import {
+	AnchorManager,
+	createAnchorManager,
+	AnchorNotFoundError,
+	NoHandoffsError,
+} from "../../runtime/anchor-manager.ts";
+import type { HandoffSummary } from "../../runtime/handoff-manager.ts";
+
+// Global anchor manager instance for CLI usage
+let globalAnchorManager: AnchorManager | null = null;
+
+function getAnchorManager(): AnchorManager {
+	if (!globalAnchorManager) {
+		globalAnchorManager = createAnchorManager();
+	}
+	return globalAnchorManager;
+}
+
+/**
+ * Get the session ID from context or generate a default.
+ */
+function getSessionId(ctx: TeamContext): string {
+	return ctx.sessionId ?? "default";
+}
+
+export function handleAnchorSet(
+	params: TeamToolParamsValue,
+	ctx: TeamContext,
+): PiTeamsToolResult {
+	const manager = getAnchorManager();
+	const sessionId = getSessionId(ctx);
+	const cfg = params.config ?? {};
+
+	// Parse context from config
+	const context: Record<string, unknown> = {};
+	if (cfg.context && typeof cfg.context === "object") {
+		Object.assign(context, cfg.context as Record<string, unknown>);
+	}
+	if (cfg.key) {
+		// Single key shorthand
+		context.key = cfg.key;
+	}
+
+	const anchorId = manager.setAnchor(sessionId, context);
+
+	return result(
+		[
+			`Anchor set successfully.`,
+			`Anchor ID: ${anchorId}`,
+			`Session: ${sessionId}`,
+			context && Object.keys(context).length > 0
+				? `Context: ${JSON.stringify(context)}`
+				: "",
+		].filter(Boolean).join("\n"),
+		{ action: "anchor", status: "ok" },
+	);
+}
+
+export function handleAnchorClear(
+	params: TeamToolParamsValue,
+	ctx: TeamContext,
+): PiTeamsToolResult {
+	const manager = getAnchorManager();
+	const sessionId = getSessionId(ctx);
+	const cfg = params.config ?? {};
+
+	let anchorId: string | undefined;
+	if (cfg.anchorId) {
+		anchorId = cfg.anchorId as string;
+	}
+
+	let accumulated: HandoffSummary;
+	try {
+		if (anchorId) {
+			accumulated = manager.clearAnchor(anchorId);
+		} else {
+			const anchorResult = manager.clearAnchorBySession(sessionId);
+			if (!anchorResult) {
+				return result(
+					"No anchor found for this session.",
+					{ action: "anchor", status: "error" },
+					true,
+				);
+			}
+			accumulated = anchorResult;
+		}
+	} catch (error) {
+		if (error instanceof AnchorNotFoundError) {
+			return result(
+				`Anchor not found: ${error.anchorId}`,
+				{ action: "anchor", status: "error" },
+				true,
+			);
+		}
+		if (error instanceof NoHandoffsError) {
+			return result(
+				"No handoffs have been accumulated to this anchor.",
+				{ action: "anchor", status: "error" },
+				true,
+			);
+		}
+		throw error;
+	}
+
+	return result(
+		[
+			`Anchor cleared successfully.`,
+			`Accumulated summary:`,
+			``,
+			`Task: ${accumulated.task}`,
+			`Outcome: ${accumulated.outcome}`,
+			``,
+			`Metrics:`,
+			`  Tokens: ${accumulated.metrics.tokensUsed}`,
+			`  Duration: ${Math.round(accumulated.metrics.duration / 1000)}s`,
+			`  Iterations: ${accumulated.metrics.iterations}`,
+			`  Tools: ${accumulated.metrics.toolsUsed.join(", ") || "(none)"}`,
+			``,
+			`Files created: ${accumulated.filesCreated.join(", ") || "(none)"}`,
+			`Files modified: ${accumulated.filesModified.join(", ") || "(none)"}`,
+			`Files deleted: ${accumulated.filesDeleted.join(", ") || "(none)"}`,
+			accumulated.decisions.length > 0
+				? `\nDecisions:\n${accumulated.decisions.map((d: { rationale: string; outcome: string }) => `  - ${d.rationale}: ${d.outcome}`).join("\n")}`
+				: "",
+			accumulated.blockers.length > 0
+				? `\nBlockers: ${accumulated.blockers.join("; ")}`
+				: "",
+			accumulated.nextSteps.length > 0
+				? `\nNext steps: ${accumulated.nextSteps.join("; ")}`
+				: "",
+		].filter(Boolean).join("\n"),
+		{ action: "anchor", status: "ok" },
+	);
+}
+
+export function handleAnchorStatus(
+	params: TeamToolParamsValue,
+	ctx: TeamContext,
+): PiTeamsToolResult {
+	const manager = getAnchorManager();
+	const sessionId = getSessionId(ctx);
+	const cfg = params.config ?? {};
+
+	let anchorId: string | undefined;
+	if (cfg.anchorId) {
+		anchorId = cfg.anchorId as string;
+	}
+
+	let status;
+	if (anchorId) {
+		status = manager.getAnchorStatus(anchorId);
+	} else {
+		status = manager.getAnchorStatusBySession(sessionId);
+	}
+
+	if (!status) {
+		return result(
+			anchorId
+				? `No anchor found with ID: ${anchorId}`
+				: `No anchor set for session: ${sessionId}`,
+			{ action: "anchor", status: "ok" },
+		);
+	}
+
+	return result(
+		[
+			`Anchor Status`,
+			`─────────────`,
+			`Anchor ID: ${status.anchorId}`,
+			`Session ID: ${status.sessionId}`,
+			`Created: ${new Date(status.createdAt).toISOString()}`,
+			`Handoffs: ${status.handoffCount}`,
+			`Total tokens: ${status.totalTokens}`,
+			`Total duration: ${Math.round(status.totalDuration / 1000)}s`,
+			status.context && Object.keys(status.context).length > 0
+				? `\nContext: ${JSON.stringify(status.context, null, 2)}`
+				: "",
+		].filter(Boolean).join("\n"),
+		{ action: "anchor", status: "ok" },
+	);
+}
+
+export function handleAnchorAccumulate(
+	params: TeamToolParamsValue,
+	ctx: TeamContext,
+): PiTeamsToolResult {
+	// This would be used to manually accumulate a handoff to the current anchor
+	// In practice, this is called internally by HandoffManager when anchor is set
+	return result(
+		"Use handleAnchorSet to set an anchor, then run tasks normally. Handoffs will be accumulated automatically.",
+		{ action: "anchor", status: "ok" },
+	);
+}

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

@@ -18,6 +18,7 @@ import { readForegroundControlStatus, writeForegroundInterruptRequest } from "..
 import { followUpLiveAgent, getLiveAgent, listActiveLiveAgents, resumeLiveAgent, steerLiveAgent, stopLiveAgent } from "../../subagents/live/manager.ts";
 import { appendLiveAgentControlRequest } from "../../subagents/live/control.ts";
 import { liveControlRealtimeMessage, publishLiveControlRealtime } from "../../subagents/live/realtime.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
 import { buildCapabilityInventory } from "../../runtime/capability-inventory.ts";
 import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
@@ -125,7 +126,7 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 				saveRunTasks(manifest, tasks);
 				appendEvent(manifest.eventsPath, { type: "plan.cancelled", runId: manifest.runId, taskId: approval.planTaskId, message: "Adaptive implementation plan was cancelled.", metadata: { provenance: "api" } });
 				manifest = updateRunStatus(manifest, "cancelled", "Plan approval was cancelled.");
-				void terminateLiveAgentsForRun(manifest.runId, "cancelled", appendEvent, manifest.eventsPath).catch(() => {});
+				void terminateLiveAgentsForRun(manifest.runId, "cancelled", appendEvent, manifest.eventsPath).catch((error) => logInternalError("team-tool.cancel-plan.terminate", error, `runId=${manifest.runId}`));
 				return result(JSON.stringify({ planApproval: manifest.planApproval, cancelledTasks: tasks.filter((task) => task.status === "cancelled").map((task) => task.id) }, null, 2), { action: "api", status: "ok", runId: manifest.runId, artifactsRoot: manifest.artifactsRoot });
 			});
 		} catch (error) {

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

@@ -0,0 +1,154 @@
+/**
+ * Auto-summarize commands for team tool.
+ * Provides on/off/status commands for auto-summarization.
+ */
+
+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;
+
+function getAutoSummarize(): AutoSummarizeService {
+	if (!globalAutoSummarize) {
+		globalAutoSummarize = createAutoSummarizeService();
+	}
+	return globalAutoSummarize;
+}
+
+export function handleAutoSummarizeOn(
+	params: TeamToolParamsValue,
+	ctx: TeamContext,
+): PiTeamsToolResult {
+	const service = getAutoSummarize();
+	const cfg = params.config ?? {};
+
+	// Apply config updates if provided
+	if (cfg.threshold !== undefined) {
+		const threshold = typeof cfg.threshold === "number" ? cfg.threshold : parseInt(String(cfg.threshold), 10);
+		if (!isNaN(threshold) && threshold >= 0) {
+			service.setThreshold(threshold);
+		}
+	}
+
+	if (cfg.minTools !== undefined) {
+		const minTools = typeof cfg.minTools === "number" ? cfg.minTools : parseInt(String(cfg.minTools), 10);
+		if (!isNaN(minTools) && minTools >= 0) {
+			service.setMinToolsUsed(minTools);
+		}
+	}
+
+	const previousState = service.isEnabled();
+	service.enable();
+	const config = service.getConfig();
+
+	return result(
+		[
+			`Auto-summarize enabled.`,
+			``,
+			`Configuration:`,
+			`  Token threshold: ${config.threshold}`,
+			`  Min tools: ${config.minToolsUsed}`,
+			`  Collapse context: ${config.collapseContext}`,
+		].join("\n"),
+		{ action: "auto-summarize", status: "ok" },
+	);
+}
+
+export function handleAutoSummarizeOff(
+	params: TeamToolParamsValue,
+	ctx: TeamContext,
+): PiTeamsToolResult {
+	const service = getAutoSummarize();
+
+	service.disable();
+
+	return result(
+		"Auto-summarize disabled.",
+		{ action: "auto-summarize", status: "ok" },
+	);
+}
+
+export function handleAutoSummarizeStatus(
+	params: TeamToolParamsValue,
+	ctx: TeamContext,
+): PiTeamsToolResult {
+	const service = getAutoSummarize();
+	const config = service.getConfig();
+	const isEnabled = service.isEnabled();
+
+	return result(
+		[
+			`Auto-summarize Status`,
+			`──────────────────`,
+			`Enabled: ${isEnabled ? "Yes" : "No"}`,
+			``,
+			`Configuration:`,
+			`  Token threshold: ${config.threshold} (default: ${DEFAULT_AUTO_SUMMARIZE_CONFIG.threshold})`,
+			`  Min tools used: ${config.minToolsUsed} (default: ${DEFAULT_AUTO_SUMMARIZE_CONFIG.minToolsUsed})`,
+			`  Collapse context: ${config.collapseContext ? "Yes" : "No"} (default: ${DEFAULT_AUTO_SUMMARIZE_CONFIG.collapseContext ? "Yes" : "No"})`,
+			``,
+			`Triggers:`,
+			`  - Token count >= ${config.threshold}`,
+			`  - Tool count >= ${config.minToolsUsed}`,
+			`  - High token-to-tool ratio (>1000 tokens/tool with 3+ tools)`,
+		].join("\n"),
+		{ action: "auto-summarize", status: "ok" },
+	);
+}
+
+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 } = {};
+
+	if (cfg.threshold !== undefined) {
+		const threshold = typeof cfg.threshold === "number" ? cfg.threshold : parseInt(String(cfg.threshold), 10);
+		if (!isNaN(threshold) && threshold >= 0) {
+			updates.threshold = threshold;
+		}
+	}
+
+	if (cfg.minTools !== undefined) {
+		const minTools = typeof cfg.minTools === "number" ? cfg.minTools : parseInt(String(cfg.minTools), 10);
+		if (!isNaN(minTools) && minTools >= 0) {
+			updates.minTools = minTools;
+		}
+	}
+
+	if (cfg.collapseContext !== undefined) {
+		updates.collapseContext = Boolean(cfg.collapseContext);
+	}
+
+	if (Object.keys(updates).length > 0) {
+		service.updateConfig(updates);
+	}
+
+	const config = service.getConfig();
+
+	return result(
+		[
+			`Auto-summarize configuration updated.`,
+			``,
+			`Current settings:`,
+			`  Token threshold: ${config.threshold}`,
+			`  Min tools used: ${config.minToolsUsed}`,
+			`  Collapse context: ${config.collapseContext ? "Yes" : "No"}`,
+			`  Enabled: ${config.enabled ? "Yes" : "No"}`,
+		].join("\n"),
+		{ action: "auto-summarize", status: "ok" },
+	);
+}
+// Re-export for team-tool.ts
+export { createAutoSummarizeService } from "../../runtime/auto-summarize.ts";

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

@@ -8,10 +8,12 @@ import { registerActiveRun, unregisterActiveRun } from "../../state/active-run-r
 import { createRunManifest, loadRunManifestById, updateRunStatus } from "../../state/state-store.ts";
 import { atomicWriteJson } from "../../state/atomic-write.ts";
 import { validateWorkflowForTeam } from "../../workflows/validate-workflow.ts";
+import { PipelineRunner, type PipelineWorkflow, type PipelineStage } from "../../runtime/pipeline-runner.ts";
 // Heavy runtime — lazy-loaded to avoid 1.4s import cost at extension registration.
 import type { executeTeamRun as ExecuteTeamRunFn } from "../../runtime/team-runner.ts";
 // eslint-disable-next-line @typescript-eslint/no-unused-vars -- type-only import for TS inference
 const _typeCheck: typeof ExecuteTeamRunFn = null as never as typeof ExecuteTeamRunFn;
+import { logInternalError } from "../../utils/internal-error.ts";
 let _cachedExecuteTeamRun: typeof ExecuteTeamRunFn | undefined;
 async function executeTeamRun(...args: Parameters<typeof ExecuteTeamRunFn>): Promise<Awaited<ReturnType<typeof ExecuteTeamRunFn>>> {
 	if (!_cachedExecuteTeamRun) {
@@ -110,6 +112,39 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	if (!baseWorkflow) return result(`Workflow '${workflowName}' not found.`, { action: "run", status: "error" }, true);
 	const workflow = directAgent ? baseWorkflow : expandParallelResearchWorkflow(baseWorkflow, ctx.cwd);
 
+	// Check if this is a pipeline workflow - special handling for multi-stage execution
+	const isPipelineWorkflow = workflowName === "pipeline" && !directAgent;
+	if (isPipelineWorkflow) {
+		// For pipeline workflows, use PipelineRunner for execution
+		const pipelineRunner = new PipelineRunner();
+		const pipelineWorkflow: PipelineWorkflow = {
+			name: workflow.name,
+			description: workflow.description,
+			goal,
+			stages: workflow.steps.map((step) => ({
+				name: step.id,
+				team: step.role,
+				inputs: step.task,
+				usePreviousResults: step.dependsOn && step.dependsOn.length > 0,
+			})),
+			stopOnError: true,
+			defaultMaxConcurrency: workflow.maxConcurrency ?? 5,
+		};
+
+		// For now, show pipeline workflow info - full integration would require
+		// connecting PipelineRunner to the actual team execution system
+		const stageInfo = pipelineWorkflow.stages.map((s) => `- ${s.name} (${s.team})`).join("\n");
+		return result([
+			`Pipeline workflow: ${workflow.name}`,
+			`Goal: ${goal}`,
+			`Stages (${pipelineWorkflow.stages.length}):`,
+			stageInfo,
+			"",
+			"Pipeline execution is available via the PipelineRunner API.",
+			"Full CLI integration requires connecting to the team execution system.",
+		].join("\n"), { action: "run", status: "ok" }, false);
+	}
+
 	const validationErrors = validateWorkflowForTeam(workflow, team);
 	if (validationErrors.length > 0) {
 		return result([`Workflow '${workflow.name}' is not valid for team '${team.name}':`, ...validationErrors.map((error) => `- ${error}`)].join("\n"), { action: "run", status: "error" }, true);
@@ -140,7 +175,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const runtimeResolution = runtimeResolutionState(runtime);
 	const executionManifest = { ...updatedManifest, runtimeResolution, runConfig: executedConfig, updatedAt: new Date().toISOString() };
 	atomicWriteJson(paths.manifestPath, executionManifest);
-	appendEventAsync(executionManifest.eventsPath, { type: "runtime.resolved", runId: executionManifest.runId, message: `Runtime resolved: ${runtime.kind} safety=${runtime.safety}`, data: { runtimeResolution } }).catch(() => {});
+	appendEventAsync(executionManifest.eventsPath, { type: "runtime.resolved", runId: executionManifest.runId, message: `Runtime resolved: ${runtime.kind} safety=${runtime.safety}`, data: { runtimeResolution } }).catch((error) => logInternalError("team-tool.run.resolved", error, `runId=${executionManifest.runId}`));
 	const runAsync = params.async ?? executedConfig.asyncByDefault ?? false;
 	let effectiveRuntime = runtime;
 	if (runAsync && runtime.kind === "live-session") {
@@ -150,7 +185,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const effectiveManifest = effectiveRuntime !== runtime ? { ...executionManifest, runtimeResolution: effectiveRuntimeResolution, updatedAt: new Date().toISOString() } : executionManifest;
 	if (effectiveRuntime !== runtime) {
 		atomicWriteJson(paths.manifestPath, effectiveManifest);
-		appendEventAsync(effectiveManifest.eventsPath, { type: "runtime.resolved", runId: effectiveManifest.runId, message: `Runtime overridden: child-process (async fallback from live-session)`, data: { runtimeResolution: effectiveRuntimeResolution } }).catch(() => {});
+		appendEventAsync(effectiveManifest.eventsPath, { type: "runtime.resolved", runId: effectiveManifest.runId, message: `Runtime overridden: child-process (async fallback from live-session)`, data: { runtimeResolution: effectiveRuntimeResolution } }).catch((error) => logInternalError("team-tool.run.override", error, `runId=${effectiveManifest.runId}`));
 	}
 	if (runAsync) {
 		if (effectiveRuntime.safety === "blocked") {

package/src/extension/team-tool.ts

@@ -170,6 +170,8 @@ import { handlePlan } from "./team-tool/plan.ts";
 import { handleOrchestrate } from "./team-tool/orchestrate.ts";
 import { handleRespond } from "./team-tool/respond.ts";
 import { handleStatus } from "./team-tool/status.ts";
+import { handleAnchorSet, handleAnchorClear, handleAnchorStatus, handleAnchorAccumulate } from "./team-tool/anchor.ts";
+import { handleAutoSummarizeOn, handleAutoSummarizeOff, handleAutoSummarizeStatus, handleAutoSummarizeConfig, createAutoSummarizeService } from "./team-tool/auto-summarize.ts";
 
 export { handleApi } from "./team-tool/api.ts";
 export { handleRetry } from "./team-tool/cancel.ts";
@@ -715,7 +717,12 @@ export function handleSteer(
 			true,
 		);
 	if (!task.pendingSteers) task.pendingSteers = [];
-	task.pendingSteers.push(message);
+		// HIGH-04: Cap pendingSteers array to prevent unbounded memory growth
+		const MAX_PENDING_STEERS = 100;
+		if (task.pendingSteers.length >= MAX_PENDING_STEERS) {
+			task.pendingSteers = task.pendingSteers.slice(-(MAX_PENDING_STEERS - 1));
+		}
+		task.pendingSteers.push(message);
 	saveRunTasks(loaded.manifest, loaded.tasks);
 	appendEvent(loaded.manifest.eventsPath, {
 		type: "task.steer_queued",
@@ -871,7 +878,7 @@ export async function handleTeamTool(
 	ctx: TeamContext,
 ): Promise<PiTeamsToolResult> {
 	const action = params.action ?? "list";
-	switch (action) {
+	switch (action as string) {
 		case "list":
 			return handleList(params, ctx);
 		case "get":
@@ -1157,6 +1164,41 @@ export async function handleTeamTool(
 			return handleSchedule(params, ctx);
 		case "scheduled":
 			return handleListScheduled(params, ctx);
+		case "anchor": {
+			const subAction = typeof params.config?.subAction === "string" ? params.config.subAction : "status";
+			switch (subAction) {
+				case "set":
+					return handleAnchorSet(params, ctx);
+				case "clear":
+					return handleAnchorClear(params, ctx);
+				case "accumulate":
+					return handleAnchorAccumulate(params, ctx);
+				default:
+					return handleAnchorStatus(params, ctx);
+			}
+		}
+		case "auto-summarize":
+		case "auto_boomerang": {
+			const subAction = typeof params.config?.subAction === "string" ? params.config.subAction : ((params.action as string) === "auto_boomerang" ? "toggle" : "status");
+			switch (subAction) {
+				case "on":
+					return handleAutoSummarizeOn(params, ctx);
+				case "off":
+					return handleAutoSummarizeOff(params, ctx);
+				case "config":
+					return handleAutoSummarizeConfig(params, ctx);
+				case "toggle": {
+					const service = createAutoSummarizeService();
+					service.toggle();
+					return result(
+						`Auto-summarize ${service.isEnabled() ? "enabled" : "disabled"}.`,
+						{ action: "auto-summarize", status: "ok" },
+					);
+				}
+				default:
+					return handleAutoSummarizeStatus(params, ctx);
+			}
+		}
 		case "onboard": {
 			const team = params.team ?? "default";
 			const onboarding = buildTeamOnboarding(team, ctx.cwd);

package/src/hooks/registry.ts

@@ -30,9 +30,7 @@ export async function executeHook(name: HookName, ctx: HookContext): Promise<Hoo
 	// SECURITY: If ctx contains a workspaceId, filter hooks to only those scoped to
 	// this workspace. This prevents globally-registered hooks from operating on runs
 	// they weren't designed for.
-	const scopedHooks = ctx.workspaceId
-		? hooks.filter((h) => !h.workspaceId || h.workspaceId === ctx.workspaceId)
-		: hooks;
+	const scopedHooks = hooks.filter((h) => !h.workspaceId || h.workspaceId === ctx.workspaceId);
 	if (scopedHooks.length === 0) return { hookName: name, outcome: "allow", durationMs: 0 };
 	const start = Date.now();
 	const diagnostics: string[] = [];

package/src/observability/event-bus.ts

@@ -19,13 +19,22 @@ type CrewEventListener = (event: CrewEvent) => void;
 
 class EventBus {
   private listeners = new Map<CrewEventType, Set<CrewEventListener>>();
-  private static instance?: EventBus;
+  private static _instance?: EventBus;
 
   static getInstance(): EventBus {
-    if (!EventBus.instance) {
-      EventBus.instance = new EventBus();
+    if (!EventBus._instance) {
+      EventBus._instance = new EventBus();
     }
-    return EventBus.instance;
+    return EventBus._instance;
+  }
+
+  /**
+   * Dispose of the EventBus instance and clear all listeners.
+   * Resets the singleton so a new instance can be created.
+   */
+  dispose(): void {
+    this.listeners.clear();
+    EventBus._instance = undefined;
   }
 
   emit(event: CrewEvent): void {

package/src/observability/event-to-metric.ts

@@ -32,7 +32,6 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 	const retryAttemptCount = registry.counter("crew.task.retry_attempt_total", "Retry attempts by run and task");
 	const deadletterCount = registry.counter("crew.task.deadletter_total", "Deadletter triggers by reason");
 	const overflowCount = registry.counter("crew.task.overflow_phase_total", "Overflow recovery phase transitions");
-	const waitingCount = registry.counter("crew.task.waiting_total", "Tasks entering waiting state");
 	const supervisorContactCount = registry.counter("crew.task.supervisor_contact_total", "Supervisor contact requests by reason");
 	registry.gauge("crew.heartbeat.staleness_ms", "Heartbeat elapsed since last seen, milliseconds");
 	const runDuration = registry.histogram("crew.run.duration_ms", "Run end-to-end duration, milliseconds", [1000, 5000, 15000, 30000, 60000, 300000, 600000, 1800000]);
@@ -50,7 +49,6 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 		["crew.task.retry_attempt", (data) => { const item = recordValue(data); taskCount.inc({ status: "retry" }); retryAttemptCount.inc({ runId: stringValue(item.runId, "unknown"), taskId: stringValue(item.taskId, "unknown") }); }],
 		["crew.task.deadletter", (data) => { const item = recordValue(data); deadletterCount.inc({ reason: stringValue(item.reason, "unknown") }); }],
 		["crew.task.overflow", (data) => { const item = recordValue(data); overflowCount.inc({ phase: stringValue(item.phase, "unknown"), previous_phase: stringValue(item.previousPhase, "none") }); }],
-		["task.waiting", (data) => { const item = recordValue(data); waitingCount.inc({ taskId: stringValue(item.taskId, "unknown"), runId: stringValue(item.runId, "unknown") }); }],
 		["supervisor.contact", (data) => { const item = recordValue(data); supervisorContactCount.inc({ reason: stringValue(item.reason, "unknown"), taskId: stringValue(item.taskId, "unknown") }); }],
 		["crew.subagent.completed", (data) => { const item = recordValue(data); subagentCount.inc({ status: stringValue(item.status, "completed") }); }],
 		["crew.subagent.failed", () => subagentCount.inc({ status: "failed" })],