@asterxsk/kiln 0.1.0 → 0.3.0

package/agent.bak.20260905-190020/extensions/subagents/src/ui/transcript.ts

@@ -0,0 +1,201 @@
+/**
+ * Transcript rendering for the takeover view: turns a SubagentSnapshot's
+ * normalized transcript + live state into plain wrapped lines. Ported from
+ * v1, with the session-poking replaced by snapshot reads.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import {
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+import type { SubagentSnapshot, TranscriptItem } from "../domain.ts";
+
+const ANSI_PATTERN =
+  // eslint-disable-next-line no-control-regex
+  /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+
+/**
+ * Strip raw ANSI codes, expand tabs, and drop control chars. Terminal-expanded
+ * tabs (and stray escapes) make lines wider than the width we declare to the
+ * TUI, which desyncs the renderer and smears the overlay.
+ */
+export function sanitizeText(text: string): string {
+  return text
+    .replace(ANSI_PATTERN, "")
+    .replaceAll("\t", "  ")
+    .replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "");
+}
+
+function renderUserText(
+  theme: Theme,
+  text: string,
+  width: number,
+  out: string[],
+) {
+  const clean = sanitizeText(text).trim();
+  if (!clean) return;
+  const wrapped = wrapTextWithAnsi(clean, Math.max(10, width - 2));
+  for (let i = 0; i < wrapped.length; i++) {
+    const prefix = i === 0 ? theme.fg("accent", "> ") : "  ";
+    out.push(
+      truncateToWidth(prefix + theme.fg("userMessageText", wrapped[i]), width),
+    );
+  }
+}
+
+function renderThinking(
+  theme: Theme,
+  text: string,
+  width: number,
+  out: string[],
+) {
+  const reasoning = sanitizeText(text).trim();
+  if (!reasoning) return;
+  const prefix = theme.fg("dim", "~ ");
+  // Preserve paragraph breaks so multi-paragraph reasoning doesn't collapse
+  // into one wall of text; each paragraph gets its own `~` continuation.
+  const wrapped = wrapTextWithAnsi(reasoning, Math.max(10, width - 2));
+  for (let i = 0; i < wrapped.length; i++) {
+    const line = wrapped[i];
+    if (line.trim() === "" && i > 0) {
+      out.push("");
+      continue;
+    }
+    out.push(
+      truncateToWidth(
+        (i === 0 ? prefix : "  ") + theme.fg("muted", theme.italic(line)),
+        width,
+      ),
+    );
+  }
+}
+
+function renderAssistantItem(
+  theme: Theme,
+  item: Extract<TranscriptItem, { kind: "assistant" }>,
+  width: number,
+  out: string[],
+) {
+  // A rendered reasoning block is followed by a blank line so the thinking
+  // doesn't run into the answer/tool call that comes next.
+  let pendingGap = false;
+  for (const part of item.parts) {
+    if (part.type === "text") {
+      const text = sanitizeText(part.text).trim();
+      if (!text) continue;
+      if (pendingGap) out.push("");
+      out.push(...wrapTextWithAnsi(text, width));
+      pendingGap = false;
+    } else if (part.type === "thinking") {
+      const before = out.length;
+      renderThinking(
+        theme,
+        part.redacted ? "[redacted reasoning]" : part.text,
+        width,
+        out,
+      );
+      pendingGap = out.length > before;
+    } else if (part.type === "toolCall") {
+      if (pendingGap) out.push("");
+      const preview = part.argsPreview ? sanitizeText(part.argsPreview) : "";
+      const line =
+        theme.fg("muted", "→ ") +
+        theme.fg("toolTitle", part.name) +
+        (preview && preview !== "{}" ? theme.fg("dim", ` ${preview}`) : "");
+      out.push(truncateToWidth(line, width));
+      pendingGap = false;
+    }
+  }
+}
+
+function renderToolResultItem(
+  theme: Theme,
+  item: Extract<TranscriptItem, { kind: "toolResult" }>,
+  width: number,
+  out: string[],
+) {
+  const firstLine =
+    sanitizeText(item.outputPreview ?? "")
+      .split("\n")
+      .find((line) => line.trim()) ?? "";
+  const label = item.isError
+    ? theme.fg("error", "  error: ")
+    : theme.fg("dim", "  output: ");
+  out.push(
+    truncateToWidth(label + theme.fg("dim", firstLine || "(no output)"), width),
+  );
+}
+
+/** Render a subagent's conversation as plain lines, wrapped to `width`. */
+export function buildTranscriptLines(
+  snap: SubagentSnapshot,
+  width: number,
+  theme: Theme,
+): string[] {
+  const out: string[] = [];
+
+  for (const item of snap.transcript) {
+    const before = out.length;
+    if (item.kind === "user") {
+      renderUserText(theme, item.text, width, out);
+    } else if (item.kind === "assistant") {
+      renderAssistantItem(theme, item, width, out);
+    } else {
+      renderToolResultItem(theme, item, width, out);
+    }
+    if (out.length > before) out.push("");
+  }
+  while (out.length > 0 && out[out.length - 1] === "") out.pop();
+
+  // Live streaming assistant buffers (cleared when the finalized message lands).
+  if (snap.liveAssistant) {
+    const { thinking, text } = snap.liveAssistant;
+    const before = out.length;
+    if (out.length > 0) out.push("");
+    if (thinking.trim()) renderThinking(theme, thinking, width, out);
+    if (text.trim()) {
+      // Separate the streamed answer from the reasoning block above it.
+      if (thinking.trim()) out.push("");
+      out.push(...wrapTextWithAnsi(sanitizeText(text).trim(), width));
+    }
+    if (out.length === before + 1) out.pop();
+  }
+
+  // Live tool executions (present until the ToolEnd lands in the transcript).
+  for (const tool of snap.liveTools) {
+    if (out.length > 0) out.push("");
+    const marker = tool.done
+      ? tool.isError
+        ? theme.fg("error", "error")
+        : theme.fg("success", "done")
+      : theme.fg("warning", "running");
+    let line = `${theme.fg("toolTitle", tool.name)} · ${marker}`;
+    const preview = tool.outputPreview && sanitizeText(tool.outputPreview);
+    if (preview) line += theme.fg("dim", ` · ${preview}`);
+    out.push(truncateToWidth(line, width));
+  }
+
+  // Queued steering/follow-up messages: show them immediately so Enter
+  // visibly acknowledges the user's input instead of appearing to do nothing.
+  for (const message of snap.queued) {
+    if (out.length > 0) out.push("");
+    const prefix = theme.fg("warning", `> [queued ${message.kind}] `);
+    const wrapped = wrapTextWithAnsi(
+      sanitizeText(message.text),
+      Math.max(10, width - visibleWidth(prefix)),
+    );
+    for (let i = 0; i < wrapped.length; i++) {
+      out.push(
+        truncateToWidth(
+          (i === 0 ? prefix : " ".repeat(visibleWidth(prefix))) +
+            theme.fg("muted", wrapped[i]),
+          width,
+        ),
+      );
+    }
+  }
+
+  return out;
+}

