pi-crew 0.1.46 → 0.1.49

package/src/extension/run-maintenance.ts

@@ -1,62 +1,68 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { TeamRunManifest } from "../state/types.ts";
-import { resolveRealContainedPath } from "../utils/safe-paths.ts";
-import { projectCrewRoot } from "../utils/paths.ts";
-import { listRuns } from "./run-index.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { redactSecrets } from "../utils/redaction.ts";
-
-export interface PruneRunsResult {
-	kept: string[];
-	removed: string[];
-	auditPath?: string;
-}
-
-export interface PruneRunsOptions {
-	intent?: string;
-}
-
-function isFinished(run: TeamRunManifest): boolean {
-	return run.status === "completed" || run.status === "failed" || run.status === "cancelled" || run.status === "blocked";
-}
-
-function isSafeToPrune(cwd: string, run: TeamRunManifest): boolean {
-	try {
-		const crewRoot = projectCrewRoot(cwd);
-		resolveRealContainedPath(crewRoot, run.stateRoot);
-		resolveRealContainedPath(crewRoot, run.artifactsRoot);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-function appendPruneAudit(cwd: string, payload: Record<string, unknown>): string | undefined {
-	try {
-		const filePath = path.join(projectCrewRoot(cwd), "audit", "prune.jsonl");
-		fs.mkdirSync(path.dirname(filePath), { recursive: true });
-		fs.appendFileSync(filePath, `${JSON.stringify(redactSecrets({ ...payload, auditedAt: new Date().toISOString() }))}\n`, "utf-8");
-		return filePath;
-	} catch (error) {
-		logInternalError("prune.audit-write", error, `cwd=${cwd}`);
-		return undefined;
-	}
-}
-
-export function pruneFinishedRuns(cwd: string, keep: number, options: PruneRunsOptions = {}): 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)) {
-		if (!isSafeToPrune(cwd, run)) {
-			logInternalError("prune.path-unsafe", new Error(`Skipping unsafe prune: stateRoot=${run.stateRoot}, artifactsRoot=${run.artifactsRoot}`), `runId=${run.runId}`);
-			continue;
-		}
-		fs.rmSync(run.stateRoot, { recursive: true, force: true });
-		fs.rmSync(run.artifactsRoot, { recursive: true, force: true });
-		removed.push(run.runId);
-	}
-	const auditPath = appendPruneAudit(cwd, { action: "prune", keep, intent: options.intent, kept, removed });
-	return { kept, removed, auditPath };
-}
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { TeamRunManifest } from "../state/types.ts";
+import { resolveRealContainedPath } from "../utils/safe-paths.ts";
+import { projectCrewRoot } from "../utils/paths.ts";
+import { listRuns } from "./run-index.ts";
+import { logInternalError } from "../utils/internal-error.ts";
+import { redactSecrets } from "../utils/redaction.ts";
+import { createCancellationToken } from "../runtime/cancellation-token.ts";
+
+export interface PruneRunsResult {
+	kept: string[];
+	removed: string[];
+	auditPath?: string;
+}
+
+export interface PruneRunsOptions {
+	intent?: string;
+	signal?: AbortSignal;
+}
+
+function isFinished(run: TeamRunManifest): boolean {
+	return run.status === "completed" || run.status === "failed" || run.status === "cancelled" || run.status === "blocked";
+}
+
+function isSafeToPrune(cwd: string, run: TeamRunManifest): boolean {
+	try {
+		const crewRoot = projectCrewRoot(cwd);
+		resolveRealContainedPath(crewRoot, run.stateRoot);
+		resolveRealContainedPath(crewRoot, run.artifactsRoot);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function appendPruneAudit(cwd: string, payload: Record<string, unknown>): string | undefined {
+	try {
+		const filePath = path.join(projectCrewRoot(cwd), "audit", "prune.jsonl");
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+		fs.appendFileSync(filePath, `${JSON.stringify(redactSecrets({ ...payload, auditedAt: new Date().toISOString() }))}\n`, "utf-8");
+		return filePath;
+	} catch (error) {
+		logInternalError("prune.audit-write", error, `cwd=${cwd}`);
+		return undefined;
+	}
+}
+
+export function pruneFinishedRuns(cwd: string, keep: number, options: PruneRunsOptions = {}): PruneRunsResult {
+	const token = createCancellationToken({ signal: options.signal });
+	const finished = listRuns(cwd, options.signal).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[] = [];
+	const toRemove = finished.slice(keep);
+	for (let i = 0; i < toRemove.length; i++) {
+		if (i % 5 === 0) token.heartbeat(`prune:${i}/${toRemove.length}`);
+		const run = toRemove[i];
+		if (!isSafeToPrune(cwd, run)) {
+			logInternalError("prune.path-unsafe", new Error(`Skipping unsafe prune: stateRoot=${run.stateRoot}, artifactsRoot=${run.artifactsRoot}`), `runId=${run.runId}`);
+			continue;
+		}
+		fs.rmSync(run.stateRoot, { recursive: true, force: true });
+		fs.rmSync(run.artifactsRoot, { recursive: true, force: true });
+		removed.push(run.runId);
+	}
+	const auditPath = appendPruneAudit(cwd, { action: "prune", keep, intent: options.intent, kept, removed });
+	return { kept, removed, auditPath };
+}

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

@@ -5,7 +5,7 @@ import { loadRunManifestById, saveRunManifest, saveRunTasks, updateRunStatus } f
 import { withRunLockSync } from "../../state/locks.ts";
 import { canTransitionTaskStatus, isTeamTaskStatus } from "../../state/contracts.ts";
 import { claimTask, releaseTaskClaim, transitionClaimedTaskStatus } from "../../state/task-claims.ts";
-import { acknowledgeMailboxMessage, appendFollowUpMessage, appendMailboxMessage, appendSteeringMessage, readDeliveryState, readMailbox, readMailboxMessage, validateMailbox, type MailboxDirection } from "../../state/mailbox.ts";
+import { acknowledgeMailboxMessage, appendFollowUpMessage, appendMailboxMessage, appendSteeringMessage, readDeliveryState, readMailbox, readMailboxMessage, validateMailbox, type MailboxDirection, type MailboxMessageKind } from "../../state/mailbox.ts";
 import { appendEvent, readEvents, readEventsCursor } from "../../state/event-log.ts";
 import { resolveCrewRuntime } from "../../runtime/runtime-resolver.ts";
 import { probeLiveSessionRuntime } from "../../subagents/live/session-runtime.ts";
@@ -17,6 +17,7 @@ import { readForegroundControlStatus, writeForegroundInterruptRequest } from "..
 import { followUpLiveAgent, getLiveAgent, listLiveAgents, resumeLiveAgent, steerLiveAgent, stopLiveAgent } from "../../subagents/live/manager.ts";
 import { appendLiveAgentControlRequest } from "../../subagents/live/control.ts";
 import { liveControlRealtimeMessage, publishLiveControlRealtime } from "../../subagents/live/realtime.ts";
+import { buildCapabilityInventory } from "../../runtime/capability-inventory.ts";
 import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { configRecord, result, type TeamContext } from "./context.ts";
@@ -76,6 +77,10 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 		});
 		return result(JSON.stringify(filtered, null, 2), { action: "api", status: "ok", ...(runIdFilter ? { runId: runIdFilter } : {}) });
 	}
