pi-crew 0.1.30 → 0.1.32

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

@@ -1,44 +1,61 @@
-import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
-import { loadConfig } from "../../config/config.ts";
-import { TeamToolParams, type TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import type { CrewWidgetState } from "../../ui/crew-widget.ts";
-import { updateCrewWidget } from "../../ui/crew-widget.ts";
-import { updatePiCrewPowerbar } from "../../ui/powerbar-publisher.ts";
-import type { createManifestCache } from "../../runtime/manifest-cache.ts";
-import { handleTeamTool } from "../team-tool.ts";
-
-export interface RegisterTeamToolDeps {
-	foregroundControllers: Set<AbortController>;
-	startForegroundRun: (ctx: ExtensionContext, runner: (signal?: AbortSignal) => Promise<void>, runId?: string) => void;
-	openLiveSidebar: (ctx: ExtensionContext, runId: string) => void;
-	getManifestCache: (cwd: string) => ReturnType<typeof createManifestCache>;
-	widgetState: CrewWidgetState;
-}
-
-export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps): void {
-	const tool: ToolDefinition = {
-		name: "team",
-		label: "Team",
-		description: "Coordinate Pi teams. Use proactively for complex multi-file work, planning, implementation, tests, reviews, security audits, research, async/background runs, and worktree-isolated execution. Use action='recommend' when unsure which team/workflow to choose. Destructive actions require explicit user confirmation.",
-		promptSnippet: "Use the team tool proactively for coordinated multi-agent work. If unsure, call { action: 'recommend', goal } first, then run or plan with the suggested team/workflow.",
-		parameters: TeamToolParams as never,
-		async execute(_id, params, signal, _onUpdate, ctx) {
-			const controller = new AbortController();
-			deps.foregroundControllers.add(controller);
-			const abort = (): void => controller.abort();
-			signal?.addEventListener("abort", abort, { once: true });
-			try {
-				const output = await handleTeamTool(params as TeamToolParamsValue, { ...ctx, signal: controller.signal, startForegroundRun: (runner, runId) => deps.startForegroundRun(ctx, runner, runId), onRunStarted: (runId) => deps.openLiveSidebar(ctx, runId) });
-				const config = loadConfig(ctx.cwd).config.ui;
-				const cache = deps.getManifestCache(ctx.cwd);
-				updateCrewWidget(ctx, deps.widgetState, config, cache);
-				updatePiCrewPowerbar(pi.events, ctx.cwd, config, cache);
-				return output;
-			} finally {
-				signal?.removeEventListener("abort", abort);
-				deps.foregroundControllers.delete(controller);
-			}
-		},
-	};
-	pi.registerTool(tool);
-}
+import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { loadConfig } from "../../config/config.ts";
+import { TeamToolParams, type TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import type { CrewWidgetState } from "../../ui/crew-widget.ts";
+import { updateCrewWidget } from "../../ui/crew-widget.ts";
+import { updatePiCrewPowerbar } from "../../ui/powerbar-publisher.ts";
+import type { createManifestCache } from "../../runtime/manifest-cache.ts";
+import { handleTeamTool } from "../team-tool.ts";
+
+export interface RegisterTeamToolDeps {
+	foregroundControllers: Set<AbortController>;
+	startForegroundRun: (ctx: ExtensionContext, runner: (signal?: AbortSignal) => Promise<void>, runId?: string) => void;
+	openLiveSidebar: (ctx: ExtensionContext, runId: string) => void;
+	getManifestCache: (cwd: string) => ReturnType<typeof createManifestCache>;
+	widgetState: CrewWidgetState;
+}
+
+export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps): void {
+	const tool: ToolDefinition = {
+		name: "team",
+		label: "Team",
+		description: "Coordinate Pi teams. Use proactively for complex multi-file work, planning, implementation, tests, reviews, security audits, research, async/background runs, and worktree-isolated execution. Use action='recommend' when unsure which team/workflow to choose. Destructive actions require explicit user confirmation.",
+		promptSnippet: "Use the team tool proactively for coordinated multi-agent work. If unsure, call { action: 'recommend', goal } first, then run or plan with the suggested team/workflow.",
+		parameters: TeamToolParams as never,
+		async execute(_id, params, signal, _onUpdate, ctx) {
+			const controller = new AbortController();
+			deps.foregroundControllers.add(controller);
+			const abort = (): void => controller.abort();
+			signal?.addEventListener("abort", abort, { once: true });
+			try {
+				const resolved = params as TeamToolParamsValue;
+				// Phase 1.5: Auto-set session name from team run context
+				if (resolved.action === "run" && resolved.goal && !pi.getSessionName()) {
+					const runLabel = resolved.team ?? resolved.agent ?? "direct";
+					pi.setSessionName(`pi-crew: ${runLabel}/${resolved.workflow ?? "default"} — ${resolved.goal.slice(0, 60)}`);
+				}
+				const output = await handleTeamTool(resolved, { ...ctx, signal: controller.signal, startForegroundRun: (runner, runId) => deps.startForegroundRun(ctx, runner, runId), onRunStarted: (runId) => deps.openLiveSidebar(ctx, runId) });
+				if (resolved.action === "run") {
+					pi.appendEntry("crew:run-started", {
+						runId: output.details?.runId,
+						team: resolved.team,
+						workflow: resolved.workflow,
+						agent: resolved.agent,
+						goal: resolved.goal,
+						status: output.details?.status,
+						timestamp: Date.now(),
+					});
+				}
+				const config = loadConfig(ctx.cwd).config.ui;
+				const cache = deps.getManifestCache(ctx.cwd);
+				updateCrewWidget(ctx, deps.widgetState, config, cache);
+				updatePiCrewPowerbar(pi.events, ctx.cwd, config, cache);
+				return output;
+			} finally {
+				signal?.removeEventListener("abort", abort);
+				deps.foregroundControllers.delete(controller);
+			}
+		},
+	};
+	pi.registerTool(tool);
+}

