ultimate-pi 0.18.0 → 0.19.0

package/.pi/lib/agt-tool-guard.ts

@@ -0,0 +1,78 @@
+import { join } from "node:path";
+import { appendPolicyAuditEvent } from "./agt/audit-run-sink.js";
+import type { BuildEvaluationContextInput } from "./agt/build-evaluation-context.js";
+import { evaluateHarnessToolPolicy } from "./agt/evaluate-policy.js";
+import { recordHarnessPolicyDeny } from "./agt/kill-switch-state.js";
+import { recordPolicyAllow, recordPolicyDeny } from "./agt/trust-run-store.js";
+import { getHarnessPackageRoot } from "./harness-paths.js";
+
+type HarnessPhase = "plan" | "execute" | "evaluate" | "adversary" | "merge";
+
+export interface PolicyStateSlice {
+	phase: HarnessPhase;
+	approvedPlan: boolean;
+	planId: string | null;
+	aborted: boolean;
+	budgetBypass: boolean;
+}
+
+export async function evaluateAgtToolCall(input: {
+	moduleUrl: string;
+	toolName: string;
+	toolInput: Record<string, unknown>;
+	policyState: PolicyStateSlice;
+	entries: unknown[];
+	sessionId: string;
+	projectRoot: string;
+}): Promise<{ block: boolean; reason?: string } | undefined> {
+	const packageRoot = getHarnessPackageRoot(input.moduleUrl);
+	const evalInput: BuildEvaluationContextInput = {
+		toolName: input.toolName,
+		toolInput: input.toolInput,
+		packageRoot,
+		projectRoot: input.projectRoot,
+		sessionId: input.sessionId,
+		entries: input.entries,
+		policyState: input.policyState,
+	};
+
+	const result = await evaluateHarnessToolPolicy(packageRoot, evalInput);
+	const runId = process.env.HARNESS_RUN_ID?.trim();
+	const runDir =
+		process.env.HARNESS_RUN_DIR?.trim() ??
+		(runId ? join(packageRoot, ".pi", "harness", "runs", runId) : "");
+
+	if (runId && runDir) {
+		const agentDid =
+			process.env.HARNESS_AGENT_DID?.trim() ??
+			(process.env.HARNESS_AGENT_ID?.trim() || "parent-orchestrator");
+		appendPolicyAuditEvent({
+			runDir,
+			runId,
+			toolName: input.toolName,
+			allowed: result.allowed,
+			reason: result.reason,
+			agentDid,
+			phase: input.policyState.phase,
+		});
+		if (result.allowed) {
+			recordPolicyAllow(runId, agentDid);
+		} else {
+			recordPolicyDeny(runId, agentDid);
+		}
+	}
+
+	if (!result.allowed) {
+		recordHarnessPolicyDeny(input.sessionId);
+		return {
+			block: true,
+			reason: result.reason.startsWith("agt-policy")
+				? result.reason
+				: `agt-policy: ${result.reason}`,
+		};
+	}
+	return undefined;
+}
+
+/** @deprecated Use evaluateAgtToolCall */
+export const evaluateAgtHarnessToolCall = evaluateAgtToolCall;

package/.pi/lib/ask-user/dialog.ts