package/agent.bak.20260905-190020/extensions/subagents/src/widget-order.ts

@@ -0,0 +1,121 @@
+/**
+ * widget-order.ts — fixed stacking order for the above-editor widgets.
+ *
+ * Pi core renders above-editor widgets in Map insertion order: every
+ * `setWidget` moves the key to the end (closest to the input). Since the
+ * todo, background-terminal, and subagent widgets update independently, the
+ * last updater would otherwise drift to the bottom. This helper keeps them
+ * pinned top-to-bottom as:
+ *
+ *   1. todos (rpiv-todos, furthest from the input)
+ *   2. background terminals
+ *   3. subagents (closest to the input)
+ *
+ * How: a tiny registry on `globalThis` records the latest factory for each
+ * managed key. Every set re-applies all visible managed widgets in canonical
+ * order (clear the three keys, re-add the visible ones), so insertion order
+ * — and therefore render order — is always canonical no matter which
+ * extension updated last. Hiding a key just clears it; deletion never
+ * disturbs the survivors' relative order, so no resync is needed there.
+ *
+ * NOTE: vendored copy. Identical logic lives in
+ * `todo/widget-order.ts`, `background-terminals/src/widget-order.ts`, and
+ * `subagents/src/widget-order.ts`. Extensions load in isolated jiti module
+ * instances (no shared imports), but they share one Node process, so the
+ * `globalThis` registry is the coordination channel. Keep the copies (and
+ * WIDGET_ORDER) in sync.
+ */
+
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+
+/** Canonical top-to-bottom order above the editor. */
+export const WIDGET_ORDER = ["rpiv-todos", "background-terminals", "subagents"] as const;
+
+export type ManagedWidgetKey = (typeof WIDGET_ORDER)[number];
+
+/** The ui surface the helper needs (the real ExtensionUIContext satisfies this). */
+export type WidgetUI = Pick<ExtensionUIContext, "setWidget">;
+
+type SetWidget = WidgetUI["setWidget"];
+/** Factory form of setWidget content (the string[] form is unused here). */
+export type WidgetFactory = Extract<Parameters<SetWidget>[1], (...args: never[]) => unknown>;
+export type WidgetOptions = Parameters<SetWidget>[2];
+
+interface RegistryEntry {
+	content: WidgetFactory;
+	options?: WidgetOptions;
+}
+
+declare global {
+	// Shared across the isolated module instances of the three extensions
+	// (same Node process, one TUI). See file header.
+	// eslint-disable-next-line no-var
+	var __kilnAboveEditorWidgetOrder: Map<string, RegistryEntry> | undefined;
+}
+
+function registry(): Map<string, RegistryEntry> {
+	return (globalThis.__kilnAboveEditorWidgetOrder ??= new Map());
+}
+
+/**
+ * Register (or refresh) a managed widget and restore canonical stacking.
+ * Pass `undefined` content to hide (same as hideOrderedWidget).
+ */
+export function setOrderedWidget(
+	ui: WidgetUI | undefined,
+	key: ManagedWidgetKey,
+	content: WidgetFactory | undefined,
+	options?: WidgetOptions,
+): void {
+	if (!ui) return;
+	if (content === undefined) {
+		hideOrderedWidget(ui, key);
+		return;
+	}
+	registry().set(key, { content, options });
+	resync(ui);
+}
+
+/** Unregister a managed widget. No-op when it isn't registered. */
+export function hideOrderedWidget(ui: WidgetUI | undefined, key: ManagedWidgetKey): void {
+	if (!ui) return;
+	const reg = registry();
+	if (!reg.has(key)) {
+		// Not tracked here, but pi may still hold it (e.g. registered before
+		// this helper existed) — clear directly so we never leak a widget.
+		try {
+			ui.setWidget(key, undefined);
+		} catch {
+			// UI may be unavailable (print/RPC modes or teardown).
+		}
+		return;
+	}
+	reg.delete(key);
+	try {
+		ui.setWidget(key, undefined);
+	} catch {
+		// UI may be unavailable (print/RPC modes or teardown).
+	}
+}
+
+/** Clear all managed keys, then re-add the visible ones in canonical order. */
+function resync(ui: WidgetUI): void {
+	const reg = registry();
+	for (const key of WIDGET_ORDER) {
+		try {
+			ui.setWidget(key, undefined);
+		} catch {
+			// UI went away mid-sync — registry still holds the truth for next time.
+			return;
+		}
+	}
+	for (const key of WIDGET_ORDER) {
+		const entry = reg.get(key);
+		if (!entry) continue;
+		try {
+			ui.setWidget(key, entry.content, entry.options);
+		} catch {
+			return;
+		}
+	}
+}

