pi-crew 0.1.51 → 0.2.1

package/src/extension/run-bundle-schema.ts

@@ -1,89 +1,89 @@
-import { isTeamRunStatus, isTeamTaskStatus } from "../state/contracts.ts";
-import type { TeamRunManifest, TeamTaskState, ArtifactDescriptor } from "../state/types.ts";
-import type { TeamEvent } from "../state/event-log.ts";
-import type { ExportedRunBundle } from "./run-export.ts";
-
-export interface BundleValidationResult {
-	ok: boolean;
-	errors: string[];
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-function validateArtifact(value: unknown, index: number, errors: string[]): value is ArtifactDescriptor {
-	if (!isRecord(value)) {
-		errors.push(`manifest.artifacts[${index}] must be an object.`);
-		return false;
-	}
-	const before = errors.length;
-	if (typeof value.kind !== "string") errors.push(`manifest.artifacts[${index}].kind must be a string.`);
-	if (typeof value.path !== "string") errors.push(`manifest.artifacts[${index}].path must be a string.`);
-	if (typeof value.createdAt !== "string") errors.push(`manifest.artifacts[${index}].createdAt must be a string.`);
-	if (typeof value.producer !== "string") errors.push(`manifest.artifacts[${index}].producer must be a string.`);
-	if (value.retention !== "run" && value.retention !== "project" && value.retention !== "temporary") errors.push(`manifest.artifacts[${index}].retention is invalid.`);
-	return errors.length === before;
-}
-
-function validateManifest(value: unknown, errors: string[]): value is TeamRunManifest {
-	if (!isRecord(value)) {
-		errors.push("manifest must be an object.");
-		return false;
-	}
-	const before = errors.length;
-	if (value.schemaVersion !== 1) errors.push("manifest.schemaVersion must be 1.");
-	for (const field of ["runId", "team", "goal", "createdAt", "updatedAt", "cwd", "stateRoot", "artifactsRoot", "tasksPath", "eventsPath"] as const) {
-		if (typeof value[field] !== "string") errors.push(`manifest.${field} must be a string.`);
-	}
-	if (!isTeamRunStatus(value.status)) errors.push("manifest.status is invalid.");
-	if (value.workspaceMode !== "single" && value.workspaceMode !== "worktree") errors.push("manifest.workspaceMode must be single or worktree.");
-	if (!Array.isArray(value.artifacts)) errors.push("manifest.artifacts must be an array.");
-	else value.artifacts.forEach((artifact, index) => validateArtifact(artifact, index, errors));
-	return errors.length === before;
-}
-
-function validateTask(value: unknown, index: number, errors: string[]): value is TeamTaskState {
-	if (!isRecord(value)) {
-		errors.push(`tasks[${index}] must be an object.`);
-		return false;
-	}
-	const before = errors.length;
-	for (const field of ["id", "runId", "role", "agent", "title", "cwd"] as const) {
-		if (typeof value[field] !== "string") errors.push(`tasks[${index}].${field} must be a string.`);
-	}
-	if (!isTeamTaskStatus(value.status)) errors.push(`tasks[${index}].status is invalid.`);
-	if (!Array.isArray(value.dependsOn)) errors.push(`tasks[${index}].dependsOn must be an array.`);
-	return errors.length === before;
-}
-
-function validateEvent(value: unknown, index: number, errors: string[]): value is TeamEvent {
-	if (!isRecord(value)) {
-		errors.push(`events[${index}] must be an object.`);
-		return false;
-	}
-	const before = errors.length;
-	for (const field of ["time", "type", "runId"] as const) {
-		if (typeof value[field] !== "string") errors.push(`events[${index}].${field} must be a string.`);
-	}
-	return errors.length === before;
-}
-
-export function validateRunBundle(value: unknown): BundleValidationResult {
-	const errors: string[] = [];
-	if (!isRecord(value)) return { ok: false, errors: ["bundle must be an object."] };
-	if (value.schemaVersion !== 1) errors.push("schemaVersion must be 1.");
-	if (typeof value.exportedAt !== "string") errors.push("exportedAt must be a string.");
-	validateManifest(value.manifest, errors);
-	if (!Array.isArray(value.tasks)) errors.push("tasks must be an array.");
-	else value.tasks.forEach((task, index) => validateTask(task, index, errors));
-	if (!Array.isArray(value.events)) errors.push("events must be an array.");
-	else value.events.forEach((event, index) => validateEvent(event, index, errors));
-	if (!Array.isArray(value.artifactPaths) || !value.artifactPaths.every((item) => typeof item === "string")) errors.push("artifactPaths must be an array of strings.");
-	return { ok: errors.length === 0, errors };
-}
-
-export function assertRunBundle(value: unknown): asserts value is ExportedRunBundle {
-	const validation = validateRunBundle(value);
-	if (!validation.ok) throw new Error(`File is not a valid pi-crew exported run bundle:\n${validation.errors.map((error) => `- ${error}`).join("\n")}`);
-}
+import { isTeamRunStatus, isTeamTaskStatus } from "../state/contracts.ts";
+import type { TeamRunManifest, TeamTaskState, ArtifactDescriptor } from "../state/types.ts";
+import type { TeamEvent } from "../state/event-log.ts";
+import type { ExportedRunBundle } from "./run-export.ts";
+
+export interface BundleValidationResult {
+	ok: boolean;
+	errors: string[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function validateArtifact(value: unknown, index: number, errors: string[]): value is ArtifactDescriptor {
+	if (!isRecord(value)) {
+		errors.push(`manifest.artifacts[${index}] must be an object.`);
+		return false;
+	}
+	const before = errors.length;
+	if (typeof value.kind !== "string") errors.push(`manifest.artifacts[${index}].kind must be a string.`);
+	if (typeof value.path !== "string") errors.push(`manifest.artifacts[${index}].path must be a string.`);
+	if (typeof value.createdAt !== "string") errors.push(`manifest.artifacts[${index}].createdAt must be a string.`);
+	if (typeof value.producer !== "string") errors.push(`manifest.artifacts[${index}].producer must be a string.`);
+	if (value.retention !== "run" && value.retention !== "project" && value.retention !== "temporary") errors.push(`manifest.artifacts[${index}].retention is invalid.`);
+	return errors.length === before;
+}
+
+function validateManifest(value: unknown, errors: string[]): value is TeamRunManifest {
+	if (!isRecord(value)) {
+		errors.push("manifest must be an object.");
+		return false;
+	}
+	const before = errors.length;
+	if (value.schemaVersion !== 1) errors.push("manifest.schemaVersion must be 1.");
+	for (const field of ["runId", "team", "goal", "createdAt", "updatedAt", "cwd", "stateRoot", "artifactsRoot", "tasksPath", "eventsPath"] as const) {
+		if (typeof value[field] !== "string") errors.push(`manifest.${field} must be a string.`);
+	}
+	if (!isTeamRunStatus(value.status)) errors.push("manifest.status is invalid.");
+	if (value.workspaceMode !== "single" && value.workspaceMode !== "worktree") errors.push("manifest.workspaceMode must be single or worktree.");
+	if (!Array.isArray(value.artifacts)) errors.push("manifest.artifacts must be an array.");
+	else value.artifacts.forEach((artifact, index) => validateArtifact(artifact, index, errors));
+	return errors.length === before;
+}
+
+function validateTask(value: unknown, index: number, errors: string[]): value is TeamTaskState {
+	if (!isRecord(value)) {
+		errors.push(`tasks[${index}] must be an object.`);
+		return false;
+	}
+	const before = errors.length;
+	for (const field of ["id", "runId", "role", "agent", "title", "cwd"] as const) {
+		if (typeof value[field] !== "string") errors.push(`tasks[${index}].${field} must be a string.`);
+	}
+	if (!isTeamTaskStatus(value.status)) errors.push(`tasks[${index}].status is invalid.`);
+	if (!Array.isArray(value.dependsOn)) errors.push(`tasks[${index}].dependsOn must be an array.`);
+	return errors.length === before;
+}
+
+function validateEvent(value: unknown, index: number, errors: string[]): value is TeamEvent {
+	if (!isRecord(value)) {
+		errors.push(`events[${index}] must be an object.`);
+		return false;
+	}
+	const before = errors.length;
+	for (const field of ["time", "type", "runId"] as const) {
+		if (typeof value[field] !== "string") errors.push(`events[${index}].${field} must be a string.`);
+	}
+	return errors.length === before;
+}
+
+export function validateRunBundle(value: unknown): BundleValidationResult {
+	const errors: string[] = [];
+	if (!isRecord(value)) return { ok: false, errors: ["bundle must be an object."] };
+	if (value.schemaVersion !== 1) errors.push("schemaVersion must be 1.");
+	if (typeof value.exportedAt !== "string") errors.push("exportedAt must be a string.");
+	validateManifest(value.manifest, errors);
+	if (!Array.isArray(value.tasks)) errors.push("tasks must be an array.");
+	else value.tasks.forEach((task, index) => validateTask(task, index, errors));
+	if (!Array.isArray(value.events)) errors.push("events must be an array.");
+	else value.events.forEach((event, index) => validateEvent(event, index, errors));
+	if (!Array.isArray(value.artifactPaths) || !value.artifactPaths.every((item) => typeof item === "string")) errors.push("artifactPaths must be an array of strings.");
+	return { ok: errors.length === 0, errors };
+}
+
+export function assertRunBundle(value: unknown): asserts value is ExportedRunBundle {
+	const validation = validateRunBundle(value);
+	if (!validation.ok) throw new Error(`File is not a valid pi-crew exported run bundle:\n${validation.errors.map((error) => `- ${error}`).join("\n")}`);
+}

package/src/extension/run-import.ts

@@ -4,12 +4,14 @@ import { assertRunBundle } from "./run-bundle-schema.ts";
 import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
 import { DEFAULT_PATHS } from "../config/defaults.ts";
 import { assertSafePathId, resolveContainedRelativePath, resolveRealContainedPath } from "../utils/safe-paths.ts";
+import { detectImportConflicts, type ConflictReport } from "../runtime/delta-conflict.ts";
 
 export interface ImportedRunBundleInfo {
 	runId: string;
 	importedAt: string;
 	bundlePath: string;
 	summaryPath: string;
+	conflictReport?: ConflictReport;
 }
 
 function importRoot(cwd: string, scope: "project" | "user"): string {
@@ -19,10 +21,32 @@ function importRoot(cwd: string, scope: "project" | "user"): string {
 
 export function importRunBundle(cwd: string, bundlePath: string, scope: "project" | "user" = "project"): ImportedRunBundleInfo {
 	const resolvedPath = path.isAbsolute(bundlePath) ? bundlePath : path.resolve(cwd, bundlePath);
+	// Path containment: only allow reading bundles from cwd or user home
+	const allowedBases = [cwd];
+	try { allowedBases.push(userCrewRoot()); } catch { /* ignore */ }
+	try { allowedBases.push(projectCrewRoot(cwd)); } catch { /* ignore */ }
+	const isContained = allowedBases.some((base) => resolvedPath.startsWith(base + path.sep) || resolvedPath === base);
+	if (!isContained) throw new Error(`Import path must be within project directory or crew root: ${resolvedPath}`);
 	const raw = JSON.parse(fs.readFileSync(resolvedPath, "utf-8")) as unknown;
 	assertRunBundle(raw);
 	const runId = assertSafePathId("runId", raw.manifest.runId);
 	const importedAt = new Date().toISOString();
+
+	// Non-blocking conflict detection: compare incoming bundle against any existing state.
+	let conflictReport: ConflictReport | undefined;
+	try {
+		const existingManifestPath = path.join(importRoot(cwd, scope), runId, "run-export.json");
+		if (fs.existsSync(existingManifestPath)) {
+			const existingRaw = JSON.parse(fs.readFileSync(existingManifestPath, "utf-8")) as { manifest?: Record<string, unknown>; tasks?: unknown[] };
+			conflictReport = detectImportConflicts(
+				{ manifest: raw.manifest as unknown as Record<string, unknown>, tasks: raw.tasks as unknown[] },
+				{ manifest: existingRaw.manifest, tasks: existingRaw.tasks },
+			);
+		}
+	} catch {
+		// Conflict detection is best-effort; do not block import on failure.
+	}
+
 	const importsRoot = importRoot(cwd, scope);
 	fs.mkdirSync(importsRoot, { recursive: true });
 	if (fs.lstatSync(importsRoot).isSymbolicLink()) throw new Error(`Invalid import root: ${importsRoot}`);
@@ -56,5 +80,5 @@ export function importRunBundle(cwd: string, bundlePath: string, scope: "project
 		...raw.tasks.map((task) => `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.error ? ` - ${task.error}` : ""}`),
 		"",
 	].join("\n"), "utf-8");
-	return { runId, importedAt, bundlePath: targetJson, summaryPath: targetSummary };
+	return { runId, importedAt, bundlePath: targetJson, summaryPath: targetSummary, ...(conflictReport?.hasConflicts ? { conflictReport } : {}) };
 }

package/src/extension/run-index.ts

@@ -33,7 +33,11 @@ function collectRuns(root: string, maxEntries?: number, signal?: AbortSignal): T
 		if (i % 10 === 0) token.heartbeat(`collectRuns:${i}/${selected.length}`);
 		try {
 			const manifest = readManifest(path.join(resolveRealContainedPath(runsRoot, selected[i]), DEFAULT_PATHS.state.manifestFile));
-			if (manifest) results.push(manifest);
+			if (!manifest) continue;
+			// Filter out ghost runs: active status but CWD no longer exists.
+			// These are deadletter/replay/temp runs whose temp dirs were cleaned up.
+			if ((manifest.status === "queued" || manifest.status === "running" || manifest.status === "planning") && manifest.cwd && !fs.existsSync(manifest.cwd)) continue;
+			results.push(manifest);
 		} catch { /* skip unreadable manifests */ }
 	}
 	return results;

package/src/extension/run-maintenance.ts

@@ -1,68 +1,142 @@
-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 };
-}
+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, userCrewRoot } 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";
+import { DEFAULT_PATHS } from "../config/defaults.ts";
+import { isSafePathId } from "../utils/safe-paths.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 = run.stateRoot.startsWith(userCrewRoot() + path.sep) ? userCrewRoot() : 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 };
+}
+
+/**
+ * Prune finished run directories at the user level (~/.pi/agent/extensions/pi-crew/state/runs/).
+ *
+ * This handles runs created without a project root (e.g. `team action='run'` from home directory)
+ * that would otherwise accumulate forever.
+ *
+ * @param keep Number of most recent finished runs to retain
+ * @returns kept and removed run IDs
+ */
+export function pruneUserLevelRuns(keep: number): PruneRunsResult {
+	const crewRoot = userCrewRoot();
+	const runsRoot = path.join(crewRoot, DEFAULT_PATHS.state.runsSubdir);
+	if (!fs.existsSync(runsRoot)) return { kept: [], removed: [] };
+
+	// Read all run directories, parse manifests, filter to finished
+	const MAX_DIRS = 500;
+	const finished: Array<{ runId: string; updatedAt: string; stateRoot: string; artifactsRoot: string }> = [];
+	const ghostRemoved: string[] = [];
+	const dirs = fs.readdirSync(runsRoot, { withFileTypes: true })
+		.filter((entry) => entry.isDirectory() && isSafePathId(entry.name))
+		.slice(0, MAX_DIRS)
+		.map((entry) => entry.name);
+
+	for (const dir of dirs) {
+		const manifestPath = path.join(runsRoot, dir, DEFAULT_PATHS.state.manifestFile);
+		let manifest: TeamRunManifest | undefined;
+		try {
+			manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8")) as TeamRunManifest;
+		} catch {
+			continue;
+		}
+
+		// Ghost run cleanup: active status but CWD no longer exists.
+		// These are deadletter/replay/temp runs from dead Pi sessions.
+		const isActive = manifest.status === "queued" || manifest.status === "running" || manifest.status === "planning";
+		if (isActive && manifest.cwd && !fs.existsSync(manifest.cwd)) {
+			fs.rmSync(path.join(runsRoot, dir), { recursive: true, force: true });
+			ghostRemoved.push(manifest.runId);
+			continue;
+		}
+
+		if (!isFinished(manifest)) continue;
+
+		// Safety check: ensure stateRoot and artifactsRoot are contained within user crew root
+		try {
+			resolveRealContainedPath(crewRoot, manifest.stateRoot);
+			resolveRealContainedPath(crewRoot, manifest.artifactsRoot);
+		} catch {
+			continue;
+		}
+
+		finished.push({
+			runId: manifest.runId,
+			updatedAt: manifest.updatedAt,
+			stateRoot: manifest.stateRoot,
+			artifactsRoot: manifest.artifactsRoot,
+		});
+	}
+
+	// Sort newest first, keep top N, remove the rest
+	finished.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+	const kept = finished.slice(0, keep).map((r) => r.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: [...removed, ...ghostRemoved] };
+}

package/src/extension/team-manager-command.ts

@@ -1,6 +1,15 @@
 import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
 import { listRuns } from "./run-index.ts";
-import { handleTeamTool } from "./team-tool.ts";
+// Lazy-loaded: team-tool.ts pulls in entire runtime chain.
+import type { handleTeamTool as HandleTeamToolFn } from "./team-tool.ts";
+let _cachedHandleTeamTool: typeof HandleTeamToolFn | undefined;
+async function handleTeamTool(params: Parameters<typeof HandleTeamToolFn>[0], ctx: Parameters<typeof HandleTeamToolFn>[1]): Promise<Awaited<ReturnType<typeof HandleTeamToolFn>>> {
+	if (!_cachedHandleTeamTool) {
+		const mod = await import("./team-tool.ts");
+		_cachedHandleTeamTool = mod.handleTeamTool;
+	}
+	return _cachedHandleTeamTool(params, ctx);
+}
 import { isToolError, textFromToolResult } from "./tool-result.ts";
 
 async function notifyResult(ctx: ExtensionCommandContext, result: Awaited<ReturnType<typeof handleTeamTool>>): Promise<void> {