@standardagents/code 0.0.2-dev.517db40 → 0.0.2-dev.b3cdaaf

package/dist/index.js

@@ -1,3463 +0,0 @@
-#!/usr/bin/env node
-import os4 from 'os';
-import fs2 from 'fs';
-import path3 from 'path';
-import readline2 from 'readline/promises';
-import { spawn } from 'child_process';
-import { stdout, stdin } from 'process';
-import fsp from 'fs/promises';
-import crypto2 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)));
-  }
-  async sendMessage(threadId, content) {
-    await this.json(`/api/threads/${threadId}/messages`, {
-      method: "POST",
-      body: JSON.stringify({ role: "user", content })
-    });
-  }
-  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;
-  }
-  /** 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 {
-    }
-  }
-  async stop(threadId) {
-    try {
-      await this.json(`/api/threads/${threadId}/stop`, { method: "POST" });
-    } catch {
-    }
-  }
-};
-
-// 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/bridge.ts
-var PATH_ARG_TOOLS = /* @__PURE__ */ new Set(["read_file", "list_dir", "grep", "glob", "write_file", "edit_file", "delete"]);
-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) => 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 = setInterval(() => {
-      try {
-        if (ws.readyState === WebSocket.OPEN) ws.send("ping");
-      } catch {
-      }
-    }, 5e3);
-  }
-  stopHeartbeat() {
-    if (this.heartbeat) {
-      clearInterval(this.heartbeat);
-      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 = await this.hooks.requestApproval(req, summary, effectiveRisk);
-      if (choice === "deny") {
-        this.hooks.onActivity(`\u26D4 ${summary} \u2014 you declined`);
-        this.respond(req, false, void 0, "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);
-      }
-    }
-    this.hooks.onStatus?.(summary);
-    const result = await this.host.execute(req.tool, req.args);
-    this.hooks.onStatus?.(null);
-    if (result.ok) {
-      this.hooks.onActivity(`\u2713 ${summary}${detailSuffix(req.tool, result.result)}`);
-      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 "list_dir":
-      return `list ${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 "delete":
-      return `delete ${a.path}`;
-    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" || tool === "delete") 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(os4.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);
-    }
-  }
-};
-var DIR = path3.join(os4.homedir(), ".standardagents");
-var FILE = path3.join(DIR, "mcp.json");
-function loadMcpConfig() {
-  try {
-    const raw = fs2.readFileSync(FILE, "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) {
-  fs2.mkdirSync(DIR, { recursive: true });
-  fs2.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) {
-    this.projectDir = projectDir;
-    this.registry = registry;
-    this.threadId = threadId;
-    this.machine = machine;
-    this.mcp = mcp;
-    this.onMcpCatalogChange = onMcpCatalogChange;
-  }
-  projectDir;
-  registry;
-  threadId;
-  machine;
-  mcp;
-  onMcpCatalogChange;
-  /** 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 "list_dir":
-          return await this.listDir(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 "delete":
-          return await this.deletePath(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 listDir(args) {
-    const dir = this.resolve(args.path ? String(args.path) : void 0);
-    const entries = await fsp.readdir(dir, { withFileTypes: true });
-    const sorted = entries.filter((e) => e.name !== ".git" && e.name !== "node_modules").sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name));
-    const lines = sorted.map((e) => e.isDirectory() ? `${e.name}/` : e.name);
-    const header = `${path3.relative(this.projectDir, dir) || "."} (${lines.length} entries)`;
-    return { ok: true, result: `${header}
-${lines.join("\n")}` };
-  }
-  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 = fs2.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"})` };
-  }
-  async deletePath(args) {
-    const target = this.resolve(String(args.path || ""));
-    const recursive = args.recursive === true;
-    const stat = await fsp.stat(target).catch(() => null);
-    if (!stat) return { ok: false, error: `Path not found: ${args.path}` };
-    if (stat.isDirectory() && !recursive) {
-      return { ok: false, error: `${args.path} is a directory; set recursive to delete it.` };
-    }
-    await fsp.rm(target, { recursive, force: false });
-    return { ok: true, result: `Deleted ${path3.relative(this.projectDir, target) || target}` };
-  }
-  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 = crypto2.randomUUID().slice(0, 8);
-    const logPath = path3.join(LOG_DIR, `${id}.log`);
-    let out;
-    try {
-      await fsp.mkdir(LOG_DIR, { recursive: true });
-      out = fs2.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) {
-      fs2.closeSync(out);
-      return { ok: false, error: `Failed to start: ${err instanceof Error ? err.message : String(err)}` };
-    }
-    fs2.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}` };
-  }
-  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;
-  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)}`;
-    let ws;
-    try {
-      ws = new WebSocket(url);
-    } catch {
-      this.scheduleReconnect();
-      return;
-    }
-    this.ws = ws;
-    ws.addEventListener("open", () => {
-      this.reconnectAttempt = 0;
-      this.resolveConnected?.();
-    });
-    ws.addEventListener("message", (ev) => 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.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;
-    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);
-      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;
-  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;
-    });
-    ws.addEventListener("message", (ev) => this.onMessage(String(ev.data)));
-    ws.addEventListener("error", () => this.handleDrop(ws));
-    ws.addEventListener("close", () => this.handleDrop(ws));
-  }
-  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.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;
-    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]})`;
-}
-
-// src/tui.ts
-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 Tui = class {
-  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"));
-  }
-  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 = [];
-  // labels of subagents currently working (one line each)
-  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
-  // 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;
-  // 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;
-  // event hooks (wired by index.ts)
-  onSubmit = () => {
-  };
-  onInterrupt = () => {
-  };
-  onUpArrow = () => {
-  };
-  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;
-    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) {
-    if (key && key.ctrl && key.name === "c") {
-      this.requestQuit();
-      return;
-    }
-    if (key && key.name === "tab" && key.shift) {
-      this.cycleLevel();
-      return;
-    }
-    const seq = key && key.sequence || str || "";
-    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 (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") {
-      this.onUpArrow();
-      return;
-    }
-    if (key.name === "return" || key.name === "enter") {
-      const text = this.inputBuffer;
-      this.inputBuffer = "";
-      this.cursorPos = 0;
-      this.renderBottom();
-      if (text.trim()) this.onSubmit(text.trim());
-      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.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.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.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;
-    }
-    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);
-  }
-  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 col = pct >= 85 ? C.red : pct >= 70 ? C.yellow : C.green;
-      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(cols) {
-    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, cols - 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}`;
-    }
-    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()}\u203A${C.reset} `;
-  }
-  visibleWidth(s) {
-    return s.replace(/\x1b\[[0-9;]*m/g, "").length;
-  }
-  /**
-   * 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(cols) {
-    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, cols - 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, cols - 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. */
-  moveToRegionTop() {
-    process.stdout.write("\r");
-    if (this.bottomDrawn && this.lastCursorRow > 0) process.stdout.write(`\x1B[${this.lastCursorRow}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 cols = process.stdout.columns || 80;
-    this.moveToRegionTop();
-    process.stdout.write("\x1B[J");
-    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) process.stdout.write(noticeLine + "\r\n");
-    const quitLine = this.quitArmed ? `${C.dim}Press Control-C again to exit${C.reset}` : null;
-    const quitRows = quitLine ? 1 : 0;
-    if (quitLine) process.stdout.write(quitLine + "\r\n");
-    const frame = FRAMES[Math.floor(Date.now() / 100) % FRAMES.length];
-    for (const label of this.subagents) {
-      const line = `${C.magenta}${frame}${C.reset} ${C.magenta}${label}${C.reset} ${C.dim}working${C.reset}`;
-      process.stdout.write(line + "\r\n");
-    }
-    const statusLine = this.statusLineText(cols);
-    const statusRows = statusLine ? 1 : 0;
-    if (statusLine) process.stdout.write(statusLine + "\r\n");
-    const paletteLines = this.paletteLines(cols);
-    for (const line of paletteLines) process.stdout.write(line + "\r\n");
-    const aboveRows = noticeRows + quitRows + this.subagents.length + statusRows + paletteLines.length;
-    const prefix = this.promptPrefix();
-    const pw = this.visibleWidth(prefix);
-    const buf = this.inputBuffer;
-    process.stdout.write(prefix + buf);
-    const inputRows = Math.max(1, Math.ceil((pw + buf.length) / cols));
-    if (this.cursorPos < buf.length) {
-      const curCell = pw + this.cursorPos;
-      const cursorRowInInput = Math.floor(curCell / cols);
-      const cursorCol = curCell % cols;
-      process.stdout.write("\r");
-      const up = inputRows - 1 - cursorRowInInput;
-      if (up > 0) process.stdout.write(`\x1B[${up}A`);
-      if (cursorCol > 0) process.stdout.write(`\x1B[${cursorCol}C`);
-      this.lastCursorRow = aboveRows + cursorRowInInput;
-    } else {
-      this.lastCursorRow = aboveRows + (inputRows - 1);
-    }
-    this.bottomDrawn = true;
-  }
-  clearBottom() {
-    if (!this.bottomDrawn) return;
-    this.moveToRegionTop();
-    process.stdout.write("\x1B[J");
-    this.bottomDrawn = false;
-  }
-  /** Print a line of transcript above the persistent input. */
-  print(text) {
-    if (this.takeoverHandler) {
-      this.bufferedPrints.push(text);
-      return;
-    }
-    this.clearBottom();
-    process.stdout.write(text + "\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 cols = Math.max(20, process.stdout.columns || 80);
-    const bg = "\x1B[48;5;238m";
-    const limit = Math.max(8, cols - 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 ? "\u203A " : "  ") + line;
-      const padded = rowText.padEnd(innerW);
-      const inner = i === 0 ? `${C.teal}\u203A${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();
-    } else if (!on) {
-      this.working = false;
-    }
-    this.syncSpinner();
-    this.renderBottom();
-  }
-  /** Labels of subagents currently working, one persistent line each. */
-  setSubagents(labels) {
-    this.subagents = labels;
-    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;
-  }
-  setInput(text) {
-    this.inputBuffer = text;
-    this.cursorPos = text.length;
-    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. */
-  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();
-      process.stdout.write(
-        `
-${C.yellow}\u2503${C.reset} ${C.bold}Permission needed${C.reset}  risk ${riskBar}
-${C.yellow}\u2503${C.reset} ${question}
-`
-      );
-      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 finish = (choice) => {
-        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 === "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/markdown.ts
-var ESC = "\x1B[";
-var R = ESC + "0m";
-var BOLD = ESC + "1m";
-var DIM = 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} ${DIM}${url}${R}`
-  );
-  s = s.replace(/\*\*([^*]+)\*\*/g, (_, t) => `${BOLD}${t}${R}`);
-  s = s.replace(/\*([^*\n]+)\*/g, (_, t) => `${ITAL}${t}${R}`);
-  s = s.replace(/~~([^~]+)~~/g, (_, t) => `${DIM}${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, cols, leadFirst, leadRest, leadWidth, text) {
-  const wrapped = wrapStyled(text, Math.max(8, cols - 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 cols = Math.max(...rows.map((r) => r.length));
-  const widths = [];
-  for (let c2 = 0; c2 < cols; 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 < cols; 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, cols = 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(), cols)) 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, cols - 2))) {
-        out.push(`${GRAY}\u2502${R} ${DIM}${ln}${R}`);
-      }
-      i++;
-      continue;
-    }
-    const bullet = line.match(/^(\s*)[-*+]\s+(.*)$/);
-    if (bullet) {
-      const leadWidth = bullet[1].length + 2;
-      wrapBlock(out, cols, `${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, cols, `${numbered[1]}${BOLD}${marker}${R} `, " ".repeat(leadWidth), leadWidth, inline(numbered[4]));
-      i++;
-      continue;
-    }
-    if (line.trim()) wrapBlock(out, cols, "", "", 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: crypto2.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 crypto2.createHash("sha256").update(input2).digest("hex");
-}
-var DIR2 = path3.join(os4.homedir(), ".standardagents");
-var FILE2 = path3.join(DIR2, "credentials");
-function normalizeEndpoint(endpoint) {
-  let e = endpoint.trim();
-  if (!/^https?:\/\//i.test(e)) e = "http://" + e;
-  return e.replace(/\/+$/, "");
-}
-function loadCredentials() {
-  try {
-    const raw = fs2.readFileSync(FILE2, "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) {
-  const creds = loadCredentials();
-  const endpoint = normalizeEndpoint(cred.endpoint);
-  creds.instances[endpoint] = { ...cred, endpoint };
-  creds.default_endpoint = endpoint;
-  fs2.mkdirSync(DIR2, { recursive: true });
-  fs2.writeFileSync(FILE2, JSON.stringify(creds, null, 2), { mode: 384 });
-  try {
-    fs2.chmodSync(FILE2, 384);
-  } catch {
-  }
-}
-function defaultEndpoint() {
-  return loadCredentials().default_endpoint ?? null;
-}
-
-// 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 printAssistant(tui, text) {
-  const cols = Math.max(20, (process.stdout.columns || 80) - 1);
-  tui.print("");
-  for (const line of renderMarkdown(text, cols)) tui.print(line);
-  tui.print("");
-}
-function farewell() {
-  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(fs2.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-    return typeof pkg.version === "string" ? pkg.version : "";
-  } catch {
-    return "";
-  }
-}
-function printWelcome(endpoint, projectDir) {
-  const home = os4.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") return `${indent}${c.red}\u2717${c.reset} ${rest}`;
-  return `${indent}${c.yellow}\u26D4 ${rest}${c.reset}`;
-}
-async function main() {
-  const args = process.argv.slice(2);
-  let endpointArg;
-  let dirArg;
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--endpoint" || args[i] === "-e") endpointArg = args[++i];
-    else if (!args[i].startsWith("-")) dirArg = args[i];
-  }
-  const projectDir = path3.resolve(dirArg || process.cwd());
-  const machine = os4.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);
-  };
-  process.on("SIGINT", onPreflightSigint);
-  let endpoint = endpointArg || defaultEndpoint() || "";
-  if (!endpoint) {
-    const answer = await ask(
-      `${c.cyan}Standard Agents instance URL${c.reset} (e.g. http://localhost:5178): `
-    );
-    endpoint = answer.trim();
-  }
-  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 paste an API token to connect to${c.reset} ${c.teal}${host}${c.reset}
-`
-    );
-    stdout.write(`${c.dim}Create one in your instance settings under API tokens.${c.reset}
-
-`);
-    for (; ; ) {
-      const token = (await ask(`${c.teal}\u276F${c.reset} ${c.dim}token${c.reset} `)).trim();
-      if (!token) {
-        stdout.write(`${c.dim}A token is required.${c.reset}
-`);
-        continue;
-      }
-      api = new ApiClient(endpoint, token);
-      if (await api.verify()) {
-        saveCredential({ endpoint, access_token: token, token_type: "Bearer", saved_at: Date.now() });
-        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}
-`);
-    }
-  }
-  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;
-  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 = os4.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);
-    }
-  } else {
-    threadId = await api.createThread(AGENT_ID, tags);
-  }
-  await runInteractive(tui, api, threadId, projectDir, machine, resumed);
-}
-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(t, titles) {
-  const agentName = (t.agent_name || "").trim();
-  const title = titles.get(agentName) || (agentName ? agentName.replace(/[_-]+/g, " ").replace(/\b\w/g, (c2) => c2.toUpperCase()) : "Subagent");
-  const nameTag = (t.tags || []).find((tag) => tag.startsWith("name:"));
-  const tagged = nameTag?.slice("name:".length).trim();
-  return tagged ? `${title} \xB7 ${tagged}` : title;
-}
-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);
-  }
-  tui.print(`${c.dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${c.reset}`);
-}
-async function runInteractive(tui, api, threadId, projectDir, machine, resumed) {
-  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);
-  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);
-  });
-  let busy = false;
-  let interrupting = false;
-  const queued = [];
-  let editingQueued = false;
-  const shownIds = /* @__PURE__ */ new Set();
-  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) => {
-      tui.print(colorActivity(line));
-      refreshBgCount();
-    },
-    onStatus: () => {
-    },
-    // the working indicator is driven by the busy poller
-    onConnection: (state, attempt) => {
-      if (state === "reconnecting") {
-        if (attempt >= 4) tui.setConnected(false);
-      } else {
-        tui.setConnected(true);
-      }
-    },
-    requestApproval: (req, summary, risk) => tui.approval(
-      `${summary}${req.requestPermission ? `
-${c.dim}why: ${req.requestPermission}${c.reset}` : ""}`,
-      risk
-    )
-  });
-  const stream = new MessageStream(api, threadId, {
-    onChunk: () => {
-    },
-    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();
-      }
-    },
-    onError: () => {
-    }
-  });
-  const activeSubagents = /* @__PURE__ */ new Map();
-  const agentTitles = /* @__PURE__ */ new Map();
-  void api.listAgents().then((list) => list.forEach((a) => agentTitles.set(a.name, a.title))).catch(() => {
-  });
-  const pushSubagents = () => tui.setSubagents([...activeSubagents.values()]);
-  const events = new SystemEvents(api, {
-    onThreadCreated: (t) => {
-      if (t.parent === threadId && !t.terminated) {
-        activeSubagents.set(t.id, subagentLabel(t, agentTitles));
-        pushSubagents();
-      }
-    },
-    onThreadUpdated: (t) => {
-      if (t.parent !== threadId) return;
-      if (t.terminated) activeSubagents.delete(t.id);
-      else activeSubagents.set(t.id, subagentLabel(t, agentTitles));
-      pushSubagents();
-    },
-    onThreadDeleted: (id) => {
-      if (activeSubagents.delete(id)) pushSubagents();
-    }
-  });
-  const quit = () => {
-    tui.end();
-    bridge.close();
-    stream.close();
-    events.close();
-    mcp.closeAll();
-    farewell();
-    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 sendNow = async (text) => {
-    tui.printUserMessage(text);
-    try {
-      await api.sendMessage(threadId, text);
-    } catch (e) {
-      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 t of toSend) await sendNow(t);
-  };
-  const requestCompaction = async () => {
-    try {
-      await api.kvSet(threadId, "compaction_request", { requestedAt: Date.now() });
-      tui.print(
-        `${c.cyan}\u27F3${c.reset} compacting the conversation in the background \u2014 recent messages stay live.`
-      );
-    } catch (err) {
-      tui.print(`${c.red}\u2717${c.reset} couldn't request compaction: ${err.message}`);
-    }
-  };
-  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: "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() }
-  ]);
-  tui.onSubmit = (text) => {
-    if (editingQueued) {
-      editingQueued = false;
-      queued.push(text);
-      tui.setQueuedCount(queued.length);
-      tui.print(`${c.gray}\u23F3 queued:${c.reset} ${text}`);
-      return;
-    }
-    if (busy) {
-      queued.push(text);
-      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);
-    }
-  };
-  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;
-    const text = queued.pop();
-    tui.setQueuedCount(queued.length);
-    editingQueued = true;
-    tui.setInput(text);
-  };
-  events.connect();
-  await Promise.all([bridge.connect(), stream.connect()]);
-  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)}`,
-    `${c.dim}type anytime \xB7 shift-tab cycles auto-accept level \xB7 / for options \xB7 esc interrupts/steers \xB7 ctrl-c quits${c.reset}`
-  ]);
-  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}`);
-    }
-    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 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-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