ultimate-pi 0.19.1 → 0.22.0

package/.pi/lib/harness-run-context.ts

@@ -8,8 +8,15 @@
 
 import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve } from "node:path";
+import {
+	isPlanApprovalAskUser,
+	PLAN_APPROVE_OPTION,
+	PLAN_CANCEL_OPTION,
+} from "./ask-user/policy.js";
 import { readYamlFile, writeYamlFile } from "./harness-yaml.js";
 
+export { isPlanApprovalAskUser } from "./ask-user/policy.js";
+
 export type HarnessPhase =
 	| "plan"
 	| "execute"
@@ -171,11 +178,6 @@ export function steerMaxAttemptsFromEnv(): number {
 
 const MUTATING_FILE_TOOLS = new Set(["write", "edit"]);
 
-const PLAN_APPROVE_OPTION =
-	/^(approve(d)?(\s+plan)?|yes,?\s+proceed|looks\s+good)$/i;
-const PLAN_CANCEL_OPTION =
-	/^(cancel(led)?|revise|request\s+changes|needs?\s+clarification)$/i;
-
 export interface PlanUserApproval {
 	plan_id: string | null;
 	approved_at: string;
@@ -702,28 +704,6 @@ export function hasApprovedPlanSignalFromUserPrompt(prompt: string): boolean {
 	return false;
 }
 
-/** Detect parent-session ask_user calls that duplicate planner plan approval. */
-export function isPlanApprovalAskUser(input: {
-	question?: string;
-	options?: unknown[];
-}): boolean {
-	const q = String(input.question ?? "").trim();
-	const opts = Array.isArray(input.options) ? input.options : [];
-	const titles = opts.map((o) => {
-		if (typeof o === "string") return o.trim();
-		if (o && typeof o === "object" && "title" in o) {
-			return String((o as { title?: string }).title ?? "").trim();
-		}
-		return "";
-	});
-	const hasPlanOptions =
-		titles.some(
-			(t) => PLAN_APPROVE_OPTION.test(t) || PLAN_CANCEL_OPTION.test(t),
-		) || PLAN_APPROVE_OPTION.test(q);
-	if (!hasPlanOptions) return false;
-	return /plan|approve/i.test(q);
-}
-
 export function appendPlanApprovalIfNew(
 	appendEntry: (customType: string, data: unknown) => void,
 	parentEntries: unknown[],
@@ -1667,6 +1647,34 @@ export async function readReviewOutcomeFromRun(
 	}
 }
 
+function nextStepForEvaluateLikePhase(input: {
+	adversaryComplete?: boolean;
+	remediation: string;
+	evalStatus: string;
+	steerAttempt: number;
+	steerMax: number;
+}): string {
+	if (input.remediation === "pass" || input.evalStatus === "pass") {
+		if (input.adversaryComplete) return "/harness-policy-status";
+		return "/harness-review";
+	}
+	if (input.remediation === "rollback") return "/harness-incident";
+	if (input.remediation === "plan_gap") return "/harness-plan (mode: revise)";
+	if (
+		input.remediation === "implementation_gap" ||
+		(input.remediation === "inconclusive" && input.evalStatus === "fail")
+	) {
+		if (input.steerAttempt < input.steerMax) return "/harness-steer";
+		return "/harness-plan (mode: revise) or /harness-abort";
+	}
+	if (input.evalStatus === "fail") {
+		if (input.steerAttempt < input.steerMax) return "/harness-steer";
+		return "/harness-plan (mode: revise) or /harness-incident";
+	}
+	if (input.adversaryComplete) return "/harness-policy-status";
+	return "/harness-review";
+}
+
 export function nextStepAfterOutcome(input: {
 	phase: HarnessPhase;
 	planStatus?: string | null;
@@ -1730,31 +1738,13 @@ export function nextStepAfterOutcome(input: {
 	}
 
 	if (input.phase === "evaluate" || input.phase === "adversary") {
-		if (remediation === "pass" || evalSt === "pass") {
-			if (input.adversaryComplete) return "/harness-policy-status";
-			return "/harness-review";
-		}
-		if (remediation === "rollback") {
-			return "/harness-incident";
-		}
-		if (remediation === "plan_gap") {
-			return "/harness-plan (mode: revise)";
-		}
-		if (
-			remediation === "implementation_gap" ||
-			(remediation === "inconclusive" && evalSt === "fail")
-		) {
-			if (steerAttempt < steerMax) {
-				return "/harness-steer";
-			}
-			return "/harness-plan (mode: revise) or /harness-abort";
-		}
-		if (evalSt === "fail") {
-			if (steerAttempt < steerMax) return "/harness-steer";
-			return "/harness-plan (mode: revise) or /harness-incident";
-		}
-		if (input.adversaryComplete) return "/harness-policy-status";
-		return "/harness-review";
+		return nextStepForEvaluateLikePhase({
+			adversaryComplete: input.adversaryComplete,
+			remediation,
+			evalStatus: evalSt,
+			steerAttempt,
+			steerMax,
+		});
 	}
 
 	if (input.phase === "merge") return "/harness-policy-status";

package/.pi/lib/harness-sentrux-parse.mjs

@@ -0,0 +1,272 @@
+/**
+ * Parse sentrux check / gate CLI stdout (and optional upstream JSON).
+ */
+
+import { createHash } from "node:crypto";
+
+export const PARSER_VERSION = "1.0.0";
+
+const PROGRESS_LINE =
+	/^\[(?:scan|build_project_map|resolve|resolve_imports|build_graphs)\]/;
+
+const VIOLATION_HEAD =
+	/^([✗⚠])\s+\[(\w+)\]\s+([\w_]+):\s+(.+)$/;
+const QUALITY_LINE = /^Quality:\s*(\d+)\s*$/;
+const RULES_CHECKED = /^sentrux check —\s*(\d+)\s+rules checked/;
+const GATE_QUALITY =
+	/^Quality:\s*(\d+)\s*->\s*(\d+)\s*$/;
+const GATE_METRIC = /^(\w[\w\s]*?):\s*(.+?)\s*→\s*(.+?)\s*$/;
+const GATE_DEGRADED_LINE = /^✗\s+DEGRADED\s*$/i;
+const GATE_PASS_LINE = /^✓\s+No degradation detected/i;
+const GATE_VIOLATION = /^\s+✗\s+(.+)$/;
+
+/** Strip scan progress noise; keep user-facing lines. */
+export function filterSentruxOutputLines(text) {
+	return text
+		.split(/\r?\n/)
+		.filter((line) => line.trim() && !PROGRESS_LINE.test(line.trim()))
+		.filter((line) => !line.startsWith("Scanning "));
+}
+
+export function sha256(text) {
+	return createHash("sha256").update(text, "utf8").digest("hex");
+}
+
+/**
+ * @param {string} text — filtered check stdout
+ */
+export function parseCheckOutput(text) {
+	const lines = filterSentruxOutputLines(text);
+	const result = {
+		parse_ok: true,
+		parse_errors: [],
+		rules_checked: null,
+		quality_signal: null,
+		check_pass: true,
+		violations: [],
+	};
+
+	for (const line of lines) {
+		const rulesM = line.match(RULES_CHECKED);
+		if (rulesM) {
+			result.rules_checked = Number.parseInt(rulesM[1], 10);
+			continue;
+		}
+		const qM = line.match(QUALITY_LINE);
+		if (qM) {
+			result.quality_signal = Number.parseInt(qM[1], 10);
+			continue;
+		}
+		if (line.includes("violation(s) found")) {
+			result.check_pass = false;
+		}
+		if (line.includes("All rules pass")) {
+			result.check_pass = true;
+		}
+	}
+
+	const rawViolations = [];
+	let current = null;
+	for (const line of lines) {
+		const head = line.match(VIOLATION_HEAD);
+		if (head) {
+			if (current) rawViolations.push(current);
+			current = {
+				severity: head[2].toLowerCase(),
+				rule: head[3],
+				message: head[4].trim(),
+				files: [],
+			};
+			if (head[1] === "✗") result.check_pass = false;
+			continue;
+		}
+		if (current && /^\s{4}\S/.test(line)) {
+			current.files.push(line.trim());
+		}
+	}
+	if (current) rawViolations.push(current);
+
+	result.violations = dedupeViolations(rawViolations);
+	return result;
+}
+
+const BOUNDARY_PAIR = new Set(["layer_direction", "boundary"]);
+
+function filesKey(v) {
+	return [...v.files].sort().join("|");
+}
+
+function violationKey(v) {
+	return `${v.rule}::${filesKey(v)}`;
+}
+
+function dedupeViolations(raw) {
+	const byKey = new Map();
+	for (const v of raw) {
+		let key = violationKey(v);
+		if (BOUNDARY_PAIR.has(v.rule)) {
+			const fk = filesKey(v);
+			for (const [k, existing] of byKey) {
+				if (
+					BOUNDARY_PAIR.has(existing.rule) &&
+					filesKey(existing) === fk
+				) {
+					key = k;
+					break;
+				}
+			}
+		}
+		const existing = byKey.get(key);
+		if (!existing) {
+			byKey.set(key, { ...v, related_rules: [] });
+			continue;
+		}
+		if (existing.rule !== v.rule && !existing.related_rules.includes(v.rule)) {
+			existing.related_rules.push(v.rule);
+		}
+		if (v.severity === "error") existing.severity = "error";
+	}
+	return [...byKey.values()];
+}
+
+/**
+ * @param {string} text — filtered gate stdout
+ */
+export function parseGateOutput(text) {
+	const lines = filterSentruxOutputLines(text);
+	const result = {
+		parse_ok: true,
+		parse_errors: [],
+		status: "pass",
+		quality_before: null,
+		quality_after: null,
+		metrics: [],
+		degraded_reasons: [],
+	};
+
+	for (const line of lines) {
+		const qM = line.match(GATE_QUALITY);
+		if (qM) {
+			result.quality_before = Number.parseInt(qM[1], 10);
+			result.quality_after = Number.parseInt(qM[2], 10);
+			continue;
+		}
+		const mM = line.match(GATE_METRIC);
+		if (mM) {
+			result.metrics.push({
+				name: mM[1].trim().toLowerCase().replace(/\s+/g, "_"),
+				before: mM[2].trim(),
+				after: mM[3].trim(),
+			});
+			continue;
+		}
+		if (GATE_DEGRADED_LINE.test(line)) {
+			result.status = "degraded";
+			continue;
+		}
+		if (GATE_PASS_LINE.test(line)) {
+			result.status = "pass";
+			continue;
+		}
+		const vM = line.match(GATE_VIOLATION);
+		if (vM) {
+			result.degraded_reasons.push(vM[1].trim());
+		}
+	}
+
+	if (
+		result.quality_before != null &&
+		result.quality_after != null &&
+		result.quality_after < result.quality_before - 200
+	) {
+		if (!result.degraded_reasons.some((r) => /quality/i.test(r))) {
+			result.degraded_reasons.push(
+				`Quality signal dropped: ${result.quality_before} -> ${result.quality_after}`,
+			);
+		}
+	}
+
+	return result;
+}
+
+/** Map violation rules → inferred bottleneck root-cause bucket. */
+export function inferBottleneck(violations, gate) {
+	const rules = new Set(violations.map((v) => v.rule));
+	if (rules.has("boundary") || rules.has("layer_direction")) {
+		return { bottleneck: "modularity", bottleneck_inferred: true };
+	}
+	if (rules.has("max_cc") || rules.has("max_fn_lines")) {
+		return { bottleneck: "equality", bottleneck_inferred: true };
+	}
+	if (rules.has("max_cycles")) {
+		return { bottleneck: "acyclicity", bottleneck_inferred: true };
+	}
+	if (gate?.degraded_reasons?.some((r) => /coupling/i.test(r))) {
+		return { bottleneck: "modularity", bottleneck_inferred: true };
+	}
+	if (gate?.degraded_reasons?.some((r) => /complex function/i.test(r))) {
+		return { bottleneck: "equality", bottleneck_inferred: true };
+	}
+	return { bottleneck: "modularity", bottleneck_inferred: true };
+}
+
+/** Parse `path:func (cc=N)` from max_cc violation file lines. */
+export function parseComplexFunctionEntries(violations) {
+	const out = [];
+	for (const v of violations) {
+		if (v.rule !== "max_cc") continue;
+		for (const f of v.files) {
+			const m = f.match(/^(.+?):([^(\s]+)\s*\(cc=(\d+)\)\s*$/);
+			if (m) {
+				out.push({
+					file: m[1],
+					func: m[2],
+					cc: Number.parseInt(m[3], 10),
+				});
+			}
+		}
+	}
+	return out;
+}
+
+/** Parse god file lines from no_god_files violations. */
+export function parseGodFileEntries(violations) {
+	const out = [];
+	for (const v of violations) {
+		if (v.rule !== "no_god_files") continue;
+		for (const f of v.files) {
+			const m = f.match(/^(.+?)\s*\(fan-out=(\d+)\)/);
+			if (m) {
+				out.push({ path: m[1], fan_out: Number.parseInt(m[2], 10) });
+			} else {
+				out.push({ path: f, fan_out: null });
+			}
+		}
+	}
+	return out;
+}
+
+/**
+ * Try upstream `sentrux check --format json` payload (future / optional).
+ * @param {unknown} json
+ */
+export function normalizeUpstreamCheckJson(json) {
+	if (!json || typeof json !== "object") return null;
+	const doc = /** @type {Record<string, unknown>} */ (json);
+	if (doc.format !== "json" && !doc.violations && !doc.diagnostics) {
+		return null;
+	}
+	return {
+		source: "upstream",
+		check_pass: doc.check_pass !== false && !(doc.violation_count > 0),
+		quality_signal:
+			typeof doc.quality_signal === "number" ? doc.quality_signal : null,
+		rules_checked:
+			typeof doc.rules_checked === "number" ? doc.rules_checked : null,
+		violations: Array.isArray(doc.violations) ? doc.violations : [],
+		bottleneck: typeof doc.bottleneck === "string" ? doc.bottleneck : null,
+		root_causes: doc.root_causes ?? null,
+		diagnostics: doc.diagnostics ?? null,
+		bottleneck_inferred: false,
+	};
+}

package/.pi/lib/harness-sentrux-root.mjs

@@ -0,0 +1,78 @@
+/**
+ * Resolve harness project root for Sentrux (.sentrux/rules.toml or architecture manifest).
+ */
+
+import { access } from "node:fs/promises";
+import { constants } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+
+export const SENTRUX_ROOT_MARKERS = [
+	join(".sentrux", "rules.toml"),
+	join(".pi", "harness", "sentrux", "architecture.manifest.json"),
+];
+
+export async function fileExists(path) {
+	try {
+		await access(path, constants.R_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function hasSentruxRootMarker(dir) {
+	for (const marker of SENTRUX_ROOT_MARKERS) {
+		if (await fileExists(join(dir, marker))) return true;
+	}
+	return false;
+}
+
+export async function findSentruxProjectRoot(startDir) {
+	let dir = resolve(startDir || process.cwd());
+	while (true) {
+		if (await hasSentruxRootMarker(dir)) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+
+export function takeRootArg(args) {
+	const next = [];
+	let explicitRoot = process.env.HARNESS_PROJECT_ROOT || "";
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--root") {
+			explicitRoot = args[i + 1] || "";
+			i++;
+			continue;
+		}
+		if (arg.startsWith("--root=")) {
+			explicitRoot = arg.slice("--root=".length);
+			continue;
+		}
+		next.push(arg);
+	}
+	return { args: next, explicitRoot };
+}
+
+export async function resolveSentruxProjectRoot(explicitRoot) {
+	if (explicitRoot) {
+		const root = isAbsolute(explicitRoot)
+			? resolve(explicitRoot)
+			: resolve(process.cwd(), explicitRoot);
+		if (!(await hasSentruxRootMarker(root))) {
+			throw new Error(
+				`${root} has no .sentrux/rules.toml or .pi/harness/sentrux/architecture.manifest.json`,
+			);
+		}
+		return root;
+	}
+	const root = await findSentruxProjectRoot(process.cwd());
+	if (!root) {
+		throw new Error(
+			"could not find a harness project root above the current directory",
+		);
+	}
+	return root;
+}

package/.pi/lib/harness-slash-completions.ts

@@ -0,0 +1,116 @@
+/**
+ * Shared slash-command argument completions for harness extension commands.
+ */
+
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+import {
+	harnessRunsRoot,
+	RUN_CONTEXT_BASENAME,
+} from "./harness-run-context.js";
+
+const MAX_RUN_SUGGESTIONS = 20;
+
+export function filterPrefix(
+	items: AutocompleteItem[],
+	prefix: string,
+): AutocompleteItem[] | null {
+	const p = prefix.trim();
+	if (!p) return items.length > 0 ? items : null;
+	const filtered = items.filter(
+		(item) =>
+			item.value.startsWith(p) ||
+			(item.label !== undefined && item.label.startsWith(p)),
+	);
+	return filtered.length > 0 ? filtered : null;
+}
+
+export function completeFlags(
+	prefix: string,
+	flags: string[],
+): AutocompleteItem[] | null {
+	const items = flags.map((flag) => ({ value: flag, label: flag }));
+	return filterPrefix(items, prefix);
+}
+
+export function completeEnum(
+	prefix: string,
+	values: string[],
+): AutocompleteItem[] | null {
+	return completeFlags(prefix, values);
+}
+
+export async function completeRunIds(
+	prefix: string,
+	projectRoot: string,
+): Promise<AutocompleteItem[] | null> {
+	const runsDir = harnessRunsRoot(projectRoot);
+	let names: string[];
+	try {
+		names = await readdir(runsDir);
+	} catch {
+		return null;
+	}
+
+	const entries: { id: string; mtime: number; phase?: string }[] = [];
+	for (const name of names) {
+		if (name.startsWith(".")) continue;
+		const dir = join(runsDir, name);
+		try {
+			const st = await stat(dir);
+			if (!st.isDirectory()) continue;
+			let phase: string | undefined;
+			try {
+				const raw = await readFile(join(dir, RUN_CONTEXT_BASENAME), "utf-8");
+				const match = raw.match(/^phase:\s*(\S+)/m);
+				if (match) phase = match[1];
+			} catch {
+				/* optional */
+			}
+			entries.push({ id: name, mtime: st.mtimeMs, phase });
+		} catch {}
+	}
+
+	entries.sort((a, b) => b.mtime - a.mtime);
+	const items: AutocompleteItem[] = entries
+		.slice(0, MAX_RUN_SUGGESTIONS)
+		.map((entry) => ({
+			value: entry.id,
+			label: entry.id,
+			description: entry.phase ? `phase ${entry.phase}` : undefined,
+		}));
+
+	return filterPrefix(items, prefix);
+}
+
+export async function completeHarnessUseRun(
+	prefix: string,
+	projectRoot: string,
+): Promise<AutocompleteItem[] | null> {
+	const p = prefix.trim();
+	if (p.startsWith("-")) {
+		return completeFlags(p, ["--claim", "--readonly"]);
+	}
+	return completeRunIds(p, projectRoot);
+}
+
+export function completeStrictFlag(prefix: string): AutocompleteItem[] | null {
+	return completeFlags(prefix, ["--strict"]);
+}
+
+export async function completeDebateOpen(
+	prefix: string,
+	projectRoot: string,
+): Promise<AutocompleteItem[] | null> {
+	const runs = await completeRunIds("", projectRoot);
+	if (!runs?.length) {
+		return filterPrefix([{ value: "plan-", label: "plan-<run-id>" }], prefix);
+	}
+	const items = runs.map((run) => ({
+		value: `plan-${run.value}`,
+		label: `plan-${run.value}`,
+		description: run.description,
+	}));
+	return filterPrefix(items, prefix);
+}