package/src/extension/result-watcher.ts

@@ -1,98 +1,98 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "../utils/completion-dedupe.ts";
-import { closeWatcher, watchWithErrorHandler } from "../utils/fs-watch.ts";
-import { createFileCoalescer } from "../utils/file-coalescer.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-
-export interface ResultWatcherEvents {
-	emit(event: string, data: unknown): void;
-}
-
-export interface ResultWatcherHandle {
-	start(): void;
-	prime(): void;
-	stop(): void;
-}
-
-interface ResultWatcherDependencies {
-	watch?: typeof watchWithErrorHandler;
-}
-
-export interface ResultWatcherOptions extends ResultWatcherDependencies {
-	eventName?: string;
-	completionTtlMs?: number;
-}
-
-const RESULT_WATCHER_RESTART_MS = 3000;
-
-function readJson(filePath: string): unknown | undefined {
-	try {
-		return JSON.parse(fs.readFileSync(filePath, "utf-8")) as unknown;
-	} catch (error) {
-		logInternalError("result-watcher.parse", error, `filePath=${filePath}`);
-		return undefined;
-	}
-}
-
-export function createResultWatcher(events: ResultWatcherEvents, resultsDir: string, eventNameOrOptions: string | ResultWatcherOptions = "pi-crew:run-result"): ResultWatcherHandle {
-	const options: ResultWatcherOptions = typeof eventNameOrOptions === "string" ? { eventName: eventNameOrOptions } : eventNameOrOptions;
-	const eventName = options.eventName ?? "pi-crew:run-result";
-	const completionTtlMs = options.completionTtlMs ?? 5 * 60_000;
-	const watch = options.watch ?? watchWithErrorHandler;
-	const seen = getGlobalSeenMap("pi-crew.result-watcher");
-	let watcher: fs.FSWatcher | null | undefined;
-	let restartTimer: ReturnType<typeof setTimeout> | undefined;
-	const coalescer = createFileCoalescer((file) => {
-		const filePath = path.join(resultsDir, file);
-		if (!file.endsWith(".json") || !fs.existsSync(filePath)) return;
-		const payload = readJson(filePath);
-		if (payload !== undefined) {
-			const key = buildCompletionKey(payload as Record<string, unknown>, `file:${file}`);
-			if (!markSeenWithTtl(seen, key, Date.now(), completionTtlMs)) {
-				events.emit(eventName, payload);
-			}
-		}
-		try {
-			fs.unlinkSync(filePath);
-		} catch (error) {
-			logInternalError("result-watcher.unlink", error, `filePath=${filePath}`);
-		}
-	}, 50);
-	const scheduleRestart = () => {
-		if (restartTimer) clearTimeout(restartTimer);
-		restartTimer = setTimeout(() => {
-			restartTimer = undefined;
-			try {
-				fs.mkdirSync(resultsDir, { recursive: true });
-				handle.start();
-			} catch (error) {
-				logInternalError("result-watcher.restart", error, `resultsDir=${resultsDir}`);
-			}
-		}, RESULT_WATCHER_RESTART_MS);
-		restartTimer.unref?.();
-	};
-	const handle: ResultWatcherHandle = {
-		start() {
-			fs.mkdirSync(resultsDir, { recursive: true });
-			if (watcher) closeWatcher(watcher);
-			watcher = watch(resultsDir, (event, fileName) => {
-				if (event !== "rename" || !fileName) return;
-				coalescer.schedule(fileName.toString());
-			}, scheduleRestart);
-			watcher?.unref?.();
-		},
-		prime() {
-			if (!fs.existsSync(resultsDir)) return;
-			for (const file of fs.readdirSync(resultsDir).filter((entry) => entry.endsWith(".json"))) coalescer.schedule(file, 0);
-		},
-		stop() {
-			if (restartTimer) clearTimeout(restartTimer);
-			restartTimer = undefined;
-			closeWatcher(watcher);
-			watcher = undefined;
-			coalescer.clear();
-		},
-	};
-	return handle;
-}
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "../utils/completion-dedupe.ts";
+import { closeWatcher, watchWithErrorHandler } from "../utils/fs-watch.ts";
+import { createFileCoalescer } from "../utils/file-coalescer.ts";
+import { logInternalError } from "../utils/internal-error.ts";
+
+export interface ResultWatcherEvents {
+	emit(event: string, data: unknown): void;
+}
+
+export interface ResultWatcherHandle {
+	start(): void;
+	prime(): void;
+	stop(): void;
+}
+
+interface ResultWatcherDependencies {
+	watch?: typeof watchWithErrorHandler;
+}
+
+export interface ResultWatcherOptions extends ResultWatcherDependencies {
+	eventName?: string;
+	completionTtlMs?: number;
+}
+
+const RESULT_WATCHER_RESTART_MS = 3000;
+
+function readJson(filePath: string): unknown | undefined {
+	try {
+		return JSON.parse(fs.readFileSync(filePath, "utf-8")) as unknown;
+	} catch (error) {
+		logInternalError("result-watcher.parse", error, `filePath=${filePath}`);
+		return undefined;
+	}
+}
+
+export function createResultWatcher(events: ResultWatcherEvents, resultsDir: string, eventNameOrOptions: string | ResultWatcherOptions = "pi-crew:run-result"): ResultWatcherHandle {
+	const options: ResultWatcherOptions = typeof eventNameOrOptions === "string" ? { eventName: eventNameOrOptions } : eventNameOrOptions;
+	const eventName = options.eventName ?? "pi-crew:run-result";
+	const completionTtlMs = options.completionTtlMs ?? 5 * 60_000;
+	const watch = options.watch ?? watchWithErrorHandler;
+	const seen = getGlobalSeenMap("pi-crew.result-watcher");
+	let watcher: fs.FSWatcher | null | undefined;
+	let restartTimer: ReturnType<typeof setTimeout> | undefined;
+	const coalescer = createFileCoalescer((file) => {
+		const filePath = path.join(resultsDir, file);
+		if (!file.endsWith(".json") || !fs.existsSync(filePath)) return;
+		const payload = readJson(filePath);
+		if (payload !== undefined) {
+			const key = buildCompletionKey(payload as Record<string, unknown>, `file:${file}`);
+			if (!markSeenWithTtl(seen, key, Date.now(), completionTtlMs)) {
+				events.emit(eventName, payload);
+			}
+		}
+		try {
+			fs.unlinkSync(filePath);
+		} catch (error) {
+			logInternalError("result-watcher.unlink", error, `filePath=${filePath}`);
+		}
+	}, 50);
+	const scheduleRestart = () => {
+		if (restartTimer) clearTimeout(restartTimer);
+		restartTimer = setTimeout(() => {
+			restartTimer = undefined;
+			try {
+				fs.mkdirSync(resultsDir, { recursive: true });
+				handle.start();
+			} catch (error) {
+				logInternalError("result-watcher.restart", error, `resultsDir=${resultsDir}`);
+			}
+		}, RESULT_WATCHER_RESTART_MS);
+		restartTimer.unref?.();
+	};
+	const handle: ResultWatcherHandle = {
+		start() {
+			fs.mkdirSync(resultsDir, { recursive: true });
+			if (watcher) closeWatcher(watcher);
+			watcher = watch(resultsDir, (event, fileName) => {
+				if (event !== "rename" || !fileName) return;
+				coalescer.schedule(fileName.toString());
+			}, scheduleRestart);
+			watcher?.unref?.();
+		},
+		prime() {
+			if (!fs.existsSync(resultsDir)) return;
+			for (const file of fs.readdirSync(resultsDir).filter((entry) => entry.endsWith(".json"))) coalescer.schedule(file, 0);
+		},
+		stop() {
+			if (restartTimer) clearTimeout(restartTimer);
+			restartTimer = undefined;
+			closeWatcher(watcher);
+			watcher = undefined;
+			coalescer.clear();
+		},
+	};
+	return handle;
+}

