ultimate-pi 0.19.0 → 0.20.0

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

@@ -0,0 +1,158 @@
+import * as nodeFs from "node:fs";
+import { AnchorStateManager } from "../../harness-anchored-edit/anchor-state.js";
+import { EditExecutor } from "../../harness-anchored-edit/edit-executor.js";
+import { splitAnchor } from "../../harness-anchored-edit/line-protocol.js";
+import type { AnchoredEdit } from "../../harness-anchored-edit/types.js";
+import { tryCorrectIndentationMismatchFromContent } from "./edit-autopatch.js";
+import { retargetReplacementIndentation } from "./indent-retarget.js";
+
+function leadingIndent(line: string): string {
+	return line.match(/^[\t ]*/)?.[0] ?? "";
+}
+
+function isIndentationOnlyChange(before: string, after: string): boolean {
+	const beforeLines = before.replace(/\r\n/g, "\n").split("\n");
+	const afterLines = after.replace(/\r\n/g, "\n").split("\n");
+	if (beforeLines.length !== afterLines.length) return false;
+	return beforeLines.every(
+		(line, index) => line.trim() === afterLines[index].trim(),
+	);
+}
+
+type AnchoredEditInput = {
+	edits?: AnchoredEdit[];
+};
+
+export function isAnchoredEditToolInput(
+	editInput: unknown,
+): editInput is AnchoredEditInput {
+	if (!editInput || typeof editInput !== "object") return false;
+	const edits = (editInput as AnchoredEditInput).edits;
+	if (!Array.isArray(edits) || edits.length === 0) return false;
+	return typeof edits[0]?.anchor === "string";
+}
+
+/**
+ * Indentation-only correction for harness anchored edit.text before apply.
+ */
+export function applyAnchoredEditAutopatch(
+	filePath: string,
+	editInput: AnchoredEditInput,
+	taskId: string,
+): { block: true; reason: string } | undefined {
+	const edits = editInput.edits;
+	if (!edits?.length) return undefined;
+
+	let crlfContent: string;
+	try {
+		crlfContent = nodeFs.readFileSync(filePath, "utf-8").replace(/\r\n/g, "\n");
+	} catch {
+		return undefined;
+	}
+
+	const lines = crlfContent.split("\n");
+	const lineAnchors = AnchorStateManager.reconcile(filePath, lines, taskId);
+	const executor = new EditExecutor();
+	const { resolvedEdits, failedEdits } = executor.resolveEdits(
+		edits,
+		lines,
+		lineAnchors,
+	);
+	if (failedEdits.length > 0) return undefined;
+
+	const corrected: Array<{
+		label: string;
+		original: string;
+		corrected: string;
+		indentationOnly: boolean;
+		apply: (value: string) => void;
+	}> = [];
+
+	for (const { lineIdx, endIdx, edit } of resolvedEdits) {
+		const editType = edit.edit_type ?? "replace";
+		const text = edit.text ?? "";
+		if (!text.trim()) continue;
+
+		let referenceBlock: string;
+		if (editType === "replace") {
+			referenceBlock = lines.slice(lineIdx, endIdx + 1).join("\n");
+		} else {
+			referenceBlock = lines[lineIdx] ?? "";
+		}
+
+		const correctedText = tryCorrectIndentationMismatchFromContent(
+			text,
+			crlfContent,
+		);
+		if (correctedText === undefined) {
+			const refIndent = leadingIndent(referenceBlock.split("\n")[0] ?? "");
+			const textIndent = leadingIndent(text.split("\n")[0] ?? "");
+			if (
+				refIndent !== textIndent &&
+				isIndentationOnlyChange(
+					textIndent + text.trimStart(),
+					refIndent + text.trimStart(),
+				)
+			) {
+				const retargeted = retargetReplacementIndentation(
+					text,
+					textIndent + text.trimStart(),
+					refIndent + text.trimStart(),
+				);
+				if (retargeted !== undefined) {
+					corrected.push({
+						label: `edits anchor ${splitAnchor(edit.anchor).anchor}`,
+						original: text,
+						corrected: retargeted,
+						indentationOnly: true,
+						apply: (value) => {
+							edit.text = value;
+						},
+					});
+				}
+			}
+			continue;
+		}
+
+		if (correctedText !== text) {
+			const retargeted = retargetReplacementIndentation(
+				text,
+				text,
+				correctedText,
+			);
+			corrected.push({
+				label: `edits anchor ${splitAnchor(edit.anchor).anchor}`,
+				original: text,
+				corrected: retargeted ?? correctedText,
+				indentationOnly: isIndentationOnlyChange(text, correctedText),
+				apply: (value) => {
+					edit.text = value;
+				},
+			});
+		}
+	}
+
+	if (corrected.length === 0) return undefined;
+
+	const unsafe = corrected.filter((entry) => !entry.indentationOnly);
+	if (unsafe.length > 0) {
+		const details = unsafe
+			.map(({ label, original }) => {
+				const preview = original.trimStart().slice(0, 60).replace(/\n/g, "↵");
+				return `${label} ("${preview}…") cannot be auto-patched (not indentation-only).`;
+			})
+			.join("\n");
+		return {
+			block: true,
+			reason:
+				`🔄 RETRYABLE — Indentation mismatch on anchored edit text\n\n` +
+				`${details}\n\n` +
+				`Next action: re-read the relevant section, then retry with text matching file indentation.`,
+		};
+	}
+
+	for (const entry of corrected) {
+		entry.apply(entry.corrected);
+	}
+	return undefined;
+}

