pi-crew 0.9.16 → 0.9.18

package/src/extension/team-tool/handle-settings.ts

@@ -1,14 +1,10 @@
-import type { TeamContext } from "../team-tool/context.ts";
 import { loadConfig, updateConfig } from "../../config/config.ts";
+import { suggestConfigKey } from "../../config/suggestions.ts";
+import { discoverPiThemes, formatThemesListing, setPiTheme } from "../../ui/theme-discovery.ts";
 import { configPatchFromConfig } from "../team-tool/config-patch.ts";
+import type { TeamContext } from "../team-tool/context.ts";
 import { result } from "../team-tool/context.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
-import { suggestConfigKey } from "../../config/suggestions.ts";
-import {
-	formatThemesListing,
-	discoverPiThemes,
-	setPiTheme,
-} from "../../ui/theme-discovery.ts";
 
 // ---------------------------------------------------------------------------
 // Effective defaults — values used when config key is not set
@@ -40,9 +36,9 @@ const EFFECTIVE_DEFAULTS: Record<string, unknown> = {
 	"autonomous.injectPolicy": true,
 	"autonomous.preferAsyncForLongTasks": false,
 	"autonomous.allowWorktreeSuggestion": true,
-	"executeWorkers": true,
-	"asyncByDefault": false,
-	"notifierIntervalMs": 5000,
+	executeWorkers: true,
+	asyncByDefault: false,
+	notifierIntervalMs: 5000,
 	"reliability.autoRetry": false,
 	"reliability.autoRecover": false,
 	"reliability.cleanupOrphanedTempDirs": true,
@@ -88,7 +84,11 @@ function formatValue(value: unknown, key?: string): string {
 
 function parseValue(raw: string): unknown {
 	// JSON handles strings (quoted), numbers, booleans, null, arrays, objects.
-	try { return JSON.parse(raw); } catch { /* keep as string */ }
+	try {
+		return JSON.parse(raw);
+	} catch {
+		/* keep as string */
+	}
 	return raw;
 }
 
@@ -107,9 +107,7 @@ function flattenConfig(obj: unknown, prefix: string = ""): string[] {
 			// Check if it's a "leaf object" — a value-type record like agent overrides
 			// where keys are agent names and values are { model, thinking, ... }
 			const entries = Object.entries(value as Record<string, unknown>);
-			const allLeafValues = entries.every(([, v]) =>
-				v === undefined || v === null || typeof v !== "object" || Array.isArray(v)
-			);
+			const allLeafValues = entries.every(([, v]) => v === undefined || v === null || typeof v !== "object" || Array.isArray(v));
 			if (allLeafValues && entries.length > 0) {
 				// It's a flat record like { explorer: { model: "...", thinking: "..." } }
 				// Check if nested values are objects (agent overrides pattern)
@@ -285,7 +283,10 @@ export function handleSettings(params: { config?: Record<string, unknown> }, ctx
 			for (const w of loaded.warnings) lines.push(`  ${w}`);
 		}
 		lines.push("", USAGE);
-		return result(lines.join("\n"), { ...OK, count: flatLines.length } as never);
+		return result(lines.join("\n"), {
+			...OK,
+			count: flatLines.length,
+		} as never);
 	}
 
 	// team-settings json — full JSON dump
@@ -294,7 +295,7 @@ export function handleSettings(params: { config?: Record<string, unknown> }, ctx
 			`// pi-crew effective config (merged from all sources)`,
 			`// Config file: ${loaded.path}`,
 			`// Sources: ${loaded.paths?.join(", ") ?? loaded.path}`,
-			...loaded.warnings?.map(w => `// WARNING: ${w}`) ?? [],
+			...(loaded.warnings?.map((w) => `// WARNING: ${w}`) ?? []),
 			"",
 			JSON.stringify(effective, null, 2),
 		];
@@ -310,15 +311,15 @@ export function handleSettings(params: { config?: Record<string, unknown> }, ctx
 			lines.push(`  ${key}${marker}`);
 		}
 		lines.push("", "✓ = currently set in config. Keys without ✓ use defaults.", "", USAGE);
-		return result(lines.join("\n"), { ...OK, count: KNOWN_KEYS.size } as never);
+		return result(lines.join("\n"), {
+			...OK,
+			count: KNOWN_KEYS.size,
+		} as never);
 	}
 
 	// team-settings paths — show all config file paths
 	if (args === "path" || args === "paths") {
-		const lines = [
-			"pi-crew config paths:",
-			`  User config:     ${loaded.path}`,
-		];
+		const lines = ["pi-crew config paths:", `  User config:     ${loaded.path}`];
 		if (ctx.cwd && loaded.paths) {
 			for (const p of loaded.paths) {
 				if (p !== loaded.path) lines.push(`  Additional:      ${p}`);
@@ -337,7 +338,9 @@ export function handleSettings(params: { config?: Record<string, unknown> }, ctx
 	if (args === "theme" || args.startsWith("theme ")) {
 		const name = args === "theme" ? "" : args.slice(6).trim();
 		if (!name) {
-			const available = discoverPiThemes().map((t) => t.name).join(", ");
+			const available = discoverPiThemes()
+				.map((t) => t.name)
+				.join(", ");
 			return result(
 				`Usage: team-settings theme <name>\n\nAvailable Pi themes: ${available}\n\nBrowse all: team-settings themes`,
 				{ ...ERR },
@@ -356,14 +359,10 @@ export function handleSettings(params: { config?: Record<string, unknown> }, ctx
 		}
 		try {
 			const savedTo = setPiTheme(name);
-			return result(
-				[
-					`✓ Pi theme set to '${name}'`,
-					`  Written to: ${savedTo}`,
-					`  Applied live — no restart needed.`,
-				].join("\n"),
-				{ ...OK, theme: name } as never,
-			);
+			return result([`✓ Pi theme set to '${name}'`, `  Written to: ${savedTo}`, `  Applied live — no restart needed.`].join("\n"), {
+				...OK,
+				theme: name,
+			} as never);
 		} catch (error) {
 			return result(error instanceof Error ? error.message : String(error), { ...ERR }, true);
 		}
@@ -382,23 +381,29 @@ export function handleSettings(params: { config?: Record<string, unknown> }, ctx
 	if (args === "scope" || args.startsWith("scope ")) {
 		const scopeArg = args === "scope" ? "" : args.slice(6).trim();
 		if (!scopeArg) {
-			return result([
-				`Current write scope: ${scope}`,
-				`  user    → writes to ${loaded.path}`,
-				`  project → writes to ${projectConfigPath(ctx.cwd)}`,
-				"Usage: team-settings scope [user|project]",
-			].join("\n"), { ...OK, scope } as never);
+			return result(
+				[
+					`Current write scope: ${scope}`,
+					`  user    → writes to ${loaded.path}`,
+					`  project → writes to ${projectConfigPath(ctx.cwd)}`,
+					"Usage: team-settings scope [user|project]",
+				].join("\n"),
+				{ ...OK, scope } as never,
+			);
 		}
 		if (scopeArg !== "user" && scopeArg !== "project") {
 			return result("Scope must be 'user' or 'project'.", { ...ERR }, true);
 		}
-		return result([
-			`Write scope is a per-command option. Use:`,
-			`  team-settings set <key> <value>  (writes to ${scopeArg === "project" ? "project" : "user"} config)`,
-			``,
-			`To change scope for a single command, pass scope in the team tool:`,
-			`  team(action="settings", config={ args: "set <key> <value>", scope: "${scopeArg}" })`,
-		].join("\n"), { ...OK } as never);
+		return result(
+			[
+				`Write scope is a per-command option. Use:`,
+				`  team-settings set <key> <value>  (writes to ${scopeArg === "project" ? "project" : "user"} config)`,
+				``,
+				`To change scope for a single command, pass scope in the team tool:`,
+				`  team(action="settings", config={ args: "set <key> <value>", scope: "${scopeArg}" })`,
+			].join("\n"),
+			{ ...OK } as never,
+		);
 	}
 
 	// team-settings get <key>
@@ -413,7 +418,11 @@ export function handleSettings(params: { config?: Record<string, unknown> }, ctx
 			if (suggestion) note = `\n(did you mean '${suggestion}'?)`;
 			else note = "\n(unknown key — may not take effect)";
 		}
-		return result(`${key} = ${formatValue(value, key)}${note}`, { ...OK, key, value } as never);
+		return result(`${key} = ${formatValue(value, key)}${note}`, {
+			...OK,
+			key,
+			value,
+		} as never);
 	}
 
 	// team-settings unset <key>
@@ -422,7 +431,10 @@ export function handleSettings(params: { config?: Record<string, unknown> }, ctx
 		if (!key) return result("Usage: team-settings unset <key>", { ...ERR }, true);
 		try {
 			const saved = updateConfig({}, { cwd: ctx.cwd, scope, unsetPaths: [key] });
-			return result(`Unset ${key}\nSaved to: ${saved.path}`, { ...OK, key } as never);
+			return result(`Unset ${key}\nSaved to: ${saved.path}`, {
+				...OK,
+				key,
+			} as never);
 		} catch (error) {
 			return result(error instanceof Error ? error.message : String(error), { ...ERR }, true);
 		}
@@ -432,7 +444,12 @@ export function handleSettings(params: { config?: Record<string, unknown> }, ctx
 	if (args.startsWith("set ")) {
 		const rest = args.slice(4).trim();
 		const spaceIdx = rest.indexOf(" ");
-		if (spaceIdx === -1) return result("Usage: team-settings set <key> <value>\nExample: team-settings set runtime.mode child-process", { ...ERR }, true);
+		if (spaceIdx === -1)
+			return result(
+				"Usage: team-settings set <key> <value>\nExample: team-settings set runtime.mode child-process",
+				{ ...ERR },
+				true,
+			);
 		const key = rest.slice(0, spaceIdx);
 		const rawValue = rest.slice(spaceIdx + 1).trim();
 		if (!key) return result("Usage: team-settings set <key> <value>", { ...ERR }, true);
@@ -450,23 +467,44 @@ export function handleSettings(params: { config?: Record<string, unknown> }, ctx
 			let warning = "";
 			if (!KNOWN_KEYS.has(key) && !key.startsWith("agents.overrides.") && !key.startsWith("ui.")) {
 				const suggestion = suggestConfigKey(key, KNOWN_SORTED);
-				warning = suggestion ? `\nWarning: unknown key. Did you mean '${suggestion}'?` : "\nWarning: unknown key — verify it exists in config schema.";
+				warning = suggestion
+					? `\nWarning: unknown key. Did you mean '${suggestion}'?`
+					: "\nWarning: unknown key — verify it exists in config schema.";
 			}
 
 			// Check if project config would sanitize this key
 			if (scope === "project") {
-				const sensitiveKeys = ["executeWorkers", "asyncByDefault", "runtime.mode", "runtime.preferLiveSession", "runtime.allowChildProcessFallback", "runtime.inheritContext", "runtime.isolationPolicy", "autonomous.profile", "autonomous.enabled", "autonomous.injectPolicy", "agents.overrides", "agents.disableBuiltins"];
-				if (sensitiveKeys.some(k => key === k || key.startsWith(k + "."))) {
-					warning += "\nNote: this key is sensitive and will be ignored in project-level config for security. Set it in user scope instead.";
+				const sensitiveKeys = [
+					"executeWorkers",
+					"asyncByDefault",
+					"runtime.mode",
+					"runtime.preferLiveSession",
+					"runtime.allowChildProcessFallback",
+					"runtime.inheritContext",
+					"runtime.isolationPolicy",
+					"autonomous.profile",
+					"autonomous.enabled",
+					"autonomous.injectPolicy",
+					"agents.overrides",
+					"agents.disableBuiltins",
+				];
+				if (sensitiveKeys.some((k) => key === k || key.startsWith(k + "."))) {
+					warning +=
+						"\nNote: this key is sensitive and will be ignored in project-level config for security. Set it in user scope instead.";
 				}
 			}
 
-			return result([
-				`Set ${key} = ${formatValue(value, key)}`,
-				`Effective: ${formatValue(effectiveValue, key)}`,
-				`Saved to: ${saved.path}`,
-				warning,
-			].filter(Boolean).join("\n"), { ...OK, key, value } as never);
+			return result(
+				[
+					`Set ${key} = ${formatValue(value, key)}`,
+					`Effective: ${formatValue(effectiveValue, key)}`,
+					`Saved to: ${saved.path}`,
+					warning,
+				]
+					.filter(Boolean)
+					.join("\n"),
+				{ ...OK, key, value } as never,
+			);
 		} catch (error) {
 			return result(error instanceof Error ? error.message : String(error), { ...ERR }, true);
 		}

package/src/extension/team-tool/health-monitor.ts

@@ -4,17 +4,13 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { listRuns } from "../run-index.ts";
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
-import {
-	isActiveRunStatus,
-	hasStaleAsyncProcess,
-	isLikelyOrphanedActiveRun,
-} from "../../runtime/process-status.ts";
-import { result, type TeamContext } from "./context.ts";
+import { hasStaleAsyncProcess, isActiveRunStatus, isLikelyOrphanedActiveRun } from "../../runtime/process-status.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import type { PiTeamsToolResult } from "../tool-result.ts";
 import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+import { listRuns } from "../run-index.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { result, type TeamContext } from "./context.ts";
 
 // ── Types ────────────────────────────────────────────────────────────
 
@@ -69,9 +65,7 @@ export const STUCK_TASK_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
 function readRunTasks(stateRoot: string): TeamTaskState[] {
 	const tasksPath = path.join(stateRoot, "tasks.json");
 	try {
-		return JSON.parse(
-			fs.readFileSync(tasksPath, "utf-8"),
-		) as TeamTaskState[];
+		return JSON.parse(fs.readFileSync(tasksPath, "utf-8")) as TeamTaskState[];
 	} catch {
 		return [];
 	}
@@ -81,10 +75,7 @@ function readRunTasks(stateRoot: string): TeamTaskState[] {
  * Detect "stuck" tasks: tasks with status "running" whose last heartbeat or
  * activity timestamp is older than STUCK_TASK_THRESHOLD_MS.
  */
-export function detectStuckTasks(
-	run: { runId: string; stateRoot: string },
-	now: number,
-): StuckTask[] {
+export function detectStuckTasks(run: { runId: string; stateRoot: string }, now: number): StuckTask[] {
 	const tasks = readRunTasks(run.stateRoot);
 	const stuck: StuckTask[] = [];
 
@@ -92,23 +83,14 @@ export function detectStuckTasks(
 		if (task.status !== "running") continue;
 
 		// Check agentProgress.lastActivityAt first, then heartbeat.lastSeenAt, then startedAt
-		const activityAt = task.agentProgress?.lastActivityAt
-			? new Date(task.agentProgress.lastActivityAt).getTime()
-			: Number.NaN;
-		const heartbeatAt = task.heartbeat?.lastSeenAt
-			? new Date(task.heartbeat.lastSeenAt).getTime()
-			: Number.NaN;
-		const startedAt = task.startedAt
-			? new Date(task.startedAt).getTime()
-			: Number.NaN;
+		const activityAt = task.agentProgress?.lastActivityAt ? new Date(task.agentProgress.lastActivityAt).getTime() : Number.NaN;
+		const heartbeatAt = task.heartbeat?.lastSeenAt ? new Date(task.heartbeat.lastSeenAt).getTime() : Number.NaN;
+		const startedAt = task.startedAt ? new Date(task.startedAt).getTime() : Number.NaN;
 
 		// Use the most recent valid timestamp
 		let latest = Number.NaN;
 		for (const ts of [activityAt, heartbeatAt, startedAt]) {
-			if (
-				Number.isFinite(ts) &&
-				(!Number.isFinite(latest) || ts > latest)
-			) {
+			if (Number.isFinite(ts) && (!Number.isFinite(latest) || ts > latest)) {
 				latest = ts;
 			}
 		}
@@ -135,40 +117,25 @@ export function detectStuckTasks(
  * Read-only — does NOT mutate anything.
  * Pattern adapted from stale-reconciler.ts:reconcileOrphanedTempWorkspaces().
  */
-export function scanZombieTempWorkspaces(
-	tmpDir: string,
-	now: number,
-): ZombieWorkspace[] {
+export function scanZombieTempWorkspaces(tmpDir: string, now: number): ZombieWorkspace[] {
 	if (!tmpDir || !fs.existsSync(tmpDir)) return [];
 	const zombies: ZombieWorkspace[] = [];
 
 	try {
 		const entries = fs.readdirSync(tmpDir, { withFileTypes: true });
 		for (const entry of entries) {
-			if (!entry.isDirectory() || !entry.name.startsWith("pi-crew-"))
-				continue;
+			if (!entry.isDirectory() || !entry.name.startsWith("pi-crew-")) continue;
 			const workspaceDir = path.join(tmpDir, entry.name);
-			const stateRunsDir = path.join(
-				workspaceDir,
-				".crew",
-				"state",
-				"runs",
-			);
+			const stateRunsDir = path.join(workspaceDir, ".crew", "state", "runs");
 			if (!fs.existsSync(stateRunsDir)) continue;
 
 			let runCount = 0;
 			try {
 				for (const runDir of fs.readdirSync(stateRunsDir)) {
-					const manifestPath = path.join(
-						stateRunsDir,
-						runDir,
-						"manifest.json",
-					);
+					const manifestPath = path.join(stateRunsDir, runDir, "manifest.json");
 					if (fs.existsSync(manifestPath)) {
 						try {
-							const manifest = JSON.parse(
-								fs.readFileSync(manifestPath, "utf-8"),
-							) as { runId?: string; status?: string };
+							const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8")) as { runId?: string; status?: string };
 							if (manifest.runId) runCount++;
 						} catch {
 							/* skip corrupt manifest */
@@ -224,29 +191,16 @@ export function collectTempWorkspaceRuns(
 	try {
 		const entries = fs.readdirSync(tmpDir, { withFileTypes: true });
 		for (const entry of entries) {
-			if (!entry.isDirectory() || !entry.name.startsWith("pi-crew-"))
-				continue;
-			const stateRunsDir = path.join(
-				tmpDir,
-				entry.name,
-				".crew",
-				"state",
-				"runs",
-			);
+			if (!entry.isDirectory() || !entry.name.startsWith("pi-crew-")) continue;
+			const stateRunsDir = path.join(tmpDir, entry.name, ".crew", "state", "runs");
 			if (!fs.existsSync(stateRunsDir)) continue;
 
 			try {
 				for (const runDir of fs.readdirSync(stateRunsDir)) {
-					const manifestPath = path.join(
-						stateRunsDir,
-						runDir,
-						"manifest.json",
-					);
+					const manifestPath = path.join(stateRunsDir, runDir, "manifest.json");
 					if (!fs.existsSync(manifestPath)) continue;
 					try {
-						const manifest = JSON.parse(
-							fs.readFileSync(manifestPath, "utf-8"),
-						) as {
+						const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8")) as {
 							runId?: string;
 							status?: string;
 							cwd?: string;
@@ -256,15 +210,8 @@ export function collectTempWorkspaceRuns(
 							updatedAt?: string;
 							summary?: string;
 						};
-						if (!manifest.runId || primaryIds.has(manifest.runId))
-							continue;
-						if (
-							manifest.status &&
-							manifest.cwd &&
-							manifest.stateRoot &&
-							manifest.artifactsRoot &&
-							manifest.updatedAt
-						) {
+						if (!manifest.runId || primaryIds.has(manifest.runId)) continue;
+						if (manifest.status && manifest.cwd && manifest.stateRoot && manifest.artifactsRoot && manifest.updatedAt) {
 							runs.push({
 								runId: manifest.runId!,
 								status: manifest.status,
@@ -296,18 +243,7 @@ export function collectTempWorkspaceRuns(
  */
 export function countStatuses(
 	runs: Array<{ status: string }>,
-): Pick<
-	HealthCounts,
-	| "total"
-	| "running"
-	| "completed"
-	| "failed"
-	| "cancelled"
-	| "blocked"
-	| "queued"
-	| "planning"
-	| "waiting"
-> {
+): Pick<HealthCounts, "total" | "running" | "completed" | "failed" | "cancelled" | "blocked" | "queued" | "planning" | "waiting"> {
 	const counts = {
 		total: runs.length,
 		running: 0,
@@ -392,11 +328,7 @@ export function buildHealthReport(
 
 	for (const run of allRuns) {
 		// 1. Ghost: active status but cwd no longer exists
-		if (
-			isActiveRunStatus(run.status) &&
-			run.cwd &&
-			!fs.existsSync(run.cwd)
-		) {
+		if (isActiveRunStatus(run.status) && run.cwd && !fs.existsSync(run.cwd)) {
 			ghost.push({
 				runId: run.runId,
 				reason: "dead-cwd",
@@ -406,10 +338,7 @@ export function buildHealthReport(
 		}
 
 		// 2. Corrupted: state root or artifacts root missing
-		if (
-			!fs.existsSync(run.stateRoot) ||
-			!fs.existsSync(run.artifactsRoot)
-		) {
+		if (!fs.existsSync(run.stateRoot) || !fs.existsSync(run.artifactsRoot)) {
 			corrupted.push({
 				runId: run.runId,
 				reason: "missing-state-or-artifacts",
@@ -514,19 +443,12 @@ export function buildHealthReport(
 	if (zombieWorkspaces.length > 0) {
 		lines.push("Zombie /tmp/ workspaces:");
 		for (const z of zombieWorkspaces) {
-			lines.push(
-				`  - ${z.dir} (${z.runCount} run${z.runCount !== 1 ? "s" : ""})`,
-			);
+			lines.push(`  - ${z.dir} (${z.runCount} run${z.runCount !== 1 ? "s" : ""})`);
 		}
 		lines.push("");
 	}
 
-	const hasIssues =
-		ghost.length > 0 ||
-		orphaned.length > 0 ||
-		corrupted.length > 0 ||
-		allStuck.length > 0 ||
-		zombieWorkspaces.length > 0;
+	const hasIssues = ghost.length > 0 || orphaned.length > 0 || corrupted.length > 0 || allStuck.length > 0 || zombieWorkspaces.length > 0;
 
 	if (!hasIssues) {
 		lines.push("All runs healthy.");
@@ -544,10 +466,7 @@ export function buildHealthReport(
 
 // ── Main handler ─────────────────────────────────────────────────────
 
-export function handleHealthMonitor(
-	ctx: TeamContext,
-	params: TeamToolParamsValue,
-): PiTeamsToolResult {
+export function handleHealthMonitor(ctx: TeamContext, params: TeamToolParamsValue): PiTeamsToolResult {
 	const { text, counts, hasIssues } = buildHealthReport(ctx, params);
 
 	return result(

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

@@ -1,12 +1,12 @@
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { readEvents } from "../../state/event-log.ts";
 import { loadRunManifestById } from "../../state/state-store.ts";
-import { aggregateUsage, formatUsage, formatCostReport } from "../../state/usage.ts";
-import type { PiTeamsToolResult } from "../tool-result.ts";
+import { aggregateUsage, formatCostReport, formatUsage } from "../../state/usage.ts";
 import { locateRunCwd } from "../team-tool.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
 import { result, type TeamContext } from "./context.ts";
-import { RUN_NOT_FOUND_HINT } from "./run-not-found.ts";
 import { formatFailurePatterns } from "./failure-patterns.ts";
+import { RUN_NOT_FOUND_HINT } from "./run-not-found.ts";
 
 export function handleEvents(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
 	if (!params.runId) return result("Events requires runId.", { action: "events", status: "error" }, true);
@@ -15,8 +15,21 @@ export function handleEvents(params: TeamToolParamsValue, ctx: TeamContext): PiT
 	const loaded = loadRunManifestById(runCwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "events", status: "error" }, true);
 	const events = readEvents(loaded.manifest.eventsPath);
-	const lines = [`Events for ${loaded.manifest.runId}:`, ...(events.length ? events.map((event) => `${event.time} ${event.type}${event.taskId ? ` ${event.taskId}` : ""}${event.message ? `: ${event.message}` : ""}${event.data ? ` ${JSON.stringify(event.data)}` : ""}`) : ["(none)"])];
-	return result(lines.join("\n"), { action: "events", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	const lines = [
+		`Events for ${loaded.manifest.runId}:`,
+		...(events.length
+			? events.map(
+					(event) =>
+						`${event.time} ${event.type}${event.taskId ? ` ${event.taskId}` : ""}${event.message ? `: ${event.message}` : ""}${event.data ? ` ${JSON.stringify(event.data)}` : ""}`,
+				)
+			: ["(none)"]),
+	];
+	return result(lines.join("\n"), {
+		action: "events",
+		status: "ok",
+		runId: loaded.manifest.runId,
+		artifactsRoot: loaded.manifest.artifactsRoot,
+	});
 }
 
 export function handleArtifacts(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
@@ -25,8 +38,21 @@ export function handleArtifacts(params: TeamToolParamsValue, ctx: TeamContext):
 	if (!runCwd) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "artifacts", status: "error" }, true);
 	const loaded = loadRunManifestById(runCwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "artifacts", status: "error" }, true);
-	const lines = [`Artifacts for ${loaded.manifest.runId}:`, ...(loaded.manifest.artifacts.length ? loaded.manifest.artifacts.map((artifact) => `- ${artifact.kind}: ${artifact.path}${artifact.sizeBytes !== undefined ? ` (${artifact.sizeBytes} bytes)` : ""}${artifact.contentHash ? ` sha256=${artifact.contentHash.slice(0, 12)}` : ""}`) : ["- (none)"])];
-	return result(lines.join("\n"), { action: "artifacts", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	const lines = [
+		`Artifacts for ${loaded.manifest.runId}:`,
+		...(loaded.manifest.artifacts.length
+			? loaded.manifest.artifacts.map(
+					(artifact) =>
+						`- ${artifact.kind}: ${artifact.path}${artifact.sizeBytes !== undefined ? ` (${artifact.sizeBytes} bytes)` : ""}${artifact.contentHash ? ` sha256=${artifact.contentHash.slice(0, 12)}` : ""}`,
+				)
+			: ["- (none)"]),
+	];
+	return result(lines.join("\n"), {
+		action: "artifacts",
+		status: "ok",
+		runId: loaded.manifest.runId,
+		artifactsRoot: loaded.manifest.artifactsRoot,
+	});
 }
 
 export function handleSummary(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
@@ -49,7 +75,14 @@ export function handleSummary(params: TeamToolParamsValue, ctx: TeamContext): Pi
 		...(failurePatternLines.length > 0 ? ["", ...failurePatternLines] : []),
 		"",
 		"Tasks:",
-		...loaded.tasks.map((task) => `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.error ? ` - ${task.error}` : ""}`),
+		...loaded.tasks.map(
+			(task) => `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.error ? ` - ${task.error}` : ""}`,
+		),
 	];
-	return result(lines.join("\n"), { action: "summary", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	return result(lines.join("\n"), {
+		action: "summary",
+		status: "ok",
+		runId: loaded.manifest.runId,
+		artifactsRoot: loaded.manifest.artifactsRoot,
+	});
 }

package/src/extension/team-tool/intent-policy.ts

@@ -36,7 +36,10 @@ export function enforceDestructiveIntent(
 	const label = DESTRUCTIVE_ACTION_LABELS[action];
 	return result(
 		`Destructive action '${label}' requires config.intent when policy.requireIntentForDestructiveActions is enabled.`,
-		{ action: action === "delete" ? "management" : action, status: "error" },
+		{
+			action: action === "delete" ? "management" : action,
+			status: "error",
+		},
 		true,
 	);
 }