pi-crew 0.5.2 → 0.5.6

package/src/config/role-tools.ts

@@ -0,0 +1,82 @@
+/**
+ * Role-based tool configurations for pi-crew agents.
+ * Uses the excludeTools option from pi v0.77.0.
+ */
+
+export interface RoleToolConfig {
+	/** Explicit list of tools to use (if undefined, use all default tools) */
+	tools?: string[];
+	/** Tools to exclude from the default set */
+	excludeTools?: string[];
+}
+
+export const ROLE_TOOL_CONFIGS: Record<string, RoleToolConfig> = {
+	// Explorer - Read-only, no write or execute
+	explorer: {
+		tools: ["read", "grep", "find", "ls", "glob"],
+		excludeTools: ["edit", "write", "bash", "web"],
+	},
+
+	// Analyst - Read and analyze, limited execution
+	analyst: {
+		excludeTools: ["edit", "write", "ask_question"],
+	},
+
+	// Planner - Planning and documentation
+	planner: {
+		excludeTools: ["ask_question"],
+	},
+
+	// Executor - Full access (default)
+	executor: {
+		// No restrictions - full tool access
+	},
+
+	// Reviewer - Read and review, no write
+	reviewer: {
+		tools: ["read", "grep", "find", "ls", "glob", "bash"],
+		excludeTools: ["edit", "write"],
+	},
+
+	// Writer - Documentation focused
+	writer: {
+		tools: ["read", "edit", "write", "ls"],
+		excludeTools: ["bash", "web", "ask_question"],
+	},
+
+	// Security Reviewer - Strict restrictions
+	security_reviewer: {
+		tools: ["read", "grep", "find"],
+		excludeTools: ["edit", "write", "bash", "web", "ask_question"],
+	},
+
+	// Test Engineer - Can write tests
+	test_engineer: {
+		tools: ["read", "edit", "write", "bash", "ls"],
+		excludeTools: ["web"],
+	},
+};
+
+/**
+ * Get tool configuration for a specific role.
+ */
+export function getToolConfig(role: string): RoleToolConfig {
+	return ROLE_TOOL_CONFIGS[role] ?? {};
+}
+
+/**
+ * Check if a role has any tool restrictions.
+ */
+export function hasToolRestrictions(role: string): boolean {
+	const config = getToolConfig(role);
+	return (config.tools !== undefined) || (config.excludeTools !== undefined);
+}
+
+/**
+ * Get all restricted roles.
+ */
+export function getRestrictedRoles(): string[] {
+	return Object.entries(ROLE_TOOL_CONFIGS)
+		.filter(([, config]) => (config.tools !== undefined) || (config.excludeTools !== undefined))
+		.map(([role]) => role);
+}

package/src/config/suggestions.ts

