@asterxsk/kiln 0.1.0

package/agent/extensions/skillsconf/src/ui/text-input.ts

@@ -0,0 +1,91 @@
+import type { Component, Focusable } from "./tui-helpers.js";
+import { truncate, visibleWidth } from "./tui-helpers.js";
+
+// Single-line text input (search query / new package name).
+export class TextInput implements Component, Focusable {
+  value = "";
+  focused = false;
+  private cursor = 0;
+
+  getValue(): string { return this.value; }
+  setValue(v: string): void { this.value = v; this.cursor = v.length; }
+
+  handleInput(data: string): void {
+    if (!data) return;
+    if (data.includes("\x1b[200~")) {
+      const start = data.indexOf("\x1b[200~");
+      const end = data.indexOf("\x1b[201~");
+      if (end !== -1) {
+        const paste = data.substring(start + 6, end);
+        this.value = this.value.slice(0, this.cursor) + paste + this.value.slice(this.cursor);
+        this.cursor += paste.length;
+        const remaining = data.slice(end + 6);
+        if (remaining) this.handleInput(remaining);
+        return;
+      }
+      data = data.replace("\x1b[200~", "");
+    }
+    if (data.includes("\x1b[201~")) data = data.replace("\x1b[201~", "");
+
+    if (data === "\x7f" || data === "\x08" || data === "\b") {
+      if (this.cursor > 0) {
+        this.value = this.value.slice(0, this.cursor - 1) + this.value.slice(this.cursor);
+        this.cursor--;
+      }
+      return;
+    }
+    if (data === "\x1b[3~") {
+      if (this.cursor < this.value.length) {
+        this.value = this.value.slice(0, this.cursor) + this.value.slice(this.cursor + 1);
+      }
+      return;
+    }
+    if (data === "\x1b[D" || data === "\x1bOD") { if (this.cursor > 0) this.cursor--; return; }
+    if (data === "\x1b[C" || data === "\x1bOC") { if (this.cursor < this.value.length) this.cursor++; return; }
+    if (data === "\x1b[H" || data === "\x1bOH" || data === "\x1b[1~") { this.cursor = 0; return; }
+    if (data === "\x1b[F" || data === "\x1bOF" || data === "\x1b[4~") { this.cursor = this.value.length; return; }
+    if (data === "\x15") { this.value = ""; this.cursor = 0; return; }
+    if (data === "\x17") {
+      if (this.cursor === 0) return;
+      let pos = this.cursor;
+      while (pos > 0 && this.value[pos - 1] === " ") pos--;
+      while (pos > 0 && this.value[pos - 1] !== " ") pos--;
+      this.value = this.value.slice(0, pos) + this.value.slice(this.cursor);
+      this.cursor = pos;
+      return;
+    }
+    if (data.startsWith("\x1b") && data.length > 1) return;
+    if (data.length === 1 && data.charCodeAt(0) < 0x20) return;
+    let insert = "";
+    for (const ch of data) {
+      const code = ch.charCodeAt(0);
+      if (code >= 0x20 && code !== 0x7f) insert += ch;
+    }
+    if (insert) {
+      this.value = this.value.slice(0, this.cursor) + insert + this.value.slice(this.cursor);
+      this.cursor += insert.length;
+    }
+  }
+
+  render(width: number): string[] {
+    const cursorMark = "\x1b_pi:c\x07";
+    let display: string;
+    if (this.focused) {
+      const before = this.value.slice(0, this.cursor);
+      const after = this.value.slice(this.cursor);
+      display = before + cursorMark + (after.length > 0 ? after : " ");
+      if (visibleWidth(display) > width) {
+        const half = Math.floor(width / 2);
+        const start = Math.max(0, this.cursor - half);
+        const slice = this.value.slice(start, start + width);
+        const curInSlice = this.cursor - start;
+        display = slice.slice(0, curInSlice) + cursorMark + slice.slice(curInSlice);
+      }
+    } else {
+      display = this.value;
+    }
+    return [truncate(display, width)];
+  }
+
+  invalidate(): void {}
+}