package/agent.bak.20260905-190020/extensions/subagents/test/by-the-way.test.ts

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  BTW_TITLE_MAX_LENGTH,
+  deriveBtwTitle,
+  isModelVisible,
+} from "../src/by-the-way.ts";
+
+test("deriveBtwTitle uses the first non-empty line and bounds the title", () => {
+  assert.equal(
+    deriveBtwTitle("\n   Why   does this work?   \nignore me"),
+    "Why does this work?",
+  );
+  assert.equal(deriveBtwTitle(" \n\t"), "by the way");
+
+  const title = deriveBtwTitle("x".repeat(BTW_TITLE_MAX_LENGTH + 10));
+  assert.equal(title.length, BTW_TITLE_MAX_LENGTH);
+  assert.equal(title, `${"x".repeat(BTW_TITLE_MAX_LENGTH - 1)}…`);
+
+  const emojiTitle = deriveBtwTitle(
+    `${"x".repeat(BTW_TITLE_MAX_LENGTH - 2)}😀 more`,
+  );
+  assert.equal(emojiTitle, `${"x".repeat(BTW_TITLE_MAX_LENGTH - 2)}😀…`);
+});
+
+test("only model-origin snapshots are visible to model-facing tools", () => {
+  assert.equal(isModelVisible({ origin: "model" }), true);
+  assert.equal(isModelVisible({ origin: "btw" }), false);
+});

