pi-crew 0.1.39 → 0.1.41

package/src/extension/result-watcher.ts

@@ -22,9 +22,16 @@ interface ResultWatcherDependencies {
 export interface ResultWatcherOptions extends ResultWatcherDependencies {
 	eventName?: string;
 	completionTtlMs?: number;
+	isCurrent?: () => boolean;
 }
 
 const RESULT_WATCHER_RESTART_MS = 3000;
+const RESULT_WATCHER_POLL_MS = 1000;
+
+function shouldFallBackToPolling(error: unknown): boolean {
+	const code = error && typeof error === "object" ? (error as { code?: unknown }).code : undefined;
+	return code === "EMFILE" || code === "ENOSPC" || code === "EPERM";
+}
 
 function readJson(filePath: string): unknown | undefined {
 	try {
@@ -40,18 +47,23 @@ export function createResultWatcher(events: ResultWatcherEvents, resultsDir: str
 	const eventName = options.eventName ?? "pi-crew:run-result";
 	const completionTtlMs = options.completionTtlMs ?? 5 * 60_000;
 	const watch = options.watch ?? watchWithErrorHandler;
+	const isCurrent = options.isCurrent ?? (() => true);
 	const seen = getGlobalSeenMap("pi-crew.result-watcher");
 	let watcher: fs.FSWatcher | null | undefined;
 	let restartTimer: ReturnType<typeof setTimeout> | undefined;
+	let pollTimer: ReturnType<typeof setInterval> | undefined;
 	const coalescer = createFileCoalescer((file) => {
+		if (!isCurrent()) return;
 		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);
-			}
+		if (payload === undefined) {
+			coalescer.schedule(file, RESULT_WATCHER_POLL_MS);
+			return;
+		}
+		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);
@@ -59,11 +71,27 @@ export function createResultWatcher(events: ResultWatcherEvents, resultsDir: str
 			logInternalError("result-watcher.unlink", error, `filePath=${filePath}`);
 		}
 	}, 50);
-	const scheduleRestart = () => {
+	const poll = () => {
+		if (!isCurrent() || !fs.existsSync(resultsDir)) return;
+		for (const file of fs.readdirSync(resultsDir).filter((entry) => entry.endsWith(".json"))) coalescer.schedule(file, 0);
+	};
+	const startPolling = () => {
+		if (pollTimer) return;
+		pollTimer = setInterval(poll, RESULT_WATCHER_POLL_MS);
+		pollTimer.unref?.();
+		poll();
+	};
+	const stopPolling = () => {
+		if (pollTimer) clearInterval(pollTimer);
+		pollTimer = undefined;
+	};
+	const scheduleRestart = (error?: unknown) => {
+		if (shouldFallBackToPolling(error)) startPolling();
 		if (restartTimer) clearTimeout(restartTimer);
 		restartTimer = setTimeout(() => {
 			restartTimer = undefined;
 			try {
+				if (!isCurrent()) return;
 				fs.mkdirSync(resultsDir, { recursive: true });
 				handle.start();
 			} catch (error) {
@@ -74,23 +102,25 @@ export function createResultWatcher(events: ResultWatcherEvents, resultsDir: str
 	};
 	const handle: ResultWatcherHandle = {
 		start() {
+			if (!isCurrent()) return;
 			fs.mkdirSync(resultsDir, { recursive: true });
 			if (watcher) closeWatcher(watcher);
 			watcher = watch(resultsDir, (event, fileName) => {
 				if (event !== "rename" || !fileName) return;
 				coalescer.schedule(fileName.toString());
 			}, scheduleRestart);
+			if (watcher) stopPolling();
 			watcher?.unref?.();
 		},
 		prime() {
-			if (!fs.existsSync(resultsDir)) return;
-			for (const file of fs.readdirSync(resultsDir).filter((entry) => entry.endsWith(".json"))) coalescer.schedule(file, 0);
+			poll();
 		},
 		stop() {
 			if (restartTimer) clearTimeout(restartTimer);
 			restartTimer = undefined;
 			closeWatcher(watcher);
 			watcher = undefined;
+			stopPolling();
 			coalescer.clear();
 		},
 	};

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

@@ -1,14 +1,15 @@
 import * as fs from "node:fs";
 import { loadConfig } from "../../config/config.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import { saveRunTasks, loadRunManifestById } from "../../state/state-store.ts";
+import { loadRunManifestById, saveRunManifest, saveRunTasks, updateRunStatus } from "../../state/state-store.ts";
 import { withRunLockSync } from "../../state/locks.ts";
 import { canTransitionTaskStatus, isTeamTaskStatus } from "../../state/contracts.ts";
 import { claimTask, releaseTaskClaim, transitionClaimedTaskStatus } from "../../state/task-claims.ts";
-import { acknowledgeMailboxMessage, appendMailboxMessage, readDeliveryState, readMailbox, validateMailbox, type MailboxDirection } from "../../state/mailbox.ts";
+import { acknowledgeMailboxMessage, appendMailboxMessage, readDeliveryState, readMailbox, readMailboxMessage, validateMailbox, type MailboxDirection } 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";
+import { currentCrewRole, permissionForRole } from "../../runtime/role-permission.ts";
 import { touchWorkerHeartbeat } from "../../runtime/worker-heartbeat.ts";
 import { agentOutputPath, readCrewAgentEventsCursor, readCrewAgentStatus, readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import { buildAgentDashboard, readAgentOutput } from "../../runtime/agent-observability.ts";
@@ -54,6 +55,13 @@ function snapshotHasRunId(snapshot: { values?: unknown }, runId: string): boolea
 	});
 }
 
+function canApprovePlan(): { allowed: boolean; reason?: string } {
+	const role = currentCrewRole();
+	if (!role) return { allowed: true };
+	if (permissionForRole(role) === "read_only") return { allowed: false, reason: `Role '${role}' is read-only and cannot approve or cancel plan gates.` };
+	return { allowed: true };
+}
+
 export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
 	const cfg = configRecord(params.config);
 	const operation = typeof cfg.operation === "string" ? cfg.operation : "read-manifest";
@@ -74,6 +82,47 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 	if (operation === "read-manifest") {
 		return result(JSON.stringify(loaded.manifest, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
 	}
+	if (operation === "approve-plan") {
+		const permission = canApprovePlan();
+		if (!permission.allowed) return result(permission.reason ?? "Plan approval is not allowed in this context.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+		try {
+			return withRunLockSync(loaded.manifest, () => {
+				const current = loadRunManifestById(ctx.cwd, loaded.manifest.runId) ?? loaded;
+				const approval = current.manifest.planApproval;
+				if (!approval?.required || approval.status !== "pending") return result("Run has no pending plan approval request.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+				const now = new Date().toISOString();
+				const manifest = { ...current.manifest, updatedAt: now, planApproval: { ...approval, status: "approved" as const, approvedAt: now, updatedAt: now } };
+				saveRunManifest(manifest);
+				appendEvent(manifest.eventsPath, { type: "plan.approved", runId: manifest.runId, taskId: approval.planTaskId, message: "Adaptive implementation plan approved; resume the run to execute mutating tasks.", metadata: { provenance: "api" } });
+				return result(JSON.stringify(manifest.planApproval, null, 2), { action: "api", status: "ok", runId: manifest.runId, artifactsRoot: 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);
+		}
+	}
+	if (operation === "cancel-plan") {
+		const permission = canApprovePlan();
+		if (!permission.allowed) return result(permission.reason ?? "Plan approval cancellation is not allowed in this context.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+		try {
+			return withRunLockSync(loaded.manifest, () => {
+				const current = loadRunManifestById(ctx.cwd, loaded.manifest.runId) ?? loaded;
+				const approval = current.manifest.planApproval;
+				if (!approval?.required || approval.status !== "pending") return result("Run has no pending plan approval request.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+				const now = new Date().toISOString();
+				const tasks = current.tasks.map((task) => task.status === "queued" || task.status === "running" ? { ...task, status: "cancelled" as const, finishedAt: now, error: "Plan approval was cancelled." } : task);
+				let manifest: typeof current.manifest = { ...current.manifest, updatedAt: now, planApproval: { ...approval, status: "cancelled" as const, cancelledAt: now, updatedAt: now } };
+				saveRunManifest(manifest);
+				saveRunTasks(manifest, tasks);
+				appendEvent(manifest.eventsPath, { type: "plan.cancelled", runId: manifest.runId, taskId: approval.planTaskId, message: "Adaptive implementation plan was cancelled.", metadata: { provenance: "api" } });
+				manifest = updateRunStatus(manifest, "cancelled", "Plan approval was cancelled.");
+				return result(JSON.stringify({ planApproval: manifest.planApproval, cancelledTasks: tasks.filter((task) => task.status === "cancelled").map((task) => task.id) }, null, 2), { action: "api", status: "ok", runId: manifest.runId, artifactsRoot: manifest.artifactsRoot });
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return result(message, { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+		}
+	}
 	if (operation === "list-tasks") {
 		return result(JSON.stringify(loaded.tasks, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
 	}
@@ -249,8 +298,18 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 		if (!messageId) return result("API ack-message requires config.messageId.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
 		try {
 			return withRunLockSync(loaded.manifest, () => {
+				const message = readMailboxMessage(loaded.manifest, messageId);
 				const delivery = acknowledgeMailboxMessage(loaded.manifest, messageId);
 				appendEvent(loaded.manifest.eventsPath, { type: "mailbox.acknowledged", runId: loaded.manifest.runId, data: { messageId } });
+				if (message?.data?.kind === "group_join" && typeof message.data.requestId === "string") {
+					appendEvent(loaded.manifest.eventsPath, {
+						type: "agent.group_join.acknowledged",
+						runId: loaded.manifest.runId,
+						message: "Group join delivery acknowledged via mailbox ack.",
+						data: { requestId: message.data.requestId, messageId, batchId: message.data.batchId, partial: message.data.partial, acknowledgedAt: delivery.updatedAt, acknowledgedBy: "leader" },
+						metadata: { provenance: "api" },
+					});
+				}
 				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 });
 			});

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

@@ -10,6 +10,7 @@ import { DEFAULT_PATHS } from "../../config/defaults.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { getPiSpawnCommand } from "../../runtime/pi-spawn.ts";
 import { validateResources } from "../validate-resources.ts";
+import { TeamToolParams } from "../../schema/team-tool-schema.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { configRecord, result, type TeamContext } from "./context.ts";
 
@@ -59,6 +60,24 @@ function checkWritableDir(dir: string): { ok: boolean; detail: string } {
 	}
 }
 
+function auditJsonSchema(schema: unknown): string[] {
+	const issues: string[] = [];
+	const walk = (node: unknown): void => {
+		if (!node || typeof node !== "object" || Array.isArray(node)) return;
+		const record = node as Record<string, unknown>;
+		if (Array.isArray(record.type)) issues.push("schema node uses array-valued type");
+		if (record.description && !record.type && !record.anyOf && !record.oneOf && !record.allOf && !record.properties) issues.push(`description-only schema node: ${record.description}`);
+		if (record.type === "array" && !record.items) issues.push("array schema missing items");
+		if (record.type && (record.anyOf || record.oneOf)) issues.push("schema node combines type with union keyword");
+		for (const value of Object.values(record)) {
+			if (Array.isArray(value)) for (const item of value) walk(item);
+			else walk(value);
+		}
+	};
+	walk(schema);
+	return issues;
+}
+
 function makeLine(check: DoctorCheck): string {
 	return `- ${check.ok ? "OK" : "FAIL"} ${check.label}: ${check.detail}`;
 }
@@ -130,6 +149,18 @@ export function buildTeamDoctorReport(input: TeamDoctorReportInput): TeamDoctorR
 			ok: input.validationErrors === 0,
 			detail: `${input.validationErrors} errors, ${input.validationWarnings} warnings`,
 		}]),
+		section("Schema", () => {
+			const schemaIssues = auditJsonSchema(TeamToolParams);
+			return [{ label: "strict-provider schema", ok: schemaIssues.length === 0, detail: schemaIssues.length ? schemaIssues.slice(0, 3).join("; ") : "team tool schema compatible" }];
+		}),
+		section("Async/result delivery", () => [
+			{ label: "result watcher", ok: true, detail: "fs.watch with polling fallback for EMFILE/ENOSPC/EPERM" },
+			{ label: "async notifier", ok: true, detail: "session-stale guarded completion notifications enabled" },
+		]),
+		section("Worktrees", () => [
+			{ label: "leader repository", ok: true, detail: input.cwd },
+			{ label: "cleanup policy", ok: true, detail: "dirty worktrees preserved unless force is set" },
+		]),
 	];
 	if (input.smokeChildPi) {
 		sections.push([`Child check`, `- ${input.smokeChildPi.ok ? "OK" : "FAIL"} child Pi smoke: ${input.smokeChildPi.detail}`]);

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

@@ -1,6 +1,7 @@
 import { loadConfig } from "../../config/config.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { appendEvent, readEvents } from "../../state/event-log.ts";
+import { readDeliveryState, readMailbox } from "../../state/mailbox.ts";
 import { loadRunManifestById, updateRunStatus } from "../../state/state-store.ts";
 import { aggregateUsage, formatUsage } from "../../state/usage.ts";
 import { applyAttentionState, formatActivityAge, resolveCrewControlConfig } from "../../runtime/agent-control.ts";
@@ -27,15 +28,32 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 	}
 	const counts = new Map<string, number>();
 	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
-	const events = readEvents(manifest.eventsPath).slice(-8);
+	const allEvents = readEvents(manifest.eventsPath);
+	const events = allEvents.slice(-8);
+	const attentionByTask = new Map(allEvents.filter((event) => event.type === "task.attention" && event.taskId).map((event) => [event.taskId!, event]));
 	const controlConfig = resolveCrewControlConfig(loadConfig(ctx.cwd).config);
 	const crewAgents = readCrewAgents(manifest).map((agent) => applyAttentionState(manifest, agent, controlConfig));
 	const artifactLines = manifest.artifacts.slice(-10).map((artifact) => `- ${artifact.kind}: ${artifact.path}${artifact.sizeBytes !== undefined ? ` (${artifact.sizeBytes} bytes)` : ""}`);
+	const deliveryState = readDeliveryState(manifest);
+	const ackTimeoutMs = loadConfig(ctx.cwd).config.runtime?.groupJoinAckTimeoutMs;
+	const groupJoinLines = readMailbox(manifest, "outbox")
+		.filter((message) => message.data?.kind === "group_join")
+		.slice(-5)
+		.map((message) => {
+			const ack = deliveryState.messages[message.id] === "acknowledged" ? "acknowledged" : "pending";
+			const ageMs = Date.now() - new Date(message.createdAt).getTime();
+			const requestId = String(message.data?.requestId ?? "unknown");
+			const timedOut = ack === "pending" && ackTimeoutMs !== undefined && Number.isFinite(ageMs) && ageMs > ackTimeoutMs;
+			if (timedOut && !allEvents.some((event) => event.type === "agent.group_join.ack_timeout" && event.data?.requestId === requestId)) {
+				appendEvent(manifest.eventsPath, { type: "agent.group_join.ack_timeout", runId: manifest.runId, message: "Group join delivery ack timed out; mailbox delivery remains the fallback.", data: { requestId, messageId: message.id, batchId: message.data?.batchId, partial: message.data?.partial, ageMs, ackTimeoutMs } });
+			}
+			return `- ${String(message.data?.partial) === "true" ? "partial" : "completed"} request=${requestId} message=${message.id} ack=${timedOut ? "timeout" : ack}`;
+		});
 	const totalUsage = aggregateUsage(tasks);
 	const activeAgents = crewAgents.filter((agent) => agent.status === "running");
 	const completedAgents = crewAgents.filter((agent) => agent.status !== "running");
 	const waitingTasks = tasks.filter((task) => task.status === "queued");
-	const agentLine = (agent: typeof crewAgents[number]): string => `- ${agent.id} [${agent.status}] ${agent.role} -> ${agent.agent} runtime=${agent.runtime}${agent.model ? ` model=${agent.model}` : ""}${agent.usage ? ` usage=${formatUsage(agent.usage)}` : ""}${agent.progress?.activityState === "needs_attention" ? " needs_attention" : ""}${formatActivityAge(agent) ? ` activity=${formatActivityAge(agent)}` : ""}${agent.progress?.currentTool ? ` tool=${agent.progress.currentTool}` : ""}${agent.toolUses ? ` tools=${agent.toolUses}` : ""}${!agent.usage && agent.progress?.tokens ? ` tokens=${agent.progress.tokens}` : ""}${agent.progress?.turns ? ` turns=${agent.progress.turns}` : ""}${agent.jsonEvents !== undefined ? ` jsonEvents=${agent.jsonEvents}` : ""}${agent.statusPath ? ` status=${agent.statusPath}` : ""}${agent.error ? ` error=${agent.error}` : ""}`;
+	const agentLine = (agent: typeof crewAgents[number]): string => `- ${agent.id} [${agent.status}] ${agent.role} -> ${agent.agent} runtime=${agent.runtime}${agent.model ? ` model=${agent.model}` : ""}${agent.usage ? ` usage=${formatUsage(agent.usage)}` : ""}${agent.progress?.activityState ? ` activityState=${agent.progress.activityState}` : ""}${formatActivityAge(agent) ? ` activity=${formatActivityAge(agent)}` : ""}${agent.progress?.currentTool ? ` tool=${agent.progress.currentTool}` : ""}${agent.toolUses ? ` tools=${agent.toolUses}` : ""}${!agent.usage && agent.progress?.tokens ? ` tokens=${agent.progress.tokens}` : ""}${agent.progress?.turns ? ` turns=${agent.progress.turns}` : ""}${agent.jsonEvents !== undefined ? ` jsonEvents=${agent.jsonEvents}` : ""}${agent.outputPath ? ` output=${agent.outputPath}` : ""}${agent.transcriptPath ? ` transcript=${agent.transcriptPath}` : ""}${agent.statusPath ? ` status=${agent.statusPath}` : ""}${agent.error ? ` error=${agent.error}` : ""}`;
 	const lines = [
 		`Run: ${manifest.runId}`,
 		`Team: ${manifest.team}`,
@@ -51,7 +69,7 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 		"Task graph:",
 		...formatTaskGraphLines(tasks),
 		"Tasks:",
-		...(tasks.length ? tasks.map((task) => `- ${task.id} [${task.status}] ${task.role} -> ${task.agent}${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.modelAttempts?.length ? ` attempts=${task.modelAttempts.length}` : ""}${task.modelRouting ? ` modelRouting=${task.modelRouting.requested ? `${task.modelRouting.requested}->` : ""}${task.modelRouting.resolved}${task.modelRouting.usedAttempt ? ` attempt=${task.modelRouting.usedAttempt + 1}` : ""}` : ""}${task.jsonEvents !== undefined ? ` jsonEvents=${task.jsonEvents}` : ""}${task.usage ? ` usage=${JSON.stringify(task.usage)}` : ""}${task.worktree ? ` worktree=${task.worktree.path}` : ""}${task.error ? ` error=${task.error}` : ""}`) : ["- (none)"]),
+		...(tasks.length ? tasks.map((task) => `- ${task.id} [${task.status}] ${task.role} -> ${task.agent}${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.modelAttempts?.length ? ` attempts=${task.modelAttempts.length}` : ""}${task.modelRouting ? ` modelRouting=${task.modelRouting.requested ? `${task.modelRouting.requested}->` : ""}${task.modelRouting.resolved}${task.modelRouting.usedAttempt ? ` attempt=${task.modelRouting.usedAttempt + 1}` : ""}` : ""}${task.agentProgress?.activityState ? ` activityState=${task.agentProgress.activityState}` : ""}${attentionByTask.get(task.id)?.data?.reason ? ` attention=${String(attentionByTask.get(task.id)?.data?.reason)}` : ""}${task.jsonEvents !== undefined ? ` jsonEvents=${task.jsonEvents}` : ""}${task.usage ? ` usage=${JSON.stringify(task.usage)}` : ""}${task.resultArtifact ? ` result=${task.resultArtifact.path}` : ""}${task.transcriptArtifact ? ` transcript=${task.transcriptArtifact.path}` : ""}${task.worktree ? ` worktree=${task.worktree.path}` : ""}${task.error ? ` error=${task.error}` : ""}`) : ["- (none)"]),
 		`Task counts: ${[...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none"}`,
 		"Active agents:",
 		...(activeAgents.length ? activeAgents.map(agentLine) : ["- (none)"]),
@@ -62,6 +80,8 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 		"Policy decisions:",
 		...(manifest.policyDecisions?.length ? manifest.policyDecisions.map((item) => `- ${item.action} (${item.reason})${item.taskId ? ` ${item.taskId}` : ""}: ${item.message}`) : ["- (none)"]),
 		`Total usage: ${formatUsage(totalUsage)}`,
+		"Group joins:",
+		...(groupJoinLines.length ? groupJoinLines : ["- (none)"]),
 		"",
 		"Recent artifacts:",
 		...(artifactLines.length ? artifactLines : ["- (none)"]),

package/src/observability/metric-sink.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { redactSecrets } from "../runtime/diagnostic-export.ts";
+import { redactSecrets } from "../utils/redaction.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import type { MetricRegistry } from "./metric-registry.ts";
 import type { MetricSnapshot } from "./metrics-primitives.ts";

package/src/runtime/agent-control.ts

@@ -1,6 +1,6 @@
 import type { PiTeamsConfig } from "../config/config.ts";
 import type { TeamRunManifest } from "../state/types.ts";
-import { appendEvent } from "../state/event-log.ts";
+import { appendTaskAttentionEvent } from "./attention-events.ts";
 import type { CrewAgentRecord } from "./crew-agent-runtime.ts";
 import { upsertCrewAgent } from "./crew-agent-records.ts";
 
@@ -53,12 +53,11 @@ export function applyAttentionState(manifest: TeamRunManifest, agent: CrewAgentR
 		},
 	};
 	upsertCrewAgent(manifest, updated);
-	appendEvent(manifest.eventsPath, {
-		type: "agent.needs_attention",
-		runId: manifest.runId,
+	appendTaskAttentionEvent({
+		manifest,
 		taskId: agent.taskId,
 		message: `${agent.agent} needs attention (no observed activity for ${Math.floor(age / 1000)}s).`,
-		data: { agentId: agent.id, ageMs: age, needsAttentionAfterMs: config.needsAttentionAfterMs },
+		data: { activityState: "needs_attention", reason: "idle", elapsedMs: age, taskId: agent.taskId, agentName: agent.agent, suggestedAction: "Check worker status, wait, steer, or cancel if needed." },
 	});
 	return updated;
 }

package/src/runtime/attention-events.ts

@@ -0,0 +1,23 @@
+import { appendEvent, readEvents } from "../state/event-log.ts";
+import type { CrewAttentionEventData, TeamRunManifest } from "../state/types.ts";
+
+export interface AppendTaskAttentionInput {
+	manifest: TeamRunManifest;
+	taskId?: string;
+	message: string;
+	data: CrewAttentionEventData;
+}
+
+export function appendTaskAttentionEvent(input: AppendTaskAttentionInput): boolean {
+	const recent = readEvents(input.manifest.eventsPath).slice(-100);
+	const duplicate = recent.some((event) => event.type === "task.attention" && event.taskId === input.taskId && event.data?.reason === input.data.reason && event.data?.activityState === input.data.activityState);
+	if (duplicate) return false;
+	appendEvent(input.manifest.eventsPath, {
+		type: "task.attention",
+		runId: input.manifest.runId,
+		taskId: input.taskId,
+		message: input.message,
+		data: { ...input.data },
+	});
+	return true;
+}

package/src/runtime/child-pi.ts

@@ -7,6 +7,7 @@ import { getPiSpawnCommand } from "./pi-spawn.ts";
 import { DEFAULT_CHILD_PI } from "../config/defaults.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { attachPostExitStdioGuard, trySignalChild } from "./post-exit-stdio-guard.ts";
+import { redactJsonLine } from "../utils/redaction.ts";
 
 const POST_EXIT_STDIO_GUARD_MS = DEFAULT_CHILD_PI.postExitStdioGuardMs;
 const FINAL_DRAIN_MS = DEFAULT_CHILD_PI.finalDrainMs;
@@ -118,7 +119,7 @@ export function buildChildPiSpawnOptions(cwd: string, env: NodeJS.ProcessEnv): S
 function appendTranscript(input: ChildPiRunInput, line: string): void {
 	if (!input.transcriptPath) return;
 	fs.mkdirSync(path.dirname(input.transcriptPath), { recursive: true });
-	fs.appendFileSync(input.transcriptPath, `${line}\n`, "utf-8");
+	fs.appendFileSync(input.transcriptPath, `${redactJsonLine(line)}\n`, "utf-8");
 }
 
 function compactString(value: string, maxChars = MAX_COMPACT_CONTENT_CHARS): string {

package/src/runtime/completion-guard.ts

@@ -0,0 +1,99 @@
+import * as fs from "node:fs";
+
+export interface CompletionMutationGuardInput {
+	role: string;
+	taskText?: string;
+	transcriptPath?: string;
+	stdout?: string;
+}
+
+export interface CompletionMutationGuardResult {
+	expectedMutation: boolean;
+	observedMutation: boolean;
+	reason?: "no_mutation_observed";
+	observedTools: string[];
+}
+
+const MUTATING_ROLES = new Set(["executor", "test-engineer"]);
+const MUTATING_TOOLS = new Set(["edit", "write", "multi_edit", "apply_patch"]);
+const READ_ONLY_COMMANDS = /^(pwd|ls|dir|cat|type|sed|grep|rg|find|git\s+(status|diff|log|show|branch|remote|rev-parse|ls-files)|npm\s+(test|run\s+(typecheck|check|lint|test|ci))|node\s+--test)\b/i;
+const MUTATING_COMMANDS = /\b(rm\s+-|del\s+|erase\s+|mv\s+|move\s+|cp\s+|copy\s+|mkdir\b|touch\b|git\s+(add|commit|push|reset|clean|checkout|switch|merge|rebase|stash)|npm\s+(install|i|uninstall|publish|version)|pnpm\s+(add|install|remove)|yarn\s+(add|install|remove)|python\b.*>|node\b.*>|echo\b.*>|Set-Content|Out-File)\b/i;
+const READ_ONLY_HINTS = /\b(read-only|no edits?|do not edit|không sửa|khong sua|chỉ đọc|chi doc|plan only|chỉ lập plan|review only|audit only)\b/i;
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function commandText(value: unknown): string {
+	const record = asRecord(value);
+	if (!record) return typeof value === "string" ? value : "";
+	for (const key of ["command", "cmd", "script", "input"]) {
+		const raw = record[key];
+		if (typeof raw === "string") return raw;
+	}
+	return JSON.stringify(record);
+}
+
+function isMutatingTool(tool: string, args: unknown): boolean {
+	const normalized = tool.toLowerCase();
+	if (MUTATING_TOOLS.has(normalized)) return true;
+	if (normalized === "bash" || normalized === "shell" || normalized === "powershell") {
+		const command = commandText(args).trim();
+		if (!command || READ_ONLY_COMMANDS.test(command)) return false;
+		return MUTATING_COMMANDS.test(command);
+	}
+	return false;
+}
+
+function collectToolCallsFromEvent(event: unknown): Array<{ tool: string; args?: unknown }> {
+	const record = asRecord(event);
+	if (!record) return [];
+	const calls: Array<{ tool: string; args?: unknown }> = [];
+	const directTool = record.toolName ?? record.name ?? record.tool;
+	if (typeof directTool === "string" && (record.type === "tool_execution_start" || record.type === "toolCall" || record.type === "tool_call")) {
+		calls.push({ tool: directTool, args: record.args ?? record.input });
+	}
+	const content = Array.isArray(record.content) ? record.content : asRecord(record.message)?.content;
+	if (Array.isArray(content)) {
+		for (const part of content) {
+			const item = asRecord(part);
+			if (!item) continue;
+			const tool = item.name ?? item.toolName ?? item.tool;
+			if (typeof tool === "string" && (item.type === "toolCall" || item.type === "tool_call" || item.type === "tool_execution_start")) calls.push({ tool, args: item.input ?? item.args });
+		}
+	}
+	return calls;
+}
+
+function transcriptText(input: CompletionMutationGuardInput): string {
+	if (input.transcriptPath && fs.existsSync(input.transcriptPath)) return fs.readFileSync(input.transcriptPath, "utf-8");
+	return input.stdout ?? "";
+}
+
+export function expectsImplementationMutation(input: Pick<CompletionMutationGuardInput, "role" | "taskText">): boolean {
+	if (!MUTATING_ROLES.has(input.role)) return false;
+	return !READ_ONLY_HINTS.test(input.taskText ?? "");
+}
+
+export function evaluateCompletionMutationGuard(input: CompletionMutationGuardInput): CompletionMutationGuardResult {
+	const expectedMutation = expectsImplementationMutation(input);
+	const observedTools: string[] = [];
+	let observedMutation = false;
+	const text = transcriptText(input);
+	for (const line of text.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		let event: unknown;
+		try { event = JSON.parse(trimmed); } catch { continue; }
+		for (const call of collectToolCallsFromEvent(event)) {
+			observedTools.push(call.tool);
+			if (isMutatingTool(call.tool, call.args)) observedMutation = true;
+		}
+	}
+	return {
+		expectedMutation,
+		observedMutation,
+		observedTools,
+		...(expectedMutation && !observedMutation ? { reason: "no_mutation_observed" as const } : {}),
+	};
+}

package/src/runtime/crew-agent-records.ts

@@ -7,6 +7,7 @@ import type { CrewAgentProgress, CrewAgentRecord, CrewRuntimeKind } from "./crew
 import { taskStatusToAgentStatus } from "./crew-agent-runtime.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { assertSafePathId, resolveRealContainedPath } from "../utils/safe-paths.ts";
+import { redactSecretString, redactSecrets } from "../utils/redaction.ts";
 
 export function agentsPath(manifest: TeamRunManifest): string {
 	return path.join(manifest.stateRoot, "agents.json");
@@ -71,7 +72,7 @@ export function readCrewAgents(manifest: TeamRunManifest): CrewAgentRecord[] {
 
 export function saveCrewAgents(manifest: TeamRunManifest, records: CrewAgentRecord[]): void {
 	fs.mkdirSync(manifest.stateRoot, { recursive: true });
-	atomicWriteJson(agentsPath(manifest), records);
+	atomicWriteJson(agentsPath(manifest), redactSecrets(records));
 	for (const record of records) writeCrewAgentStatus(manifest, record);
 }
 
@@ -84,7 +85,7 @@ export function upsertCrewAgent(manifest: TeamRunManifest, record: CrewAgentReco
 
 export function writeCrewAgentStatus(manifest: TeamRunManifest, record: CrewAgentRecord): void {
 	ensureAgentStateDir(manifest, record.taskId);
-	atomicWriteJson(agentStatusPath(manifest, record.taskId), record);
+	atomicWriteJson(agentStatusPath(manifest, record.taskId), redactSecrets(record));
 }
 
 export function readCrewAgentStatus(manifest: TeamRunManifest, taskOrAgentId: string): CrewAgentRecord | undefined {
@@ -121,7 +122,7 @@ export function appendCrewAgentEvent(manifest: TeamRunManifest, taskId: string,
 	ensureAgentStateDir(manifest, taskId);
 	const filePath = agentStateFile(manifest, taskId, "events.jsonl");
 	const seq = nextAgentEventSeq(filePath);
-	fs.appendFileSync(filePath, `${JSON.stringify({ seq, time: new Date().toISOString(), event })}\n`, "utf-8");
+	fs.appendFileSync(filePath, `${JSON.stringify(redactSecrets({ seq, time: new Date().toISOString(), event }))}\n`, "utf-8");
 	try {
 		const stat = fs.statSync(filePath);
 		agentEventSeqCache.set(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, seq });
@@ -172,7 +173,7 @@ export function readCrewAgentEventsCursor(manifest: TeamRunManifest, taskId: str
 export function appendCrewAgentOutput(manifest: TeamRunManifest, taskId: string, text: string): void {
 	if (!text.trim()) return;
 	ensureAgentStateDir(manifest, taskId);
-	fs.appendFileSync(agentStateFile(manifest, taskId, "output.log"), `${text}\n`, "utf-8");
+	fs.appendFileSync(agentStateFile(manifest, taskId, "output.log"), `${redactSecretString(text)}\n`, "utf-8");
 }
 
 export function emptyCrewAgentProgress(): CrewAgentProgress {

package/src/runtime/crew-agent-runtime.ts

@@ -1,5 +1,5 @@
 import type { TeamTaskStatus } from "../state/contracts.ts";
-import type { ModelRoutingState, UsageState } from "../state/types.ts";
+import type { CrewActivityState, ModelRoutingState, UsageState } from "../state/types.ts";
 
 export type CrewRuntimeKind = "scaffold" | "child-process" | "live-session";
 export type CrewAgentStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "stopped";
@@ -21,7 +21,7 @@ export interface CrewAgentProgress {
 	turns?: number;
 	durationMs?: number;
 	lastActivityAt?: string;
-	activityState?: "active" | "needs_attention" | "stale";
+	activityState?: CrewActivityState;
 	failedTool?: string;
 }
 

package/src/runtime/diagnostic-export.ts

@@ -9,6 +9,8 @@ import { loadRunManifestById } from "../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { summarizeHeartbeats, type HeartbeatSummary } from "../ui/heartbeat-aggregator.ts";
 import type { RunUiSnapshot } from "../ui/snapshot-types.ts";
+import { redactSecrets } from "../utils/redaction.ts";
+export { redactSecrets } from "../utils/redaction.ts";
 
 export interface DiagnosticReport {
 	schemaVersion?: number;
@@ -25,22 +27,6 @@ export interface DiagnosticReport {
 
 const SECRET_KEY_PATTERN = /(token|key|password|secret|credential|auth)/i;
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-export function redactSecrets(value: unknown, keyName = ""): unknown {
-	if (SECRET_KEY_PATTERN.test(keyName)) return "***";
-	if (typeof value === "string") return value.replace(/((?:token|key|password|secret|credential|auth)[\w.-]*\s*[=:]\s*)[^\s,;]+/gi, "$1***");
-	if (Array.isArray(value)) return value.map((item) => redactSecrets(item));
-	if (isRecord(value)) {
-		const output: Record<string, unknown> = {};
-		for (const [key, entry] of Object.entries(value)) output[key] = redactSecrets(entry, key);
-		return output;
-	}
-	return value;
-}
-
 function envRedacted(): Record<string, string> {
 	const output: Record<string, string> = {};
 	for (const [key, value] of Object.entries(process.env)) {