ultimate-pi 0.18.1 → 0.19.0

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,7 +1,8 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { isHarnessProjectEnabled } from "../../lib/harness-project-config.js";
+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");
 
@@ -39,7 +40,17 @@ export function claimExtensionLoad(key: string, moduleUrl: string): boolean {
 	return true;
 }
 
-/** Skip duplicate loads and skip all governance extensions when harness is disabled. */
+/** 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,

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;

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

package/.pi/lib/harness-lens/clients/file-kinds.ts

@@ -0,0 +1,380 @@
+/**
+ * File Kind Detection for pi-lens
+ *
+ * Centralized file type detection to avoid duplication across clients.
+ * Maps file extensions and paths to semantic file kinds.
+ */
+
+import { basename, extname } from "node:path";
+
+// --- Types ---
+
+export type FileKind =
+	| "clojure" // Clojure
+	| "cmake" // CMake
+	| "csharp" // C#
+	| "css" // CSS
+	| "cxx" // C/C++
+	| "dart" // Dart
+	| "docker" // Dockerfile
+	| "elixir" // Elixir
+	| "fish" // Fish shell
+	| "fsharp" // F#
+	| "gleam" // Gleam
+	| "go" // Go
+	| "haskell" // Haskell
+	| "html" // HTML
+	| "java" // Java
+	| "json" // JSON
+	| "jsts" // JavaScript/TypeScript/frameworks
+	| "kotlin" // Kotlin
+	| "lua" // Lua
+	| "markdown" // Markdown
+	| "nix" // Nix
+	| "ocaml" // OCaml
+	| "php" // PHP
+	| "powershell" // PowerShell
+	| "prisma" // Prisma schema
+	| "python" // Python
+	| "ruby" // Ruby
+	| "rust" // Rust
+	| "shell" // Shell
+	| "sql" // SQL
+	| "swift" // Swift
+	| "terraform" // Terraform
+	| "toml" // TOML
+	| "yaml" // YAML
+	| "zig"; // Zig
+
+// --- Extension Maps ---
+
+export const KIND_EXTENSIONS: Record<FileKind, readonly string[]> = {
+	clojure: [".clj", ".cljc", ".cljs", ".edn"],
+	cmake: [".cmake"],
+	csharp: [".cs"],
+	css: [".css", ".less", ".sass", ".scss"],
+	// From llvm-project/clang/lib/Driver/Types.cpp clang::driver::types::lookupTypeForExtension:
+	cxx: [
+		// C
+		".c",
+		".h",
+		// C++
+		".c++",
+		".cc",
+		".cp",
+		".cpp",
+		".cxx",
+		".hh",
+		".hpp",
+		".hxx",
+		// C++ include files
+		".inl",
+		".ipp",
+		".tpp",
+		".txx",
+		// C++20 module interface files
+		".c++m",
+		".cppm",
+		".cxxm",
+		".ixx",
+		// CUDA
+		".cu",
+		// HIP
+		".hip",
+		// Objective-C
+		".m",
+		".mm",
+		// OpenCL
+		".cl",
+		".clcpp",
+	],
+	dart: [".dart"],
+	docker: [".dockerfile"],
+	elixir: [".ex", ".exs"],
+	fish: [".fish"],
+	fsharp: [".fs", ".fsi", ".fsx"],
+	gleam: [".gleam"],
+	go: [".go"],
+	haskell: [".hs", ".lhs"],
+	html: [".htm", ".html"],
+	java: [".java"],
+	json: [".json", ".json5", ".jsonc"],
+	jsts: [
+		".cjs",
+		".cts",
+		".js",
+		".jsx",
+		".mjs",
+		".mts",
+		".svelte",
+		".ts",
+		".tsx",
+		".vue",
+	],
+	kotlin: [".kt", ".kts"],
+	lua: [".lua"],
+	markdown: [".md", ".mdx"],
+	nix: [".nix"],
+	ocaml: [".ml", ".mli"],
+	php: [".php"],
+	powershell: [".ps1", ".psm1", ".psd1"],
+	prisma: [".prisma"],
+	python: [".py", ".pyi"],
+	ruby: [".gemspec", ".rake", ".rb", ".ru"],
+	rust: [".rs"],
+	shell: [".bash", ".sh", ".zsh"],
+	sql: [".sql"],
+	swift: [".swift"],
+	terraform: [".tf", ".tfvars"],
+	toml: [".toml"],
+	yaml: [".yaml", ".yml"],
+	zig: [".zig", ".zon"],
+};
+
+// Reverse map: extension → file kind (for fast lookup)
+const EXT_TO_KIND = new Map<string, FileKind>();
+for (const [kind, exts] of Object.entries(KIND_EXTENSIONS)) {
+	for (const ext of exts) {
+		EXT_TO_KIND.set(ext.toLowerCase(), kind as FileKind);
+	}
+	// Also register without leading dot
+	for (const ext of exts) {
+		if (ext.startsWith(".")) {
+			EXT_TO_KIND.set(ext.slice(1).toLowerCase(), kind as FileKind);
+		}
+	}
+}
+
+// Special filenames that indicate a file kind
+const SPECIAL_FILENAMES: Array<{ pattern: RegExp; kind: FileKind }> = [
+	{ pattern: /^CMakeLists\.txt$/i, kind: "cmake" },
+	{ pattern: /^Makefile$/i, kind: "shell" },
+	{ pattern: /^Dockerfile(\.\w+)?$/i, kind: "docker" },
+];
+
+// --- Detection Functions ---
+
+/**
+ * Detect the file kind from a file path.
+ * Returns the semantic file kind or undefined if unknown.
+ */
+export function detectFileKind(filePath: string): FileKind | undefined {
+	if (!filePath || typeof filePath !== "string") {
+		return undefined;
+	}
+
+	// Check special filenames first
+	const base = basename(filePath);
+	for (const { pattern, kind } of SPECIAL_FILENAMES) {
+		if (pattern.test(base)) {
+			return kind;
+		}
+	}
+
+	// Check by extension
+	const ext = extname(filePath).toLowerCase();
+	return EXT_TO_KIND.get(ext);
+}
+
+/**
+ * Check if a file kind is supported by a specific tool or capability.
+ *
+ * @example
+ * // Check if TypeScript file
+ * if (isFileKind(filePath, "jsts")) { ... }
+ *
+ * // Check for multiple kinds
+ * if (isFileKind(filePath, ["jsts", "python"])) { ... }
+ */
+export function isFileKind(
+	filePath: string,
+	kind: FileKind | FileKind[],
+): boolean {
+	const detected = detectFileKind(filePath);
+	if (!detected) return false;
+
+	if (Array.isArray(kind)) {
+		return kind.includes(detected);
+	}
+
+	return detected === kind;
+}
+
+/**
+ * Get all file kinds that match a given file extension.
+ * Useful for listing which tools might handle a file.
+ */
+export function getFileKindsForExtension(ext: string): FileKind[] {
+	const normalizedExt = ext.startsWith(".") ? ext : `.${ext}`;
+	const kind = EXT_TO_KIND.get(normalizedExt.toLowerCase());
+	return kind ? [kind] : [];
+}
+
+/**
+ * Check if a file kind represents a code file (not config/markdown).
+ */
+export function isCodeKind(kind: FileKind): boolean {
+	return [
+		"jsts",
+		"python",
+		"go",
+		"rust",
+		"cxx",
+		"fish",
+		"shell",
+		"ruby",
+		"html",
+		"php",
+		"powershell",
+		"prisma",
+		"csharp",
+		"fsharp",
+		"java",
+		"kotlin",
+		"swift",
+		"dart",
+		"lua",
+		"zig",
+		"haskell",
+		"elixir",
+		"gleam",
+		"ocaml",
+		"clojure",
+		"terraform",
+		"nix",
+	].includes(kind);
+}
+
+/**
+ * Check if a file kind represents a text/config file.
+ */
+export function isConfigKind(kind: FileKind): boolean {
+	return [
+		"json",
+		"yaml",
+		"markdown",
+		"css",
+		"sql",
+		"docker",
+		"cmake",
+		"toml",
+	].includes(kind);
+}
+
+/**
+ * Get human-readable description of a file kind.
+ */
+export function getFileKindLabel(kind: FileKind): string {
+	const labels: Record<FileKind, string> = {
+		jsts: "JavaScript/TypeScript",
+		python: "Python",
+		go: "Go",
+		rust: "Rust",
+		cxx: "C/C++",
+		cmake: "CMake",
+		shell: "Shell",
+		json: "JSON",
+		markdown: "Markdown",
+		css: "CSS",
+		yaml: "YAML",
+		sql: "SQL",
+		ruby: "Ruby",
+		html: "HTML",
+		docker: "Dockerfile",
+		php: "PHP",
+		powershell: "PowerShell",
+		prisma: "Prisma",
+		csharp: "C#",
+		fish: "Fish shell",
+		fsharp: "F#",
+		java: "Java",
+		kotlin: "Kotlin",
+		swift: "Swift",
+		dart: "Dart",
+		lua: "Lua",
+		zig: "Zig",
+		haskell: "Haskell",
+		elixir: "Elixir",
+		gleam: "Gleam",
+		ocaml: "OCaml",
+		clojure: "Clojure",
+		terraform: "Terraform",
+		nix: "Nix",
+		toml: "TOML",
+	};
+	return labels[kind] ?? kind;
+}
+
+/**
+ * Get file extensions for a file kind.
+ */
+export function getExtensionsForKind(kind: FileKind): string[] {
+	return [...(KIND_EXTENSIONS[kind] ?? [])];
+}
+
+/**
+ * Check if a file should be scanned for linting/formatting.
+ * Excludes test files, generated files, etc.
+ */
+export function isScannableFile(filePath: string): boolean {
+	const kind = detectFileKind(filePath);
+	if (!kind) return false;
+
+	// Exclude test files for most kinds
+	const base = basename(filePath);
+	if (
+		base.includes(".test.") ||
+		base.includes(".spec.") ||
+		base.startsWith("test-") ||
+		base.startsWith("spec-")
+	) {
+		return false;
+	}
+
+	// Only scan code and config files
+	return isCodeKind(kind) || isConfigKind(kind);
+}
+
+/**
+ * Get the language identifier for LSP/tools that use language IDs.
+ */
+export function getLanguageId(kind: FileKind): string {
+	const languageIds: Record<FileKind, string> = {
+		jsts: "typescript",
+		python: "python",
+		go: "go",
+		rust: "rust",
+		cxx: "cpp",
+		cmake: "cmake",
+		shell: "shell",
+		json: "json",
+		markdown: "markdown",
+		css: "css",
+		yaml: "yaml",
+		sql: "sql",
+		ruby: "ruby",
+		html: "html",
+		docker: "dockerfile",
+		php: "php",
+		powershell: "powershell",
+		prisma: "prisma",
+		csharp: "csharp",
+		fish: "fish",
+		fsharp: "fsharp",
+		java: "java",
+		kotlin: "kotlin",
+		swift: "swift",
+		dart: "dart",
+		lua: "lua",
+		zig: "zig",
+		haskell: "haskell",
+		elixir: "elixir",
+		gleam: "gleam",
+		ocaml: "ocaml",
+		clojure: "clojure",
+		terraform: "terraform",
+		nix: "nix",
+		toml: "toml",
+	};
+	return languageIds[kind] ?? "plaintext";
+}