package/agent.bak.20260905-190020/extensions/subagents/test/claude.test.ts

@@ -0,0 +1,119 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Effect } from "effect";
+import { SubagentManager } from "../src/manager.ts";
+import { claudeBackend } from "../src/backends/claude.ts";
+import type { ParentContext, SpawnTask } from "../src/domain.ts";
+import { createSubagentRuntime, runTool } from "../src/runtime.ts";
+
+const parent: ParentContext = {
+  parentCwd: process.cwd(),
+  projectTrusted: false,
+};
+
+function task(prompt: string): SpawnTask {
+  return {
+    prompt,
+    title: "live Claude test",
+    cwd: process.cwd(),
+    model: "haiku",
+    reasoningEffort: "off",
+    parent,
+  };
+}
+
+async function claudeAvailable() {
+  return Effect.runPromise(claudeBackend.available);
+}
+
+/** Rejecting deadline so a hung wait still reaches finally() and disposes. */
+function deadline<A>(operation: Promise<A>, timeoutMs: number) {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<never>((_resolve, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`Live Claude test exceeded ${timeoutMs}ms`)),
+      timeoutMs,
+    );
+  });
+  return Promise.race([operation, timeout]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+
+test(
+  "Claude backend completes a live manager run",
+  { timeout: 60_000 },
+  async (t) => {
+    if (!(await claudeAvailable())) {
+      t.skip("Claude Code executable is unavailable");
+      return;
+    }
+
+    const runtime = createSubagentRuntime();
+    try {
+      const manager = await runtime.runPromise(SubagentManager);
+      const started = await runTool(
+        runtime,
+        manager.spawn("claude", task("Reply with exactly: hello claude")),
+      );
+      await deadline(runTool(runtime, manager.waitFor([started.id])), 45_000);
+
+      const done = manager.view.get(started.id);
+      assert.equal(done?.status, "done");
+      assert.match(done?.finalText ?? "", /hello claude/i);
+      assert.ok(done?.meta.nativeSessionId);
+      assert.ok(done?.meta.sessionFilePath?.endsWith(".jsonl"));
+    } finally {
+      await runtime.dispose();
+    }
+  },
+);
+
+test(
+  "Claude backend interrupt settles a live run as aborted",
+  { timeout: 60_000 },
+  async (t) => {
+    if (!(await claudeAvailable())) {
+      t.skip("Claude Code executable is unavailable");
+      return;
+    }
+
+    const runtime = createSubagentRuntime();
+    try {
+      const manager = await runtime.runPromise(SubagentManager);
+      const started = await runTool(
+        runtime,
+        manager.spawn(
+          "claude",
+          task(
+            "Write a detailed 10,000-word essay about the history of computing.",
+          ),
+        ),
+      );
+
+      // Wait for streamed output so cancellation definitely lands mid-run and
+      // exercises the SDK's normal interrupt receipt/result path.
+      const streamDeadline = Date.now() + 15_000;
+      while (
+        manager.view.get(started.id)?.status === "running" &&
+        !manager.view.get(started.id)?.liveAssistant?.text &&
+        Date.now() < streamDeadline
+      ) {
+        await new Promise((resolve) => setTimeout(resolve, 20));
+      }
+      assert.equal(manager.view.get(started.id)?.status, "running");
+      assert.ok(manager.view.get(started.id)?.liveAssistant?.text);
+
+      const report = await deadline(
+        runTool(runtime, manager.cancel([started.id])),
+        20_000,
+      );
+
+      assert.equal(report[0]?.cancelled, true);
+      assert.equal(manager.view.get(started.id)?.status, "error");
+      assert.equal(manager.view.get(started.id)?.errorText, "Run was aborted");
+    } finally {
+      await runtime.dispose();
+    }
+  },
+);

package/agent.bak.20260905-190020/extensions/subagents/test/codex.test.ts

@@ -0,0 +1,102 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Effect } from "effect";
+import { codexBackend } from "../src/backends/codex.ts";
+import type { ParentContext, SpawnTask } from "../src/domain.ts";
+import { SubagentManager } from "../src/manager.ts";
+import { createSubagentRuntime, runTool } from "../src/runtime.ts";
+
+const parent: ParentContext = {
+  parentCwd: process.cwd(),
+  projectTrusted: false,
+};
+
+function task(prompt: string): SpawnTask {
+  return {
+    prompt,
+    title: "live Codex test",
+    cwd: process.cwd(),
+    parent,
+  };
+}
+
+function deadline<A>(operation: Promise<A>, timeoutMs: number) {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<never>((_resolve, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`Live Codex test exceeded ${timeoutMs}ms`)),
+      timeoutMs,
+    );
+  });
+  return Promise.race([operation, timeout]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+
+async function codexAvailable() {
+  return Effect.runPromise(codexBackend.available);
+}
+
+test(
+  "Codex backend completes a live manager run",
+  { timeout: 75_000 },
+  async (t) => {
+    if (!(await codexAvailable())) {
+      t.skip("codex executable is unavailable");
+      return;
+    }
+
+    const runtime = createSubagentRuntime();
+    try {
+      const manager = await runtime.runPromise(SubagentManager);
+      const spawned = await runTool(
+        runtime,
+        manager.spawn("codex", task("Reply with exactly: hello codex")),
+      );
+
+      await deadline(runTool(runtime, manager.waitFor([spawned.id])), 60_000);
+      const done = manager.view.get(spawned.id);
+      assert.equal(done?.status, "done");
+      assert.match(done?.finalText ?? "", /hello codex/i);
+      assert.equal(done?.meta.backend, "codex");
+      assert.ok(done?.meta.nativeSessionId);
+      assert.ok(done?.meta.sessionFilePath);
+    } finally {
+      await runtime.dispose();
+    }
+  },
+);
+
+test(
+  "Codex backend interrupt settles a live manager run",
+  { timeout: 30_000 },
+  async (t) => {
+    if (!(await codexAvailable())) {
+      t.skip("codex executable is unavailable");
+      return;
+    }
+
+    const runtime = createSubagentRuntime();
+    try {
+      const manager = await runtime.runPromise(SubagentManager);
+      const spawned = await runTool(
+        runtime,
+        manager.spawn(
+          "codex",
+          task("Run `sleep 30`, then reply with the word finished."),
+        ),
+      );
+
+      await new Promise((resolve) => setTimeout(resolve, 250));
+      const result = await deadline(
+        runTool(runtime, manager.cancel([spawned.id])),
+        10_000,
+      );
+      assert.equal(result[0]?.cancelled, true);
+      assert.equal(manager.view.get(spawned.id)?.status, "error");
+      assert.equal(manager.view.get(spawned.id)?.errorText, "Run was aborted");
+    } finally {
+      await runtime.dispose();
+    }
+  },
+);

package/agent.bak.20260905-190020/extensions/subagents/test/context-usage.test.ts

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { contextOccupancyTokens } from "../src/backends/claude.ts";
+import { parseThreadTokenUsage } from "../src/backends/codex.ts";
+
+// --- Claude: per-request occupancy, never the run aggregate ------------------
+
+test("Claude occupancy sums one request's input, cache, and output tokens", () => {
+  assert.equal(
+    contextOccupancyTokens({
+      input_tokens: 12,
+      cache_read_input_tokens: 45_000,
+      cache_creation_input_tokens: 3_000,
+      output_tokens: 700,
+    }),
+    48_712,
+  );
+});
+
+test("Claude occupancy treats null cache/output counts as zero", () => {
+  assert.equal(
+    contextOccupancyTokens({
+      input_tokens: 9_000,
+      cache_read_input_tokens: null,
+      cache_creation_input_tokens: null,
+      output_tokens: 250,
+    }),
+    9_250,
+  );
+});
+
+test("Claude occupancy is unknown without a usable per-request usage", () => {
+  assert.equal(contextOccupancyTokens(undefined), undefined);
+  assert.equal(contextOccupancyTokens(null), undefined);
+  assert.equal(
+    contextOccupancyTokens({ input_tokens: null, output_tokens: 5 }),
+    undefined,
+  );
+});
+
+test("Claude occupancy from the last request stays below the window where the run aggregate would not", () => {
+  // A 10-request tool loop over a mostly-cached 150k prompt: the aggregate
+  // usage (what SDKResultMessage.usage reports) re-counts the cache per
+  // request and blows past the 200k window; the final request's usage is the
+  // true occupancy.
+  const perRequest = {
+    input_tokens: 500,
+    cache_read_input_tokens: 150_000,
+    cache_creation_input_tokens: 0,
+    output_tokens: 400,
+  };
+  const aggregate = {
+    input_tokens: 500 * 10,
+    cache_read_input_tokens: 150_000 * 10,
+    cache_creation_input_tokens: 0,
+    output_tokens: 400 * 10,
+  };
+  const occupancy = contextOccupancyTokens(perRequest);
+  assert.ok(occupancy !== undefined && occupancy < 200_000);
+  const misleading = contextOccupancyTokens(aggregate);
+  assert.ok(misleading !== undefined && misleading > 200_000);
+});
+
+// --- Codex: last request's total, never the thread-cumulative total ----------
+
+const codexParams = (tokenUsage: unknown) => ({
+  threadId: "t",
+  turnId: "u",
+  tokenUsage,
+});
+
+test("Codex occupancy uses tokenUsage.last.totalTokens, not the cumulative total", () => {
+  const { tokens, contextWindow } = parseThreadTokenUsage(
+    codexParams({
+      total: {
+        totalTokens: 1_450_000,
+        inputTokens: 1_400_000,
+        cachedInputTokens: 1_300_000,
+        outputTokens: 50_000,
+        reasoningOutputTokens: 20_000,
+      },
+      last: {
+        totalTokens: 61_000,
+        inputTokens: 60_000,
+        cachedInputTokens: 55_000,
+        outputTokens: 1_000,
+        reasoningOutputTokens: 400,
+      },
+      modelContextWindow: 272_000,
+    }),
+  );
+  assert.equal(tokens, 61_000);
+  assert.equal(contextWindow, 272_000);
+});
+
+test("Codex occupancy is unknown when last usage or window is absent", () => {
+  assert.deepEqual(
+    parseThreadTokenUsage(
+      codexParams({ total: { totalTokens: 10 }, modelContextWindow: null }),
+    ),
+    { tokens: undefined, contextWindow: undefined },
+  );
+  assert.deepEqual(parseThreadTokenUsage({ threadId: "t" }), {
+    tokens: undefined,
+    contextWindow: undefined,
+  });
+});