pi-crew 0.9.50 → 0.9.52

package/src/workflows/discover-workflows.ts

@@ -1,290 +0,0 @@
-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 { packageRoot, projectCrewRoot, userPiRoot } from "../utils/paths.ts";
-import type { WorkflowConfig, WorkflowStep } from "./workflow-config.ts";
-
-export interface WorkflowDiscoveryResult {
-	builtin: WorkflowConfig[];
-	user: WorkflowConfig[];
-	project: WorkflowConfig[];
-}
-
-const STEP_CONFIG_KEYS = new Set([
-	"role",
-	"dependsOn",
-	"parallelGroup",
-	"output",
-	"reads",
-	"model",
-	"skills",
-	"progress",
-	"worktree",
-	"verify",
-	"task",
-	"seedPaths",
-	"preStepScript",
-	"preStepArgs",
-	"preStepTimeout",
-	"preStepOptional",
-]);
-
-function parseStepSection(id: string, body: string): WorkflowStep | undefined {
-	const lines = body.trim().split("\n");
-	const config: Record<string, string> = {};
-	const taskLines: string[] = [];
-	let inTask = false;
-	let sawConfig = false;
-	for (const line of lines) {
-		if (!inTask) {
-			if (line.trim() === "") {
-				if (!sawConfig) continue;
-				inTask = true;
-				continue;
-			}
-			const match = line.match(/^([\w-]+):\s*(.*)$/);
-			if (match) {
-				config[match[1]!.trim()] = match[2]!.trim();
-				sawConfig = true;
-				continue;
-			}
-			inTask = true;
-		}
-		taskLines.push(line);
-	}
-	const role = config.role || id;
-	return {
-		id,
-		role,
-		task: taskLines.join("\n").trim() || config.task || "{goal}",
-		dependsOn: parseCsv(config.dependsOn),
-		parallelGroup: config.parallelGroup || undefined,
-		output: config.output === "false" ? false : config.output || undefined,
-		reads: config.reads === "false" ? false : parseCsv(config.reads),
-		model: config.model || undefined,
-		skills: config.skills === "false" ? false : parseCsv(config.skills),
-		progress: config.progress === "true" ? true : config.progress === "false" ? false : 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,
-		preStepScript: config.preStepScript || undefined,
-		preStepArgs: parseCsv(config.preStepArgs) || undefined,
-		preStepTimeout: parseOptionalInteger(config.preStepTimeout) ?? undefined,
-		preStepOptional: config.preStepOptional === "true" || config.preStepOptional === "1",
-	};
-}
-
-const parseOptionalInteger = (value: string | undefined): number | undefined => {
-	const trimmed = value?.trim();
-	if (!trimmed) return undefined;
-	const n = Number.parseInt(trimmed, 10);
-	return Number.isNaN(n) ? undefined : n;
-};
-
-const parseOptionalBoolean = (value: string | undefined): boolean | undefined => {
-	const trimmed = value?.trim().toLowerCase();
-	if (!trimmed) return undefined;
-	if (trimmed === "true" || trimmed === "yes" || trimmed === "1") return true;
-	if (trimmed === "false" || trimmed === "no" || trimmed === "0") return false;
-	return undefined;
-};
-
-/** Parse frontmatter `topology:` field. Validates against allowed enum; bad values are silently
- *  dropped (fall through to auto-classification in topology-analyzer). */
-const parseTopology = (value: string | undefined): WorkflowConfig["topology"] => {
-	if (!value) return undefined;
-	const v = value.trim().toLowerCase();
-	if (v === "single" || v === "sequential" || v === "concurrent" || v === "complex-dag" || v === "dynamic") {
-		return v;
-	}
-	return undefined;
-};
-
-function hasSectionBoundary(body: string, match: RegExpMatchArray): boolean {
-	const index = match.index ?? 0;
-	if (index === 0 || body.slice(0, index).trim() === "") return true;
-	const prev = body.slice(Math.max(0, index - 2), index);
-	// Accept blank line or single newline before heading.
-	return prev === "\n\n" || prev.endsWith("\n");
-}
-
-function isStepHeading(body: string, match: RegExpMatchArray): boolean {
-	const sectionStart = match.index! + match[0].length + (body[match.index! + match[0].length] === "\n" ? 1 : 0);
-	const nextHeading = body.slice(sectionStart).search(/^##\s+.+[^\S\n]*$/m);
-	const section = body.slice(sectionStart, nextHeading >= 0 ? sectionStart + nextHeading : body.length);
-	for (const line of section.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		const config = trimmed.match(/^([\w-]+):\s*(.*)$/);
-		if (config && STEP_CONFIG_KEYS.has(config[1]!)) return true;
-		return false;
-	}
-	return false;
-}
-
-function parseWorkflowFile(filePath: string, source: ResourceSource): WorkflowConfig | undefined {
-	try {
-		const content = fs.readFileSync(filePath, "utf-8");
-		const { frontmatter, body } = parseFrontmatter(content);
-		const name = frontmatter.name?.trim() || path.basename(filePath, ".workflow.md");
-		const matches = [...body.matchAll(/^##\s+(.+)[^\S\n]*$/gm)];
-		const explicitStepIndexes = new Set(
-			matches
-				.map((match, index) => (isStepHeading(body, match) ? index : undefined))
-				.filter((index): index is number => index !== undefined),
-		);
-		const effectiveMatches = matches.filter(
-			(match, index) =>
-				explicitStepIndexes.has(index) || (hasSectionBoundary(body, match) && /^[a-z][a-z0-9-]*$/.test(match[1]?.trim() ?? "")),
-		);
-		const parseMatches = explicitStepIndexes.size ? effectiveMatches : matches;
-		const steps: WorkflowStep[] = [];
-		for (let i = 0; i < parseMatches.length; i++) {
-			const match = parseMatches[i]!;
-			const id = match[1]!.trim();
-			const sectionStart = match.index! + match[0].length + (body[match.index! + match[0].length] === "\n" ? 1 : 0);
-			const sectionEnd = i + 1 < parseMatches.length ? parseMatches[i + 1]!.index! : body.length;
-			const step = parseStepSection(id, body.slice(sectionStart, sectionEnd));
-			if (step) steps.push(step);
-		}
-		return {
-			name,
-			description: frontmatter.description?.trim() || "No description provided.",
-			source,
-			filePath,
-			maxConcurrency: parseOptionalInteger(frontmatter.maxConcurrency),
-			topology: parseTopology(frontmatter.topology),
-			coalesceMicroTasks: parseOptionalBoolean(frontmatter.coalesceMicroTasks),
-			steps,
-		};
-	} catch {
-		return undefined;
-	}
-}
-
-function readWorkflowDir(dir: string, source: ResourceSource): WorkflowConfig[] {
-	if (!fs.existsSync(dir)) return [];
-	const staticWorkflows = fs
-		.readdirSync(dir)
-		.filter((entry) => entry.endsWith(".workflow.md"))
-		.map((entry) => parseWorkflowFile(path.join(dir, entry), source))
-		.filter((workflow): workflow is WorkflowConfig => workflow !== undefined)
-		.sort((a, b) => a.name.localeCompare(b.name));
-	// P2: also discover dynamic workflows (*.dwf.ts). A .dwf.ts's default export is a JS orchestrator.
-	const dynamicWorkflows = fs
-		.readdirSync(dir)
-		.filter((entry) => entry.endsWith(".dwf.ts"))
-		.map((entry) => parseDynamicWorkflowFile(path.join(dir, entry), source))
-		.filter((workflow): workflow is WorkflowConfig => workflow !== undefined);
-	return [...staticWorkflows, ...dynamicWorkflows].sort((a, b) => a.name.localeCompare(b.name));
-}
-
-/** P2: a .dwf.ts is a dynamic workflow. Name = filename stem; script = the file itself. */
-function parseDynamicWorkflowFile(filePath: string, source: ResourceSource): WorkflowConfig | undefined {
-	try {
-		const basename = path.basename(filePath, ".dwf.ts");
-		return {
-			name: basename,
-			description: `Dynamic workflow script (${basename}.dwf.ts).`,
-			source,
-			filePath,
-			steps: [],
-			runtime: "dynamic",
-			dynamicScript: filePath,
-		};
-	} catch {
-		return undefined;
-	}
-}
-
-// ─── Workflow Discovery Cache (F17) ──────────────────────────────────────
-// Mirrors the Agent Discovery Cache pattern (see discover-agents.ts:493-556).
-// `discoverWorkflows(cwd)` is called on the powerbar hot path (≤200 ms coalesce =
-// up to ~5 Hz when a run is active + emitting events). Without caching, each call
-// walks 3 roots, each requiring readdirSync × 2 + readFileSync + regex-parse per
-// `.workflow.md`. We use TTL + dir-stamp invalidation so the cache survives
-// steady-state rendering yet still picks up file changes within a few seconds.
-//
-// SECURITY: ResourceIdentity preserved — same precedence + same parsers as before.
-// Reviewers: there is no path-component concern; this only memoises a pure function
-// of the filesystem state into a process-local Map.
-const WORKFLOW_DISCOVERY_TTL_MS = 5000;
-const WORKFLOW_DISCOVERY_MAX_ENTRIES = 32;
-interface CachedWorkflowEntry {
-	result: WorkflowDiscoveryResult;
-	expiresAt: number;
-	/** mtime tuple of the 3 workflow source dirs; change ⇒ invalidate early. */
-	dirStamp: string;
-}
-const workflowCache = new Map<string, CachedWorkflowEntry>();
-
-/** Compact mtime signature for the 3 workflow source dirs. Cheap (3 statSync). */
-function workflowDirStamp(cwd: string): string {
-	const dirs = [
-		path.join(packageRoot(), "workflows"),
-		path.join(userPiRoot(), "workflows"),
-		path.join(projectCrewRoot(cwd), "workflows"),
-	];
-	let out = "";
-	for (const d of dirs) {
-		try {
-			const st = fs.statSync(d);
-			out += `${st.mtimeMs}|`;
-		} catch {
-			out += "0|";
-		}
-	}
-	return out;
-}
-
-/** Drop one or all cached entries. Called from management actions and tests. */
-export function invalidateWorkflowDiscoveryCache(cwd?: string): void {
-	if (cwd) {
-		workflowCache.delete(cwd);
-	} else {
-		workflowCache.clear();
-	}
-}
-
-export function discoverWorkflows(cwd: string): WorkflowDiscoveryResult {
-	if (!cwd || typeof cwd !== "string") {
-		return { builtin: [], user: [], project: [] };
-	}
-	// F17: serve from cache when both TTL is fresh AND dir-stamp is unchanged.
-	// `dirStamp` is a 3-stat pulse we run on every cached call — it is much
-	// cheaper than the disk scan it protects against (3 statSync vs 2 readdirSync
-	// + N readFileSync + regex parse per `.workflow.md`).
-	const now = Date.now();
-	const stamp = workflowDirStamp(cwd);
-	const cached = workflowCache.get(cwd);
-	if (cached && cached.expiresAt > now && cached.dirStamp === stamp) {
-		return cached.result;
-	}
-	const result: WorkflowDiscoveryResult = {
-		builtin: readWorkflowDir(path.join(packageRoot(), "workflows"), "builtin"),
-		user: readWorkflowDir(path.join(userPiRoot(), "workflows"), "user"),
-		project: readWorkflowDir(path.join(projectCrewRoot(cwd), "workflows"), "project"),
-	};
-	workflowCache.set(cwd, {
-		result,
-		expiresAt: now + WORKFLOW_DISCOVERY_TTL_MS,
-		dirStamp: stamp,
-	});
-	// Bounded LRU-ish eviction by insertion order (Map iteration order).
-	while (workflowCache.size > WORKFLOW_DISCOVERY_MAX_ENTRIES) {
-		const oldest = workflowCache.keys().next().value;
-		if (oldest === undefined) break;
-		workflowCache.delete(oldest);
-	}
-	return result;
-}
-
-export function allWorkflows(discovery: WorkflowDiscoveryResult | undefined): WorkflowConfig[] {
-	if (!discovery) return [];
-	const byName = new Map<string, WorkflowConfig>();
-	for (const workflow of [...discovery.project, ...discovery.builtin, ...discovery.user]) {
-		byName.set(workflow.name, workflow);
-	}
-	return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}

package/src/workflows/intermediate-store.ts

@@ -1,166 +0,0 @@
-/**
- * Phase-gated intermediate store — persist workflow step outputs to disk.
- *
- * Pattern origin: Understand-Anything 7-phase pipeline where each phase
- * writes structured JSON to intermediate/ directory. Phase N reads Phase N-1
- * output from disk (not context). Enables:
- * - Context isolation between steps
- * - Incremental re-runs (skip completed phases)
- * - Debugging (inspect intermediate outputs)
- */
-
-import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { logInternalError } from "../utils/internal-error.ts";
-import { isSafePathId } from "../utils/safe-paths.ts";
-
-// ── Types ────────────────────────────────────────────────────────────────
-
-export interface IntermediateOutput {
-	phase: string;
-	stepId: string;
-	timestamp: string;
-	data: unknown;
-}
-
-export interface IntermediateStoreConfig {
-	/** Root directory for intermediates (e.g., ".crew/intermediate/") */
-	intermediateDir: string;
-	/** File patterns to preserve across runs (e.g., ["scan-result.json"]) */
-	preservePatterns: string[];
-}
-
-// ── Store Operations ─────────────────────────────────────────────────────
-
-const DEFAULT_CONFIG: IntermediateStoreConfig = {
-	intermediateDir: ".crew/intermediate",
-	preservePatterns: [],
-};
-
-/**
- * Ensure the intermediate directory exists.
- */
-export function ensureIntermediateDir(config: Partial<IntermediateStoreConfig> = {}): string {
-	const dir = config.intermediateDir ?? DEFAULT_CONFIG.intermediateDir;
-	mkdirSync(dir, { recursive: true });
-	return dir;
-}
-
-/**
- * Write an intermediate output for a phase.
- *
- * @param config - Store configuration
- * @param phase - Phase name (e.g., "explore", "analyze")
- * @param stepId - Step ID for correlation
- * @param data - Phase output data
- * @returns Path to the written file
- */
-export function writeIntermediate(config: Partial<IntermediateStoreConfig>, phase: string, stepId: string, data: unknown): string {
-	// Security: validate phase/stepId before building the filename to prevent
-	// path traversal via poisoned phase or stepId.
-	if (!isSafePathId(phase) || !isSafePathId(stepId)) {
-		throw new Error("Invalid phase or stepId for intermediate store");
-	}
-	const dir = ensureIntermediateDir(config);
-	const filename = `${phase}-${stepId}.json`;
-	const filePath = path.join(dir, filename);
-
-	const output: IntermediateOutput = {
-		phase,
-		stepId,
-		timestamp: new Date().toISOString(),
-		data,
-	};
-
-	writeFileSync(filePath, JSON.stringify(output, null, 2), "utf-8");
-	return filePath;
-}
-
-/**
- * Read an intermediate output for a phase.
- *
- * @param config - Store configuration
- * @param phase - Phase name
- * @param stepId - Step ID
- * @returns Parsed intermediate output, or undefined if not found
- */
-export function readIntermediate(config: Partial<IntermediateStoreConfig>, phase: string, stepId: string): IntermediateOutput | undefined {
-	// M-2 fix (code-review 2026-06-23): validate phase/stepId before building the
-	// filename to prevent path traversal via a poisoned stepId.
-	if (!isSafePathId(phase) || !isSafePathId(stepId)) return undefined;
-	const dir = config.intermediateDir ?? DEFAULT_CONFIG.intermediateDir;
-	const filename = `${phase}-${stepId}.json`;
-	const filePath = path.join(dir, filename);
-
-	if (!existsSync(filePath)) return undefined;
-
-	try {
-		const content = readFileSync(filePath, "utf-8");
-		return JSON.parse(content) as IntermediateOutput;
-	} catch (error) {
-		logInternalError("intermediate-store.read", error, `filePath=${filePath}`);
-		return undefined;
-	}
-}
-
-/**
- * Read the most recent intermediate output for any phase.
- *
- * Useful when you don't know the exact stepId but want the latest
- * output from a phase (e.g., for incremental re-runs).
- */
-export function readLatestIntermediate(config: Partial<IntermediateStoreConfig>, phase: string): IntermediateOutput | undefined {
-	const dir = config.intermediateDir ?? DEFAULT_CONFIG.intermediateDir;
-	if (!existsSync(dir)) return undefined;
-
-	const files = readdirSync(dir)
-		.filter((f) => f.startsWith(`${phase}-`) && f.endsWith(".json"))
-		.sort()
-		.reverse(); // most recent first
-
-	if (files.length === 0) return undefined;
-
-	try {
-		const content = readFileSync(path.join(dir, files[0]!), "utf-8");
-		return JSON.parse(content) as IntermediateOutput;
-	} catch {
-		return undefined;
-	}
-}
-
-/**
- * Clean up intermediate files, preserving specified patterns.
- *
- * @param config - Store configuration
- * @returns Number of files removed
- */
-export function cleanupIntermediates(config: Partial<IntermediateStoreConfig> = {}): number {
-	const dir = config.intermediateDir ?? DEFAULT_CONFIG.intermediateDir;
-	const preserve = config.preservePatterns ?? DEFAULT_CONFIG.preservePatterns;
-
-	if (!existsSync(dir)) return 0;
-
-	const files = readdirSync(dir);
-	let removed = 0;
-
-	for (const file of files) {
-		const shouldPreserve = preserve.some((pattern) => file.includes(pattern));
-		if (!shouldPreserve) {
-			try {
-				unlinkSync(path.join(dir, file));
-				removed++;
-			} catch (error) {
-				logInternalError("intermediate-store.cleanup", error, `file=${file}`);
-			}
-		}
-	}
-
-	return removed;
-}
-
-/**
- * Check if a phase has completed (intermediate exists).
- */
-export function hasPhaseCompleted(config: Partial<IntermediateStoreConfig>, phase: string, stepId: string): boolean {
-	return readIntermediate(config, phase, stepId) !== undefined;
-}

package/src/workflows/preflight-validator.ts

@@ -1,168 +0,0 @@
-// src/workflows/preflight-validator.ts
-//
-// Decision tree from .crew/knowledge.md "pi-crew USAGE THRESHOLD RULE"
-// (3-step refined rule, 2026-06-29). The validator runs synchronously
-// before executeTeamRun and returns a structured result; it NEVER throws.
-// Call sites decide whether to short-circuit (block) or just log (warn).
-//
-// The validator is a pure function: it accepts an optional eventAppender
-// in PreflightOptions for future telemetry wiring but does NOT call it
-// itself. Integration call sites (Phase 3) will fire telemetry from the
-// result they receive. This keeps the validator side-effect free and
-// trivially testable.
-
-import { analyzeWorkflowTopology, type WorkflowTopology } from "./topology-analyzer.ts";
-import type { WorkflowConfig } from "./workflow-config.ts";
-
-export interface PreflightOptions {
-	/** When true, downgrade any block/warn to allow. Audit trail should log the override. */
-	force?: boolean;
-	/** Optional hook reserved for future telemetry wiring. Not invoked by the validator. */
-	eventAppender?: (eventsPath: string, event: object) => void;
-}
-
-export interface PreflightResult {
-	/**
-	 * Advisory severity. NEVER blocks execution — all levels log a note and proceed.
-	 * - `info`  — context-only, e.g. dynamic workflow, force-bypass acknowledged.
-	 * - `note`  — topology=`concurrent` or `complex-dag`: validated good use cases.
-	 * - `warn`  — potential misuse (single / sequential 2–3 / 4+ sequential). Provides
-	 *             the measured cost evidence (Run #3, Run #1) so the agent can decide
-	 *             whether to proceed or refactor into raw Agent calls.
-	 */
-	level: "info" | "note" | "warn";
-	message: string;
-	suggestion: string;
-	topology: WorkflowTopology;
-	/** Mirrored from TopologyAnalysis for telemetry — useful to scope warn events. */
-	stepCount: number;
-	/** Mirrored from TopologyAnalysis — what the analyzer recommends. */
-	recommendation: string;
-}
-
-function info(topology: WorkflowTopology, stepCount: number, recommendation: string, message: string): PreflightResult {
-	return {
-		level: "info",
-		message,
-		suggestion: "",
-		topology,
-		stepCount,
-		recommendation,
-	};
-}
-
-function note(topology: WorkflowTopology, stepCount: number, recommendation: string, message: string): PreflightResult {
-	return {
-		level: "note",
-		message,
-		suggestion: "Validated use case — proceeding.",
-		topology,
-		stepCount,
-		recommendation,
-	};
-}
-
-function warn(topology: WorkflowTopology, stepCount: number, recommendation: string, message: string, suggestion: string): PreflightResult {
-	return {
-		level: "warn",
-		message,
-		suggestion,
-		topology,
-		stepCount,
-		recommendation,
-	};
-}
-
-/**
- * Validate workflow usage against the topology threshold rule.
- *
- * **Returns a PreflightResult. NEVER blocks the call.** The validator is advisory only —
- * the agent (caller) decides whether to proceed, refactor, or override. This honors
- * Pi's design philosophy: tooling provides information, agents exercise judgment.
- *
- * Severity levels:
- * - `info`  — context-only (dynamic, force-bypass acknowledged).
- * - `note`  — validated use case (`concurrent`, `complex-dag`). Proceed.
- * - `warn`  — potential inefficiency. Provides measured cost evidence so the agent
- *             can weigh the trade-off (e.g. audit-trail value vs. raw-call speed).
- *
- * No `block` level exists — there is no scenario where pi-crew hard-rejects a call.
- * The agent always gets to decide.
- */
-export function validateWorkflowUsage(workflow: WorkflowConfig, options: PreflightOptions = {}): PreflightResult {
-	const analysis = analyzeWorkflowTopology(workflow);
-	const { topology, stepCount, recommendation } = analysis;
-
-	// Rule 0: dynamic workflows are runtime-decided.
-	if (topology === "dynamic") {
-		return info(topology, stepCount, recommendation, "Dynamic workflow — runtime decides topology.");
-	}
-
-	// Rule 0b: explicit force-bypass acknowledged (still log it).
-	if (options.force === true) {
-		return info(
-			topology,
-			stepCount,
-			recommendation,
-			`Force-bypassed preflight acknowledged (topology=${topology}, stepCount=${stepCount}). Proceeding as requested.`,
-		);
-	}
-
-	// Rule 1: SINGLE — advisory note that raw Agent would be simpler.
-	if (topology === "single") {
-		return warn(
-			topology,
-			stepCount,
-			recommendation,
-			"Single-task workflow: pi-crew overhead exceeds benefit; raw Agent tool would be ~30× faster and ~5× cheaper. Proceeding anyway — proceed only if audit trail or team coordination matters here.",
-			"Consider using the raw Agent tool instead. If proceeding, no action needed — pi-crew will run the workflow as configured.",
-		);
-	}
-
-	// Rule 2: SEQUENTIAL — note per chain length with measured cost evidence.
-	if (topology === "sequential") {
-		if (stepCount === 2) {
-			return warn(
-				topology,
-				stepCount,
-				recommendation,
-				"2-step sequential chain: pi-crew adds overhead; 2 raw Agent calls would be faster. Proceeding anyway.",
-				"Consider 2 raw Agent calls in one turn if speed matters. Otherwise, no action needed.",
-			);
-		}
-		if (stepCount === 3) {
-			return warn(
-				topology,
-				stepCount,
-				recommendation,
-				"3-step sequential chain: measured 5.7× slower and 1.9× costlier than 3 raw Agent calls (Run #3 in .crew/state/runs/). Proceeding anyway.",
-				"Consider 3 raw Agent calls. If audit trail justifies overhead, proceed.",
-			);
-		}
-		return warn(
-			topology,
-			stepCount,
-			recommendation,
-			`${stepCount}-step sequential chain: longer chains may justify pi-crew for audit/dag-context reasons, but raw Agent calls remain faster. Proceeding anyway.`,
-			"Consider chaining raw Agent calls if speed matters. Otherwise, no action needed.",
-		);
-	}
-
-	// Rule 3: CONCURRENT — validated good use case, informational note.
-	if (topology === "concurrent") {
-		return note(
-			topology,
-			stepCount,
-			recommendation,
-			`Validated use case: ${analysis.fanOutDegree}-way parallel fan-out. pi-crew's parallelism wins here.`,
-		);
-	}
-
-	// Rule 4: COMPLEX_DAG — validated good use case, informational note.
-	return note(
-		topology,
-		stepCount,
-		recommendation,
-		`Validated use case: complex DAG with ${stepCount} steps, depth ${analysis.dagDepth}. pi-crew's dependency-context injection and adaptive-plan support wins here.`,
-	);
-}