ada-agent 0.1.0

package/src/client/tui-mode.ts

@@ -0,0 +1,41 @@
+// The inline TUI loop: drives the same Agent, rendering everything inline (composer follows the
+// conversation, reply opens on the ◆ icon, spinner shows a "thinking" word while the model works).
+
+import { stdout } from "node:process";
+import type { Agent } from "./agent.ts";
+import { setAsker } from "./tools.ts";
+import { Tui } from "./tui.ts";
+
+export async function runTui(agent: Agent, model: string): Promise<void> {
+  const tui = new Tui();
+  agent.setOnApprove(async (name, summary) => tui.confirm(`run ${name} ${summary}`));
+  setAsker((question, options) => tui.ask(question, options));
+  tui.start();
+  // Header as the first lines (scrolls away naturally as the conversation grows).
+  stdout.write(
+    `${"\x1b[38;5;214m"}█▀█ █▀▄ █▀█\n█▀█ █▄▀ █▀█\x1b[0m  \x1b[2m${model}\x1b[0m\n` +
+      `\x1b[2mAsk me to build, edit, or explain code in ${process.cwd()}\x1b[0m\n\n`,
+  );
+  try {
+    for (;;) {
+      tui.setStatus(`${model} · ~${agent.contextTokens()} tok`);
+      const line = await tui.readLine();
+      if (line === null) break; // Ctrl+C/Ctrl+D at empty prompt
+      if (!line) continue;
+      if (line === "/exit" || line === "/quit") break;
+      const abort = new AbortController();
+      const steer: string[] = [];
+      tui.beginTurn(abort, steer);
+      try {
+        await agent.send(line, { signal: abort.signal, steer, onReplyStart: () => tui.replyStart() });
+      } catch (e) {
+        stdout.write(`\n\x1b[31m[error] ${e instanceof Error ? e.message : e}\x1b[0m`);
+      } finally {
+        tui.endTurn();
+        stdout.write("\n\n"); // breathing room before the next composer
+      }
+    }
+  } finally {
+    tui.stop();
+  }
+}

package/src/client/tui.ts