+	if (operation === "inventory") {
+		const inventory = buildCapabilityInventory(ctx.cwd, ctx.config);
+		return result(JSON.stringify(inventory, null, 2), { action: "api", status: "ok" });
+	}
 	if (!params.runId) return result("API requires runId.", { action: "api", status: "error" }, true);
 	const loaded = loadRunManifestById(ctx.cwd, params.runId);
 	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "api", status: "error" }, true);
@@ -275,9 +280,10 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 	if (operation === "read-mailbox") {
 		const direction = cfg.direction === "inbox" || cfg.direction === "outbox" ? cfg.direction as MailboxDirection : undefined;
 		const taskId = typeof cfg.taskId === "string" ? cfg.taskId : undefined;
+		const kind = typeof cfg.kind === "string" && ["message", "steer", "follow-up", "response", "group_join"].includes(cfg.kind) ? cfg.kind as MailboxMessageKind : undefined;
 		if (taskId && !loaded.tasks.some((task) => task.id === taskId)) return result(`API read-mailbox taskId '${taskId}' does not match a run task.`, { action: "api", status: "error", runId: loaded.manifest.runId }, true);
 		try {
-			return result(JSON.stringify(readMailbox(loaded.manifest, direction, taskId), null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+			return result(JSON.stringify(readMailbox(loaded.manifest, direction, taskId, kind), null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			return result(message, { action: "api", status: "error", runId: loaded.manifest.runId }, true);
@@ -416,5 +422,20 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 			return result(message, { action: "api", status: "error", runId: loaded.manifest.runId }, true);
 		}
 	}
+	if (operation === "diff") {
+		const diffArtifacts = loaded.manifest.artifacts.filter(a => a.kind === "diff" || a.kind === "patch");
+		if (diffArtifacts.length === 0) {
+			return result(`No diff artifacts found for run ${loaded.manifest.runId}. Diffs are captured in worktree mode.`, { action: "api", status: "ok", runId: loaded.manifest.runId, intent: `diff ${loaded.manifest.runId}: no diffs` });
+		}
+		const parts: string[] = [`Diff artifacts for run ${loaded.manifest.runId}:`];
+		for (const artifact of diffArtifacts) {
+			const content = safeReadContainedFile(loaded.manifest.artifactsRoot, artifact.path);
+			if (content) {
+				const display = content.length > 4000 ? content.slice(0, 4000) + "\n... (truncated)" : content;
+				parts.push(`\n--- ${artifact.path} ---\n${display}`);
+			}
+		}
+		return result(parts.join("\n"), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot, intent: `diff ${loaded.manifest.runId}` });
+	}
 	return result(`Unknown API operation: ${operation}`, { action: "api", status: "error", runId: loaded.manifest.runId }, true);
 }

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

@@ -3,11 +3,13 @@ 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 { cancellationReasonFromUnknown } from "../../runtime/cancellation.ts";
+import { cancellationReasonFromUnknown, buildSyntheticTerminalEvidence, type CancellationReason } from "../../runtime/cancellation.ts";
 import { appendEvent } from "../../state/event-log.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
+import { executeHook, appendHookEvent } from "../../hooks/registry.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { result, type TeamContext } from "./context.ts";
+import { enforceDestructiveIntent, intentFromConfig } from "./intent-policy.ts";
 
 export interface AbortOwnedResult {
 	abortedIds: string[];
@@ -61,25 +63,93 @@ function configFromParams(params: TeamToolParamsValue): Record<string, unknown>
 	return params.config && typeof params.config === "object" && !Array.isArray(params.config) ? params.config : undefined;
 }
 
-function cancelReasonFromParams(params: TeamToolParamsValue): { code: string; message: string } {
+function cancelReasonFromParams(params: TeamToolParamsValue): CancellationReason {
 	const config = configFromParams(params);
 	const rawReason = config?.reason ?? config?.cancelReason;
 	const reason = rawReason === undefined ? { code: "caller_cancelled" as const, message: "Run cancelled by user request." } : cancellationReasonFromUnknown(rawReason);
 	return { code: reason.code, message: reason.message };
 }
 
-function intentFromParams(params: TeamToolParamsValue): string | undefined {
-	const config = configFromParams(params);
-	const rawIntent = config?.intent ?? config?._intent;
-	if (typeof rawIntent !== "string") return undefined;
-	const intent = rawIntent.replace(/\s+/g, " ").trim();
-	return intent ? intent.slice(0, 500) : undefined;
+export async function handleRetry(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
+	if (!params.runId) return result("Retry requires runId.", { action: "retry", status: "error" }, true);
+	const loaded = loadRunManifestById(ctx.cwd, params.runId);
+	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "retry", status: "error" }, true);
+
+	// Pre-lock ownership check: reject foreign-owned runs
+	const foreignRun = typeof loaded.manifest.ownerSessionId === "string" && loaded.manifest.ownerSessionId !== ctx.sessionId;
+	if (foreignRun) {
+		return result(`Run ${loaded.manifest.runId} belongs to another session; not retried.`, { action: "retry", status: "error", runId: loaded.manifest.runId }, true);
+	}
+
+	// Execute before_retry hook after ownership confirmed, before mutation lock
+	const hookReport = await executeHook("before_retry", { runId: loaded.manifest.runId, cwd: ctx.cwd });
+	appendHookEvent(loaded.manifest, hookReport);
+	if (hookReport.outcome === "block") {
+		return result(`Retry blocked by hook: ${hookReport.reason ?? "before_retry hook blocked the operation."}`, { action: "retry", status: "error", runId: loaded.manifest.runId }, true);
+	}
+
+	const targetTaskId = typeof params.taskId === "string" ? params.taskId : undefined;
+
+	return withRunLockSync(loaded.manifest, () => {
+		const retryableStatuses: ReadonlySet<string> = new Set(["failed", "cancelled"]);
+
+		const matchingTasks = loaded.tasks.filter((task) => {
+			if (targetTaskId && task.id !== targetTaskId) return false;
+			return retryableStatuses.has(task.status);
+		});
+
+		if (matchingTasks.length === 0) {
+			return result(targetTaskId ? `Task '${targetTaskId}' is not failed/cancelled; nothing to retry.` : "No failed/cancelled tasks to retry.", { action: "retry", status: "error", runId: loaded.manifest.runId }, true);
+		}
+
+		const retriedIds = new Set(matchingTasks.map((t) => t.id));
+		const tasks = loaded.tasks.map((task) => {
+			if (!retriedIds.has(task.id)) return task;
+			const { error: _error, finishedAt: _finishedAt, terminalEvidence: _terminalEvidence, ...rest } = task;
+			return { ...rest, status: "queued" as const };
+		});
+		saveRunTasks(loaded.manifest, tasks);
+		try {
+			saveCrewAgents(loaded.manifest, tasks.map((task) => recordFromTask(loaded.manifest, task, "child-process")));
+		} catch (error) {
+			logInternalError("team-tool.handleRetry.crewAgents", error, `runId=${loaded.manifest.runId}`);
+		}
+
+		const retriedTaskIds = [...retriedIds];
+		for (const taskId of retriedTaskIds) {
+			appendEvent(loaded.manifest.eventsPath, { type: "task.retried", runId: loaded.manifest.runId, taskId, message: `Task ${taskId} queued for retry.` });
+		}
+
+		return result(`Retried ${retriedTaskIds.length} task(s) in run ${loaded.manifest.runId}.`, {
+			action: "retry",
+			status: "ok",
+			runId: loaded.manifest.runId,
+			retriedTaskIds: retriedTaskIds,
+			intent: `retrying ${retriedTaskIds.length} task(s) in ${loaded.manifest.runId}`,
+		});
+	});
 }
 
-export function handleCancel(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
+	const intentError = enforceDestructiveIntent("cancel", params, ctx.config);
+	if (intentError) return intentError;
 	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);
+
+	// Pre-lock ownership check: reject foreign-owned runs before executing hooks
+	const preCheck = abortOwned(loaded.manifest.runId, undefined, ctx);
+	if (preCheck.abortedIds.length === 0 && preCheck.foreignIds.length > 0) {
+		return result(`Run ${loaded.manifest.runId} belongs to another session; not cancelled.`, { action: "cancel", status: "error", runId: loaded.manifest.runId, foreignIds: preCheck.foreignIds }, true);
+	}
+
+	// Execute before_cancel hook after ownership confirmed, before mutation lock
+	const hookReport = await executeHook("before_cancel", { runId: loaded.manifest.runId, cwd: ctx.cwd });
+	appendHookEvent(loaded.manifest, hookReport);
+	if (hookReport.outcome === "block") {
+		return result(`Cancel blocked by hook: ${hookReport.reason ?? "before_cancel hook blocked the operation."}`, { action: "cancel", status: "error", runId: loaded.manifest.runId }, true);
+	}
+
 	return withRunLockSync(loaded.manifest, () => {
 		if ((loaded.manifest.status === "completed" || loaded.manifest.status === "cancelled") && !params.force) return result(`Run ${loaded.manifest.runId} is already ${loaded.manifest.status}; nothing to cancel. Use force: true to mark it cancelled anyway.`, { action: "cancel", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
 
@@ -90,13 +160,17 @@ export function handleCancel(params: TeamToolParamsValue, ctx: TeamContext): PiT
 		}
 		const cancellableIds = new Set(abortResult.abortedIds);
 		const cancelReason = cancelReasonFromParams(params);
-		const cancelIntent = intentFromParams(params);
+		const cancelIntent = intentFromConfig(params.config);
 		const cancelData = cancelIntent ? { reason: cancelReason.code, intent: cancelIntent } : { reason: cancelReason.code };
 		const cancelMessage = `${cancelReason.message} (${cancelReason.code})`;
 
 		const tasks = loaded.tasks.map((task) => {
 			if (cancellableIds.has(task.id) && (task.status === "queued" || task.status === "running" || task.status === "waiting")) {
-				return { ...task, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: cancelMessage };
+				const base = { ...task, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: cancelMessage };
+				if (task.status === "running") {
+					return { ...base, terminalEvidence: [...(task.terminalEvidence ?? []), buildSyntheticTerminalEvidence("worker", cancelReason, task.startedAt)] };
+				}
+				return base;
 			}
 			return task;
 		});
@@ -111,6 +185,7 @@ export function handleCancel(params: TeamToolParamsValue, ctx: TeamContext): PiT
 		} catch (error) {
 			logInternalError("team-tool.handleCancel.interruptRequest", error, `runId=${loaded.manifest.runId}`);
 		}
+		ctx.abortForegroundRun?.(loaded.manifest.runId);
 		for (const taskId of abortResult.abortedIds) {
 			appendEvent(loaded.manifest.eventsPath, { type: "task.cancelled", runId: loaded.manifest.runId, taskId, message: cancelMessage, data: cancelData });
 		}

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

@@ -1,4 +1,5 @@
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { PiTeamsConfig } from "../../config/config.ts";
 import type { MetricRegistry } from "../../observability/metric-registry.ts";
 import type { TeamToolDetails } from "../team-tool-types.ts";
 import { toolResult, type PiTeamsToolResult } from "../tool-result.ts";
@@ -11,8 +12,10 @@ export type TeamContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<Extension
 	metricRegistry?: MetricRegistry;
 	signal?: AbortSignal;
 	startForegroundRun?: (runner: (signal?: AbortSignal) => Promise<void>, runId?: string) => void;
+	abortForegroundRun?: (runId: string) => boolean;
 	onRunStarted?: (runId: string) => void;
 	onJsonEvent?: (taskId: string, runId: string, event: unknown) => void;
+	config?: PiTeamsConfig;
 };
 
 export function withSessionId<T extends Pick<ExtensionContext, "sessionManager">>(ctx: T): T & { sessionId?: string } {