ultimate-pi 0.20.0 → 0.22.0

package/.pi/lib/harness-lens/clients/tool-policy.ts

@@ -1132,13 +1132,81 @@ export interface AutofixPolicyContext {
 	hasBiomeConfig?: boolean;
 }
 
+const JS_TS_EXTENSIONS = new Set([
+	".js",
+	".jsx",
+	".ts",
+	".tsx",
+	".mjs",
+	".cjs",
+]);
+const PY_EXTENSIONS = new Set([".py", ".pyi"]);
+const KOTLIN_EXTENSIONS = new Set([".kt", ".kts"]);
+
+function staticLinterPolicy(
+	runner: LintRunnerName,
+	gate: ToolGate = "smart-default",
+	defaultWhenUnconfigured = true,
+): LinterPolicy {
+	return {
+		runnerNames: [runner],
+		preferredRunners: [runner],
+		defaultRunner: runner,
+		defaultWhenUnconfigured,
+		gate,
+	};
+}
+
+const STATIC_LINTER_POLICY_BY_EXTENSION = new Map<string, LinterPolicy>([
+	[".css", staticLinterPolicy("stylelint")],
+	[".scss", staticLinterPolicy("stylelint")],
+	[".sass", staticLinterPolicy("stylelint")],
+	[".less", staticLinterPolicy("stylelint")],
+	[".sql", staticLinterPolicy("sqlfluff")],
+	[".rb", staticLinterPolicy("rubocop")],
+	[".rake", staticLinterPolicy("rubocop")],
+	[".gemspec", staticLinterPolicy("rubocop")],
+	[".ru", staticLinterPolicy("rubocop")],
+	[".yaml", staticLinterPolicy("yamllint")],
+	[".yml", staticLinterPolicy("yamllint")],
+	[".md", staticLinterPolicy("markdownlint")],
+	[".mdx", staticLinterPolicy("markdownlint")],
+	[".html", staticLinterPolicy("htmlhint")],
+	[".htm", staticLinterPolicy("htmlhint")],
+	[".toml", staticLinterPolicy("taplo")],
+	[".rs", staticLinterPolicy("rust-clippy")],
+	[".sh", staticLinterPolicy("shellcheck")],
+	[".bash", staticLinterPolicy("shellcheck")],
+	[".fish", staticLinterPolicy("fish-indent")],
+	[".tf", staticLinterPolicy("tflint")],
+	[".tfvars", staticLinterPolicy("tflint")],
+	[".ex", staticLinterPolicy("credo")],
+	[".exs", staticLinterPolicy("credo")],
+	[".eex", staticLinterPolicy("credo")],
+	[".heex", staticLinterPolicy("credo")],
+	[".leex", staticLinterPolicy("credo")],
+	[".c", staticLinterPolicy("cpp-check")],
+	[".cc", staticLinterPolicy("cpp-check")],
+	[".cpp", staticLinterPolicy("cpp-check")],
+	[".cxx", staticLinterPolicy("cpp-check")],
+	[".h", staticLinterPolicy("cpp-check")],
+	[".hpp", staticLinterPolicy("cpp-check")],
+	[".ino", staticLinterPolicy("cpp-check")],
+	[".dart", staticLinterPolicy("dart-analyze")],
+	[".gleam", staticLinterPolicy("gleam-check")],
+	[".ps1", staticLinterPolicy("psscriptanalyzer")],
+	[".psm1", staticLinterPolicy("psscriptanalyzer")],
+	[".psd1", staticLinterPolicy("psscriptanalyzer")],
+	[".prisma", staticLinterPolicy("prisma-validate")],
+]);
+
 export function getLinterPolicyForFile(
 	filePath: string,
 	context: LinterPolicyContext = {},
 ): LinterPolicy | undefined {
 	const ext = path.extname(filePath).toLowerCase();
 
-	if ([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"].includes(ext)) {
+	if (JS_TS_EXTENSIONS.has(ext)) {
 		const policy = getJstsLintPolicy({
 			hasEslintConfig: context.hasEslintConfig,
 			hasOxlintConfig: context.hasOxlintConfig,
@@ -1154,7 +1222,7 @@ export function getLinterPolicyForFile(
 		};
 	}
 
-	if ([".py", ".pyi"].includes(ext)) {
+	if (PY_EXTENSIONS.has(ext)) {
 		const preferredRunners: LintRunnerName[] = ["ruff-lint"];
 		if (context.hasMypyConfig) preferredRunners.push("mypy");
 		return {
@@ -1166,77 +1234,11 @@ export function getLinterPolicyForFile(
 		};
 	}
 
-	if ([".css", ".scss", ".sass", ".less"].includes(ext)) {
-		return {
-			runnerNames: ["stylelint"],
-			preferredRunners: ["stylelint"],
-			defaultRunner: "stylelint",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if (ext === ".sql") {
-		return {
-			runnerNames: ["sqlfluff"],
-			preferredRunners: ["sqlfluff"],
-			defaultRunner: "sqlfluff",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if ([".rb", ".rake", ".gemspec", ".ru"].includes(ext)) {
-		return {
-			runnerNames: ["rubocop"],
-			preferredRunners: ["rubocop"],
-			defaultRunner: "rubocop",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if ([".yaml", ".yml"].includes(ext)) {
-		return {
-			runnerNames: ["yamllint"],
-			preferredRunners: ["yamllint"],
-			defaultRunner: "yamllint",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if ([".md", ".mdx"].includes(ext)) {
-		return {
-			runnerNames: ["markdownlint"],
-			preferredRunners: ["markdownlint"],
-			defaultRunner: "markdownlint",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if ([".html", ".htm"].includes(ext)) {
-		return {
-			runnerNames: ["htmlhint"],
-			preferredRunners: ["htmlhint"],
-			defaultRunner: "htmlhint",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
 	if (path.basename(filePath).toLowerCase() === "dockerfile") {
-		return {
-			runnerNames: ["hadolint"],
-			preferredRunners: ["hadolint"],
-			defaultRunner: "hadolint",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
+		return staticLinterPolicy("hadolint");
 	}
 
-	if ([".kt", ".kts"].includes(ext)) {
+	if (KOTLIN_EXTENSIONS.has(ext)) {
 		const preferredRunners: LintRunnerName[] = ["ktlint"];
 		if (context.hasDetektConfig) preferredRunners.push("detekt");
 		return {
@@ -1248,16 +1250,6 @@ export function getLinterPolicyForFile(
 		};
 	}
 
-	if (ext === ".toml") {
-		return {
-			runnerNames: ["taplo"],
-			preferredRunners: ["taplo"],
-			defaultRunner: "taplo",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
 	if (ext === ".go") {
 		return {
 			runnerNames: ["golangci-lint"],
@@ -1278,107 +1270,7 @@ export function getLinterPolicyForFile(
 		};
 	}
 
-	if (ext === ".rs") {
-		return {
-			runnerNames: ["rust-clippy"],
-			preferredRunners: ["rust-clippy"],
-			defaultRunner: "rust-clippy",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if ([".sh", ".bash"].includes(ext)) {
-		return {
-			runnerNames: ["shellcheck"],
-			preferredRunners: ["shellcheck"],
-			defaultRunner: "shellcheck",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if (ext === ".fish") {
-		return {
-			runnerNames: ["fish-indent"],
-			preferredRunners: ["fish-indent"],
-			defaultRunner: "fish-indent",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if ([".tf", ".tfvars"].includes(ext)) {
-		return {
-			runnerNames: ["tflint"],
-			preferredRunners: ["tflint"],
-			defaultRunner: "tflint",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if ([".ex", ".exs", ".eex", ".heex", ".leex"].includes(ext)) {
-		return {
-			runnerNames: ["credo"],
-			preferredRunners: ["credo"],
-			defaultRunner: "credo",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if ([".c", ".cc", ".cpp", ".cxx", ".h", ".hpp", ".ino"].includes(ext)) {
-		return {
-			runnerNames: ["cpp-check"],
-			preferredRunners: ["cpp-check"],
-			defaultRunner: "cpp-check",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if (ext === ".dart") {
-		return {
-			runnerNames: ["dart-analyze"],
-			preferredRunners: ["dart-analyze"],
-			defaultRunner: "dart-analyze",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if (ext === ".gleam") {
-		return {
-			runnerNames: ["gleam-check"],
-			preferredRunners: ["gleam-check"],
-			defaultRunner: "gleam-check",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if ([".ps1", ".psm1", ".psd1"].includes(ext)) {
-		return {
-			runnerNames: ["psscriptanalyzer"],
-			preferredRunners: ["psscriptanalyzer"],
-			defaultRunner: "psscriptanalyzer",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	if (ext === ".prisma") {
-		return {
-			runnerNames: ["prisma-validate"],
-			preferredRunners: ["prisma-validate"],
-			defaultRunner: "prisma-validate",
-			defaultWhenUnconfigured: true,
-			gate: "smart-default",
-		};
-	}
-
-	return undefined;
+	return STATIC_LINTER_POLICY_BY_EXTENSION.get(ext);
 }
 
 export function getLinterPolicyForCwd(

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

@@ -336,57 +336,101 @@ function applyEditAutopatch(
 	return undefined;
 }
 
-export default function harnessLensExtension(pi: ExtensionAPI): void {
-	initLensEvents(pi);
-	const globalConfig = loadPiLensGlobalConfig();
-	let lensEnabled = !globalConfig.noLens;
-
-	type PiWithFlags = ExtensionAPI & {
-		getFlag?: (name: string) => boolean | undefined;
-	};
-	const piFlags = pi as PiWithFlags;
-	const readCliFlag = (name: string): boolean | undefined => {
-		if (typeof piFlags.getFlag === "function") return piFlags.getFlag(name);
-		return process.argv.includes(`--${name}`) ? true : undefined;
-	};
-	const getFlag = (name: string) =>
-		getLensFlag(name, readCliFlag, globalConfig);
-
+function registerLensRuntimePart1(
+	pi: ExtensionAPI,
+	getFlag: (name: string) => boolean | string | undefined,
+	runtime: RuntimeCoordinator,
+	lensEnabledRef: { current: boolean },
+) {
 	pi.registerFlag("no-lens", {
 		description: "Disable harness-lens for this session.",
 		type: "boolean",
 		default: false,
 	});
+}
+
+function registerLensRuntimePart2(
+	pi: ExtensionAPI,
+	getFlag: (name: string) => boolean | string | undefined,
+	runtime: RuntimeCoordinator,
+	lensEnabledRef: { current: boolean },
+) {
 	pi.registerFlag("no-lsp", {
 		description: "Disable LSP auto-touch and lsp_* tools backing servers.",
 		type: "boolean",
 		default: false,
 	});
+}
+
+function registerLensRuntimePart3(
+	pi: ExtensionAPI,
+	getFlag: (name: string) => boolean | string | undefined,
+	runtime: RuntimeCoordinator,
+	lensEnabledRef: { current: boolean },
+) {
 	pi.registerFlag("no-autoformat", {
 		description: "Disable auto-format on write/edit.",
 		type: "boolean",
 		default: false,
 	});
+}
+
+function registerLensRuntimePart4(
+	pi: ExtensionAPI,
+	getFlag: (name: string) => boolean | string | undefined,
+	runtime: RuntimeCoordinator,
+	lensEnabledRef: { current: boolean },
+) {
 	pi.registerFlag("immediate-format", {
 		description: "Format during tool_result instead of deferring to agent_end.",
 		type: "boolean",
 		default: false,
 	});
+}
+
+function registerLensRuntimePart5(
+	pi: ExtensionAPI,
+	getFlag: (name: string) => boolean | string | undefined,
+	runtime: RuntimeCoordinator,
+	lensEnabledRef: { current: boolean },
+) {
 	pi.registerFlag("lens-guard", {
 		description: "Block git commit/push while unresolved lens blockers exist.",
 		type: "boolean",
 		default: false,
 	});
+}
 
+function registerLensRuntimePart6(
+	pi: ExtensionAPI,
+	getFlag: (name: string) => boolean | string | undefined,
+	runtime: RuntimeCoordinator,
+	lensEnabledRef: { current: boolean },
+) {
 	pi.registerTool(createLspDiagnosticsTool());
-	pi.registerTool(createLspNavigationTool());
+}
 
+function registerLensRuntimePart7(
+	pi: ExtensionAPI,
+	getFlag: (name: string) => boolean | string | undefined,
+	runtime: RuntimeCoordinator,
+	lensEnabledRef: { current: boolean },
+) {
+	pi.registerTool(createLspNavigationTool(getFlag));
+}
+
+function registerLensRuntimePart8(
+	pi: ExtensionAPI,
+	getFlag: (name: string) => boolean | string | undefined,
+	runtime: RuntimeCoordinator,
+	lensEnabledRef: { current: boolean },
+) {
 	pi.on("session_start", async (_event, ctx) => {
 		if (getFlag("no-lens")) {
-			lensEnabled = false;
+			lensEnabledRef.current = false;
 			return;
 		}
-		lensEnabled = true;
+		lensEnabledRef.current = true;
 		runtime.resetForSession();
 		clearWidgetState();
 		resetFormatService();
@@ -416,15 +460,126 @@ export default function harnessLensExtension(pi: ExtensionAPI): void {
 			});
 		}
 	});
+}
 
+function registerLensRuntimePart9(
+	pi: ExtensionAPI,
+	getFlag: (name: string) => boolean | string | undefined,
+	runtime: RuntimeCoordinator,
+	lensEnabledRef: { current: boolean },
+) {
 	pi.on("turn_start", () => {
-		if (!lensEnabled) return;
+		if (!lensEnabledRef.current) return;
 		runtime.beginTurn();
 		clearLastAnalyzedStateCache();
 	});
+}
+
+async function ensureToolCallLspConfig(args: {
+	getFlag: (name: string) => boolean | string | undefined;
+	filePath: string | undefined;
+	ctx: any;
+	runtime: RuntimeCoordinator;
+}): Promise<void> {
+	if (args.getFlag("no-lsp")) return;
+	try {
+		await ensureLSPConfigInitialized(
+			args.filePath
+				? path.dirname(args.filePath)
+				: (args.ctx.cwd ?? args.runtime.projectRoot),
+		);
+	} catch (err) {
+		dbg(`tool_call lsp config init failed: ${err}`);
+	}
+}
+
+function maybeAutoTouchLspOnToolCall(args: {
+	getFlag: (name: string) => boolean | string | undefined;
+	toolName: string;
+	filePath: string;
+	runtime: RuntimeCoordinator;
+}): void {
+	if (
+		args.getFlag("no-lsp") ||
+		!isLspCapableFile(args.filePath) ||
+		shouldSkipLspAutoTouch(args.filePath, args.runtime.projectRoot)
+	) {
+		return;
+	}
+	const shouldWarmRead =
+		args.toolName === "read" && args.runtime.shouldWarmLspOnRead(args.filePath);
+	const shouldTouch =
+		args.toolName === "write" ||
+		args.toolName === "edit" ||
+		args.toolName === "lsp_navigation" ||
+		shouldWarmRead;
+	if (!shouldTouch) return;
+	try {
+		const content = nodeFs.readFileSync(args.filePath, "utf-8");
+		if (args.toolName === "read")
+			args.runtime.markLspReadWarmStarted(args.filePath);
+		void getLSPService()
+			.touchFile(args.filePath, content, {
+				diagnostics: "none",
+				source: `tool_call:${args.toolName}`,
+			})
+			.then((result) => {
+				if (args.toolName !== "read") return;
+				if (result === undefined)
+					args.runtime.clearLspReadWarmState(args.filePath);
+				else args.runtime.markLspReadWarmCompleted(args.filePath);
+			})
+			.catch((err) => {
+				if (args.toolName === "read") {
+					args.runtime.clearLspReadWarmState(args.filePath);
+				}
+				dbg(`lsp auto-touch failed: ${err}`);
+			});
+	} catch {
+		if (args.toolName === "read")
+			args.runtime.clearLspReadWarmState(args.filePath);
+	}
+}
 
+function applyEditAutopatchForToolCall(
+	filePath: string,
+	event: unknown,
+	ctx: unknown,
+) {
+	if (
+		!isToolCallEventType(
+			"edit",
+			event as Parameters<typeof isToolCallEventType>[1],
+		)
+	) {
+		return undefined;
+	}
+	const editInput = (event as { input?: unknown }).input;
+	if (isAnchoredEditToolInput(editInput)) {
+		return applyAnchoredEditAutopatch(
+			filePath,
+			editInput,
+			anchoredEditTaskId({
+				sessionId: (ctx as { sessionId?: string }).sessionId,
+			}),
+		);
+	}
+	const legacyInput = editInput as {
+		oldText?: string;
+		newText?: string;
+		edits?: Array<{ oldText?: string; newText?: string }>;
+	};
+	return applyEditAutopatch(filePath, legacyInput);
+}
+
+function registerLensRuntimePart10(
+	pi: ExtensionAPI,
+	getFlag: (name: string) => boolean | string | undefined,
+	runtime: RuntimeCoordinator,
+	lensEnabledRef: { current: boolean },
+) {
 	pi.on("tool_call", async (event, ctx) => {
-		if (!lensEnabled) return;
+		if (!lensEnabledRef.current) return;
 
 		const toolName = (event as { toolName?: string }).toolName ?? "";
 		if (
@@ -442,100 +597,33 @@ export default function harnessLensExtension(pi: ExtensionAPI): void {
 			runtime.projectRoot,
 		);
 
-		if (!getFlag("no-lsp")) {
-			try {
-				await ensureLSPConfigInitialized(
-					filePath ? path.dirname(filePath) : (ctx.cwd ?? runtime.projectRoot),
-				);
-			} catch (err) {
-				dbg(`tool_call lsp config init failed: ${err}`);
-			}
-		}
-
+		await ensureToolCallLspConfig({ getFlag, filePath, ctx, runtime });
 		if (!filePath || !nodeFs.existsSync(filePath)) return;
 		if (isPathIgnoredByProject(filePath, runtime.projectRoot, false)) return;
 
-		if (
-			!getFlag("no-lsp") &&
-			isLspCapableFile(filePath) &&
-			!shouldSkipLspAutoTouch(filePath, runtime.projectRoot)
-		) {
-			const shouldWarmRead =
-				toolName === "read" && runtime.shouldWarmLspOnRead(filePath);
-			const shouldTouch =
-				toolName === "write" ||
-				toolName === "edit" ||
-				toolName === "lsp_navigation" ||
-				shouldWarmRead;
-			if (shouldTouch) {
-				try {
-					const content = nodeFs.readFileSync(filePath, "utf-8");
-					if (toolName === "read") runtime.markLspReadWarmStarted(filePath);
-					void getLSPService()
-						.touchFile(filePath, content, {
-							diagnostics: "none",
-							source: `tool_call:${toolName}`,
-						})
-						.then((result) => {
-							if (toolName === "read") {
-								if (result === undefined) {
-									runtime.clearLspReadWarmState(filePath);
-								} else {
-									runtime.markLspReadWarmCompleted(filePath);
-								}
-							}
-						})
-						.catch((err) => {
-							if (toolName === "read") runtime.clearLspReadWarmState(filePath);
-							dbg(`lsp auto-touch failed: ${err}`);
-						});
-				} catch {
-					if (toolName === "read") runtime.clearLspReadWarmState(filePath);
-				}
-			}
-		}
-
-		if (
-			isToolCallEventType(
-				"edit",
-				event as Parameters<typeof isToolCallEventType>[1],
-			)
-		) {
-			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;
-			}
-		}
+		maybeAutoTouchLspOnToolCall({ getFlag, toolName, filePath, runtime });
+		const block = applyEditAutopatchForToolCall(filePath, event, ctx);
+		if (block) return block;
 	});
+}
 
-	pi.on("tool_result", async (event, _ctx) => {
-		if (!lensEnabled) return;
-		return handleToolResult({
-			event: event as Parameters<typeof handleToolResult>[0]["event"],
-			getFlag,
-			dbg,
-			runtime,
-			resetLSPService,
-		});
-	});
+function registerLensRuntimePart11(
+	pi: ExtensionAPI,
+	getFlag: (name: string) => boolean | string | undefined,
+	runtime: RuntimeCoordinator,
+	lensEnabledRef: { current: boolean },
+) {
+	pi as any;
+}
 
+function registerLensRuntimePart12(
+	pi: ExtensionAPI,
+	getFlag: (name: string) => boolean | string | undefined,
+	runtime: RuntimeCoordinator,
+	lensEnabledRef: { current: boolean },
+) {
 	pi.on("agent_end", async (_event, ctx) => {
-		if (!lensEnabled) return;
+		if (!lensEnabledRef.current) return;
 		await handleAgentEnd({
 			ctxCwd: ctx.cwd,
 			getFlag,
@@ -547,3 +635,48 @@ export default function harnessLensExtension(pi: ExtensionAPI): void {
 		});
 	});
 }
+
+function registerHarnessLensRuntime(
+	pi: ExtensionAPI,
+	args: {
+		getFlag: (name: string) => boolean | string | undefined;
+		runtime: RuntimeCoordinator;
+		lensEnabledRef: { current: boolean };
+	},
+) {
+	const { getFlag, runtime, lensEnabledRef } = args;
+	registerLensRuntimePart1(pi, getFlag, runtime, lensEnabledRef);
+	registerLensRuntimePart2(pi, getFlag, runtime, lensEnabledRef);
+	registerLensRuntimePart3(pi, getFlag, runtime, lensEnabledRef);
+	registerLensRuntimePart4(pi, getFlag, runtime, lensEnabledRef);
+	registerLensRuntimePart5(pi, getFlag, runtime, lensEnabledRef);
+	registerLensRuntimePart6(pi, getFlag, runtime, lensEnabledRef);
+	registerLensRuntimePart7(pi, getFlag, runtime, lensEnabledRef);
+	registerLensRuntimePart8(pi, getFlag, runtime, lensEnabledRef);
+	registerLensRuntimePart9(pi, getFlag, runtime, lensEnabledRef);
+	registerLensRuntimePart10(pi, getFlag, runtime, lensEnabledRef);
+	registerLensRuntimePart11(pi, getFlag, runtime, lensEnabledRef);
+	registerLensRuntimePart12(pi, getFlag, runtime, lensEnabledRef);
+}
+
+export default function harnessLensExtension(pi: ExtensionAPI): void {
+	initLensEvents(pi);
+	const globalConfig = loadPiLensGlobalConfig();
+	const lensEnabledRef = { current: !globalConfig.noLens };
+
+	type PiWithFlags = ExtensionAPI & {
+		getFlag?: (name: string) => boolean | string | undefined;
+	};
+	const piFlags = pi as PiWithFlags;
+	const readCliFlag = (name: string): boolean | undefined => {
+		if (typeof piFlags.getFlag === "function") {
+			const flag = piFlags.getFlag(name);
+			return typeof flag === "boolean" ? flag : undefined;
+		}
+		return process.argv.includes(`--${name}`) ? true : undefined;
+	};
+	const getFlag = (name: string) =>
+		getLensFlag(name, readCliFlag, globalConfig);
+
+	registerHarnessLensRuntime(pi, { getFlag, runtime, lensEnabledRef });
+}