package/agent/extensions/skillsconf/src/ui/tui-helpers.ts

@@ -0,0 +1,144 @@
+// Minimal Component type mirroring the pi-tui contract used by ctx.ui.custom.
+export interface Component {
+  render(width: number): string[];
+  handleInput?(data: string): void;
+  invalidate(): void;
+}
+
+export interface Focusable {
+  focused: boolean;
+}
+
+export function stripAnsi(s: string): string {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").replace(/\x1b\]8;;.*?\x1b\\/g, "").replace(/\x1b_pi:c\x07/g, "");
+}
+
+export function visibleWidth(s: string): number {
+  const stripped = stripAnsi(s);
+  let w = 0;
+  for (const ch of stripped) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (cp >= 0x1100 && (
+      cp <= 0x115F || cp === 0x2329 || cp === 0x232A ||
+      (cp >= 0x2E80 && cp <= 0xA4CF && cp !== 0x303F) ||
+      (cp >= 0xAC00 && cp <= 0xD7A3) ||
+      (cp >= 0xF900 && cp <= 0xFAFF) ||
+      (cp >= 0xFE10 && cp <= 0xFE19) ||
+      (cp >= 0xFE30 && cp <= 0xFE6F) ||
+      (cp >= 0xFF00 && cp <= 0xFF60) ||
+      (cp >= 0xFFE0 && cp <= 0xFFE6)
+    )) {
+      w += 2;
+    } else {
+      w += 1;
+    }
+  }
+  return w;
+}
+
+function extractAnsiCode(str: string, pos: number): { code: string; length: number } | null {
+  if (str[pos] !== "\x1b") return null;
+  const next = str[pos + 1];
+  if (next === "[") {
+    let i = pos + 2;
+    while (i < str.length) {
+      const c = str[i];
+      if ((c >= "0" && c <= "9") || c === ";" || c === ":" || c === "?") { i++; continue; }
+      i++;
+      return { code: str.slice(pos, i), length: i - pos };
+    }
+    return null;
+  }
+  if (next === "]") {
+    const end = str.indexOf("\x1b\\", pos);
+    if (end !== -1) return { code: str.slice(pos, end + 2), length: end + 2 - pos };
+    const bel = str.indexOf("\x07", pos);
+    if (bel !== -1) return { code: str.slice(pos, bel + 1), length: bel + 1 - pos };
+    return null;
+  }
+  if (str.startsWith("\x1b_pi:c\x07", pos)) return { code: "\x1b_pi:c\x07", length: 7 };
+  return null;
+}
+
+export function truncate(text: string, maxWidth: number, ellipsis = "..."): string {
+  if (maxWidth <= 0) return "";
+  const vw = visibleWidth(text);
+  if (vw <= maxWidth) return text;
+  const ellW = visibleWidth(ellipsis);
+  const target = maxWidth - ellW;
+  if (target <= 0) {
+    let out = "";
+    let w = 0;
+    let i = 0;
+    while (i < text.length) {
+      const ansi = extractAnsiCode(text, i);
+      if (ansi) { out += ansi.code; i += ansi.length; continue; }
+      let grapheme = text[i];
+      if (grapheme.charCodeAt(0) >= 0xD800 && grapheme.charCodeAt(0) <= 0xDBFF && i + 1 < text.length) {
+        grapheme = text.slice(i, i + 2);
+      }
+      const gw = visibleWidth(grapheme);
+      if (w + gw > maxWidth) break;
+      out += grapheme;
+      w += gw;
+      i += grapheme.length;
+    }
+    return out;
+  }
+  let out = "";
+  let w = 0;
+  let i = 0;
+  while (i < text.length) {
+    const ansi = extractAnsiCode(text, i);
+    if (ansi) { out += ansi.code; i += ansi.length; continue; }
+    let grapheme = text[i];
+    if (grapheme.charCodeAt(0) >= 0xD800 && grapheme.charCodeAt(0) <= 0xDBFF && i + 1 < text.length) {
+      grapheme = text.slice(i, i + 2);
+    }
+    const gw = visibleWidth(grapheme);
+    if (w + gw > target) break;
+    out += grapheme;
+    w += gw;
+    i += grapheme.length;
+  }
+  out += ellipsis;
+  return out;
+}
+
+/** Theme-safe styling helpers (fall back to plain text when theme is missing). */
+export function fg(theme: unknown, color: string, text: string): string {
+  try {
+    const t = theme as { fg?: (c: string, s: string) => string };
+    if (t && typeof t.fg === "function") return t.fg(color, text);
+  } catch {}
+  return text;
+}
+
+export function bold(theme: unknown, text: string): string {
+  try {
+    const t = theme as { bold?: (s: string) => string };
+    if (t && typeof t.bold === "function") return t.bold(text);
+  } catch {}
+  return text;
+}
+
+export function highlight(theme: unknown, text: string): string {
+  try {
+    const t = theme as { bg?: (c: string, s: string) => string };
+    if (t && typeof t.bg === "function") {
+      try {
+        const v = t.bg("selectedBg", text);
+        if (v !== text) return v;
+      } catch {}
+      try {
+        const v2 = t.bg("selection", text);
+        if (v2 !== text) return v2;
+      } catch {}
+    }
+  } catch {}
+  try {
+    const t = theme as { fg?: (c: string, s: string) => string };
+    if (t && typeof t.fg === "function") return t.fg("accent", text);
+  } catch {}
+  return `› ${text}`;
+}