@@ -0,0 +1,314 @@
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import {
+	Editor,
+	type EditorTheme,
+	Key,
+	matchesKey,
+	truncateToWidth,
+} from "@earendil-works/pi-tui";
+import type { AskResponse, DialogResult, ValidatedAskParams } from "./types.js";
+
+type DisplayOption = {
+	title: string;
+	description?: string;
+	isFreeform?: boolean;
+};
+
+interface CustomAnswer {
+	response: AskResponse;
+}
+
+type ThemeLike = { fg(color: string, text: string): string };
+type TuiLike = ConstructorParameters<typeof Editor>[0] & {
+	requestRender(): void;
+};
+type Done = (answer: CustomAnswer | null) => void;
+
+function withTimeout<T>(
+	promise: Promise<T | null>,
+	ms: number | undefined,
+): Promise<T | null> {
+	if (!ms) return promise;
+	return Promise.race([
+		promise,
+		new Promise<null>((resolve) => {
+			setTimeout(() => resolve(null), ms);
+		}),
+	]);
+}
+
+function displayOptionsFor(validated: ValidatedAskParams): DisplayOption[] {
+	const displayOptions: DisplayOption[] = [...validated.options];
+	if (validated.allowFreeform) {
+		displayOptions.push({ title: "Type something…", isFreeform: true });
+	}
+	return displayOptions;
+}
+
+async function runFreeformOnly(
+	ui: ExtensionUIContext,
+	question: string,
+): Promise<DialogResult> {
+	const text = await ui.input(question, "");
+	if (!text?.trim()) return { response: null, cancelled: true };
+	return {
+		response: { kind: "freeform", text: text.trim() },
+		cancelled: false,
+	};
+}
+
+function editorThemeFor(theme: ThemeLike): EditorTheme {
+	return {
+		borderColor: (s) => theme.fg("accent", s),
+		selectList: {
+			selectedPrefix: (t) => theme.fg("accent", t),
+			selectedText: (t) => theme.fg("accent", t),
+			description: (t) => theme.fg("muted", t),
+			scrollInfo: (t) => theme.fg("dim", t),
+			noMatch: (t) => theme.fg("warning", t),
+		},
+	};
+}
+
+class AskDialogController {
+	private optionIndex = 0;
+	private editMode = false;
+	private readonly selected = new Set<number>();
+	private cachedLines: string[] | undefined;
+	private readonly editor: Editor;
+
+	constructor(
+		private readonly validated: ValidatedAskParams,
+		private readonly displayOptions: DisplayOption[],
+		private readonly tui: TuiLike,
+		private readonly theme: ThemeLike,
+		private readonly done: Done,
+	) {
+		this.editor = new Editor(tui, editorThemeFor(theme));
+		this.editor.onSubmit = (value) => this.submitFreeform(value);
+	}
+
+	invalidate(): void {
+		this.cachedLines = undefined;
+	}
+
+	handleInput(data: string): void {
+		if (this.editMode) {
+			this.handleEditInput(data);
+			return;
+		}
+		if (this.handleNavigationInput(data)) return;
+		if (this.validated.allowMultiple && matchesKey(data, Key.space)) {
+			this.toggleMultiSelect();
+			return;
+		}
+		if (matchesKey(data, Key.enter)) this.submitSelection();
+		if (matchesKey(data, Key.escape)) this.done(null);
+	}
+
+	render(width: number): string[] {
+		if (this.cachedLines) return this.cachedLines;
+		const lines: string[] = [];
+		const add = (s: string) => lines.push(truncateToWidth(s, width));
+		const useOverlay = this.validated.displayMode !== "inline";
+		this.renderHeader(lines, add, width, useOverlay);
+		this.renderOptions(add);
+		this.renderEditor(lines, add, width);
+		this.renderFooter(add, width, useOverlay);
+		this.cachedLines = lines;
+		return lines;
+	}
+
+	private refresh(): void {
+		this.invalidate();
+		this.tui.requestRender();
+	}
+
+	private submitFreeform(value: string): void {
+		const trimmed = value.trim();
+		if (trimmed) {
+			this.done({ response: { kind: "freeform", text: trimmed } });
+			return;
+		}
+		this.editMode = false;
+		this.editor.setText("");
+		this.refresh();
+	}
+
+	private submitSelection(): void {
+		if (this.validated.allowMultiple) {
+			const titles = [...this.selected]
+				.sort((a, b) => a - b)
+				.map((i) => this.displayOptions[i].title)
+				.filter((t) => t !== "Type something…");
+			if (titles.length) {
+				this.done({ response: { kind: "selection", selections: titles } });
+			}
+			return;
+		}
+		const opt = this.displayOptions[this.optionIndex];
+		if (opt.isFreeform) {
+			this.editMode = true;
+			this.refresh();
+			return;
+		}
+		this.done({ response: { kind: "selection", selections: [opt.title] } });
+	}
+
+	private handleEditInput(data: string): void {
+		if (matchesKey(data, Key.escape)) {
+			this.editMode = false;
+			this.editor.setText("");
+		} else {
+			this.editor.handleInput(data);
+		}
+		this.refresh();
+	}
+
+	private handleNavigationInput(data: string): boolean {
+		if (matchesKey(data, Key.up)) {
+			this.optionIndex = Math.max(0, this.optionIndex - 1);
+			this.refresh();
+			return true;
+		}
+		if (matchesKey(data, Key.down)) {
+			this.optionIndex = Math.min(
+				this.displayOptions.length - 1,
+				this.optionIndex + 1,
+			);
+			this.refresh();
+			return true;
+		}
+		return false;
+	}
+
+	private toggleMultiSelect(): void {
+		const opt = this.displayOptions[this.optionIndex];
+		if (opt.isFreeform) return;
+		if (this.selected.has(this.optionIndex)) {
+			this.selected.delete(this.optionIndex);
+		} else {
+			this.selected.add(this.optionIndex);
+		}
+		this.refresh();
+	}
+
+	private renderHeader(
+		lines: string[],
+		add: (s: string) => void,
+		width: number,
+		useOverlay: boolean,
+	): void {
+		if (useOverlay) add(this.theme.fg("accent", "─".repeat(width)));
+		if (this.validated.context) {
+			for (const line of this.validated.context.split("\n")) {
+				add(this.theme.fg("muted", ` ${line}`));
+			}
+			lines.push("");
+		}
+		add(this.theme.fg("text", ` ${this.validated.question}`));
+		lines.push("");
+	}
+
+	private renderOptions(add: (s: string) => void): void {
+		for (let i = 0; i < this.displayOptions.length; i++) {
+			const opt = this.displayOptions[i];
+			const prefix = this.optionPrefix(i, opt.isFreeform === true);
+			const label = this.optionLabel(i, opt);
+			add(`${prefix}${label}`);
+			if (opt.description)
+				add(`     ${this.theme.fg("muted", opt.description)}`);
+		}
+	}
+
+	private optionPrefix(index: number, isFreeform: boolean): string {
+		if (!this.validated.allowMultiple) {
+			return index === this.optionIndex ? this.theme.fg("accent", "> ") : "  ";
+		}
+		if (isFreeform) return "  ";
+		return this.selected.has(index) ? this.theme.fg("accent", "[x] ") : "[ ] ";
+	}
+
+	private optionLabel(index: number, opt: DisplayOption): string {
+		const raw = `${index + 1}. ${opt.title}`;
+		const focused = index === this.optionIndex;
+		if (opt.isFreeform && this.editMode && focused) {
+			return this.theme.fg("accent", `${raw} ✎`);
+		}
+		if (focused && !this.validated.allowMultiple) {
+			return this.theme.fg("accent", raw);
+		}
+		return this.theme.fg("text", raw);
+	}
+
+	private renderEditor(
+		lines: string[],
+		add: (s: string) => void,
+		width: number,
+	): void {
+		if (!this.editMode) return;
+		lines.push("");
+		add(this.theme.fg("muted", " Your answer:"));
+		for (const line of this.editor.render(width - 2)) add(` ${line}`);
+	}
+
+	private renderFooter(
+		add: (s: string) => void,
+		width: number,
+		useOverlay: boolean,
+	): void {
+		add("");
+		if (this.editMode) {
+			add(this.theme.fg("dim", " Enter to submit • Esc to go back"));
+		} else if (this.validated.allowMultiple) {
+			add(
+				this.theme.fg(
+					"dim",
+					" ↑↓ navigate • Space toggle • Enter confirm • Esc cancel",
+				),
+			);
+		} else {
+			add(
+				this.theme.fg("dim", " ↑↓ navigate • Enter to select • Esc to cancel"),
+			);
+		}
+		if (useOverlay) add(this.theme.fg("accent", "─".repeat(width)));
+	}
+}
+
+async function runOptionDialog(
+	ui: ExtensionUIContext,
+	validated: ValidatedAskParams,
+	displayOptions: DisplayOption[],
+): Promise<CustomAnswer | null> {
+	return withTimeout(
+		ui.custom<CustomAnswer | null>((tui, theme, _kb, done) => {
+			const controller = new AskDialogController(
+				validated,
+				displayOptions,
+				tui as TuiLike,
+				theme,
+				done,
+			);
+			return {
+				render: (width: number) => controller.render(width),
+				invalidate: () => controller.invalidate(),
+				handleInput: (data: string) => controller.handleInput(data),
+			};
+		}),
+		validated.timeout,
+	);
+}
+
+export async function runAskDialog(
+	ui: ExtensionUIContext,
+	validated: ValidatedAskParams,
+): Promise<DialogResult> {
+	const displayOptions = displayOptionsFor(validated);
+	if (displayOptions.length === 0) {
+		return runFreeformOnly(ui, validated.question);
+	}
+	const result = await runOptionDialog(ui, validated, displayOptions);
+	if (!result) return { response: null, cancelled: true };
+	return { response: result.response, cancelled: false };
+}

