@standardagents/code 0.0.2-dev.b3cdaaf → 0.1.1

package/dist/index.js

@@ -0,0 +1,4811 @@
+#!/usr/bin/env node
+import os6 from 'os';
+import fs4 from 'fs';
+import path3 from 'path';
+import readline2 from 'readline/promises';
+import { spawn, execFile } from 'child_process';
+import { stdout, stdin } from 'process';
+import fsp from 'fs/promises';
+import crypto from 'crypto';
+import readline from 'readline';
+
+// src/api.ts
+var ApiClient = class {
+  constructor(endpoint, token) {
+    this.endpoint = endpoint;
+    this.token = token;
+  }
+  endpoint;
+  token;
+  get wsEndpoint() {
+    return this.endpoint.replace(/^http/, "ws");
+  }
+  /** The instance origin (used to build admin-UI links). */
+  get origin() {
+    return this.endpoint;
+  }
+  get bearer() {
+    return this.token;
+  }
+  async json(pathname, init) {
+    const res = await fetch(`${this.endpoint}${pathname}`, {
+      ...init,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.token}`,
+        ...init?.headers || {}
+      }
+    });
+    const text = await res.text();
+    if (!res.ok) {
+      throw new Error(`${init?.method || "GET"} ${pathname} -> ${res.status}: ${text.slice(0, 300)}`);
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  async verify() {
+    try {
+      await this.json("/api/auth/me");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Agent name → display title map (best effort; for labeling subagents). */
+  async listAgents() {
+    const res = await this.json("/api/agents");
+    const arr = Array.isArray(res) ? res : res.agents || [];
+    return arr.filter((a) => a && typeof a.name === "string").map((a) => ({ name: a.name, title: typeof a.title === "string" ? a.title : a.name }));
+  }
+  async createThread(agentId, tags) {
+    const res = await this.json("/api/threads", {
+      method: "POST",
+      body: JSON.stringify({ agent_id: agentId, tags })
+    });
+    const id = res.threadId || res.id;
+    if (!id) throw new Error("Thread create returned no id");
+    return id;
+  }
+  /** List threads for an agent, optionally filtering to those carrying all given tags. */
+  async listThreads(agentId, requireTags) {
+    const res = await this.json(
+      `/api/threads?agent_id=${encodeURIComponent(agentId)}&limit=100`
+    );
+    const arr = Array.isArray(res) ? res : res.threads || [];
+    return arr.map((t) => ({
+      id: t.id,
+      tags: Array.isArray(t.tags) ? t.tags : [],
+      created_at: t.created_at,
+      title: t.title,
+      preview: t.preview || t.last_message
+    })).filter((t) => requireTags.every((tag) => t.tags.includes(tag)));
+  }
+  /**
+   * Subagent child threads of a thread, each with its current lifecycle status
+   * (`running`/`idle`/`terminated`). Sourced from the parent's child registry,
+   * which the live `/api/events` stream doesn't carry — so the CLI reads this to
+   * learn which subagents are *actually running* (vs idle or finished), both on
+   * (re)connect and whenever a subagent thread changes.
+   */
+  async listSubagents(threadId) {
+    const res = await this.json(
+      `/api/threads/${threadId}/subagents`
+    );
+    const arr = Array.isArray(res) ? res : res.subagents || [];
+    return arr.filter((s) => s && (s.id ?? s.reference)).map((s) => ({
+      id: s.id ?? s.reference,
+      agent_name: s.agent_name ?? s.name ?? null,
+      title: s.title ?? null,
+      threadName: s.threadName ?? s.thread_name ?? null,
+      status: typeof s.status === "string" ? s.status : "running"
+    }));
+  }
+  /**
+   * Send a user message, optionally with attachments (e.g. pasted images).
+   * Attachments use the instance's message-POST shape — base64 `data` +
+   * `mimeType` — which the server stores in the thread filesystem and injects
+   * into the LLM's vision context as real image content blocks.
+   */
+  async sendMessage(threadId, content, attachments) {
+    const body = { role: "user", content };
+    if (attachments && attachments.length > 0) body.attachments = attachments;
+    await this.json(`/api/threads/${threadId}/messages`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async getMessages(threadId, limit = 50) {
+    const res = await this.json(
+      `/api/threads/${threadId}/messages?limit=${limit}`
+    );
+    return Array.isArray(res) ? res : res.messages || [];
+  }
+  async getLogs(threadId, limit = 100) {
+    const res = await this.json(
+      `/api/threads/${threadId}/logs?limit=${limit}&order=desc`
+    );
+    return Array.isArray(res) ? res : res.logs || [];
+  }
+  /**
+   * Deliver a durable forwarded tool result to the thread, resuming the turn.
+   * Retries with backoff — this is the durable delivery path, so it must land
+   * even if the connection is briefly flaky after a permission wait.
+   */
+  async postToolResult(threadId, toolCallId, ok, result, error) {
+    const body = JSON.stringify({ tool_call_id: toolCallId, ok, result, error });
+    for (let attempt = 0; attempt < 6; attempt++) {
+      try {
+        await this.json(`/api/threads/${threadId}/tool-result`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body
+        });
+        return true;
+      } catch {
+        await new Promise((r) => setTimeout(r, Math.min(500 * 2 ** attempt, 8e3)));
+      }
+    }
+    return false;
+  }
+  /**
+   * Download raw file bytes from the thread's filesystem (e.g. an
+   * /attachments/* asset a subagent generated). Returns null on any failure.
+   */
+  async fetchFile(threadId, fsPath) {
+    const clean2 = fsPath.startsWith("/") ? fsPath : `/${fsPath}`;
+    try {
+      const res = await fetch(`${this.endpoint}/api/threads/${threadId}/fs${clean2}`, {
+        headers: { Authorization: `Bearer ${this.token}` }
+      });
+      if (!res.ok) return null;
+      return Buffer.from(await res.arrayBuffer());
+    } catch {
+      return null;
+    }
+  }
+  /** Read a value from the thread's durable KV store (null if absent). */
+  async kvGet(threadId, key) {
+    try {
+      const res = await this.json(
+        `/api/threads/${threadId}/kv?key=${encodeURIComponent(key)}`
+      );
+      return res?.value ?? null;
+    } catch {
+      return null;
+    }
+  }
+  /** Write a value to the thread's durable KV store. */
+  async kvSet(threadId, key, value) {
+    try {
+      await this.json(`/api/threads/${threadId}/kv`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ key, value })
+      });
+    } catch {
+    }
+  }
+  // ── skills (instance-global Agent Skills library) ─────────────────────────
+  /** Installed skills — metadata only. Includes disabled skills. */
+  async listSkills() {
+    const res = await this.json(`/api/skills?all=1`);
+    return Array.isArray(res?.skills) ? res.skills : [];
+  }
+  /** Enable/disable an installed skill. */
+  async setSkillEnabled(name, enabled) {
+    await this.json(`/api/skills/${encodeURIComponent(name)}`, {
+      method: "PATCH",
+      body: JSON.stringify({ enabled })
+    });
+  }
+  /** Uninstall a skill. */
+  async removeSkill(name) {
+    await this.json(`/api/skills/${encodeURIComponent(name)}`, { method: "DELETE" });
+  }
+  /**
+   * Kick off background conversation compaction now. Spawns the compaction
+   * subagent directly server-side (so it fires even while the thread is idle).
+   */
+  async compact(threadId) {
+    await this.json(`/api/threads/${threadId}/compact`, { method: "POST" });
+  }
+  async stop(threadId) {
+    try {
+      await this.json(`/api/threads/${threadId}/stop`, { method: "POST" });
+    } catch {
+    }
+  }
+  /** The thread's current goal (set via set_goal / update_goal_step). */
+  async getGoal(threadId) {
+    try {
+      const r = await this.json(`/api/threads/${threadId}/goal`);
+      return {
+        summary: r?.summary ?? null,
+        description: r?.description ?? null,
+        steps: Array.isArray(r?.steps) ? r.steps : []
+      };
+    } catch {
+      return { summary: null, description: null, steps: [] };
+    }
+  }
+};
+
+// src/permissions.ts
+function decide(state, tool, risk, hasPermissionRequest) {
+  const effectiveRisk = typeof risk === "number" ? Math.min(5, Math.max(1, risk)) : hasPermissionRequest ? 3 : 1;
+  if (state.alwaysAllow.has(tool)) return "allow";
+  if (state.allowRisk.has(effectiveRisk)) return "allow";
+  return effectiveRisk <= state.level ? "allow" : "ask";
+}
+var CATASTROPHIC_PATTERNS = [
+  /\brm\s+(-[a-z]*\s+)*-[a-z]*f[a-z]*\s+(-[a-z]*\s+)*(\/|~|\$HOME|\/\*|\.\s*$|\/\s*$)/i,
+  // rm -rf / , rm -rf ~
+  /\brm\s+-rf\s+--no-preserve-root/i,
+  /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/,
+  // fork bomb
+  /\bmkfs(\.\w+)?\b/i,
+  // format filesystem
+  /\bdd\b[^\n]*\bof=\/dev\/(sd|disk|nvme|hd)/i,
+  // overwrite raw disk
+  /\b(shutdown|reboot|halt|poweroff)\b/i,
+  />\s*\/dev\/(sd|disk|nvme|hd)/i,
+  /\bchmod\s+-R\s+(000|777)\s+\/(?:\s|$)/i
+];
+function isCatastrophic(command) {
+  return CATASTROPHIC_PATTERNS.some((re) => re.test(command));
+}
+
+// src/approvals.ts
+var KEY = "approvals";
+async function loadApprovals(api, threadId) {
+  const v = await api.kvGet(threadId, KEY);
+  if (v && typeof v === "object" && !Array.isArray(v)) {
+    const o = v;
+    const n = Number(o.level);
+    const level = n >= 1 && n <= 5 ? n : void 0;
+    return {
+      level,
+      allowTools: Array.isArray(o.allowTools) ? o.allowTools : [],
+      allowRisk: Array.isArray(o.allowRisk) ? o.allowRisk : []
+    };
+  }
+  return { allowTools: [], allowRisk: [] };
+}
+function saveApprovals(api, threadId, perm) {
+  const payload = {
+    level: perm.level,
+    allowTools: Array.from(perm.alwaysAllow).sort(),
+    allowRisk: Array.from(perm.allowRisk).sort((a, b) => a - b)
+  };
+  void api.kvSet(threadId, KEY, payload);
+}
+
+// src/heartbeat.ts
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var CONNECTION_SILENCE_TIMEOUT_MS = 15e3;
+var Heartbeat = class {
+  constructor(ws, onDead, options = {}) {
+    this.ws = ws;
+    this.onDead = onDead;
+    this.intervalMs = options.intervalMs ?? HEARTBEAT_INTERVAL_MS;
+    this.silenceMs = options.silenceMs ?? CONNECTION_SILENCE_TIMEOUT_MS;
+  }
+  ws;
+  onDead;
+  timer = null;
+  lastRecvAt = 0;
+  intervalMs;
+  silenceMs;
+  start() {
+    this.stop();
+    this.lastRecvAt = Date.now();
+    this.timer = setInterval(() => this.tick(), this.intervalMs);
+  }
+  /** Record that a frame was received — proof the connection is alive. */
+  markAlive() {
+    this.lastRecvAt = Date.now();
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  tick() {
+    if (Date.now() - this.lastRecvAt > this.silenceMs) {
+      this.fail();
+      return;
+    }
+    try {
+      if (this.ws.readyState === WebSocket.OPEN) this.ws.send("ping");
+      else this.fail();
+    } catch {
+      this.fail();
+    }
+  }
+  fail() {
+    this.stop();
+    try {
+      this.ws.close();
+    } catch {
+    }
+    this.onDead();
+  }
+};
+
+// src/render.ts
+var RESET = "\x1B[0m";
+var DIM = "\x1B[2m";
+var ADD_BG = "\x1B[48;5;22m\x1B[38;5;254m";
+var DEL_BG = "\x1B[48;5;52m\x1B[38;5;254m";
+var MAX_SIDE_LINES = 4;
+function clamp(s, max) {
+  return s.length > max ? s.slice(0, Math.max(0, max - 1)) + "\u2026" : s;
+}
+function cols() {
+  return Math.max(20, process.stdout.columns || 80);
+}
+function flat(line) {
+  return line.replace(/\t/g, "  ");
+}
+function diffLines(oldStr, newStr) {
+  let oldLines = oldStr.split("\n");
+  let newLines = newStr.split("\n");
+  while (oldLines.length && newLines.length && oldLines[0] === newLines[0]) {
+    oldLines.shift();
+    newLines.shift();
+  }
+  while (oldLines.length && newLines.length && oldLines[oldLines.length - 1] === newLines[newLines.length - 1]) {
+    oldLines.pop();
+    newLines.pop();
+  }
+  const width = cols() - 2;
+  const out = [];
+  const side = (lines, bg, sign) => {
+    const shown = lines.slice(0, MAX_SIDE_LINES);
+    for (const l of shown) out.push(`${bg}${sign} ${clamp(flat(l), width)}${RESET}`);
+    const hidden = lines.length - shown.length;
+    if (hidden > 0) out.push(`${DIM}  \u2026 +${hidden} more line${hidden === 1 ? "" : "s"}${RESET}`);
+  };
+  side(oldLines, DEL_BG, "-");
+  side(newLines, ADD_BG, "+");
+  return out;
+}
+function newFileLines(content) {
+  const lines = content.split("\n");
+  const width = cols() - 2;
+  const shown = lines.slice(0, MAX_SIDE_LINES);
+  const out = shown.map((l) => `${ADD_BG}+ ${clamp(flat(l), width)}${RESET}`);
+  const hidden = lines.length - shown.length;
+  if (hidden > 0) out.push(`${DIM}  \u2026 +${hidden} more line${hidden === 1 ? "" : "s"}${RESET}`);
+  return out;
+}
+function highlightBash(cmd) {
+  const CYAN2 = "\x1B[36m";
+  const GREEN = "\x1B[32m";
+  const MAGENTA = "\x1B[35m";
+  let out = "";
+  let i = 0;
+  let expectProgram = true;
+  while (i < cmd.length) {
+    const ch = cmd[i];
+    if (ch === "'" || ch === '"') {
+      let j = i + 1;
+      while (j < cmd.length && cmd[j] !== ch) {
+        if (ch === '"' && cmd[j] === "\\") j++;
+        j++;
+      }
+      out += `${GREEN}${cmd.slice(i, Math.min(j + 1, cmd.length))}${RESET}`;
+      i = j + 1;
+      continue;
+    }
+    if (ch === "#") {
+      out += `${DIM}${cmd.slice(i)}${RESET}`;
+      break;
+    }
+    const op = cmd.slice(i).match(/^(\|\||&&|\||;|>>|>|<)/);
+    if (op) {
+      out += `${MAGENTA}${op[1]}${RESET}`;
+      i += op[1].length;
+      expectProgram = true;
+      continue;
+    }
+    const word = cmd.slice(i).match(/^[^\s'"#|;&<>]+/);
+    if (word) {
+      const w = word[0];
+      if (w.startsWith("-")) out += `${DIM}${w}${RESET}`;
+      else if (expectProgram) {
+        out += `${CYAN2}${w}${RESET}`;
+        expectProgram = false;
+      } else out += w;
+      i += w.length;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+
+// src/bridge.ts
+var PATH_ARG_TOOLS = /* @__PURE__ */ new Set(["read_file", "grep", "glob", "write_file", "edit_file"]);
+var Bridge = class {
+  constructor(api, threadId, host, perm, hooks) {
+    this.api = api;
+    this.threadId = threadId;
+    this.host = host;
+    this.perm = perm;
+    this.hooks = hooks;
+  }
+  api;
+  threadId;
+  host;
+  perm;
+  hooks;
+  ws = null;
+  closed = false;
+  heartbeat = null;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  resolveConnected = null;
+  // Durable forwarded calls we've started handling, so a server re-send (after a
+  // reconnect) doesn't prompt or run them twice.
+  handledDurable = /* @__PURE__ */ new Set();
+  /**
+   * Connect and keep the bridge connected. Resolves on the first successful
+   * open; thereafter any drop is reconnected automatically with exponential
+   * backoff (disconnections are expected — e.g. a dev-server reload — so this
+   * must be rock solid). A short safety timeout resolves startup even if the
+   * very first attempt is slow, since reconnection continues in the background.
+   */
+  connect() {
+    return new Promise((resolve) => {
+      let settled = false;
+      this.resolveConnected = () => {
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      };
+      setTimeout(() => this.resolveConnected?.(), 8e3);
+      this.openSocket();
+    });
+  }
+  openSocket() {
+    if (this.closed) return;
+    const url = `${this.api.wsEndpoint}/api/threads/${this.threadId}/bridge?token=${encodeURIComponent(this.api.bearer)}`;
+    let ws;
+    try {
+      ws = new WebSocket(url);
+    } catch {
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws = ws;
+    ws.addEventListener("open", () => {
+      const wasReconnecting = this.reconnectAttempt > 0;
+      this.reconnectAttempt = 0;
+      this.startHeartbeat(ws);
+      this.hooks.onConnection?.(wasReconnecting ? "reconnected" : "connected", 0);
+      this.resolveConnected?.();
+    });
+    ws.addEventListener("message", (ev) => {
+      if (this.ws === ws) this.heartbeat?.markAlive();
+      this.onMessage(String(ev.data));
+    });
+    ws.addEventListener("error", () => this.handleDrop(ws));
+    ws.addEventListener("close", () => this.handleDrop(ws));
+  }
+  handleDrop(ws) {
+    if (this.ws !== ws) return;
+    this.ws = null;
+    this.stopHeartbeat();
+    this.scheduleReconnect();
+  }
+  scheduleReconnect() {
+    if (this.closed || this.reconnectTimer) return;
+    this.reconnectAttempt++;
+    this.hooks.onConnection?.("reconnecting", this.reconnectAttempt);
+    const base = Math.min(500 * 2 ** (this.reconnectAttempt - 1), 15e3);
+    const delay = base + Math.floor(Math.random() * 400);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.openSocket();
+    }, delay);
+  }
+  startHeartbeat(ws) {
+    this.stopHeartbeat();
+    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws));
+    this.heartbeat.start();
+  }
+  stopHeartbeat() {
+    if (this.heartbeat) {
+      this.heartbeat.stop();
+      this.heartbeat = null;
+    }
+  }
+  close() {
+    this.closed = true;
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.ws?.close();
+  }
+  send(payload) {
+    try {
+      this.ws?.send(JSON.stringify(payload));
+    } catch {
+    }
+  }
+  async onMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.type !== "tool_request") return;
+    const req = msg;
+    await this.handleToolRequest(req);
+  }
+  /**
+   * Reply to a tool request. Durable calls (the agent parked them) deliver the
+   * result over HTTP so it lands even if this socket later drops; legacy calls
+   * reply over the WebSocket.
+   */
+  respond(req, ok, result, error) {
+    if (req.durable && req.toolCallId) {
+      void this.api.postToolResult(this.threadId, req.toolCallId, ok, result, error);
+    } else {
+      this.send({ type: "tool_response", id: req.id, ok, result, error });
+    }
+  }
+  async handleToolRequest(req) {
+    if (req.durable && req.toolCallId) {
+      if (this.handledDurable.has(req.toolCallId)) return;
+      this.handledDurable.add(req.toolCallId);
+    }
+    const summary = describe(req);
+    let effectiveRisk = typeof req.risk === "number" ? req.risk : req.requestPermission ? 3 : 1;
+    if (PATH_ARG_TOOLS.has(req.tool) && this.host.isOutsideProject(req.args.path)) {
+      effectiveRisk = Math.max(effectiveRisk, 4);
+    }
+    if (req.tool === "bash" && isCatastrophic(String(req.args.command || ""))) {
+      this.hooks.onActivity(`\u26D4 blocked dangerous command: ${summary}`);
+      this.respond(req, false, void 0, "Blocked: this command is considered catastrophic and was refused by the client safety guard.");
+      return;
+    }
+    const permKey = permissionKey(req);
+    const decision = decide(this.perm, permKey, effectiveRisk, !!req.requestPermission);
+    if (decision === "deny") {
+      this.hooks.onActivity(`\u26D4 ${summary} \u2014 blocked (risk ${effectiveRisk})`);
+      this.respond(req, false, void 0, `Denied by policy (risk ${effectiveRisk}).`);
+      return;
+    }
+    if (decision === "ask") {
+      const { choice, reason } = await this.hooks.requestApproval(req, summary, effectiveRisk);
+      if (choice === "deny") {
+        const why = reason?.trim();
+        this.hooks.onActivity(`\u26D4 ${summary} \u2014 you declined${why ? `: ${why}` : ""}`);
+        this.respond(
+          req,
+          false,
+          void 0,
+          why ? `The user declined to run this operation. Their reason: ${why}` : "The user declined to run this operation."
+        );
+        return;
+      }
+      if (choice === "always") this.perm.alwaysAllow.add(permKey);
+      if (choice === "always_risk") this.perm.allowRisk.add(effectiveRisk);
+      if (choice === "always" || choice === "always_risk") {
+        saveApprovals(this.api, this.threadId, this.perm);
+      }
+    }
+    const callKey = req.toolCallId ?? req.id ?? `${req.tool}:${summary}`;
+    this.hooks.onStatus?.(callKey, summary);
+    let result;
+    try {
+      result = await this.host.execute(req.tool, req.args);
+    } finally {
+      this.hooks.onStatus?.(callKey, null);
+    }
+    if (result.ok) {
+      const display = req.tool === "bash" ? `bash: ${highlightBash(String(req.args.command ?? "").slice(0, 200))}` : summary;
+      let detail;
+      if (req.tool === "edit_file") {
+        detail = diffLines(String(req.args.old_string ?? ""), String(req.args.new_string ?? ""));
+      } else if (req.tool === "write_file") {
+        detail = newFileLines(String(req.args.content ?? ""));
+      }
+      this.hooks.onActivity(`\u2713 ${display}${detailSuffix(req.tool, result.result)}`, detail);
+      this.respond(req, true, result.result ?? "");
+    } else {
+      this.hooks.onActivity(`\u2717 ${summary} \u2014 ${result.error}`);
+      this.respond(req, false, void 0, result.error);
+    }
+  }
+};
+function permissionKey(req) {
+  if (req.tool !== "mcp") return req.tool;
+  const a = req.args;
+  const server = String(a.server || "?");
+  const action = String(a.action || "call");
+  if (action === "read_resource") return `mcp:${server}/resource`;
+  if (action === "list_tools") return `mcp:${server}/list`;
+  return `mcp:${server}/${String(a.tool || "?")}`;
+}
+function describe(req) {
+  const a = req.args;
+  switch (req.tool) {
+    case "mcp": {
+      const server = String(a.server || "?");
+      const action = String(a.action || "call");
+      if (action === "list_tools") return `mcp ${server}: list tools`;
+      if (action === "read_resource") return `mcp ${server}: read ${a.uri}`;
+      return `mcp ${server}: ${a.tool}`;
+    }
+    case "read_file":
+      return `read ${a.path}`;
+    case "grep":
+      return `grep "${a.pattern}"${a.glob ? ` in ${a.glob}` : ""}`;
+    case "glob":
+      return `find ${a.pattern}`;
+    case "write_file":
+      return `write ${a.path}`;
+    case "edit_file":
+      return `edit ${a.path}`;
+    case "save_to_disk":
+      return `save ${a.source_path} \u2192 ${a.dest_path}`;
+    case "run_skill_script":
+      return `skill ${a.skill}: run ${a.entry}`;
+    case "bash":
+      return `bash: ${String(a.command).slice(0, 80)}`;
+    default:
+      return `${req.tool} ${JSON.stringify(a).slice(0, 80)}`;
+  }
+}
+function detailSuffix(tool, result) {
+  if (!result) return "";
+  if (tool === "write_file" || tool === "edit_file") return "";
+  if (tool === "bash") {
+    const m = result.match(/\[exit code (\d+)\]\s*$/);
+    return m ? ` (exit ${m[1]})` : "";
+  }
+  const lines = result.split("\n").length;
+  return ` (${lines} line${lines === 1 ? "" : "s"})`;
+}
+var LOG_DIR = path3.join(os6.homedir(), ".standardagents", "process-logs");
+var KEY2 = "bg_processes";
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+var ProcessRegistry = class {
+  constructor(api, threadId, machine) {
+    this.api = api;
+    this.threadId = threadId;
+    this.machine = machine;
+  }
+  api;
+  threadId;
+  machine;
+  async read() {
+    const value = await this.api.kvGet(this.threadId, KEY2);
+    return Array.isArray(value) ? value : [];
+  }
+  async write(entries) {
+    await this.api.kvSet(this.threadId, KEY2, entries);
+  }
+  /** Mark this machine's dead "running" entries as exited. Returns true if any changed. */
+  reconcileLiveness(entries) {
+    let changed = false;
+    for (const e of entries) {
+      if (e.machine === this.machine && e.status === "running" && !isAlive(e.pid)) {
+        e.status = "exited";
+        e.endedAt = Date.now();
+        changed = true;
+      }
+    }
+    return changed;
+  }
+  /** All tracked processes, newest first, with liveness re-checked + persisted. */
+  async list() {
+    const entries = await this.read();
+    if (this.reconcileLiveness(entries)) await this.write(entries);
+    return entries.sort((a, b) => b.startedAt - a.startedAt);
+  }
+  async runningCount() {
+    const entries = await this.list();
+    return entries.filter((e) => e.status === "running").length;
+  }
+  async get(id) {
+    return (await this.read()).find((e) => e.id === id) ?? null;
+  }
+  async add(entry) {
+    const entries = await this.read();
+    entries.push(entry);
+    await this.write(entries);
+  }
+  async markExited(id, exitCode) {
+    const entries = await this.read();
+    const e = entries.find((x) => x.id === id);
+    if (e && e.status === "running") {
+      e.status = "exited";
+      e.exitCode = exitCode;
+      e.endedAt = Date.now();
+      await this.write(entries);
+    }
+  }
+  async markStopped(id) {
+    const entries = await this.read();
+    const e = entries.find((x) => x.id === id);
+    if (e) {
+      e.status = "stopped";
+      e.endedAt = Date.now();
+      await this.write(entries);
+    }
+  }
+};
+function configFile() {
+  return process.env.STANDARDAGENTS_MCP_CONFIG || path3.join(os6.homedir(), ".standardagents", "mcp.json");
+}
+function loadMcpConfig() {
+  try {
+    const raw = fs4.readFileSync(configFile(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.servers || typeof parsed.servers !== "object") parsed.servers = {};
+    return parsed;
+  } catch {
+    return { servers: {} };
+  }
+}
+function listMcpServers() {
+  const cfg = loadMcpConfig();
+  return Object.values(cfg.servers).sort((a, b) => a.name.localeCompare(b.name));
+}
+function saveMcpServer(server) {
+  const cfg = loadMcpConfig();
+  cfg.servers[server.name] = server;
+  write(cfg);
+}
+function removeMcpServer(name) {
+  const cfg = loadMcpConfig();
+  delete cfg.servers[name];
+  write(cfg);
+}
+function setMcpServerEnabled(name, enabled) {
+  const cfg = loadMcpConfig();
+  const s = cfg.servers[name];
+  if (!s) return;
+  s.enabled = enabled;
+  write(cfg);
+}
+function write(cfg) {
+  const file = configFile();
+  fs4.mkdirSync(path3.dirname(file), { recursive: true });
+  fs4.writeFileSync(file, JSON.stringify(cfg, null, 2), { mode: 384 });
+}
+function parseServerSpec(spec) {
+  const trimmed = spec.trim();
+  const colon = trimmed.indexOf(":");
+  if (colon <= 0) return null;
+  const name = trimmed.slice(0, colon).trim();
+  const rest = trimmed.slice(colon + 1).trim();
+  if (!name || !rest) return null;
+  const parts = tokenize(rest);
+  if (!parts.length) return null;
+  const [command, ...args] = parts;
+  return { name, command, args, enabled: true };
+}
+function serverFromCommand(name, commandLine, env) {
+  const cleanName = name.trim();
+  const parts = tokenize(commandLine.trim());
+  if (!cleanName || !parts.length) return null;
+  const [command, ...args] = parts;
+  return { name: cleanName, command, args, env, enabled: true };
+}
+function tokenize(input2) {
+  const out = [];
+  let cur = "";
+  let quote = null;
+  for (let i = 0; i < input2.length; i++) {
+    const ch = input2[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+      else cur += ch;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (/\s/.test(ch)) {
+      if (cur) {
+        out.push(cur);
+        cur = "";
+      }
+    } else {
+      cur += ch;
+    }
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+
+// src/host-tools.ts
+var STARTUP_GRACE_MS = 600;
+function isAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function readLogTail(logPath, n) {
+  try {
+    const content = await fsp.readFile(logPath, "utf8");
+    return content.split("\n").filter(Boolean).slice(-n).join("\n");
+  } catch {
+    return "";
+  }
+}
+var HostTools = class {
+  constructor(projectDir, registry, threadId, machine, mcp, onMcpCatalogChange, api) {
+    this.projectDir = projectDir;
+    this.registry = registry;
+    this.threadId = threadId;
+    this.machine = machine;
+    this.mcp = mcp;
+    this.onMcpCatalogChange = onMcpCatalogChange;
+    this.api = api;
+  }
+  projectDir;
+  registry;
+  threadId;
+  machine;
+  mcp;
+  onMcpCatalogChange;
+  api;
+  /** Resolve a user/model-supplied path against the project directory. */
+  resolve(p) {
+    if (!p || p === ".") return this.projectDir;
+    return path3.resolve(this.projectDir, p);
+  }
+  /** True when the resolved path escapes the project directory. */
+  isOutsideProject(p) {
+    const abs = this.resolve(p);
+    const rel = path3.relative(this.projectDir, abs);
+    return rel.startsWith("..") || path3.isAbsolute(rel);
+  }
+  async execute(tool, args) {
+    try {
+      switch (tool) {
+        case "read_file":
+          return await this.readFile(args);
+        case "grep":
+          return await this.grep(args);
+        case "glob":
+          return await this.glob(args);
+        case "write_file":
+          return await this.writeFile(args);
+        case "edit_file":
+          return await this.editFile(args);
+        case "bash":
+          return await this.bash(args);
+        case "save_to_disk":
+          return await this.saveToDisk(args);
+        case "run_skill_script":
+          return await this.runSkillScript(args);
+        case "background_process": {
+          const action = String(args.action || "list");
+          if (action === "start") return await this.runBackground(args);
+          return await this.backgroundProcesses(args);
+        }
+        case "mcp": {
+          if (!this.mcp) {
+            return { ok: false, error: "MCP is not available in this session." };
+          }
+          if (String(args.action) === "remove") {
+            const name = String(args.server || "");
+            if (!name) return { ok: false, error: "remove requires a 'server' name." };
+            this.mcp.disconnect(name);
+            removeMcpServer(name);
+            this.onMcpCatalogChange?.();
+            return { ok: true, result: JSON.stringify({ removed: name }) };
+          }
+          return await this.mcp.dispatch(args);
+        }
+        case "install_mcp":
+          return await this.installMcp(args);
+        default:
+          return { ok: false, error: `Unknown tool: ${tool}` };
+      }
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async readFile(args) {
+    const file = this.resolve(String(args.path || ""));
+    const stat = await fsp.stat(file).catch(() => null);
+    if (!stat) return { ok: false, error: `File not found: ${args.path}` };
+    if (stat.isDirectory()) return { ok: false, error: `${args.path} is a directory` };
+    if (stat.size > 2e6) return { ok: false, error: `File too large (${stat.size} bytes)` };
+    const content = await fsp.readFile(file, "utf8");
+    const lines = content.split("\n");
+    const offset = typeof args.offset === "number" ? Math.max(1, args.offset) : 1;
+    const limit = typeof args.limit === "number" ? args.limit : lines.length;
+    const slice = lines.slice(offset - 1, offset - 1 + limit);
+    const numbered = slice.map((l, i) => `${offset + i}	${l}`).join("\n");
+    return { ok: true, result: numbered || "(empty file)" };
+  }
+  async grep(args) {
+    const pattern = String(args.pattern || "");
+    if (!pattern) return { ok: false, error: "pattern is required" };
+    const searchPath = this.resolve(args.path ? String(args.path) : void 0);
+    const rgArgs = ["--line-number", "--no-heading", "--color", "never", "--max-count", "200"];
+    if (args.ignore_case) rgArgs.push("-i");
+    if (args.glob) rgArgs.push("--glob", String(args.glob));
+    rgArgs.push("--", pattern, searchPath);
+    const rg = await this.run("rg", rgArgs, this.projectDir, 3e4);
+    if (rg.code === 127) {
+      return { ok: false, error: "ripgrep (rg) not found on host; install it for grep." };
+    }
+    const out = rg.stdout.trim();
+    return { ok: true, result: out || "(no matches)" };
+  }
+  async glob(args) {
+    const pattern = String(args.pattern || "");
+    if (!pattern) return { ok: false, error: "pattern is required" };
+    const base = this.resolve(args.path ? String(args.path) : void 0);
+    const rg = await this.run("rg", ["--files", "--glob", pattern, base], this.projectDir, 3e4);
+    if (rg.code === 127) {
+      const matches = await this.walkGlob(base, pattern);
+      return { ok: true, result: matches.slice(0, 300).join("\n") || "(no files)" };
+    }
+    const rel = rg.stdout.trim().split("\n").filter(Boolean).map((p) => path3.relative(this.projectDir, p)).slice(0, 300);
+    return { ok: true, result: rel.join("\n") || "(no files)" };
+  }
+  async writeFile(args) {
+    const file = this.resolve(String(args.path || ""));
+    const content = String(args.content ?? "");
+    await fsp.mkdir(path3.dirname(file), { recursive: true });
+    const existed = fs4.existsSync(file);
+    await fsp.writeFile(file, content, "utf8");
+    return {
+      ok: true,
+      result: `${existed ? "Overwrote" : "Created"} ${path3.relative(this.projectDir, file)} (${Buffer.byteLength(content)} bytes)`
+    };
+  }
+  async editFile(args) {
+    const file = this.resolve(String(args.path || ""));
+    const oldStr = String(args.old_string ?? "");
+    const newStr = String(args.new_string ?? "");
+    const replaceAll = args.replace_all === true;
+    const stat = await fsp.stat(file).catch(() => null);
+    if (!stat) return { ok: false, error: `File not found: ${args.path}` };
+    const content = await fsp.readFile(file, "utf8");
+    if (oldStr === "") return { ok: false, error: "old_string cannot be empty" };
+    const count = content.split(oldStr).length - 1;
+    if (count === 0) return { ok: false, error: "old_string not found in file (it must match exactly)." };
+    if (count > 1 && !replaceAll) {
+      return { ok: false, error: `old_string is not unique (${count} matches). Add more context or set replace_all.` };
+    }
+    const updated = replaceAll ? content.split(oldStr).join(newStr) : content.replace(oldStr, newStr);
+    await fsp.writeFile(file, updated, "utf8");
+    return { ok: true, result: `Edited ${path3.relative(this.projectDir, file)} (${count} replacement${count === 1 ? "" : "s"})` };
+  }
+  /**
+   * Copy a file from the THREAD filesystem (e.g. a generated /attachments/*
+   * asset) onto the project disk: download the bytes from the instance API and
+   * write them at the destination. The bytes never pass through the model.
+   */
+  async saveToDisk(args) {
+    const source = String(args.source_path || "");
+    const destArg = String(args.dest_path || "");
+    if (!source || !destArg) return { ok: false, error: "source_path and dest_path are required" };
+    if (!this.api || !this.threadId) {
+      return { ok: false, error: "No instance API available for thread file downloads." };
+    }
+    const bytes = await this.api.fetchFile(this.threadId, source);
+    if (!bytes) return { ok: false, error: `Could not download ${source} from the thread filesystem.` };
+    const dest = this.resolve(destArg);
+    await fsp.mkdir(path3.dirname(dest), { recursive: true });
+    const existed = fs4.existsSync(dest);
+    await fsp.writeFile(dest, bytes);
+    return {
+      ok: true,
+      result: `${existed ? "Overwrote" : "Saved"} ${path3.relative(this.projectDir, dest)} (${bytes.length} bytes) from ${source}`
+    };
+  }
+  /**
+   * Execute a SKILL script on the host. Skills live in the instance (cloud is
+   * the source of truth); the server forwards the skill's files with the call
+   * and we materialize them into a content-addressed temp dir — nothing about
+   * a skill is stored on this machine beyond an ephemeral cache. The script
+   * runs with cwd = the PROJECT (so it can operate on the user's files) and
+   * SKILL_DIR pointing at the materialized folder (so it can read its own
+   * references/assets).
+   */
+  async runSkillScript(args) {
+    const skill = String(args.skill || "skill");
+    const entry = String(args.entry || "");
+    if (!entry) return { ok: false, error: "entry (the script path within the skill) is required" };
+    let files;
+    try {
+      const parsed = JSON.parse(String(args.files_json || "[]"));
+      if (!Array.isArray(parsed)) throw new Error("not an array");
+      files = parsed.map((f) => ({ path: String(f.path), content: String(f.content ?? "") }));
+    } catch {
+      return { ok: false, error: "files_json must be a JSON array of {path, content}" };
+    }
+    if (!files.some((f) => f.path === entry)) {
+      return { ok: false, error: `entry "${entry}" is not among the provided skill files` };
+    }
+    let scriptArgs = [];
+    if (args.args_json) {
+      try {
+        const parsed = JSON.parse(String(args.args_json));
+        if (!Array.isArray(parsed)) throw new Error("not an array");
+        scriptArgs = parsed.map(String);
+      } catch {
+        return { ok: false, error: "args_json must be a JSON array of strings" };
+      }
+    }
+    const hash = crypto.createHash("sha256").update(JSON.stringify(files)).digest("hex").slice(0, 12);
+    const skillDir = path3.join(os6.tmpdir(), "standardcode-skills", `${skill}-${hash}`);
+    for (const f of files) {
+      const dest = path3.resolve(skillDir, f.path);
+      if (path3.relative(skillDir, dest).startsWith("..")) {
+        return { ok: false, error: `Skill file escapes its directory: ${f.path}` };
+      }
+      await fsp.mkdir(path3.dirname(dest), { recursive: true });
+      await fsp.writeFile(dest, f.content, "utf8");
+    }
+    const entryPath = path3.resolve(skillDir, entry);
+    const entryContent = files.find((f) => f.path === entry).content;
+    let cmd;
+    let argv;
+    if (entryContent.startsWith("#!")) {
+      await fsp.chmod(entryPath, 493);
+      cmd = entryPath;
+      argv = scriptArgs;
+    } else {
+      const ext = path3.extname(entry).toLowerCase();
+      const interp = {
+        ".py": ["python3"],
+        ".sh": ["bash"],
+        ".js": ["node"],
+        ".mjs": ["node"],
+        ".ts": ["npx", "tsx"]
+      };
+      const found = interp[ext];
+      if (!found) return { ok: false, error: `No interpreter for "${ext}" \u2014 add a shebang line to the script.` };
+      cmd = found[0];
+      argv = [...found.slice(1), entryPath, ...scriptArgs];
+    }
+    const timeoutMs = typeof args.timeout_ms === "number" ? Math.min(args.timeout_ms, 3e5) : 12e4;
+    return await new Promise((resolvePromise) => {
+      const child = spawn(cmd, argv, {
+        cwd: this.projectDir,
+        env: { ...process.env, SKILL_DIR: skillDir },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let out = "";
+      const cap = (chunk) => {
+        if (out.length < 2e5) out += chunk.toString("utf8");
+      };
+      child.stdout.on("data", cap);
+      child.stderr.on("data", cap);
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        resolvePromise({ ok: false, error: `Skill script timed out after ${timeoutMs}ms.
+${out.slice(-4e3)}` });
+      }, timeoutMs);
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        resolvePromise({ ok: false, error: `Could not launch ${cmd}: ${err.message}` });
+      });
+      child.on("exit", (code) => {
+        clearTimeout(timer);
+        const body = out.trim() || "(no output)";
+        if (code === 0) resolvePromise({ ok: true, result: body });
+        else resolvePromise({ ok: false, error: `Script exited with code ${code}:
+${body.slice(-6e3)}` });
+      });
+    });
+  }
+  async bash(args) {
+    const command = String(args.command || "");
+    if (!command.trim()) return { ok: false, error: "command is required" };
+    const cwd = args.cwd ? this.resolve(String(args.cwd)) : this.projectDir;
+    const timeout = typeof args.timeout_ms === "number" ? args.timeout_ms : 12e4;
+    const res = await this.run("bash", ["-lc", command], cwd, timeout);
+    const combined = [res.stdout, res.stderr].filter(Boolean).join("\n").trim();
+    const truncated = combined.length > 3e4 ? combined.slice(0, 3e4) + "\n\u2026(truncated)" : combined;
+    if (res.timedOut) {
+      return { ok: false, error: `Command timed out after ${timeout}ms.
+${truncated}` };
+    }
+    const status = `exit code ${res.code}`;
+    return {
+      ok: res.code === 0,
+      result: `${truncated || "(no output)"}
+[${status}]`,
+      error: res.code === 0 ? void 0 : `Command failed (${status}).
+${truncated}`
+    };
+  }
+  /** Start a tracked long-running process, detached, with output to a log file. */
+  async runBackground(args) {
+    const command = String(args.command || "");
+    if (!command.trim()) return { ok: false, error: "command is required" };
+    const cwd = args.cwd ? this.resolve(String(args.cwd)) : this.projectDir;
+    const id = crypto.randomUUID().slice(0, 8);
+    const logPath = path3.join(LOG_DIR, `${id}.log`);
+    let out;
+    try {
+      await fsp.mkdir(LOG_DIR, { recursive: true });
+      out = fs4.openSync(logPath, "a");
+    } catch (err) {
+      return { ok: false, error: `Could not open log file: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    let child;
+    try {
+      child = spawn("bash", ["-lc", command], { cwd, detached: true, stdio: ["ignore", out, out] });
+    } catch (err) {
+      fs4.closeSync(out);
+      return { ok: false, error: `Failed to start: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    fs4.closeSync(out);
+    const pid = child.pid;
+    if (!pid) return { ok: false, error: "Process failed to start (no pid)." };
+    let earlyExit;
+    const onEarlyExit = (code) => {
+      earlyExit = code;
+    };
+    child.on("exit", onEarlyExit);
+    await new Promise((r) => setTimeout(r, STARTUP_GRACE_MS));
+    if (earlyExit !== void 0 || !isAlive2(pid)) {
+      const tail = await readLogTail(logPath, 15);
+      const code = earlyExit ?? "unknown";
+      return {
+        ok: false,
+        error: `The process exited immediately (exit code ${code}) \u2014 it did not stay running, so nothing was started or tracked.` + (tail ? `
+
+Output:
+${tail}` : " No output was captured.")
+      };
+    }
+    child.removeListener("exit", onEarlyExit);
+    child.unref();
+    if (this.registry) {
+      const entry = {
+        id,
+        pid,
+        command,
+        description: typeof args.description === "string" ? args.description : void 0,
+        cwd,
+        machine: this.machine ?? "",
+        logPath,
+        startedAt: Date.now(),
+        status: "running"
+      };
+      await this.registry.add(entry);
+      child.on("exit", (code) => void this.registry?.markExited(id, code));
+    }
+    return {
+      ok: true,
+      result: JSON.stringify(
+        {
+          id,
+          pid,
+          status: "running",
+          logPath,
+          note: `Started in the background as process ${id} (pid ${pid}) and confirmed running. Output is logged to ${logPath}. Use background_process (list/logs/stop) to check on it or stop it.`
+        },
+        null,
+        2
+      )
+    };
+  }
+  /**
+   * Install + connect an MCP server from a name + launch command (e.g.
+   * "npx -y @playwright/mcp@latest"). Saves it to the user's MCP config,
+   * launches it, runs the handshake, and republishes the catalog on success so
+   * the agent immediately sees its tools. The connect IS the install — for `npx`
+   * commands the package is fetched on first run.
+   */
+  async installMcp(args) {
+    if (!this.mcp) return { ok: false, error: "MCP is not available in this session." };
+    const name = String(args.name || "");
+    const command = String(args.command || "");
+    if (!name || !command) {
+      return { ok: false, error: 'install_mcp needs a `name` and a `command` (e.g. "npx -y @playwright/mcp@latest").' };
+    }
+    let env;
+    if (typeof args.env_json === "string" && args.env_json.trim()) {
+      try {
+        const parsed = JSON.parse(args.env_json);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) env = parsed;
+        else return { ok: false, error: "env_json must encode a JSON object of environment variables." };
+      } catch (e) {
+        return { ok: false, error: `env_json is not valid JSON: ${e instanceof Error ? e.message : String(e)}` };
+      }
+    }
+    const cfg = serverFromCommand(name, command, env);
+    if (!cfg) return { ok: false, error: `Could not parse the command: "${command}".` };
+    saveMcpServer(cfg);
+    try {
+      const client = await this.mcp.connect(cfg);
+      this.onMcpCatalogChange?.();
+      const tools = client.tools.map((t) => t.name);
+      return {
+        ok: true,
+        result: JSON.stringify(
+          {
+            server: cfg.name,
+            command: `${cfg.command} ${cfg.args.join(" ")}`.trim(),
+            connected: true,
+            toolCount: tools.length,
+            tools,
+            note: `Installed and connected MCP server "${cfg.name}" with ${tools.length} tool${tools.length === 1 ? "" : "s"}${tools.length ? `: ${tools.join(", ")}` : ""}. They are available now and will auto-connect next session.`
+          },
+          null,
+          2
+        )
+      };
+    } catch (err) {
+      this.onMcpCatalogChange?.();
+      return {
+        ok: false,
+        error: `Saved MCP server "${cfg.name}" but it failed to start: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  /** List / inspect logs of / stop tracked background processes. */
+  async backgroundProcesses(args) {
+    const action = String(args.action || "list");
+    if (!this.registry) {
+      return { ok: true, result: "Background-process tracking is not available in this session." };
+    }
+    if (action === "list") {
+      const procs = await this.registry.list();
+      if (!procs.length) return { ok: true, result: "No background processes for this session." };
+      const lines = procs.map((p) => {
+        const age = relativeAge(p.startedAt);
+        const status = p.status === "running" ? "running" : `${p.status}${typeof p.exitCode === "number" ? ` (exit ${p.exitCode})` : ""}`;
+        return `${p.id}  [${status}]  pid ${p.pid}  started ${age}
+    ${p.command}`;
+      });
+      return { ok: true, result: lines.join("\n") };
+    }
+    const id = String(args.id || "");
+    const proc = await this.registry.get(id);
+    if (!proc) return { ok: false, error: `No background process with id ${id}` };
+    if (action === "logs") {
+      const maxLines = typeof args.lines === "number" ? args.lines : 60;
+      let content = "";
+      try {
+        content = await fsp.readFile(proc.logPath, "utf8");
+      } catch {
+        return { ok: true, result: `(no output captured yet for ${id})` };
+      }
+      const tail = content.split("\n").slice(-maxLines).join("\n");
+      return { ok: true, result: tail || `(no output yet for ${id})` };
+    }
+    if (action === "stop") {
+      if (proc.status !== "running") {
+        return { ok: true, result: `Process ${id} is already ${proc.status}.` };
+      }
+      try {
+        process.kill(-proc.pid, "SIGTERM");
+        setTimeout(() => {
+          try {
+            process.kill(-proc.pid, "SIGKILL");
+          } catch {
+          }
+        }, 3e3);
+      } catch {
+        try {
+          process.kill(proc.pid, "SIGKILL");
+        } catch {
+        }
+      }
+      await this.registry.markStopped(id);
+      return { ok: true, result: `Stopped background process ${id} (pid ${proc.pid}).` };
+    }
+    return { ok: false, error: `Unknown action: ${action}` };
+  }
+  /**
+   * Terminate every still-running background process this machine started, so
+   * detached children don't outlive the CLI when the session quits. Sends
+   * SIGTERM to each process group, waits a brief grace, then SIGKILL any
+   * straggler, and records them stopped. Best effort and bounded so quitting
+   * stays snappy. Returns the number of running processes it signaled.
+   */
+  async stopAllLocalProcesses() {
+    if (!this.registry) return 0;
+    let running = [];
+    try {
+      const procs = await this.registry.list();
+      running = procs.filter((p) => p.status === "running" && p.machine === (this.machine ?? ""));
+    } catch {
+      return 0;
+    }
+    if (!running.length) return 0;
+    const signal = (pid, sig) => {
+      try {
+        process.kill(-pid, sig);
+      } catch {
+        try {
+          process.kill(pid, sig);
+        } catch {
+        }
+      }
+    };
+    for (const proc of running) signal(proc.pid, "SIGTERM");
+    await new Promise((r) => setTimeout(r, 300));
+    for (const proc of running) signal(proc.pid, "SIGKILL");
+    await Promise.allSettled(running.map((proc) => this.registry.markStopped(proc.id)));
+    return running.length;
+  }
+  run(cmd, args, cwd, timeoutMs) {
+    return new Promise((resolve) => {
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+      let exitCode = 0;
+      let settled = false;
+      const MAX_OUTPUT = 256 * 1024;
+      let child;
+      try {
+        child = spawn(cmd, args, { cwd, detached: true });
+      } catch {
+        resolve({ stdout: "", stderr: "", code: 127, timedOut: false });
+        return;
+      }
+      child.unref();
+      let graceTimer = null;
+      const settle = (code) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        if (graceTimer) clearTimeout(graceTimer);
+        resolve({ stdout, stderr, code, timedOut });
+      };
+      const timer = setTimeout(() => {
+        timedOut = true;
+        try {
+          if (child.pid) process.kill(-child.pid, "SIGKILL");
+        } catch {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }
+        setTimeout(() => settle(exitCode), 250);
+      }, timeoutMs);
+      child.stdout?.on("data", (d) => {
+        if (stdout.length < MAX_OUTPUT) stdout += d.toString();
+      });
+      child.stderr?.on("data", (d) => {
+        if (stderr.length < MAX_OUTPUT) stderr += d.toString();
+      });
+      child.on("error", (err) => {
+        if (!stderr) stderr = String(err);
+        settle(err.code === "ENOENT" ? 127 : 1);
+      });
+      child.on("close", (code) => settle(code ?? exitCode));
+      child.on("exit", (code) => {
+        exitCode = code ?? 0;
+        graceTimer = setTimeout(() => settle(exitCode), 250);
+      });
+    });
+  }
+  async walkGlob(base, pattern) {
+    const re = globToRegExp(pattern);
+    const out = [];
+    const walk = async (dir) => {
+      const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => []);
+      for (const e of entries) {
+        if (e.name === ".git" || e.name === "node_modules") continue;
+        const full = path3.join(dir, e.name);
+        if (e.isDirectory()) await walk(full);
+        else {
+          const rel = path3.relative(this.projectDir, full);
+          if (re.test(rel) || re.test(e.name)) out.push(rel);
+        }
+      }
+    };
+    await walk(base);
+    return out;
+  }
+};
+function relativeAge(startedAt) {
+  const diff = (Date.now() - startedAt) / 1e3;
+  if (diff < 60) return `${Math.floor(diff)}s ago`;
+  if (diff < 3600) return `${Math.floor(diff / 60)}m ago`;
+  if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`;
+  return `${Math.floor(diff / 86400)}d ago`;
+}
+function globToRegExp(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, " ").replace(/\*/g, "[^/]*").replace(/ /g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`);
+}
+
+// src/stream.ts
+var MessageStream = class {
+  constructor(api, threadId, hooks) {
+    this.api = api;
+    this.threadId = threadId;
+    this.hooks = hooks;
+  }
+  api;
+  threadId;
+  hooks;
+  ws = null;
+  closed = false;
+  heartbeat = null;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  resolveConnected = null;
+  /**
+   * Connect and stay connected. Resolves on first open; reconnects on any drop
+   * with exponential backoff. Silent — the bridge surfaces the user-facing
+   * connection status; completion is detected via HTTP polling regardless, so a
+   * dropped stream only affects live display, not correctness.
+   */
+  connect() {
+    return new Promise((resolve) => {
+      let settled = false;
+      this.resolveConnected = () => {
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      };
+      setTimeout(() => this.resolveConnected?.(), 8e3);
+      this.openSocket();
+    });
+  }
+  openSocket() {
+    if (this.closed) return;
+    const url = `${this.api.wsEndpoint}/api/threads/${this.threadId}/stream?token=${encodeURIComponent(this.api.bearer)}&reasoning=1`;
+    let ws;
+    try {
+      ws = new WebSocket(url);
+    } catch {
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws = ws;
+    ws.addEventListener("open", () => {
+      this.reconnectAttempt = 0;
+      this.startHeartbeat(ws);
+      this.resolveConnected?.();
+    });
+    ws.addEventListener("message", (ev) => {
+      if (this.ws === ws) this.heartbeat?.markAlive();
+      this.onMessage(String(ev.data));
+    });
+    ws.addEventListener("error", () => this.handleDrop(ws));
+    ws.addEventListener("close", () => this.handleDrop(ws));
+  }
+  handleDrop(ws) {
+    if (this.ws !== ws) return;
+    this.ws = null;
+    this.stopHeartbeat();
+    this.scheduleReconnect();
+  }
+  startHeartbeat(ws) {
+    this.stopHeartbeat();
+    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws));
+    this.heartbeat.start();
+  }
+  stopHeartbeat() {
+    if (this.heartbeat) {
+      this.heartbeat.stop();
+      this.heartbeat = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.closed || this.reconnectTimer) return;
+    this.reconnectAttempt++;
+    const base = Math.min(500 * 2 ** (this.reconnectAttempt - 1), 15e3);
+    const delay = base + Math.floor(Math.random() * 400);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.openSocket();
+    }, delay);
+  }
+  close() {
+    this.closed = true;
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.ws?.close();
+  }
+  onMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.type === "event" && typeof msg.eventType === "string") {
+      this.hooks.onEvent?.(msg.eventType, msg.data);
+      return;
+    }
+    if (msg.type === "message_chunk" && (msg.depth ?? 0) === 0) {
+      if (typeof msg.chunk === "string") this.hooks.onChunk(msg.chunk, msg.message_id);
+      return;
+    }
+    if (msg.type === "reasoning_chunk" && (msg.depth ?? 0) === 0) {
+      if (typeof msg.chunk === "string") this.hooks.onReasoningChunk?.(msg.chunk, msg.message_id);
+      return;
+    }
+    if (msg.type === "message_data" && (msg.depth ?? 0) === 0) {
+      const data = msg.data || {};
+      if (data.role === "assistant" && typeof data.content === "string" && data.content.trim()) {
+        const tc = data.tool_calls;
+        const hasToolCalls2 = Array.isArray(tc) ? tc.length > 0 : typeof tc === "string" && tc.trim() !== "" && tc.trim() !== "null" && tc.trim() !== "[]";
+        this.hooks.onAssistantText(data.content, hasToolCalls2);
+      }
+      if (data.role === "assistant" && data.status === "failed" && data.error) {
+        this.hooks.onError(String(data.error));
+      }
+    }
+  }
+};
+
+// src/events-stream.ts
+var SystemEvents = class {
+  constructor(api, hooks) {
+    this.api = api;
+    this.hooks = hooks;
+  }
+  api;
+  hooks;
+  ws = null;
+  closed = false;
+  heartbeat = null;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  connect() {
+    this.openSocket();
+  }
+  openSocket() {
+    if (this.closed) return;
+    const url = `${this.api.wsEndpoint}/api/events?token=${encodeURIComponent(this.api.bearer)}`;
+    let ws;
+    try {
+      ws = new WebSocket(url);
+    } catch {
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws = ws;
+    ws.addEventListener("open", () => {
+      this.reconnectAttempt = 0;
+      this.startHeartbeat(ws);
+      this.hooks.onOpen?.();
+    });
+    ws.addEventListener("message", (ev) => {
+      if (this.ws === ws) this.heartbeat?.markAlive();
+      this.onMessage(String(ev.data));
+    });
+    ws.addEventListener("error", () => this.handleDrop(ws));
+    ws.addEventListener("close", () => this.handleDrop(ws));
+  }
+  startHeartbeat(ws) {
+    this.stopHeartbeat();
+    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws));
+    this.heartbeat.start();
+  }
+  stopHeartbeat() {
+    if (this.heartbeat) {
+      this.heartbeat.stop();
+      this.heartbeat = null;
+    }
+  }
+  onMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg?.type === "thread_created" && msg.thread) this.hooks.onThreadCreated(msg.thread);
+    else if (msg?.type === "thread_updated" && msg.thread) this.hooks.onThreadUpdated(msg.thread);
+    else if (msg?.type === "thread_deleted" && typeof msg.threadId === "string") {
+      this.hooks.onThreadDeleted(msg.threadId);
+    }
+  }
+  handleDrop(ws) {
+    if (this.ws !== ws) return;
+    this.ws = null;
+    this.stopHeartbeat();
+    this.scheduleReconnect();
+  }
+  scheduleReconnect() {
+    if (this.closed || this.reconnectTimer) return;
+    this.reconnectAttempt++;
+    const base = Math.min(500 * 2 ** (this.reconnectAttempt - 1), 15e3);
+    const delay = base + Math.floor(Math.random() * 400);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.openSocket();
+    }, delay);
+  }
+  close() {
+    this.closed = true;
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.ws?.close();
+  }
+};
+
+// src/types.ts
+var LEVELS = [1, 2, 3, 4, 5];
+var LEVEL_DETAIL = {
+  1: "only safe reads run automatically",
+  2: "+ safe writes & builds",
+  3: "+ installs & project edits",
+  4: "+ outside-project & git-history",
+  5: "everything \u2014 never ask"
+};
+function levelLabel(level) {
+  return `auto-accept level ${level} (${LEVEL_DETAIL[level]})`;
+}
+var FILE_MIMES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+var MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+function run(cmd, args, maxBuffer = MAX_IMAGE_BYTES * 2) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { encoding: "buffer", maxBuffer }, (err, stdout) => {
+      resolve({ ok: !err, stdout: stdout ?? Buffer.alloc(0) });
+    });
+  });
+}
+function fromFile(filePath) {
+  const mime = FILE_MIMES[path3.extname(filePath).toLowerCase()];
+  if (!mime) return null;
+  try {
+    const stat = fs4.statSync(filePath);
+    if (!stat.isFile() || stat.size === 0 || stat.size > MAX_IMAGE_BYTES) return null;
+    return { data: fs4.readFileSync(filePath).toString("base64"), mime };
+  } catch {
+    return null;
+  }
+}
+async function readDarwin() {
+  const tmp = path3.join(os6.tmpdir(), `sc-clip-${process.pid}-${Date.now()}.png`);
+  const script = [
+    `set d to the clipboard as \xABclass PNGf\xBB`,
+    `set f to open for access POSIX file "${tmp}" with write permission`,
+    `set eof f to 0`,
+    `write d to f`,
+    `close access f`
+  ].join("\n");
+  const png = await run("osascript", ["-e", script]);
+  if (png.ok) {
+    const img = fromFile(tmp);
+    try {
+      fs4.unlinkSync(tmp);
+    } catch {
+    }
+    if (img) return img;
+  }
+  const furl = await run("osascript", ["-e", "POSIX path of (the clipboard as \xABclass furl\xBB)"]);
+  if (furl.ok) {
+    const p = furl.stdout.toString("utf8").trim();
+    if (p) return fromFile(p);
+  }
+  return null;
+}
+async function readLinux() {
+  for (const [cmd, args] of [
+    ["wl-paste", ["--type", "image/png"]],
+    ["xclip", ["-selection", "clipboard", "-t", "image/png", "-o"]]
+  ]) {
+    const res = await run(cmd, args);
+    if (res.ok && res.stdout.length > 8 && res.stdout.length <= MAX_IMAGE_BYTES && res.stdout[0] === 137 && res.stdout[1] === 80) {
+      return { data: res.stdout.toString("base64"), mime: "image/png" };
+    }
+  }
+  return null;
+}
+async function readWindows() {
+  const tmp = path3.join(os6.tmpdir(), `sc-clip-${process.pid}-${Date.now()}.png`);
+  const ps = [
+    "Add-Type -AssemblyName System.Windows.Forms;",
+    "$img = [System.Windows.Forms.Clipboard]::GetImage();",
+    `if ($img -ne $null) { $img.Save('${tmp.replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png) }`
+  ].join(" ");
+  await run("powershell", ["-NoProfile", "-STA", "-Command", ps]);
+  const img = fromFile(tmp);
+  try {
+    fs4.unlinkSync(tmp);
+  } catch {
+  }
+  return img;
+}
+async function readClipboardImage() {
+  try {
+    if (process.platform === "darwin") return await readDarwin();
+    if (process.platform === "win32") return await readWindows();
+    return await readLinux();
+  } catch {
+    return null;
+  }
+}
+
+// src/tui.ts
+function imagePlaceholder(seq) {
+  return `[#Image ${seq}]`;
+}
+var C = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  gray: "\x1B[90m",
+  teal: "\x1B[38;5;37m"
+};
+var FRAMES = ["\u28F7", "\u28EF", "\u28DF", "\u287F", "\u28BF", "\u28FB", "\u28FD", "\u28FE"];
+var SUBAGENT_COLORS = [
+  "\x1B[35m",
+  // magenta
+  "\x1B[38;5;39m",
+  // azure
+  "\x1B[38;5;75m",
+  // blue
+  "\x1B[32m",
+  // green
+  "\x1B[38;5;141m",
+  // violet
+  "\x1B[38;5;177m"
+  // orchid
+];
+var COMPACTION_COLOR = "\x1B[38;5;208m";
+var COMPACTION_AGENT = "compaction_agent";
+var Tui = class _Tui {
+  constructor(level = 1) {
+    this.level = level;
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.on("keypress", (str, key) => this.dispatch(str, key));
+    process.stdin.resume();
+    process.stdout.write("\x1B[?2004h");
+    process.on("exit", () => process.stdout.write("\x1B[?2004l\x1B[?25h"));
+    process.stdout.on("resize", () => this.renderBottom());
+  }
+  level;
+  // input + indicators
+  inputBuffer = "";
+  cursorPos = 0;
+  // caret index within inputBuffer (0..length)
+  lastCursorRow = 0;
+  // caret's row offset from the input region top, last render
+  working = false;
+  workingStart = 0;
+  spinnerTimer = null;
+  bgCount = 0;
+  queuedCount = 0;
+  subagents = [];
+  // active subagents (one line each)
+  subagentColorByID = /* @__PURE__ */ new Map();
+  // subagent id → SUBAGENT_COLORS index
+  tokensIn = 0;
+  // cumulative input tokens
+  tokensOut = 0;
+  // cumulative output tokens (includes the in-progress live count)
+  contextPct = null;
+  // % of the model context window currently used
+  // Live streaming preview, shown just above the status line while a turn runs:
+  // the model's internal reasoning (dim italic) until the answer starts, then the
+  // answer text (plain). Bounded to a tail; cleared when the message commits.
+  streamThinking = "";
+  streamResponse = "";
+  streamMessageId = null;
+  // the message currently previewing
+  streamRedrawTimer = null;
+  streamIdleTimer = null;
+  // wipes a stale preview
+  // Live goal checklist, fixed below the status bar. Driven by the goal_updated
+  // thread event (+ an initial fetch). null = nothing to show.
+  goal = null;
+  // Set true the moment every step of a goal is done: the goal area is cleared
+  // and the status line shows "Goal complete." until the next turn starts.
+  goalComplete = false;
+  // Inline slash-command palette: when the input starts with "/", the filtered
+  // command list renders above the prompt and arrows/enter/tab drive it.
+  commands = [];
+  slashIdx = 0;
+  // highlighted index within the FILTERED command list
+  step = null;
+  // current step label (e.g. "writing index.html")
+  stepStart = 0;
+  // when the current step began (for the step's own elapsed)
+  stepOut = 0;
+  // output tokens produced during the current step
+  connected = true;
+  bottomDrawn = false;
+  started = false;
+  // Resize bookkeeping: the width the region was last drawn at, and the visible
+  // width of every HUD row written above the input. When the terminal is
+  // resized, previously drawn rows re-wrap (a full-width ruler becomes 2+ rows
+  // when narrowed), so the move-up count recorded at draw time is wrong — these
+  // let moveToRegionTop recompute the region height under the NEW wrap instead
+  // of leaving stale rulers behind.
+  lastDrawnCols = 0;
+  drawnHudWidths = [];
+  // takeover (approval / menu) state
+  takeoverHandler = null;
+  bufferedPrints = [];
+  // double-press-to-quit state: the first ctrl-c arms a brief window and shows a
+  // transient hint; a second ctrl-c within the window actually quits.
+  quitArmed = false;
+  quitTimer = null;
+  // bracketed-paste state
+  pasting = false;
+  pasteTimer = null;
+  // Images pasted into the CURRENT input (Ctrl+V). Each got a `[#Image N]`
+  // placeholder at the caret; on submit only images whose placeholder is still
+  // present in the text are handed to onSubmit. Cleared with the input.
+  pendingImages = [];
+  imagePasteBusy = false;
+  // one clipboard read at a time
+  // Sent-message history for ↑/↓ recall (oldest → newest). `historyIdx` is the
+  // entry currently shown (null = not browsing); the in-progress draft is
+  // stashed so cycling past the newest entry restores it. Any edit exits
+  // browsing and keeps the recalled text as the new draft.
+  history = [];
+  historyIdx = null;
+  historyDraft = "";
+  historyDraftImages = [];
+  // event hooks (wired by index.ts)
+  onSubmit = () => {
+  };
+  onInterrupt = () => {
+  };
+  /** Up on the top row: return true to consume it (e.g. pull a queued message)
+   *  before history recall gets a chance. */
+  onUpArrow = () => false;
+  onQuit = () => process.exit(0);
+  levelListeners = [];
+  get colors() {
+    return C;
+  }
+  setQuitHandler(fn) {
+    this.onQuit = fn;
+  }
+  /**
+   * Handle a ctrl-c. The first press arms a 2-second window and surfaces a
+   * transient "Press Control-C again to exit" hint in the bottom region; a
+   * second press within the window quits. After the window lapses the hint
+   * clears and the next ctrl-c starts over — so it always takes two.
+   */
+  requestQuit() {
+    if (this.quitArmed) {
+      if (this.quitTimer) clearTimeout(this.quitTimer);
+      this.quitTimer = null;
+      this.quitArmed = false;
+      this.onQuit();
+      return;
+    }
+    this.quitArmed = true;
+    this.renderBottom();
+    this.quitTimer = setTimeout(() => {
+      this.quitArmed = false;
+      this.quitTimer = null;
+      this.renderBottom();
+    }, 2e3);
+  }
+  /** Tear down the bottom region and restore the terminal (called on quit). */
+  end() {
+    if (this.quitTimer) clearTimeout(this.quitTimer);
+    this.quitTimer = null;
+    if (this.streamIdleTimer) clearTimeout(this.streamIdleTimer);
+    this.streamIdleTimer = null;
+    this.clearBottom();
+    process.stdout.write("\x1B[?2004l\x1B[?25h");
+  }
+  onLevelChange(fn) {
+    this.levelListeners.push(fn);
+  }
+  /** Carrot colour by level — cooler/safer (low) to warmer/permissive (high). */
+  levelColor() {
+    return { 1: C.cyan, 2: C.green, 3: C.yellow, 4: C.magenta, 5: C.red }[this.level];
+  }
+  // ─── key dispatch ──────────────────────────────────────────────────────────
+  dispatch(str, key) {
+    const seq = key && key.sequence || str || "";
+    if (seq === "\n" || seq === "\x1B[13;2u" || seq === "\x1B[27;2;13~") {
+      this.insertAtCursor("\n");
+      return;
+    }
+    if (key && key.ctrl && key.name === "c") {
+      this.requestQuit();
+      return;
+    }
+    if (key && key.name === "tab" && key.shift) {
+      this.cycleLevel();
+      return;
+    }
+    if (!this.pasting && seq.includes("\x1B[200~")) {
+      this.pasting = true;
+      this.armPasteSafety();
+      this.handlePasteChunk(seq.slice(seq.indexOf("\x1B[200~") + 6));
+      return;
+    }
+    if (this.pasting) {
+      this.armPasteSafety();
+      this.handlePasteChunk(seq);
+      return;
+    }
+    if (this.takeoverHandler) {
+      this.takeoverHandler(str, key);
+      return;
+    }
+    if (!key) return;
+    if (this.paletteOpen()) {
+      const matches = this.filteredCommands();
+      const cur = matches.length ? Math.min(this.slashIdx, matches.length - 1) : 0;
+      if (key.name === "up") {
+        if (matches.length) {
+          this.slashIdx = (cur - 1 + matches.length) % matches.length;
+          this.renderBottom();
+        }
+        return;
+      }
+      if (key.name === "down") {
+        if (matches.length) {
+          this.slashIdx = (cur + 1) % matches.length;
+          this.renderBottom();
+        }
+        return;
+      }
+      if (key.name === "tab") {
+        if (matches.length) {
+          this.inputBuffer = "/" + matches[cur].name;
+          this.cursorPos = this.inputBuffer.length;
+          this.slashIdx = 0;
+          this.renderBottom();
+        }
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        if (key.shift) {
+          this.insertAtCursor("\n");
+          return;
+        }
+        if (matches.length) this.runCommand(matches[cur]);
+        return;
+      }
+      if (key.name === "escape") {
+        this.inputBuffer = "";
+        this.cursorPos = 0;
+        this.slashIdx = 0;
+        this.renderBottom();
+        return;
+      }
+    }
+    if (key.name === "escape") {
+      this.onInterrupt();
+      return;
+    }
+    if (key.name === "left") {
+      if (this.cursorPos > 0) {
+        this.cursorPos--;
+        this.renderBottom();
+      }
+      return;
+    }
+    if (key.name === "right") {
+      if (this.cursorPos < this.inputBuffer.length) {
+        this.cursorPos++;
+        this.renderBottom();
+      }
+      return;
+    }
+    if (key.name === "home" || key.ctrl && key.name === "a") {
+      this.cursorPos = 0;
+      this.renderBottom();
+      return;
+    }
+    if (key.name === "end" || key.ctrl && key.name === "e") {
+      this.cursorPos = this.inputBuffer.length;
+      this.renderBottom();
+      return;
+    }
+    if (key.name === "up") {
+      const { caretRow } = this.inputLayout();
+      if (caretRow > 0) {
+        this.moveCaretVertical(-1);
+        return;
+      }
+      if (this.onUpArrow()) return;
+      this.historyPrev();
+      return;
+    }
+    if (key.name === "down") {
+      const { caretRow, rowCount } = this.inputLayout();
+      if (caretRow < rowCount - 1) {
+        this.moveCaretVertical(1);
+        return;
+      }
+      this.historyNext();
+      return;
+    }
+    if (key.name === "return" || key.name === "enter") {
+      if (key.shift) {
+        this.insertAtCursor("\n");
+        return;
+      }
+      const text = this.inputBuffer;
+      const images = this.pendingImages.filter((img) => text.includes(imagePlaceholder(img.seq)));
+      this.inputBuffer = "";
+      this.cursorPos = 0;
+      this.pendingImages = [];
+      this.historyIdx = null;
+      this.historyDraft = "";
+      this.historyDraftImages = [];
+      this.renderBottom();
+      if (text.trim()) {
+        this.addHistoryEntry(text.trim());
+        this.onSubmit(text.trim(), images);
+      }
+      return;
+    }
+    if (key.ctrl && key.name === "v") {
+      void this.pasteClipboardImage();
+      return;
+    }
+    if (key.name === "backspace") {
+      if (this.cursorPos > 0) {
+        this.inputBuffer = this.inputBuffer.slice(0, this.cursorPos - 1) + this.inputBuffer.slice(this.cursorPos);
+        this.cursorPos--;
+        this.slashIdx = 0;
+        this.historyIdx = null;
+        this.renderBottom();
+      }
+      return;
+    }
+    if (key.name === "delete") {
+      if (this.cursorPos < this.inputBuffer.length) {
+        this.inputBuffer = this.inputBuffer.slice(0, this.cursorPos) + this.inputBuffer.slice(this.cursorPos + 1);
+        this.slashIdx = 0;
+        this.historyIdx = null;
+        this.renderBottom();
+      }
+      return;
+    }
+    if (key.ctrl || key.meta || key.name === "tab") return;
+    if (str && str >= " ") {
+      this.insertAtCursor(str);
+    }
+  }
+  insertAtCursor(text) {
+    this.inputBuffer = this.inputBuffer.slice(0, this.cursorPos) + text + this.inputBuffer.slice(this.cursorPos);
+    this.cursorPos += text.length;
+    this.slashIdx = 0;
+    this.historyIdx = null;
+    this.renderBottom();
+  }
+  /** Insert a paste fragment at the caret; collapse newlines (single-line input). */
+  handlePasteChunk(chunk) {
+    const end = chunk.indexOf("\x1B[201~");
+    const content = (end >= 0 ? chunk.slice(0, end) : chunk).replace(/[\r\n]+/g, " ");
+    if (content) {
+      this.inputBuffer = this.inputBuffer.slice(0, this.cursorPos) + content + this.inputBuffer.slice(this.cursorPos);
+      this.cursorPos += content.length;
+      this.historyIdx = null;
+    }
+    if (end >= 0) {
+      this.pasting = false;
+      if (this.pasteTimer) {
+        clearTimeout(this.pasteTimer);
+        this.pasteTimer = null;
+      }
+    }
+    this.renderBottom();
+  }
+  /** Never let a missed end-marker wedge the input: clear paste mode shortly. */
+  armPasteSafety() {
+    if (this.pasteTimer) clearTimeout(this.pasteTimer);
+    this.pasteTimer = setTimeout(() => {
+      this.pasting = false;
+      this.pasteTimer = null;
+      this.renderBottom();
+    }, 2e3);
+  }
+  // ─── input layout + vertical caret movement ────────────────────────────────
+  /**
+   * The input's physical rows (same wrapping math as renderBottom: logical
+   * lines split on "\n", line 0 led by the prompt prefix, each wrapping at the
+   * terminal width) plus where the caret sits among them. Each row records the
+   * buffer index of its first character, its character count, and the visual
+   * column its first character renders at (only row 0 is offset, by the
+   * prompt). Drives ↑/↓: row 0 is "the top line" (history recall territory),
+   * anything below moves the caret instead.
+   */
+  inputLayout() {
+    const cols2 = process.stdout.columns || 80;
+    const pw = this.visibleWidth(this.promptPrefix());
+    const lines = this.inputBuffer.split("\n");
+    const rows = [];
+    let offset = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const lead = i === 0 ? pw : 0;
+      const len = lines[i].length;
+      const nRows = Math.max(1, Math.ceil((lead + len) / cols2));
+      for (let j = 0; j < nRows; j++) {
+        const charStart = Math.max(0, j * cols2 - lead);
+        const charEnd = Math.min(len, (j + 1) * cols2 - lead);
+        rows.push({ start: offset + charStart, len: Math.max(0, charEnd - charStart), colOffset: j === 0 ? lead : 0 });
+      }
+      offset += len + 1;
+    }
+    let pos = this.cursorPos;
+    let caretLine = 0;
+    while (caretLine < lines.length - 1 && pos > lines[caretLine].length) {
+      pos -= lines[caretLine].length + 1;
+      caretLine++;
+    }
+    const caretCell = (caretLine === 0 ? pw : 0) + pos;
+    let caretRow = Math.floor(caretCell / cols2);
+    for (let i = 0; i < caretLine; i++) {
+      const lead = i === 0 ? pw : 0;
+      caretRow += Math.max(1, Math.ceil((lead + lines[i].length) / cols2));
+    }
+    const caretCol = caretCell % cols2;
+    while (caretRow >= rows.length) rows.push({ start: this.inputBuffer.length, len: 0, colOffset: 0 });
+    return { rows, caretRow, caretCol, rowCount: rows.length };
+  }
+  /** Move the caret one visual row up/down, keeping the column when possible. */
+  moveCaretVertical(delta) {
+    const { rows, caretRow, caretCol } = this.inputLayout();
+    const target = caretRow + delta;
+    if (target < 0 || target >= rows.length) return;
+    const row = rows[target];
+    const within = Math.max(0, Math.min(caretCol - row.colOffset, row.len));
+    this.cursorPos = Math.min(row.start + within, this.inputBuffer.length);
+    this.renderBottom();
+  }
+  // ─── sent-message history (↑/↓ recall) ─────────────────────────────────────
+  /** Seed the recall history (oldest → newest), e.g. from the on-disk file. */
+  setHistory(entries) {
+    this.history = entries.filter((e) => e.trim() !== "");
+  }
+  /** Record a sent message (skipping a consecutive duplicate). */
+  addHistoryEntry(text) {
+    if (this.history[this.history.length - 1] === text) return;
+    this.history.push(text);
+  }
+  /** Recall the previous (older) history entry; stashes the draft first. */
+  historyPrev() {
+    if (!this.history.length) return;
+    if (this.historyIdx === null) {
+      this.historyDraft = this.inputBuffer;
+      this.historyDraftImages = this.pendingImages;
+      this.historyIdx = this.history.length - 1;
+    } else if (this.historyIdx > 0) {
+      this.historyIdx--;
+    } else {
+      return;
+    }
+    this.pendingImages = [];
+    this.inputBuffer = this.history[this.historyIdx];
+    this.cursorPos = this.inputBuffer.length;
+    this.slashIdx = 0;
+    this.renderBottom();
+  }
+  /** Step toward the newest entry; past it, restore the stashed draft. */
+  historyNext() {
+    if (this.historyIdx === null) return;
+    if (this.historyIdx < this.history.length - 1) {
+      this.historyIdx++;
+      this.pendingImages = [];
+      this.inputBuffer = this.history[this.historyIdx];
+    } else {
+      this.historyIdx = null;
+      this.inputBuffer = this.historyDraft;
+      this.pendingImages = this.historyDraftImages;
+      this.historyDraft = "";
+      this.historyDraftImages = [];
+    }
+    this.cursorPos = this.inputBuffer.length;
+    this.slashIdx = 0;
+    this.renderBottom();
+  }
+  // ─── clipboard image paste (Ctrl+V) ────────────────────────────────────────
+  /**
+   * Read an image off the system clipboard and drop an `[#Image N]`
+   * placeholder at the caret. The bytes ride along with the message on submit
+   * (as a real attachment) as long as the placeholder is still in the text —
+   * delete the placeholder and the image is dropped too.
+   */
+  async pasteClipboardImage() {
+    if (this.imagePasteBusy) return;
+    this.imagePasteBusy = true;
+    try {
+      const img = await readClipboardImage();
+      if (!img) {
+        this.print(`${C.dim}No image on the clipboard.${C.reset}`);
+        return;
+      }
+      const seq = this.pendingImages.reduce((m, i) => Math.max(m, i.seq), 0) + 1;
+      this.pendingImages.push({ seq, data: img.data, mime: img.mime });
+      this.insertAtCursor(imagePlaceholder(seq));
+    } finally {
+      this.imagePasteBusy = false;
+    }
+  }
+  cycleLevel() {
+    const idx = LEVELS.indexOf(this.level);
+    this.setLevel(LEVELS[(idx + 1) % LEVELS.length]);
+  }
+  setLevel(level) {
+    if (level === this.level) return;
+    this.level = level;
+    this.levelListeners.forEach((fn) => fn(this.level));
+    this.print(`${this.levelColor()}${levelLabel(this.level)}${C.reset}`);
+  }
+  // ─── bottom input line ───────────────────────────────────────────────────
+  /** Begin showing the persistent input line. */
+  start() {
+    this.started = true;
+    this.renderBottom();
+  }
+  /** Format an elapsed millisecond span as 45s / 2m 05s / 1h 05m. */
+  formatElapsed(ms) {
+    const s = Math.floor(ms / 1e3);
+    if (s < 60) return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60) return `${m}m ${String(s % 60).padStart(2, "0")}s`;
+    const h = Math.floor(m / 60);
+    return `${h}h ${String(m % 60).padStart(2, "0")}m`;
+  }
+  /** Compact token count: 945 → "945", 12345 → "12.35k", 1_250_000 → "1.25M". */
+  fmtTokens(n) {
+    if (n < 1e3) return String(n);
+    if (n < 1e6) return `${(n / 1e3).toFixed(2)}k`;
+    return `${(n / 1e6).toFixed(2)}M`;
+  }
+  spinnerFrame() {
+    return `${C.bold}${C.cyan}${FRAMES[Math.floor(Date.now() / 100) % FRAMES.length]}${C.reset}`;
+  }
+  /**
+   * "↑X ↓Y" cumulative token totals (greyed — low-priority), plus a context
+   * window gauge "ctx N%" when known. The gauge colour ramps with fill (green →
+   * yellow → red) so the user can see compaction approaching at a glance.
+   */
+  tokensText() {
+    const parts = [];
+    if (this.tokensIn > 0) parts.push(`\u2191${this.fmtTokens(this.tokensIn)}`);
+    if (this.tokensOut > 0) parts.push(`\u2193${this.fmtTokens(this.tokensOut)}`);
+    let out = parts.length ? `${C.gray}${parts.join(" ")}${C.reset}` : "";
+    if (this.contextPct != null) {
+      const pct = this.contextPct;
+      const calmGreen = "\x1B[38;5;65m";
+      const col = pct >= 85 ? C.red : pct >= 70 ? C.yellow : calmGreen;
+      const gauge = `${col}ctx ${pct}%${C.reset}`;
+      out = out ? `${out} ${gauge}` : gauge;
+    }
+    return out;
+  }
+  /**
+   * Set the context-window fill percentage (0–100), or null to hide it.
+   * Driven by the runtime's `context_usage` KV (latest request input tokens ÷
+   * model context window).
+   */
+  setContextPct(pct) {
+    const next = pct == null ? null : Math.max(0, Math.min(100, Math.round(pct)));
+    if (next === this.contextPct) return;
+    this.contextPct = next;
+    this.renderBottom();
+  }
+  /** Plain "ctx N%" label (no ANSI) for menu hints, or "" when unknown. */
+  contextPctLabel() {
+    return this.contextPct == null ? "" : `ctx ${this.contextPct}%`;
+  }
+  /** Register the slash commands shown in the inline `/` palette. */
+  setCommands(commands) {
+    this.commands = commands;
+  }
+  /** Is the `/` command palette currently showing? (input starts with "/".) */
+  paletteOpen() {
+    return this.started && !this.takeoverHandler && this.commands.length > 0 && this.inputBuffer.startsWith("/");
+  }
+  /** Commands matching the text typed after "/", in declared order. */
+  filteredCommands() {
+    if (!this.inputBuffer.startsWith("/")) return [];
+    const q = this.inputBuffer.slice(1).trim().toLowerCase();
+    if (q === "") return this.commands;
+    return this.commands.filter(
+      (c2) => c2.name.startsWith(q) || c2.name.includes(q) || c2.label.toLowerCase().includes(q)
+    );
+  }
+  runCommand(cmd) {
+    this.inputBuffer = "";
+    this.cursorPos = 0;
+    this.slashIdx = 0;
+    this.renderBottom();
+    void Promise.resolve(cmd.run()).catch(() => {
+    });
+  }
+  /**
+   * The summary line ABOVE the prompt. While working it reads
+   * `⣷ Working <step> <elapsed> ↑in ↓out`; when idle it keeps the cumulative
+   * token totals visible (`↑in ↓out`) so they live in the summary rather than
+   * crowding the prompt. Null when idle with nothing counted yet.
+   */
+  statusLineText(cols2) {
+    const tk = this.tokensText();
+    if (this.working) {
+      const el = this.formatElapsed(Date.now() - this.workingStart);
+      const right = `${C.dim}${el}${C.reset}${tk ? " " + tk : ""}`;
+      const head = `${this.spinnerFrame()} ${C.bold}Working${C.reset}`;
+      const avail = Math.max(0, cols2 - this.visibleWidth(head) - this.visibleWidth(right) - 2);
+      let stepPart = "";
+      if (this.step && avail > 1) {
+        let s = this.step;
+        if (s.length > avail) s = s.slice(0, avail - 1) + "\u2026";
+        stepPart = ` ${C.dim}${s}${C.reset}`;
+      }
+      return `${head}${stepPart} ${right}`;
+    }
+    if (this.goalComplete) {
+      const done = `${C.bold}${C.green}\u2713 Goal complete.${C.reset}`;
+      return tk ? `${done} ${tk}` : done;
+    }
+    return tk ? tk : null;
+  }
+  /** The prompt line prefix (with ANSI colour) that precedes the typed text. */
+  promptPrefix() {
+    const q = this.queuedCount > 0 ? `${C.yellow}[\u23F3 ${this.queuedCount} queued]${C.reset} ` : "";
+    const bg = this.bgCount > 0 ? `${C.cyan}[\u2699 ${this.bgCount} bg]${C.reset} ` : "";
+    return `${q}${bg}${this.levelColor()}\u276F${C.reset} `;
+  }
+  visibleWidth(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+  }
+  /**
+   * The slash-palette block rendered BELOW the input. While the palette is open
+   * we reserve a fixed number of rows — one per available command — padding with
+   * blank rows so the region height never changes as the filter narrows. That
+   * pins the input: the region scrolls into place once when the palette opens,
+   * then nothing below the input resizes, so the text you're typing never jumps.
+   * Returns `[]` when the palette is closed (no reservation, input sits at the
+   * bottom as usual).
+   */
+  paletteBlockLines(cols2) {
+    if (!this.paletteOpen()) return [];
+    const rows = this.paletteLines(cols2);
+    const reserved = Math.max(this.commands.length, rows.length);
+    while (rows.length < reserved) rows.push("");
+    return rows;
+  }
+  /**
+   * Build the slash-palette rows for the current filter. Each row is clamped to
+   * ONE physical line (a wrapped row would desync the move-up redraw), with the
+   * `/name` highlighted, the label dimmed, and the hint right-aligned.
+   */
+  paletteLines(cols2) {
+    if (!this.paletteOpen()) return [];
+    const matches = this.filteredCommands();
+    if (matches.length === 0) return [`  ${C.gray}no matching command${C.reset}`];
+    const cur = Math.min(this.slashIdx, matches.length - 1);
+    const pointerW = 2;
+    return matches.map((cmd, i) => {
+      const sel = i === cur;
+      const hint = (typeof cmd.hint === "function" ? cmd.hint() : cmd.hint) ?? "";
+      const hintW = hint.length;
+      const name = `/${cmd.name}`;
+      let visible = `${name}  ${cmd.label}`;
+      const labelMax = Math.max(6, cols2 - pointerW - (hintW ? hintW + 2 : 0));
+      if (visible.length > labelMax) visible = visible.slice(0, labelMax - 1) + "\u2026";
+      const desc = visible.slice(name.length);
+      const pointer = sel ? `${C.magenta}\u276F${C.reset} ` : "  ";
+      const nameStyled = sel ? `${C.bold}${C.cyan}${name}${C.reset}` : `${C.cyan}${name}${C.reset}`;
+      let line = `${pointer}${nameStyled}${C.gray}${desc}${C.reset}`;
+      if (hintW) {
+        const gap = Math.max(2, cols2 - pointerW - visible.length - hintW);
+        line += `${" ".repeat(gap)}${C.gray}${hint}${C.reset}`;
+      }
+      return line;
+    });
+  }
+  /**
+   * Move the cursor to the top-left of the current bottom region.
+   *
+   * Same width as the last draw → the caret's recorded row offset is exact.
+   * Width CHANGED (terminal resized) → previously drawn rows re-wrapped, so
+   * that offset is stale; recompute it under the new wrap instead: each drawn
+   * HUD row of visible width w now occupies ceil(w / cols) physical rows
+   * (reflowing terminals re-wrap hard lines; the cursor follows its logical
+   * position in the input text, which inputLayout locates at the new width).
+   */
+  moveToRegionTop() {
+    process.stdout.write("\r");
+    if (!this.bottomDrawn) return;
+    const cols2 = process.stdout.columns || 80;
+    let up;
+    if (cols2 !== this.lastDrawnCols && this.lastDrawnCols > 0) {
+      let above = 0;
+      for (const w of this.drawnHudWidths) above += Math.max(1, Math.ceil(Math.max(w, 1) / cols2));
+      up = above + this.inputLayout().caretRow;
+    } else {
+      up = this.lastCursorRow;
+    }
+    if (up > 0) process.stdout.write(`\x1B[${up}A`);
+  }
+  /**
+   * Render the bottom region: an optional step line, then the prompt + input
+   * (wrapping across as many rows as needed), with the caret placed at cursorPos.
+   * Uses only relative cursor moves so it survives terminal scrolling when the
+   * region grows near the bottom of the screen.
+   */
+  renderBottom() {
+    if (!this.started || this.takeoverHandler) return;
+    const cols2 = process.stdout.columns || 80;
+    this.moveToRegionTop();
+    process.stdout.write("\x1B[J");
+    const hudWidths = [];
+    const writeHudRow = (line) => {
+      hudWidths.push(this.visibleWidth(line));
+      process.stdout.write(line + "\r\n");
+    };
+    const previewLines = this.streamPreviewLines(cols2);
+    for (const line of previewLines) writeHudRow(line);
+    const rulerRows = 1;
+    writeHudRow(`${C.dim}${"\u2500".repeat(cols2)}${C.reset}`);
+    const noticeLine = this.connected ? null : `${C.yellow}\u26A0 lost connection to the workspace \u2014 reconnecting\u2026${C.reset}`;
+    const noticeRows = noticeLine ? 1 : 0;
+    if (noticeLine) writeHudRow(noticeLine);
+    const quitLine = this.quitArmed ? `${C.dim}Press Control-C again to exit${C.reset}` : null;
+    const quitRows = quitLine ? 1 : 0;
+    if (quitLine) writeHudRow(quitLine);
+    const frame = FRAMES[Math.floor(Date.now() / 100) % FRAMES.length];
+    for (const sub of this.subagents) {
+      const color = sub.agentName === COMPACTION_AGENT ? COMPACTION_COLOR : SUBAGENT_COLORS[this.subagentColorByID.get(sub.id) ?? 0];
+      const budget = cols2 - 10;
+      let label = sub.label;
+      if (budget < 1) label = "";
+      else if (label.length > budget) label = label.slice(0, Math.max(0, budget - 1)) + "\u2026";
+      const line = `${color}${frame}${C.reset} ${color}${label}${C.reset} ${C.dim}working${C.reset}`;
+      writeHudRow(line);
+    }
+    const statusLine = this.statusLineText(cols2);
+    const statusRows = statusLine ? 1 : 0;
+    if (statusLine) writeHudRow(statusLine);
+    const goalLines = this.goalLines(cols2);
+    for (const line of goalLines) writeHudRow(line);
+    const aboveRows = previewLines.length + rulerRows + noticeRows + quitRows + this.subagents.length + statusRows + goalLines.length;
+    const prefix = this.promptPrefix();
+    const pw = this.visibleWidth(prefix);
+    const lines = this.inputBuffer.split("\n");
+    process.stdout.write(prefix + lines[0]);
+    for (let i = 1; i < lines.length; i++) process.stdout.write("\r\n" + lines[i]);
+    const rowsOf = (len, lead) => Math.max(1, Math.ceil((lead + len) / cols2));
+    const lineRows = lines.map((l, i) => rowsOf(l.length, i === 0 ? pw : 0));
+    const inputRows = lineRows.reduce((a, b) => a + b, 0);
+    let pos = this.cursorPos;
+    let caretLine = 0;
+    while (caretLine < lines.length - 1 && pos > lines[caretLine].length) {
+      pos -= lines[caretLine].length + 1;
+      caretLine++;
+    }
+    const caretCell = (caretLine === 0 ? pw : 0) + pos;
+    let caretRow = Math.floor(caretCell / cols2);
+    for (let i = 0; i < caretLine; i++) caretRow += lineRows[i];
+    const caretCol = caretCell % cols2;
+    const paletteBlock = this.paletteBlockLines(cols2);
+    for (const line of paletteBlock) process.stdout.write("\r\n" + line);
+    if (paletteBlock.length > 0) {
+      process.stdout.write("\r");
+      const up = inputRows - 1 + paletteBlock.length - caretRow;
+      if (up > 0) process.stdout.write(`\x1B[${up}A`);
+      if (caretCol > 0) process.stdout.write(`\x1B[${caretCol}C`);
+      this.lastCursorRow = aboveRows + caretRow;
+    } else if (this.cursorPos < this.inputBuffer.length) {
+      process.stdout.write("\r");
+      const up = inputRows - 1 - caretRow;
+      if (up > 0) process.stdout.write(`\x1B[${up}A`);
+      if (caretCol > 0) process.stdout.write(`\x1B[${caretCol}C`);
+      this.lastCursorRow = aboveRows + caretRow;
+    } else {
+      this.lastCursorRow = aboveRows + (inputRows - 1);
+    }
+    this.drawnHudWidths = hudWidths;
+    this.lastDrawnCols = cols2;
+    this.bottomDrawn = true;
+  }
+  clearBottom() {
+    if (!this.bottomDrawn) return;
+    this.moveToRegionTop();
+    process.stdout.write("\x1B[J");
+    this.bottomDrawn = false;
+  }
+  // ── live streaming preview ────────────────────────────────────────────────
+  // An ephemeral tail of the model's output above the status line: reasoning in
+  // dim italic until the answer begins, then the answer plain. clearStream()
+  // wipes it right before the finished message is committed to the transcript
+  // (which renders full markdown), so there's no double-render.
+  static STREAM_TAIL = 20;
+  // How long a preview may sit untouched before it's wiped. The model often
+  // reasons and then calls a tool without ever emitting an answer, so without
+  // this the reasoning tail would linger on screen until the *next* thought (or
+  // message) arrives. Re-armed on every delta → fires this long after the last.
+  static STREAM_IDLE_MS = 1e4;
+  /** Append a fragment of streamed answer text (rendered plain). */
+  streamResponseDelta(delta, messageId) {
+    this.beginStreamMessage(messageId);
+    this.streamResponse += delta;
+    this.scheduleStreamRedraw();
+    this.armStreamIdleExpiry();
+  }
+  /**
+   * Append a fragment of streamed internal reasoning (rendered dim italic).
+   * Ignored once the answer has started, since reasoning precedes the answer.
+   */
+  streamThinkingDelta(delta, messageId) {
+    this.beginStreamMessage(messageId);
+    if (this.streamResponse) return;
+    this.streamThinking += delta;
+    this.scheduleStreamRedraw();
+    this.armStreamIdleExpiry();
+  }
+  /** Reset the preview when a new message starts, so two messages' output (e.g.
+   *  one that only reasons then calls a tool, then the next) never blend. */
+  beginStreamMessage(messageId) {
+    if (messageId !== void 0 && messageId !== this.streamMessageId) {
+      this.streamMessageId = messageId;
+      this.streamThinking = "";
+      this.streamResponse = "";
+    }
+  }
+  /** Wipe the live preview — call right before committing the final message. */
+  clearStream() {
+    if (this.streamRedrawTimer) {
+      clearTimeout(this.streamRedrawTimer);
+      this.streamRedrawTimer = null;
+    }
+    if (this.streamIdleTimer) {
+      clearTimeout(this.streamIdleTimer);
+      this.streamIdleTimer = null;
+    }
+    this.streamMessageId = null;
+    if (!this.streamThinking && !this.streamResponse) return;
+    this.streamThinking = "";
+    this.streamResponse = "";
+    this.renderBottom();
+  }
+  scheduleStreamRedraw() {
+    if (this.streamRedrawTimer || this.takeoverHandler || !this.started) return;
+    this.streamRedrawTimer = setTimeout(() => {
+      this.streamRedrawTimer = null;
+      this.renderBottom();
+    }, 40);
+  }
+  /** Re-armed on every streamed delta: once the model goes quiet for a beat, the
+   *  preview is stale, so wipe it instead of letting it sit until the next
+   *  message. The committed message (if any) still renders in full via
+   *  clearStream(), so nothing is lost. */
+  armStreamIdleExpiry() {
+    if (this.streamIdleTimer) clearTimeout(this.streamIdleTimer);
+    this.streamIdleTimer = setTimeout(() => {
+      this.streamIdleTimer = null;
+      if (!this.streamThinking && !this.streamResponse) return;
+      this.streamThinking = "";
+      this.streamResponse = "";
+      this.renderBottom();
+    }, _Tui.STREAM_IDLE_MS);
+  }
+  /**
+   * The preview's physical rows: a tail of reasoning (dim italic) before the
+   * answer starts, otherwise a tail of the answer (plain). Each row is clamped to
+   * one terminal line so the bottom-region redraw math stays correct.
+   *
+   * Rows match the committed transcript formatting so a finished message doesn't
+   * visibly "snap" into shape: the answer's first line carries the grey gutter
+   * dot (as long as it hasn't scrolled out of the tail) and the body indents two
+   * spaces beneath it; reasoning aligns at the same indent, dotless.
+   */
+  streamPreviewLines(cols2) {
+    const thinkStyle = "\x1B[3m\x1B[38;5;240m";
+    const clamp2 = (s, wrap, lead) => {
+      const max = cols2 - 2;
+      const t = s.length > max ? s.slice(0, Math.max(0, max - 1)) + "\u2026" : s;
+      return wrap ? `${lead}${wrap}${t}${C.reset}` : `${lead}${t}`;
+    };
+    const realLines = (text) => text.replace(/\r/g, "").split("\n").filter((l) => l.trim() !== "");
+    if (this.streamResponse) {
+      const all = realLines(this.streamResponse);
+      const shown = all.slice(-20);
+      const firstVisible = all.length <= _Tui.STREAM_TAIL;
+      return shown.map(
+        (l, i) => clamp2(l, "", i === 0 && firstVisible ? `${C.gray}\u2022${C.reset} ` : "  ")
+      );
+    }
+    if (this.streamThinking) {
+      return realLines(this.streamThinking).slice(-20).map((l) => clamp2(l, thinkStyle, "  "));
+    }
+    return [];
+  }
+  // ── live goal checklist ───────────────────────────────────────────────────
+  /**
+   * Update the goal from the goal_updated event (or the initial fetch). When
+   * every step is done, the goal is fully achieved: we clear the goal area and
+   * flip on the "Goal complete." status badge instead of leaving a finished
+   * checklist sitting there.
+   */
+  setGoal(goal) {
+    const steps = goal?.steps;
+    if (steps && Array.isArray(steps) && steps.length) {
+      const allDone = steps.every((s) => s.status === "done");
+      if (allDone) {
+        this.goal = null;
+        this.goalComplete = true;
+      } else {
+        this.goal = goal;
+        this.goalComplete = false;
+      }
+    } else {
+      this.goal = null;
+    }
+    this.renderBottom();
+  }
+  /**
+   * The goal's physical rows: a header (the short summary + progress) then one
+   * row per step, indented two spaces beneath it so the todos clearly belong to
+   * the goal — ○ pending / ▸ in-progress / ✓ done — each clamped to a line.
+   */
+  goalLines(cols2) {
+    const steps = this.goal?.steps;
+    if (!steps?.length) return [];
+    const oneLine = (s) => s.replace(/\s+/g, " ").trim();
+    const clamp2 = (s, max) => s.length > max ? s.slice(0, Math.max(0, max - 1)) + "\u2026" : s;
+    const calmGreen = "\x1B[38;5;65m";
+    const out = [];
+    const done = steps.filter((s) => s.status === "done").length;
+    const summary = oneLine(this.goal?.summary || this.goal?.description || "Goal");
+    const prefix = `Goal ${done}/${steps.length} `;
+    const sum = clamp2(summary, Math.max(1, cols2 - prefix.length));
+    out.push(`${C.bold}Goal${C.reset} ${C.gray}${done}/${steps.length}${C.reset} ${sum}`);
+    for (const s of steps) {
+      const text = clamp2(oneLine(s.step || ""), Math.max(1, cols2 - 4));
+      if (s.status === "done") out.push(`  ${calmGreen}\u2713${C.reset} ${C.dim}${text}${C.reset}`);
+      else if (s.status === "in_progress") out.push(`  ${C.cyan}\u25B8${C.reset} ${text}`);
+      else out.push(`  ${C.gray}\u25CB ${text}${C.reset}`);
+    }
+    return out;
+  }
+  /**
+   * Transcript gutter: content starts at column 1, so the far-left column is a
+   * clean strip where only status glyphs (✓ ✗ ⛔ …) land — scanning down the
+   * left edge reads as a ledger of what happened. Lines already led by a
+   * gutter glyph or whitespace (indented blocks, the user-message bar) pass
+   * through untouched.
+   */
+  gutterize(text) {
+    return text.split("\n").map((line) => {
+      const plain = line.replace(/\x1b\[[0-9;]*m/g, "");
+      if (plain === "" || /^[\s✓✗⛔⚠⚙⚡⏳↪›❯◇─•]/.test(plain)) return line;
+      return " " + line;
+    }).join("\n");
+  }
+  /** Print a line of transcript above the persistent input. */
+  print(text) {
+    const line = this.gutterize(text);
+    if (this.takeoverHandler) {
+      this.bufferedPrints.push(line);
+      return;
+    }
+    this.clearBottom();
+    process.stdout.write(line + "\n");
+    this.renderBottom();
+  }
+  /** Multi-line convenience. */
+  printLines(lines) {
+    for (const l of lines) this.print(l);
+  }
+  /**
+   * Print a user message as a highlighted block so it stands out in the
+   * transcript (à la Codex). The bar is sized to the text (not full width, which
+   * would wrap awkwardly), padded with a space on each side and a blank line
+   * above and below, and a teal `›` marks the first row.
+   */
+  printUserMessage(text) {
+    const cols2 = Math.max(20, process.stdout.columns || 80);
+    const bg = "\x1B[48;5;238m";
+    const limit = Math.max(8, cols2 - 6);
+    const words = text.replace(/\s+/g, " ").trim().split(" ");
+    const lines = [];
+    let cur = "";
+    for (let w of words) {
+      while (w.length > limit) {
+        if (cur) {
+          lines.push(cur);
+          cur = "";
+        }
+        lines.push(w.slice(0, limit));
+        w = w.slice(limit);
+      }
+      if (!cur) cur = w;
+      else if (cur.length + 1 + w.length <= limit) cur += " " + w;
+      else {
+        lines.push(cur);
+        cur = w;
+      }
+    }
+    if (cur || !lines.length) lines.push(cur);
+    const innerW = 2 + Math.max(...lines.map((l) => l.length));
+    this.print("");
+    lines.forEach((line, i) => {
+      const rowText = (i === 0 ? "\u276F " : "  ") + line;
+      const padded = rowText.padEnd(innerW);
+      const inner = i === 0 ? `${C.teal}\u276F${C.reset}${bg}${padded.slice(1)}` : padded;
+      this.print(`${bg} ${inner} ${C.reset}`);
+    });
+    this.print("");
+  }
+  // ─── working indicator (turn state) ───────────────────────────────────────
+  setWorking(on) {
+    if (on && !this.working) {
+      this.working = true;
+      this.workingStart = Date.now();
+      this.goalComplete = false;
+    } else if (!on) {
+      this.working = false;
+    }
+    this.syncSpinner();
+    this.renderBottom();
+  }
+  /** The subagents currently working, one persistent line each. Each keeps a
+   *  stable, distinct colour for as long as it's active; the compaction agent
+   *  is always orange (its colour never comes from the shared pool). */
+  setSubagents(subagents) {
+    this.subagents = subagents;
+    const active = new Set(subagents.map((s) => s.id));
+    for (const id of [...this.subagentColorByID.keys()]) {
+      if (!active.has(id)) this.subagentColorByID.delete(id);
+    }
+    for (const s of subagents) {
+      if (s.agentName === COMPACTION_AGENT) continue;
+      if (this.subagentColorByID.has(s.id)) continue;
+      const used = new Set(this.subagentColorByID.values());
+      let idx = 0;
+      while (used.has(idx) && idx < SUBAGENT_COLORS.length - 1) idx++;
+      this.subagentColorByID.set(s.id, idx);
+    }
+    this.syncSpinner();
+    this.renderBottom();
+  }
+  /** Run the spinner animation while anything (the agent or a subagent) is active. */
+  syncSpinner() {
+    const spinning = this.working || this.subagents.length > 0;
+    if (spinning && !this.spinnerTimer) {
+      this.spinnerTimer = setInterval(() => this.renderBottom(), 100);
+    } else if (!spinning && this.spinnerTimer) {
+      clearInterval(this.spinnerTimer);
+      this.spinnerTimer = null;
+    }
+  }
+  get isWorking() {
+    return this.working;
+  }
+  setBackgroundCount(n) {
+    this.bgCount = n;
+    this.renderBottom();
+  }
+  setQueuedCount(n) {
+    this.queuedCount = n;
+    this.renderBottom();
+  }
+  setConnected(connected) {
+    this.connected = connected;
+    this.renderBottom();
+  }
+  // ─── input buffer access (for up-arrow editing of queued messages) ─────────
+  getInput() {
+    return this.inputBuffer;
+  }
+  /** Replace the input (and any pasted images tied to placeholders in it). */
+  setInput(text, images = []) {
+    this.inputBuffer = text;
+    this.cursorPos = text.length;
+    this.pendingImages = images;
+    this.historyIdx = null;
+    this.renderBottom();
+  }
+  /** Cumulative token totals shown on the prompt line (`outTokens` includes live). */
+  setTokens(inTokens, outTokens) {
+    this.tokensIn = inTokens;
+    this.tokensOut = outTokens;
+    this.renderBottom();
+  }
+  /**
+   * Current step the agent is working on, shown on the line above the prompt.
+   * `outTokens` is the output produced during this step. The step's own timer
+   * resets whenever the label changes.
+   */
+  setStep(label, outTokens) {
+    const next = label && label.trim() ? label.trim() : null;
+    if (next !== this.step) {
+      this.step = next;
+      this.stepStart = Date.now();
+    }
+    this.stepOut = outTokens;
+    this.renderBottom();
+  }
+  // ─── takeover helpers (approval / menus) ───────────────────────────────────
+  beginTakeover() {
+    this.clearBottom();
+    process.stdout.write("\r\x1B[K");
+    process.stdout.write("\x1B[?25l");
+    this.bottomDrawn = false;
+  }
+  endTakeover() {
+    this.takeoverHandler = null;
+    process.stdout.write("\x1B[?25h");
+    const buffered = this.bufferedPrints;
+    this.bufferedPrints = [];
+    for (const t of buffered) {
+      process.stdout.write(t + "\n");
+    }
+    this.renderBottom();
+  }
+  /** Approval prompt: arrow-navigable with y/a/l/n shortcuts. Pauses input.
+   * Tab resolves "deny_with_reason" so the caller can collect a free-text reason. */
+  approval(question, risk) {
+    return new Promise((resolve) => {
+      const options = [
+        { value: "allow", label: "Allow once", shortcut: "y", color: C.green },
+        { value: "always", label: "Always allow this tool", shortcut: "a", color: C.cyan },
+        { value: "always_risk", label: `Allow all level ${risk} this session`, shortcut: "l", color: C.cyan },
+        { value: "deny", label: "Deny", shortcut: "n", color: C.red }
+      ];
+      let idx = 0;
+      const riskBar = `${C.red}${"\u25CF".repeat(risk)}${C.gray}${"\u25CB".repeat(5 - risk)}${C.reset}`;
+      this.beginTakeover();
+      const cols2 = Math.max(1, process.stdout.columns || 80);
+      const physRows = (line) => Math.max(1, Math.ceil(this.visibleWidth(line) / cols2));
+      const headerText = `${C.yellow}\u2503${C.reset} ${C.bold}Permission needed${C.reset}  risk ${riskBar}`;
+      const questionLines = question.split("\n").map((line) => `${C.yellow}\u2503${C.reset} ${line}`);
+      const hintLine = `${C.yellow}\u2503${C.reset} ${C.gray}\u21E5 tab \u2014 deny with a reason${C.reset}`;
+      const blockLines = [headerText, ...questionLines, hintLine];
+      const headerRows = 1 + blockLines.reduce((n, line) => n + physRows(line), 0);
+      process.stdout.write(`
+` + blockLines.map((line) => `${line}
+`).join(""));
+      const renderLine = (i) => {
+        const o = options[i];
+        const sel = i === idx;
+        const pointer = sel ? `${o.color}\u276F${C.reset}` : " ";
+        const label = sel ? `${C.bold}${o.label}${C.reset}` : o.label;
+        return `${C.yellow}\u2503${C.reset} ${pointer} ${label} ${C.gray}(${o.shortcut})${C.reset}`;
+      };
+      const draw = (moveUp) => {
+        if (moveUp) process.stdout.write(`\x1B[${options.length}A`);
+        for (let i = 0; i < options.length; i++) process.stdout.write(`\r\x1B[K${renderLine(i)}
+`);
+      };
+      draw(false);
+      const erase = () => {
+        process.stdout.write("\r");
+        const up = headerRows + options.length;
+        if (up > 0) process.stdout.write(`\x1B[${up}A`);
+        process.stdout.write("\x1B[J");
+      };
+      const finish = (choice) => {
+        erase();
+        this.endTakeover();
+        resolve(choice);
+      };
+      this.takeoverHandler = (str, key) => {
+        if (key?.name === "up" || str === "k") {
+          idx = (idx - 1 + options.length) % options.length;
+          draw(true);
+        } else if (key?.name === "down" || str === "j") {
+          idx = (idx + 1) % options.length;
+          draw(true);
+        } else if (key?.name === "tab") {
+          finish("deny_with_reason");
+        } else if (key?.name === "return" || key?.name === "enter") {
+          finish(options[idx].value);
+        } else {
+          const k = (str || "").toLowerCase();
+          if (k === "y") finish("allow");
+          else if (k === "a") finish("always");
+          else if (k === "l") finish("always_risk");
+          else if (k === "n" || key?.name === "escape") finish("deny");
+        }
+      };
+    });
+  }
+  /** Arrow-key selection menu (slash menu, process menu, resume). Pauses input. */
+  select(title, items) {
+    return new Promise((resolve) => {
+      let idx = 0;
+      this.beginTakeover();
+      if (title) process.stdout.write(`
+${title}
+
+`);
+      const renderLine = (i) => {
+        const w = process.stdout.columns || 80;
+        const it = items[i];
+        const sel = i === idx;
+        const hint = it.hint ?? "";
+        const hintW = hint.length;
+        const pointerW = 2;
+        const labelMax = Math.max(6, w - 2 - pointerW - (hintW ? hintW + 2 : 0));
+        let label = it.label;
+        if (label.length > labelMax) label = label.slice(0, labelMax - 1) + "\u2026";
+        const pointer = sel ? `${C.magenta}\u276F${C.reset} ` : "  ";
+        const styledLabel = sel ? `${C.bold}${C.cyan}${label}${C.reset}` : label;
+        let line = `${pointer}${styledLabel}`;
+        if (hintW) {
+          const gap = Math.max(2, w - 2 - pointerW - label.length - hintW);
+          line += `${" ".repeat(gap)}${C.gray}${hint}${C.reset}`;
+        }
+        return line;
+      };
+      const draw = (moveUp) => {
+        if (moveUp) process.stdout.write(`\x1B[${items.length}A`);
+        for (let i = 0; i < items.length; i++) process.stdout.write(`\r\x1B[K${renderLine(i)}
+`);
+      };
+      draw(false);
+      const titleRows = title ? 3 : 0;
+      const erase = () => {
+        process.stdout.write("\r");
+        const up = titleRows + items.length;
+        if (up > 0) process.stdout.write(`\x1B[${up}A`);
+        process.stdout.write("\x1B[J");
+      };
+      const close = (value) => {
+        erase();
+        this.endTakeover();
+        resolve(value);
+      };
+      this.takeoverHandler = (str, key) => {
+        if (!key) return;
+        if (key.name === "up" || str === "k") {
+          idx = (idx - 1 + items.length) % items.length;
+          draw(true);
+        } else if (key.name === "down" || str === "j") {
+          idx = (idx + 1) % items.length;
+          draw(true);
+        } else if (key.name === "return" || key.name === "enter") {
+          close(items[idx].value);
+        } else if (key.name === "escape") {
+          close(void 0);
+        }
+      };
+    });
+  }
+  /**
+   * Free-text prompt (single line). Pauses the main input and reads a line —
+   * used where a menu can't, e.g. entering an MCP server command. Enter submits,
+   * Escape (or empty submit) cancels with null.
+   */
+  prompt(question, placeholder = "") {
+    return new Promise((resolve) => {
+      let buf = "";
+      this.beginTakeover();
+      process.stdout.write("\x1B[?25h");
+      process.stdout.write(`
+${C.cyan}\u2503${C.reset} ${question}
+`);
+      if (placeholder) process.stdout.write(`${C.gray}\u2503 e.g. ${placeholder}${C.reset}
+`);
+      const draw = () => {
+        process.stdout.write(`\r\x1B[K${C.cyan}\u2503${C.reset} ${C.bold}\u203A${C.reset} ${buf}`);
+      };
+      draw();
+      const finish = (value) => {
+        process.stdout.write("\n");
+        this.endTakeover();
+        resolve(value);
+      };
+      this.takeoverHandler = (str, key) => {
+        if (key?.name === "escape") return finish(null);
+        if (key?.name === "return" || key?.name === "enter") return finish(buf.trim() || null);
+        if (key?.name === "backspace") {
+          buf = buf.slice(0, -1);
+          draw();
+          return;
+        }
+        if (str && !key?.ctrl && !key?.meta && str >= " ") {
+          buf += str;
+          draw();
+        }
+      };
+    });
+  }
+  banner(lines) {
+    this.clearBottom();
+    process.stdout.write("\n");
+    for (const l of lines) process.stdout.write(l + "\n");
+  }
+};
+
+// src/history.ts
+var HISTORY_KEY = "input_history";
+var MAX_ENTRIES = 100;
+function clean(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((e) => typeof e === "string" && e.trim() !== "").slice(-MAX_ENTRIES);
+}
+async function loadHistory(store, threadId, seedThreadId) {
+  const own = clean(await store.kvGet(threadId, HISTORY_KEY));
+  if (own.length) return own;
+  if (seedThreadId && seedThreadId !== threadId) {
+    const seeded = clean(await store.kvGet(seedThreadId, HISTORY_KEY));
+    if (seeded.length) {
+      void store.kvSet(threadId, HISTORY_KEY, seeded);
+      return seeded;
+    }
+  }
+  return [];
+}
+function appendHistory(store, threadId, history, text) {
+  const t = text.trim();
+  if (!t || history[history.length - 1] === t) return history;
+  history.push(t);
+  if (history.length > MAX_ENTRIES) history.splice(0, history.length - MAX_ENTRIES);
+  void store.kvSet(threadId, HISTORY_KEY, [...history]);
+  return history;
+}
+
+// src/markdown.ts
+var ESC = "\x1B[";
+var R = ESC + "0m";
+var BOLD = ESC + "1m";
+var DIM2 = ESC + "2m";
+var ITAL = ESC + "3m";
+var UNDER = ESC + "4m";
+var TEAL = ESC + "38;5;37m";
+var CYAN = ESC + "36m";
+var GRAY = ESC + "90m";
+var ANSI = /\x1b\[[0-9;]*m/g;
+function visibleWidth(s) {
+  return s.replace(ANSI, "").length;
+}
+function padEndVisible(s, width) {
+  const pad = width - visibleWidth(s);
+  return pad > 0 ? s + " ".repeat(pad) : s;
+}
+function inline(s) {
+  const codes = [];
+  s = s.replace(/`([^`]+)`/g, (_, code) => {
+    codes.push(code);
+    return "\0" + (codes.length - 1) + "\0";
+  });
+  s = s.replace(
+    /\[([^\]]+)\]\(([^)\s]+)\)/g,
+    (_, text, url) => `${CYAN}${UNDER}${text}${R} ${DIM2}${url}${R}`
+  );
+  s = s.replace(/\*\*([^*]+)\*\*/g, (_, t) => `${BOLD}${t}${R}`);
+  s = s.replace(/\*([^*\n]+)\*/g, (_, t) => `${ITAL}${t}${R}`);
+  s = s.replace(/~~([^~]+)~~/g, (_, t) => `${DIM2}${t}${R}`);
+  s = s.replace(/\x00(\d+)\x00/g, (_, i) => `${TEAL}${codes[+i].replace(/ /g, String.fromCharCode(160))}${R}`);
+  return s;
+}
+function wrapStyled(text, width) {
+  if (width < 4 || visibleWidth(text) <= width) return [text];
+  const words = text.split(" ");
+  const lines = [];
+  let cur = "";
+  let curLen = 0;
+  for (const w of words) {
+    const wLen = visibleWidth(w);
+    if (cur === "") {
+      cur = w;
+      curLen = wLen;
+    } else if (curLen + 1 + wLen <= width) {
+      cur += " " + w;
+      curLen += 1 + wLen;
+    } else {
+      lines.push(cur);
+      cur = w;
+      curLen = wLen;
+    }
+  }
+  if (cur !== "" || lines.length === 0) lines.push(cur);
+  return lines;
+}
+function wrapBlock(out, cols2, leadFirst, leadRest, leadWidth, text) {
+  const wrapped = wrapStyled(text, Math.max(8, cols2 - leadWidth));
+  wrapped.forEach((ln, idx) => out.push((idx === 0 ? leadFirst : leadRest) + ln));
+}
+function tableCells(row) {
+  let r = row.trim();
+  if (r.startsWith("|")) r = r.slice(1);
+  if (r.endsWith("|")) r = r.slice(0, -1);
+  return r.split("|").map((c2) => c2.trim());
+}
+var SEPARATOR = /^[\s|:-]+$/;
+function isTableSeparator(line) {
+  return SEPARATOR.test(line) && line.includes("-") && line.includes("|");
+}
+function renderTable(rows) {
+  const cols2 = Math.max(...rows.map((r) => r.length));
+  const widths = [];
+  for (let c2 = 0; c2 < cols2; c2++) {
+    widths[c2] = Math.max(...rows.map((r) => visibleWidth(inline(r[c2] ?? ""))));
+  }
+  const sep = `${GRAY} \u2502 ${R}`;
+  const out = [];
+  rows.forEach((r, ri) => {
+    const cells = [];
+    for (let c2 = 0; c2 < cols2; c2++) {
+      const raw = r[c2] ?? "";
+      const styled = ri === 0 ? `${BOLD}${inline(raw)}${R}` : inline(raw);
+      cells.push(padEndVisible(styled, widths[c2]));
+    }
+    out.push(("  " + cells.join(sep)).replace(/\s+$/, ""));
+    if (ri === 0) {
+      const rule = widths.map((w) => `${GRAY}${"\u2500".repeat(w)}${R}`).join(`${GRAY}\u2500\u253C\u2500${R}`);
+      out.push("  " + rule);
+    }
+  });
+  return out;
+}
+function renderMarkdown(src, cols2 = 80) {
+  const lines = src.replace(/\r\n/g, "\n").split("\n");
+  const out = [];
+  let inFence = false;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (/^\s*```/.test(line)) {
+      inFence = !inFence;
+      i++;
+      continue;
+    }
+    if (inFence) {
+      out.push(`${GRAY}\u2502${R} ${line}`);
+      i++;
+      continue;
+    }
+    if (line.includes("|") && i + 1 < lines.length && isTableSeparator(lines[i + 1])) {
+      const block = [tableCells(line)];
+      i += 2;
+      while (i < lines.length && lines[i].includes("|") && lines[i].trim()) {
+        block.push(tableCells(lines[i]));
+        i++;
+      }
+      out.push(...renderTable(block));
+      continue;
+    }
+    const heading = line.match(/^(#{1,6})\s+(.*)$/);
+    if (heading) {
+      for (const ln of wrapStyled(heading[2].trim(), cols2)) out.push(`${BOLD}${TEAL}${ln}${R}`);
+      i++;
+      continue;
+    }
+    if (/^\s*([-*_])(\s*\1){2,}\s*$/.test(line)) {
+      out.push(`${GRAY}\u2500\u2500\u2500\u2500\u2500\u2500${R}`);
+      i++;
+      continue;
+    }
+    const quote = line.match(/^\s*>\s?(.*)$/);
+    if (quote) {
+      for (const ln of wrapStyled(inline(quote[1]), Math.max(8, cols2 - 2))) {
+        out.push(`${GRAY}\u2502${R} ${DIM2}${ln}${R}`);
+      }
+      i++;
+      continue;
+    }
+    const bullet = line.match(/^(\s*)[-*+]\s+(.*)$/);
+    if (bullet) {
+      const leadWidth = bullet[1].length + 2;
+      wrapBlock(out, cols2, `${bullet[1]}${TEAL}\u2022${R} `, " ".repeat(leadWidth), leadWidth, inline(bullet[2]));
+      i++;
+      continue;
+    }
+    const numbered = line.match(/^(\s*)(\d+)([.)])\s+(.*)$/);
+    if (numbered) {
+      const marker = `${numbered[2]}${numbered[3]}`;
+      const leadWidth = numbered[1].length + marker.length + 1;
+      wrapBlock(out, cols2, `${numbered[1]}${BOLD}${marker}${R} `, " ".repeat(leadWidth), leadWidth, inline(numbered[4]));
+      i++;
+      continue;
+    }
+    if (line.trim()) wrapBlock(out, cols2, "", "", 0, inline(line));
+    else out.push("");
+    i++;
+  }
+  return out;
+}
+var MCP_PROTOCOL_VERSION = "2025-06-18";
+var SUPPORTED_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+var CLIENT_INFO = { name: "standard-code", version: "0.1.0" };
+var RPC_TIMEOUT_MS = 3e4;
+var INIT_TIMEOUT_MS = 9e4;
+var McpClient = class {
+  constructor(config) {
+    this.config = config;
+    this.serverInfo = { name: config.name };
+  }
+  config;
+  child = null;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  buffer = "";
+  closed = false;
+  serverInfo;
+  protocolVersion = MCP_PROTOCOL_VERSION;
+  capabilities = {};
+  instructions = "";
+  tools = [];
+  resources = [];
+  lastError = null;
+  /** Spawn the server, run the initialize handshake, and discover capabilities. */
+  async connect(defaultCwd) {
+    const child = spawn(this.config.command, this.config.args, {
+      cwd: this.config.cwd || defaultCwd,
+      env: { ...process.env, ...this.config.env || {} },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    child.on("error", (err) => this.failAll(new Error(`MCP server '${this.config.name}' failed to start: ${err.message}`)));
+    child.on("exit", (code) => {
+      if (!this.closed) this.failAll(new Error(`MCP server '${this.config.name}' exited (code ${code ?? "unknown"}).`));
+    });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => this.onData(chunk));
+    child.stderr.setEncoding("utf8");
+    let stderrTail = "";
+    child.stderr.on("data", (d) => {
+      stderrTail = (stderrTail + d).slice(-2e3);
+    });
+    try {
+      const initResult = await this.request(
+        "initialize",
+        {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: { tools: {}, resources: {} },
+          clientInfo: CLIENT_INFO
+        },
+        INIT_TIMEOUT_MS
+      );
+      const negotiated = initResult.protocolVersion || MCP_PROTOCOL_VERSION;
+      if (!SUPPORTED_PROTOCOL_VERSIONS.includes(negotiated)) {
+        throw new Error(
+          `Server requires unsupported MCP protocol version '${negotiated}' (this client speaks ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")}).`
+        );
+      }
+      this.protocolVersion = negotiated;
+      this.capabilities = initResult.capabilities || {};
+      this.serverInfo = initResult.serverInfo || { name: this.config.name };
+      this.instructions = initResult.instructions || "";
+      this.notify("notifications/initialized");
+      if (this.capabilities.tools) await this.refreshTools();
+      if (this.capabilities.resources) await this.refreshResources();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.lastError = stderrTail ? `${msg}
+${stderrTail.trim()}` : msg;
+      this.close();
+      throw new Error(this.lastError);
+    }
+  }
+  async refreshTools() {
+    const res = await this.request("tools/list", {});
+    this.tools = Array.isArray(res?.tools) ? res.tools : [];
+  }
+  async refreshResources() {
+    try {
+      const res = await this.request("resources/list", {});
+      this.resources = Array.isArray(res?.resources) ? res.resources : [];
+    } catch {
+      this.resources = [];
+    }
+  }
+  /** Call a tool and return its flattened text + a provenance attestation. */
+  async callTool(name, args) {
+    const res = await this.request("tools/call", { name, arguments: args });
+    const text = flattenContent(res?.content, res?.structuredContent);
+    return this.attest(name, args, text, !!res?.isError);
+  }
+  /** Read a resource and return its flattened text + attestation. */
+  async readResource(uri) {
+    const res = await this.request("resources/read", { uri });
+    const text = flattenResourceContents(res?.contents);
+    return this.attest(uri, { uri }, text, false);
+  }
+  attest(target, args, text, isError) {
+    const attestation = {
+      server: this.config.name,
+      serverInfo: this.serverInfo,
+      protocolVersion: this.protocolVersion,
+      target,
+      argsSha256: sha256(canonicalJson(args)),
+      resultSha256: sha256(text),
+      nonce: crypto.randomBytes(8).toString("hex"),
+      isError,
+      at: Date.now()
+    };
+    return { ok: !isError, text, attestation };
+  }
+  catalogEntry() {
+    return {
+      name: this.config.name,
+      status: this.lastError ? "error" : "connected",
+      serverInfo: this.serverInfo,
+      protocolVersion: this.protocolVersion,
+      instructions: this.instructions || void 0,
+      capabilities: this.capabilities,
+      tools: this.tools,
+      resources: this.resources,
+      error: this.lastError || void 0
+    };
+  }
+  close() {
+    this.closed = true;
+    this.failAll(new Error("connection closed"));
+    try {
+      this.child?.stdin.end();
+    } catch {
+    }
+    try {
+      this.child?.kill("SIGTERM");
+    } catch {
+    }
+    this.child = null;
+  }
+  // ── JSON-RPC plumbing ─────────────────────────────────────────────────────
+  request(method, params, timeoutMs = RPC_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+      if (!this.child || this.closed) {
+        reject(new Error(`MCP server '${this.config.name}' is not connected.`));
+        return;
+      }
+      const id = this.nextId++;
+      const payload = { jsonrpc: "2.0", id, method, params };
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP request '${method}' to '${this.config.name}' timed out after ${timeoutMs}ms.`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      this.write(payload);
+    });
+  }
+  notify(method, params) {
+    const payload = { jsonrpc: "2.0", method, params };
+    this.write(payload);
+  }
+  write(payload) {
+    if (!this.child) return;
+    try {
+      this.child.stdin.write(JSON.stringify(payload) + "\n");
+    } catch (err) {
+      this.failAll(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  onData(chunk) {
+    this.buffer += chunk;
+    let nl;
+    while ((nl = this.buffer.indexOf("\n")) >= 0) {
+      const line = this.buffer.slice(0, nl).trim();
+      this.buffer = this.buffer.slice(nl + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      this.dispatch(msg);
+    }
+  }
+  dispatch(msg) {
+    if (typeof msg.id === "number" && ("result" in msg || "error" in msg) && msg.method === void 0) {
+      const entry = this.pending.get(msg.id);
+      if (!entry) return;
+      this.pending.delete(msg.id);
+      clearTimeout(entry.timer);
+      if (msg.error) entry.reject(new Error(`${msg.error.message} (code ${msg.error.code})`));
+      else entry.resolve(msg.result);
+      return;
+    }
+    if (msg.method && typeof msg.id === "number") {
+      if (msg.method === "ping") {
+        this.write({ jsonrpc: "2.0", id: msg.id, result: {} });
+      } else {
+        this.write({
+          jsonrpc: "2.0",
+          id: msg.id,
+          error: { code: -32601, message: `Method not supported by host: ${msg.method}` }
+        });
+      }
+      return;
+    }
+    if (msg.method && msg.id === void 0) {
+      if (msg.method === "notifications/tools/list_changed") void this.refreshTools().catch(() => {
+      });
+      if (msg.method === "notifications/resources/list_changed") void this.refreshResources().catch(() => {
+      });
+    }
+  }
+  failAll(err) {
+    for (const [, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.reject(err);
+    }
+    this.pending.clear();
+  }
+};
+var McpManager = class {
+  constructor(defaultCwd) {
+    this.defaultCwd = defaultCwd;
+  }
+  defaultCwd;
+  clients = /* @__PURE__ */ new Map();
+  /** Last attestations produced this session (most recent last). */
+  attestations = [];
+  /** Connect one server (replacing any existing client of the same name). */
+  async connect(config) {
+    this.disconnect(config.name);
+    const client = new McpClient(config);
+    this.clients.set(config.name, client);
+    await client.connect(this.defaultCwd);
+    return client;
+  }
+  disconnect(name) {
+    const existing = this.clients.get(name);
+    if (existing) {
+      existing.close();
+      this.clients.delete(name);
+    }
+  }
+  closeAll() {
+    for (const [, c2] of this.clients) c2.close();
+    this.clients.clear();
+  }
+  get(name) {
+    return this.clients.get(name);
+  }
+  connectedNames() {
+    return Array.from(this.clients.keys()).sort();
+  }
+  toolCount() {
+    let n = 0;
+    for (const [, c2] of this.clients) n += c2.tools.length;
+    return n;
+  }
+  /** A JSON-serializable catalog of every connected server for the KV/context. */
+  catalog() {
+    return {
+      servers: Array.from(this.clients.values()).map((c2) => c2.catalogEntry()),
+      generatedAt: Date.now()
+    };
+  }
+  recentAttestations(n = 10) {
+    return this.attestations.slice(-n);
+  }
+  /** Execute a forwarded `mcp` tool request and return host-shaped text. */
+  async dispatch(args) {
+    const action = String(args.action || "call");
+    const serverName = typeof args.server === "string" ? args.server : "";
+    if (action === "list") {
+      const servers = this.catalog().servers.map((s) => ({
+        name: s.name,
+        tools: s.tools.length,
+        resources: s.resources?.length ?? 0
+      }));
+      return {
+        ok: true,
+        result: servers.length ? JSON.stringify({ servers }, null, 2) : "No MCP servers are connected. The user can add one with the /mcp command, or you can install one with install_mcp."
+      };
+    }
+    if (action === "list_tools") {
+      const cat = this.catalog().servers.filter((s) => !serverName || s.name === serverName);
+      if (!cat.length) return { ok: false, error: serverName ? `No connected MCP server named '${serverName}'.` : "No MCP servers are connected. The user can add one with the /mcp command." };
+      return { ok: true, result: JSON.stringify(cat, null, 2) };
+    }
+    const client = this.clients.get(serverName);
+    if (!client) {
+      const avail = this.connectedNames();
+      return {
+        ok: false,
+        error: avail.length ? `No connected MCP server named '${serverName}'. Connected servers: ${avail.join(", ")}.` : `No MCP servers are connected. The user can add one with the /mcp command.`
+      };
+    }
+    try {
+      let res;
+      if (action === "read_resource") {
+        const uri = String(args.uri || "");
+        if (!uri) return { ok: false, error: "read_resource requires a 'uri'." };
+        res = await client.readResource(uri);
+      } else {
+        const toolName = String(args.tool || "");
+        if (!toolName) return { ok: false, error: "call requires a 'tool' name." };
+        const callArgs = parseArgs(args.arguments_json);
+        if (callArgs instanceof Error) return { ok: false, error: callArgs.message };
+        res = await client.callTool(toolName, callArgs);
+      }
+      this.attestations.push(res.attestation);
+      const footer = formatAttestation(res.attestation);
+      if (!res.ok) {
+        return { ok: false, error: `${res.text || "The MCP tool reported an error."}
+${footer}` };
+      }
+      return { ok: true, result: `${res.text}
+${footer}` };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+};
+function parseArgs(raw) {
+  if (raw == null || raw === "") return {};
+  if (typeof raw === "object") return raw;
+  if (typeof raw !== "string") return new Error("arguments_json must be a JSON object string.");
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    return new Error("arguments_json must encode a JSON object.");
+  } catch (e) {
+    return new Error(`arguments_json is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+function flattenContent(content, structured) {
+  const parts = [];
+  for (const block of content || []) {
+    if (block.type === "text" && typeof block.text === "string") parts.push(block.text);
+    else if (block.type === "resource" && block.resource && typeof block.resource === "object") {
+      const r = block.resource;
+      if (typeof r.text === "string") parts.push(r.text);
+      else parts.push(`[resource ${String(r.uri ?? "")}]`);
+    } else if (block.type === "image") parts.push(`[image ${String(block.mimeType ?? "")}]`);
+    else if (block.type === "audio") parts.push(`[audio ${String(block.mimeType ?? "")}]`);
+    else parts.push(JSON.stringify(block));
+  }
+  if (!parts.length && structured !== void 0) parts.push(JSON.stringify(structured, null, 2));
+  return parts.join("\n").trim();
+}
+function flattenResourceContents(contents) {
+  const parts = [];
+  for (const c2 of contents || []) {
+    if (typeof c2.text === "string") parts.push(c2.text);
+    else if (typeof c2.blob === "string") parts.push(`[binary resource ${String(c2.uri ?? "")} (${c2.blob.length} b64 chars)]`);
+  }
+  return parts.join("\n").trim();
+}
+function formatAttestation(a) {
+  const id = `${a.serverInfo.name}${a.serverInfo.version ? `@${a.serverInfo.version}` : ""}`;
+  return `[attestation] server=${a.server} (${id}) protocol=${a.protocolVersion} target=${a.target} args_sha256=${a.argsSha256.slice(0, 16)} result_sha256=${a.resultSha256.slice(0, 16)} nonce=${a.nonce}`;
+}
+function canonicalJson(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const k of Object.keys(value).sort()) {
+      out[k] = sortKeys(value[k]);
+    }
+    return out;
+  }
+  return value;
+}
+function sha256(input2) {
+  return crypto.createHash("sha256").update(input2).digest("hex");
+}
+var DIR = path3.join(os6.homedir(), ".standardagents");
+var FILE = path3.join(DIR, "credentials");
+function normalizeEndpoint(endpoint) {
+  let e = endpoint.trim();
+  if (!/^https?:\/\//i.test(e)) e = "http://" + e;
+  return e.replace(/\/+$/, "");
+}
+function loadCredentials() {
+  try {
+    const raw = fs4.readFileSync(FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.instances) parsed.instances = {};
+    return parsed;
+  } catch {
+    return { instances: {} };
+  }
+}
+function getCredential(endpoint) {
+  const creds = loadCredentials();
+  return creds.instances[normalizeEndpoint(endpoint)] ?? null;
+}
+function saveCredential(cred, options = {}) {
+  const creds = loadCredentials();
+  const endpoint = normalizeEndpoint(cred.endpoint);
+  creds.instances[endpoint] = { ...cred, endpoint };
+  if (options.updateDefault ?? true) {
+    creds.default_endpoint = endpoint;
+  }
+  fs4.mkdirSync(DIR, { recursive: true });
+  fs4.writeFileSync(FILE, JSON.stringify(creds, null, 2), { mode: 384 });
+  try {
+    fs4.chmodSync(FILE, 384);
+  } catch {
+  }
+}
+function defaultEndpoint() {
+  return loadCredentials().default_endpoint ?? null;
+}
+function saveDefaultEndpoint(endpoint) {
+  const creds = loadCredentials();
+  creds.default_endpoint = normalizeEndpoint(endpoint);
+  fs4.mkdirSync(DIR, { recursive: true });
+  fs4.writeFileSync(FILE, JSON.stringify(creds, null, 2), { mode: 384 });
+  try {
+    fs4.chmodSync(FILE, 384);
+  } catch {
+  }
+}
+
+// src/index.ts
+var AGENT_ID = "standard_code_agent";
+var c = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  white: "\x1B[97m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  gray: "\x1B[90m",
+  magenta: "\x1B[35m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  teal: "\x1B[38;5;37m"
+  // brand teal (matches the marketing site's teal accent)
+};
+var LOGO_MARK = [
+  "     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+  "     \u2588\u2588\u2588        \u2588\u2588",
+  "     \u2588\u2588          \u2588",
+  "\u2588\u2588\u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588   \u2588\u2588",
+  "\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588",
+  "\u2588\u2588   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2588\u2588\u2588\u2588",
+  "\u2588          \u2588\u2588",
+  "\u2588\u2588        \u2588\u2588\u2588",
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588"
+];
+function printUsage() {
+  stdout.write(
+    [
+      "",
+      `${c.bold}Usage${c.reset}`,
+      "  standardcode [options] [dir]",
+      "",
+      `${c.bold}Options${c.reset}`,
+      "  -e, --endpoint [url]  Use a Standard Agents instance for this run only.",
+      "                       If url is omitted, prompt for it.",
+      "                       Credentials are remembered for that endpoint, but",
+      "                       the saved default endpoint is not changed.",
+      "  -h, --help            Show this help.",
+      ""
+    ].join("\n")
+  );
+}
+function parseArgs2(args) {
+  const parsed = { help: false, promptEndpoint: false };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (arg === "--endpoint" || arg === "-e") {
+      const value = args[i + 1];
+      if (value && !value.startsWith("-")) {
+        parsed.endpoint = value;
+        i++;
+      } else {
+        parsed.promptEndpoint = true;
+      }
+      continue;
+    }
+    if (arg.startsWith("--endpoint=")) {
+      const value = arg.slice("--endpoint=".length);
+      if (value) {
+        parsed.endpoint = value;
+      } else {
+        parsed.promptEndpoint = true;
+      }
+      continue;
+    }
+    if (arg === "--") {
+      if (i === 0 && args[i + 1]?.startsWith("-")) continue;
+      const rest = args.slice(i + 1);
+      if (rest.length > 1) throw new Error("Expected at most one project directory.");
+      if (rest[0]) parsed.dir = rest[0];
+      break;
+    }
+    if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`);
+    if (parsed.dir) throw new Error("Expected at most one project directory.");
+    parsed.dir = arg;
+  }
+  return parsed;
+}
+function printAssistant(tui, text) {
+  const cols2 = Math.max(20, (process.stdout.columns || 80) - 3);
+  tui.clearStream();
+  tui.print("");
+  let dotted = false;
+  for (const line of renderMarkdown(text, cols2)) {
+    if (!dotted && line.trim()) {
+      tui.print(`${c.gray}\u2022${c.reset} ${line}`);
+      dotted = true;
+    } else {
+      tui.print(`  ${line}`);
+    }
+  }
+  tui.print("");
+}
+function farewell(stoppedProcs = 0) {
+  if (stoppedProcs > 0) {
+    stdout.write(
+      `
+${c.cyan}\u2699${c.reset} Stopped ${stoppedProcs} background process${stoppedProcs === 1 ? "" : "es"}.
+`
+    );
+  }
+  stdout.write(`
+${c.teal}\u25C7${c.reset} ${c.dim}Standard Code \u2014 see you soon.${c.reset}
+`);
+}
+function isLocalHost(host) {
+  return host === "localhost" || host === "127.0.0.1" || host === "::1" || host.endsWith(".local") || host.endsWith(".localhost") || /^10\./.test(host) || /^192\.168\./.test(host) || /^172\.(1[6-9]|2\d|3[01])\./.test(host);
+}
+function relaxTlsForLocalEndpoint(endpoint) {
+  let host = "";
+  try {
+    host = new URL(endpoint).hostname;
+  } catch {
+    return false;
+  }
+  if (!endpoint.startsWith("https:") || !isLocalHost(host)) return false;
+  const origEmit = process.emitWarning.bind(process);
+  process.emitWarning = ((warning, ...args) => {
+    const msg = typeof warning === "string" ? warning : warning?.message ?? "";
+    if (msg.includes("NODE_TLS_REJECT_UNAUTHORIZED")) return;
+    return origEmit(warning, ...args);
+  });
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+  return true;
+}
+function readVersion() {
+  try {
+    const pkg = JSON.parse(fs4.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    return typeof pkg.version === "string" ? pkg.version : "";
+  } catch {
+    return "";
+  }
+}
+function printWelcome(endpoint, projectDir) {
+  const home = os6.homedir();
+  const dir = projectDir.startsWith(home) ? "~" + projectDir.slice(home.length) : projectDir;
+  const host = endpoint.replace(/^https?:\/\//, "").replace(/\/$/, "");
+  const version = readVersion();
+  const pad = "  ";
+  const meta = [
+    `${c.bold}${c.white}Standard Code${c.reset}${version ? `  ${c.dim}v${version}${c.reset}` : ""}`,
+    `${c.dim}terminal coding agent${c.reset}`,
+    `${c.teal}${host}${c.reset}`,
+    `${c.dim}${dir}${c.reset}`
+  ];
+  const markWidth = Math.max(...LOGO_MARK.map((l) => [...l].length));
+  const metaTop = Math.floor((LOGO_MARK.length - meta.length) / 2);
+  stdout.write("\n");
+  for (let i = 0; i < LOGO_MARK.length; i++) {
+    const glyph = LOGO_MARK[i].padEnd(markWidth);
+    const line = meta[i - metaTop];
+    stdout.write(`${pad}${glyph}${line ? `   ${line}` : ""}
+`);
+  }
+  stdout.write("\n");
+}
+function colorActivity(line) {
+  const m = line.match(/^(\s*)([✓✗⛔])\s?([\s\S]*)$/);
+  if (!m) return `${c.dim}${line}${c.reset}`;
+  const [, indent, glyph, rest] = m;
+  if (glyph === "\u2713") {
+    const body = rest.replace(/\s(\([^()]*\))\s*$/, ` ${c.dim}$1${c.reset}`);
+    return `${indent}${c.green}\u2713${c.reset} ${body}`;
+  }
+  if (glyph === "\u2717") {
+    const ERR_MAX_LINES = 7;
+    const lines = rest.split("\n");
+    const shown = lines.slice(0, ERR_MAX_LINES);
+    const hidden = lines.length - shown.length;
+    const body = shown.map(
+      (l, i) => i === 0 ? `${indent}${c.red}\u2717 ${l}${c.reset}` : `${indent}${c.red}${c.dim}${l}${c.reset}`
+    ).join("\n");
+    if (hidden > 0) {
+      return `${body}
+${indent}${c.dim}\u2026 +${hidden} more line${hidden === 1 ? "" : "s"}${c.reset}`;
+    }
+    return body;
+  }
+  return `${indent}${c.yellow}\u26D4 ${rest}${c.reset}`;
+}
+async function main() {
+  let cliArgs;
+  try {
+    cliArgs = parseArgs2(process.argv.slice(2));
+  } catch (error) {
+    stdout.write(`${c.red}error:${c.reset} ${error instanceof Error ? error.message : String(error)}
+`);
+    printUsage();
+    process.exit(1);
+  }
+  if (cliArgs.help) {
+    printUsage();
+    return;
+  }
+  const endpointArg = cliArgs.endpoint;
+  const endpointOverride = cliArgs.promptEndpoint || typeof endpointArg === "string" && endpointArg.trim() !== "";
+  const dirArg = cliArgs.dir;
+  const projectDir = path3.resolve(dirArg || process.cwd());
+  const machine = os6.hostname();
+  const reader = { rl: null };
+  let handoffClosing = false;
+  let preflightArmed = false;
+  let preflightTimer = null;
+  const onPreflightSigint = () => {
+    if (preflightArmed) {
+      if (preflightTimer) clearTimeout(preflightTimer);
+      reader.rl?.close();
+      farewell();
+      process.exit(0);
+    }
+    preflightArmed = true;
+    stdout.write(`
+${c.dim}Press Control-C again to exit${c.reset}
+`);
+    preflightTimer = setTimeout(() => {
+      preflightArmed = false;
+      preflightTimer = null;
+    }, 2e3);
+  };
+  const ask = async (question) => {
+    if (!reader.rl) {
+      reader.rl = readline2.createInterface({ input: stdin, output: stdout });
+      reader.rl.on("SIGINT", onPreflightSigint);
+      reader.rl.on("close", () => {
+        if (handoffClosing) return;
+        farewell();
+        process.exit(0);
+      });
+    }
+    return reader.rl.question(question);
+  };
+  const askEndpoint = async () => {
+    for (; ; ) {
+      const answer = (await ask(
+        `${c.cyan}Standard Agents instance URL${c.reset} (e.g. http://localhost:5178): `
+      )).trim();
+      if (answer) return answer;
+      stdout.write(`${c.dim}An endpoint URL is required.${c.reset}
+`);
+    }
+  };
+  process.on("SIGINT", onPreflightSigint);
+  let endpointPrompted = false;
+  let endpoint = endpointArg || (cliArgs.promptEndpoint ? "" : defaultEndpoint() || "");
+  if (!endpoint) {
+    endpoint = await askEndpoint();
+    endpointPrompted = true;
+  }
+  endpoint = normalizeEndpoint(endpoint);
+  const tlsRelaxed = relaxTlsForLocalEndpoint(endpoint);
+  printWelcome(endpoint, projectDir);
+  if (tlsRelaxed) {
+    stdout.write(`${c.dim}  TLS verification relaxed for local endpoint.${c.reset}
+
+`);
+  }
+  const stored = getCredential(endpoint);
+  let api = stored ? new ApiClient(endpoint, stored.access_token) : null;
+  if (!api || !await api.verify()) {
+    const host = endpoint.replace(/^https?:\/\//, "").replace(/\/$/, "");
+    stdout.write(
+      `${c.bold}${c.white}Sign in${c.reset} ${c.dim}\u2014 connect to${c.reset} ${c.teal}${host}${c.reset}
+`
+    );
+    stdout.write(
+      `${c.dim}Press Enter to sign in with your browser, or paste an API token.${c.reset}
+
+`
+    );
+    for (; ; ) {
+      const token = (await ask(`${c.teal}\u276F${c.reset} ${c.dim}token (or Enter for browser)${c.reset} `)).trim();
+      if (!token) {
+        const got = await deviceLogin(endpoint).catch((e) => {
+          stdout.write(`${c.red}\u2717${c.reset} ${c.dim}${e instanceof Error ? e.message : String(e)}${c.reset}
+`);
+          return null;
+        });
+        if (!got) continue;
+        api = new ApiClient(endpoint, got);
+        if (await api.verify()) {
+          saveCredential(
+            { endpoint, access_token: got, token_type: "Bearer", saved_at: Date.now() },
+            { updateDefault: !endpointOverride }
+          );
+          stdout.write(`${c.green}\u2713${c.reset} Connected to ${c.teal}${host}${c.reset}
+`);
+          break;
+        }
+        stdout.write(`${c.red}\u2717${c.reset} ${c.dim}Browser sign-in didn't verify. Try again.${c.reset}
+`);
+        continue;
+      }
+      api = new ApiClient(endpoint, token);
+      if (await api.verify()) {
+        saveCredential(
+          { endpoint, access_token: token, token_type: "Bearer", saved_at: Date.now() },
+          { updateDefault: !endpointOverride }
+        );
+        stdout.write(`${c.green}\u2713${c.reset} Connected to ${c.teal}${host}${c.reset}
+`);
+        break;
+      }
+      stdout.write(`${c.red}\u2717${c.reset} ${c.dim}That token didn't work. Try again.${c.reset}
+`);
+    }
+  } else if (endpointPrompted) {
+    saveDefaultEndpoint(endpoint);
+  }
+  if (!api) process.exit(1);
+  handoffClosing = true;
+  reader.rl?.close();
+  const tags = [`path:${projectDir}`, `machine:${machine}`];
+  let existing = [];
+  try {
+    existing = await api.listThreads(AGENT_ID, tags);
+  } catch {
+    existing = [];
+  }
+  const tui = new Tui(1);
+  let threadId;
+  let resumed = false;
+  let historySeed;
+  if (existing.length > 0) {
+    const summaries = await summarizeThreads(api, existing.slice(0, 8));
+    const items = summaries.map((s) => ({
+      label: s.label,
+      hint: s.hint,
+      value: s.id
+    }));
+    items.push({ label: "\uFF0B Start a new session", value: null });
+    const home = os6.homedir();
+    const tilde = projectDir.startsWith(home) ? "~" + projectDir.slice(home.length) : projectDir;
+    const shortDir = tilde.length > 38 ? "\u2026" + tilde.slice(-37) : tilde;
+    const picked = await tui.select(
+      `${c.bold}${c.magenta}Resume a session${c.reset}  ${c.gray}${shortDir}${c.reset}  ${c.dim}\u2191\u2193 \xB7 enter \xB7 esc to cancel${c.reset}`,
+      items
+    );
+    if (typeof picked === "string") {
+      threadId = picked;
+      resumed = true;
+    } else {
+      threadId = await api.createThread(AGENT_ID, tags);
+      historySeed = existing[0]?.id;
+    }
+  } else {
+    threadId = await api.createThread(AGENT_ID, tags);
+  }
+  await runInteractive(tui, api, threadId, projectDir, machine, resumed, historySeed);
+}
+async function summarizeThreads(api, threads) {
+  return Promise.all(
+    threads.map(async (t) => {
+      let preview = "";
+      try {
+        const msgs = await api.getMessages(t.id, 30);
+        const users = msgs.filter((m) => m.role === "user" && typeof m.content === "string" && m.content.trim()).sort((a, b) => (a.created_at ?? 0) - (b.created_at ?? 0));
+        if (users[0]) preview = String(users[0].content).replace(/\s+/g, " ").trim();
+      } catch {
+      }
+      const label = preview ? preview.length > 64 ? preview.slice(0, 63) + "\u2026" : preview : "(empty session)";
+      const when = t.created_at ? relativeTime(t.created_at) : "";
+      const hint = [t.id.slice(0, 8), when].filter(Boolean).join(" \xB7 ");
+      return { id: t.id, label, hint };
+    })
+  );
+}
+function subagentLabel(s, titles) {
+  const agentName = (s.agent_name || "").trim();
+  const title = (s.title || "").trim() || titles.get(agentName) || (agentName ? agentName.replace(/[_-]+/g, " ").replace(/\b\w/g, (c2) => c2.toUpperCase()) : "Subagent");
+  const tagged = (s.threadName || "").trim();
+  return tagged ? `${title} \xB7 ${tagged}` : title;
+}
+async function deviceLogin(endpoint) {
+  const start = await fetch(`${endpoint}/api/auth/device/start`, { method: "POST" });
+  if (!start.ok) throw new Error(`This instance does not support browser sign-in (HTTP ${start.status}). Paste an API token instead.`);
+  const info = await start.json();
+  stdout.write(`${c.dim}Opening your browser to approve this sign-in\u2026${c.reset}
+`);
+  stdout.write(`${c.dim}If it doesn't open, visit:${c.reset} ${c.teal}${info.verify_url}${c.reset}
+`);
+  openUrl(info.verify_url);
+  const deadline = Date.now() + (info.expires_in ?? 600) * 1e3;
+  const interval = Math.max(2, info.interval ?? 2) * 1e3;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, interval));
+    const res = await fetch(info.poll_url).catch(() => null);
+    if (!res) continue;
+    if (res.status === 404) throw new Error("The sign-in link expired. Try again.");
+    const body = await res.json().catch(() => ({}));
+    if (body.status === "approved" && body.token) return body.token;
+    if (body.status === "denied") throw new Error("Sign-in was denied in the browser.");
+  }
+  throw new Error("Timed out waiting for browser approval. Try again.");
+}
+function openUrl(url) {
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.unref();
+  } catch {
+  }
+}
+function relativeTime(unixSeconds) {
+  const diff = Date.now() / 1e3 - unixSeconds;
+  if (diff < 60) return "just now";
+  if (diff < 3600) return `${Math.floor(diff / 60)}m ago`;
+  if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`;
+  return `${Math.floor(diff / 86400)}d ago`;
+}
+function hasToolCalls(m) {
+  const tc = m?.tool_calls;
+  if (Array.isArray(tc)) return tc.length > 0;
+  if (typeof tc === "string") {
+    const s = tc.trim();
+    return s.length > 0 && s !== "null" && s !== "[]";
+  }
+  return false;
+}
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((b) => typeof b === "string" ? b : typeof b?.text === "string" ? b.text : "").join("");
+  }
+  return "";
+}
+function threadBusy(msgs) {
+  if (!msgs.length) return false;
+  if (msgs.some((m) => m.status === "pending")) return true;
+  const last = [...msgs].sort((a, b) => (b.created_at ?? 0) - (a.created_at ?? 0))[0];
+  if (!last) return false;
+  if (last.role === "user" || last.role === "tool") return true;
+  if (last.role === "assistant") return hasToolCalls(last);
+  return false;
+}
+async function printHistory(api, threadId, tui) {
+  let msgs;
+  try {
+    msgs = await api.getMessages(threadId, 200);
+  } catch {
+    return;
+  }
+  const convo = msgs.filter((m) => m.role === "user" || m.role === "assistant" && messageText(m.content).trim()).sort((a, b) => (a.created_at ?? 0) - (b.created_at ?? 0));
+  if (!convo.length) return;
+  const shown = convo.slice(-24);
+  tui.print(`${c.dim}\u2500\u2500 resuming session \xB7 ${convo.length} message${convo.length === 1 ? "" : "s"} \u2500\u2500${c.reset}`);
+  if (shown.length < convo.length) tui.print(`${c.dim}   \u2026 earlier messages omitted${c.reset}`);
+  for (const m of shown) {
+    const text = messageText(m.content).trim();
+    if (!text) continue;
+    if (m.role === "user") tui.printUserMessage(text);
+    else printAssistant(tui, text);
+  }
+}
+async function runInteractive(tui, api, threadId, projectDir, machine, resumed, historySeedThreadId) {
+  const registry = new ProcessRegistry(api, threadId, machine);
+  const mcp = new McpManager(projectDir);
+  const publishMcpCatalog = () => void api.kvSet(threadId, "mcp_catalog", mcp.catalog()).catch(() => {
+  });
+  const host = new HostTools(projectDir, registry, threadId, machine, mcp, publishMcpCatalog, api);
+  const refreshBgCount = () => {
+    void registry.runningCount().then((n) => tui.setBackgroundCount(n)).catch(() => {
+    });
+  };
+  const perm = { level: tui.level, alwaysAllow: /* @__PURE__ */ new Set(), allowRisk: /* @__PURE__ */ new Set() };
+  const savedApprovals = await loadApprovals(api, threadId);
+  for (const t of savedApprovals.allowTools) perm.alwaysAllow.add(t);
+  for (const r of savedApprovals.allowRisk) perm.allowRisk.add(r);
+  if (savedApprovals.level) {
+    perm.level = savedApprovals.level;
+    tui.setLevel(savedApprovals.level);
+  }
+  tui.onLevelChange((l) => {
+    perm.level = l;
+    saveApprovals(api, threadId, perm);
+  });
+  saveApprovals(api, threadId, perm);
+  let busy = false;
+  let interrupting = false;
+  const queued = [];
+  let editingQueued = false;
+  const shownIds = /* @__PURE__ */ new Set();
+  const pendingSent = /* @__PURE__ */ new Map();
+  let tokensIn = 0;
+  let tokensOut = 0;
+  let liveOut = 0;
+  const countedLogs = /* @__PURE__ */ new Set();
+  const activeSteps = /* @__PURE__ */ new Map();
+  const refreshStatus = () => {
+    tui.setTokens(tokensIn, tokensOut + liveOut);
+    let label = null;
+    for (const v of activeSteps.values()) label = v;
+    tui.setStep(label, liveOut);
+  };
+  const bridge = new Bridge(api, threadId, host, perm, {
+    onActivity: (line, detail) => {
+      tui.print(colorActivity(line));
+      if (detail) for (const d of detail) tui.print(d);
+      refreshBgCount();
+    },
+    onStatus: (id, summary) => {
+      if (summary) {
+        if (!activeSteps.has(id)) activeSteps.set(id, summary);
+      } else {
+        activeSteps.delete(id);
+      }
+      refreshStatus();
+    },
+    onConnection: (state, attempt) => {
+      if (state === "reconnecting") {
+        if (attempt >= 4) tui.setConnected(false);
+      } else {
+        tui.setConnected(true);
+      }
+    },
+    requestApproval: async (req, summary, risk) => {
+      const choice = await tui.approval(
+        `${summary}${req.requestPermission ? `
+${c.bold}why: ${req.requestPermission}${c.reset}` : ""}`,
+        risk
+      );
+      if (choice === "deny_with_reason") {
+        const reason = await tui.prompt(
+          "Why are you denying this? (sent to the agent \u2014 enter to send, esc to skip)"
+        );
+        return { choice: "deny", reason: reason ?? void 0 };
+      }
+      return { choice };
+    }
+  });
+  const stream = new MessageStream(api, threadId, {
+    // Live streaming preview: answer text and (opt-in) internal reasoning feed
+    // the TUI's ephemeral preview; the committed message still renders from
+    // polling, which calls tui.clearStream() first so there's no double-render.
+    onChunk: (text, mid) => tui.streamResponseDelta(text, mid),
+    onReasoningChunk: (text, mid) => tui.streamThinkingDelta(text, mid),
+    onAssistantText: () => {
+    },
+    onEvent: (eventType, data) => {
+      if (eventType === "generation" && typeof data?.outputTokens === "number") {
+        liveOut = data.outputTokens;
+        refreshStatus();
+      } else if (eventType === "tool_call_started" && data?.id) {
+        activeSteps.set(data.id, data.progress || data.name || "working");
+        refreshStatus();
+      } else if (eventType === "tool_call_done" && data?.id) {
+        activeSteps.delete(data.id);
+        refreshStatus();
+      } else if (eventType === "goal_updated" && data) {
+        tui.setGoal(data);
+      }
+    },
+    onError: () => {
+    }
+  });
+  const activeSubagents = /* @__PURE__ */ new Map();
+  const agentTitles = /* @__PURE__ */ new Map();
+  const agentTitlesReady = api.listAgents().then((list) => list.forEach((a) => agentTitles.set(a.name, a.title))).catch(() => {
+  });
+  const pushSubagents = () => tui.setSubagents(
+    [...activeSubagents.entries()].map(([id, s]) => ({ id, label: s.label, agentName: s.agentName }))
+  );
+  const reconcileSubagents = async () => {
+    try {
+      await agentTitlesReady;
+      const subs = await api.listSubagents(threadId);
+      activeSubagents.clear();
+      for (const s of subs) {
+        if (s.status !== "running") continue;
+        activeSubagents.set(s.id, {
+          label: subagentLabel(s, agentTitles),
+          agentName: s.agent_name ?? void 0
+        });
+      }
+      pushSubagents();
+    } catch {
+    }
+  };
+  let reconcileTimer = null;
+  let reconcilePending = false;
+  const scheduleReconcile = () => {
+    if (reconcileTimer) {
+      reconcilePending = true;
+      return;
+    }
+    reconcileTimer = setTimeout(async () => {
+      reconcileTimer = null;
+      await reconcileSubagents();
+      if (reconcilePending) {
+        reconcilePending = false;
+        scheduleReconcile();
+      }
+    }, 150);
+  };
+  const events = new SystemEvents(api, {
+    onOpen: () => scheduleReconcile(),
+    onThreadCreated: (t) => {
+      if (t.parent === threadId) scheduleReconcile();
+    },
+    onThreadUpdated: (t) => {
+      if (t.parent === threadId) scheduleReconcile();
+    },
+    onThreadDeleted: (id) => {
+      if (activeSubagents.has(id)) scheduleReconcile();
+    }
+  });
+  const quit = async () => {
+    tui.end();
+    const stopped = api.stop(threadId).catch(() => {
+    });
+    const procsStopped = host.stopAllLocalProcesses().catch(() => 0);
+    bridge.close();
+    stream.close();
+    events.close();
+    mcp.closeAll();
+    const [, killed] = await Promise.race([
+      Promise.all([stopped, procsStopped]),
+      new Promise((r) => setTimeout(() => r([void 0, 0]), 1500))
+    ]);
+    farewell(killed);
+    process.exit(0);
+  };
+  tui.setQuitHandler(quit);
+  const viewThread = () => {
+    const url = `${api.origin}/threads/${threadId}`;
+    openUrl(url);
+    tui.print(`${c.gray}opened ${c.cyan}${url}${c.reset}`);
+  };
+  const bgMgr = {
+    list: () => registry.list(),
+    stop: async (id) => {
+      await host.execute("background_process", { action: "stop", id });
+      refreshBgCount();
+    }
+  };
+  const mcpCtl = {
+    configured: () => listMcpServers(),
+    connectedNames: () => mcp.connectedNames(),
+    catalog: () => mcp.catalog(),
+    connect: async (cfg) => {
+      try {
+        const client = await mcp.connect(cfg);
+        publishMcpCatalog();
+        return { ok: true, tools: client.tools.length };
+      } catch (e) {
+        publishMcpCatalog();
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+      }
+    },
+    disconnect: (name) => {
+      mcp.disconnect(name);
+      publishMcpCatalog();
+    },
+    add: async (cfg) => {
+      saveMcpServer(cfg);
+      return mcpCtl.connect(cfg);
+    },
+    // Seed the request into the main chat — the agent researches + installs it
+    // there (using research_agent + install_mcp), visible in the transcript.
+    requestInstall: (query) => {
+      void sendNow(
+        `Install an MCP server for me: ${query}. Research the best one and its exact launch command, then install it.`
+      );
+    },
+    remove: (name) => {
+      mcp.disconnect(name);
+      removeMcpServer(name);
+      publishMcpCatalog();
+    },
+    setEnabled: (name, enabled) => setMcpServerEnabled(name, enabled)
+  };
+  const extFor = (mime) => ({ "image/png": "png", "image/jpeg": "jpg", "image/gif": "gif", "image/webp": "webp" })[mime] ?? "bin";
+  const toAttachments = (images) => images.map((img) => ({ name: `image-${img.seq}.${extFor(img.mime)}`, mimeType: img.mime, data: img.data }));
+  const sendNow = async (text, images = []) => {
+    tui.printUserMessage(text);
+    const key = text.trim();
+    pendingSent.set(key, (pendingSent.get(key) ?? 0) + 1);
+    try {
+      await api.sendMessage(threadId, text, toAttachments(images));
+    } catch (e) {
+      const n = (pendingSent.get(key) ?? 1) - 1;
+      if (n > 0) pendingSent.set(key, n);
+      else pendingSent.delete(key);
+      tui.print(`${c.dim}failed to send: ${e instanceof Error ? e.message : String(e)}${c.reset}`);
+      return;
+    }
+    interrupting = false;
+    busy = true;
+    tui.setWorking(true);
+  };
+  const flushQueued = async () => {
+    if (!queued.length) return;
+    const toSend = queued.splice(0);
+    tui.setQueuedCount(0);
+    for (const q of toSend) await sendNow(q.text, q.images);
+  };
+  const requestCompaction = async () => {
+    try {
+      await api.compact(threadId);
+    } catch (err) {
+      tui.print(`${c.red}\u2717${c.reset} couldn't start compaction: ${err.message}`);
+    }
+  };
+  const skillsCtl = {
+    list: () => api.listSkills(),
+    setEnabled: (name, enabled) => api.setSkillEnabled(name, enabled),
+    remove: (name) => api.removeSkill(name),
+    // Seed the request into the main chat — the agent researches or authors
+    // the skill there (research_agent + install_skill), visible in the transcript.
+    requestInstall: (query) => {
+      void sendNow(
+        `Install a skill for me: ${query}. Find the skill's published files (or author a proper SKILL.md from your research), install it with install_skill, then tell me what it can do.`
+      );
+    }
+  };
+  tui.setCommands([
+    {
+      name: "compact",
+      label: "Compact conversation now",
+      hint: () => tui.contextPctLabel() || "free up context",
+      run: requestCompaction
+    },
+    { name: "level", label: "Auto-accept level", hint: () => `level ${tui.level}`, run: () => runLevelMenu(tui, perm) },
+    {
+      name: "permissions",
+      label: "Approved commands",
+      hint: () => {
+        const n = perm.alwaysAllow.size + perm.allowRisk.size;
+        return n ? `${n} approved` : "none";
+      },
+      run: () => runApprovalsMenu(tui, perm, () => saveApprovals(api, threadId, perm))
+    },
+    {
+      name: "mcp",
+      label: "MCP servers",
+      hint: () => {
+        const n = mcpCtl.connectedNames().length;
+        return n ? `${n} connected` : "none";
+      },
+      run: () => runMcpMenu(tui, mcpCtl)
+    },
+    {
+      name: "skills",
+      label: "Agent skills",
+      hint: "list / install / manage",
+      run: () => runSkillsMenu(tui, skillsCtl)
+    },
+    { name: "background", label: "Background processes", hint: "list / stop", run: () => runProcessMenu(tui, bgMgr) },
+    { name: "view", label: "View thread in AgentBuilder", run: () => viewThread() },
+    { name: "keybindings", label: "Keyboard shortcuts", run: () => showKeybindings(tui) },
+    { name: "quit", label: "Quit", run: () => quit() }
+  ]);
+  const history = await loadHistory(api, threadId, historySeedThreadId);
+  tui.setHistory(history);
+  tui.onSubmit = (text, images) => {
+    appendHistory(api, threadId, history, text);
+    if (editingQueued) {
+      editingQueued = false;
+      queued.push({ text, images });
+      tui.setQueuedCount(queued.length);
+      tui.print(`${c.gray}\u23F3 queued:${c.reset} ${text}`);
+      return;
+    }
+    if (busy) {
+      queued.push({ text, images });
+      tui.setQueuedCount(queued.length);
+      tui.print(`${c.gray}\u23F3 queued:${c.reset} ${text}  ${c.dim}(esc to steer now)${c.reset}`);
+    } else {
+      void sendNow(text, images);
+    }
+  };
+  tui.onInterrupt = () => {
+    if (queued.length > 0) {
+      tui.print(`${c.yellow}\u21AA steering \u2014 stopping current work and sending your message\u2026${c.reset}`);
+      void api.stop(threadId).catch(() => {
+      }).then(() => flushQueued());
+    } else if (busy) {
+      interrupting = true;
+      busy = false;
+      activeSteps.clear();
+      liveOut = 0;
+      tui.setWorking(false);
+      refreshStatus();
+      tui.print(`${c.yellow}[interrupted by user]${c.reset}`);
+      void api.stop(threadId).catch(() => {
+      });
+    }
+  };
+  tui.onUpArrow = () => {
+    if (tui.getInput().trim() || queued.length === 0) return false;
+    const q = queued.pop();
+    tui.setQueuedCount(queued.length);
+    editingQueued = true;
+    tui.setInput(q.text, q.images);
+    return true;
+  };
+  events.connect();
+  await Promise.all([bridge.connect(), stream.connect()]);
+  void api.getGoal(threadId).then((g) => tui.setGoal(g)).catch(() => {
+  });
+  tui.banner([
+    `${c.bold}${c.magenta}Standard Code${c.reset} ${c.dim}\u2014 coding agent${c.reset}`,
+    `${c.gray}project:${c.reset} ${projectDir}`,
+    `${c.gray}machine:${c.reset} ${machine}   ${c.gray}thread:${c.reset} ${threadId.slice(0, 8)}`
+  ]);
+  if (resumed) await printHistory(api, threadId, tui);
+  try {
+    (await api.getMessages(threadId, 200)).forEach((m) => shownIds.add(m.id));
+  } catch {
+  }
+  const runningProcs = (await registry.list()).filter((p) => p.status === "running");
+  if (runningProcs.length) {
+    tui.print(
+      `${c.cyan}\u2699 ${runningProcs.length} background process${runningProcs.length === 1 ? "" : "es"} running:${c.reset}`
+    );
+    for (const p of runningProcs) tui.print(`${c.gray}  ${p.id}  ${p.description || p.command}${c.reset}`);
+  }
+  refreshBgCount();
+  const enabledServers = listMcpServers().filter((s) => s.enabled);
+  for (const s of enabledServers) {
+    const res = await mcpCtl.connect(s);
+    if (res.ok) {
+      tui.print(`${c.cyan}\u26A1 MCP "${s.name}" connected${c.reset} ${c.gray}(${res.tools} tool${res.tools === 1 ? "" : "s"})${c.reset}`);
+    } else {
+      tui.print(`${c.red}\u26A0 MCP "${s.name}" failed:${c.reset} ${c.gray}${res.error}${c.reset}`);
+    }
+  }
+  publishMcpCatalog();
+  tui.start();
+  const poll = async () => {
+    let msgs;
+    try {
+      msgs = await api.getMessages(threadId, 60);
+    } catch {
+      return;
+    }
+    const sorted = [...msgs].sort((a, b) => (a.created_at ?? 0) - (b.created_at ?? 0));
+    for (const m of sorted) {
+      if (shownIds.has(m.id) || m.status === "pending") continue;
+      shownIds.add(m.id);
+      const text = messageText(m.content).trim();
+      if (m.role === "assistant" && text) printAssistant(tui, text);
+      else if (m.role === "system" && text) tui.print(`${c.dim}${text}${c.reset}`);
+      else if (m.role === "user" && text) {
+        const pending = pendingSent.get(text) ?? 0;
+        if (pending > 0) {
+          if (pending === 1) pendingSent.delete(text);
+          else pendingSent.set(text, pending - 1);
+        } else {
+          tui.printUserMessage(text);
+        }
+      }
+    }
+    const polledBusy = threadBusy(msgs);
+    if (interrupting) {
+      if (!polledBusy) interrupting = false;
+      busy = false;
+    } else {
+      busy = polledBusy;
+    }
+    tui.setWorking(busy);
+    if (!busy) {
+      if (activeSteps.size) activeSteps.clear();
+      liveOut = 0;
+      refreshStatus();
+      if (queued.length > 0 && !editingQueued) await flushQueued();
+    }
+    refreshBgCount();
+    try {
+      const logs = await api.getLogs(threadId, 100);
+      let landed = 0;
+      for (const l of logs) {
+        if (!l.is_complete) continue;
+        const id = l.id ?? `${l.created_at}:${l.total_tokens}`;
+        if (countedLogs.has(id)) continue;
+        countedLogs.add(id);
+        const inT = Number(l.input_tokens) || 0;
+        const outT = Number(l.output_tokens) || 0;
+        tokensIn += inT;
+        tokensOut += outT;
+        landed += outT;
+      }
+      if (landed > 0) liveOut = 0;
+      refreshStatus();
+    } catch {
+    }
+    try {
+      const cu = await api.kvGet(threadId, "context_usage");
+      const used = Number(cu?.inputTokens) || 0;
+      const max = Number(cu?.maxContextTokens) || 0;
+      tui.setContextPct(max > 0 && used > 0 ? used / max * 100 : null);
+    } catch {
+    }
+  };
+  setInterval(() => void poll().catch(() => {
+  }), 1200);
+  await new Promise(() => {
+  });
+}
+async function runSkillsMenu(tui, skills) {
+  let list;
+  try {
+    list = await skills.list();
+  } catch (e) {
+    tui.print(`${c.red}\u2717 couldn't load skills:${c.reset} ${c.gray}${e instanceof Error ? e.message : String(e)}${c.reset}`);
+    return;
+  }
+  const INSTALL = "__install__";
+  const items = list.map((s) => ({
+    label: s.name,
+    hint: `${s.enabled ? "enabled" : "disabled"} \xB7 ${s.files.length} file${s.files.length === 1 ? "" : "s"}`,
+    value: s.name
+  }));
+  items.push({ label: "\uFF0B Install a skill\u2026", hint: "find & install", value: INSTALL });
+  const picked = await tui.select(
+    `${c.bold}Agent skills${c.reset}  ${c.dim}(\u2191/\u2193 \xB7 enter \xB7 esc to close)${c.reset}`,
+    items
+  );
+  if (!picked) return;
+  if (picked === INSTALL) {
+    const query = await tui.prompt(
+      "What skill do you want to install?",
+      "the anthropic pdf skill / a skill for writing conventional commits"
+    );
+    if (query) skills.requestInstall(query);
+    return;
+  }
+  const skill = list.find((s) => s.name === picked);
+  tui.print(`${c.cyan}${skill.name}${c.reset}${skill.version ? ` ${c.dim}v${skill.version}${c.reset}` : ""} ${c.gray}\u2014 ${skill.description}${c.reset}`);
+  const action = await tui.select(`${c.bold}${picked}${c.reset}`, [
+    skill.enabled ? { label: "Disable (hide from the agent)", value: "disable" } : { label: "Enable", value: "enable" },
+    { label: "View files", value: "files" },
+    { label: "Remove this skill", value: "remove" },
+    { label: "Back", value: "back" }
+  ]);
+  try {
+    if (action === "enable" || action === "disable") {
+      await skills.setEnabled(picked, action === "enable");
+      tui.print(`${c.gray}${action}d ${picked}${c.reset}`);
+    } else if (action === "files") {
+      for (const f of skill.files) tui.print(`  ${c.gray}${f}${c.reset}`);
+    } else if (action === "remove") {
+      await skills.remove(picked);
+      tui.print(`${c.gray}removed ${picked}${c.reset}`);
+    }
+  } catch (e) {
+    tui.print(`${c.red}\u2717 ${e instanceof Error ? e.message : String(e)}${c.reset}`);
+  }
+}
+async function runLevelMenu(tui, perm) {
+  const picked = await tui.select(
+    `${c.bold}Auto-accept level${c.reset}  ${c.dim}(\u2191/\u2193 \xB7 enter \xB7 shift-tab cycles)${c.reset}`,
+    LEVELS.map((l) => ({
+      label: levelLabel(l),
+      hint: l === tui.level ? "current" : "",
+      value: l
+    }))
+  );
+  if (picked) {
+    tui.setLevel(picked);
+    perm.level = picked;
+  }
+}
+function showKeybindings(tui) {
+  tui.print(`${c.gray}shortcuts:${c.reset}`);
+  tui.print(`${c.gray}  shift-tab${c.reset}  cycle auto-accept level (1\u20135)`);
+  tui.print(`${c.gray}  /${c.reset}          open the command palette (type to filter)`);
+  tui.print(`${c.gray}  ctrl-v${c.reset}     paste an image from the clipboard ([#Image 1])`);
+  tui.print(`${c.gray}  \u2191 / \u2193${c.reset}      cycle past messages (on the input's top line)`);
+  tui.print(`${c.gray}  ctrl-c${c.reset}     quit`);
+}
+async function runProcessMenu(tui, bg) {
+  const procs = await bg.list();
+  if (!procs.length) {
+    tui.print(`${c.gray}No background processes for this session.${c.reset}`);
+    return;
+  }
+  const items = procs.map((p) => {
+    const status = p.status === "running" ? `${c.green}running${c.reset}` : `${c.gray}${p.status}${typeof p.exitCode === "number" ? ` (exit ${p.exitCode})` : ""}${c.reset}`;
+    return {
+      label: `${p.description || p.command}`,
+      hint: `${p.id} \xB7 ${status}`,
+      value: p.id
+    };
+  });
+  const picked = await tui.select(
+    `${c.bold}Background processes${c.reset}  ${c.dim}(\u2191/\u2193 \xB7 enter to manage \xB7 esc to close)${c.reset}`,
+    items
+  );
+  if (!picked) return;
+  const proc = procs.find((p) => p.id === picked);
+  if (!proc || proc.status !== "running") {
+    tui.print(`${c.gray}${picked} is not running.${c.reset}`);
+    return;
+  }
+  const action = await tui.select(`${c.bold}${proc.description || proc.command}${c.reset}`, [
+    { label: "Stop this process", value: "stop" },
+    { label: "Leave it running", value: "leave" }
+  ]);
+  if (action === "stop") {
+    await bg.stop(picked);
+    tui.print(`${c.gray}stopped ${picked}${c.reset}`);
+  }
+}
+async function runApprovalsMenu(tui, perm, save) {
+  const tools = Array.from(perm.alwaysAllow).sort();
+  const risks = Array.from(perm.allowRisk).sort((a, b) => a - b);
+  if (!tools.length && !risks.length) {
+    tui.print(
+      `${c.gray}No pre-approved commands. At a permission prompt, choose "Always allow this tool" or "Allow all level N" to add some.${c.reset}`
+    );
+    return;
+  }
+  const items = [
+    ...tools.map((t) => ({ label: `Tool: ${t}`, hint: "always allowed", value: `tool:${t}` })),
+    ...risks.map((r) => ({ label: `All level ${r} risk`, hint: "always allowed", value: `risk:${r}` })),
+    { label: "Clear all approvals", hint: "", value: "clear" }
+  ];
+  const picked = await tui.select(
+    `${c.bold}Approved commands${c.reset}  ${c.dim}(enter to revoke \xB7 esc to close)${c.reset}`,
+    items
+  );
+  if (!picked) return;
+  if (picked === "clear") {
+    perm.alwaysAllow.clear();
+    perm.allowRisk.clear();
+    tui.print(`${c.gray}cleared all approvals${c.reset}`);
+  } else if (picked.startsWith("tool:")) {
+    const t = picked.slice(5);
+    perm.alwaysAllow.delete(t);
+    tui.print(`${c.gray}revoked tool ${t}${c.reset}`);
+  } else if (picked.startsWith("risk:")) {
+    const r = Number(picked.slice(5));
+    perm.allowRisk.delete(r);
+    tui.print(`${c.gray}revoked level ${r}${c.reset}`);
+  }
+  save();
+}
+async function runMcpMenu(tui, mcp) {
+  const configured = mcp.configured();
+  const connected = new Set(mcp.connectedNames());
+  const cat = mcp.catalog();
+  const INSTALL = "__install__";
+  const ADD_MANUAL = "__manual__";
+  const items = configured.map((s) => {
+    const entry = cat.servers.find((e) => e.name === s.name);
+    const status = !s.enabled ? "disabled" : connected.has(s.name) ? `connected \xB7 ${entry?.tools.length ?? 0} tools` : entry?.error ? "error" : "disconnected";
+    return { label: s.name, hint: status, value: s.name };
+  });
+  items.push({ label: "\uFF0B Install a new MCP server\u2026", hint: "find & install", value: INSTALL });
+  items.push({ label: "Add manually (name: command)\u2026", hint: "advanced", value: ADD_MANUAL });
+  const picked = await tui.select(
+    `${c.bold}MCP servers${c.reset}  ${c.dim}(\u2191/\u2193 \xB7 enter \xB7 esc to close)${c.reset}`,
+    items
+  );
+  if (!picked) return;
+  if (picked === INSTALL) {
+    await installMcpServerFlow(tui, mcp);
+    return;
+  }
+  if (picked === ADD_MANUAL) {
+    await addMcpServer(tui, mcp);
+    return;
+  }
+  const server = configured.find((s) => s.name === picked);
+  const isConnected = connected.has(picked);
+  const action = await tui.select(`${c.bold}${picked}${c.reset}`, [
+    { label: "View tools", value: "tools" },
+    isConnected ? { label: "Disconnect", value: "disconnect" } : { label: "Connect", value: "connect" },
+    server.enabled ? { label: "Disable (don't auto-connect)", value: "disable" } : { label: "Enable (auto-connect on start)", value: "enable" },
+    { label: "Remove this server", value: "remove" },
+    { label: "Back", value: "back" }
+  ]);
+  if (action === "tools") {
+    const entry = mcp.catalog().servers.find((e) => e.name === picked);
+    if (!entry || entry.status !== "connected") {
+      tui.print(`${c.gray}${picked} is not connected \u2014 connect it to list tools.${c.reset}`);
+      return;
+    }
+    if (!entry.tools.length) tui.print(`${c.gray}${picked} exposes no tools.${c.reset}`);
+    for (const t of entry.tools) tui.print(`  ${c.cyan}${t.name}${c.reset}${t.description ? ` ${c.gray}\u2014 ${t.description}${c.reset}` : ""}`);
+    if (entry.resources.length) tui.print(`  ${c.gray}${entry.resources.length} resource(s)${c.reset}`);
+  } else if (action === "connect") {
+    const res = await mcp.connect(server);
+    tui.print(res.ok ? `${c.cyan}\u26A1 connected (${res.tools} tools)${c.reset}` : `${c.red}\u26A0 ${res.error}${c.reset}`);
+  } else if (action === "disconnect") {
+    mcp.disconnect(picked);
+    tui.print(`${c.gray}disconnected ${picked}${c.reset}`);
+  } else if (action === "enable") {
+    mcp.setEnabled(picked, true);
+    const res = await mcp.connect(server);
+    tui.print(res.ok ? `${c.cyan}\u26A1 enabled + connected (${res.tools} tools)${c.reset}` : `${c.red}\u26A0 enabled but failed: ${res.error}${c.reset}`);
+  } else if (action === "disable") {
+    mcp.setEnabled(picked, false);
+    mcp.disconnect(picked);
+    tui.print(`${c.gray}disabled + disconnected ${picked}${c.reset}`);
+  } else if (action === "remove") {
+    mcp.remove(picked);
+    tui.print(`${c.gray}removed ${picked}${c.reset}`);
+  }
+}
+async function addMcpServer(tui, mcp) {
+  const spec = await tui.prompt(
+    "Add an MCP server \u2014 enter  name: command [args\u2026]",
+    "fs: npx -y @modelcontextprotocol/server-filesystem ."
+  );
+  if (!spec) return;
+  const cfg = parseServerSpec(spec);
+  if (!cfg) {
+    tui.print(`${c.yellow}couldn't parse that. Use  name: command [args]${c.reset}`);
+    return;
+  }
+  tui.print(`${c.gray}connecting MCP "${cfg.name}" (${cfg.command} ${cfg.args.join(" ")})\u2026${c.reset}`);
+  const res = await mcp.add(cfg);
+  if (res.ok) tui.print(`${c.cyan}\u26A1 MCP "${cfg.name}" connected${c.reset} ${c.gray}(${res.tools} tool${res.tools === 1 ? "" : "s"})${c.reset}`);
+  else tui.print(`${c.red}\u26A0 MCP "${cfg.name}" failed:${c.reset} ${c.gray}${res.error}${c.reset} ${c.dim}(saved; retry from the MCP menu)${c.reset}`);
+}
+async function installMcpServerFlow(tui, mcp) {
+  const query = await tui.prompt(
+    "What MCP server do you want to install?",
+    "the best computer-use mcp server for mac"
+  );
+  if (!query) return;
+  mcp.requestInstall(query);
+}
+main().catch((err) => {
+  process.stderr.write(`
+${err instanceof Error ? err.stack || err.message : String(err)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map