@@ -0,0 +1,224 @@
+// Inline terminal UI for the ada REPL — no scroll region, no pinned footer. Everything flows
+// inline like a chat: the composer is drawn right after the last reply (so there's never a void),
+// the user's line is committed as a dim full-width bar, and ada's reply begins on the ◆ icon's
+// line. While the model is thinking, a spinner cycles a random "processing" word. Raw-mode input
+// is a small state machine:
+//   line    — reading a user message (Enter submits; ↑/↓ history)
+//   turn    — agent running (Esc/Ctrl+C interrupts; type+Enter queues a steer)
+//   confirm — an approval prompt awaiting y / a / n
+
+import { stdin, stdout } from "node:process";
+
+const GOLD = "\x1b[38;5;214m"; // ada accent (xterm 214)
+const DIM = "\x1b[2m";
+const RST = "\x1b[0m";
+const SPIN = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+// Playful gerunds shown while the model works (à la Claude's "Cogitating…").
+const WORDS = [
+  "Cogitating", "Pondering", "Noodling", "Percolating", "Ruminating", "Conjuring",
+  "Finagling", "Tinkering", "Scheming", "Untangling", "Marinating", "Synthesizing",
+  "Spelunking", "Vibing", "Hatching", "Brewing", "Mulling", "Crunching", "Simmering", "Whittling",
+];
+
+type Mode = "idle" | "line" | "turn" | "confirm";
+
+/** Claude-style full-width user bar, e.g. " › hi" on a dim background. */
+export function userBar(text: string, cols: number): string {
+  const visible = 3 + text.length; // " › " + text
+  const pad = visible >= cols ? "" : " ".repeat(cols - visible);
+  return `\x1b[48;5;238m ${GOLD}›${RST}\x1b[97m ${text}${pad}${RST}`;
+}
+
+export class Tui {
+  private buf = "";
+  private status = "";
+  private history: string[] = [];
+  private hist = -1;
+  private mode: Mode = "idle";
+  private spin = 0;
+  private word = WORDS[0]!;
+  private thinkTimer: ReturnType<typeof setInterval> | null = null;
+  private thinking = false;
+
+  private lineResolve: ((s: string | null) => void) | null = null;
+  private confirmResolve: ((s: "yes" | "all" | "no") => void) | null = null;
+  private abort: AbortController | null = null;
+  private steer: string[] | null = null;
+  private onData = (b: Buffer): void => this.key(b.toString("utf8"));
+
+  start(): void {
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("data", this.onData);
+    stdout.write("\x1b[?25l"); // hide the real cursor; the composer draws a fake block
+  }
+
+  stop(): void {
+    this.stopThinking();
+    stdin.off("data", this.onData);
+    if (stdin.isTTY) stdin.setRawMode(false);
+    stdin.pause(); // unref stdin so the process can exit
+    stdout.write("\x1b[?25h\n"); // show cursor, fresh line
+  }
+
+  setStatus(s: string): void {
+    this.status = s;
+  }
+
+  /** Read one user line in an inline composer. Resolves null on Ctrl+C/Ctrl+D at an empty prompt. */
+  readLine(): Promise<string | null> {
+    this.mode = "line";
+    this.buf = "";
+    this.hist = -1;
+    this.renderComposer();
+    return new Promise((res) => (this.lineResolve = res));
+  }
+
+  /** Ask the user a question mid-turn (for the ask_user tool); returns their answer. */
+  async ask(question: string, options?: string[]): Promise<string> {
+    this.stopThinking();
+    stdout.write(`\x1b[36m? ${question}\x1b[0m\n`);
+    if (options?.length) stdout.write(`${options.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}\n`);
+    const ans = ((await this.readLine()) ?? "").trim();
+    this.mode = "turn";
+    if (options?.length) {
+      const n = Number(ans);
+      if (Number.isInteger(n) && n >= 1 && n <= options.length) return options[n - 1]!;
+    }
+    return ans;
+  }
+
+  beginTurn(abort: AbortController, steer: string[]): void {
+    this.mode = "turn";
+    this.abort = abort;
+    this.steer = steer;
+    this.buf = "";
+    this.startThinking();
+  }
+
+  endTurn(): void {
+    this.stopThinking();
+    this.mode = "idle";
+  }
+
+  /** First visible output of the turn: drop the spinner and open the reply on the ◆ line. */
+  replyStart(): void {
+    this.stopThinking();
+    stdout.write(`${GOLD}◆${RST} `);
+  }
+
+  /** Approval prompt drawn inline; resolves on y / a / n. */
+  confirm(label: string): Promise<"yes" | "all" | "no"> {
+    this.stopThinking();
+    this.mode = "confirm";
+    stdout.write(`${GOLD}?${RST} ${label}  ${DIM}[y]es / [a]ll / [N]o${RST} `);
+    return new Promise((res) => (this.confirmResolve = res));
+  }
+
+  // ---- internals ----
+  private renderComposer(): void {
+    const cols = stdout.columns || 80;
+    const max = Math.max(8, cols - 3);
+    const shown = this.buf.length > max ? `…${this.buf.slice(this.buf.length - max + 1)}` : this.buf;
+    stdout.write(`\r\x1b[2K${GOLD}›${RST} ${shown}\x1b[7m \x1b[0m`); // trailing reverse-video = block cursor
+  }
+
+  private commitUser(text: string): void {
+    stdout.write(`\r\x1b[2K${userBar(text, stdout.columns || 80)}\n`); // composer line becomes the bar
+  }
+
+  private startThinking(): void {
+    this.thinking = true;
+    this.word = WORDS[Math.floor(Math.random() * WORDS.length)]!;
+    this.renderThinking();
+    this.thinkTimer = setInterval(() => {
+      this.spin = (this.spin + 1) % SPIN.length;
+      if (this.spin === 0) this.word = WORDS[Math.floor(Math.random() * WORDS.length)]!;
+      this.renderThinking();
+    }, 90);
+  }
+
+  private renderThinking(): void {
+    const tail = this.status ? `  ${DIM}${this.status} · esc to interrupt${RST}` : `  ${DIM}esc to interrupt${RST}`;
+    stdout.write(`\r\x1b[2K${GOLD}${SPIN[this.spin]}${RST} ${DIM}${this.word}…${RST}${tail}`);
+  }
+
+  private stopThinking(): void {
+    if (this.thinkTimer) {
+      clearInterval(this.thinkTimer);
+      this.thinkTimer = null;
+    }
+    if (this.thinking) {
+      stdout.write("\r\x1b[2K"); // erase the spinner line, leave cursor at column 0
+      this.thinking = false;
+    }
+  }
+
+  private key(s: string): void {
+    if (this.mode === "confirm") {
+      const k = s.toLowerCase();
+      if (k === "y") this.resolveConfirm("yes");
+      else if (k === "a") this.resolveConfirm("all");
+      else if (k === "n" || k === "\r" || k === "\n" || k === "\x1b") this.resolveConfirm("no");
+      return;
+    }
+
+    if (s === "\x03") {
+      // Ctrl+C
+      if (this.mode === "turn") this.abort?.abort();
+      else if (this.lineResolve) {
+        stdout.write("\n");
+        this.lineResolve(this.buf ? "" : null); // empty prompt → exit
+      }
+      return;
+    }
+    if (s === "\x1b") {
+      if (this.mode === "turn") this.abort?.abort();
+      return;
+    }
+    if (s === "\x1b[A" || s === "\x1b[B") {
+      if (this.mode === "line" && this.history.length) {
+        if (s === "\x1b[A") this.hist = this.hist < 0 ? this.history.length - 1 : Math.max(0, this.hist - 1);
+        else this.hist = this.hist < 0 ? -1 : this.hist + 1;
+        this.buf = this.hist >= 0 && this.hist < this.history.length ? this.history[this.hist]! : "";
+        this.renderComposer();
+      }
+      return;
+    }
+    if (s.startsWith("\x1b")) return; // ignore other escape sequences
+
+    for (const ch of s) {
+      if (ch === "\r" || ch === "\n") {
+        const text = this.buf.trim();
+        this.buf = "";
+        if (this.mode === "line") {
+          if (text) {
+            this.history.push(text);
+            this.commitUser(text); // echo exactly once, as the bar
+          } else {
+            stdout.write("\r\x1b[2K");
+          }
+          this.hist = -1;
+          this.lineResolve?.(text);
+        } else if (this.mode === "turn" && text) {
+          this.steer?.push(text);
+          stdout.write(`${DIM}  ↳ queued: ${text}${RST}\n`); // steer is captured blind, echoed on submit
+        }
+      } else if (ch === "\x7f" || ch === "\b") {
+        this.buf = this.buf.slice(0, -1);
+        if (this.mode === "line") this.renderComposer();
+      } else if (ch >= " ") {
+        this.buf += ch;
+        if (this.mode === "line") this.renderComposer();
+      }
+    }
+  }
+
+  private resolveConfirm(d: "yes" | "all" | "no"): void {
+    this.mode = "turn";
+    const r = this.confirmResolve;
+    this.confirmResolve = null;
+    stdout.write("\n"); // finalize the prompt line
+    r?.(d);
+  }
+}

