one-code-extension 0.1.4 → 0.3.0

package/extensions/subagents/pending-claim.ts

@@ -0,0 +1,45 @@
+/**
+ * The backstop for a fabricated agent result (pure).
+ *
+ * Putting Claude Code's prohibition in the Agent tool's RESULT rather than only
+ * in its description was the first fix for WEAK-MODEL-REVIEW-2026-09-06 H1, and
+ * measured live it was not enough: `openai-codex/gpt-5.6-luna` still ended a
+ * turn with the pending agent's answer in 3 of 6 `pending` runs, with the
+ * prohibition verifiably on the wire. The failure has a signature — the model
+ * writes "I'm waiting for the agent's result" and then states the result in the
+ * same message — and a shape the harness can see without reading the text at
+ * all: the agent loop ended while a run started inside it was still live.
+ *
+ * So the harness says so on the next request. This cannot un-print the sentence
+ * the user already saw; what it does is stop the model treating the real
+ * notification as confirmation of something it invented, which is how the
+ * fabrication survived into the final answer ("The agent confirmed the same
+ * result").
+ *
+ * Wording is deliberately CONDITIONAL. The trigger fires on correct behaviour
+ * too — a model that said only "I'm waiting for the agent" ends its turn the
+ * same way — so the text must not accuse. Measured precision on the six-run
+ * battery: 4 fires, 3 of them real fabrications.
+ */
+
+/** A live run the model started during the agent loop that just ended. */
+export interface PendingRun {
+	name: string;
+	taskId: string;
+}
+
+/**
+ * The one-shot for a turn that ended with runs still pending, or undefined when
+ * there is nothing to say. Named runs, so a model with several in flight knows
+ * which ones it cannot have heard from.
+ */
+export function pendingClaimReminder(runs: readonly PendingRun[]): string | undefined {
+	if (runs.length === 0) return undefined;
+	const named = runs.map((run) => `${run.name} (task ${run.taskId})`).join(", ");
+	const subject = runs.length === 1 ? "It has" : "They have";
+	return (
+		`You ended that turn while ${named} ${runs.length === 1 ? "was" : "were"} still running. ${subject} not reported yet, ` +
+		"so anything you stated about the result did not come from the agent — if you gave the user a result, say plainly in your next message that it was not the agent's and correct it. " +
+		"Wait for the notification, or call task_output with block=true."
+	);
+}

package/extensions/subagents/prose.ts

@@ -0,0 +1,105 @@
+/**
+ * Markdown prose for the subagent transcript viewer: the child's assistant
+ * text renders through pi-tui's real `Markdown` component — the exact renderer
+ * the main transcript uses — so the panel matches the main session's text
+ * fidelity (headings, code highlighting, lists) instead of plain wrapped text.
+ *
+ * pi-tui is pi's own nested dependency (not hoisted, not ours to pin), and it
+ * cannot be require.resolve'd: pi-coding-agent's exports map defines only the
+ * "import" condition (createRequire fails with `No "exports" main defined`)
+ * and exposes no "./package.json" subpath. So the package is located by
+ * walking the same node_modules candidates Node itself would try — nested
+ * under pi-coding-agent first (npm's layout here), then hoisted as a sibling —
+ * and its entry file is imported by URL. Resolving relative to THIS file gives
+ * the same pi-coding-agent instance the rest of the package's imports bind to.
+ *
+ * `Markdown` memoizes render by (text, width); instances are cached per
+ * transcript block (immutable text → WeakMap, GC'd with the block) and per
+ * streaming slot (mutable text → keyed Map + setText, guarded so an unchanged
+ * text never invalidates the cache). The markdown theme comes from
+ * pi-coding-agent's `getMarkdownTheme()`, which reads the theme pi initialized
+ * at startup.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import type { ProseRenderer } from "./panel-render.ts";
+
+interface MarkdownLike {
+	setText(text: string): void;
+	render(width: number): string[];
+}
+
+type MarkdownCtor = new (text: string, paddingX: number, paddingY: number, theme: unknown) => MarkdownLike;
+
+/** The pi-tui entry file, found by walking node_modules (see module doc). Exported for tests. */
+export function resolvePiTuiEntry(): string {
+	const req = createRequire(import.meta.url);
+	const bases = req.resolve.paths("@earendil-works/pi-coding-agent") ?? [];
+	for (const base of bases) {
+		const agentDir = join(base, "@earendil-works", "pi-coding-agent");
+		if (!existsSync(join(agentDir, "package.json"))) continue;
+		for (const candidate of [
+			join(agentDir, "node_modules", "@earendil-works", "pi-tui"),
+			join(base, "@earendil-works", "pi-tui"),
+		]) {
+			const pkgPath = join(candidate, "package.json");
+			if (!existsSync(pkgPath)) continue;
+			const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as {
+				exports?: Record<string, string | { import?: string; default?: string }>;
+				module?: string;
+				main?: string;
+			};
+			const dot = pkg.exports?.["."];
+			const entry = (typeof dot === "string" ? dot : (dot?.import ?? dot?.default)) ?? pkg.module ?? pkg.main ?? "index.js";
+			return join(candidate, entry);
+		}
+	}
+	throw new Error("cannot locate @earendil-works/pi-tui next to pi-coding-agent");
+}
+
+let ctorPromise: Promise<MarkdownCtor> | undefined;
+
+async function loadMarkdownCtor(): Promise<MarkdownCtor> {
+	return (ctorPromise ??= (async () => {
+		const mod = (await import(pathToFileURL(resolvePiTuiEntry()).href)) as { Markdown?: MarkdownCtor };
+		if (typeof mod.Markdown !== "function") throw new Error("pi-tui exports no Markdown component");
+		return mod.Markdown;
+	})().catch((error) => {
+		ctorPromise = undefined; // a transient failure may recover on retry
+		throw error;
+	}));
+}
+
+/**
+ * Build the markdown ProseRenderer. Throws when pi-tui cannot be resolved —
+ * the caller falls back to plain wrapped text and tells the user once.
+ */
+export async function createMarkdownProse(): Promise<ProseRenderer> {
+	const Markdown = await loadMarkdownCtor();
+	const theme = getMarkdownTheme();
+	const blockCache = new WeakMap<object, MarkdownLike>();
+	const streamCache = new Map<string, { md: MarkdownLike; text: string }>();
+	return (ref, text, width) => {
+		if (typeof ref === "string") {
+			let slot = streamCache.get(ref);
+			if (!slot) {
+				slot = { md: new Markdown(text, 0, 0, theme), text };
+				streamCache.set(ref, slot);
+			} else if (slot.text !== text) {
+				slot.md.setText(text);
+				slot.text = text;
+			}
+			return slot.md.render(width);
+		}
+		let md = blockCache.get(ref);
+		if (!md) {
+			md = new Markdown(text, 0, 0, theme);
+			blockCache.set(ref, md);
+		}
+		return md.render(width);
+	};
+}