@standardagents/code 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import os4 from 'os';
-import fs2 from 'fs';
+import os6 from 'os';
+import fs4 from 'fs';
 import path3 from 'path';
 import readline2 from 'readline/promises';
-import { spawn } from 'child_process';
+import { spawn, execFile } from 'child_process';
 import { stdout, stdin } from 'process';
 import fsp from 'fs/promises';
-import crypto2 from 'crypto';
+import crypto from 'crypto';
 import readline from 'readline';
 
 // src/api.ts
@@ -83,10 +83,38 @@ var ApiClient = class {
       preview: t.preview || t.last_message
     })).filter((t) => requireTags.every((tag) => t.tags.includes(tag)));
   }
-  async sendMessage(threadId, content) {
+  /**
+   * Subagent child threads of a thread, each with its current lifecycle status
+   * (`running`/`idle`/`terminated`). Sourced from the parent's child registry,
+   * which the live `/api/events` stream doesn't carry — so the CLI reads this to
+   * learn which subagents are *actually running* (vs idle or finished), both on
+   * (re)connect and whenever a subagent thread changes.
+   */
+  async listSubagents(threadId) {
+    const res = await this.json(
+      `/api/threads/${threadId}/subagents`
+    );
+    const arr = Array.isArray(res) ? res : res.subagents || [];
+    return arr.filter((s) => s && (s.id ?? s.reference)).map((s) => ({
+      id: s.id ?? s.reference,
+      agent_name: s.agent_name ?? s.name ?? null,
+      title: s.title ?? null,
+      threadName: s.threadName ?? s.thread_name ?? null,
+      status: typeof s.status === "string" ? s.status : "running"
+    }));
+  }
+  /**
+   * Send a user message, optionally with attachments (e.g. pasted images).
+   * Attachments use the instance's message-POST shape — base64 `data` +
+   * `mimeType` — which the server stores in the thread filesystem and injects
+   * into the LLM's vision context as real image content blocks.
+   */
+  async sendMessage(threadId, content, attachments) {
+    const body = { role: "user", content };
+    if (attachments && attachments.length > 0) body.attachments = attachments;
     await this.json(`/api/threads/${threadId}/messages`, {
       method: "POST",
-      body: JSON.stringify({ role: "user", content })
+      body: JSON.stringify(body)
     });
   }
   async getMessages(threadId, limit = 50) {
@@ -122,6 +150,22 @@ var ApiClient = class {
     }
     return false;
   }
+  /**
+   * Download raw file bytes from the thread's filesystem (e.g. an
+   * /attachments/* asset a subagent generated). Returns null on any failure.
+   */
+  async fetchFile(threadId, fsPath) {
+    const clean2 = fsPath.startsWith("/") ? fsPath : `/${fsPath}`;
+    try {
+      const res = await fetch(`${this.endpoint}/api/threads/${threadId}/fs${clean2}`, {
+        headers: { Authorization: `Bearer ${this.token}` }
+      });
+      if (!res.ok) return null;
+      return Buffer.from(await res.arrayBuffer());
+    } catch {
+      return null;
+    }
+  }
   /** Read a value from the thread's durable KV store (null if absent). */
   async kvGet(threadId, key) {
     try {
@@ -144,12 +188,49 @@ var ApiClient = class {
     } catch {
     }
   }
+  // ── skills (instance-global Agent Skills library) ─────────────────────────
+  /** Installed skills — metadata only. Includes disabled skills. */
+  async listSkills() {
+    const res = await this.json(`/api/skills?all=1`);
+    return Array.isArray(res?.skills) ? res.skills : [];
+  }
+  /** Enable/disable an installed skill. */
+  async setSkillEnabled(name, enabled) {
+    await this.json(`/api/skills/${encodeURIComponent(name)}`, {
+      method: "PATCH",
+      body: JSON.stringify({ enabled })
+    });
+  }
+  /** Uninstall a skill. */
+  async removeSkill(name) {
+    await this.json(`/api/skills/${encodeURIComponent(name)}`, { method: "DELETE" });
+  }
+  /**
+   * Kick off background conversation compaction now. Spawns the compaction
+   * subagent directly server-side (so it fires even while the thread is idle).
+   */
+  async compact(threadId) {
+    await this.json(`/api/threads/${threadId}/compact`, { method: "POST" });
+  }
   async stop(threadId) {
     try {
       await this.json(`/api/threads/${threadId}/stop`, { method: "POST" });
     } catch {
     }
   }
+  /** The thread's current goal (set via set_goal / update_goal_step). */
+  async getGoal(threadId) {
+    try {
+      const r = await this.json(`/api/threads/${threadId}/goal`);
+      return {
+        summary: r?.summary ?? null,
+        description: r?.description ?? null,
+        steps: Array.isArray(r?.steps) ? r.steps : []
+      };
+    } catch {
+      return { summary: null, description: null, steps: [] };
+    }
+  }
 };
 
 // src/permissions.ts
@@ -202,8 +283,155 @@ function saveApprovals(api, threadId, perm) {
   void api.kvSet(threadId, KEY, payload);
 }
 
+// src/heartbeat.ts
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var CONNECTION_SILENCE_TIMEOUT_MS = 15e3;
+var Heartbeat = class {
+  constructor(ws, onDead, options = {}) {
+    this.ws = ws;
+    this.onDead = onDead;
+    this.intervalMs = options.intervalMs ?? HEARTBEAT_INTERVAL_MS;
+    this.silenceMs = options.silenceMs ?? CONNECTION_SILENCE_TIMEOUT_MS;
+  }
+  ws;
+  onDead;
+  timer = null;
+  lastRecvAt = 0;
+  intervalMs;
+  silenceMs;
+  start() {
+    this.stop();
+    this.lastRecvAt = Date.now();
+    this.timer = setInterval(() => this.tick(), this.intervalMs);
+  }
+  /** Record that a frame was received — proof the connection is alive. */
+  markAlive() {
+    this.lastRecvAt = Date.now();
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  tick() {
+    if (Date.now() - this.lastRecvAt > this.silenceMs) {
+      this.fail();
+      return;
+    }
+    try {
+      if (this.ws.readyState === WebSocket.OPEN) this.ws.send("ping");
+      else this.fail();
+    } catch {
+      this.fail();
+    }
+  }
+  fail() {
+    this.stop();
+    try {
+      this.ws.close();
+    } catch {
+    }
+    this.onDead();
+  }
+};
+
+// src/render.ts
+var RESET = "\x1B[0m";
+var DIM = "\x1B[2m";
+var ADD_BG = "\x1B[48;5;22m\x1B[38;5;254m";
+var DEL_BG = "\x1B[48;5;52m\x1B[38;5;254m";
+var MAX_SIDE_LINES = 4;
+function clamp(s, max) {
+  return s.length > max ? s.slice(0, Math.max(0, max - 1)) + "\u2026" : s;
+}
+function cols() {
+  return Math.max(20, process.stdout.columns || 80);
+}
+function flat(line) {
+  return line.replace(/\t/g, "  ");
+}
+function diffLines(oldStr, newStr) {
+  let oldLines = oldStr.split("\n");
+  let newLines = newStr.split("\n");
+  while (oldLines.length && newLines.length && oldLines[0] === newLines[0]) {
+    oldLines.shift();
+    newLines.shift();
+  }
+  while (oldLines.length && newLines.length && oldLines[oldLines.length - 1] === newLines[newLines.length - 1]) {
+    oldLines.pop();
+    newLines.pop();
+  }
+  const width = cols() - 2;
+  const out = [];
+  const side = (lines, bg, sign) => {
+    const shown = lines.slice(0, MAX_SIDE_LINES);
+    for (const l of shown) out.push(`${bg}${sign} ${clamp(flat(l), width)}${RESET}`);
+    const hidden = lines.length - shown.length;
+    if (hidden > 0) out.push(`${DIM}  \u2026 +${hidden} more line${hidden === 1 ? "" : "s"}${RESET}`);
+  };
+  side(oldLines, DEL_BG, "-");
+  side(newLines, ADD_BG, "+");
+  return out;
+}
+function newFileLines(content) {
+  const lines = content.split("\n");
+  const width = cols() - 2;
+  const shown = lines.slice(0, MAX_SIDE_LINES);
+  const out = shown.map((l) => `${ADD_BG}+ ${clamp(flat(l), width)}${RESET}`);
+  const hidden = lines.length - shown.length;
+  if (hidden > 0) out.push(`${DIM}  \u2026 +${hidden} more line${hidden === 1 ? "" : "s"}${RESET}`);
+  return out;
+}
+function highlightBash(cmd) {
+  const CYAN2 = "\x1B[36m";
+  const GREEN = "\x1B[32m";
+  const MAGENTA = "\x1B[35m";
+  let out = "";
+  let i = 0;
+  let expectProgram = true;
+  while (i < cmd.length) {
+    const ch = cmd[i];
+    if (ch === "'" || ch === '"') {
+      let j = i + 1;
+      while (j < cmd.length && cmd[j] !== ch) {
+        if (ch === '"' && cmd[j] === "\\") j++;
+        j++;
+      }
+      out += `${GREEN}${cmd.slice(i, Math.min(j + 1, cmd.length))}${RESET}`;
+      i = j + 1;
+      continue;
+    }
+    if (ch === "#") {
+      out += `${DIM}${cmd.slice(i)}${RESET}`;
+      break;
+    }
+    const op = cmd.slice(i).match(/^(\|\||&&|\||;|>>|>|<)/);
+    if (op) {
+      out += `${MAGENTA}${op[1]}${RESET}`;
+      i += op[1].length;
+      expectProgram = true;
+      continue;
+    }
+    const word = cmd.slice(i).match(/^[^\s'"#|;&<>]+/);
+    if (word) {
+      const w = word[0];
+      if (w.startsWith("-")) out += `${DIM}${w}${RESET}`;
+      else if (expectProgram) {
+        out += `${CYAN2}${w}${RESET}`;
+        expectProgram = false;
+      } else out += w;
+      i += w.length;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+
 // src/bridge.ts
-var PATH_ARG_TOOLS = /* @__PURE__ */ new Set(["read_file", "list_dir", "grep", "glob", "write_file", "edit_file", "delete"]);
+var PATH_ARG_TOOLS = /* @__PURE__ */ new Set(["read_file", "grep", "glob", "write_file", "edit_file"]);
 var Bridge = class {
   constructor(api, threadId, host, perm, hooks) {
     this.api = api;
@@ -264,7 +492,10 @@ var Bridge = class {
       this.hooks.onConnection?.(wasReconnecting ? "reconnected" : "connected", 0);
       this.resolveConnected?.();
     });
-    ws.addEventListener("message", (ev) => this.onMessage(String(ev.data)));
+    ws.addEventListener("message", (ev) => {
+      if (this.ws === ws) this.heartbeat?.markAlive();
+      this.onMessage(String(ev.data));
+    });
     ws.addEventListener("error", () => this.handleDrop(ws));
     ws.addEventListener("close", () => this.handleDrop(ws));
   }
@@ -287,16 +518,12 @@ var Bridge = class {
   }
   startHeartbeat(ws) {
     this.stopHeartbeat();
-    this.heartbeat = setInterval(() => {
-      try {
-        if (ws.readyState === WebSocket.OPEN) ws.send("ping");
-      } catch {
-      }
-    }, 5e3);
+    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws));
+    this.heartbeat.start();
   }
   stopHeartbeat() {
     if (this.heartbeat) {
-      clearInterval(this.heartbeat);
+      this.heartbeat.stop();
       this.heartbeat = null;
     }
   }
@@ -361,10 +588,16 @@ var Bridge = class {
       return;
     }
     if (decision === "ask") {
-      const choice = await this.hooks.requestApproval(req, summary, effectiveRisk);
+      const { choice, reason } = 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.");
+        const why = reason?.trim();
+        this.hooks.onActivity(`\u26D4 ${summary} \u2014 you declined${why ? `: ${why}` : ""}`);
+        this.respond(
+          req,
+          false,
+          void 0,
+          why ? `The user declined to run this operation. Their reason: ${why}` : "The user declined to run this operation."
+        );
         return;
       }
       if (choice === "always") this.perm.alwaysAllow.add(permKey);
@@ -373,11 +606,23 @@ var Bridge = class {
         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);
+    const callKey = req.toolCallId ?? req.id ?? `${req.tool}:${summary}`;
+    this.hooks.onStatus?.(callKey, summary);
+    let result;
+    try {
+      result = await this.host.execute(req.tool, req.args);
+    } finally {
+      this.hooks.onStatus?.(callKey, null);
+    }
     if (result.ok) {
-      this.hooks.onActivity(`\u2713 ${summary}${detailSuffix(req.tool, result.result)}`);
+      const display = req.tool === "bash" ? `bash: ${highlightBash(String(req.args.command ?? "").slice(0, 200))}` : summary;
+      let detail;
+      if (req.tool === "edit_file") {
+        detail = diffLines(String(req.args.old_string ?? ""), String(req.args.new_string ?? ""));
+      } else if (req.tool === "write_file") {
+        detail = newFileLines(String(req.args.content ?? ""));
+      }
+      this.hooks.onActivity(`\u2713 ${display}${detailSuffix(req.tool, result.result)}`, detail);
       this.respond(req, true, result.result ?? "");
     } else {
       this.hooks.onActivity(`\u2717 ${summary} \u2014 ${result.error}`);
@@ -406,8 +651,6 @@ function describe(req) {
     }
     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":
@@ -416,8 +659,10 @@ function describe(req) {
       return `write ${a.path}`;
     case "edit_file":
       return `edit ${a.path}`;
-    case "delete":
-      return `delete ${a.path}`;
+    case "save_to_disk":
+      return `save ${a.source_path} \u2192 ${a.dest_path}`;
+    case "run_skill_script":
+      return `skill ${a.skill}: run ${a.entry}`;
     case "bash":
       return `bash: ${String(a.command).slice(0, 80)}`;
     default:
@@ -426,7 +671,7 @@ function describe(req) {
 }
 function detailSuffix(tool, result) {
   if (!result) return "";
-  if (tool === "write_file" || tool === "edit_file" || tool === "delete") return "";
+  if (tool === "write_file" || tool === "edit_file") return "";
   if (tool === "bash") {
     const m = result.match(/\[exit code (\d+)\]\s*$/);
     return m ? ` (exit ${m[1]})` : "";
@@ -434,7 +679,7 @@ function detailSuffix(tool, result) {
   const lines = result.split("\n").length;
   return ` (${lines} line${lines === 1 ? "" : "s"})`;
 }
-var LOG_DIR = path3.join(os4.homedir(), ".standardagents", "process-logs");
+var LOG_DIR = path3.join(os6.homedir(), ".standardagents", "process-logs");
 var KEY2 = "bg_processes";
 function isAlive(pid) {
   try {
@@ -510,11 +755,12 @@ var ProcessRegistry = class {
     }
   }
 };
-var DIR = path3.join(os4.homedir(), ".standardagents");
-var FILE = path3.join(DIR, "mcp.json");
+function configFile() {
+  return process.env.STANDARDAGENTS_MCP_CONFIG || path3.join(os6.homedir(), ".standardagents", "mcp.json");
+}
 function loadMcpConfig() {
   try {
-    const raw = fs2.readFileSync(FILE, "utf8");
+    const raw = fs4.readFileSync(configFile(), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed.servers || typeof parsed.servers !== "object") parsed.servers = {};
     return parsed;
@@ -544,8 +790,9 @@ function setMcpServerEnabled(name, enabled) {
   write(cfg);
 }
 function write(cfg) {
-  fs2.mkdirSync(DIR, { recursive: true });
-  fs2.writeFileSync(FILE, JSON.stringify(cfg, null, 2), { mode: 384 });
+  const file = configFile();
+  fs4.mkdirSync(path3.dirname(file), { recursive: true });
+  fs4.writeFileSync(file, JSON.stringify(cfg, null, 2), { mode: 384 });
 }
 function parseServerSpec(spec) {
   const trimmed = spec.trim();
@@ -609,13 +856,14 @@ async function readLogTail(logPath, n) {
   }
 }
 var HostTools = class {
-  constructor(projectDir, registry, threadId, machine, mcp, onMcpCatalogChange) {
+  constructor(projectDir, registry, threadId, machine, mcp, onMcpCatalogChange, api) {
     this.projectDir = projectDir;
     this.registry = registry;
     this.threadId = threadId;
     this.machine = machine;
     this.mcp = mcp;
     this.onMcpCatalogChange = onMcpCatalogChange;
+    this.api = api;
   }
   projectDir;
   registry;
@@ -623,6 +871,7 @@ var HostTools = class {
   machine;
   mcp;
   onMcpCatalogChange;
+  api;
   /** Resolve a user/model-supplied path against the project directory. */
   resolve(p) {
     if (!p || p === ".") return this.projectDir;
@@ -639,8 +888,6 @@ var HostTools = class {
       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":
@@ -651,8 +898,10 @@ var HostTools = class {
           return await this.editFile(args);
         case "bash":
           return await this.bash(args);
-        case "delete":
-          return await this.deletePath(args);
+        case "save_to_disk":
+          return await this.saveToDisk(args);
+        case "run_skill_script":
+          return await this.runSkillScript(args);
         case "background_process": {
           const action = String(args.action || "list");
           if (action === "start") return await this.runBackground(args);
@@ -695,15 +944,6 @@ var HostTools = class {
     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" };
@@ -735,7 +975,7 @@ ${lines.join("\n")}` };
     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);
+    const existed = fs4.existsSync(file);
     await fsp.writeFile(file, content, "utf8");
     return {
       ok: true,
@@ -760,16 +1000,125 @@ ${lines.join("\n")}` };
     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.` };
+  /**
+   * Copy a file from the THREAD filesystem (e.g. a generated /attachments/*
+   * asset) onto the project disk: download the bytes from the instance API and
+   * write them at the destination. The bytes never pass through the model.
+   */
+  async saveToDisk(args) {
+    const source = String(args.source_path || "");
+    const destArg = String(args.dest_path || "");
+    if (!source || !destArg) return { ok: false, error: "source_path and dest_path are required" };
+    if (!this.api || !this.threadId) {
+      return { ok: false, error: "No instance API available for thread file downloads." };
     }
-    await fsp.rm(target, { recursive, force: false });
-    return { ok: true, result: `Deleted ${path3.relative(this.projectDir, target) || target}` };
+    const bytes = await this.api.fetchFile(this.threadId, source);
+    if (!bytes) return { ok: false, error: `Could not download ${source} from the thread filesystem.` };
+    const dest = this.resolve(destArg);
+    await fsp.mkdir(path3.dirname(dest), { recursive: true });
+    const existed = fs4.existsSync(dest);
+    await fsp.writeFile(dest, bytes);
+    return {
+      ok: true,
+      result: `${existed ? "Overwrote" : "Saved"} ${path3.relative(this.projectDir, dest)} (${bytes.length} bytes) from ${source}`
+    };
+  }
+  /**
+   * Execute a SKILL script on the host. Skills live in the instance (cloud is
+   * the source of truth); the server forwards the skill's files with the call
+   * and we materialize them into a content-addressed temp dir — nothing about
+   * a skill is stored on this machine beyond an ephemeral cache. The script
+   * runs with cwd = the PROJECT (so it can operate on the user's files) and
+   * SKILL_DIR pointing at the materialized folder (so it can read its own
+   * references/assets).
+   */
+  async runSkillScript(args) {
+    const skill = String(args.skill || "skill");
+    const entry = String(args.entry || "");
+    if (!entry) return { ok: false, error: "entry (the script path within the skill) is required" };
+    let files;
+    try {
+      const parsed = JSON.parse(String(args.files_json || "[]"));
+      if (!Array.isArray(parsed)) throw new Error("not an array");
+      files = parsed.map((f) => ({ path: String(f.path), content: String(f.content ?? "") }));
+    } catch {
+      return { ok: false, error: "files_json must be a JSON array of {path, content}" };
+    }
+    if (!files.some((f) => f.path === entry)) {
+      return { ok: false, error: `entry "${entry}" is not among the provided skill files` };
+    }
+    let scriptArgs = [];
+    if (args.args_json) {
+      try {
+        const parsed = JSON.parse(String(args.args_json));
+        if (!Array.isArray(parsed)) throw new Error("not an array");
+        scriptArgs = parsed.map(String);
+      } catch {
+        return { ok: false, error: "args_json must be a JSON array of strings" };
+      }
+    }
+    const hash = crypto.createHash("sha256").update(JSON.stringify(files)).digest("hex").slice(0, 12);
+    const skillDir = path3.join(os6.tmpdir(), "standardcode-skills", `${skill}-${hash}`);
+    for (const f of files) {
+      const dest = path3.resolve(skillDir, f.path);
+      if (path3.relative(skillDir, dest).startsWith("..")) {
+        return { ok: false, error: `Skill file escapes its directory: ${f.path}` };
+      }
+      await fsp.mkdir(path3.dirname(dest), { recursive: true });
+      await fsp.writeFile(dest, f.content, "utf8");
+    }
+    const entryPath = path3.resolve(skillDir, entry);
+    const entryContent = files.find((f) => f.path === entry).content;
+    let cmd;
+    let argv;
+    if (entryContent.startsWith("#!")) {
+      await fsp.chmod(entryPath, 493);
+      cmd = entryPath;
+      argv = scriptArgs;
+    } else {
+      const ext = path3.extname(entry).toLowerCase();
+      const interp = {
+        ".py": ["python3"],
+        ".sh": ["bash"],
+        ".js": ["node"],
+        ".mjs": ["node"],
+        ".ts": ["npx", "tsx"]
+      };
+      const found = interp[ext];
+      if (!found) return { ok: false, error: `No interpreter for "${ext}" \u2014 add a shebang line to the script.` };
+      cmd = found[0];
+      argv = [...found.slice(1), entryPath, ...scriptArgs];
+    }
+    const timeoutMs = typeof args.timeout_ms === "number" ? Math.min(args.timeout_ms, 3e5) : 12e4;
+    return await new Promise((resolvePromise) => {
+      const child = spawn(cmd, argv, {
+        cwd: this.projectDir,
+        env: { ...process.env, SKILL_DIR: skillDir },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let out = "";
+      const cap = (chunk) => {
+        if (out.length < 2e5) out += chunk.toString("utf8");
+      };
+      child.stdout.on("data", cap);
+      child.stderr.on("data", cap);
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        resolvePromise({ ok: false, error: `Skill script timed out after ${timeoutMs}ms.
+${out.slice(-4e3)}` });
+      }, timeoutMs);
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        resolvePromise({ ok: false, error: `Could not launch ${cmd}: ${err.message}` });
+      });
+      child.on("exit", (code) => {
+        clearTimeout(timer);
+        const body = out.trim() || "(no output)";
+        if (code === 0) resolvePromise({ ok: true, result: body });
+        else resolvePromise({ ok: false, error: `Script exited with code ${code}:
+${body.slice(-6e3)}` });
+      });
+    });
   }
   async bash(args) {
     const command = String(args.command || "");
@@ -797,12 +1146,12 @@ ${truncated}`
     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 id = crypto.randomUUID().slice(0, 8);
     const logPath = path3.join(LOG_DIR, `${id}.log`);
     let out;
     try {
       await fsp.mkdir(LOG_DIR, { recursive: true });
-      out = fs2.openSync(logPath, "a");
+      out = fs4.openSync(logPath, "a");
     } catch (err) {
       return { ok: false, error: `Could not open log file: ${err instanceof Error ? err.message : String(err)}` };
     }
@@ -810,10 +1159,10 @@ ${truncated}`
     try {
       child = spawn("bash", ["-lc", command], { cwd, detached: true, stdio: ["ignore", out, out] });
     } catch (err) {
-      fs2.closeSync(out);
+      fs4.closeSync(out);
       return { ok: false, error: `Failed to start: ${err instanceof Error ? err.message : String(err)}` };
     }
-    fs2.closeSync(out);
+    fs4.closeSync(out);
     const pid = child.pid;
     if (!pid) return { ok: false, error: "Process failed to start (no pid)." };
     let earlyExit;
@@ -973,6 +1322,39 @@ ${tail}` : " No output was captured.")
     }
     return { ok: false, error: `Unknown action: ${action}` };
   }
+  /**
+   * Terminate every still-running background process this machine started, so
+   * detached children don't outlive the CLI when the session quits. Sends
+   * SIGTERM to each process group, waits a brief grace, then SIGKILL any
+   * straggler, and records them stopped. Best effort and bounded so quitting
+   * stays snappy. Returns the number of running processes it signaled.
+   */
+  async stopAllLocalProcesses() {
+    if (!this.registry) return 0;
+    let running = [];
+    try {
+      const procs = await this.registry.list();
+      running = procs.filter((p) => p.status === "running" && p.machine === (this.machine ?? ""));
+    } catch {
+      return 0;
+    }
+    if (!running.length) return 0;
+    const signal = (pid, sig) => {
+      try {
+        process.kill(-pid, sig);
+      } catch {
+        try {
+          process.kill(pid, sig);
+        } catch {
+        }
+      }
+    };
+    for (const proc of running) signal(proc.pid, "SIGTERM");
+    await new Promise((r) => setTimeout(r, 300));
+    for (const proc of running) signal(proc.pid, "SIGKILL");
+    await Promise.allSettled(running.map((proc) => this.registry.markStopped(proc.id)));
+    return running.length;
+  }
   run(cmd, args, cwd, timeoutMs) {
     return new Promise((resolve) => {
       let stdout = "";
@@ -1069,6 +1451,7 @@ var MessageStream = class {
   hooks;
   ws = null;
   closed = false;
+  heartbeat = null;
   reconnectAttempt = 0;
   reconnectTimer = null;
   resolveConnected = null;
@@ -1093,7 +1476,7 @@ var MessageStream = class {
   }
   openSocket() {
     if (this.closed) return;
-    const url = `${this.api.wsEndpoint}/api/threads/${this.threadId}/stream?token=${encodeURIComponent(this.api.bearer)}`;
+    const url = `${this.api.wsEndpoint}/api/threads/${this.threadId}/stream?token=${encodeURIComponent(this.api.bearer)}&reasoning=1`;
     let ws;
     try {
       ws = new WebSocket(url);
@@ -1104,17 +1487,33 @@ var MessageStream = class {
     this.ws = ws;
     ws.addEventListener("open", () => {
       this.reconnectAttempt = 0;
+      this.startHeartbeat(ws);
       this.resolveConnected?.();
     });
-    ws.addEventListener("message", (ev) => this.onMessage(String(ev.data)));
+    ws.addEventListener("message", (ev) => {
+      if (this.ws === ws) this.heartbeat?.markAlive();
+      this.onMessage(String(ev.data));
+    });
     ws.addEventListener("error", () => this.handleDrop(ws));
     ws.addEventListener("close", () => this.handleDrop(ws));
   }
   handleDrop(ws) {
     if (this.ws !== ws) return;
     this.ws = null;
+    this.stopHeartbeat();
     this.scheduleReconnect();
   }
+  startHeartbeat(ws) {
+    this.stopHeartbeat();
+    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws));
+    this.heartbeat.start();
+  }
+  stopHeartbeat() {
+    if (this.heartbeat) {
+      this.heartbeat.stop();
+      this.heartbeat = null;
+    }
+  }
   scheduleReconnect() {
     if (this.closed || this.reconnectTimer) return;
     this.reconnectAttempt++;
@@ -1127,6 +1526,7 @@ var MessageStream = class {
   }
   close() {
     this.closed = true;
+    this.stopHeartbeat();
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
@@ -1145,7 +1545,11 @@ var MessageStream = class {
       return;
     }
     if (msg.type === "message_chunk" && (msg.depth ?? 0) === 0) {
-      if (typeof msg.chunk === "string") this.hooks.onChunk(msg.chunk);
+      if (typeof msg.chunk === "string") this.hooks.onChunk(msg.chunk, msg.message_id);
+      return;
+    }
+    if (msg.type === "reasoning_chunk" && (msg.depth ?? 0) === 0) {
+      if (typeof msg.chunk === "string") this.hooks.onReasoningChunk?.(msg.chunk, msg.message_id);
       return;
     }
     if (msg.type === "message_data" && (msg.depth ?? 0) === 0) {
@@ -1172,6 +1576,7 @@ var SystemEvents = class {
   hooks;
   ws = null;
   closed = false;
+  heartbeat = null;
   reconnectAttempt = 0;
   reconnectTimer = null;
   connect() {
@@ -1190,11 +1595,27 @@ var SystemEvents = class {
     this.ws = ws;
     ws.addEventListener("open", () => {
       this.reconnectAttempt = 0;
+      this.startHeartbeat(ws);
+      this.hooks.onOpen?.();
+    });
+    ws.addEventListener("message", (ev) => {
+      if (this.ws === ws) this.heartbeat?.markAlive();
+      this.onMessage(String(ev.data));
     });
-    ws.addEventListener("message", (ev) => this.onMessage(String(ev.data)));
     ws.addEventListener("error", () => this.handleDrop(ws));
     ws.addEventListener("close", () => this.handleDrop(ws));
   }
+  startHeartbeat(ws) {
+    this.stopHeartbeat();
+    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws));
+    this.heartbeat.start();
+  }
+  stopHeartbeat() {
+    if (this.heartbeat) {
+      this.heartbeat.stop();
+      this.heartbeat = null;
+    }
+  }
   onMessage(raw) {
     let msg;
     try {
@@ -1211,6 +1632,7 @@ var SystemEvents = class {
   handleDrop(ws) {
     if (this.ws !== ws) return;
     this.ws = null;
+    this.stopHeartbeat();
     this.scheduleReconnect();
   }
   scheduleReconnect() {
@@ -1225,6 +1647,7 @@ var SystemEvents = class {
   }
   close() {
     this.closed = true;
+    this.stopHeartbeat();
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
@@ -1245,8 +1668,98 @@ var LEVEL_DETAIL = {
 function levelLabel(level) {
   return `auto-accept level ${level} (${LEVEL_DETAIL[level]})`;
 }
+var FILE_MIMES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+var MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+function run(cmd, args, maxBuffer = MAX_IMAGE_BYTES * 2) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { encoding: "buffer", maxBuffer }, (err, stdout) => {
+      resolve({ ok: !err, stdout: stdout ?? Buffer.alloc(0) });
+    });
+  });
+}
+function fromFile(filePath) {
+  const mime = FILE_MIMES[path3.extname(filePath).toLowerCase()];
+  if (!mime) return null;
+  try {
+    const stat = fs4.statSync(filePath);
+    if (!stat.isFile() || stat.size === 0 || stat.size > MAX_IMAGE_BYTES) return null;
+    return { data: fs4.readFileSync(filePath).toString("base64"), mime };
+  } catch {
+    return null;
+  }
+}
+async function readDarwin() {
+  const tmp = path3.join(os6.tmpdir(), `sc-clip-${process.pid}-${Date.now()}.png`);
+  const script = [
+    `set d to the clipboard as \xABclass PNGf\xBB`,
+    `set f to open for access POSIX file "${tmp}" with write permission`,
+    `set eof f to 0`,
+    `write d to f`,
+    `close access f`
+  ].join("\n");
+  const png = await run("osascript", ["-e", script]);
+  if (png.ok) {
+    const img = fromFile(tmp);
+    try {
+      fs4.unlinkSync(tmp);
+    } catch {
+    }
+    if (img) return img;
+  }
+  const furl = await run("osascript", ["-e", "POSIX path of (the clipboard as \xABclass furl\xBB)"]);
+  if (furl.ok) {
+    const p = furl.stdout.toString("utf8").trim();
+    if (p) return fromFile(p);
+  }
+  return null;
+}
+async function readLinux() {
+  for (const [cmd, args] of [
+    ["wl-paste", ["--type", "image/png"]],
+    ["xclip", ["-selection", "clipboard", "-t", "image/png", "-o"]]
+  ]) {
+    const res = await run(cmd, args);
+    if (res.ok && res.stdout.length > 8 && res.stdout.length <= MAX_IMAGE_BYTES && res.stdout[0] === 137 && res.stdout[1] === 80) {
+      return { data: res.stdout.toString("base64"), mime: "image/png" };
+    }
+  }
+  return null;
+}
+async function readWindows() {
+  const tmp = path3.join(os6.tmpdir(), `sc-clip-${process.pid}-${Date.now()}.png`);
+  const ps = [
+    "Add-Type -AssemblyName System.Windows.Forms;",
+    "$img = [System.Windows.Forms.Clipboard]::GetImage();",
+    `if ($img -ne $null) { $img.Save('${tmp.replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png) }`
+  ].join(" ");
+  await run("powershell", ["-NoProfile", "-STA", "-Command", ps]);
+  const img = fromFile(tmp);
+  try {
+    fs4.unlinkSync(tmp);
+  } catch {
+  }
+  return img;
+}
+async function readClipboardImage() {
+  try {
+    if (process.platform === "darwin") return await readDarwin();
+    if (process.platform === "win32") return await readWindows();
+    return await readLinux();
+  } catch {
+    return null;
+  }
+}
 
 // src/tui.ts
+function imagePlaceholder(seq) {
+  return `[#Image ${seq}]`;
+}
 var C = {
   reset: "\x1B[0m",
   dim: "\x1B[2m",
@@ -1261,7 +1774,23 @@ var C = {
   teal: "\x1B[38;5;37m"
 };
 var FRAMES = ["\u28F7", "\u28EF", "\u28DF", "\u287F", "\u28BF", "\u28FB", "\u28FD", "\u28FE"];
-var Tui = class {
+var SUBAGENT_COLORS = [
+  "\x1B[35m",
+  // magenta
+  "\x1B[38;5;39m",
+  // azure
+  "\x1B[38;5;75m",
+  // blue
+  "\x1B[32m",
+  // green
+  "\x1B[38;5;141m",
+  // violet
+  "\x1B[38;5;177m"
+  // orchid
+];
+var COMPACTION_COLOR = "\x1B[38;5;208m";
+var COMPACTION_AGENT = "compaction_agent";
+var Tui = class _Tui {
   constructor(level = 1) {
     this.level = level;
     readline.emitKeypressEvents(process.stdin);
@@ -1270,6 +1799,7 @@ var Tui = class {
     process.stdin.resume();
     process.stdout.write("\x1B[?2004h");
     process.on("exit", () => process.stdout.write("\x1B[?2004l\x1B[?25h"));
+    process.stdout.on("resize", () => this.renderBottom());
   }
   level;
   // input + indicators
@@ -1284,13 +1814,31 @@ var Tui = class {
   bgCount = 0;
   queuedCount = 0;
   subagents = [];
-  // labels of subagents currently working (one line each)
+  // active subagents (one line each)
+  subagentColorByID = /* @__PURE__ */ new Map();
+  // subagent id → SUBAGENT_COLORS index
   tokensIn = 0;
   // cumulative input tokens
   tokensOut = 0;
   // cumulative output tokens (includes the in-progress live count)
   contextPct = null;
   // % of the model context window currently used
+  // Live streaming preview, shown just above the status line while a turn runs:
+  // the model's internal reasoning (dim italic) until the answer starts, then the
+  // answer text (plain). Bounded to a tail; cleared when the message commits.
+  streamThinking = "";
+  streamResponse = "";
+  streamMessageId = null;
+  // the message currently previewing
+  streamRedrawTimer = null;
+  streamIdleTimer = null;
+  // wipes a stale preview
+  // Live goal checklist, fixed below the status bar. Driven by the goal_updated
+  // thread event (+ an initial fetch). null = nothing to show.
+  goal = null;
+  // Set true the moment every step of a goal is done: the goal area is cleared
+  // and the status line shows "Goal complete." until the next turn starts.
+  goalComplete = false;
   // Inline slash-command palette: when the input starts with "/", the filtered
   // command list renders above the prompt and arrows/enter/tab drive it.
   commands = [];
@@ -1305,6 +1853,14 @@ var Tui = class {
   connected = true;
   bottomDrawn = false;
   started = false;
+  // Resize bookkeeping: the width the region was last drawn at, and the visible
+  // width of every HUD row written above the input. When the terminal is
+  // resized, previously drawn rows re-wrap (a full-width ruler becomes 2+ rows
+  // when narrowed), so the move-up count recorded at draw time is wrong — these
+  // let moveToRegionTop recompute the region height under the NEW wrap instead
+  // of leaving stale rulers behind.
+  lastDrawnCols = 0;
+  drawnHudWidths = [];
   // takeover (approval / menu) state
   takeoverHandler = null;
   bufferedPrints = [];
@@ -1315,13 +1871,28 @@ var Tui = class {
   // bracketed-paste state
   pasting = false;
   pasteTimer = null;
+  // Images pasted into the CURRENT input (Ctrl+V). Each got a `[#Image N]`
+  // placeholder at the caret; on submit only images whose placeholder is still
+  // present in the text are handed to onSubmit. Cleared with the input.
+  pendingImages = [];
+  imagePasteBusy = false;
+  // one clipboard read at a time
+  // Sent-message history for ↑/↓ recall (oldest → newest). `historyIdx` is the
+  // entry currently shown (null = not browsing); the in-progress draft is
+  // stashed so cycling past the newest entry restores it. Any edit exits
+  // browsing and keeps the recalled text as the new draft.
+  history = [];
+  historyIdx = null;
+  historyDraft = "";
+  historyDraftImages = [];
   // event hooks (wired by index.ts)
   onSubmit = () => {
   };
   onInterrupt = () => {
   };
-  onUpArrow = () => {
-  };
+  /** Up on the top row: return true to consume it (e.g. pull a queued message)
+   *  before history recall gets a chance. */
+  onUpArrow = () => false;
   onQuit = () => process.exit(0);
   levelListeners = [];
   get colors() {
@@ -1356,6 +1927,8 @@ var Tui = class {
   end() {
     if (this.quitTimer) clearTimeout(this.quitTimer);
     this.quitTimer = null;
+    if (this.streamIdleTimer) clearTimeout(this.streamIdleTimer);
+    this.streamIdleTimer = null;
     this.clearBottom();
     process.stdout.write("\x1B[?2004l\x1B[?25h");
   }
@@ -1368,6 +1941,11 @@ var Tui = class {
   }
   // ─── key dispatch ──────────────────────────────────────────────────────────
   dispatch(str, key) {
+    const seq = key && key.sequence || str || "";
+    if (seq === "\n" || seq === "\x1B[13;2u" || seq === "\x1B[27;2;13~") {
+      this.insertAtCursor("\n");
+      return;
+    }
     if (key && key.ctrl && key.name === "c") {
       this.requestQuit();
       return;
@@ -1376,7 +1954,6 @@ var Tui = class {
       this.cycleLevel();
       return;
     }
-    const seq = key && key.sequence || str || "";
     if (!this.pasting && seq.includes("\x1B[200~")) {
       this.pasting = true;
       this.armPasteSafety();
@@ -1420,6 +1997,10 @@ var Tui = class {
         return;
       }
       if (key.name === "return" || key.name === "enter") {
+        if (key.shift) {
+          this.insertAtCursor("\n");
+          return;
+        }
         if (matches.length) this.runCommand(matches[cur]);
         return;
       }
@@ -1460,15 +2041,46 @@ var Tui = class {
       return;
     }
     if (key.name === "up") {
-      this.onUpArrow();
+      const { caretRow } = this.inputLayout();
+      if (caretRow > 0) {
+        this.moveCaretVertical(-1);
+        return;
+      }
+      if (this.onUpArrow()) return;
+      this.historyPrev();
+      return;
+    }
+    if (key.name === "down") {
+      const { caretRow, rowCount } = this.inputLayout();
+      if (caretRow < rowCount - 1) {
+        this.moveCaretVertical(1);
+        return;
+      }
+      this.historyNext();
       return;
     }
     if (key.name === "return" || key.name === "enter") {
+      if (key.shift) {
+        this.insertAtCursor("\n");
+        return;
+      }
       const text = this.inputBuffer;
+      const images = this.pendingImages.filter((img) => text.includes(imagePlaceholder(img.seq)));
       this.inputBuffer = "";
       this.cursorPos = 0;
+      this.pendingImages = [];
+      this.historyIdx = null;
+      this.historyDraft = "";
+      this.historyDraftImages = [];
       this.renderBottom();
-      if (text.trim()) this.onSubmit(text.trim());
+      if (text.trim()) {
+        this.addHistoryEntry(text.trim());
+        this.onSubmit(text.trim(), images);
+      }
+      return;
+    }
+    if (key.ctrl && key.name === "v") {
+      void this.pasteClipboardImage();
       return;
     }
     if (key.name === "backspace") {
@@ -1476,6 +2088,7 @@ var Tui = class {
         this.inputBuffer = this.inputBuffer.slice(0, this.cursorPos - 1) + this.inputBuffer.slice(this.cursorPos);
         this.cursorPos--;
         this.slashIdx = 0;
+        this.historyIdx = null;
         this.renderBottom();
       }
       return;
@@ -1484,6 +2097,7 @@ var Tui = class {
       if (this.cursorPos < this.inputBuffer.length) {
         this.inputBuffer = this.inputBuffer.slice(0, this.cursorPos) + this.inputBuffer.slice(this.cursorPos + 1);
         this.slashIdx = 0;
+        this.historyIdx = null;
         this.renderBottom();
       }
       return;
@@ -1497,6 +2111,7 @@ var Tui = class {
     this.inputBuffer = this.inputBuffer.slice(0, this.cursorPos) + text + this.inputBuffer.slice(this.cursorPos);
     this.cursorPos += text.length;
     this.slashIdx = 0;
+    this.historyIdx = null;
     this.renderBottom();
   }
   /** Insert a paste fragment at the caret; collapse newlines (single-line input). */
@@ -1506,6 +2121,7 @@ var Tui = class {
     if (content) {
       this.inputBuffer = this.inputBuffer.slice(0, this.cursorPos) + content + this.inputBuffer.slice(this.cursorPos);
       this.cursorPos += content.length;
+      this.historyIdx = null;
     }
     if (end >= 0) {
       this.pasting = false;
@@ -1525,6 +2141,128 @@ var Tui = class {
       this.renderBottom();
     }, 2e3);
   }
+  // ─── input layout + vertical caret movement ────────────────────────────────
+  /**
+   * The input's physical rows (same wrapping math as renderBottom: logical
+   * lines split on "\n", line 0 led by the prompt prefix, each wrapping at the
+   * terminal width) plus where the caret sits among them. Each row records the
+   * buffer index of its first character, its character count, and the visual
+   * column its first character renders at (only row 0 is offset, by the
+   * prompt). Drives ↑/↓: row 0 is "the top line" (history recall territory),
+   * anything below moves the caret instead.
+   */
+  inputLayout() {
+    const cols2 = process.stdout.columns || 80;
+    const pw = this.visibleWidth(this.promptPrefix());
+    const lines = this.inputBuffer.split("\n");
+    const rows = [];
+    let offset = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const lead = i === 0 ? pw : 0;
+      const len = lines[i].length;
+      const nRows = Math.max(1, Math.ceil((lead + len) / cols2));
+      for (let j = 0; j < nRows; j++) {
+        const charStart = Math.max(0, j * cols2 - lead);
+        const charEnd = Math.min(len, (j + 1) * cols2 - lead);
+        rows.push({ start: offset + charStart, len: Math.max(0, charEnd - charStart), colOffset: j === 0 ? lead : 0 });
+      }
+      offset += len + 1;
+    }
+    let pos = this.cursorPos;
+    let caretLine = 0;
+    while (caretLine < lines.length - 1 && pos > lines[caretLine].length) {
+      pos -= lines[caretLine].length + 1;
+      caretLine++;
+    }
+    const caretCell = (caretLine === 0 ? pw : 0) + pos;
+    let caretRow = Math.floor(caretCell / cols2);
+    for (let i = 0; i < caretLine; i++) {
+      const lead = i === 0 ? pw : 0;
+      caretRow += Math.max(1, Math.ceil((lead + lines[i].length) / cols2));
+    }
+    const caretCol = caretCell % cols2;
+    while (caretRow >= rows.length) rows.push({ start: this.inputBuffer.length, len: 0, colOffset: 0 });
+    return { rows, caretRow, caretCol, rowCount: rows.length };
+  }
+  /** Move the caret one visual row up/down, keeping the column when possible. */
+  moveCaretVertical(delta) {
+    const { rows, caretRow, caretCol } = this.inputLayout();
+    const target = caretRow + delta;
+    if (target < 0 || target >= rows.length) return;
+    const row = rows[target];
+    const within = Math.max(0, Math.min(caretCol - row.colOffset, row.len));
+    this.cursorPos = Math.min(row.start + within, this.inputBuffer.length);
+    this.renderBottom();
+  }
+  // ─── sent-message history (↑/↓ recall) ─────────────────────────────────────
+  /** Seed the recall history (oldest → newest), e.g. from the on-disk file. */
+  setHistory(entries) {
+    this.history = entries.filter((e) => e.trim() !== "");
+  }
+  /** Record a sent message (skipping a consecutive duplicate). */
+  addHistoryEntry(text) {
+    if (this.history[this.history.length - 1] === text) return;
+    this.history.push(text);
+  }
+  /** Recall the previous (older) history entry; stashes the draft first. */
+  historyPrev() {
+    if (!this.history.length) return;
+    if (this.historyIdx === null) {
+      this.historyDraft = this.inputBuffer;
+      this.historyDraftImages = this.pendingImages;
+      this.historyIdx = this.history.length - 1;
+    } else if (this.historyIdx > 0) {
+      this.historyIdx--;
+    } else {
+      return;
+    }
+    this.pendingImages = [];
+    this.inputBuffer = this.history[this.historyIdx];
+    this.cursorPos = this.inputBuffer.length;
+    this.slashIdx = 0;
+    this.renderBottom();
+  }
+  /** Step toward the newest entry; past it, restore the stashed draft. */
+  historyNext() {
+    if (this.historyIdx === null) return;
+    if (this.historyIdx < this.history.length - 1) {
+      this.historyIdx++;
+      this.pendingImages = [];
+      this.inputBuffer = this.history[this.historyIdx];
+    } else {
+      this.historyIdx = null;
+      this.inputBuffer = this.historyDraft;
+      this.pendingImages = this.historyDraftImages;
+      this.historyDraft = "";
+      this.historyDraftImages = [];
+    }
+    this.cursorPos = this.inputBuffer.length;
+    this.slashIdx = 0;
+    this.renderBottom();
+  }
+  // ─── clipboard image paste (Ctrl+V) ────────────────────────────────────────
+  /**
+   * Read an image off the system clipboard and drop an `[#Image N]`
+   * placeholder at the caret. The bytes ride along with the message on submit
+   * (as a real attachment) as long as the placeholder is still in the text —
+   * delete the placeholder and the image is dropped too.
+   */
+  async pasteClipboardImage() {
+    if (this.imagePasteBusy) return;
+    this.imagePasteBusy = true;
+    try {
+      const img = await readClipboardImage();
+      if (!img) {
+        this.print(`${C.dim}No image on the clipboard.${C.reset}`);
+        return;
+      }
+      const seq = this.pendingImages.reduce((m, i) => Math.max(m, i.seq), 0) + 1;
+      this.pendingImages.push({ seq, data: img.data, mime: img.mime });
+      this.insertAtCursor(imagePlaceholder(seq));
+    } finally {
+      this.imagePasteBusy = false;
+    }
+  }
   cycleLevel() {
     const idx = LEVELS.indexOf(this.level);
     this.setLevel(LEVELS[(idx + 1) % LEVELS.length]);
@@ -1571,7 +2309,8 @@ var Tui = class {
     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 calmGreen = "\x1B[38;5;65m";
+      const col = pct >= 85 ? C.red : pct >= 70 ? C.yellow : calmGreen;
       const gauge = `${col}ctx ${pct}%${C.reset}`;
       out = out ? `${out} ${gauge}` : gauge;
     }
@@ -1623,13 +2362,13 @@ var Tui = class {
    * 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) {
+  statusLineText(cols2) {
     const tk = this.tokensText();
     if (this.working) {
       const el = this.formatElapsed(Date.now() - this.workingStart);
       const right = `${C.dim}${el}${C.reset}${tk ? " " + tk : ""}`;
       const head = `${this.spinnerFrame()} ${C.bold}Working${C.reset}`;
-      const avail = Math.max(0, cols - this.visibleWidth(head) - this.visibleWidth(right) - 2);
+      const avail = Math.max(0, cols2 - this.visibleWidth(head) - this.visibleWidth(right) - 2);
       let stepPart = "";
       if (this.step && avail > 1) {
         let s = this.step;
@@ -1638,23 +2377,43 @@ var Tui = class {
       }
       return `${head}${stepPart} ${right}`;
     }
+    if (this.goalComplete) {
+      const done = `${C.bold}${C.green}\u2713 Goal complete.${C.reset}`;
+      return tk ? `${done} ${tk}` : done;
+    }
     return tk ? tk : null;
   }
   /** The prompt line prefix (with ANSI colour) that precedes the typed text. */
   promptPrefix() {
     const q = this.queuedCount > 0 ? `${C.yellow}[\u23F3 ${this.queuedCount} queued]${C.reset} ` : "";
     const bg = this.bgCount > 0 ? `${C.cyan}[\u2699 ${this.bgCount} bg]${C.reset} ` : "";
-    return `${q}${bg}${this.levelColor()}\u203A${C.reset} `;
+    return `${q}${bg}${this.levelColor()}\u276F${C.reset} `;
   }
   visibleWidth(s) {
     return s.replace(/\x1b\[[0-9;]*m/g, "").length;
   }
+  /**
+   * The slash-palette block rendered BELOW the input. While the palette is open
+   * we reserve a fixed number of rows — one per available command — padding with
+   * blank rows so the region height never changes as the filter narrows. That
+   * pins the input: the region scrolls into place once when the palette opens,
+   * then nothing below the input resizes, so the text you're typing never jumps.
+   * Returns `[]` when the palette is closed (no reservation, input sits at the
+   * bottom as usual).
+   */
+  paletteBlockLines(cols2) {
+    if (!this.paletteOpen()) return [];
+    const rows = this.paletteLines(cols2);
+    const reserved = Math.max(this.commands.length, rows.length);
+    while (rows.length < reserved) rows.push("");
+    return rows;
+  }
   /**
    * Build the slash-palette rows for the current filter. Each row is clamped to
    * ONE physical line (a wrapped row would desync the move-up redraw), with the
    * `/name` highlighted, the label dimmed, and the hint right-aligned.
    */
-  paletteLines(cols) {
+  paletteLines(cols2) {
     if (!this.paletteOpen()) return [];
     const matches = this.filteredCommands();
     if (matches.length === 0) return [`  ${C.gray}no matching command${C.reset}`];
@@ -1666,23 +2425,42 @@ var Tui = class {
       const hintW = hint.length;
       const name = `/${cmd.name}`;
       let visible = `${name}  ${cmd.label}`;
-      const labelMax = Math.max(6, cols - pointerW - (hintW ? hintW + 2 : 0));
+      const labelMax = Math.max(6, cols2 - pointerW - (hintW ? hintW + 2 : 0));
       if (visible.length > labelMax) visible = visible.slice(0, labelMax - 1) + "\u2026";
       const desc = visible.slice(name.length);
       const pointer = sel ? `${C.magenta}\u276F${C.reset} ` : "  ";
       const nameStyled = sel ? `${C.bold}${C.cyan}${name}${C.reset}` : `${C.cyan}${name}${C.reset}`;
       let line = `${pointer}${nameStyled}${C.gray}${desc}${C.reset}`;
       if (hintW) {
-        const gap = Math.max(2, cols - pointerW - visible.length - hintW);
+        const gap = Math.max(2, cols2 - pointerW - visible.length - hintW);
         line += `${" ".repeat(gap)}${C.gray}${hint}${C.reset}`;
       }
       return line;
     });
   }
-  /** Move the cursor to the top-left of the current bottom region. */
+  /**
+   * Move the cursor to the top-left of the current bottom region.
+   *
+   * Same width as the last draw → the caret's recorded row offset is exact.
+   * Width CHANGED (terminal resized) → previously drawn rows re-wrapped, so
+   * that offset is stale; recompute it under the new wrap instead: each drawn
+   * HUD row of visible width w now occupies ceil(w / cols) physical rows
+   * (reflowing terminals re-wrap hard lines; the cursor follows its logical
+   * position in the input text, which inputLayout locates at the new width).
+   */
   moveToRegionTop() {
     process.stdout.write("\r");
-    if (this.bottomDrawn && this.lastCursorRow > 0) process.stdout.write(`\x1B[${this.lastCursorRow}A`);
+    if (!this.bottomDrawn) return;
+    const cols2 = process.stdout.columns || 80;
+    let up;
+    if (cols2 !== this.lastDrawnCols && this.lastDrawnCols > 0) {
+      let above = 0;
+      for (const w of this.drawnHudWidths) above += Math.max(1, Math.ceil(Math.max(w, 1) / cols2));
+      up = above + this.inputLayout().caretRow;
+    } else {
+      up = this.lastCursorRow;
+    }
+    if (up > 0) process.stdout.write(`\x1B[${up}A`);
   }
   /**
    * Render the bottom region: an optional step line, then the prompt + input
@@ -1692,43 +2470,77 @@ var Tui = class {
    */
   renderBottom() {
     if (!this.started || this.takeoverHandler) return;
-    const cols = process.stdout.columns || 80;
+    const cols2 = process.stdout.columns || 80;
     this.moveToRegionTop();
     process.stdout.write("\x1B[J");
+    const hudWidths = [];
+    const writeHudRow = (line) => {
+      hudWidths.push(this.visibleWidth(line));
+      process.stdout.write(line + "\r\n");
+    };
+    const previewLines = this.streamPreviewLines(cols2);
+    for (const line of previewLines) writeHudRow(line);
+    const rulerRows = 1;
+    writeHudRow(`${C.dim}${"\u2500".repeat(cols2)}${C.reset}`);
     const noticeLine = this.connected ? null : `${C.yellow}\u26A0 lost connection to the workspace \u2014 reconnecting\u2026${C.reset}`;
     const noticeRows = noticeLine ? 1 : 0;
-    if (noticeLine) process.stdout.write(noticeLine + "\r\n");
+    if (noticeLine) writeHudRow(noticeLine);
     const quitLine = this.quitArmed ? `${C.dim}Press Control-C again to exit${C.reset}` : null;
     const quitRows = quitLine ? 1 : 0;
-    if (quitLine) process.stdout.write(quitLine + "\r\n");
+    if (quitLine) writeHudRow(quitLine);
     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");
+    for (const sub of this.subagents) {
+      const color = sub.agentName === COMPACTION_AGENT ? COMPACTION_COLOR : SUBAGENT_COLORS[this.subagentColorByID.get(sub.id) ?? 0];
+      const budget = cols2 - 10;
+      let label = sub.label;
+      if (budget < 1) label = "";
+      else if (label.length > budget) label = label.slice(0, Math.max(0, budget - 1)) + "\u2026";
+      const line = `${color}${frame}${C.reset} ${color}${label}${C.reset} ${C.dim}working${C.reset}`;
+      writeHudRow(line);
     }
-    const statusLine = this.statusLineText(cols);
+    const statusLine = this.statusLineText(cols2);
     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;
+    if (statusLine) writeHudRow(statusLine);
+    const goalLines = this.goalLines(cols2);
+    for (const line of goalLines) writeHudRow(line);
+    const aboveRows = previewLines.length + rulerRows + noticeRows + quitRows + this.subagents.length + statusRows + goalLines.length;
     const prefix = this.promptPrefix();
     const pw = this.visibleWidth(prefix);
-    const 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;
+    const lines = this.inputBuffer.split("\n");
+    process.stdout.write(prefix + lines[0]);
+    for (let i = 1; i < lines.length; i++) process.stdout.write("\r\n" + lines[i]);
+    const rowsOf = (len, lead) => Math.max(1, Math.ceil((lead + len) / cols2));
+    const lineRows = lines.map((l, i) => rowsOf(l.length, i === 0 ? pw : 0));
+    const inputRows = lineRows.reduce((a, b) => a + b, 0);
+    let pos = this.cursorPos;
+    let caretLine = 0;
+    while (caretLine < lines.length - 1 && pos > lines[caretLine].length) {
+      pos -= lines[caretLine].length + 1;
+      caretLine++;
+    }
+    const caretCell = (caretLine === 0 ? pw : 0) + pos;
+    let caretRow = Math.floor(caretCell / cols2);
+    for (let i = 0; i < caretLine; i++) caretRow += lineRows[i];
+    const caretCol = caretCell % cols2;
+    const paletteBlock = this.paletteBlockLines(cols2);
+    for (const line of paletteBlock) process.stdout.write("\r\n" + line);
+    if (paletteBlock.length > 0) {
+      process.stdout.write("\r");
+      const up = inputRows - 1 + paletteBlock.length - caretRow;
+      if (up > 0) process.stdout.write(`\x1B[${up}A`);
+      if (caretCol > 0) process.stdout.write(`\x1B[${caretCol}C`);
+      this.lastCursorRow = aboveRows + caretRow;
+    } else if (this.cursorPos < this.inputBuffer.length) {
       process.stdout.write("\r");
-      const up = inputRows - 1 - cursorRowInInput;
+      const up = inputRows - 1 - caretRow;
       if (up > 0) process.stdout.write(`\x1B[${up}A`);
-      if (cursorCol > 0) process.stdout.write(`\x1B[${cursorCol}C`);
-      this.lastCursorRow = aboveRows + cursorRowInInput;
+      if (caretCol > 0) process.stdout.write(`\x1B[${caretCol}C`);
+      this.lastCursorRow = aboveRows + caretRow;
     } else {
       this.lastCursorRow = aboveRows + (inputRows - 1);
     }
+    this.drawnHudWidths = hudWidths;
+    this.lastDrawnCols = cols2;
     this.bottomDrawn = true;
   }
   clearBottom() {
@@ -1737,14 +2549,183 @@ var Tui = class {
     process.stdout.write("\x1B[J");
     this.bottomDrawn = false;
   }
+  // ── live streaming preview ────────────────────────────────────────────────
+  // An ephemeral tail of the model's output above the status line: reasoning in
+  // dim italic until the answer begins, then the answer plain. clearStream()
+  // wipes it right before the finished message is committed to the transcript
+  // (which renders full markdown), so there's no double-render.
+  static STREAM_TAIL = 20;
+  // How long a preview may sit untouched before it's wiped. The model often
+  // reasons and then calls a tool without ever emitting an answer, so without
+  // this the reasoning tail would linger on screen until the *next* thought (or
+  // message) arrives. Re-armed on every delta → fires this long after the last.
+  static STREAM_IDLE_MS = 1e4;
+  /** Append a fragment of streamed answer text (rendered plain). */
+  streamResponseDelta(delta, messageId) {
+    this.beginStreamMessage(messageId);
+    this.streamResponse += delta;
+    this.scheduleStreamRedraw();
+    this.armStreamIdleExpiry();
+  }
+  /**
+   * Append a fragment of streamed internal reasoning (rendered dim italic).
+   * Ignored once the answer has started, since reasoning precedes the answer.
+   */
+  streamThinkingDelta(delta, messageId) {
+    this.beginStreamMessage(messageId);
+    if (this.streamResponse) return;
+    this.streamThinking += delta;
+    this.scheduleStreamRedraw();
+    this.armStreamIdleExpiry();
+  }
+  /** Reset the preview when a new message starts, so two messages' output (e.g.
+   *  one that only reasons then calls a tool, then the next) never blend. */
+  beginStreamMessage(messageId) {
+    if (messageId !== void 0 && messageId !== this.streamMessageId) {
+      this.streamMessageId = messageId;
+      this.streamThinking = "";
+      this.streamResponse = "";
+    }
+  }
+  /** Wipe the live preview — call right before committing the final message. */
+  clearStream() {
+    if (this.streamRedrawTimer) {
+      clearTimeout(this.streamRedrawTimer);
+      this.streamRedrawTimer = null;
+    }
+    if (this.streamIdleTimer) {
+      clearTimeout(this.streamIdleTimer);
+      this.streamIdleTimer = null;
+    }
+    this.streamMessageId = null;
+    if (!this.streamThinking && !this.streamResponse) return;
+    this.streamThinking = "";
+    this.streamResponse = "";
+    this.renderBottom();
+  }
+  scheduleStreamRedraw() {
+    if (this.streamRedrawTimer || this.takeoverHandler || !this.started) return;
+    this.streamRedrawTimer = setTimeout(() => {
+      this.streamRedrawTimer = null;
+      this.renderBottom();
+    }, 40);
+  }
+  /** Re-armed on every streamed delta: once the model goes quiet for a beat, the
+   *  preview is stale, so wipe it instead of letting it sit until the next
+   *  message. The committed message (if any) still renders in full via
+   *  clearStream(), so nothing is lost. */
+  armStreamIdleExpiry() {
+    if (this.streamIdleTimer) clearTimeout(this.streamIdleTimer);
+    this.streamIdleTimer = setTimeout(() => {
+      this.streamIdleTimer = null;
+      if (!this.streamThinking && !this.streamResponse) return;
+      this.streamThinking = "";
+      this.streamResponse = "";
+      this.renderBottom();
+    }, _Tui.STREAM_IDLE_MS);
+  }
+  /**
+   * The preview's physical rows: a tail of reasoning (dim italic) before the
+   * answer starts, otherwise a tail of the answer (plain). Each row is clamped to
+   * one terminal line so the bottom-region redraw math stays correct.
+   *
+   * Rows match the committed transcript formatting so a finished message doesn't
+   * visibly "snap" into shape: the answer's first line carries the grey gutter
+   * dot (as long as it hasn't scrolled out of the tail) and the body indents two
+   * spaces beneath it; reasoning aligns at the same indent, dotless.
+   */
+  streamPreviewLines(cols2) {
+    const thinkStyle = "\x1B[3m\x1B[38;5;240m";
+    const clamp2 = (s, wrap, lead) => {
+      const max = cols2 - 2;
+      const t = s.length > max ? s.slice(0, Math.max(0, max - 1)) + "\u2026" : s;
+      return wrap ? `${lead}${wrap}${t}${C.reset}` : `${lead}${t}`;
+    };
+    const realLines = (text) => text.replace(/\r/g, "").split("\n").filter((l) => l.trim() !== "");
+    if (this.streamResponse) {
+      const all = realLines(this.streamResponse);
+      const shown = all.slice(-20);
+      const firstVisible = all.length <= _Tui.STREAM_TAIL;
+      return shown.map(
+        (l, i) => clamp2(l, "", i === 0 && firstVisible ? `${C.gray}\u2022${C.reset} ` : "  ")
+      );
+    }
+    if (this.streamThinking) {
+      return realLines(this.streamThinking).slice(-20).map((l) => clamp2(l, thinkStyle, "  "));
+    }
+    return [];
+  }
+  // ── live goal checklist ───────────────────────────────────────────────────
+  /**
+   * Update the goal from the goal_updated event (or the initial fetch). When
+   * every step is done, the goal is fully achieved: we clear the goal area and
+   * flip on the "Goal complete." status badge instead of leaving a finished
+   * checklist sitting there.
+   */
+  setGoal(goal) {
+    const steps = goal?.steps;
+    if (steps && Array.isArray(steps) && steps.length) {
+      const allDone = steps.every((s) => s.status === "done");
+      if (allDone) {
+        this.goal = null;
+        this.goalComplete = true;
+      } else {
+        this.goal = goal;
+        this.goalComplete = false;
+      }
+    } else {
+      this.goal = null;
+    }
+    this.renderBottom();
+  }
+  /**
+   * The goal's physical rows: a header (the short summary + progress) then one
+   * row per step, indented two spaces beneath it so the todos clearly belong to
+   * the goal — ○ pending / ▸ in-progress / ✓ done — each clamped to a line.
+   */
+  goalLines(cols2) {
+    const steps = this.goal?.steps;
+    if (!steps?.length) return [];
+    const oneLine = (s) => s.replace(/\s+/g, " ").trim();
+    const clamp2 = (s, max) => s.length > max ? s.slice(0, Math.max(0, max - 1)) + "\u2026" : s;
+    const calmGreen = "\x1B[38;5;65m";
+    const out = [];
+    const done = steps.filter((s) => s.status === "done").length;
+    const summary = oneLine(this.goal?.summary || this.goal?.description || "Goal");
+    const prefix = `Goal ${done}/${steps.length} `;
+    const sum = clamp2(summary, Math.max(1, cols2 - prefix.length));
+    out.push(`${C.bold}Goal${C.reset} ${C.gray}${done}/${steps.length}${C.reset} ${sum}`);
+    for (const s of steps) {
+      const text = clamp2(oneLine(s.step || ""), Math.max(1, cols2 - 4));
+      if (s.status === "done") out.push(`  ${calmGreen}\u2713${C.reset} ${C.dim}${text}${C.reset}`);
+      else if (s.status === "in_progress") out.push(`  ${C.cyan}\u25B8${C.reset} ${text}`);
+      else out.push(`  ${C.gray}\u25CB ${text}${C.reset}`);
+    }
+    return out;
+  }
+  /**
+   * Transcript gutter: content starts at column 1, so the far-left column is a
+   * clean strip where only status glyphs (✓ ✗ ⛔ …) land — scanning down the
+   * left edge reads as a ledger of what happened. Lines already led by a
+   * gutter glyph or whitespace (indented blocks, the user-message bar) pass
+   * through untouched.
+   */
+  gutterize(text) {
+    return text.split("\n").map((line) => {
+      const plain = line.replace(/\x1b\[[0-9;]*m/g, "");
+      if (plain === "" || /^[\s✓✗⛔⚠⚙⚡⏳↪›❯◇─•]/.test(plain)) return line;
+      return " " + line;
+    }).join("\n");
+  }
   /** Print a line of transcript above the persistent input. */
   print(text) {
+    const line = this.gutterize(text);
     if (this.takeoverHandler) {
-      this.bufferedPrints.push(text);
+      this.bufferedPrints.push(line);
       return;
     }
     this.clearBottom();
-    process.stdout.write(text + "\n");
+    process.stdout.write(line + "\n");
     this.renderBottom();
   }
   /** Multi-line convenience. */
@@ -1758,9 +2739,9 @@ var Tui = class {
    * above and below, and a teal `›` marks the first row.
    */
   printUserMessage(text) {
-    const cols = Math.max(20, process.stdout.columns || 80);
+    const cols2 = Math.max(20, process.stdout.columns || 80);
     const bg = "\x1B[48;5;238m";
-    const limit = Math.max(8, cols - 6);
+    const limit = Math.max(8, cols2 - 6);
     const words = text.replace(/\s+/g, " ").trim().split(" ");
     const lines = [];
     let cur = "";
@@ -1784,9 +2765,9 @@ var Tui = class {
     const innerW = 2 + Math.max(...lines.map((l) => l.length));
     this.print("");
     lines.forEach((line, i) => {
-      const rowText = (i === 0 ? "\u203A " : "  ") + line;
+      const rowText = (i === 0 ? "\u276F " : "  ") + line;
       const padded = rowText.padEnd(innerW);
-      const inner = i === 0 ? `${C.teal}\u203A${C.reset}${bg}${padded.slice(1)}` : padded;
+      const inner = i === 0 ? `${C.teal}\u276F${C.reset}${bg}${padded.slice(1)}` : padded;
       this.print(`${bg} ${inner} ${C.reset}`);
     });
     this.print("");
@@ -1796,15 +2777,30 @@ var Tui = class {
     if (on && !this.working) {
       this.working = true;
       this.workingStart = Date.now();
+      this.goalComplete = false;
     } else if (!on) {
       this.working = false;
     }
     this.syncSpinner();
     this.renderBottom();
   }
-  /** Labels of subagents currently working, one persistent line each. */
-  setSubagents(labels) {
-    this.subagents = labels;
+  /** The subagents currently working, one persistent line each. Each keeps a
+   *  stable, distinct colour for as long as it's active; the compaction agent
+   *  is always orange (its colour never comes from the shared pool). */
+  setSubagents(subagents) {
+    this.subagents = subagents;
+    const active = new Set(subagents.map((s) => s.id));
+    for (const id of [...this.subagentColorByID.keys()]) {
+      if (!active.has(id)) this.subagentColorByID.delete(id);
+    }
+    for (const s of subagents) {
+      if (s.agentName === COMPACTION_AGENT) continue;
+      if (this.subagentColorByID.has(s.id)) continue;
+      const used = new Set(this.subagentColorByID.values());
+      let idx = 0;
+      while (used.has(idx) && idx < SUBAGENT_COLORS.length - 1) idx++;
+      this.subagentColorByID.set(s.id, idx);
+    }
     this.syncSpinner();
     this.renderBottom();
   }
@@ -1837,9 +2833,12 @@ var Tui = class {
   getInput() {
     return this.inputBuffer;
   }
-  setInput(text) {
+  /** Replace the input (and any pasted images tied to placeholders in it). */
+  setInput(text, images = []) {
     this.inputBuffer = text;
     this.cursorPos = text.length;
+    this.pendingImages = images;
+    this.historyIdx = null;
     this.renderBottom();
   }
   /** Cumulative token totals shown on the prompt line (`outTokens` includes live). */
@@ -1879,7 +2878,8 @@ var Tui = class {
     }
     this.renderBottom();
   }
-  /** Approval prompt: arrow-navigable with y/a/l/n shortcuts. Pauses input. */
+  /** Approval prompt: arrow-navigable with y/a/l/n shortcuts. Pauses input.
+   * Tab resolves "deny_with_reason" so the caller can collect a free-text reason. */
   approval(question, risk) {
     return new Promise((resolve) => {
       const options = [
@@ -1891,12 +2891,16 @@ var Tui = class {
       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 cols2 = Math.max(1, process.stdout.columns || 80);
+      const physRows = (line) => Math.max(1, Math.ceil(this.visibleWidth(line) / cols2));
+      const headerText = `${C.yellow}\u2503${C.reset} ${C.bold}Permission needed${C.reset}  risk ${riskBar}`;
+      const questionLines = question.split("\n").map((line) => `${C.yellow}\u2503${C.reset} ${line}`);
+      const hintLine = `${C.yellow}\u2503${C.reset} ${C.gray}\u21E5 tab \u2014 deny with a reason${C.reset}`;
+      const blockLines = [headerText, ...questionLines, hintLine];
+      const headerRows = 1 + blockLines.reduce((n, line) => n + physRows(line), 0);
+      process.stdout.write(`
+` + blockLines.map((line) => `${line}
+`).join(""));
       const renderLine = (i) => {
         const o = options[i];
         const sel = i === idx;
@@ -1910,7 +2914,14 @@ ${C.yellow}\u2503${C.reset} ${question}
 `);
       };
       draw(false);
+      const erase = () => {
+        process.stdout.write("\r");
+        const up = headerRows + options.length;
+        if (up > 0) process.stdout.write(`\x1B[${up}A`);
+        process.stdout.write("\x1B[J");
+      };
       const finish = (choice) => {
+        erase();
         this.endTakeover();
         resolve(choice);
       };
@@ -1921,6 +2932,8 @@ ${C.yellow}\u2503${C.reset} ${question}
         } else if (key?.name === "down" || str === "j") {
           idx = (idx + 1) % options.length;
           draw(true);
+        } else if (key?.name === "tab") {
+          finish("deny_with_reason");
         } else if (key?.name === "return" || key?.name === "enter") {
           finish(options[idx].value);
         } else {
@@ -2041,11 +3054,39 @@ ${C.cyan}\u2503${C.reset} ${question}
   }
 };
 
+// src/history.ts
+var HISTORY_KEY = "input_history";
+var MAX_ENTRIES = 100;
+function clean(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((e) => typeof e === "string" && e.trim() !== "").slice(-MAX_ENTRIES);
+}
+async function loadHistory(store, threadId, seedThreadId) {
+  const own = clean(await store.kvGet(threadId, HISTORY_KEY));
+  if (own.length) return own;
+  if (seedThreadId && seedThreadId !== threadId) {
+    const seeded = clean(await store.kvGet(seedThreadId, HISTORY_KEY));
+    if (seeded.length) {
+      void store.kvSet(threadId, HISTORY_KEY, seeded);
+      return seeded;
+    }
+  }
+  return [];
+}
+function appendHistory(store, threadId, history, text) {
+  const t = text.trim();
+  if (!t || history[history.length - 1] === t) return history;
+  history.push(t);
+  if (history.length > MAX_ENTRIES) history.splice(0, history.length - MAX_ENTRIES);
+  void store.kvSet(threadId, HISTORY_KEY, [...history]);
+  return history;
+}
+
 // src/markdown.ts
 var ESC = "\x1B[";
 var R = ESC + "0m";
 var BOLD = ESC + "1m";
-var DIM = ESC + "2m";
+var DIM2 = ESC + "2m";
 var ITAL = ESC + "3m";
 var UNDER = ESC + "4m";
 var TEAL = ESC + "38;5;37m";
@@ -2067,11 +3108,11 @@ function inline(s) {
   });
   s = s.replace(
     /\[([^\]]+)\]\(([^)\s]+)\)/g,
-    (_, text, url) => `${CYAN}${UNDER}${text}${R} ${DIM}${url}${R}`
+    (_, text, url) => `${CYAN}${UNDER}${text}${R} ${DIM2}${url}${R}`
   );
   s = s.replace(/\*\*([^*]+)\*\*/g, (_, t) => `${BOLD}${t}${R}`);
   s = s.replace(/\*([^*\n]+)\*/g, (_, t) => `${ITAL}${t}${R}`);
-  s = s.replace(/~~([^~]+)~~/g, (_, t) => `${DIM}${t}${R}`);
+  s = s.replace(/~~([^~]+)~~/g, (_, t) => `${DIM2}${t}${R}`);
   s = s.replace(/\x00(\d+)\x00/g, (_, i) => `${TEAL}${codes[+i].replace(/ /g, String.fromCharCode(160))}${R}`);
   return s;
 }
@@ -2098,8 +3139,8 @@ function wrapStyled(text, width) {
   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));
+function wrapBlock(out, cols2, leadFirst, leadRest, leadWidth, text) {
+  const wrapped = wrapStyled(text, Math.max(8, cols2 - leadWidth));
   wrapped.forEach((ln, idx) => out.push((idx === 0 ? leadFirst : leadRest) + ln));
 }
 function tableCells(row) {
@@ -2113,16 +3154,16 @@ function isTableSeparator(line) {
   return SEPARATOR.test(line) && line.includes("-") && line.includes("|");
 }
 function renderTable(rows) {
-  const cols = Math.max(...rows.map((r) => r.length));
+  const cols2 = Math.max(...rows.map((r) => r.length));
   const widths = [];
-  for (let c2 = 0; c2 < cols; c2++) {
+  for (let c2 = 0; c2 < cols2; c2++) {
     widths[c2] = Math.max(...rows.map((r) => visibleWidth(inline(r[c2] ?? ""))));
   }
   const sep = `${GRAY} \u2502 ${R}`;
   const out = [];
   rows.forEach((r, ri) => {
     const cells = [];
-    for (let c2 = 0; c2 < cols; c2++) {
+    for (let c2 = 0; c2 < cols2; c2++) {
       const raw = r[c2] ?? "";
       const styled = ri === 0 ? `${BOLD}${inline(raw)}${R}` : inline(raw);
       cells.push(padEndVisible(styled, widths[c2]));
@@ -2135,7 +3176,7 @@ function renderTable(rows) {
   });
   return out;
 }
-function renderMarkdown(src, cols = 80) {
+function renderMarkdown(src, cols2 = 80) {
   const lines = src.replace(/\r\n/g, "\n").split("\n");
   const out = [];
   let inFence = false;
@@ -2164,7 +3205,7 @@ function renderMarkdown(src, cols = 80) {
     }
     const heading = line.match(/^(#{1,6})\s+(.*)$/);
     if (heading) {
-      for (const ln of wrapStyled(heading[2].trim(), cols)) out.push(`${BOLD}${TEAL}${ln}${R}`);
+      for (const ln of wrapStyled(heading[2].trim(), cols2)) out.push(`${BOLD}${TEAL}${ln}${R}`);
       i++;
       continue;
     }
@@ -2175,8 +3216,8 @@ function renderMarkdown(src, cols = 80) {
     }
     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}`);
+      for (const ln of wrapStyled(inline(quote[1]), Math.max(8, cols2 - 2))) {
+        out.push(`${GRAY}\u2502${R} ${DIM2}${ln}${R}`);
       }
       i++;
       continue;
@@ -2184,7 +3225,7 @@ function renderMarkdown(src, cols = 80) {
     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]));
+      wrapBlock(out, cols2, `${bullet[1]}${TEAL}\u2022${R} `, " ".repeat(leadWidth), leadWidth, inline(bullet[2]));
       i++;
       continue;
     }
@@ -2192,11 +3233,11 @@ function renderMarkdown(src, cols = 80) {
     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]));
+      wrapBlock(out, cols2, `${numbered[1]}${BOLD}${marker}${R} `, " ".repeat(leadWidth), leadWidth, inline(numbered[4]));
       i++;
       continue;
     }
-    if (line.trim()) wrapBlock(out, cols, "", "", 0, inline(line));
+    if (line.trim()) wrapBlock(out, cols2, "", "", 0, inline(line));
     else out.push("");
     i++;
   }
@@ -2307,7 +3348,7 @@ ${stderrTail.trim()}` : msg;
       target,
       argsSha256: sha256(canonicalJson(args)),
       resultSha256: sha256(text),
-      nonce: crypto2.randomBytes(8).toString("hex"),
+      nonce: crypto.randomBytes(8).toString("hex"),
       isError,
       at: Date.now()
     };
@@ -2577,10 +3618,10 @@ function sortKeys(value) {
   return value;
 }
 function sha256(input2) {
-  return crypto2.createHash("sha256").update(input2).digest("hex");
+  return crypto.createHash("sha256").update(input2).digest("hex");
 }
-var DIR2 = path3.join(os4.homedir(), ".standardagents");
-var FILE2 = path3.join(DIR2, "credentials");
+var DIR = path3.join(os6.homedir(), ".standardagents");
+var FILE = path3.join(DIR, "credentials");
 function normalizeEndpoint(endpoint) {
   let e = endpoint.trim();
   if (!/^https?:\/\//i.test(e)) e = "http://" + e;
@@ -2588,7 +3629,7 @@ function normalizeEndpoint(endpoint) {
 }
 function loadCredentials() {
   try {
-    const raw = fs2.readFileSync(FILE2, "utf8");
+    const raw = fs4.readFileSync(FILE, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed.instances) parsed.instances = {};
     return parsed;
@@ -2600,21 +3641,33 @@ function getCredential(endpoint) {
   const creds = loadCredentials();
   return creds.instances[normalizeEndpoint(endpoint)] ?? null;
 }
-function saveCredential(cred) {
+function saveCredential(cred, options = {}) {
   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 });
+  if (options.updateDefault ?? true) {
+    creds.default_endpoint = endpoint;
+  }
+  fs4.mkdirSync(DIR, { recursive: true });
+  fs4.writeFileSync(FILE, JSON.stringify(creds, null, 2), { mode: 384 });
   try {
-    fs2.chmodSync(FILE2, 384);
+    fs4.chmodSync(FILE, 384);
   } catch {
   }
 }
 function defaultEndpoint() {
   return loadCredentials().default_endpoint ?? null;
 }
+function saveDefaultEndpoint(endpoint) {
+  const creds = loadCredentials();
+  creds.default_endpoint = normalizeEndpoint(endpoint);
+  fs4.mkdirSync(DIR, { recursive: true });
+  fs4.writeFileSync(FILE, JSON.stringify(creds, null, 2), { mode: 384 });
+  try {
+    fs4.chmodSync(FILE, 384);
+  } catch {
+  }
+}
 
 // src/index.ts
 var AGENT_ID = "standard_code_agent";
@@ -2643,13 +3696,86 @@ var LOGO_MARK = [
   "\u2588\u2588        \u2588\u2588\u2588",
   "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588"
 ];
+function printUsage() {
+  stdout.write(
+    [
+      "",
+      `${c.bold}Usage${c.reset}`,
+      "  standardcode [options] [dir]",
+      "",
+      `${c.bold}Options${c.reset}`,
+      "  -e, --endpoint [url]  Use a Standard Agents instance for this run only.",
+      "                       If url is omitted, prompt for it.",
+      "                       Credentials are remembered for that endpoint, but",
+      "                       the saved default endpoint is not changed.",
+      "  -h, --help            Show this help.",
+      ""
+    ].join("\n")
+  );
+}
+function parseArgs2(args) {
+  const parsed = { help: false, promptEndpoint: false };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (arg === "--endpoint" || arg === "-e") {
+      const value = args[i + 1];
+      if (value && !value.startsWith("-")) {
+        parsed.endpoint = value;
+        i++;
+      } else {
+        parsed.promptEndpoint = true;
+      }
+      continue;
+    }
+    if (arg.startsWith("--endpoint=")) {
+      const value = arg.slice("--endpoint=".length);
+      if (value) {
+        parsed.endpoint = value;
+      } else {
+        parsed.promptEndpoint = true;
+      }
+      continue;
+    }
+    if (arg === "--") {
+      if (i === 0 && args[i + 1]?.startsWith("-")) continue;
+      const rest = args.slice(i + 1);
+      if (rest.length > 1) throw new Error("Expected at most one project directory.");
+      if (rest[0]) parsed.dir = rest[0];
+      break;
+    }
+    if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`);
+    if (parsed.dir) throw new Error("Expected at most one project directory.");
+    parsed.dir = arg;
+  }
+  return parsed;
+}
 function printAssistant(tui, text) {
-  const cols = Math.max(20, (process.stdout.columns || 80) - 1);
+  const cols2 = Math.max(20, (process.stdout.columns || 80) - 3);
+  tui.clearStream();
   tui.print("");
-  for (const line of renderMarkdown(text, cols)) tui.print(line);
+  let dotted = false;
+  for (const line of renderMarkdown(text, cols2)) {
+    if (!dotted && line.trim()) {
+      tui.print(`${c.gray}\u2022${c.reset} ${line}`);
+      dotted = true;
+    } else {
+      tui.print(`  ${line}`);
+    }
+  }
   tui.print("");
 }
-function farewell() {
+function farewell(stoppedProcs = 0) {
+  if (stoppedProcs > 0) {
+    stdout.write(
+      `
+${c.cyan}\u2699${c.reset} Stopped ${stoppedProcs} background process${stoppedProcs === 1 ? "" : "es"}.
+`
+    );
+  }
   stdout.write(`
 ${c.teal}\u25C7${c.reset} ${c.dim}Standard Code \u2014 see you soon.${c.reset}
 `);
@@ -2676,14 +3802,14 @@ function relaxTlsForLocalEndpoint(endpoint) {
 }
 function readVersion() {
   try {
-    const pkg = JSON.parse(fs2.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    const pkg = JSON.parse(fs4.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "";
   } catch {
     return "";
   }
 }
 function printWelcome(endpoint, projectDir) {
-  const home = os4.homedir();
+  const home = os6.homedir();
   const dir = projectDir.startsWith(home) ? "~" + projectDir.slice(home.length) : projectDir;
   const host = endpoint.replace(/^https?:\/\//, "").replace(/\/$/, "");
   const version = readVersion();
@@ -2713,19 +3839,41 @@ function colorActivity(line) {
     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}`;
+  if (glyph === "\u2717") {
+    const ERR_MAX_LINES = 7;
+    const lines = rest.split("\n");
+    const shown = lines.slice(0, ERR_MAX_LINES);
+    const hidden = lines.length - shown.length;
+    const body = shown.map(
+      (l, i) => i === 0 ? `${indent}${c.red}\u2717 ${l}${c.reset}` : `${indent}${c.red}${c.dim}${l}${c.reset}`
+    ).join("\n");
+    if (hidden > 0) {
+      return `${body}
+${indent}${c.dim}\u2026 +${hidden} more line${hidden === 1 ? "" : "s"}${c.reset}`;
+    }
+    return body;
+  }
   return `${indent}${c.yellow}\u26D4 ${rest}${c.reset}`;
 }
 async function main() {
-  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];
+  let cliArgs;
+  try {
+    cliArgs = parseArgs2(process.argv.slice(2));
+  } catch (error) {
+    stdout.write(`${c.red}error:${c.reset} ${error instanceof Error ? error.message : String(error)}
+`);
+    printUsage();
+    process.exit(1);
   }
+  if (cliArgs.help) {
+    printUsage();
+    return;
+  }
+  const endpointArg = cliArgs.endpoint;
+  const endpointOverride = cliArgs.promptEndpoint || typeof endpointArg === "string" && endpointArg.trim() !== "";
+  const dirArg = cliArgs.dir;
   const projectDir = path3.resolve(dirArg || process.cwd());
-  const machine = os4.hostname();
+  const machine = os6.hostname();
   const reader = { rl: null };
   let handoffClosing = false;
   let preflightArmed = false;
@@ -2758,13 +3906,22 @@ ${c.dim}Press Control-C again to exit${c.reset}
     }
     return reader.rl.question(question);
   };
+  const askEndpoint = async () => {
+    for (; ; ) {
+      const answer = (await ask(
+        `${c.cyan}Standard Agents instance URL${c.reset} (e.g. http://localhost:5178): `
+      )).trim();
+      if (answer) return answer;
+      stdout.write(`${c.dim}An endpoint URL is required.${c.reset}
+`);
+    }
+  };
   process.on("SIGINT", onPreflightSigint);
-  let endpoint = endpointArg || defaultEndpoint() || "";
+  let endpointPrompted = false;
+  let endpoint = endpointArg || (cliArgs.promptEndpoint ? "" : defaultEndpoint() || "");
   if (!endpoint) {
-    const answer = await ask(
-      `${c.cyan}Standard Agents instance URL${c.reset} (e.g. http://localhost:5178): `
-    );
-    endpoint = answer.trim();
+    endpoint = await askEndpoint();
+    endpointPrompted = true;
   }
   endpoint = normalizeEndpoint(endpoint);
   const tlsRelaxed = relaxTlsForLocalEndpoint(endpoint);
@@ -2779,22 +3936,43 @@ ${c.dim}Press Control-C again to exit${c.reset}
   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}
+      `${c.bold}${c.white}Sign in${c.reset} ${c.dim}\u2014 connect to${c.reset} ${c.teal}${host}${c.reset}
 `
     );
-    stdout.write(`${c.dim}Create one in your instance settings under API tokens.${c.reset}
+    stdout.write(
+      `${c.dim}Press Enter to sign in with your browser, or paste an API token.${c.reset}
 
-`);
+`
+    );
     for (; ; ) {
-      const token = (await ask(`${c.teal}\u276F${c.reset} ${c.dim}token${c.reset} `)).trim();
+      const token = (await ask(`${c.teal}\u276F${c.reset} ${c.dim}token (or Enter for browser)${c.reset} `)).trim();
       if (!token) {
-        stdout.write(`${c.dim}A token is required.${c.reset}
+        const got = await deviceLogin(endpoint).catch((e) => {
+          stdout.write(`${c.red}\u2717${c.reset} ${c.dim}${e instanceof Error ? e.message : String(e)}${c.reset}
+`);
+          return null;
+        });
+        if (!got) continue;
+        api = new ApiClient(endpoint, got);
+        if (await api.verify()) {
+          saveCredential(
+            { endpoint, access_token: got, token_type: "Bearer", saved_at: Date.now() },
+            { updateDefault: !endpointOverride }
+          );
+          stdout.write(`${c.green}\u2713${c.reset} Connected to ${c.teal}${host}${c.reset}
+`);
+          break;
+        }
+        stdout.write(`${c.red}\u2717${c.reset} ${c.dim}Browser sign-in didn't verify. Try again.${c.reset}
 `);
         continue;
       }
       api = new ApiClient(endpoint, token);
       if (await api.verify()) {
-        saveCredential({ endpoint, access_token: token, token_type: "Bearer", saved_at: Date.now() });
+        saveCredential(
+          { endpoint, access_token: token, token_type: "Bearer", saved_at: Date.now() },
+          { updateDefault: !endpointOverride }
+        );
         stdout.write(`${c.green}\u2713${c.reset} Connected to ${c.teal}${host}${c.reset}
 `);
         break;
@@ -2802,6 +3980,8 @@ ${c.dim}Press Control-C again to exit${c.reset}
       stdout.write(`${c.red}\u2717${c.reset} ${c.dim}That token didn't work. Try again.${c.reset}
 `);
     }
+  } else if (endpointPrompted) {
+    saveDefaultEndpoint(endpoint);
   }
   if (!api) process.exit(1);
   handoffClosing = true;
@@ -2816,6 +3996,7 @@ ${c.dim}Press Control-C again to exit${c.reset}
   const tui = new Tui(1);
   let threadId;
   let resumed = false;
+  let historySeed;
   if (existing.length > 0) {
     const summaries = await summarizeThreads(api, existing.slice(0, 8));
     const items = summaries.map((s) => ({
@@ -2824,7 +4005,7 @@ ${c.dim}Press Control-C again to exit${c.reset}
       value: s.id
     }));
     items.push({ label: "\uFF0B Start a new session", value: null });
-    const home = os4.homedir();
+    const home = os6.homedir();
     const tilde = projectDir.startsWith(home) ? "~" + projectDir.slice(home.length) : projectDir;
     const shortDir = tilde.length > 38 ? "\u2026" + tilde.slice(-37) : tilde;
     const picked = await tui.select(
@@ -2836,11 +4017,12 @@ ${c.dim}Press Control-C again to exit${c.reset}
       resumed = true;
     } else {
       threadId = await api.createThread(AGENT_ID, tags);
+      historySeed = existing[0]?.id;
     }
   } else {
     threadId = await api.createThread(AGENT_ID, tags);
   }
-  await runInteractive(tui, api, threadId, projectDir, machine, resumed);
+  await runInteractive(tui, api, threadId, projectDir, machine, resumed, historySeed);
 }
 async function summarizeThreads(api, threads) {
   return Promise.all(
@@ -2859,13 +4041,34 @@ async function summarizeThreads(api, threads) {
     })
   );
 }
-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();
+function subagentLabel(s, titles) {
+  const agentName = (s.agent_name || "").trim();
+  const title = (s.title || "").trim() || titles.get(agentName) || (agentName ? agentName.replace(/[_-]+/g, " ").replace(/\b\w/g, (c2) => c2.toUpperCase()) : "Subagent");
+  const tagged = (s.threadName || "").trim();
   return tagged ? `${title} \xB7 ${tagged}` : title;
 }
+async function deviceLogin(endpoint) {
+  const start = await fetch(`${endpoint}/api/auth/device/start`, { method: "POST" });
+  if (!start.ok) throw new Error(`This instance does not support browser sign-in (HTTP ${start.status}). Paste an API token instead.`);
+  const info = await start.json();
+  stdout.write(`${c.dim}Opening your browser to approve this sign-in\u2026${c.reset}
+`);
+  stdout.write(`${c.dim}If it doesn't open, visit:${c.reset} ${c.teal}${info.verify_url}${c.reset}
+`);
+  openUrl(info.verify_url);
+  const deadline = Date.now() + (info.expires_in ?? 600) * 1e3;
+  const interval = Math.max(2, info.interval ?? 2) * 1e3;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, interval));
+    const res = await fetch(info.poll_url).catch(() => null);
+    if (!res) continue;
+    if (res.status === 404) throw new Error("The sign-in link expired. Try again.");
+    const body = await res.json().catch(() => ({}));
+    if (body.status === "approved" && body.token) return body.token;
+    if (body.status === "denied") throw new Error("Sign-in was denied in the browser.");
+  }
+  throw new Error("Timed out waiting for browser approval. Try again.");
+}
 function openUrl(url) {
   const platform = process.platform;
   const cmd = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
@@ -2926,14 +4129,13 @@ async function printHistory(api, threadId, tui) {
     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) {
+async function runInteractive(tui, api, threadId, projectDir, machine, resumed, historySeedThreadId) {
   const registry = new ProcessRegistry(api, threadId, machine);
   const mcp = new McpManager(projectDir);
   const publishMcpCatalog = () => void api.kvSet(threadId, "mcp_catalog", mcp.catalog()).catch(() => {
   });
-  const host = new HostTools(projectDir, registry, threadId, machine, mcp, publishMcpCatalog);
+  const host = new HostTools(projectDir, registry, threadId, machine, mcp, publishMcpCatalog, api);
   const refreshBgCount = () => {
     void registry.runningCount().then((n) => tui.setBackgroundCount(n)).catch(() => {
     });
@@ -2950,11 +4152,13 @@ async function runInteractive(tui, api, threadId, projectDir, machine, resumed)
     perm.level = l;
     saveApprovals(api, threadId, perm);
   });
+  saveApprovals(api, threadId, perm);
   let busy = false;
   let interrupting = false;
   const queued = [];
   let editingQueued = false;
   const shownIds = /* @__PURE__ */ new Set();
+  const pendingSent = /* @__PURE__ */ new Map();
   let tokensIn = 0;
   let tokensOut = 0;
   let liveOut = 0;
@@ -2967,13 +4171,19 @@ async function runInteractive(tui, api, threadId, projectDir, machine, resumed)
     tui.setStep(label, liveOut);
   };
   const bridge = new Bridge(api, threadId, host, perm, {
-    onActivity: (line) => {
+    onActivity: (line, detail) => {
       tui.print(colorActivity(line));
+      if (detail) for (const d of detail) tui.print(d);
       refreshBgCount();
     },
-    onStatus: () => {
+    onStatus: (id, summary) => {
+      if (summary) {
+        if (!activeSteps.has(id)) activeSteps.set(id, summary);
+      } else {
+        activeSteps.delete(id);
+      }
+      refreshStatus();
     },
-    // the working indicator is driven by the busy poller
     onConnection: (state, attempt) => {
       if (state === "reconnecting") {
         if (attempt >= 4) tui.setConnected(false);
@@ -2981,15 +4191,27 @@ async function runInteractive(tui, api, threadId, projectDir, machine, resumed)
         tui.setConnected(true);
       }
     },
-    requestApproval: (req, summary, risk) => tui.approval(
-      `${summary}${req.requestPermission ? `
-${c.dim}why: ${req.requestPermission}${c.reset}` : ""}`,
-      risk
-    )
+    requestApproval: async (req, summary, risk) => {
+      const choice = await tui.approval(
+        `${summary}${req.requestPermission ? `
+${c.bold}why: ${req.requestPermission}${c.reset}` : ""}`,
+        risk
+      );
+      if (choice === "deny_with_reason") {
+        const reason = await tui.prompt(
+          "Why are you denying this? (sent to the agent \u2014 enter to send, esc to skip)"
+        );
+        return { choice: "deny", reason: reason ?? void 0 };
+      }
+      return { choice };
+    }
   });
   const stream = new MessageStream(api, threadId, {
-    onChunk: () => {
-    },
+    // Live streaming preview: answer text and (opt-in) internal reasoning feed
+    // the TUI's ephemeral preview; the committed message still renders from
+    // polling, which calls tui.clearStream() first so there's no double-render.
+    onChunk: (text, mid) => tui.streamResponseDelta(text, mid),
+    onReasoningChunk: (text, mid) => tui.streamThinkingDelta(text, mid),
     onAssistantText: () => {
     },
     onEvent: (eventType, data) => {
@@ -3002,6 +4224,8 @@ ${c.dim}why: ${req.requestPermission}${c.reset}` : ""}`,
       } else if (eventType === "tool_call_done" && data?.id) {
         activeSteps.delete(data.id);
         refreshStatus();
+      } else if (eventType === "goal_updated" && data) {
+        tui.setGoal(data);
       }
     },
     onError: () => {
@@ -3009,33 +4233,69 @@ ${c.dim}why: ${req.requestPermission}${c.reset}` : ""}`,
   });
   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 agentTitlesReady = api.listAgents().then((list) => list.forEach((a) => agentTitles.set(a.name, a.title))).catch(() => {
   });
-  const pushSubagents = () => tui.setSubagents([...activeSubagents.values()]);
+  const pushSubagents = () => tui.setSubagents(
+    [...activeSubagents.entries()].map(([id, s]) => ({ id, label: s.label, agentName: s.agentName }))
+  );
+  const reconcileSubagents = async () => {
+    try {
+      await agentTitlesReady;
+      const subs = await api.listSubagents(threadId);
+      activeSubagents.clear();
+      for (const s of subs) {
+        if (s.status !== "running") continue;
+        activeSubagents.set(s.id, {
+          label: subagentLabel(s, agentTitles),
+          agentName: s.agent_name ?? void 0
+        });
+      }
+      pushSubagents();
+    } catch {
+    }
+  };
+  let reconcileTimer = null;
+  let reconcilePending = false;
+  const scheduleReconcile = () => {
+    if (reconcileTimer) {
+      reconcilePending = true;
+      return;
+    }
+    reconcileTimer = setTimeout(async () => {
+      reconcileTimer = null;
+      await reconcileSubagents();
+      if (reconcilePending) {
+        reconcilePending = false;
+        scheduleReconcile();
+      }
+    }, 150);
+  };
   const events = new SystemEvents(api, {
+    onOpen: () => scheduleReconcile(),
     onThreadCreated: (t) => {
-      if (t.parent === threadId && !t.terminated) {
-        activeSubagents.set(t.id, subagentLabel(t, agentTitles));
-        pushSubagents();
-      }
+      if (t.parent === threadId) scheduleReconcile();
     },
     onThreadUpdated: (t) => {
-      if (t.parent !== threadId) return;
-      if (t.terminated) activeSubagents.delete(t.id);
-      else activeSubagents.set(t.id, subagentLabel(t, agentTitles));
-      pushSubagents();
+      if (t.parent === threadId) scheduleReconcile();
     },
     onThreadDeleted: (id) => {
-      if (activeSubagents.delete(id)) pushSubagents();
+      if (activeSubagents.has(id)) scheduleReconcile();
     }
   });
-  const quit = () => {
+  const quit = async () => {
     tui.end();
+    const stopped = api.stop(threadId).catch(() => {
+    });
+    const procsStopped = host.stopAllLocalProcesses().catch(() => 0);
     bridge.close();
     stream.close();
     events.close();
     mcp.closeAll();
-    farewell();
+    const [, killed] = await Promise.race([
+      Promise.all([stopped, procsStopped]),
+      new Promise((r) => setTimeout(() => r([void 0, 0]), 1500))
+    ]);
+    farewell(killed);
     process.exit(0);
   };
   tui.setQuitHandler(quit);
@@ -3087,11 +4347,18 @@ ${c.dim}why: ${req.requestPermission}${c.reset}` : ""}`,
     },
     setEnabled: (name, enabled) => setMcpServerEnabled(name, enabled)
   };
-  const sendNow = async (text) => {
+  const extFor = (mime) => ({ "image/png": "png", "image/jpeg": "jpg", "image/gif": "gif", "image/webp": "webp" })[mime] ?? "bin";
+  const toAttachments = (images) => images.map((img) => ({ name: `image-${img.seq}.${extFor(img.mime)}`, mimeType: img.mime, data: img.data }));
+  const sendNow = async (text, images = []) => {
     tui.printUserMessage(text);
+    const key = text.trim();
+    pendingSent.set(key, (pendingSent.get(key) ?? 0) + 1);
     try {
-      await api.sendMessage(threadId, text);
+      await api.sendMessage(threadId, text, toAttachments(images));
     } catch (e) {
+      const n = (pendingSent.get(key) ?? 1) - 1;
+      if (n > 0) pendingSent.set(key, n);
+      else pendingSent.delete(key);
       tui.print(`${c.dim}failed to send: ${e instanceof Error ? e.message : String(e)}${c.reset}`);
       return;
     }
@@ -3103,16 +4370,25 @@ ${c.dim}why: ${req.requestPermission}${c.reset}` : ""}`,
     if (!queued.length) return;
     const toSend = queued.splice(0);
     tui.setQueuedCount(0);
-    for (const t of toSend) await sendNow(t);
+    for (const q of toSend) await sendNow(q.text, q.images);
   };
   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.`
-      );
+      await api.compact(threadId);
     } catch (err) {
-      tui.print(`${c.red}\u2717${c.reset} couldn't request compaction: ${err.message}`);
+      tui.print(`${c.red}\u2717${c.reset} couldn't start compaction: ${err.message}`);
+    }
+  };
+  const skillsCtl = {
+    list: () => api.listSkills(),
+    setEnabled: (name, enabled) => api.setSkillEnabled(name, enabled),
+    remove: (name) => api.removeSkill(name),
+    // Seed the request into the main chat — the agent researches or authors
+    // the skill there (research_agent + install_skill), visible in the transcript.
+    requestInstall: (query) => {
+      void sendNow(
+        `Install a skill for me: ${query}. Find the skill's published files (or author a proper SKILL.md from your research), install it with install_skill, then tell me what it can do.`
+      );
     }
   };
   tui.setCommands([
@@ -3141,25 +4417,34 @@ ${c.dim}why: ${req.requestPermission}${c.reset}` : ""}`,
       },
       run: () => runMcpMenu(tui, mcpCtl)
     },
+    {
+      name: "skills",
+      label: "Agent skills",
+      hint: "list / install / manage",
+      run: () => runSkillsMenu(tui, skillsCtl)
+    },
     { name: "background", label: "Background processes", hint: "list / stop", run: () => runProcessMenu(tui, bgMgr) },
     { name: "view", label: "View thread in AgentBuilder", run: () => viewThread() },
     { name: "keybindings", label: "Keyboard shortcuts", run: () => showKeybindings(tui) },
     { name: "quit", label: "Quit", run: () => quit() }
   ]);
-  tui.onSubmit = (text) => {
+  const history = await loadHistory(api, threadId, historySeedThreadId);
+  tui.setHistory(history);
+  tui.onSubmit = (text, images) => {
+    appendHistory(api, threadId, history, text);
     if (editingQueued) {
       editingQueued = false;
-      queued.push(text);
+      queued.push({ text, images });
       tui.setQueuedCount(queued.length);
       tui.print(`${c.gray}\u23F3 queued:${c.reset} ${text}`);
       return;
     }
     if (busy) {
-      queued.push(text);
+      queued.push({ text, images });
       tui.setQueuedCount(queued.length);
       tui.print(`${c.gray}\u23F3 queued:${c.reset} ${text}  ${c.dim}(esc to steer now)${c.reset}`);
     } else {
-      void sendNow(text);
+      void sendNow(text, images);
     }
   };
   tui.onInterrupt = () => {
@@ -3180,19 +4465,21 @@ ${c.dim}why: ${req.requestPermission}${c.reset}` : ""}`,
     }
   };
   tui.onUpArrow = () => {
-    if (tui.getInput().trim() || queued.length === 0) return;
-    const text = queued.pop();
+    if (tui.getInput().trim() || queued.length === 0) return false;
+    const q = queued.pop();
     tui.setQueuedCount(queued.length);
     editingQueued = true;
-    tui.setInput(text);
+    tui.setInput(q.text, q.images);
+    return true;
   };
   events.connect();
   await Promise.all([bridge.connect(), stream.connect()]);
+  void api.getGoal(threadId).then((g) => tui.setGoal(g)).catch(() => {
+  });
   tui.banner([
     `${c.bold}${c.magenta}Standard Code${c.reset} ${c.dim}\u2014 coding agent${c.reset}`,
     `${c.gray}project:${c.reset} ${projectDir}`,
-    `${c.gray}machine:${c.reset} ${machine}   ${c.gray}thread:${c.reset} ${threadId.slice(0, 8)}`,
-    `${c.dim}type anytime \xB7 shift-tab cycles auto-accept level \xB7 / for options \xB7 esc interrupts/steers \xB7 ctrl-c quits${c.reset}`
+    `${c.gray}machine:${c.reset} ${machine}   ${c.gray}thread:${c.reset} ${threadId.slice(0, 8)}`
   ]);
   if (resumed) await printHistory(api, threadId, tui);
   try {
@@ -3232,6 +4519,15 @@ ${c.dim}why: ${req.requestPermission}${c.reset}` : ""}`,
       const text = messageText(m.content).trim();
       if (m.role === "assistant" && text) printAssistant(tui, text);
       else if (m.role === "system" && text) tui.print(`${c.dim}${text}${c.reset}`);
+      else if (m.role === "user" && text) {
+        const pending = pendingSent.get(text) ?? 0;
+        if (pending > 0) {
+          if (pending === 1) pendingSent.delete(text);
+          else pendingSent.set(text, pending - 1);
+        } else {
+          tui.printUserMessage(text);
+        }
+      }
     }
     const polledBusy = threadBusy(msgs);
     if (interrupting) {
@@ -3279,6 +4575,56 @@ ${c.dim}why: ${req.requestPermission}${c.reset}` : ""}`,
   await new Promise(() => {
   });
 }
+async function runSkillsMenu(tui, skills) {
+  let list;
+  try {
+    list = await skills.list();
+  } catch (e) {
+    tui.print(`${c.red}\u2717 couldn't load skills:${c.reset} ${c.gray}${e instanceof Error ? e.message : String(e)}${c.reset}`);
+    return;
+  }
+  const INSTALL = "__install__";
+  const items = list.map((s) => ({
+    label: s.name,
+    hint: `${s.enabled ? "enabled" : "disabled"} \xB7 ${s.files.length} file${s.files.length === 1 ? "" : "s"}`,
+    value: s.name
+  }));
+  items.push({ label: "\uFF0B Install a skill\u2026", hint: "find & install", value: INSTALL });
+  const picked = await tui.select(
+    `${c.bold}Agent skills${c.reset}  ${c.dim}(\u2191/\u2193 \xB7 enter \xB7 esc to close)${c.reset}`,
+    items
+  );
+  if (!picked) return;
+  if (picked === INSTALL) {
+    const query = await tui.prompt(
+      "What skill do you want to install?",
+      "the anthropic pdf skill / a skill for writing conventional commits"
+    );
+    if (query) skills.requestInstall(query);
+    return;
+  }
+  const skill = list.find((s) => s.name === picked);
+  tui.print(`${c.cyan}${skill.name}${c.reset}${skill.version ? ` ${c.dim}v${skill.version}${c.reset}` : ""} ${c.gray}\u2014 ${skill.description}${c.reset}`);
+  const action = await tui.select(`${c.bold}${picked}${c.reset}`, [
+    skill.enabled ? { label: "Disable (hide from the agent)", value: "disable" } : { label: "Enable", value: "enable" },
+    { label: "View files", value: "files" },
+    { label: "Remove this skill", value: "remove" },
+    { label: "Back", value: "back" }
+  ]);
+  try {
+    if (action === "enable" || action === "disable") {
+      await skills.setEnabled(picked, action === "enable");
+      tui.print(`${c.gray}${action}d ${picked}${c.reset}`);
+    } else if (action === "files") {
+      for (const f of skill.files) tui.print(`  ${c.gray}${f}${c.reset}`);
+    } else if (action === "remove") {
+      await skills.remove(picked);
+      tui.print(`${c.gray}removed ${picked}${c.reset}`);
+    }
+  } catch (e) {
+    tui.print(`${c.red}\u2717 ${e instanceof Error ? e.message : String(e)}${c.reset}`);
+  }
+}
 async function runLevelMenu(tui, perm) {
   const picked = await tui.select(
     `${c.bold}Auto-accept level${c.reset}  ${c.dim}(\u2191/\u2193 \xB7 enter \xB7 shift-tab cycles)${c.reset}`,
@@ -3297,6 +4643,8 @@ function showKeybindings(tui) {
   tui.print(`${c.gray}shortcuts:${c.reset}`);
   tui.print(`${c.gray}  shift-tab${c.reset}  cycle auto-accept level (1\u20135)`);
   tui.print(`${c.gray}  /${c.reset}          open the command palette (type to filter)`);
+  tui.print(`${c.gray}  ctrl-v${c.reset}     paste an image from the clipboard ([#Image 1])`);
+  tui.print(`${c.gray}  \u2191 / \u2193${c.reset}      cycle past messages (on the input's top line)`);
   tui.print(`${c.gray}  ctrl-c${c.reset}     quit`);
 }
 async function runProcessMenu(tui, bg) {