package/.pi/lib/harness-lens/index.ts

@@ -7,6 +7,11 @@ import * as nodeFs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { isToolCallEventType } from "@earendil-works/pi-coding-agent";
+import { anchoredEditTaskId } from "../harness-anchored-edit/task-id.js";
+import {
+	applyAnchoredEditAutopatch,
+	isAnchoredEditToolInput,
+} from "./clients/anchored-edit-autopatch.js";
 import {
 	tryCorrectIndentationMismatch,
 	tryCorrectIndentationMismatchFromContent,
@@ -496,13 +501,25 @@ export default function harnessLensExtension(pi: ExtensionAPI): void {
 				event as Parameters<typeof isToolCallEventType>[1],
 			)
 		) {
-			const editInput = (event as { input?: unknown }).input as {
-				oldText?: string;
-				newText?: string;
-				edits?: Array<{ oldText?: string; newText?: string }>;
-			};
-			const block = applyEditAutopatch(filePath, editInput);
-			if (block) return block;
+			const editInput = (event as { input?: unknown }).input;
+			if (isAnchoredEditToolInput(editInput)) {
+				const block = applyAnchoredEditAutopatch(
+					filePath,
+					editInput,
+					anchoredEditTaskId({
+						sessionId: (ctx as { sessionId?: string }).sessionId,
+					}),
+				);
+				if (block) return block;
+			} else {
+				const legacyInput = editInput as {
+					oldText?: string;
+					newText?: string;
+					edits?: Array<{ oldText?: string; newText?: string }>;
+				};
+				const block = applyEditAutopatch(filePath, legacyInput);
+				if (block) return block;
+			}
 		}
 	});
 

package/.pi/lib/harness-subagent-auth.ts

@@ -2,7 +2,7 @@
  * Resolve concrete LLM credentials for harness subagent subprocesses.
  *
  * Harness subprocesses run with `--no-extensions`, so auth forwarding only uses
- * concrete provider/model references from the parent session or agent config.
+ * concrete provider/model references from env, agent config, or parent session.
  */
 
 import type { AgentConfig } from "../../vendor/pi-subagents/src/agents.js";
@@ -30,22 +30,52 @@ export interface ConcreteSubagentModel {
 	modelId: string;
 }
 
