pi-crew 0.9.68 → 0.10.1

package/src/workflows/discover-workflows.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ResourceSource } from "../agents/agent-config.ts";
 import { parseCsv, parseFrontmatter } from "../utils/frontmatter.ts";
+import { logInternalError } from "../utils/internal-error.ts";
 import { packageRoot, projectCrewRoot, userPiRoot } from "../utils/paths.ts";
 import type { WorkflowConfig, WorkflowStep } from "./workflow-config.ts";
 
@@ -24,6 +25,8 @@ const STEP_CONFIG_KEYS = new Set([
 	"verify",
 	"task",
 	"seedPaths",
+	"specRefs",
+	"specStrict",
 	"preStepScript",
 	"preStepArgs",
 	"preStepTimeout",
@@ -68,6 +71,11 @@ function parseStepSection(id: string, body: string): WorkflowStep | undefined {
 		worktree: config.worktree === "true" ? true : config.worktree === "false" ? false : undefined,
 		verify: config.verify === "true" ? true : config.verify === "false" ? false : undefined,
 		seedPaths: parseCsv(config.seedPaths) || undefined,
+		specRefs: parseCsv(config.specRefs) || undefined,
+		// Tri-state (round-1 P1-2): ABSENT = undefined so the workflow-level flag
+		// survives the `step.specStrict ?? workflow.specStrict` dispatch merge; an
+		// explicit `false` stays false (per-step opt-out of a strict workflow).
+		specStrict: config.specStrict === undefined ? undefined : config.specStrict === "true" || config.specStrict === "1",
 		preStepScript: config.preStepScript || undefined,
 		preStepArgs: parseCsv(config.preStepArgs) || undefined,
 		preStepTimeout: parseOptionalInteger(config.preStepTimeout) ?? undefined,
@@ -155,8 +163,16 @@ function parseWorkflowFile(filePath: string, source: ResourceSource): WorkflowCo
 				// runtime, but stripping here prevents the script value from even reaching
 				// downstream consumers (coalesce-tasks, policy-engine, etc.).
 				if (source === "project" && step.preStepScript) {
-					console.warn(
-						`[discover-workflows] Stripping preStepScript from project workflow '${name}' step '${step.id}': '${step.preStepScript}' (F-02: project-sourced pre-step scripts are not allowed for RCE prevention)`,
+					// F-02 redaction: NEVER log the preStepScript body — project workflows
+					// are untrusted input and the script may contain secrets. Log name,
+					// step id, and script length only.
+					logInternalError(
+						"discover-workflows",
+						new Error(
+							`Stripping preStepScript from project workflow '${name}' step '${step.id}' — script body redacted (${step.preStepScript.length} chars) (F-02: project-sourced pre-step scripts are not allowed for RCE prevention)`,
+						),
+						undefined,
+						"warn",
 					);
 					step.preStepScript = undefined;
 					step.preStepArgs = undefined;
@@ -174,6 +190,7 @@ function parseWorkflowFile(filePath: string, source: ResourceSource): WorkflowCo
 			maxConcurrency: parseOptionalInteger(frontmatter.maxConcurrency),
 			topology: parseTopology(frontmatter.topology),
 			coalesceMicroTasks: parseOptionalBoolean(frontmatter.coalesceMicroTasks),
+			specStrict: parseOptionalBoolean(frontmatter.specStrict),
 			steps,
 		};
 	} catch {

package/src/workflows/validate-workflow.ts

@@ -9,7 +9,13 @@ export function validateWorkflowForTeam(workflow: WorkflowConfig, team: TeamConf
 	for (const step of workflow.steps) {
 		if (stepIds.has(step.id)) errors.push(`Duplicate workflow step id '${step.id}'.`);
 		stepIds.add(step.id);
-		if (!roles.has(step.role)) errors.push(`Step '${step.id}' references unknown team role '${step.role}'.`);
+		if (!roles.has(step.role)) {
+			// F19-9: the distill adapter needs roles the default team lacks
+			// (analyst/critic) — hint the correct invocation instead of a bare
+			// unknown-role error.
+			const distillHint = workflow.name === "distill" ? " (run with team='implementation' — needs analyst+critic roles)" : "";
+			errors.push(`Step '${step.id}' references unknown team role '${step.role}'.${distillHint}`);
+		}
 	}
 
 	for (const step of workflow.steps) {

package/src/workflows/workflow-config.ts

@@ -22,6 +22,12 @@ export interface WorkflowStep {
 	/** Per-step files to overlay into the worktree (in addition to global worktree.seedPaths).
 	 * Useful when only certain steps need access to local drafts or scripts. */
 	seedPaths?: string[];
+	/** T4/R6 (ADR-6): workspace SpecRecord ids this step is held to; frozen
+	 *  into the task packet at dispatch (specStrict per workflow frontmatter). */
+	specRefs?: string[];
+	/** T4/R6 (ADR-6 §7): per-step strict-mode opt-in. Normally inherited from
+	 *  the workflow-level frontmatter flag (merged at dispatch). */
+	specStrict?: boolean;
 	/** Path to a deterministic script to run before dispatching the LLM worker.
 	 * Script stdout is injected into the worker's prompt as context.
 	 * Pattern origin: Understand-Anything deterministic pre-step pattern. */
@@ -65,6 +71,10 @@ export interface WorkflowConfig {
 	 *  in v0.9.17 unless the workflow author opts in. See
 	 *  src/runtime/scheduling/coalesce-tasks.ts. */
 	coalesceMicroTasks?: boolean;
+	/** T4/R6 (ADR-6 §7): strict spec mode opt-in (frontmatter `specStrict: true`).
+	 *  Requires a verifier-role step (reject-start, §5) and fails the write-gate
+	 *  on coverage gaps or machine-check failures (§4). */
+	specStrict?: boolean;
 }
 
 /** A dynamic workflow (runtime === "dynamic"). steps is empty — the script is the source of truth. */

package/src/workflows/workflow-serializer.ts

@@ -14,6 +14,8 @@ function serializeStep(step: WorkflowStep): string[] {
 	if (step.progress !== undefined) lines.push(`progress: ${step.progress ? "true" : "false"}`);
 	if (step.worktree !== undefined) lines.push(`worktree: ${step.worktree ? "true" : "false"}`);
 	if (step.verify !== undefined) lines.push(`verify: ${step.verify ? "true" : "false"}`);
+	if (step.specRefs?.length) lines.push(`specRefs: ${step.specRefs.join(", ")}`);
+	if (step.specStrict !== undefined && step.specStrict !== false) lines.push("specStrict: true");
 	lines.push("", step.task.trim(), "");
 	return lines;
 }
@@ -24,6 +26,7 @@ export function serializeWorkflow(workflow: WorkflowConfig): string {
 		`name: ${workflow.name}`,
 		`description: ${workflow.description}`,
 		...(workflow.maxConcurrency !== undefined ? [`maxConcurrency: ${workflow.maxConcurrency}`] : []),
+		...(workflow.specStrict !== undefined ? [`specStrict: ${workflow.specStrict ? "true" : "false"}`] : []),
 		"---",
 		"",
 		...workflow.steps.flatMap(serializeStep),

package/src/worktree/worktree-manager.ts

@@ -146,6 +146,12 @@ export function assertCleanLeader(repoRoot: string): void {
 
 // --- Async versions ---
 
+// R5-L1 (Round 5 LOW-1): the exported clear*() fns below stay unwired by
+// leader decision (rewiring run-start/lock-release paths is riskier than the
+// leak); the FIFO caps bound these caches instead.
+const MAX_GIT_ROOT_CACHE = 256;
+const MAX_CLEAN_LEADER_CACHE = 256;
+
 /** Cache for findGitRoot results keyed by cwd. Cleared per-run. */
 const _gitRootCache = new Map<string, string>();
 
@@ -159,6 +165,10 @@ export async function findGitRootAsync(cwd: string): Promise<string> {
 	if (cached) return cached;
 	const root = await gitAsync(cwd, ["rev-parse", "--show-toplevel"]);
 	_gitRootCache.set(cwd, root);
+	if (_gitRootCache.size > MAX_GIT_ROOT_CACHE) {
+		const oldest = _gitRootCache.keys().next().value;
+		if (oldest !== undefined) _gitRootCache.delete(oldest);
+	}
 	return root;
 }
 
@@ -179,6 +189,10 @@ export async function assertCleanLeaderAsync(repoRoot: string): Promise<void> {
 		throw new Error("Worktree mode requires a clean leader repository. Commit/stash changes or use workspaceMode: 'single'.");
 	}
 	_cleanLeaderCache.add(repoRoot);
+	if (_cleanLeaderCache.size > MAX_CLEAN_LEADER_CACHE) {
+		const oldest = _cleanLeaderCache.values().next().value;
+		if (oldest !== undefined) _cleanLeaderCache.delete(oldest);
+	}
 }
 
 function linkNodeModulesIfPresent(repoRoot: string, worktreePath: string): boolean {
@@ -469,6 +483,10 @@ async function branchExistsAsync(repoRoot: string, branch: string): Promise<{ lo
 // run no new stale worktrees appear, so one prune suffices).
 const _prunedRepos = new Set<string>();
 const _pruneInFlight = new Map<string, Promise<void>>();
+// R5-L2 (Round 5 LOW-2): FIFO cap — dedupe-only Set, never cleared in
+// production; eviction just means a re-prune for that repo later, which is
+// harmless (prune is idempotent and coalesced).
+const MAX_PRUNED_REPOS = 128;
 async function pruneStaleWorktreesAsync(repoRoot: string): Promise<void> {
 	if (_prunedRepos.has(repoRoot)) return;
 	const inFlight = _pruneInFlight.get(repoRoot);
@@ -483,6 +501,10 @@ async function pruneStaleWorktreesAsync(repoRoot: string): Promise<void> {
 			/* best-effort */
 		}
 		_prunedRepos.add(repoRoot);
+		if (_prunedRepos.size > MAX_PRUNED_REPOS) {
+			const oldest = _prunedRepos.values().next().value;
+			if (oldest !== undefined) _prunedRepos.delete(oldest);
+		}
 		_pruneInFlight.delete(repoRoot);
 	})();
 	_pruneInFlight.set(repoRoot, p);

package/src/agents/agent-search.ts

@@ -1,98 +0,0 @@
-import type { AgentConfig } from "./agent-config.ts";
-
-// ─── BM25 Agent Search ──────────────────────────────────────────────────────
-// Lightweight BM25 search over agent descriptors for task-to-agent matching.
-// Based on the same BM25 algorithm used in oh-my-pi's tool-index.ts.
-
-export interface AgentSearchDocument {
-	agent: AgentConfig;
-	termFrequencies: Map<string, number>;
-	length: number;
-}
-
-export interface AgentSearchIndex {
-	documents: AgentSearchDocument[];
-	averageLength: number;
-	documentFrequencies: Map<string, number>;
-}
-
-export interface AgentSearchResult {
-	agent: AgentConfig;
-	score: number;
-}
-
-const BM25_K1 = 1.2;
-const BM25_B = 0.75;
-const FIELD_WEIGHTS = {
-	name: 6,
-	description: 2,
-	role: 3,
-} as const;
-
-function tokenize(value: string): string[] {
-	return value
-		.replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-		.replace(/[^a-zA-Z0-9]+/g, " ")
-		.toLowerCase()
-		.trim()
-		.split(/\s+/)
-		.filter((token) => token.length > 0);
-}
-
-function addWeightedTokens(termFrequencies: Map<string, number>, value: string | undefined, weight: number): void {
-	if (!value) return;
-	for (const token of tokenize(value)) {
-		termFrequencies.set(token, (termFrequencies.get(token) ?? 0) + weight);
-	}
-}
-
-function buildAgentSearchDocument(agent: AgentConfig): AgentSearchDocument {
-	const termFrequencies = new Map<string, number>();
-	addWeightedTokens(termFrequencies, agent.name, FIELD_WEIGHTS.name);
-	addWeightedTokens(termFrequencies, agent.description, FIELD_WEIGHTS.description);
-	// Role from agent name heuristic
-	const roleHint = agent.name?.replace(/[-_]/g, " ") ?? "";
-	addWeightedTokens(termFrequencies, roleHint, FIELD_WEIGHTS.role);
-	const length = Array.from(termFrequencies.values()).reduce((sum, value) => sum + value, 0);
-	return { agent, termFrequencies, length };
-}
-
-export function buildAgentSearchIndex(agents: Iterable<AgentConfig>): AgentSearchIndex {
-	const documents = Array.from(agents, buildAgentSearchDocument);
-	const averageLength = documents.reduce((sum, document) => sum + document.length, 0) / documents.length || 1;
-	const documentFrequencies = new Map<string, number>();
-	for (const document of documents) {
-		for (const token of new Set(document.termFrequencies.keys())) {
-			documentFrequencies.set(token, (documentFrequencies.get(token) ?? 0) + 1);
-		}
-	}
-	return { documents, averageLength, documentFrequencies };
-}
-
-export function searchAgents(index: AgentSearchIndex, query: string, limit: number): AgentSearchResult[] {
-	const queryTokens = tokenize(query);
-	if (queryTokens.length === 0) return [];
-	if (index.documents.length === 0) return [];
-
-	const queryTermCounts = new Map<string, number>();
-	for (const token of queryTokens) {
-		queryTermCounts.set(token, (queryTermCounts.get(token) ?? 0) + 1);
-	}
-
-	return index.documents
-		.map((document) => {
-			let score = 0;
-			for (const [token, queryTermCount] of queryTermCounts) {
-				const termFrequency = document.termFrequencies.get(token) ?? 0;
-				if (termFrequency === 0) continue;
-				const documentFrequency = index.documentFrequencies.get(token) ?? 0;
-				const idf = Math.log(1 + (index.documents.length - documentFrequency + 0.5) / (documentFrequency + 0.5));
-				const normalization = BM25_K1 * (1 - BM25_B + BM25_B * (document.length / index.averageLength));
-				score += queryTermCount * idf * ((termFrequency * (BM25_K1 + 1)) / (termFrequency + normalization));
-			}
-			return { agent: document.agent, score };
-		})
-		.filter((result) => result.score > 0)
-		.sort((left, right) => right.score - left.score || left.agent.name.localeCompare(right.agent.name))
-		.slice(0, limit);
-}

package/src/benchmark/benchmark-runner.ts

@@ -1,313 +0,0 @@
-/**
- * Benchmark runner - agent-eval inspired benchmarking system.
- * Provides tiered evaluation for workflow tasks.
- */
-
-import { execFileSync } from "node:child_process";
-
-export interface BenchmarkJudge {
-	type: "pytest" | "grep" | "command";
-	command?: string;
-	pattern?: string;
-	description: string;
-}
-
-export interface BenchmarkTask {
-	id: string;
-	name: string;
-	prompt: string;
-	judges: BenchmarkJudge[];
-	/** Optional task-type label used for aggregate metrics grouping. */
-	taskType?: string;
-}
-
-export interface BenchmarkResult {
-	taskId: string;
-	/** Task-type label for aggregation grouping. */
-	taskType?: string;
-	passed: boolean;
-	judgeResults: { description: string; passed: boolean; output?: string }[];
-	durationMs: number;
-	/** Estimated cost in dollars (0 if not tracked). */
-	cost: number;
-}
-
-/**
- * Validate command against allowlist to prevent shell injection.
- * Only allows specific safe commands with arguments.
- */
-/**
- * Validate command against allowlist to prevent shell injection.
- * Uses comprehensive shell metacharacter blocking similar to safe-bash.ts.
- */
-function validateCommand(command: string): void {
-	// Basic allowlist - must start with an allowed command.
-	// SECURITY (H-7): `npx`/`node` were removed because they enable arbitrary code
-	// execution without any shell metacharacter (e.g. `npx --yes evil-package`
-	// or `node -e "require('fs')…"`). Use `npm test`/`npm run …` instead of raw
-	// `node`/`npx` in benchmark task definitions.
-	// `echo` is allowed because the metachar blocker (validateGateCommand) rejects
-	// command substitution (`$(...)`, backticks), so `echo $(evil)` cannot run;
-	// bare `echo …` only prints. It's the canonical exit-0 command used in
-	// benchmark fixtures across Linux/macOS/Windows(sh).
-	const allowlist = /^(pytest|grep|npm test|cargo test|cargo clippy|echo) /;
-	if (!allowlist.test(command)) {
-		throw new Error(`Command not allowed: ${command}. Only pytest, grep, npm test, cargo test/clippy, echo allowed.`);
-	}
-
-	// Block shell metacharacters after command name
-	const afterCommand = command.substring(command.indexOf(" ") + 1);
-
-	// Block dangerous shell metacharacters
-	const dangerousPatterns = [
-		/[;&|`$(){}[\]<>\\]/, // Shell metacharacters
-		/\$\([^)]*\)/, // Command substitution $(...)
-		/`[^`]*`/, // Backtick command substitution
-		/\|/, // Pipe
-		/&&/, // And
-		/\|\|/, // Or
-		/>>/, // Append redirect
-		/2>&1/, // stderr redirect
-		/>/, // Output redirect
-		/</, // Input redirect
-	];
-
-	for (const pattern of dangerousPatterns) {
-		if (pattern.test(afterCommand)) {
-			throw new Error(`Shell metacharacters not allowed in command arguments`);
-		}
-	}
-}
-
-/**
- * Run a single benchmark task with tiered judges.
- * Tier 1: pytest (fast, deterministic)
- * Tier 2: grep pattern matching
- * Tier 3: command execution
- * Fails fast on first tier failure.
- */
-function splitCommand(command: string): { program: string; args: string[] } {
-	// Naive split on whitespace. validateCommand already rejects shell
-	// metacharacters, so a simple split is safe.
-	const parts = command.trim().split(/\s+/);
-	if (parts.length === 0) {
-		throw new Error("Empty command");
-	}
-	return { program: parts[0]!, args: parts.slice(1) };
-}
-
-export async function runBenchmark(task: BenchmarkTask): Promise<BenchmarkResult> {
-	const startTime = Date.now();
-	const judgeResults: BenchmarkResult["judgeResults"] = [];
-
-	for (const judge of task.judges) {
-		try {
-			let passed = false;
-			let output: string | undefined;
-
-			if (judge.type === "pytest" && judge.command) {
-				// Validate command before execution (defense-in-depth)
-				validateCommand(judge.command);
-				// Use execFileSync to avoid shell parsing. validateCommand
-				// already rejects metacharacters, so a simple split is safe.
-				const { program, args } = splitCommand(judge.command);
-				// Tier 1: pytest - fast deterministic check
-				output = execFileSync(program, args, {
-					timeout: 5000,
-					encoding: "utf-8",
-					cwd: process.cwd(),
-				});
-				// Look for pytest summary line with passed count
-				passed = output.includes("passed");
-			} else if (judge.type === "grep" && judge.pattern && judge.command) {
-				// Validate command before execution (defense-in-depth)
-				validateCommand(judge.command);
-				const { program, args } = splitCommand(judge.command);
-				// Tier 2: grep pattern matching
-				output = execFileSync(program, args, {
-					timeout: 5000,
-					encoding: "utf-8",
-					cwd: process.cwd(),
-				});
-				passed = output.includes(judge.pattern);
-			} else if (judge.type === "command" && judge.command) {
-				// Validate command before execution (defense-in-depth)
-				validateCommand(judge.command);
-				const { program, args } = splitCommand(judge.command);
-				// Tier 3: command execution
-				output = execFileSync(program, args, {
-					timeout: 10000,
-					encoding: "utf-8",
-					cwd: process.cwd(),
-				});
-				passed = true; // Command succeeded = pass
-			}
-
-			judgeResults.push({
-				description: judge.description,
-				passed: passed ?? false,
-				output,
-			});
-		} catch (e: unknown) {
-			const error = e as { message?: string };
-			judgeResults.push({
-				description: judge.description,
-				passed: false,
-				output: error.message ?? String(e),
-			});
-		}
-	}
-
-	return {
-		taskId: task.id,
-		passed: judgeResults.every((j) => j.passed),
-		judgeResults,
-		durationMs: Date.now() - startTime,
-		cost: 0,
-		taskType: task.taskType,
-	};
-}
-
-/**
- * Aggregate metrics computed over a group of benchmark results for a single task type.
- */
-export interface BenchmarkMetrics {
-	taskType: string;
-	totalTasks: number;
-	passedTasks: number;
-	/** Ratio of passed/total (0–1). */
-	passRate: number;
-	/** Mean execution duration in milliseconds. */
-	avgTimeMs: number;
-	/** Total estimated cost in dollars across all tasks. */
-	totalCost: number;
-	/** Mean cost in dollars per task. */
-	avgCost: number;
-}
-
-/**
- * Per-task-type aggregate metrics map.
- * Keys are task-type labels; "__default__" is used when a task has no label.
- */
-export type AggregateMetrics = Record<string, BenchmarkMetrics>;
-
-/**
- * Run multiple benchmark tasks and aggregate results.
- *
- * @param tasks - Benchmark tasks to execute. Each task may carry a `taskType` label.
- * @param taskTypes - Optional subset of task-type labels to run. If provided, only tasks
- *   whose `taskType` is in this set will be executed. If omitted, all tasks run.
- */
-export async function runBenchmarkSuite(
-	tasks: BenchmarkTask[],
-	taskTypes?: string[],
-): Promise<{
-	results: BenchmarkResult[];
-	totalPassed: number;
-	totalFailed: number;
-	totalDurationMs: number;
-	totalCost: number;
-}> {
-	const filtered = taskTypes ? tasks.filter((t) => t.taskType && taskTypes.includes(t.taskType)) : tasks;
-
-	const results: BenchmarkResult[] = [];
-
-	for (const task of filtered) {
-		const result = await runBenchmark(task);
-		results.push(result);
-	}
-
-	const totalPassed = results.filter((r) => r.passed).length;
-	const totalFailed = results.length - totalPassed;
-	const totalDurationMs = results.reduce((a, b) => a + b.durationMs, 0);
-	const totalCost = results.reduce((a, b) => a + b.cost, 0);
-
-	return { results, totalPassed, totalFailed, totalDurationMs, totalCost };
-}
-
-/**
- * Aggregate benchmark results into per-task-type metrics.
- *
- * @param results - Raw benchmark results (may include any task-type mix).
- * @returns A map from task-type label to `BenchmarkMetrics`. Tasks with no label
- *   are grouped under `"__default__"`.
- */
-export function aggregateBenchmarkMetrics(results: BenchmarkResult[]): AggregateMetrics {
-	const buckets: Record<string, BenchmarkResult[]> = {};
-
-	for (const result of results) {
-		const key = result.taskType ?? "__default__";
-		if (!buckets[key]) buckets[key] = [];
-		buckets[key].push(result);
-	}
-
-	const metrics: AggregateMetrics = {};
-
-	for (const [taskType, group] of Object.entries(buckets)) {
-		const totalTasks = group.length;
-		const passedTasks = group.filter((r) => r.passed).length;
-		const passRate = totalTasks > 0 ? passedTasks / totalTasks : 0;
-		const avgTimeMs = totalTasks > 0 ? group.reduce((s, r) => s + r.durationMs, 0) / totalTasks : 0;
-		const totalCost = group.reduce((s, r) => s + r.cost, 0);
-		const avgCost = totalTasks > 0 ? totalCost / totalTasks : 0;
-
-		metrics[taskType] = {
-			taskType,
-			totalTasks,
-			passedTasks,
-			passRate: Math.round(passRate * 1000) / 1000,
-			avgTimeMs: Math.round(avgTimeMs),
-			totalCost: Math.round(totalCost * 1e6) / 1e6,
-			avgCost: Math.round(avgCost * 1e6) / 1e6,
-		};
-	}
-
-	return metrics;
-}
-
-/**
- * Generate a markdown comparison table for benchmark results including per-type aggregates.
- *
- * @param results - Benchmark results to report.
- * @param includeTaskTypeComparison - When true (default), appends a per-task-type aggregate table.
- */
-export function generateBenchmarkReport(results: BenchmarkResult[], includeTaskTypeComparison = true): string {
-	const lines: string[] = ["# Benchmark Results", ""];
-
-	lines.push("| Task | Type | Status | Duration | Cost |");
-	lines.push("|------|------|--------|---------|------|");
-
-	for (const r of results) {
-		const status = r.passed ? "✅ PASS" : "❌ FAIL";
-		const type = r.taskType ?? "—";
-		const cost = r.cost > 0 ? `$${r.cost.toFixed(4)}` : "—";
-		lines.push(`| ${r.taskId} | ${type} | ${status} | ${r.durationMs}ms | ${cost} |`);
-	}
-
-	lines.push("");
-
-	// Per-type aggregate table.
-	if (includeTaskTypeComparison && results.length > 0) {
-		const metrics = aggregateBenchmarkMetrics(results);
-		const types = Object.keys(metrics).sort();
-
-		if (types.length > 0) {
-			lines.push("## Per-Task-Type Comparison", "");
-			lines.push("| Task Type | Total | Passed | Pass Rate | Avg Time | Avg Cost |");
-			lines.push("|-----------|-------|--------|-----------|----------|---------|");
-
-			for (const t of types) {
-				const m = metrics[t];
-				const passRatePct = `${(m.passRate * 100).toFixed(1)}%`;
-				const avgCostStr = m.avgCost > 0 ? `$${m.avgCost.toFixed(4)}` : "—";
-				lines.push(`| ${m.taskType} | ${m.totalTasks} | ${m.passedTasks} | ${passRatePct} | ${m.avgTimeMs}ms | ${avgCostStr} |`);
-			}
-		}
-	}
-
-	const passed = results.filter((r) => r.passed).length;
-	lines.push("");
-	lines.push(`**Total: ${passed}/${results.length} passed**`);
-
-	return lines.join("\n");
-}

package/src/benchmark/feedback-loop.ts

@@ -1,73 +0,0 @@
-/**
- * Feedback loop - continuous improvement cycle: evaluate → learn → apply → re-evaluate
- */
-
-import type { RunMetrics } from "../state/stores/run-metrics.ts";
-
-/** @internal */
-interface FeedbackLoopStats {
-	runsObserved: number;
-	avgSuccessRate: number;
-	recommendations: string[];
-}
-
-/** @internal */
-class FeedbackLoop {
-	private runs: RunMetrics[] = [];
-	private static readonly MAX_RUNS = 1000;
-
-	/**
-	 * Record a run's metrics for learning.
-	 */
-	recordRun(metrics: RunMetrics): void {
-		this.runs.push(metrics);
-		// Trim to MAX_RUNS to prevent unbounded memory growth
-		if (this.runs.length > FeedbackLoop.MAX_RUNS) {
-			this.runs = this.runs.slice(-FeedbackLoop.MAX_RUNS);
-		}
-	}
-
-	/**
-	 * Get current statistics and recommendations.
-	 */
-	getStats(): FeedbackLoopStats {
-		if (this.runs.length === 0) {
-			return {
-				runsObserved: 0,
-				avgSuccessRate: 0,
-				recommendations: ["No runs observed yet. Run some workflows to gather data."],
-			};
-		}
-
-		const successRates = this.runs.map((r) => (r.taskCount > 0 ? r.completedCount / r.taskCount : 0));
-		const avg = successRates.reduce((a, b) => a + b, 0) / successRates.length;
-
-		const recommendations: string[] = [];
-		if (avg >= 0.9) {
-			recommendations.push(`High success rate (${(avg * 100).toFixed(0)}%). Current configuration is working well.`);
-		} else if (avg >= 0.7) {
-			recommendations.push(`Moderate success rate (${(avg * 100).toFixed(0)}%). Consider reviewing failed tasks for patterns.`);
-		} else {
-			recommendations.push(`Low success rate (${(avg * 100).toFixed(0)}%). Investigate failure patterns.`);
-		}
-
-		// Cost awareness
-		const avgCost = this.runs.reduce((a, b) => a + b.totalCost, 0) / this.runs.length;
-		if (avgCost > 10) {
-			recommendations.push(`Average cost per run: $${avgCost.toFixed(2)}. Consider optimization.`);
-		}
-
-		return {
-			runsObserved: this.runs.length,
-			avgSuccessRate: avg,
-			recommendations,
-		};
-	}
-
-	/**
-	 * Clear recorded runs.
-	 */
-	clear(): void {
-		this.runs = [];
-	}
-}