package/agent/extensions/skillsconf/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "types": ["node"]
+  },
+  "include": ["index.ts", "src/**/*.ts"],
+  "exclude": ["dist", "node_modules"]
+}

package/agent/extensions/status line/index.ts

@@ -0,0 +1,282 @@
+/**
+ * Status Line — custom footer for pi
+ *
+ * Left:  provider/model using {thinking} effort • {percent}%/{window}
+ * Right: $cost • path
+ *
+ * Colors:
+ *  - model / thinking / cost → white (theme "text")
+ *  - path → blue (theme "accent")
+ *  - context → white under 262k tokens, red over 262k
+ *  - separators (•, spaces) → dim
+ *
+ * Example (Muse Spark 1.2 contributor on high, 1% of 1M, $0.002, ~/.pi):
+ *   left:  opencode-go/muse-spark-1.2-contributer using high effort • 1%/1M
+ *   right: $0.002 • ~/.pi
+ *
+ * Visibility: shown in chat and in overlay views (e.g. the subagent interactive
+ * takeover, which is a fullscreen overlay). Hidden during editor takeovers such
+ * as /settings, /model, modelconf, or skillsconf — detected by tracking TUI
+ * focus: every takeover moves focus away from the chat editor (and returns it
+ * on close), while overlays keep hasOverlay() true.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { TUI } from "@earendil-works/pi-tui";
+import { appendFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+// DEBUG: bump to confirm the loaded build; dumps raw render bytes to status-line-debug.log
+const DEBUG_VERSION = 5;
+const DEBUG_LOG = fileURLToPath(new URL("./status-line-debug.log", import.meta.url));
+function debugLog(msg: string) {
+	try {
+		appendFileSync(DEBUG_LOG, `${new Date().toISOString()} v${DEBUG_VERSION} ${msg}\n`);
+	} catch {}
+}
+
+// ---- helpers ----
+
+function formatCwd(cwd: string): string {
+	const home = process.env.HOME ?? process.env.USERPROFILE;
+	if (!home) return cwd;
+	// Normalize windows backslashes for comparison
+	const normCwd = cwd.replace(/\\/g, "/");
+	const normHome = home.replace(/\\/g, "/");
+	if (normCwd === normHome) return "~";
+	if (normCwd.startsWith(normHome + "/")) {
+		return `~${normCwd.slice(normHome.length)}`;
+	}
+	return cwd;
+}
+
+function formatWindow(n: number): string {
+	if (n >= 1_000_000) {
+		const m = n / 1_000_000;
+		// Keep one decimal if not round, e.g. 1.1M; otherwise 1M
+		if (Number.isInteger(m)) return `${m}M`;
+		return `${m.toFixed(1)}M`;
+	}
+	if (n >= 1000) {
+		const k = n / 1000;
+		if (Number.isInteger(k)) return `${k}k`;
+		return `${k.toFixed(1)}k`;
+	}
+	return String(n);
+}
+
+function formatContext(ctx: ExtensionContext): { text: string; over: boolean } {
+	const usage = ctx.getContextUsage();
+	const window = usage?.contextWindow ?? ctx.model?.contextWindow;
+
+	if (!usage || usage.tokens === null || usage.percent === null || !window) {
+		// Unknown tokens — show placeholder but never red
+		return { text: window ? `?%/${formatWindow(window)}` : "?%/??", over: false };
+	}
+
+	const percent = Math.round(usage.percent);
+	const over = usage.tokens > 262_000;
+	return { text: `${percent}%/${formatWindow(window)}`, over };
+}
+
+function formatThinking(level: string | undefined): string {
+	if (!level || level === "off") return "off";
+	return `using ${level} effort`;
+}
+
+function computeCost(ctx: ExtensionContext): number {
+	let total = 0;
+	try {
+		for (const e of ctx.sessionManager.getBranch()) {
+			if (e.type === "message" && (e as unknown as { message?: { role?: string; usage?: { cost?: { total?: number } } } }).message?.role === "assistant") {
+				const usage = (e as unknown as { message: { usage?: { cost?: { total?: number } } } }).message.usage;
+				if (usage?.cost?.total) total += usage.cost.total;
+			}
+		}
+	} catch {
+		// ignore
+	}
+	return total;
+}
+
+// ---- takeover visibility ----
+//
+// Hide the footer when a full-screen takeover view is open (/settings, /model,
+// modelconf, skillsconf, login, …) but keep it visible in chat and in overlay
+// views (e.g. the subagent interactive takeover, which is a fullscreen overlay).
+//
+// Two signals, both fail-open (the footer stays visible unless we are sure a
+// takeover is open):
+// 1. Extension UI (ctx.ui.custom/select/input/confirm/editor) always emits
+//    ui_prompt_start/end around the prompt. An active prompt without an overlay
+//    means the editor was replaced by a takeover view.
+// 2. Core takeovers (/settings, /model, login, reload notice) emit no events,
+//    but they move TUI focus to a well-known component class, so match those
+//    names. Inline widgets like autocomplete never move focus, so the footer
+//    stays visible while completing.
+
+// Matches core takeover views (all setFocus targets without ui_prompt
+// events): SettingsSelectorComponent, ModelSelectorComponent,
+// LoginDialogComponent, and the reload-notice Container.
+
+const CORE_TAKEOVER_FOCUS = /(SelectorComponent|DialogComponent)$/;
+
+function coreTakeoverName(tui: TUI): string | null {
+	let focused: object | null = null;
+	try {
+		focused = (tui as unknown as { getFocusedComponent?: () => object | null }).getFocusedComponent?.() ?? null;
+	} catch {
+		return null;
+	}
+	if (!focused) return null;
+	const name = (focused as { constructor?: { name?: string } }).constructor?.name ?? "?";
+	if (name === "Container" || CORE_TAKEOVER_FOCUS.test(name)) return name;
+	return null;
+}
+
+function hasVisibleOverlay(tui: TUI): boolean {
+	try {
+		return typeof tui.hasOverlay === "function" && tui.hasOverlay();
+	} catch {
+		return false;
+	}
+}
+
+// ---- extension ----
+
+export default function (pi: ExtensionAPI) {
+	debugLog("extension factory loaded");
+	let activeTui: TUI | undefined;
+	let lastHideReason: string | null | undefined;
+	// Active extension UI prompts (ctx.ui.custom/select/input/confirm/editor).
+	// Any prompt without a visible overlay is an editor takeover.
+	let uiPromptDepth = 0;
+
+	pi.on("ui_prompt_start", () => {
+		uiPromptDepth++;
+		activeTui?.requestRender();
+	});
+	pi.on("ui_prompt_end", () => {
+		uiPromptDepth = Math.max(0, uiPromptDepth - 1);
+		activeTui?.requestRender();
+	});
+	// Re-render footer when model/thinking/tools change outside the normal render loop
+	pi.on("model_select", () => activeTui?.requestRender());
+	pi.on("thinking_level_select", () => activeTui?.requestRender());
+	pi.on("tool_result", () => activeTui?.requestRender());
+	pi.on("message_update", () => activeTui?.requestRender());
+	// Session switches / compaction can change context window
+	pi.on("session_start", async (_event, ctx) => {
+		if (ctx.mode !== "tui") return;
+
+		ctx.ui.setFooter((tui, theme, footerData) => {
+			activeTui = tui;
+			const unsubBranch = footerData.onBranchChange(() => tui.requestRender());
+
+			// Keep cost/context fresh during streaming token updates
+			// message_update fires per-token; requestRender is cheap & coalesced
+			const unsubSession = (ctx as unknown as { sessionManager: { on?: (ev: string, fn: () => void) => () => void } }).sessionManager.on?.("update" as never, () => tui.requestRender());
+
+			return {
+				dispose() {
+					try {
+						unsubBranch();
+					} catch {}
+					if (typeof unsubSession === "function") {
+						try {
+							(unsubSession as () => void)();
+						} catch {}
+					}
+					if (activeTui === tui) activeTui = undefined;
+				},
+				invalidate() {},
+				render(width: number): string[] {
+					if (width <= 0) return [""];
+					// Overlay views (subagent takeover, pickers) keep the footer.
+					let hideReason: string | null = null;
+					if (!hasVisibleOverlay(tui)) {
+						hideReason = uiPromptDepth > 0 ? "ui-prompt" : coreTakeoverName(tui);
+					}
+					if (hideReason !== lastHideReason) {
+						lastHideReason = hideReason;
+						debugLog(hideReason ? `hidden (${hideReason})` : "shown");
+					}
+					if (hideReason) return [""];
+					const modelId = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "no-model";
+					const thinkingLevel = (pi.getThinkingLevel() as string | undefined) ?? (ctx.thinkingLevel as string | undefined) ?? "off";
+					const thinkingText = formatThinking(thinkingLevel);
+					const { text: ctxText, over } = formatContext(ctx);
+					const cost = computeCost(ctx);
+					const costStr = `$${cost.toFixed(3)}`;
+					const cwdStr = formatCwd(ctx.cwd);
+
+					// --- plain strings for width math (no ANSI, so hyphens can't lose color in truncate/wrap) ---
+					const leftPlain = `${modelId} ${thinkingText} • ${ctxText}`;
+					const rightPlain = `${costStr} • ${cwdStr}`;
+					const leftW = leftPlain.length; // all ascii, visibleWidth == length
+					const rightW = rightPlain.length;
+					if (width === 1) return [theme.fg("dim", "─")];
+
+					// Colors — force true white (#FFFFFF) so "-" never falls back to dim grey
+					const W_OPEN = "\x1b[38;2;255;255;255m";
+					const W_CLOSE = "\x1b[39m";
+					const white = (s: string) => `${W_OPEN}${s}${W_CLOSE}`;
+					const blue = (s: string) => theme.fg("accent", s);
+					const dim = (s: string) => theme.fg("dim", s);
+					const red = (s: string) => theme.fg("error", s);
+					const sepPlain = " • ";
+					const sep = dim(sepPlain);
+
+					// Build ANSI line only after width decisions
+					let left: string;
+					let right: string;
+					const gapPlain = Math.max(1, width - leftW - rightW);
+					if (leftW + 1 + rightW <= width) {
+						left = white(modelId) + dim(" ") + white(thinkingText) + sep + (over ? red(ctxText) : white(ctxText));
+						right = white(costStr) + sep + blue(cwdStr);
+						const gap = " ".repeat(gapPlain);
+						return [left + gap + right];
+					}
+					// Not enough width: truncate leftPlain first (keep right intact), then color the truncated pieces
+					const maxLeft = Math.max(0, width - rightW - 1);
+					let leftTruncPlain = leftPlain;
+					if (leftPlain.length > maxLeft) {
+						leftTruncPlain = maxLeft <= 3 ? leftPlain.slice(0, maxLeft) : leftPlain.slice(0, maxLeft - 3) + "...";
+					}
+					// Re-derive left parts from truncated plain (approx: truncate from the end)
+					// Simpler: color the whole truncated left as white, but keep "•" dim and ctx red/white tail
+					// Find where " • " sits in leftPlain
+					const sepIdx = leftPlain.lastIndexOf(sepPlain);
+					if (sepIdx !== -1 && leftTruncPlain.length > sepIdx) {
+						const head = leftTruncPlain.slice(0, sepIdx);
+						const tail = leftTruncPlain.slice(sepIdx + sepPlain.length);
+						left = white(head) + sep + (over ? red(tail) : white(tail));
+					} else {
+						left = white(leftTruncPlain);
+					}
+					right = white(costStr) + sep + blue(cwdStr);
+					let line = left + " " + right;
+					// Final safety: truncateToWidth handles ANSI correctly for the final line
+					if (visibleWidth(line) > width) line = truncateToWidth(line, width);
+					debugLog(`width=${width} line=${JSON.stringify(line)}`);
+					return [line];
+				},
+			};
+		});
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		// Never leave a stale prompt count behind (would hide the footer forever).
+		uiPromptDepth = 0;
+		// Restore default footer when session tears down (avoid stale closure)
+		try {
+			if (ctx.mode === "tui") ctx.ui.setFooter(undefined);
+		} catch {}
+		activeTui = undefined;
+	});
+
+	// Streaming: request render for live cost/context updates
+	pi.on("agent_start", () => activeTui?.requestRender());
+	pi.on("agent_settled", () => activeTui?.requestRender());
+}

package/agent/extensions/status line/install.ps1

@@ -0,0 +1,23 @@
+#!/usr/bin/env pwsh
+# Per-extension installer — Windows / PowerShell
+# Installs npm dependencies for this extension. No-op if no package.json.
+$ErrorActionPreference = "Stop"
+$extDir = $PSScriptRoot
+if (-not $extDir) { $extDir = Split-Path -Parent $MyInvocation.MyCommand.Path }
+if (-not (Test-Path "$extDir/package.json")) {
+  Write-Host "  - no package.json — skipping" -ForegroundColor DarkGray
+  exit 0
+}
+if (-not (Get-Command npm -ErrorAction SilentlyContinue)) {
+  Write-Host "  x npm not found — install Node.js 22+" -ForegroundColor Red
+  exit 1
+}
+if (Test-Path "$extDir/package-lock.json") {
+  Write-Host "  - npm ci" -ForegroundColor DarkGray
+  npm --prefix $extDir ci --no-audit --no-fund
+} else {
+  Write-Host "  - npm install" -ForegroundColor DarkGray
+  npm --prefix $extDir install --no-audit --no-fund
+}
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+Write-Host "  + done" -ForegroundColor Green

package/agent/extensions/status line/install.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+# Per-extension installer — macOS / Linux
+# Installs npm dependencies for this extension. No-op if no package.json.
+set -eu
+EXT_DIR="$(cd "$(dirname "$0")" && pwd)"
+if [ ! -f "$EXT_DIR/package.json" ]; then
+  echo "  · no package.json — skipping"
+  exit 0
+fi
+if ! command -v npm >/dev/null 2>&1; then
+  echo "  ✖ npm not found — install Node.js 22+" >&2
+  exit 1
+fi
+if [ -f "$EXT_DIR/package-lock.json" ]; then
+  echo "  · npm ci"
+  npm --prefix "$EXT_DIR" ci --no-audit --no-fund
+else
+  echo "  · npm install"
+  npm --prefix "$EXT_DIR" install --no-audit --no-fund
+fi
+echo "  ✓ done"

package/agent/extensions/subagents/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);
+});