ultimate-pi 0.20.0 → 0.22.0

package/.pi/lib/harness-lens/tools/lsp-navigation.ts

@@ -723,6 +723,15 @@ function buildNavigationOutput(args: {
 	return { output, actionStats, isEmpty, resultCount };
 }
 
+function isDirectoryPath(filePath: string): boolean {
+	if (!filePath) return false;
+	try {
+		return nodeFs.statSync(filePath).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
 export function createLspNavigationTool(
 	getFlag: (name: string) => boolean | string | undefined,
 ) {
@@ -1021,14 +1030,7 @@ export function createLspNavigationTool(
 					: path.resolve(ctx.cwd || ".", rawPath)
 				: "";
 
-			let filePathIsDirectory = false;
-			if (filePath) {
-				try {
-					filePathIsDirectory = nodeFs.statSync(filePath).isDirectory();
-				} catch {
-					// non-existent path — existing error paths handle this
-				}
-			}
+			const filePathIsDirectory = isDirectoryPath(filePath);
 
 			const lspService = getLSPService();
 			if (operation === "workspaceDiagnostics") {

package/.pi/lib/harness-repair-brief.ts

@@ -64,27 +64,23 @@ export async function synthesizeRepairBrief(
 	const planRel =
 		input.planPacketPath?.replace(/\\/g, "/") ?? "plan-packet.yaml";
 	const plan = await readArtifactYaml(runRoot, planRel, "plan-packet");
+	const sentruxRepair = await readArtifactYaml(
+		runRoot,
+		"artifacts/sentrux-repair-plan.yaml",
+		"sentrux-repair-plan",
+	);
 
 	const remediation =
 		(typeof review?.remediation_class === "string" &&
 			review.remediation_class) ||
 		"implementation_gap";
 
-	const sourceArtifacts: Record<string, string> = {
-		"review-outcome":
-			input.reviewOutcomePath ?? "artifacts/review-outcome.yaml",
-	};
-	if (evalDoc) {
-		sourceArtifacts["eval-verdict"] =
-			input.evalVerdictPath ?? "artifacts/eval-verdict.yaml";
-	}
-	if (adversary) {
-		sourceArtifacts["adversary-report"] =
-			input.adversaryReportPath ?? "artifacts/adversary-report.yaml";
-	}
-	if (plan) {
-		sourceArtifacts["plan-packet"] = planRel;
-	}
+	const sourceArtifacts = buildSourceArtifacts(input, planRel, {
+		evalDoc,
+		adversary,
+		plan,
+		sentruxRepair,
+	});
 
 	const failedIds = [
 		...stringList(review?.failed_acceptance_check_ids),
@@ -93,7 +89,7 @@ export async function synthesizeRepairBrief(
 	];
 	const uniqueFailed = [...new Set(failedIds)];
 
-	const fixDirectives: string[] = [];
+	const fixDirectives: string[] = sentruxFixDirectives(sentruxRepair);
 	for (const key of [
 		"fix_directives",
 		"repair_directives",
@@ -117,15 +113,7 @@ export async function synthesizeRepairBrief(
 		);
 	}
 
-	const execPlan = asRecord(plan?.execution_plan);
-	const priorityLakeIds = stringList(execPlan?.critical_path_lake_ids);
-	if (priorityLakeIds.length === 0) {
-		const lakes = Array.isArray(execPlan?.lakes) ? execPlan.lakes : [];
-		for (const lake of lakes) {
-			const l = asRecord(lake);
-			if (l && typeof l.id === "string") priorityLakeIds.push(l.id);
-		}
-	}
+	const priorityLakeIds = collectPriorityLakeIds(plan);
 
 	const brief: Record<string, unknown> = {
 		schema_version: REPAIR_BRIEF_SCHEMA,
@@ -143,3 +131,74 @@ export async function synthesizeRepairBrief(
 	}
 	return brief;
 }
+
+function buildSourceArtifacts(
+	input: SynthesizeRepairBriefInput,
+	planRel: string,
+	docs: {
+		evalDoc: Record<string, unknown> | null;
+		adversary: Record<string, unknown> | null;
+		plan: Record<string, unknown> | null;
+		sentruxRepair: Record<string, unknown> | null;
+	},
+): Record<string, string> {
+	const sourceArtifacts: Record<string, string> = {
+		"review-outcome":
+			input.reviewOutcomePath ?? "artifacts/review-outcome.yaml",
+	};
+	if (docs.evalDoc)
+		sourceArtifacts["eval-verdict"] =
+			input.evalVerdictPath ?? "artifacts/eval-verdict.yaml";
+	if (docs.adversary)
+		sourceArtifacts["adversary-report"] =
+			input.adversaryReportPath ?? "artifacts/adversary-report.yaml";
+	if (docs.plan) sourceArtifacts["plan-packet"] = planRel;
+	if (docs.sentruxRepair)
+		sourceArtifacts["sentrux-repair-plan"] =
+			"artifacts/sentrux-repair-plan.yaml";
+	return sourceArtifacts;
+}
+
+function sentruxFixDirectives(
+	sentruxRepair: Record<string, unknown> | null,
+): string[] {
+	if (!sentruxRepair) return [];
+	const out: string[] = [];
+	const actions = Array.isArray(sentruxRepair.actions)
+		? sentruxRepair.actions
+		: [];
+	for (const raw of actions) {
+		const action = asRecord(raw);
+		if (!action) continue;
+		const id = typeof action.id === "string" ? action.id : "action";
+		const target = typeof action.target === "string" ? action.target : "";
+		const instruction =
+			typeof action.instruction === "string" ? action.instruction : "";
+		if (instruction)
+			out.push(`[sentrux:${id}] ${target}: ${instruction}`.trim());
+	}
+	if (
+		typeof sentruxRepair.summary === "string" &&
+		sentruxRepair.summary.trim()
+	) {
+		out.unshift(`[sentrux] ${sentruxRepair.summary.trim()}`);
+	}
+	for (const v of stringList(sentruxRepair.verification)) {
+		out.push(`[sentrux:verify] ${v}`);
+	}
+	return out;
+}
+
+function collectPriorityLakeIds(
+	plan: Record<string, unknown> | null,
+): string[] {
+	const execPlan = asRecord(plan?.execution_plan);
+	const ids = stringList(execPlan?.critical_path_lake_ids);
+	if (ids.length > 0) return ids;
+	const lakes = Array.isArray(execPlan?.lakes) ? execPlan.lakes : [];
+	for (const lake of lakes) {
+		const record = asRecord(lake);
+		if (record && typeof record.id === "string") ids.push(record.id);
+	}
+	return ids;
+}

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;
+}