package/src/sdk/index.ts

@@ -0,0 +1,36 @@
+// Typed client SDK for the ada HTTP API (started with `ada serve`). Drive ada programmatically:
+//
+//   import { createClient } from "ada/sdk";
+//   const ada = createClient("http://localhost:8788");
+//   const { text } = await ada.prompt("list the files in this project");
+
+export interface PromptResult {
+  text: string;
+  usage?: string;
+}
+
+export interface AdaClient {
+  /** Send a prompt; runs a fresh agent turn server-side and returns its final text. */
+  prompt(text: string, opts?: { model?: string }): Promise<PromptResult>;
+  /** Server health + the default model. */
+  health(): Promise<{ ok: boolean; model?: string }>;
+}
+
+export function createClient(baseUrl = "http://localhost:8788"): AdaClient {
+  const url = baseUrl.replace(/\/+$/, "");
+  return {
+    async prompt(text, opts) {
+      const res = await fetch(`${url}/v1/prompt`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ text, model: opts?.model }),
+      });
+      if (!res.ok) throw new Error(`ada ${res.status}: ${await res.text().catch(() => res.statusText)}`);
+      return (await res.json()) as PromptResult;
+    },
+    async health() {
+      const res = await fetch(`${url}/health`);
+      return (await res.json()) as { ok: boolean; model?: string };
+    },
+  };
+}

package/src/selfcheck.ts