@@ -1,9 +1,17 @@
 /**
  * Fuzzy config key suggestions — Levenshtein-based typo correction for pi-crew config keys.
+ *
+ * SECURITY NOTE: The levenshtein() function processes user-supplied input and compares
+ * against a known list. While the timing variance across edit distances is minimal
+ * and the input is typically config key names (not secrets), there is a theoretical
+ * timing attack risk if an attacker could measure response times for different inputs.
+ * Risk level: LOW — mitigated by the small alphabet (config key names only) and
+ * the fixed-size DP array used in this implementation.
  */
 
 /**
  * Classic Levenshtein edit distance between two strings.
+ * See security note above regarding timing attack considerations.
  */
 export function levenshtein(a: string, b: string): number {
 	const la = a.length;

package/src/config/types.ts

@@ -19,6 +19,8 @@ export interface PiTeamsAutonomousConfig {
 	preferAsyncForLongTasks?: boolean;
 	allowWorktreeSuggestion?: boolean;
 	magicKeywords?: Record<string, string[]>;
+	/** Mark certain bash commands as excludeFromContext to reduce context tokens. Default: false */
+	excludeContextBash?: boolean;
 }
 
 export interface CrewLimitsConfig {
@@ -66,6 +68,8 @@ export interface CrewRuntimeConfig {
 		/** Default runtime for roles not in isolatedRoles. Default: "live-session" (uses live-session). */
 		defaultRuntime?: "live-session" | "child-process";
 	};
+	/** Mark certain bash commands as excludeFromContext to reduce context tokens. Default: false */
+	excludeContextBash?: boolean;
 }
 
 export interface CrewControlConfig {

package/src/extension/async-notifier.ts

@@ -12,6 +12,7 @@ export interface AsyncNotifierState {
 	interval?: ReturnType<typeof setInterval>;
 	generation?: number;
 	lastStoppedAtMs?: number;
+	lastListRunsMs?: number;
 }
 
 export interface AsyncNotifierOptions {
@@ -80,6 +81,8 @@ export function markDeadAsyncRunIfNeeded(run: TeamRunManifest, now = Date.now(),
 	});
 }
 
+const LIST_RUNS_DEBOUNCE_MS = 30_000;
+
 export function startAsyncRunNotifier(ctx: ExtensionContext, state: AsyncNotifierState, intervalMs = 5000, options: AsyncNotifierOptions = {}): void {
 	if (state.interval) clearInterval(state.interval);
 	const generation = options.generation ?? ((state.generation ?? 0) + 1);
@@ -93,10 +96,16 @@ export function startAsyncRunNotifier(ctx: ExtensionContext, state: AsyncNotifie
 		const updatedAtMs = timeMs(run.updatedAt) ?? 0;
 		if (isFinished(run.status) && updatedAtMs < staleBeforeMs) state.seenFinishedRunIds.add(run.runId);
 	}
+	let cachedRuns: TeamRunManifest[] | undefined;
 	state.interval = setInterval(() => {
 		try {
 			if (options.isCurrent && !options.isCurrent(generation)) return;
-			for (const run of listRuns(ctx.cwd).slice(0, 20)) {
+			const nowMs = Date.now();
+			if (cachedRuns === undefined || nowMs - (state.lastListRunsMs ?? 0) > LIST_RUNS_DEBOUNCE_MS) {
+				cachedRuns = listRuns(ctx.cwd).slice(0, 20);
+				state.lastListRunsMs = nowMs;
+			}
+			for (const run of cachedRuns) {
 				const current = markDeadAsyncRunIfNeeded(run) ?? run;
 				if (!isFinished(current.status) || state.seenFinishedRunIds.has(current.runId)) continue;
 				state.seenFinishedRunIds.add(current.runId);

package/src/extension/crew-cleanup.ts

@@ -0,0 +1,114 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+// NOTE: globalProgressTracker import kept for documentation but not directly used
+// since we don't have agent IDs to untrack. Actual progress clearing should be
+// handled by the progress tracker itself on shutdown.
+// import { globalProgressTracker } from "../runtime/progress-tracker.ts";
+
+/**
+ * Registers cleanup handlers for graceful shutdown.
+ * Handles session_shutdown and SIGTERM/SIGHUP signals.
+ */
+
+interface ChildProcessInfo {
+	pid: number;
+	runId: string;
+	agentId: string;
+	startedAt: number;
+}
+
+class ChildProcessRegistry {
+	private processes = new Map<number, ChildProcessInfo>();
+
+	register(pid: number, runId: string, agentId: string): void {
+		this.processes.set(pid, { pid, runId, agentId, startedAt: Date.now() });
+	}
+
+	unregister(pid: number): void {
+		this.processes.delete(pid);
+	}
+
+	getAllPids(): number[] {
+		return Array.from(this.processes.keys());
+	}
+
+	getInfo(pid: number): ChildProcessInfo | undefined {
+		return this.processes.get(pid);
+	}
+
+	clear(): void {
+		this.processes.clear();
+	}
+}
+
+export const childProcessRegistry = new ChildProcessRegistry();
+
+export function registerCleanupHandler(pi: ExtensionAPI): void {
+	// Handle session_shutdown event
+	pi.on("session_shutdown", async () => {
+		console.log("[pi-crew] Session shutdown - cleaning up resources");
+
+		try {
+			// Kill all child-pi processes
+			await cleanupChildProcesses();
+
+			// Cleanup temp directories
+			await cleanupTempDirectories();
+
+			console.log("[pi-crew] Cleanup complete");
+		} catch (error) {
+			console.error("[pi-crew] Cleanup error:", error);
+		}
+	});
+
+	// Handle SIGTERM/SIGHUP signals
+	const handleSignal = async (signal: string): Promise<void> => {
+		console.log(`[pi-crew] Received ${signal} - starting cleanup`);
+		await cleanupChildProcesses();
+	};
+
+	process.on("SIGTERM", () => { void handleSignal("SIGTERM"); });
+	process.on("SIGHUP", () => { void handleSignal("SIGHUP"); });
+}
+
+async function cleanupChildProcesses(): Promise<void> {
+	const pids = childProcessRegistry.getAllPids();
+
+	for (const pid of pids) {
+		try {
+			process.kill(pid, "SIGTERM");
+			console.log(`[pi-crew] Sent SIGTERM to child process ${pid}`);
+		} catch (error: unknown) {
+			// Process may already be dead or not exist
+			const err = error as NodeJS.ErrnoException;
+			if (err.code !== "ESRCH" && err.code !== "ENOENT") {
+				console.error(`[pi-crew] Error killing process ${pid}:`, err.message);
+			}
+		}
+		childProcessRegistry.unregister(pid);
+	}
+
+	// Clear progress tracker
+	// Note: Can't call untrack on all because we don't track agent IDs here
+	// The progress tracker should clear itself on shutdown via session_dispose
+}
+
+async function cleanupTempDirectories(): Promise<void> {
+	// NOTE: getTempDir is not available in paths.ts.
+	// For now, just log that cleanup is pending.
+	// Actual temp directory cleanup should be implemented by the run-graph
+	// or the specific code that creates temporary workspaces.
+	try {
+		console.log(`[pi-crew] Temp directory cleanup deferred to run-graph`);
+	} catch (error) {
+		console.error("[pi-crew] Temp cleanup error:", error);
+	}
+}
+
+// Export for child-pi.ts to register processes
+export function registerChildProcess(pid: number, runId: string, agentId: string): void {
+	childProcessRegistry.register(pid, runId, agentId);
+}
+
+export function unregisterChildProcess(pid: number): void {
+	childProcessRegistry.unregister(pid);
+}

package/src/extension/cross-extension-rpc.ts

@@ -1,5 +1,6 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
+import { resolveContainedPath } from "../utils/safe-paths.ts";
 // Lazy-loaded to avoid pulling team-tool.ts (and its entire runtime chain) into module load.
 import type { handleTeamTool as HandleTeamToolFn } from "./team-tool.ts";
 let _cachedHandleTeamTool: typeof HandleTeamToolFn | undefined;
@@ -69,7 +70,6 @@ function isAllowedRpcRunParams(params: TeamToolParamsValue): { ok: boolean; erro
 	// SECURITY: Validate cwd is within the project directory if provided.
 	if (params.cwd && typeof params.cwd === "string") {
 		try {
-			const { resolveContainedPath } = require("../utils/safe-paths.ts");
 			resolveContainedPath(params.cwd, ".");
 		} catch {
 			return { ok: false, error: "RPC run config.cwd must be within the project directory" };

package/src/extension/notification-router.ts

@@ -55,12 +55,29 @@ export class NotificationRouter {
 	private readonly seen = new Map<string, number>();
 	private batch: NotificationDescriptor[] = [];
 	private timer: ReturnType<typeof setTimeout> | undefined;
+	private seenCleanupCounter = 0;
+	private static readonly SEEN_MAP_MAX_SIZE = 10000;
 
 	constructor(opts: NotificationRouterOptions = {}, deliver: (notification: NotificationDescriptor) => void) {
 		this.opts = opts;
 		this.deliver = deliver;
 	}
 
+	/**
+	 * Evict oldest entries from seen Map if it exceeds MAX_SIZE.
+	 * This prevents unbounded memory growth from notifications without TTL.
+	 */
+	private evictSeenIfNeeded(): void {
+		if (this.seen.size > NotificationRouter.SEEN_MAP_MAX_SIZE) {
+			// Sort by timestamp (oldest first) and keep only half
+			const entries = [...this.seen.entries()].sort((a, b) => a[1] - b[1]);
+			const keepCount = Math.floor(NotificationRouter.SEEN_MAP_MAX_SIZE / 2);
+			for (const [key] of entries.slice(0, entries.length - keepCount)) {
+				this.seen.delete(key);
+			}
+		}
+	}
+
 	enqueue(notification: NotificationDescriptor): boolean {
 		const now = this.opts.now?.() ?? Date.now();
 		const withTime = { ...notification, timestamp: notification.timestamp ?? now };
@@ -77,6 +94,7 @@ export class NotificationRouter {
 		const previous = this.seen.get(key);
 		if (previous !== undefined && now - previous < dedupWindow) return false;
 		this.seen.set(key, now);
+		this.evictSeenIfNeeded();
 		const batchWindow = this.opts.batchWindowMs ?? 0;
 		if (batchWindow <= 0) {
 			this.deliver(withTime);

package/src/extension/register.ts

@@ -17,6 +17,7 @@ import {
 	stopAsyncRunNotifier,
 } from "./async-notifier.ts";
 import { registerAutonomousPolicy } from "./autonomous-policy.ts";
+import { registerCleanupHandler } from "./crew-cleanup.ts";
 import { notifyActiveRuns } from "./session-summary.ts";
 
 let _cachedLiveRunSidebar: typeof LiveRunSidebarType | undefined;
@@ -703,7 +704,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 				widgetState,
 				loadConfig(currentCtx.cwd).config.ui,
 			);
-		clearPiCrewPowerbar(pi.events, currentCtx);
+		clearPiCrewPowerbar(pi.events);
 	};
 	const openLiveSidebar = (ctx: ExtensionContext, runId: string): void => {
 		const uiConfig = loadConfig(ctx.cwd).config.ui;
@@ -859,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) {
@@ -942,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);
@@ -1084,7 +1087,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			widgetState,
 			currentCtx ? loadConfig(currentCtx.cwd).config.ui : undefined,
 		);
-		clearPiCrewPowerbar(pi.events, currentCtx);
+		clearPiCrewPowerbar(pi.events);
 		disposePowerbarCoalescer();
 		heartbeatWatcher?.dispose();
 		if (autoRepairTimer) {
@@ -1496,8 +1499,17 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 				manifests,
 			);
 			// 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 { sessionId?: string }).sessionId : undefined;
+			const sessionManifests = manifests.filter(
+				(run) =>
+					!run.ownerSessionId ||
+					run.ownerSessionId === currentSessionId ||
+					(run as unknown as Record<string, unknown>).ownerSessionGeneration === currentSessionGen,
+			);
 			const now = Date.now();
-			for (const run of manifests) {
+			for (const run of sessionManifests) {
 				if (run.status !== "running") continue;
 				try {
 					const snapshot = snapshotCache.get(run.runId);
@@ -1749,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,
@@ -1792,6 +1798,8 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	});
 	time("register.tools");
 
+	registerCleanupHandler(pi);
+
 	registerTeamCommands(pi, {
 		startForegroundRun,
 		abortForegroundRun,

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) {