package/src/extension/run-import.ts

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { assertRunBundle } from "./run-bundle-schema.ts";
-import { projectPiRoot, userPiRoot } from "../utils/paths.ts";
+import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
+import { DEFAULT_PATHS } from "../config/defaults.ts";
 
 export interface ImportedRunBundleInfo {
 	runId: string;
@@ -11,9 +12,8 @@ export interface ImportedRunBundleInfo {
 }
 
 function importRoot(cwd: string, scope: "project" | "user"): string {
-	return scope === "project"
-		? path.join(projectPiRoot(cwd), "teams", "imports")
-		: path.join(userPiRoot(), "extensions", "pi-crew", "imports");
+	const base = scope === "project" ? projectCrewRoot(cwd) : userCrewRoot();
+	return path.join(base, DEFAULT_PATHS.state.importsSubdir);
 }
 
 export function importRunBundle(cwd: string, bundlePath: string, scope: "project" | "user" = "project"): ImportedRunBundleInfo {

package/src/extension/run-index.ts

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { TeamRunManifest } from "../state/types.ts";
-import { projectPiRoot, userPiRoot } from "../utils/paths.ts";
+import { DEFAULT_PATHS } from "../config/defaults.ts";
+import { findRepoRoot, projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
 
 function readManifest(filePath: string): TeamRunManifest | undefined {
 	try {
@@ -12,33 +13,32 @@ function readManifest(filePath: string): TeamRunManifest | undefined {
 }
 
 function collectRuns(root: string, maxEntries?: number): TeamRunManifest[] {
-	const runsRoot = path.join(root, "state", "runs");
+	const runsRoot = path.join(root, DEFAULT_PATHS.state.runsSubdir);
 	if (!fs.existsSync(runsRoot)) return [];
 	const entries = fs.readdirSync(runsRoot).sort((a, b) => b.localeCompare(a));
 	const selected = maxEntries !== undefined ? entries.slice(0, Math.max(0, maxEntries)) : entries;
 	return selected
-		.map((entry) => readManifest(path.join(runsRoot, entry, "manifest.json")))
+		.map((entry) => readManifest(path.join(runsRoot, entry, DEFAULT_PATHS.state.manifestFile)))
 		.filter((manifest): manifest is TeamRunManifest => manifest !== undefined);
 }
 
-function mergeRuns(userRuns: TeamRunManifest[], projectRuns: TeamRunManifest[], max?: number): TeamRunManifest[] {
+function mergeRuns(runSets: TeamRunManifest[][], max?: number): TeamRunManifest[] {
 	const byId = new Map<string, TeamRunManifest>();
-	for (const run of [...userRuns, ...projectRuns]) byId.set(run.runId, run);
+	for (const runs of runSets) for (const run of runs) byId.set(run.runId, run);
 	const sorted = [...byId.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
 	return max !== undefined ? sorted.slice(0, Math.max(0, max)) : sorted;
 }
 
+function scopedRunRoots(cwd: string): string[] {
+	return [findRepoRoot(cwd) ? projectCrewRoot(cwd) : userCrewRoot()];
+}
+
 export function listRuns(cwd: string): TeamRunManifest[] {
-	return mergeRuns(
-		collectRuns(path.join(userPiRoot(), "extensions", "pi-crew", "runs")),
-		collectRuns(path.join(projectPiRoot(cwd), "teams")),
-	);
+	const roots = scopedRunRoots(cwd);
+	return mergeRuns(roots.map((root) => collectRuns(root)));
 }
 
 export function listRecentRuns(cwd: string, max = 20): TeamRunManifest[] {
-	return mergeRuns(
-		collectRuns(path.join(userPiRoot(), "extensions", "pi-crew", "runs"), max),
-		collectRuns(path.join(projectPiRoot(cwd), "teams"), max),
-		max,
-	);
+	const roots = scopedRunRoots(cwd);
+	return mergeRuns(roots.map((root) => collectRuns(root, max)), max);
 }

package/src/extension/run-maintenance.ts

@@ -1,24 +1,24 @@
-import * as fs from "node:fs";
-import type { TeamRunManifest } from "../state/types.ts";
-import { listRuns } from "./run-index.ts";
-
-export interface PruneRunsResult {
-	kept: string[];
-	removed: string[];
-}
-
-function isFinished(run: TeamRunManifest): boolean {
-	return run.status === "completed" || run.status === "failed" || run.status === "cancelled" || run.status === "blocked";
-}
-
-export function pruneFinishedRuns(cwd: string, keep: number): PruneRunsResult {
-	const finished = listRuns(cwd).filter((run) => run.cwd === cwd && isFinished(run)).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-	const kept = finished.slice(0, keep).map((run) => run.runId);
-	const removed: string[] = [];
-	for (const run of finished.slice(keep)) {
-		fs.rmSync(run.stateRoot, { recursive: true, force: true });
-		fs.rmSync(run.artifactsRoot, { recursive: true, force: true });
-		removed.push(run.runId);
-	}
-	return { kept, removed };
-}
+import * as fs from "node:fs";
+import type { TeamRunManifest } from "../state/types.ts";
+import { listRuns } from "./run-index.ts";
+
+export interface PruneRunsResult {
+	kept: string[];
+	removed: string[];
+}
+
+function isFinished(run: TeamRunManifest): boolean {
+	return run.status === "completed" || run.status === "failed" || run.status === "cancelled" || run.status === "blocked";
+}
+
+export function pruneFinishedRuns(cwd: string, keep: number): PruneRunsResult {
+	const finished = listRuns(cwd).filter((run) => run.cwd === cwd && isFinished(run)).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+	const kept = finished.slice(0, keep).map((run) => run.runId);
+	const removed: string[] = [];
+	for (const run of finished.slice(keep)) {
+		fs.rmSync(run.stateRoot, { recursive: true, force: true });
+		fs.rmSync(run.artifactsRoot, { recursive: true, force: true });
+		removed.push(run.runId);
+	}
+	return { kept, removed };
+}

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

@@ -116,6 +116,7 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 		const messageText = typeof cfg.message === "string" && cfg.message.trim() ? cfg.message.trim() : "Please report your current status, blocker, or smallest next step.";
 		const message = appendMailboxMessage(loaded.manifest, { direction: "inbox", from: "leader", to: agent.taskId, taskId: agent.taskId, body: messageText });
 		appendEvent(loaded.manifest.eventsPath, { type: "agent.nudged", runId: loaded.manifest.runId, taskId: agent.taskId, message: messageText, data: { agentId: agent.id, mailboxMessageId: message.id } });
+		ctx.events?.emit?.("crew.mailbox.message", { runId: loaded.manifest.runId, id: message.id, direction: message.direction, from: message.from, to: message.to, taskId: message.taskId, source: "nudge-agent" });
 		return result(JSON.stringify({ agentId: agent.id, mailboxMessage: message }, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
 	}
 	if (operation === "list-live-agents") {
@@ -170,6 +171,7 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 			return withRunLockSync(loaded.manifest, () => {
 				const message = appendMailboxMessage(loaded.manifest, { direction, from, to, body, taskId });
 				appendEvent(loaded.manifest.eventsPath, { type: "mailbox.message", runId: loaded.manifest.runId, data: { id: message.id, direction, from, to } });
+				ctx.events?.emit?.("crew.mailbox.message", { runId: loaded.manifest.runId, id: message.id, direction, from, to, taskId, source: "send-message" });
 				return result(JSON.stringify(message, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
 			});
 		} catch (error) {
@@ -184,6 +186,7 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 			return withRunLockSync(loaded.manifest, () => {
 				const delivery = acknowledgeMailboxMessage(loaded.manifest, messageId);
 				appendEvent(loaded.manifest.eventsPath, { type: "mailbox.acknowledged", runId: loaded.manifest.runId, data: { messageId } });
+				ctx.events?.emit?.("crew.mailbox.acknowledged", { runId: loaded.manifest.runId, messageId, delivery });
 				return result(JSON.stringify(delivery, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
 			});
 		} catch (error) {

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

@@ -1,31 +1,31 @@
-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 { writeForegroundInterruptRequest } from "../../runtime/foreground-control.ts";
-import { logInternalError } from "../../utils/internal-error.ts";
-import type { PiTeamsToolResult } from "../tool-result.ts";
-import { result, type TeamContext } from "./context.ts";
-
-export function handleCancel(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Cancel requires runId.", { action: "cancel", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "cancel", status: "error" }, true);
-	return withRunLockSync(loaded.manifest, () => {
-		if (loaded.manifest.status === "completed" && !params.force) return result(`Run ${loaded.manifest.runId} is already completed; nothing to cancel. Use force: true to mark it cancelled anyway.`, { action: "cancel", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
-		const tasks = loaded.tasks.map((task) => task.status === "queued" || task.status === "running" ? { ...task, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: "Run cancelled by user request." } : task);
-		saveRunTasks(loaded.manifest, tasks);
-		try {
-			saveCrewAgents(loaded.manifest, tasks.map((task) => recordFromTask(loaded.manifest, task, "child-process")));
-		} catch (error) {
-			logInternalError("team-tool.handleCancel.crewAgents", error, `runId=${loaded.manifest.runId}`);
-		}
-		try {
-			writeForegroundInterruptRequest(loaded.manifest, "Run cancelled by user request.");
-		} catch (error) {
-			logInternalError("team-tool.handleCancel.interruptRequest", error, `runId=${loaded.manifest.runId}`);
-		}
-		const updated = updateRunStatus(loaded.manifest, "cancelled", "Run cancelled by user request. Already-finished worker processes are not retroactively changed.");
-		return result(`Cancelled run ${updated.runId}.`, { action: "cancel", status: "ok", runId: updated.runId, artifactsRoot: updated.artifactsRoot });
-	});
-}
+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 { writeForegroundInterruptRequest } from "../../runtime/foreground-control.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { result, type TeamContext } from "./context.ts";
+
+export function handleCancel(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+	if (!params.runId) return result("Cancel requires runId.", { action: "cancel", status: "error" }, true);
+	const loaded = loadRunManifestById(ctx.cwd, params.runId);
+	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "cancel", status: "error" }, true);
+	return withRunLockSync(loaded.manifest, () => {
+		if (loaded.manifest.status === "completed" && !params.force) return result(`Run ${loaded.manifest.runId} is already completed; nothing to cancel. Use force: true to mark it cancelled anyway.`, { action: "cancel", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+		const tasks = loaded.tasks.map((task) => task.status === "queued" || task.status === "running" ? { ...task, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: "Run cancelled by user request." } : task);
+		saveRunTasks(loaded.manifest, tasks);
+		try {
+			saveCrewAgents(loaded.manifest, tasks.map((task) => recordFromTask(loaded.manifest, task, "child-process")));
+		} catch (error) {
+			logInternalError("team-tool.handleCancel.crewAgents", error, `runId=${loaded.manifest.runId}`);
+		}
+		try {
+			writeForegroundInterruptRequest(loaded.manifest, "Run cancelled by user request.");
+		} catch (error) {
+			logInternalError("team-tool.handleCancel.interruptRequest", error, `runId=${loaded.manifest.runId}`);
+		}
+		const updated = updateRunStatus(loaded.manifest, "cancelled", "Run cancelled by user request. Already-finished worker processes are not retroactively changed.");
+		return result(`Cancelled run ${updated.runId}.`, { action: "cancel", status: "ok", runId: updated.runId, artifactsRoot: updated.artifactsRoot });
+	});
+}