@@ -0,0 +1,364 @@
+// Offline self-check: tools, session persistence, and routing. No network, no API key.
+// Run with: npm run selfcheck
+
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { estimateTokens, isContextOverflowError, planCut } from "./client/compaction.ts";
+import { loadImage } from "./client/image.ts";
+import { expandPrompt } from "./client/prompts.ts";
+import { MarkdownStreamer, highlight, renderEditDiff } from "./client/render.ts";
+import { Session, list } from "./client/session.ts";
+import { loadSkills, registerSkillTool, routeConfident } from "./client/skills.ts";
+import { describeCall, parseTextToolCalls, permPhrase, readIntegrationDocs, soleIntegration, writeProjectSkills } from "./client/agent.ts";
+import { userBar } from "./client/tui.ts";
+import { configuredServers, listConnectors, loadMcpServers } from "./client/mcp.ts";
+import { confidentSkill, rankSkills } from "./client/skill-router.ts";
+import { getDiagnostics } from "./client/lsp.ts";
+import { snapshot } from "./client/snapshot.ts";
+import { renderJobs, startJob } from "./client/background.ts";
+import { formatFile, htmlToText, isDestructive, registerTool, setAsker, toolByName } from "./client/tools.ts";
+import * as checkpoint from "./client/checkpoint.ts";
+import { renderTodos, setTodos } from "./client/todos.ts";
+import { deleteCredential, getCredential, setCredential } from "./server/credentials.ts";
+import { isAllowed } from "./server/identity.ts";
+import { route } from "./server/router.ts";
+
+function tool(name: string) {
+  const t = toolByName.get(name);
+  if (!t) throw new Error(`missing tool: ${name}`);
+  return t;
+}
+
+async function main(): Promise<void> {
+  // --- tools: write -> edit -> read round-trip ---
+  const dir = join(tmpdir(), `ada-selfcheck-${Date.now()}`);
+  const file = join(dir, "a.txt");
+
+  let r = await tool("write_file").run({ path: file, content: "hello world" });
+  assert.ok(!r.isError, r.output);
+  r = await tool("edit_file").run({ path: file, old_text: "world", new_text: "ada" });
+  assert.ok(!r.isError, r.output);
+  r = await tool("read_file").run({ path: file });
+  assert.equal(r.output, "hello ada");
+
+  // ambiguous edit must error
+  await tool("write_file").run({ path: file, content: "x x" });
+  r = await tool("edit_file").run({ path: file, old_text: "x", new_text: "y" });
+  assert.ok(r.isError, "ambiguous edit should error");
+
+  // missing read must error
+  r = await tool("read_file").run({ path: join(dir, "nope.txt") });
+  assert.ok(r.isError, "missing read should error");
+
+  // bash
+  r = await tool("bash").run({ command: "echo hi" });
+  assert.ok(r.output.includes("hi"), r.output);
+
+  // grep / ls / glob
+  await tool("write_file").run({ path: join(dir, "hello.txt"), content: "alpha\nNEEDLE here\nbeta" });
+  const g = await tool("grep").run({ path: dir, pattern: "NEEDLE" });
+  assert.ok(g.output.includes("NEEDLE"), g.output);
+  const l = await tool("ls").run({ path: dir });
+  assert.ok(l.output.includes("hello.txt"), l.output);
+  const gl = await tool("glob").run({ pattern: "src/selfcheck.ts" });
+  assert.ok(gl.output.includes("selfcheck.ts"), gl.output);
+
+  // read offset/limit
+  await tool("write_file").run({ path: join(dir, "lines.txt"), content: "L1\nL2\nL3\nL4" });
+  const ol = await tool("read_file").run({ path: join(dir, "lines.txt"), offset: 2, limit: 2 });
+  assert.equal(ol.output, "L2\nL3");
+
+  // multi-edit
+  await tool("write_file").run({ path: join(dir, "m.txt"), content: "aaa bbb ccc" });
+  r = await tool("edit_file").run({
+    path: join(dir, "m.txt"),
+    edits: [
+      { old_text: "aaa", new_text: "AAA" },
+      { old_text: "ccc", new_text: "CCC" },
+    ],
+  });
+  assert.ok(!r.isError, r.output);
+  r = await tool("read_file").run({ path: join(dir, "m.txt") });
+  assert.equal(r.output, "AAA bbb CCC");
+
+  // CRLF preservation: file uses \r\n, edit's old_text uses \n
+  const crlf = join(dir, "crlf.txt");
+  await tool("write_file").run({ path: crlf, content: "one\r\ntwo\r\nthree" });
+  r = await tool("edit_file").run({ path: crlf, old_text: "two", new_text: "TWO" });
+  assert.ok(!r.isError, r.output);
+  r = await tool("read_file").run({ path: crlf });
+  assert.ok(r.output.includes("\r\n") && r.output.includes("TWO"), JSON.stringify(r.output));
+
+  rmSync(dir, { recursive: true, force: true });
+
+  // --- session append -> load round-trip ---
+  const s = Session.create();
+  s.append({ role: "user", content: "hello" });
+  s.append({ role: "assistant", content: "hi there" });
+  const loaded = s.load();
+  assert.equal(loaded.length, 2);
+  assert.equal(loaded[0]!.content, "hello");
+  rmSync(s.file, { force: true });
+
+  // --- branching: fork seeds messages, records parent, load skips __meta ---
+  const parent = Session.create();
+  parent.append({ role: "user", content: "p1" });
+  const branch = Session.fork(parent.file, [
+    { role: "user", content: "p1" },
+    { role: "assistant", content: "a1" },
+  ]);
+  const bl = branch.load();
+  assert.equal(bl.length, 2, "fork load skips the __meta line");
+  assert.equal(bl[0]!.content, "p1");
+  const bm = list().find((m) => m.file === branch.file);
+  assert.ok(bm?.parent === parent.file, "branch records its parent");
+  rmSync(parent.file, { force: true });
+  rmSync(branch.file, { force: true });
+
+  // --- router prefix mapping ---
+  assert.equal(route("gpt-4o"), "openai");
+  assert.equal(route("o3-mini"), "openai");
+  assert.equal(route("claude-opus-4-8"), "anthropic");
+  assert.equal(route("gemini-2.5-pro"), "google");
+  assert.equal(route("mistral-large-latest"), "mistral");
+  assert.equal(route("grok-2"), "xai");
+  assert.equal(route("deepseek-chat"), "deepseek");
+  assert.equal(route("qwen-max"), "dashscope");
+  assert.equal(route("qwq-32b"), "dashscope");
+  assert.equal(route("qwen/qwen-2.5-72b-instruct"), "openrouter"); // namespaced id stays on OpenRouter
+  assert.equal(route("gemma4:latest"), "ollama"); // local Ollama "model:tag"
+  assert.equal(route("mistralai/mistral-7b:free"), "openrouter"); // slash wins over colon
+  assert.equal(route("meta-llama/llama-3.1-70b"), "openrouter");
+  assert.equal(route("anything", "mistral"), "mistral");
+
+  // --- compaction ---
+  assert.ok(estimateTokens([{ role: "user", content: "hello" }] as never) > 0);
+  assert.ok(isContextOverflowError(new Error("maximum context length exceeded")));
+  assert.ok(!isContextOverflowError(new Error("invalid api key")));
+  const convo = [
+    { role: "system", content: "sys" },
+    { role: "user", content: "u1" },
+    { role: "assistant", content: null, tool_calls: [{ id: "c1", type: "function", function: { name: "bash", arguments: "{}" } }] },
+    { role: "tool", tool_call_id: "c1", content: "out" },
+    { role: "assistant", content: "a1" },
+    { role: "user", content: "u2" },
+    { role: "assistant", content: "a2" },
+    { role: "user", content: "u3" },
+    { role: "assistant", content: "a3" },
+  ];
+  const plan = planCut(convo as never, 2);
+  assert.ok(plan, "should plan a cut");
+  assert.equal(plan!.system!.role, "system");
+  assert.equal(plan!.tail[0]!.role, "user"); // tail starts on a user boundary — tool pairs never split
+
+  // --- rendering ---
+  const diff = renderEditDiff("f.ts", "old line", "new line");
+  assert.ok(diff.includes("old line") && diff.includes("new line"), diff);
+  const ms = new MarkdownStreamer();
+  const rendered = ms.push("# Title\n- item\n") + ms.end();
+  assert.ok(rendered.includes("Title") && rendered.includes("item"), rendered);
+  const hl = highlight('const x = "hi" // c');
+  assert.ok(hl.includes("\x1b[") && hl.includes("const"), hl); // keywords/strings/comments colored
+
+  // --- prompt templates ---
+  const pm = new Map([["fix", "Fix $1 carefully. All: $ARGUMENTS"]]);
+  assert.equal(expandPrompt(pm, "/fix foo.ts it crashes"), "Fix foo.ts carefully. All: foo.ts it crashes");
+  assert.equal(expandPrompt(pm, "/unknown x"), null);
+  assert.equal(expandPrompt(pm, "hello"), null);
+
+  // --- extensibility: dynamic tool registration + skills ---
+  registerTool({
+    name: "__demo",
+    description: "demo",
+    parameters: { type: "object", properties: {} },
+    needsApproval: false,
+    async run() {
+      return { output: "ok" };
+    },
+  });
+  assert.ok(toolByName.get("__demo"), "registerTool adds a dynamic tool");
+  registerSkillTool([{ name: "demo", description: "d", path: "nope" }]);
+  assert.ok(toolByName.get("use_skill"), "registerSkillTool exposes use_skill");
+
+  // --- credential store round-trip ---
+  await setCredential("__selfcheck", { type: "api_key", key: "sk-test" });
+  assert.equal(getCredential("__selfcheck")?.key, "sk-test");
+  await deleteCredential("__selfcheck");
+  assert.equal(getCredential("__selfcheck"), undefined);
+
+  // --- multimodal: image file → data url ---
+  const imgPath = join(tmpdir(), `ada-img-${Date.now()}.png`);
+  writeFileSync(imgPath, Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+  const img = loadImage(imgPath);
+  assert.ok(img && img.dataUrl.startsWith("data:image/png;base64,"), "loadImage → png data url");
+  rmSync(imgPath, { force: true });
+
+  // --- checkpoint undo round-trip ---
+  const cpFile = join(tmpdir(), `ada-cp-${Date.now()}.txt`);
+  writeFileSync(cpFile, "v1");
+  checkpoint.record(cpFile);
+  writeFileSync(cpFile, "v2");
+  checkpoint.undoAll();
+  assert.equal(readFileSync(cpFile, "utf8"), "v1", "undo restores the original content");
+  rmSync(cpFile, { force: true });
+
+  // --- todos + destructive detection ---
+  setTodos([{ text: "alpha", status: "done" }, { text: "beta", status: "todo" }]);
+  assert.ok(renderTodos().includes("alpha") && renderTodos().includes("beta"), "todos render");
+  assert.ok(isDestructive("rm -rf /tmp/x"), "rm -rf is destructive");
+  assert.ok(!isDestructive("ls -la"), "ls is not destructive");
+
+  // --- web_fetch HTML→text + tools registered ---
+  const ht = htmlToText("<h1>Hi</h1><p>a &amp; b</p><script>x()</script><ul><li>one</li></ul>");
+  assert.ok(/Hi/.test(ht) && /a & b/.test(ht) && /- one/.test(ht) && !/x\(\)/.test(ht), "htmlToText strips tags/scripts, decodes entities");
+  assert.ok(toolByName.has("web_fetch") && toolByName.has("web_search"), "web tools registered");
+  assert.equal(formatFile(join(tmpdir(), "x.go")), false, "formatFile is a safe no-op when untrusted/no formatter (never throws)");
+  assert.ok(toolByName.has("lsp_diagnostics"), "lsp_diagnostics tool registered");
+  assert.deepEqual(await getDiagnostics(join(tmpdir(), "x.ts")), [], "getDiagnostics no-ops when untrusted/no server (never throws)");
+  const bashRun = await toolByName.get("bash")!.run({ command: "echo pty-probe-123" });
+  assert.ok(/pty-probe-123/.test(bashRun.output) && /exit 0/.test(bashRun.output), `bash runs a command (PTY): ${bashRun.output.slice(0, 60)}`);
+
+  // --- apply_patch: create → update → delete across files ---
+  const ap = toolByName.get("apply_patch")!;
+  const apDir = join(tmpdir(), `ada-ap-${process.pid}`);
+  mkdirSync(apDir, { recursive: true });
+  const apFile = join(apDir, "a.txt");
+  assert.ok(!(await ap.run({ files: [{ path: apFile, action: "create", content: "hello\n" }] })).isError && existsSync(apFile), "apply_patch create");
+  await ap.run({ files: [{ path: apFile, action: "update", edits: [{ old_text: "hello", new_text: "world" }] }] });
+  assert.ok(/world/.test(readFileSync(apFile, "utf8")), "apply_patch update");
+  await ap.run({ files: [{ path: apFile, action: "delete" }] });
+  assert.ok(!existsSync(apFile), "apply_patch delete");
+  rmSync(apDir, { recursive: true, force: true });
+
+  // --- ask_user via a stub asker ---
+  const askTool = toolByName.get("ask_user")!;
+  setAsker(async (_q, opts) => (opts ? opts[0]! : "the-answer"));
+  assert.ok(/the-answer/.test((await askTool.run({ question: "?" })).output), "ask_user returns the answer");
+  assert.ok(/picked-A/.test((await askTool.run({ question: "?", options: ["picked-A", "B"] })).output), "ask_user with options");
+  setAsker(null);
+  assert.equal((await askTool.run({ question: "?" })).isError, true, "ask_user errors when no asker is installed");
+
+  // --- grep still works (rg fast path falls back to the JS scan when rg is absent) ---
+  assert.ok(/tools\.ts/.test((await toolByName.get("grep")!.run({ pattern: "export const tools", path: "src/client" })).output), "grep finds matches");
+
+  // --- workspace snapshot returns a git tree SHA (or null outside a repo); never throws ---
+  const snap = snapshot();
+  assert.ok(snap === null || /^[0-9a-f]{40}$/.test(snap), "snapshot returns a tree SHA");
+
+  // --- approval context: readable call descriptions + plain-words permission phrases ---
+  assert.equal(describeCall("bash", { command: 'dir "C:\\x" /b' }).detail, 'dir "C:\\x" /b', "bash → shows the command, not JSON");
+  assert.equal(describeCall("read_file", { path: "a.ts" }).label, "read", "read_file → 'read'");
+  assert.equal(describeCall("merchant__list_products", {}).label, "merchant", "MCP tool → connector name as label");
+  assert.ok(permPhrase("bash", true).startsWith("⚠"), "destructive bash phrase is flagged");
+  assert.equal(permPhrase("write_file", false), "create or modify files on disk", "write phrase");
+  assert.ok(permPhrase("merchant__x", false).includes("connector"), "MCP phrase mentions the connector");
+
+  // --- background job runs and reports ---
+  const jid = startJob("selfcheck job", async () => "job-done-ok");
+  await new Promise((r) => setTimeout(r, 30));
+  assert.ok(renderJobs().includes(jid) && /job-done-ok/.test(renderJobs()), "background job runs and reports its result");
+  assert.equal((await toolByName.get("web_fetch")!.run({ url: "http://127.0.0.1/x" })).isError, true, "web_fetch blocks loopback (SSRF guard)");
+
+  // --- destructive classifier: real dangers flagged; everyday redirects are not (2>/dev/null bug) ---
+  // The /dev/ sink allow-list is boundary-anchored, so device writes whose name starts with a sink
+  // token (ttyS0, tty1) are still caught — they were a confirmed bypass before the fix.
+  for (const c of ["rm -rf /", "dd if=/dev/zero of=/dev/sda", "git push --force origin main", "git reset --hard", "> /dev/sda", "> /dev/ttyS0", "echo x > /dev/tty1"]) {
+    assert.ok(isDestructive(c), `should be destructive: ${c}`);
+  }
+  for (const c of ['ls "/some/dir" 2>/dev/null', "cat x >/dev/null", "echo hi > /dev/stdout", "grep foo bar 2> /dev/null", "node app.js &>/dev/null", "x >/dev/null 2>&1", "cat >/dev/tty"]) {
+    assert.ok(!isDestructive(c), `should NOT be destructive: ${c}`);
+  }
+
+  // --- leaked tool-call recovery (Ollama-over-stream emits the call as text) ---
+  const leaked = parseTextToolCalls('{"name": "update_todos", "arguments": {"todos": []}}');
+  assert.equal(leaked?.[0]?.name, "update_todos", "plain JSON tool call recovered");
+  const tagged = parseTextToolCalls('<tool_call>{"name":"ls","arguments":{"path":"."}}</tool_call>');
+  assert.equal(tagged?.[0]?.name, "ls", "<tool_call> wrapped call recovered");
+  assert.equal(parseTextToolCalls('{"name":"spend_time","arguments":{}}'), null, "unknown tool not treated as a call");
+  assert.equal(parseTextToolCalls("just some prose"), null, "prose is not a tool call");
+
+  // --- TUI user bar fills the full width (no void, single styled echo) ---
+  const bar = userBar("hi", 40);
+  assert.ok(bar.includes("hi") && bar.includes("›"), "user bar shows the text + marker");
+  assert.ok(bar.includes("\x1b[48;5;238m"), "user bar has a full-width background");
+  assert.ok(userBar("x".repeat(200), 40).length > 40, "over-long input does not crash padding");
+
+  // --- bundled skills load + scalable discovery (list_skills / slim use_skill) ---
+  const allSkills = loadSkills(true);
+  const skillNames = allSkills.map((s) => s.name);
+  assert.ok(skillNames.length >= 200, `>=200 skills load (got ${skillNames.length})`);
+  for (const want of ["commit", "ponytail", "dockerize", "migration", "react-hooks", "terraform-module", "pixel-diff", "canvas-debug", "connect-github", "design-system"]) {
+    assert.ok(skillNames.includes(want), `bundled skill present: ${want}`);
+  }
+  registerSkillTool(allSkills);
+  const useSkill = toolByName.get("use_skill")!;
+  assert.ok(useSkill.description.length < 400, `use_skill description is slim (got ${useSkill.description.length})`);
+  const listSkills = toolByName.get("list_skills")!;
+  const filtered = (await listSkills.run({ filter: "docker" })).output;
+  assert.ok(/dockerize/.test(filtered) && !/migration/.test(filtered), "list_skills filter narrows results");
+  assert.ok(/categories/.test((await listSkills.run({})).output), "list_skills overview lists categories");
+
+  // --- skill routing (lexical relevance ranker behind find_skill + auto-suggest) ---
+  assert.ok(rankSkills("write a database migration", allSkills, 5).some((r) => r.name === "migration"), "routing surfaces migration");
+  assert.ok(rankSkills("set up a dark mode theme", allSkills, 5).some((r) => r.name === "dark-mode"), "routing surfaces dark-mode");
+  const dockerTop = rankSkills("build a docker image for the app", allSkills, 5).map((r) => r.name);
+  assert.ok(dockerTop.includes("dockerize") || dockerTop.includes("docker-compose"), `routing surfaces a docker skill (got ${dockerTop.join(",")})`);
+  assert.equal(rankSkills("", allSkills).length, 0, "empty query → no matches");
+
+  // --- confident skill orchestration: auto-apply only on a dominant, name-exact match ---
+  assert.equal(confidentSkill("describe the project", allSkills), "project-overview", "confident: describe the project → project-overview");
+  assert.equal(confidentSkill("draw an architecture diagram of this project", allSkills), "architecture-diagram", "confident: → architecture-diagram");
+  assert.equal(confidentSkill("make a powerpoint about Q3 results", allSkills), null, "precision guard: 'powerpoint' must NOT auto-apply 'low-power'");
+  assert.equal(confidentSkill("what is 2 + 2", allSkills), null, "ambiguous query → no auto-apply");
+  // LOADED was set by registerSkillTool(allSkills) above, so routeConfident/skillBody resolve a body.
+  const applied = routeConfident("describe the project");
+  assert.ok(applied?.name === "project-overview" && /purpose/i.test(applied.body), "routeConfident returns the skill body to inject");
+  assert.equal(routeConfident("make a powerpoint about Q3 results"), null, "routeConfident respects the precision guard");
+
+  // --- connector catalog (read-only; does not touch .ada/mcp.json) ---
+  const catalog = listConnectors();
+  assert.ok(catalog.length >= 8 && catalog.some((c) => c.name === "github"), "connector catalog populated");
+  assert.ok(catalog.find((c) => c.name === "github")?.needsEnv.includes("GITHUB_PERSONAL_ACCESS_TOKEN"), "github connector declares its env var");
+
+  // --- toolsmith path end-to-end via a real stub MCP server (skips if a real .ada/mcp.json exists) ---
+  const adaDir = join(process.cwd(), ".ada");
+  const mcpCfg = join(adaDir, "mcp.json");
+  if (!existsSync(mcpCfg) && existsSync(join(process.cwd(), "test", "stub-mcp.mjs"))) {
+    mkdirSync(adaDir, { recursive: true });
+    writeFileSync(mcpCfg, JSON.stringify({ servers: { stub: { command: "node", args: ["test/stub-mcp.mjs"] } } }));
+    try {
+      const loaded = await loadMcpServers(true);
+      assert.ok(loaded.some((l) => l.startsWith("stub")), "stub MCP server connected + tools registered");
+      assert.deepEqual(configuredServers(), ["stub"], "configuredServers sees the stub");
+      assert.equal(soleIntegration(), "stub", "soleIntegration → stub");
+      const docs = readIntegrationDocs("stub");
+      assert.ok(/stub__echo/.test(docs) && /stub__add/.test(docs), "readDocs lists the stub's tools");
+      const n = writeProjectSkills([
+        { name: "stub-echo", content: "---\nname: stub-echo\ndescription: echo via the stub\ncategory: integration-stub\n---\n# Echo\n1. call stub__echo\n## Rules\n- keep it short" },
+        { name: "stub-junk", content: "not a skill file" },
+      ]);
+      assert.equal(n, 1, "writeProjectSkills writes valid skills and skips junk");
+      assert.ok(existsSync(join(adaDir, "skills", "stub-echo", "SKILL.md")), "stub-echo SKILL.md written");
+    } finally {
+      rmSync(mcpCfg, { force: true });
+      rmSync(join(adaDir, "skills", "stub-echo"), { recursive: true, force: true });
+    }
+  }
+
+  // --- login allowlist ---
+  assert.ok(isAllowed("anyone"), "no allowlist → allow any authenticated user");
+  process.env.ADA_ALLOWED_USERS = "alice, bob";
+  assert.ok(isAllowed("alice"));
+  assert.ok(!isAllowed("carol"), "off-allowlist user rejected");
+  delete process.env.ADA_ALLOWED_USERS;
+
+  console.log("selfcheck OK");
+  process.exit(0); // a spawned stub MCP subprocess can hold stdin open — exit cleanly
+}
+
+main().catch((e) => {
+  console.error("selfcheck FAILED:", e instanceof Error ? e.message : e);
+  process.exit(1);
+});