pi-crew 0.9.53 → 0.9.55

package/src/extension/team-tool/failure-patterns.ts

@@ -0,0 +1,118 @@
+/**
+ * failure-patterns.ts — Group failed tasks by error similarity (Round 17 BS-4).
+ *
+ * Before this, a run with 8 failed tasks surfaced 8 separate raw error
+ * strings. The user had to mentally group them ("5 of these say 'model
+ * routing fallback failed'"). This module detects common failure patterns
+ * so `summary` can say "5 of 8 failures share root cause: X".
+ *
+ * Grouping strategy (cheap, deterministic, no ML):
+ *   1. Normalize: lowercase, collapse whitespace, strip task ids / run ids /
+ *      absolute paths / numbers → a canonical "signature".
+ *   2. Bucket by signature. Buckets with >1 member are "common patterns".
+ *   3. Sort by frequency desc.
+ *
+ * Conservative: only buckets with >=2 members count as a pattern (a single
+ * failure is just itself). Returns [] when there are no repeated signatures.
+ */
+
+export interface FailurePattern {
+	/** Canonical error signature used for grouping. */
+	signature: string;
+	/** A representative original error (the shortest variant) for display. */
+	representative: string;
+	/** Task ids that hit this pattern. */
+	taskIds: string[];
+	/** Count of failures in this bucket (== taskIds.length). */
+	count: number;
+}
+
+export interface FailurePatternInput {
+	id: string;
+	status: string;
+	error?: string;
+}
+
+/**
+ * Normalize an error string into a grouping signature.
+ * Exported for unit testing.
+ */
+export function normalizeErrorSignature(error: string | undefined): string {
+	if (!error) return "(no error detail)";
+	let s = error.toLowerCase();
+	// Strip run ids (team_YYYYMMDDHHMMSS_xxxxxxxxxxxxxxxx)
+	s = s.replace(/team_\d{8,}_[a-z0-9]{12,}/g, "<run>");
+	// Strip task ids (01_explore, adaptive-03-executor, etc.)
+	s = s.replace(/\b(adaptive-)?\d{2,}[a-z0-9_-]+/g, "<task>");
+	// Strip absolute paths
+	s = s.replace(/\/(?:home|users|tmp|var|opt|root)[^\s'"]*/g, "<path>");
+	// Strip numbers (line numbers, counts, pids, ms durations)
+	s = s.replace(/\b\d+\b/g, "N");
+	// Collapse whitespace
+	s = s.replace(/\s+/g, " ").trim();
+	return s || "(no error detail)";
+}
+
+/**
+ * Group failed tasks by error-pattern similarity. Only groups with >=2
+ * members are returned (singletons are not "patterns"). Sorted by count desc.
+ *
+ * @param tasks  the run's tasks (any with status 'failed'/'cancelled' are
+ *               considered failures for aggregation purposes).
+ */
+export function aggregateFailurePatterns(tasks: FailurePatternInput[]): FailurePattern[] {
+	const failed = tasks.filter((t) => t.status === "failed" || t.status === "cancelled");
+	if (failed.length === 0) return [];
+	const buckets = new Map<string, FailurePattern>();
+	for (const t of failed) {
+		const signature = normalizeErrorSignature(t.error);
+		const existing = buckets.get(signature);
+		if (existing) {
+			existing.taskIds.push(t.id);
+			existing.count += 1;
+			// Keep the shortest non-empty variant as representative (most readable).
+			if (t.error && (!existing.representative || t.error.length < existing.representative.length)) {
+				existing.representative = t.error;
+			}
+		} else {
+			buckets.set(signature, {
+				signature,
+				representative: t.error ?? "(no error detail)",
+				taskIds: [t.id],
+				count: 1,
+			});
+		}
+	}
+	// Only patterns with >=2 members (repeated root causes).
+	return [...buckets.values()].filter((b) => b.count >= 2).sort((a, b) => b.count - a.count);
+}
+
+/**
+ * Render failure patterns as human-readable lines for the `summary` action.
+ * Returns [] when there are no repeated patterns (so the caller can omit the
+ * section entirely).
+ *
+ * Example output:
+ *   Common failure patterns (3 of 5 failures share 2 root causes):
+ *   - [×3] model routing fallback failed: all 2 candidates exhausted
+ *       tasks: 02_exec, 03_exec, 04_exec
+ *   - [×2] EPERM: operation not permitted, rename
+ *       tasks: 05_exec, 06_exec
+ */
+export function formatFailurePatterns(tasks: FailurePatternInput[]): string[] {
+	const patterns = aggregateFailurePatterns(tasks);
+	if (patterns.length === 0) return [];
+	const failedCount = tasks.filter((t) => t.status === "failed" || t.status === "cancelled").length;
+	const groupedCount = patterns.reduce((sum, p) => sum + p.count, 0);
+	const lines = [
+		`Common failure patterns (${groupedCount} of ${failedCount} failures share ${patterns.length} root cause${patterns.length === 1 ? "" : "s"}):`,
+	];
+	for (const p of patterns) {
+		const rep = p.representative.length > 100 ? `${p.representative.slice(0, 99)}…` : p.representative;
+		lines.push(`- [×${p.count}] ${rep}`);
+		const shown = p.taskIds.slice(0, 6);
+		const more = p.taskIds.length > 6 ? `, +${p.taskIds.length - 6} more` : "";
+		lines.push(`    tasks: ${shown.join(", ")}${more}`);
+	}
+	return lines;
+}

package/src/extension/team-tool/goal-wrap.ts

@@ -0,0 +1,330 @@
+/**
+ * goal-wrap.ts — Apply the `goal` completion-guarantee to builtin workflows.
+ *
+ * RFC v0.5 vision: when `goalWrap[workflowName].enabled` is set in .crew/config.json,
+ * the builtin workflow runs as the WORKER TURN inside a goal loop (worker → judge →
+ * feedback → redo until achieved / maxTurns / budget / stuck).
+ *
+ * Design (A + D confirmed with user):
+ *   - OUTER wrap: the builtin workflow IS the worker turn (judge evaluates the whole thing)
+ *   - KEEP .workflow.md: no convert; the existing adaptive planner (e.g. `implementation`)
+ *     keeps its flexibility; we just re-run it per turn with the judge's feedback.
+ *   - Per-workflow toggle via team-setting config.
+ *
+ * Reuses the Phase 1 goal infrastructure: GoalStore, GoalLoopState, runGoalLoop. The
+ * builtin workflow's per-turn execution goes through executeTeamRun (same as a normal
+ * goal worker turn), so Phase 1's protections (integrity snapshot, budget guard,
+ * nonce-token feedback, worker cap, workspace lock) all apply.
+ */
+
+import { loadConfig } from "../../config/config.ts";
+import type { GoalWrapWorkflowConfig } from "../../config/types.ts";
+import { GoalStore } from "../../runtime/goal-state-store.ts";
+import { snapshotManifests } from "../../runtime/verification-integrity.ts";
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import { atomicWriteJson } from "../../state/atomic-write.ts";
+import { appendEvent } from "../../state/event-log.ts";
+import { createRunPaths, saveRunManifestAsync } from "../../state/state-store.ts";
+import type { GoalLoopState, TeamRunManifest } from "../../state/types.ts";
+import { spawnBackgroundTeamRun } from "../../subagents/async-entry.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import type { WorkflowConfig } from "../../workflows/workflow-config.ts";
+import { result, type TeamContext } from "./context.ts";
+
+/** Builtin workflows eligible for goal-wrap (have a clear "done" condition). */
+export const GOAL_WRAP_ELIGIBLE_BUILTINS = new Set(["implementation", "fast-fix", "default"]);
+
+/**
+ * Maximum number of workflow steps allowed for goal-wrap.
+ *
+ * Multi-step workflows (>=2 steps in their .workflow.md definition) crash
+ * non-deterministically when run as goal-wrap worker turns in the background
+ * goal-loop process. Root cause: V8/libuv-level race during event-loop yields
+ * in the team-runner batch transition (see investigation commit a9f6e09 +
+ * Phase 1.5 RFC 15). Sync fs workarounds regress; worker-thread isolation
+ * doesn't help. The crash is NOT in fs writes.
+ *
+ * Decision: REFUSE goal-wrap for multi-step workflows rather than ship a
+ * feature with hidden non-deterministic crashes. Single-step workflows
+ * (e.g. implementation, which has only the adaptive `assess` step and
+ * injects more tasks via the adaptive planner) work reliably end-to-end.
+ *
+ * Users who want goal completion-guarantee on multi-step work should use
+ * `team action='run' workflow=<multi-step>` for the one-shot execution, or
+ * break the work into single-step goals.
+ */
+export const GOAL_WRAP_MAX_STEPS = 1;
+
+// GoalWrapWorkflowConfig is re-exported from config/types.ts (single source of truth).
+export type { GoalWrapWorkflowConfig };
+
+/** Read the goal-wrap config for a given workflow name (merged user + project config). */
+export function readGoalWrapConfig(cwd: string, workflowName: string): GoalWrapWorkflowConfig | undefined {
+	const loaded = loadConfig(cwd);
+	const cfg = loaded.config?.goalWrap as Record<string, GoalWrapWorkflowConfig> | undefined;
+	if (!cfg) return undefined;
+	return cfg[workflowName];
+}
+
+/** Is goal-wrap enabled for this workflow (per config)? */
+export function isGoalWrapEnabled(cwd: string, workflowName: string): boolean {
+	if (!GOAL_WRAP_ELIGIBLE_BUILTINS.has(workflowName)) return false;
+	const wc = readGoalWrapConfig(cwd, workflowName);
+	return wc?.enabled === true;
+}
+
+/**
+ * Validate a goal-wrap config entry. Returns an error string if invalid, undefined if OK.
+ * Mirrors the Phase 1 validation: budget required (or unlimited), evaluatorModel required.
+ */
+export function validateGoalWrapConfig(wc: GoalWrapWorkflowConfig): string | undefined {
+	if (!wc.evaluatorModel) {
+		return "goalWrap config requires evaluatorModel (the goal-judge model). No silent default.";
+	}
+	const hasBudget = typeof wc.budgetTotal === "number" && wc.budgetTotal >= 1000;
+	if (!wc.budgetUnlimited && !hasBudget) {
+		return "goalWrap config requires either budgetTotal (>=1000) OR budgetUnlimited:true. No silent unbounded-spend default.";
+	}
+	if (wc.budgetUnlimited && hasBudget) {
+		return "goalWrap config: budgetTotal and budgetUnlimited are mutually exclusive.";
+	}
+	return undefined;
+}
+
+/**
+ * Start a goal-wrapped run. Creates a GoalLoopState + goal-loop manifest + spawns the
+ * background goal-loop process. The worker turn's workflow is the resolved builtin.
+ *
+ * The goal-loop-runner's buildTurnWorkflow() generates a 1-step "goal-turn" workflow; for
+ * goal-wrap we OVERRIDE that by storing the target workflow name on the GoalLoopState
+ * and having the runner use it per turn. (See the `team` field carry-through.)
+ */
+/**
+ * Persist `async: { pid, logPath, spawnedAt }` on a goal-loop manifest and write
+ * it atomically to disk. This is the missing piece that makes goal-loop runs
+ * detectable by async-notifier.markDeadAsyncRunIfNeeded — without it, the
+ * notifier returns early on `!run.async` and the goal appears to hang at "1/3"
+ * forever even after the background runner has died.
+ *
+ * Mirrors the normal-run path in run.ts:371-372 which writes the async field on
+ * the team-run manifest via `atomicWriteJson(paths.manifestPath, asyncManifest)`.
+ */
+export function persistAsyncOnGoalLoopManifest(
+	manifestPath: string,
+	manifest: TeamRunManifest,
+	spawned: { pid: number; logPath: string },
+): void {
+	const asyncGoalManifest = {
+		...manifest,
+		async: {
+			pid: spawned.pid,
+			logPath: spawned.logPath,
+			spawnedAt: new Date().toISOString(),
+		},
+	};
+	atomicWriteJson(manifestPath, asyncGoalManifest);
+}
+/**
+ * Decide whether a workflow should be goal-wrapped.
+ *
+ * Returns one of:
+ *   { enabled: true }                          — goal-wrap is enabled AND safe
+ *   { enabled: false, reason: "config-off" }     — goal-wrap not enabled in config
+ *   { enabled: false, reason: "multi-step" }     — enabled but refused (multi-step
+ *                                                workflows crash non-deterministically
+ *                                                in the background goal-loop process
+ *                                                due to V8/libuv race; see GOAL_WRAP_MAX_STEPS)
+ *   { enabled: false, reason: "invalid-config" } — config present but invalid
+ *
+ * Use this in run.ts to decide whether to route to startGoalWrappedRun or fall
+ * through to the normal team-run path. NEVER refuse with an error — when
+ * goal-wrap is unsafe for a given workflow, silently fall back so the user
+ * still gets the workflow run they asked for.
+ */
+export function shouldGoalWrap(
+	cwd: string,
+	workflow: WorkflowConfig,
+):
+	| { enabled: true }
+	| {
+			enabled: false;
+			reason: "config-off" | "multi-step" | "invalid-config";
+			message?: string;
+	  } {
+	const wc = readGoalWrapConfig(cwd, workflow.name);
+	if (wc?.enabled !== true) {
+		return { enabled: false, reason: "config-off" };
+	}
+	const validationError = validateGoalWrapConfig(wc);
+	if (validationError) {
+		return {
+			enabled: false,
+			reason: "invalid-config",
+			message: validationError,
+		};
+	}
+	if (workflow.steps.length > GOAL_WRAP_MAX_STEPS) {
+		return {
+			enabled: false,
+			reason: "multi-step",
+			message: `goal-wrap disabled for '${workflow.name}' (${workflow.steps.length} steps): multi-step workflows crash non-deterministically in the background goal-loop (V8/libuv race). Running as a normal one-shot team run instead.`,
+		};
+	}
+	return { enabled: true };
+}
+
+export async function startGoalWrappedRun(
+	params: TeamToolParamsValue,
+	ctx: TeamContext,
+	workflow: WorkflowConfig,
+	goal: string,
+): Promise<ReturnType<typeof result>> {
+	const cwd = ctx.cwd;
+	const wc = readGoalWrapConfig(cwd, workflow.name);
+	if (wc?.enabled !== true) {
+		return result(
+			`goal-wrap is not enabled for workflow '${workflow.name}' in .crew/config.json.`,
+			{ action: "run", status: "error" },
+			true,
+		);
+	}
+	const validationError = validateGoalWrapConfig(wc);
+	if (validationError) {
+		return result(`Invalid goalWrap config for '${workflow.name}': ${validationError}`, { action: "run", status: "error" }, true);
+	}
+
+	try {
+		const store = new GoalStore(cwd);
+		const goalId = store.createGoalId();
+		const ownerSessionId = ctx.sessionId ?? "unknown";
+		const now = new Date().toISOString();
+		const maxTurns = typeof wc.maxTurns === "number" && wc.maxTurns > 0 ? wc.maxTurns : 5; // goal-wrap default: tighter than standalone goal's 20
+
+		// P1a integrity snapshot (only when verification.commands declared).
+		const verification = wc.verification;
+		const isTextOnly = verification?.mode === "text-only" || !verification?.commands?.length;
+		let verificationIntegrity: GoalLoopState["verificationIntegrity"];
+		if (isTextOnly) {
+			verificationIntegrity = "none-text-only";
+		} else {
+			try {
+				verificationIntegrity = {
+					snapshot: snapshotManifests(cwd),
+					takenAt: now,
+				};
+			} catch (error) {
+				logInternalError("goal-wrap.integritySnapshot", error, `goalId=${goalId}`);
+				verificationIntegrity = "none-text-only";
+			}
+		}
+
+		const goalState: GoalLoopState = {
+			goalId,
+			ownerSessionId,
+			objective: goal,
+			state: "running",
+			maxTurns,
+			turnsUsed: 0,
+			budgetTotal: typeof wc.budgetTotal === "number" ? wc.budgetTotal : undefined,
+			budgetUnlimited: wc.budgetUnlimited || undefined,
+			budgetWarning: 0.8,
+			budgetAbort: 0.95,
+			budgetUsed: 0,
+			verificationIntegrity,
+			verification: verification as { commands: string[]; allowManualEvidence?: boolean } | undefined,
+			evaluatorModel: wc.evaluatorModel!,
+			workerAgent: params.agent ?? "executor",
+			workerModel: typeof params.model === "string" ? params.model : undefined,
+			team: typeof params.team === "string" ? params.team : undefined,
+			cwd,
+			verdicts: [],
+			history: [],
+			createdAt: now,
+			updatedAt: now,
+		};
+		// Carry the target workflow name so the runner uses it (not the default goal-turn).
+		// Stored on the state via a documented extension field.
+		(goalState as GoalLoopState & { goalWrapWorkflow?: string }).goalWrapWorkflow = workflow.name;
+		store.save(goalState);
+
+		const paths = createRunPaths(cwd, goalId);
+		const goalLoopManifest: TeamRunManifest = {
+			schemaVersion: 1,
+			runId: goalId,
+			sessionId: ownerSessionId,
+			team: `goal-wrap-${goalId}`,
+			workflow: "goal-loop",
+			goal,
+			status: "queued",
+			workspaceMode: "single",
+			createdAt: now,
+			updatedAt: now,
+			cwd,
+			stateRoot: paths.stateRoot,
+			artifactsRoot: paths.artifactsRoot,
+			tasksPath: paths.tasksPath,
+			eventsPath: paths.eventsPath,
+			artifacts: [],
+			ownerSessionId,
+			runKind: "goal-loop",
+		};
+		await saveRunManifestAsync(goalLoopManifest);
+		appendEvent(paths.eventsPath, {
+			type: "goal.loop_start",
+			runId: goalId,
+			data: {
+				goalId,
+				objective: goal,
+				maxTurns,
+				goalWrapWorkflow: workflow.name,
+			},
+		});
+
+		const spawned = await spawnBackgroundTeamRun(goalLoopManifest);
+		const pid = spawned.pid ?? 0;
+		// FIX: persist async.pid on the OUTER goal-loop manifest (not just goal state).
+		// Without this, async-notifier.markDeadAsyncRunIfNeeded returns early on
+		// `!run.async` and the user sees the goal hang at "1/3" forever even after the
+		// background runner dies (it currently dies silently due to a multi-step
+		// atomic-write bug — see investigation report). Mirrors run.ts:371-372 which
+		// writes asyncManifest = { ...effectiveManifest, async: {...} } to manifestPath.
+		persistAsyncOnGoalLoopManifest(paths.manifestPath, goalLoopManifest, {
+			pid,
+			logPath: spawned.logPath,
+		});
+		const withAsync = {
+			...goalState,
+			async: {
+				pid,
+				logPath: spawned.logPath,
+				spawnedAt: new Date().toISOString(),
+			},
+		};
+		store.save(withAsync);
+
+		return result(
+			[
+				`Goal-wrapped '${workflow.name}' started (background pid=${pid}).`,
+				`Goal ${goalId} [running] — worker = '${workflow.name}' workflow, judged each turn by ${wc.evaluatorModel}.`,
+				`  turn: 0/${maxTurns}   budget: ${wc.budgetUnlimited ? "∞ (unlimited)" : `${wc.budgetTotal}`}`,
+				verification?.commands?.length
+					? `  verification: ${verification.commands.join(", ")}`
+					: "  verification: text-only (no objective oracle)",
+				``,
+				`Next: \`team action='goal' config.subAction='status' config.goalId='${goalId}'\`.`,
+				`Log: ${spawned.logPath}`,
+			].join("\n"),
+			{
+				action: "run",
+				status: "ok",
+				runId: goalId,
+				artifactsRoot: paths.artifactsRoot,
+				data: { goalId, goalWrap: true, workflow: workflow.name, pid },
+			},
+			false,
+		);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return result(`goal-wrap start failed: ${message}`, { action: "run", status: "error" }, true);
+	}
+}