ultimate-pi 0.18.1 → 0.19.1

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()}`;
+}

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

@@ -0,0 +1,369 @@
+/**
+ * WRS local cache — pooled `.web/cache/` entries with freshness + search context.
+ * Workspace aliases (`.web/search-deep.json`, …) are copies/links for agent ergonomics.
+ */
+
+import {
+	copyFileSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	statSync,
+	writeFileSync,
+} from "node:fs";
+import { createHash } from "node:crypto";
+import { dirname, resolve } from "node:path";
+
+export const WEB_ROOT = ".web";
+export const WEB_CACHE_ROOT = `${WEB_ROOT}/cache`;
+
+export type WebCacheKind =
+	| "search"
+	| "search-deep"
+	| "fetch-page"
+	| "fetch-map"
+	| "fetch-highlights";
+
+export interface WebCacheMeta {
+	version: 1;
+	kind: WebCacheKind;
+	cacheKey: string;
+	createdAt: string;
+	expiresAt: string;
+	ttlSeconds: number;
+	context: Record<string, unknown>;
+	artifact: string;
+	hitCount: number;
+}
+
+export interface SearchCacheContext {
+	query: string;
+	tier: string;
+	engine: string;
+	limit: number;
+	category?: string;
+	expandHeuristic?: boolean;
+	anglesFingerprint?: string;
+}
+
+export interface FetchCacheContext {
+	url: string;
+	mode: "scrape" | "map";
+	fast: boolean;
+	highlightQuery?: string;
+	highlights: boolean;
+}
+
+export interface CacheLookupResult {
+	hit: boolean;
+	stale: boolean;
+	cacheKey: string;
+	entryDir: string;
+	artifactPath: string;
+	metaPath: string;
+	meta?: WebCacheMeta;
+	ageMs?: number;
+}
+
+function shaKey(payload: unknown): string {
+	return createHash("sha256")
+		.update(JSON.stringify(payload))
+		.digest("hex")
+		.slice(0, 20);
+}
+
+export function cacheEnabled(): boolean {
+	const raw = process.env.HARNESS_WEB_CACHE?.trim();
+	if (raw === "0" || raw?.toLowerCase() === "false") return false;
+	return true;
+}
+
+export function defaultCacheTtlSeconds(): number {
+	const raw = process.env.HARNESS_WEB_CACHE_TTL_SEC?.trim();
+	if (raw) {
+		const n = Number.parseInt(raw, 10);
+		if (Number.isFinite(n) && n > 0) return n;
+	}
+	return 86_400; // 24h
+}
+
+export function fingerprintFile(projectRoot: string, relPath: string): string | undefined {
+	const full = resolve(projectRoot, relPath);
+	if (!existsSync(full)) return undefined;
+	const text = readFileSync(full, "utf-8");
+	return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+
+export function searchCacheKey(ctx: SearchCacheContext): string {
+	return shaKey({
+		v: 1,
+		kind: ctx.tier === "deep" || ctx.tier === "research" ? "search-deep" : "search",
+		query: ctx.query.trim().toLowerCase(),
+		tier: ctx.tier,
+		engine: ctx.engine,
+		limit: ctx.limit,
+		category: ctx.category?.trim().toLowerCase() || null,
+		expandHeuristic: Boolean(ctx.expandHeuristic),
+		angles: ctx.anglesFingerprint || null,
+	});
+}
+
+export function fetchCacheKey(ctx: FetchCacheContext): string {
+	return shaKey({
+		v: 1,
+		kind: ctx.highlights ? "fetch-highlights" : ctx.mode === "map" ? "fetch-map" : "fetch-page",
+		url: ctx.url.trim(),
+		mode: ctx.mode,
+		fast: ctx.fast,
+		highlightQuery: ctx.highlightQuery?.trim() || null,
+	});
+}
+
+function cacheKindFromTier(tier: string): WebCacheKind {
+	return tier === "deep" || tier === "research" ? "search-deep" : "search";
+}
+
+function entryDir(projectRoot: string, kind: WebCacheKind, cacheKey: string): string {
+	return `${WEB_CACHE_ROOT}/${kind}/${cacheKey}`;
+}
+
+function readMeta(metaPath: string): WebCacheMeta | undefined {
+	if (!existsSync(metaPath)) return undefined;
+	try {
+		const data = JSON.parse(readFileSync(metaPath, "utf-8")) as WebCacheMeta;
+		if (data?.version !== 1) return undefined;
+		return data;
+	} catch {
+		return undefined;
+	}
+}
+
+export function isCacheFresh(
+	meta: WebCacheMeta,
+	options?: { maxAgeSec?: number; nowMs?: number },
+): boolean {
+	const now = options?.nowMs ?? Date.now();
+	const expiresAt = Date.parse(meta.expiresAt);
+	if (Number.isFinite(expiresAt) && now > expiresAt) return false;
+	if (options?.maxAgeSec != null && options.maxAgeSec > 0) {
+		const createdAt = Date.parse(meta.createdAt);
+		if (Number.isFinite(createdAt) && now - createdAt > options.maxAgeSec * 1000) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function bumpHitCount(metaPath: string, meta: WebCacheMeta): void {
+	const next: WebCacheMeta = { ...meta, hitCount: (meta.hitCount ?? 0) + 1 };
+	writeFileSync(metaPath, `${JSON.stringify(next, null, 2)}\n`, "utf-8");
+}
+
+export function lookupSearchCache(
+	projectRoot: string,
+	ctx: SearchCacheContext,
+	options?: { maxAgeSec?: number; ttlSeconds?: number },
+): CacheLookupResult {
+	const cacheKey = searchCacheKey(ctx);
+	const kind = cacheKindFromTier(ctx.tier);
+	const relDir = entryDir(projectRoot, kind, cacheKey);
+	const absDir = resolve(projectRoot, relDir);
+	const artifactName = kind === "search-deep" ? "search-deep.json" : "search.json";
+	const artifactPath = resolve(absDir, artifactName);
+	const metaPath = resolve(absDir, "meta.json");
+	const base: CacheLookupResult = {
+		hit: false,
+		stale: false,
+		cacheKey,
+		entryDir: relDir,
+		artifactPath: `${relDir}/${artifactName}`,
+		metaPath: `${relDir}/meta.json`,
+	};
+	if (!cacheEnabled() || !existsSync(artifactPath)) return base;
+	const meta = readMeta(metaPath);
+	if (!meta) return { ...base, hit: true, stale: true };
+	const fresh = isCacheFresh(meta, {
+		maxAgeSec: options?.maxAgeSec,
+	});
+	const createdAt = Date.parse(meta.createdAt);
+	const ageMs = Number.isFinite(createdAt) ? Date.now() - createdAt : undefined;
+	if (fresh) bumpHitCount(metaPath, meta);
+	return {
+		...base,
+		hit: true,
+		stale: !fresh,
+		meta,
+		ageMs,
+	};
+}
+
+export function lookupFetchCache(
+	projectRoot: string,
+	ctx: FetchCacheContext,
+	options?: { maxAgeSec?: number },
+): CacheLookupResult {
+	const cacheKey = fetchCacheKey(ctx);
+	const kind: WebCacheKind = ctx.highlights
+		? "fetch-highlights"
+		: ctx.mode === "map"
+			? "fetch-map"
+			: "fetch-page";
+	const relDir = entryDir(projectRoot, kind, cacheKey);
+	const absDir = resolve(projectRoot, relDir);
+	const artifactName = ctx.highlights
+		? "highlights.json"
+		: ctx.mode === "map"
+			? "map.json"
+			: "page.md";
+	const artifactPath = resolve(absDir, artifactName);
+	const metaPath = resolve(absDir, "meta.json");
+	const base: CacheLookupResult = {
+		hit: false,
+		stale: false,
+		cacheKey,
+		entryDir: relDir,
+		artifactPath: `${relDir}/${artifactName}`,
+		metaPath: `${relDir}/meta.json`,
+	};
+	if (!cacheEnabled() || !existsSync(artifactPath)) return base;
+	const meta = readMeta(metaPath);
+	if (!meta) return { ...base, hit: true, stale: true };
+	const fresh = isCacheFresh(meta, { maxAgeSec: options?.maxAgeSec });
+	const createdAt = Date.parse(meta.createdAt);
+	const ageMs = Number.isFinite(createdAt) ? Date.now() - createdAt : undefined;
+	if (fresh) bumpHitCount(metaPath, meta);
+	return {
+		...base,
+		hit: true,
+		stale: !fresh,
+		meta,
+		ageMs,
+	};
+}
+
+export function writeSearchCacheEntry(
+	projectRoot: string,
+	ctx: SearchCacheContext,
+	sourceArtifactPath: string,
+	options?: { anglesPath?: string; ttlSeconds?: number },
+): { cacheKey: string; entryDir: string; metaPath: string } {
+	const cacheKey = searchCacheKey(ctx);
+	const kind = cacheKindFromTier(ctx.tier);
+	const relDir = entryDir(projectRoot, kind, cacheKey);
+	const absDir = resolve(projectRoot, relDir);
+	mkdirSync(absDir, { recursive: true });
+	const artifactName = kind === "search-deep" ? "search-deep.json" : "search.json";
+	const destArtifact = resolve(absDir, artifactName);
+	copyFileSync(resolve(projectRoot, sourceArtifactPath), destArtifact);
+	if (options?.anglesPath && existsSync(resolve(projectRoot, options.anglesPath))) {
+		copyFileSync(resolve(projectRoot, options.anglesPath), resolve(absDir, "angles.yaml"));
+	}
+	const ttl = options?.ttlSeconds ?? defaultCacheTtlSeconds();
+	const now = new Date();
+	const expires = new Date(now.getTime() + ttl * 1000);
+	const meta: WebCacheMeta = {
+		version: 1,
+		kind,
+		cacheKey,
+		createdAt: now.toISOString(),
+		expiresAt: expires.toISOString(),
+		ttlSeconds: ttl,
+		context: {
+			query: ctx.query,
+			tier: ctx.tier,
+			engine: ctx.engine,
+			limit: ctx.limit,
+			category: ctx.category ?? null,
+			expandHeuristic: Boolean(ctx.expandHeuristic),
+			anglesFingerprint: ctx.anglesFingerprint ?? null,
+		},
+		artifact: artifactName,
+		hitCount: 0,
+	};
+	const metaPath = resolve(absDir, "meta.json");
+	writeFileSync(metaPath, `${JSON.stringify(meta, null, 2)}\n`, "utf-8");
+	return { cacheKey, entryDir: relDir, metaPath: `${relDir}/meta.json` };
+}
+
+export function writeFetchCacheEntry(
+	projectRoot: string,
+	ctx: FetchCacheContext,
+	sourceArtifactPath: string,
+	extra?: { highlightsPath?: string },
+): { cacheKey: string; entryDir: string } {
+	const cacheKey = fetchCacheKey(ctx);
+	const kind: WebCacheKind = ctx.highlights
+		? "fetch-highlights"
+		: ctx.mode === "map"
+			? "fetch-map"
+			: "fetch-page";
+	const relDir = entryDir(projectRoot, kind, cacheKey);
+	const absDir = resolve(projectRoot, relDir);
+	mkdirSync(absDir, { recursive: true });
+	const artifactName = ctx.highlights
+		? "highlights.json"
+		: ctx.mode === "map"
+			? "map.json"
+			: "page.md";
+	copyFileSync(resolve(projectRoot, sourceArtifactPath), resolve(absDir, artifactName));
+	if (extra?.highlightsPath && existsSync(resolve(projectRoot, extra.highlightsPath))) {
+		copyFileSync(
+			resolve(projectRoot, extra.highlightsPath),
+			resolve(absDir, "highlights.json"),
+		);
+	}
+	const ttl = defaultCacheTtlSeconds();
+	const now = new Date();
+	const expires = new Date(now.getTime() + ttl * 1000);
+	const meta: WebCacheMeta = {
+		version: 1,
+		kind,
+		cacheKey,
+		createdAt: now.toISOString(),
+		expiresAt: expires.toISOString(),
+		ttlSeconds: ttl,
+		context: {
+			url: ctx.url,
+			mode: ctx.mode,
+			fast: ctx.fast,
+			highlightQuery: ctx.highlightQuery ?? null,
+			highlights: ctx.highlights,
+		},
+		artifact: artifactName,
+		hitCount: 0,
+	};
+	writeFileSync(
+		resolve(absDir, "meta.json"),
+		`${JSON.stringify(meta, null, 2)}\n`,
+		"utf-8",
+	);
+	return { cacheKey, entryDir: relDir };
+}
+
+/** Copy cached artifact to a stable workspace path for agents (`.web/search-deep.json`, …). */
+export function publishWorkspaceAlias(
+	projectRoot: string,
+	cacheArtifactPath: string,
+	workspaceBasename: string,
+): string {
+	const workspacePath = `${WEB_ROOT}/${workspaceBasename}`;
+	const dest = resolve(projectRoot, workspacePath);
+	mkdirSync(dirname(dest), { recursive: true });
+	copyFileSync(resolve(projectRoot, cacheArtifactPath), dest);
+	return workspacePath;
+}
+
+export function formatCacheAge(ageMs: number | undefined): string {
+	if (ageMs == null || ageMs < 0) return "unknown";
+	if (ageMs < 60_000) return `${Math.round(ageMs / 1000)}s`;
+	if (ageMs < 3_600_000) return `${Math.round(ageMs / 60_000)}m`;
+	return `${(ageMs / 3_600_000).toFixed(1)}h`;
+}
+
+export function webCacheHint(): string {
+	return (
+		`[WRS cache] Pooled under ${WEB_CACHE_ROOT}/ with TTL (HARNESS_WEB_CACHE_TTL_SEC, default 24h). ` +
+		`Workspace aliases: ${WEB_ROOT}/search-deep.json, ${WEB_ROOT}/angles.yaml, ${WEB_ROOT}/page.md. ` +
+		`Use refreshCache:true to bypass. Same query+angles reuses SERP without network.`
+	);
+}

package/.pi/{extensions/lib → lib}/harness-web/run-cli.ts

@@ -46,6 +46,8 @@ export interface SearchHit {
 	url: string;
 	title: string;
 	description: string;
+	score?: number;
+	angle_ids?: string[];
 }
 
 export function summarizeSearchJson(filePath: string, cwd: string): string {
@@ -55,11 +57,15 @@ export function summarizeSearchJson(filePath: string, cwd: string): string {
 		const data = JSON.parse(readFileSync(full, "utf-8")) as {
 			query?: string;
 			engine?: string;
+			tier?: string;
+			mode?: string;
 			data?: { web?: SearchHit[] };
 		};
 		const hits = data.data?.web ?? [];
+		const tier = data.tier ?? data.mode ?? "standard";
 		const lines = [
 			`engine: ${data.engine ?? "unknown"}`,
+			`tier: ${tier}`,
 			`query: ${data.query ?? ""}`,
 			`results: ${hits.length}`,
 			"",
@@ -67,6 +73,12 @@ export function summarizeSearchJson(filePath: string, cwd: string): string {
 		for (const [i, hit] of hits.entries()) {
 			lines.push(`${i + 1}. ${hit.title || "(no title)"}`);
 			lines.push(`   ${hit.url}`);
+			if (hit.score != null) {
+				lines.push(`   score: ${hit.score}`);
+			}
+			if (hit.angle_ids?.length) {
+				lines.push(`   angles: ${hit.angle_ids.join(", ")}`);
+			}
 			if (hit.description) {
 				const snip =
 					hit.description.length > 120
@@ -81,12 +93,40 @@ export function summarizeSearchJson(filePath: string, cwd: string): string {
 	}
 }
 
+export function summarizeDeepSearchJson(filePath: string, cwd: string): string {
+	const full = resolve(cwd, filePath);
+	if (!existsSync(full)) return "";
+	try {
+		const data = JSON.parse(readFileSync(full, "utf-8")) as {
+			query?: string;
+			angles?: Array<{ id: string; query: string }>;
+			data?: { web?: SearchHit[] };
+		};
+		const lines = [
+			summarizeSearchJson(filePath, cwd),
+			"",
+			`angles: ${data.angles?.length ?? 0}`,
+		];
+		for (const a of data.angles ?? []) {
+			lines.push(`  - ${a.id}: ${a.query}`);
+		}
+		lines.push("");
+		lines.push("Prefer URLs with multiple angle_ids. Use web_fetch highlights on top 3.");
+		return lines.join("\n");
+	} catch {
+		return summarizeSearchJson(filePath, cwd);
+	}
+}
+
 export function harnessWebContextLine(): string {
 	const engine = process.env.HARNESS_WEB_SEARCH_ENGINE?.trim() || "ddg_html";
 	const searx = process.env.HARNESS_WEB_SEARXNG_URL?.trim();
 	const searxPart = searx ? ` searxng_url=${searx}` : "";
 	return (
-		`[HarnessWeb] search_engine=${engine}${searxPart} — use web_search / web_fetch tools; ` +
-		"never resolve UP_PKG, ls harness-web.py, or python3 -c import scrapling before searching."
+		`[HarnessWeb] engine=${engine}${searxPart} | research: tier=deep + web-query-expander | ` +
+		"latency: tier=instant|standard or web-query-expander-fast | " +
+		"artifacts: .web/runs/<run_id>/ or .web/sessions/<session_id>/ (not flat .web/answer.md) | " +
+		"models: HARNESS_WEB_*_MODEL env (provider/model-id) | " +
+		"skill: web-retrieval"
 	);
 }

package/.pi/{extensions/lib → lib}/plan-approval/create-plan.ts

@@ -8,8 +8,8 @@ import {
 	saveProjectActiveRun,
 	saveRunContextToDisk,
 	validatePlanPacket,
-} from "../../../lib/harness-run-context.js";
-import { writeYamlFile } from "../../../lib/harness-yaml.js";
+} from "../harness-run-context.js";
+import { writeYamlFile } from "../harness-yaml.js";
 import { writePlanReviewMarkdown } from "./plan-review.js";
 
 export const CREATE_PLAN_SNIPPET = "create_plan()";

package/.pi/{extensions/lib → lib}/plan-approval/format-plan.ts

@@ -1,5 +1,5 @@
-import type { PlanPacketLike } from "../../../lib/harness-run-context.js";
-import { stringifyYaml } from "../../../lib/harness-yaml.js";
+import type { PlanPacketLike } from "../harness-run-context.js";
+import { stringifyYaml } from "../harness-yaml.js";
 
 /** Canonical YAML for plan_packet (same shape as plan-packet.yaml on disk). */
 export function formatPlanPacketYaml(packet: PlanPacketLike): string {