package/.pi/{extensions/lib → lib}/debate-bus-core.ts

@@ -4,25 +4,25 @@
 
 import { appendFile, mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import {
+	type DebateState,
+	getDebateState,
+	getLastSeverity,
+	type SeverityScores,
+	setDebateState,
+	setLastSeverity,
+} from "./debate-bus-state.js";
 import {
 	type DebateParticipant,
 	debatePhaseFromId,
 	isPlanDebateId,
 	PLAN_DEBATE_PARTICIPANTS,
 	POST_EXECUTE_DEBATE_PARTICIPANTS,
-} from "../../lib/debate-orchestrator-types.js";
+} from "./debate-orchestrator-types.js";
 import {
 	isHarnessBudgetEnforceOn,
 	shouldEmitBlockingBudgetExhausted,
-} from "../../lib/harness-budget-enforce.js";
-import {
-	type DebateState,
-	getDebateState,
-	getLastSeverity,
-	type SeverityScores,
-	setDebateState,
-	setLastSeverity,
-} from "./debate-bus-state.js";
+} from "./harness-budget-enforce.js";
 import {
 	type DebateProfile,
 	PLAN_BUDGET_FAST,

package/.pi/{extensions/lib → lib}/debate-bus-state.ts

@@ -2,7 +2,7 @@
  * Shared in-process debate bus state (one session per Pi process).
  */
 
-import type { DebateParticipant } from "../../lib/debate-orchestrator-types.js";
+import type { DebateParticipant } from "./debate-orchestrator-types.js";
 import type { DebateProfile } from "./plan-debate-eligibility.js";
 import type { PlanDebateFocus } from "./plan-debate-focus.js";
 

package/.pi/{extensions/lib → lib}/extension-load-guard.ts

@@ -1,6 +1,8 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { isAgtGovernanceActive } from "./agt-governance-active.js";
+import { isHarnessProjectEnabled } from "./harness-project-config.js";
 
 const LOAD_GUARD_KEY = Symbol.for("ultimate-pi.extension-load-guard");
 
@@ -37,3 +39,22 @@ export function claimExtensionLoad(key: string, moduleUrl: string): boolean {
 	registry.add(key);
 	return true;
 }
+
+/** AGT subprocess governance for all subagents when project/harness policy is active. */
+export function claimSubagentGovernanceLoad(
+	key: string,
+	moduleUrl: string,
+	projectRoot?: string,
+): boolean {
+	if (!isAgtGovernanceActive(projectRoot)) return false;
+	return claimExtensionLoad(key, moduleUrl);
+}
+
+/** Skip duplicate loads and skip harness-only governance when harness is disabled. */
+export function claimHarnessGovernanceLoad(
+	key: string,
+	moduleUrl: string,
+): boolean {
+	if (!isHarnessProjectEnabled()) return false;
+	return claimExtensionLoad(key, moduleUrl);
+}

package/.pi/lib/harness-agt-tool-guard.ts

@@ -0,0 +1,5 @@
+export {
+	evaluateAgtHarnessToolCall,
+	evaluateAgtToolCall,
+	type PolicyStateSlice,
+} from "./agt-tool-guard.js";

package/.pi/{extensions/lib → lib}/harness-artifact-gate.ts

@@ -6,7 +6,7 @@ import { constants } from "node:fs";
 import { access, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
-import { validateAgainstHarnessSchema } from "../../lib/harness-schema-validate.js";
+import { validateAgainstHarnessSchema } from "./harness-schema-validate.js";
 
 export interface ArtifactGateResult {
 	ok: boolean;
@@ -20,9 +20,6 @@ const ARTIFACT_SCHEMA: Record<string, string> = {
 		"plan-implementation-research-brief.schema.json",
 	"artifacts/stack.yaml": "plan-stack-brief.schema.json",
 	"artifacts/planning-context.yaml": "plan-planning-context.schema.json",
-	"artifacts/scout-graphify.yaml": "plan-scout-findings.schema.json",
-	"artifacts/scout-structure.yaml": "plan-scout-findings.schema.json",
-	"artifacts/scout-semantic.yaml": "plan-scout-findings.schema.json",
 	"artifacts/eval-verdict.yaml": "eval-verdict.schema.json",
 	"artifacts/adversary-report.yaml": "adversary-report.schema.json",
 };
@@ -48,10 +45,10 @@ async function fileExists(path: string): Promise<boolean> {
 	}
 }
 
-function scoutStatusBad(doc: Record<string, unknown>): string | null {
+function artifactStatusBad(doc: Record<string, unknown>): string | null {
 	const status = String(doc.status ?? "ok").toLowerCase();
 	if (status === "partial" || status === "failed" || status === "error") {
-		return `scout status is "${status}"`;
+		return `artifact status is "${status}"`;
 	}
 	return null;
 }
@@ -105,17 +102,10 @@ export async function validateHarnessArtifactFile(
 		}
 	}
 
-	if (doc && normalized.startsWith("artifacts/scout-")) {
-		const scoutErr = scoutStatusBad(doc);
-		if (scoutErr) {
-			errors.push(`${normalized}: ${scoutErr}`);
-		}
-	}
-
 	if (doc && normalized === "artifacts/planning-context.yaml") {
-		const scoutErr = scoutStatusBad(doc);
-		if (scoutErr) {
-			errors.push(`${normalized}: ${scoutErr}`);
+		const statusErr = artifactStatusBad(doc);
+		if (statusErr) {
+			errors.push(`${normalized}: ${statusErr}`);
 		}
 		const coverage = doc.coverage as Record<string, unknown> | undefined;
 		if (coverage && typeof coverage === "object") {

package/.pi/lib/harness-debate-core-deps.ts

@@ -0,0 +1,14 @@
+export { Type } from "@sinclair/typebox";
+export { parse as parseYaml } from "yaml";
+export type { DebateParticipant } from "./debate-orchestrator-types.js";
+export {
+	extractLastSubmitCall,
+	type MessageLike,
+} from "./harness-agent-output.js";
+export { captureHarnessEvent } from "./harness-posthog.js";
+export {
+	getLatestRunContext,
+	getRunIdFromSession,
+} from "./harness-run-context.js";
+export { DEBATE_AGENT_SUBMIT_TOOL } from "./harness-subagent-submit-registry.js";
+export { writeYamlFile } from "./harness-yaml.js";

package/.pi/lib/harness-debate-workflow-deps.ts

@@ -0,0 +1,43 @@
+export {
+	acceptDebateRound,
+	capsForDebate,
+	finalizeDebateConsensus,
+	openDebateBus,
+} from "./debate-bus-core.js";
+export { getDebateState } from "./debate-bus-state.js";
+export {
+	type DebateEligibilityInput,
+	harnessPlanDebateEligibility,
+} from "./plan-debate-eligibility.js";
+export {
+	buildPlanReviewRoundEnvelope,
+	type PlanReviewRoundDraft,
+} from "./plan-debate-envelope.js";
+export {
+	getPlanFocusCoverage,
+	planDebateOutcomeComplete,
+} from "./plan-debate-focus.js";
+export { normalizePlanDebateId, planDebateIdForRun } from "./plan-debate-id.js";
+export {
+	applyDebateLane,
+	applyDebateLaneFromDoc,
+	type DebateLaneKind,
+	debateLaneForAgent,
+	formatApplyLaneMessage,
+} from "./plan-debate-lane.js";
+export { getPlanDebateRoundStatus } from "./plan-debate-round-status.js";
+export { withReviewRoundYamlWrite } from "./plan-debate-write-guard.js";
+export {
+	formatTranscriptForSpawn,
+	getMessengerRoundState,
+	initPlanMessenger,
+	loadMessengerState,
+	messengerRoundDebateReady,
+	postMessengerMessage,
+	readRoundTranscript,
+} from "./plan-messenger.js";
+export {
+	loadValidationTurnYaml,
+	validateIntegratorDraft,
+} from "./plan-review-integrator-rules.js";
+export { assessPlanScopeDrift } from "./plan-scope-guard.js";

package/.pi/lib/harness-lens/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

package/.pi/lib/harness-lens/clients/edit-autopatch.ts

@@ -0,0 +1,88 @@
+import * as nodeFs from "node:fs";
+
+export function tryCorrectIndentationMismatchFromContent(
+	oldText: string,
+	content: string,
+): string | undefined {
+	const normalized = oldText.replace(/\r\n/g, "\n");
+	if (content.includes(normalized)) return undefined;
+
+	const conversions = [
+		(s: string) =>
+			s
+				.split("\n")
+				.map((l) => l.replace(/^\t+/, (m) => "  ".repeat(m.length)))
+				.join("\n"),
+		(s: string) =>
+			s
+				.split("\n")
+				.map((l) => l.replace(/^\t+/, (m) => "    ".repeat(m.length)))
+				.join("\n"),
+		(s: string) =>
+			s
+				.split("\n")
+				.map((l) => l.replace(/^( {2})+/, (m) => "\t".repeat(m.length / 2)))
+				.join("\n"),
+		(s: string) =>
+			s
+				.split("\n")
+				.map((l) => l.replace(/^( {4})+/, (m) => "\t".repeat(m.length / 4)))
+				.join("\n"),
+	];
+
+	for (const convert of conversions) {
+		const candidate = convert(normalized);
+		if (candidate !== normalized && content.includes(candidate))
+			return candidate;
+	}
+
+	return findIndentationInsensitiveCandidate(content, normalized);
+}
+
+export function tryCorrectIndentationMismatch(
+	oldText: string,
+	filePath: string,
+): string | undefined {
+	try {
+		return tryCorrectIndentationMismatchFromContent(
+			oldText,
+			nodeFs.readFileSync(filePath, "utf-8").replace(/\r\n/g, "\n"),
+		);
+	} catch {
+		return undefined;
+	}
+}
+
+function findIndentationInsensitiveCandidate(
+	content: string,
+	oldText: string,
+): string | undefined {
+	const contentLines = content.split("\n");
+	const oldLines = oldText.split("\n");
+	const stripIndent = (line: string) => line.replace(/^[\t ]+/, "").trimEnd();
+	const expected = oldLines.map(stripIndent);
+
+	for (
+		let start = 0;
+		start <= contentLines.length - oldLines.length;
+		start += 1
+	) {
+		let matches = true;
+		for (let offset = 0; offset < oldLines.length; offset += 1) {
+			if (
+				stripIndent(contentLines[start + offset] ?? "") !== expected[offset]
+			) {
+				matches = false;
+				break;
+			}
+		}
+		if (matches) {
+			const candidate = contentLines
+				.slice(start, start + oldLines.length)
+				.join("\n");
+			if (candidate !== oldText) return candidate;
+		}
+	}
+
+	return undefined;
+}