+function toConcrete(ref: string): ConcreteSubagentModel | undefined {
+	const parsed = parseModelRef(ref);
+	if (!parsed) return undefined;
+	return { modelRef: ref, ...parsed };
+}
+
+const WEB_FAST_AGENT_IDS = new Set([
+	"harness/web-retrieval/web-query-expander-fast",
+	"harness/web-retrieval/web-summarizer",
+	"harness/web-retrieval/web-gap-analyzer",
+]);
+
+const WEB_QUALITY_AGENT_IDS = new Set([
+	"harness/web-retrieval/web-answerer",
+	"harness/web-retrieval/web-criteria-verifier",
+]);
+
+function envModelRef(varName: string): string | undefined {
+	const v = process.env[varName]?.trim();
+	return v && parseModelRef(v) ? v : undefined;
+}
+
+function modelFromEnv(agentName: string): ConcreteSubagentModel | undefined {
+	const fast = envModelRef("HARNESS_WEB_FAST_MODEL");
+	if (fast && WEB_FAST_AGENT_IDS.has(agentName)) return toConcrete(fast);
+	const expander = envModelRef("HARNESS_WEB_EXPANDER_MODEL");
+	if (expander && agentName === "harness/web-retrieval/web-query-expander") return toConcrete(expander);
+	const quality = envModelRef("HARNESS_WEB_QUALITY_MODEL");
+	if (quality && WEB_QUALITY_AGENT_IDS.has(agentName)) return toConcrete(quality);
+	return undefined;
+}
+
 export function resolveConcreteSubagentModel(
 	_parentCwd: string,
 	parentModel: { provider: string; id: string } | undefined,
 	agent: AgentConfig,
 	_taskSnippet?: string,
 ): ConcreteSubagentModel | undefined {
+	const envOverride = modelFromEnv(agent.name);
+	if (envOverride) return envOverride;
+
 	if (agent.model) {
-		const parsed = parseModelRef(agent.model);
-		if (parsed) {
-			return { modelRef: agent.model, ...parsed };
-		}
+		const concrete = toConcrete(agent.model);
+		if (concrete) return concrete;
 	}
 
 	if (!parentModel || parentModel.provider === "router") return undefined;
-	const modelRef = `${parentModel.provider}/${parentModel.id}`;
-	const parsed = parseModelRef(modelRef);
-	if (!parsed) return undefined;
-	return { modelRef, ...parsed };
+	return toConcrete(`${parentModel.provider}/${parentModel.id}`);
 }

package/.pi/lib/harness-subagents-bridge.ts

@@ -14,7 +14,7 @@ import {
 	type SpawnAuthForward,
 } from "../../vendor/pi-subagents/src/subagents.js";
 import { subagentGovernanceExtensionPath } from "../extensions/subagent-governance.js";
