@asterxsk/kiln 0.3.0 → 0.4.2

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

@@ -1,201 +0,0 @@
-/**
- * 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

@@ -1,121 +0,0 @@
-/**
- * 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

@@ -1,29 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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,
-  });
-});