-import { getAgentKind } from "./agents-policy.mjs";
+import { getAgentKind, resolveExtensionBundlePaths } from "./agents-policy.mjs";
 import {
 	delegationEnvFromBundle,
 	mintSubagentDelegation,
@@ -43,6 +43,10 @@ import {
 	inferPhaseForPrecheck,
 	precheckHarnessSubagentSpawn,
 } from "./harness-subagent-precheck.js";
+import {
+	getRememberedSessionWebArtifactDir,
+	resolveWebArtifactScope,
+} from "./harness-web/artifacts.js";
 
 const spawnBudget = createSpawnBudgetState();
 let lastSessionId = "harness";
@@ -122,6 +126,8 @@ export function createHarnessSubagentsExtension(
 		packageRoot,
 		subprocessGovernanceExtensionPath: governanceExtPath,
 		harnessSubprocessExtensionPath: governanceExtPath,
+		resolveExtensionBundlePaths: (bundleName) =>
+			resolveExtensionBundlePaths(packageRoot, bundleName),
 		resolveSubprocessEnv: (task, agent) => {
 			const projectRoot = process.cwd();
 			const base: Record<string, string> = {
@@ -130,6 +136,23 @@ export function createHarnessSubagentsExtension(
 				HARNESS_PKG_ROOT: packageRoot,
 				HARNESS_PROJECT_ROOT: projectRoot,
 			};
+			if (agent.name.startsWith("harness/web-retrieval/")) {
+				const ctx = parseSpawnContextFromTask(task);
+				const remembered = getRememberedSessionWebArtifactDir(lastSessionId);
+				if (remembered) {
+					base.HARNESS_WEB_ARTIFACT_DIR = remembered;
+				} else if (ctx?.run_id) {
+					base.HARNESS_WEB_ARTIFACT_DIR = resolveWebArtifactScope({
+						projectRoot,
+						explicitArtifactDir: `.web/runs/${ctx.run_id}`,
+					}).artifactDir;
+				} else {
+					base.HARNESS_WEB_ARTIFACT_DIR = resolveWebArtifactScope({
+						projectRoot,
+						piSessionId: lastSessionId,
+					}).artifactDir;
+				}
+			}
 			const ctx = parseSpawnContextFromTask(task);
 			if (!ctx?.run_id) return base;
 			if (spawnCircuitOpen(ctx.run_id)) {

package/.pi/lib/harness-web/artifacts.ts

@@ -0,0 +1,200 @@
+/**
+ * WRS workspace paths — flat `.web/` aliases + optional per-run/session isolation.
+ * Search/fetch payloads are pooled under `.web/cache/` (see cache.ts).
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { activeRunPointerPath } from "../harness-run-context.js";
+import { WEB_ROOT, webCacheHint } from "./cache.js";
+
+export type WebArtifactScopeSource =
+	| "explicit"
+	| "run"
+	| "session"
+	| "workspace";
+
+export interface WebArtifactScope {
+	/** Relative path under repo root, e.g. `.web` or `.web/runs/abc` */
+	artifactDir: string;
+	scopeId: string;
+	source: WebArtifactScopeSource;
+}
+
+function webIsolateEnabled(): boolean {
+	return (
+		process.env.HARNESS_WEB_ISOLATE === "1" ||
+		process.env.HARNESS_WEB_LEGACY_SCOPE === "1"
+	);
+}
+
+/** Parent session → last resolved artifact dir (for web-retrieval subagent env). */
+const sessionArtifactDirs = new Map<string, string>();
+
+const CANONICAL_BASENAMES = new Set([
+	"angles.yaml",
+	"angles-inline.yaml",
+	"search-deep.json",
+	"search.json",
+	"evidence-bundle.json",
+	"answer.md",
+	"highlights.json",
+	"page.md",
+	"map.json",
+]);
+
+export function sanitizeWebScopeId(id: string): string {
+	return id.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 120);
+}
+
+export function isScopedWebArtifactPath(path: string): boolean {
+	const n = path.replace(/\\/g, "/");
+	if (!n.startsWith(`${WEB_ROOT}/`)) return false;
+	const rest = n.slice(`${WEB_ROOT}/`.length);
+	const top = rest.split("/")[0];
+	return top === "runs" || top === "sessions";
+}
+
+function readActiveHarnessRunId(projectRoot: string): string | null {
+	const pointerPath = activeRunPointerPath(projectRoot);
+	if (!existsSync(pointerPath)) return null;
+	try {
+		const raw = readFileSync(pointerPath, "utf-8");
+		const data = JSON.parse(raw) as { run_id?: string };
+		const runId = data.run_id?.trim();
+		return runId || null;
+	} catch {
+		return null;
+	}
+}
+
+export function resolveWebArtifactScope(options: {
+	projectRoot: string;
+	piSessionId?: string;
+	explicitScope?: string;
+	explicitArtifactDir?: string;
+}): WebArtifactScope {
+	const explicitDir =
+		options.explicitArtifactDir?.trim() ||
+		options.explicitScope?.trim() ||
+		process.env.HARNESS_WEB_ARTIFACT_DIR?.trim() ||
+		process.env.HARNESS_WEB_SCOPE?.trim();
+	if (explicitDir) {
+		const normalized = normalizeArtifactDir(explicitDir);
+		return {
+			artifactDir: normalized,
+			scopeId: normalized.split("/").pop() ?? normalized,
+			source: "explicit",
+		};
+	}
+
+	if (webIsolateEnabled()) {
+		const runId =
+			process.env.HARNESS_RUN_ID?.trim() ||
+			readActiveHarnessRunId(options.projectRoot);
+		if (runId) {
+			const id = sanitizeWebScopeId(runId);
+			return {
+				artifactDir: `${WEB_ROOT}/runs/${id}`,
+				scopeId: id,
+				source: "run",
+			};
+		}
+
+		const sessionId = options.piSessionId?.trim();
+		if (sessionId) {
+			const id = sanitizeWebScopeId(sessionId);
+			return {
+				artifactDir: `${WEB_ROOT}/sessions/${id}`,
+				scopeId: id,
+				source: "session",
+			};
+		}
+	}
+
+	return {
+		artifactDir: WEB_ROOT,
+		scopeId: "workspace",
+		source: "workspace",
+	};
+}
+
+export function normalizeArtifactDir(dir: string): string {
+	let n = dir.replace(/\\/g, "/").trim();
+	if (n.startsWith("./")) n = n.slice(2);
+	if (n === WEB_ROOT || n === `${WEB_ROOT}/`) return WEB_ROOT;
+	if (!n.startsWith(`${WEB_ROOT}/`)) {
+		n = `${WEB_ROOT}/${n.replace(/^\/+/, "")}`;
+	}
+	return n.replace(/\/+$/, "");
+}
+
+export function scopedWebArtifactPath(
+	artifactDir: string,
+	basename: string,
+): string {
+	const base = normalizeArtifactDir(artifactDir);
+	if (base === WEB_ROOT) return `${WEB_ROOT}/${basename}`;
+	return `${base}/${basename}`;
+}
+
+/**
+ * Resolve output path: honor explicit paths; optional isolation rewrites flat canonical names.
+ */
+export function resolveWebOutputPath(options: {
+	projectRoot: string;
+	piSessionId?: string;
+	basename: string;
+	explicitOutput?: string;
+	webScope?: string;
+}): { path: string; artifactDir: string; scope: WebArtifactScope } {
+	const scope = resolveWebArtifactScope({
+		projectRoot: options.projectRoot,
+		piSessionId: options.piSessionId,
+		explicitScope: options.webScope,
+	});
+
+	const explicit = options.explicitOutput?.trim();
+	if (explicit) {
+		const norm = explicit.replace(/\\/g, "/");
+		if (isScopedWebArtifactPath(norm)) {
+			const artifactDir = norm.slice(0, norm.lastIndexOf("/"));
+			return { path: norm, artifactDir, scope };
+		}
+		const base = norm.split("/").pop() ?? norm;
+		if (
+			webIsolateEnabled() &&
+			scope.source !== "workspace" &&
+			norm.startsWith(`${WEB_ROOT}/`) &&
+			CANONICAL_BASENAMES.has(base)
+		) {
+			const path = scopedWebArtifactPath(scope.artifactDir, base);
+			return { path, artifactDir: scope.artifactDir, scope };
+		}
+		return { path: norm, artifactDir: scope.artifactDir, scope };
+	}
+
+	const path = scopedWebArtifactPath(scope.artifactDir, options.basename);
+	return { path, artifactDir: scope.artifactDir, scope };
+}
+
+export function rememberSessionWebArtifactDir(
+	sessionId: string,
+	artifactDir: string,
+): void {
+	if (!sessionId?.trim() || !artifactDir?.trim()) return;
+	sessionArtifactDirs.set(sessionId.trim(), normalizeArtifactDir(artifactDir));
+}
+
+export function getRememberedSessionWebArtifactDir(
+	sessionId: string,
+): string | undefined {
+	return sessionArtifactDirs.get(sessionId.trim());
+}
+
+export function webArtifactScopeHint(scope: WebArtifactScope): string {
+	const isolateNote = webIsolateEnabled()
+		? `Isolation on (${scope.artifactDir}/). Set HARNESS_WEB_ISOLATE=0 for shared workspace only.`
+		: `Shared workspace ${scope.artifactDir}/ for angles, search-deep, answer.md. Set HARNESS_WEB_ISOLATE=1 to isolate per session/run.`;
+	return `[WRS workspace] ${isolateNote} ${webCacheHint()}`;
+}