wholestack 0.4.0 → 0.5.0

package/dist/{chunk-7DJJXUV4.js → chunk-PGKDYDAR.js}

@@ -39,7 +39,22 @@ function renderTodos(todos) {
   }
   line();
 }
-function banner() {
+var SHIMMER = [44, 44, 45, 80, 81, 117, 147, 176, 176, 147, 117, 81, 45, 44];
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function shimmerRow(row, rowIdx, phase) {
+  let out = "";
+  for (let col = 0; col < row.length; col++) {
+    const ch = row[col];
+    if (ch === " ") {
+      out += ch;
+      continue;
+    }
+    const code = SHIMMER[(col + rowIdx + phase) % SHIMMER.length];
+    out += `\x1B[1;38;5;${code}m${ch}\x1B[0m`;
+  }
+  return out;
+}
+async function banner() {
   const art = [
     "\u2590\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u258C",
     "\u2590 .----------------. \u258C",
@@ -62,13 +77,55 @@ function banner() {
     if (i === 8) return "   " + c.dim("/build for full stack apps");
     return "";
   };
+  const renderFinal = () => {
+    art.forEach((row, i) => {
+      const colored = zRows.has(i) ? c.bold(c.cyan(row)) : c.cyan(row);
+      line("  " + colored + side(i));
+    });
+  };
   line();
-  art.forEach((row, i) => {
-    const colored = zRows.has(i) ? c.bold(c.cyan(row)) : c.cyan(row);
-    line("  " + colored + side(i));
-  });
+  const animate = TTY && useColor && !process.env.ZETA_NO_ANIM;
+  if (!animate) {
+    renderFinal();
+    line();
+    return;
+  }
+  const FRAME_MS = 70;
+  const MAX_FRAMES = 900;
+  const stdin2 = process.stdin;
+  let stop = false;
+  const onKey = () => {
+    stop = true;
+  };
+  const rawCapable = typeof stdin2.setRawMode === "function";
+  if (rawCapable) stdin2.setRawMode(true);
+  stdin2.resume();
+  stdin2.once("data", onKey);
+  process.stdout.write("\x1B[?25l");
+  try {
+    for (let f = 0; f < MAX_FRAMES && !stop; f++) {
+      if (f > 0) process.stdout.write(`\x1B[${art.length}A`);
+      art.forEach((row, i) => {
+        process.stdout.write("\r  " + shimmerRow(row, i, f) + "\x1B[K\n");
+      });
+      await sleep(FRAME_MS);
+    }
+    process.stdout.write(`\x1B[${art.length}A`);
+    art.forEach((row, i) => {
+      const colored = zRows.has(i) ? c.bold(c.cyan(row)) : c.cyan(row);
+      process.stdout.write("\r  " + colored + side(i) + "\x1B[K\n");
+    });
+  } finally {
+    process.stdout.write("\x1B[?25h");
+    stdin2.removeListener("data", onKey);
+    if (rawCapable) stdin2.setRawMode(false);
+    stdin2.pause();
+  }
   line();
 }
+function bell() {
+  if (TTY && !process.env.ZETA_NO_BELL) process.stderr.write("\x07");
+}
 function fmtTokens(n) {
   if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
   if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
@@ -112,26 +169,6 @@ function wrapPlain(text, width) {
   }
   return out;
 }
-function responseBox(text, title = "Zeta-G1.0") {
-  const inner = boxInnerWidth();
-  const textW = inner - 2;
-  const rows = wrapPlain(text, textW);
-  const label = ` ${title} `;
-  const rem = Math.max(0, inner - label.length);
-  const lft = Math.floor(rem / 2);
-  const top = "\u256D" + "\u2500".repeat(lft) + label + "\u2500".repeat(rem - lft) + "\u256E";
-  const blank = "\u2502" + " ".repeat(inner) + "\u2502";
-  const bottom = "\u2570" + "\u2500".repeat(inner) + "\u256F";
-  line();
-  line("  " + c.cyan(top));
-  line("  " + c.cyan(blank));
-  for (const r of rows) {
-    line("  " + c.cyan("\u2502") + " " + r.padEnd(textW) + " " + c.cyan("\u2502"));
-  }
-  line("  " + c.cyan(blank));
-  line("  " + c.cyan(bottom));
-  line();
-}
 function userBox(text) {
   const inner = boxInnerWidth();
   const textW = inner - 2;
@@ -158,23 +195,166 @@ function reasoningHeader() {
   line();
   line("  " + c.magenta("\u273B ") + c.dim(c.italic("thinking")));
 }
-var Spinner = class _Spinner {
-  static frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  i = 0;
+var SWIPE = [
+  238,
+  239,
+  240,
+  242,
+  244,
+  246,
+  248,
+  250,
+  252,
+  254,
+  255,
+  87,
+  51,
+  45,
+  44,
+  45,
+  51,
+  87,
+  255,
+  254,
+  252,
+  250,
+  248,
+  246,
+  244,
+  242,
+  240,
+  239
+];
+var TRUECOLOR = /truecolor|24bit/i.test(process.env.COLORTERM ?? "");
+function swipeRgb(t) {
+  const stops = [
+    [60, 64, 74],
+    [0, 200, 212],
+    [235, 242, 255],
+    [0, 200, 212],
+    [60, 64, 74]
+  ];
+  const x = t % 1 * (stops.length - 1);
+  const i = Math.floor(x);
+  const f = x - i;
+  const a = stops[i];
+  const b = stops[Math.min(i + 1, stops.length - 1)];
+  return [
+    Math.round(a[0] + (b[0] - a[0]) * f),
+    Math.round(a[1] + (b[1] - a[1]) * f),
+    Math.round(a[2] + (b[2] - a[2]) * f)
+  ];
+}
+function swipeAnsi(p) {
+  if (TRUECOLOR) {
+    const [r, g, b] = swipeRgb((p % SWIPE.length + SWIPE.length) % SWIPE.length / SWIPE.length);
+    return `\x1B[38;2;${r};${g};${b}m`;
+  }
+  return `\x1B[38;5;${SWIPE[(p % SWIPE.length + SWIPE.length) % SWIPE.length]}m`;
+}
+function shimmerText(text, phase) {
+  if (!useColor) return text;
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === " ") {
+      out += ch;
+      continue;
+    }
+    out += swipeAnsi(i + phase) + ch + "\x1B[0m";
+  }
+  return out;
+}
+var THINKING_WORDS = [
+  "thinking",
+  "cooking",
+  "vibin",
+  "whippin",
+  "stirring the pot",
+  "noodlin",
+  "scheming",
+  "wiring it up",
+  "summoning",
+  "locking in",
+  "manifesting",
+  "crunching",
+  "galaxy braining",
+  "percolating",
+  "marinating",
+  "conjuring",
+  "untangling",
+  "threading the needle",
+  "herding electrons",
+  "spelunking the stack",
+  "chiseling",
+  "brewing",
+  "plotting",
+  "tinkering",
+  "compiling thoughts",
+  "doing the thing"
+];
+var THINKING_WORDS_YOLO = [
+  "makin babies",
+  "stressin",
+  "sending it",
+  "full send",
+  "cooking with gas",
+  "going feral",
+  "yeetin code",
+  "gambling",
+  "raw-doggin prod",
+  "no cap buildin",
+  "speedrunnin",
+  "touchin grass",
+  "zootin",
+  "catchin a fade",
+  "standin on business"
+];
+function thinkingWords(yolo = false) {
+  return yolo ? [...THINKING_WORDS, ...THINKING_WORDS_YOLO] : THINKING_WORDS;
+}
+var Spinner = class {
+  phase = 0;
+  ticks = 0;
   timer = null;
   text = "";
-  start(text) {
+  phrases = null;
+  phraseIdx = 0;
+  hint = "";
+  startedAt = 0;
+  /**
+   * @param text     fixed label (used when no `phrases`)
+   * @param opts.phrases  rotate through these instead of a fixed label
+   * @param opts.hint     dim suffix, e.g. "esc to interrupt"
+   */
+  start(text, opts = {}) {
     if (!TTY) return;
     this.text = text;
-    this.timer = setInterval(() => this.tick(), 90);
+    this.phrases = opts.phrases && opts.phrases.length ? opts.phrases : null;
+    this.hint = opts.hint ?? "";
+    this.phraseIdx = this.phrases ? Date.now() % this.phrases.length : 0;
+    this.startedAt = Date.now();
+    this.timer = setInterval(() => this.tick(), 80);
     this.tick();
   }
   update(text) {
     this.text = text;
   }
+  label() {
+    if (this.phrases) return this.phrases[this.phraseIdx % this.phrases.length] + "\u2026";
+    return this.text;
+  }
   tick() {
-    const frame = _Spinner.frames[this.i = (this.i + 1) % _Spinner.frames.length];
-    process.stderr.write(`\r  ${c.cyan(frame)} ${c.dim(this.text)}\x1B[K`);
+    this.ticks++;
+    if (this.phrases && this.ticks % 30 === 0) {
+      this.phraseIdx = (this.phraseIdx + 1) % this.phrases.length;
+    }
+    this.phase = (this.phase + SWIPE.length - 1) % SWIPE.length;
+    const dot = swipeAnsi(this.phase) + "\u2726\x1B[0m";
+    const secs = Math.floor((Date.now() - this.startedAt) / 1e3);
+    const elapsed = secs >= 1 ? c.dim(` ${secs}s`) : "";
+    const tail2 = this.hint ? "  " + c.dim(`(${this.hint})`) : "";
+    process.stderr.write(`\r  ${dot} ${shimmerText(this.label(), this.phase)}${elapsed}${tail2}\x1B[K`);
   }
   stop() {
     if (this.timer) {
@@ -721,10 +901,111 @@ function tail(s) {
   return s.slice(-4e3);
 }
 
+// src/tasks.ts
+import { spawn as spawn4 } from "child_process";
+var MAX_OUTPUT_CHARS = 64 * 1024;
+var TaskManager = class {
+  seq = 0;
+  map = /* @__PURE__ */ new Map();
+  /** Start a detached-from-the-REPL background command. Returns the task id. */
+  start(command, args, cwd) {
+    const id = `t${++this.seq}`;
+    const display = [command, ...args].join(" ");
+    const child = spawn4(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      // Own process group so we can signal the whole tree on kill.
+      detached: false
+    });
+    const task = {
+      id,
+      display,
+      status: "running",
+      exitCode: null,
+      startedAt: Date.now(),
+      endedAt: null,
+      announced: false,
+      child,
+      buffer: ""
+    };
+    const append = (chunk) => {
+      task.buffer += chunk.toString();
+      if (task.buffer.length > MAX_OUTPUT_CHARS) {
+        task.buffer = task.buffer.slice(task.buffer.length - MAX_OUTPUT_CHARS);
+      }
+    };
+    child.stdout?.on("data", append);
+    child.stderr?.on("data", append);
+    child.on("error", (e) => {
+      task.buffer += `
+[spawn error] ${e.message}
+`;
+      task.status = "failed";
+      task.exitCode = task.exitCode ?? -1;
+      task.endedAt = Date.now();
+    });
+    child.on("close", (code) => {
+      task.exitCode = code;
+      task.status = code === 0 ? "exited" : "failed";
+      task.endedAt = Date.now();
+    });
+    this.map.set(id, task);
+    return this.toRecord(task);
+  }
+  toRecord(t) {
+    const { child: _child, buffer: _buffer, ...rec } = t;
+    return { ...rec };
+  }
+  get(id) {
+    const t = this.map.get(id);
+    if (!t) return null;
+    return { record: this.toRecord(t), output: t.buffer };
+  }
+  list() {
+    return [...this.map.values()].map((t) => this.toRecord(t));
+  }
+  /** Tasks that finished since the last call and haven't been announced yet. */
+  drainCompleted() {
+    const done = [];
+    for (const t of this.map.values()) {
+      if (t.status !== "running" && !t.announced) {
+        t.announced = true;
+        done.push(this.toRecord(t));
+      }
+    }
+    return done;
+  }
+  kill(id) {
+    const t = this.map.get(id);
+    if (!t) return false;
+    if (t.status === "running") {
+      try {
+        t.child.kill("SIGTERM");
+      } catch {
+      }
+    }
+    return true;
+  }
+  killAll() {
+    for (const t of this.map.values()) {
+      if (t.status === "running") {
+        try {
+          t.child.kill("SIGTERM");
+        } catch {
+        }
+      }
+    }
+  }
+  runtimeSeconds(t) {
+    return Math.round(((t.endedAt ?? Date.now()) - t.startedAt) / 1e3);
+  }
+};
+var tasks = new TaskManager();
+
 // src/tools.ts
 import { tool } from "ai";
 import { z } from "zod";
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { readFile as readFile2, writeFile, mkdir, readdir, stat } from "fs/promises";
 import { resolve as resolve2, dirname as dirname2, relative, join as join4, sep as sep2 } from "path";
 import fg from "fast-glob";
@@ -739,7 +1020,7 @@ function inside(ctx, p) {
 }
 function runShell(cmd, args, opts) {
   return new Promise((res) => {
-    const child = spawn4(cmd, args, { cwd: opts.cwd, shell: false });
+    const child = spawn5(cmd, args, { cwd: opts.cwd, shell: false });
     let out = "";
     const timer = setTimeout(() => child.kill("SIGKILL"), opts.timeoutMs);
     const onAbort = () => child.kill("SIGKILL");
@@ -772,7 +1053,7 @@ async function search(ctx, pattern, searchPath, globPat, ignoreCase, maxResults,
     if (globPat) args.push("--glob", globPat);
     for (const ig of IGNORE) args.push("--glob", "!" + ig);
     args.push("-e", pattern, abs);
-    const child = spawn4("rg", args, { cwd: ctx.cwd });
+    const child = spawn5("rg", args, { cwd: ctx.cwd });
     const onAbort = () => child.kill("SIGKILL");
     signal?.addEventListener("abort", onAbort, { once: true });
     let out = "";
@@ -1237,19 +1518,77 @@ function buildTools(ctx) {
         }
         return { ok: false, error: r.error, log: r.log };
       }
+    }),
+    run_background: tool({
+      description: "Start a long-running command in the BACKGROUND (builds, test watchers, long scripts) and keep working. Returns a task id immediately \u2014 DO NOT wait. Poll it later with task_output, or just continue; finished tasks are reported back automatically. Use this instead of run_command when a job takes more than a few seconds or should run while you do other work. Gated by the permission layer like run_command.",
+      inputSchema: z.object({
+        command: z.string().describe("The executable, e.g. pnpm, npm, forge, node, vitest."),
+        args: z.array(z.string()).default([])
+      }),
+      execute: async ({ command, args }) => {
+        const display = [command, ...args].join(" ");
+        if (await permissions.requestCommand(`(background) ${display}`) === "deny") {
+          return {
+            ok: false,
+            declined: true,
+            error: permissions.isPlan() ? permissions.planRefusal() : `declined: \`${display}\` \u2014 approve it, switch /mode, or re-run with --yes.`
+          };
+        }
+        const rec = tasks.start(command, args, ctx.cwd);
+        toolLine("run_background", c.dim(`${rec.id} \xB7 ${display}`));
+        return {
+          ok: true,
+          taskId: rec.id,
+          status: rec.status,
+          note: `started in background as ${rec.id}; poll with task_output or keep working`
+        };
+      }
+    }),
+    task_output: tool({
+      description: "Check a background task started with run_background: its status (running|exited|failed), exit code, runtime, and latest output. Pass no id to list all tasks. Use after starting a background job to see whether it finished and what it produced.",
+      inputSchema: z.object({
+        id: z.string().optional().describe("Task id (e.g. t1). Omit to list every task."),
+        tail: z.number().int().min(200).max(2e4).default(4e3).describe("Max output chars to return.")
+      }),
+      execute: async ({ id, tail: tail2 }) => {
+        if (!id) {
+          return {
+            ok: true,
+            tasks: tasks.list().map((t) => ({
+              id: t.id,
+              status: t.status,
+              exitCode: t.exitCode,
+              seconds: tasks.runtimeSeconds(t),
+              command: t.display
+            }))
+          };
+        }
+        const found = tasks.get(id);
+        if (!found) return { ok: false, error: `no task ${id}` };
+        toolLine("task_output", c.dim(`${id} \xB7 ${found.record.status}`));
+        return {
+          ok: true,
+          id,
+          status: found.record.status,
+          exitCode: found.record.exitCode,
+          seconds: tasks.runtimeSeconds(found.record),
+          command: found.record.display,
+          output: found.output.slice(-tail2)
+        };
+      }
     })
   };
 }
 
 // src/hooks.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { readFileSync, existsSync as existsSync4 } from "fs";
 import { homedir } from "os";
 import { join as join5 } from "path";
 var HOOK_TIMEOUT_MS = 15e3;
 function runOne(def, event, payload, cwd) {
   return new Promise((res) => {
-    const child = spawn5("sh", ["-c", def.command], { cwd });
+    const child = spawn6("sh", ["-c", def.command], { cwd });
     let stdout2 = "";
     let stderr = "";
     const timer = setTimeout(() => child.kill("SIGKILL"), HOOK_TIMEOUT_MS);
@@ -1472,10 +1811,14 @@ var OPENROUTER_URL = "https://openrouter.ai/api/v1";
 var CEREBRAS_KEY = "CEREBRAS_API_KEY";
 var KEY_ENV = "OPENROUTER_API_KEY";
 var DEFAULT_CUSTOM_MODEL = "anthropic/claude-sonnet-4.6";
+var VISION_MODEL = process.env.ZETA_VISION_MODEL?.trim() || "anthropic/claude-sonnet-4.6";
 var MODELS = /* @__PURE__ */ new Map([
   ["zeta-g1-lite", { modelId: "gpt-oss-120b", label: "Zeta-G1.0 Lite", keyEnv: CEREBRAS_KEY, baseURL: CEREBRAS_URL, contextWindow: 128e3, thinking: "budget" }],
   ["zeta-g1", { modelId: "zai-glm-4.7", label: "Zeta-G1.0", keyEnv: CEREBRAS_KEY, baseURL: CEREBRAS_URL, contextWindow: 128e3, thinking: "budget" }],
-  ["zeta-g1-max", { modelId: "zai-glm-4.7", label: "Zeta-G1.0 MAX", keyEnv: CEREBRAS_KEY, baseURL: CEREBRAS_URL, contextWindow: 128e3, thinking: "budget" }]
+  ["zeta-g1-max", { modelId: "zai-glm-4.7", label: "Zeta-G1.0 MAX", keyEnv: CEREBRAS_KEY, baseURL: CEREBRAS_URL, contextWindow: 128e3, thinking: "budget" }],
+  // The vision tier — accepts image input (screenshots, mocks, diagrams). Routed
+  // over OpenRouter because the Cerebras tiers are text-only.
+  ["zeta-g1-vision", { modelId: VISION_MODEL, label: "Zeta-G1.0 Vision", keyEnv: KEY_ENV, baseURL: OPENROUTER_URL, contextWindow: 2e5, thinking: null }]
 ]);
 var MODEL_KEYS = [...MODELS.keys()];
 function registerCustom(id) {
@@ -1510,6 +1853,9 @@ function resolveModelKey(raw) {
     lite: "zeta-g1-lite",
     max: "zeta-g1-max",
     pro: "zeta-g1-max",
+    vision: "zeta-g1-vision",
+    vis: "zeta-g1-vision",
+    image: "zeta-g1-vision",
     // legacy convenience — resolve silently, but only the Zeta label is shown
     opus: "zeta-g1-max",
     sonnet: "zeta-g1",
@@ -1531,6 +1877,9 @@ function modelLabel(key) {
 function modelId(key) {
   return spec(key).modelId;
 }
+function visionCapable(key) {
+  return key === "zeta-g1-vision" || key.startsWith("custom:");
+}
 function modelContextWindow(key) {
   return spec(key).contextWindow;
 }
@@ -1747,6 +2096,35 @@ var ROLE_PLANNER = [
   "name the files and seams involved, and call out unknowns and risks up front.",
   "Propose the smallest plan that fully covers the goal."
 ].join("\n");
+var ROLE_NZT_48 = [
+  "ROLE \u2014 NZT-48 (web3 special operations):",
+  "You are NZT-48 for this session: a web3 special-ops agent \u2014 sharper than an",
+  "arrow, precise and tactical with every move. Voice: precise, tactical,",
+  "economical. State the objective, the move, and the evidence \u2014 nothing else.",
+  "",
+  "Drive the CLI's web3 commands (audit / prove / verify) and the existing",
+  "Foundry \xB7 Slither \xB7 Halmos \xB7 firewall harness \u2014 do not reinvent the prover.",
+  "",
+  "FOUR MISSIONS \u2014 run the one the request calls for, end to end:",
+  "1. AUDIT & PROVE \u2014 discover every contract and ALL candidate invariants (never",
+  "   just the first); prove each with the real harness; fold verdicts honestly",
+  "   (proven / refuted / degraded); emit the signed bundle. Degraded is NOT a",
+  "   pass.",
+  "2. EXPLOIT RECON (defensive) \u2014 map the attack surface (reentrancy, access",
+  "   control, overflow, oracle/price manipulation, unchecked calls, value",
+  "   extraction, proxy traps). Report severity + location + exploit path + fix.",
+  "   Hunt weaknesses to CLOSE them; never weaponize.",
+  "3. BUILD & SHIP \u2014 idea \u2192 ISL \u2192 Solidity \u2192 proven \u2192 deploy-ready, inside the",
+  "   deterministic provable fragment. Run forge build/test, Slither, Halmos.",
+  "   Never weaken a gate to force green \u2014 self-heal the spec instead.",
+  "4. MONITOR & RESPOND \u2014 re-prove only changed contracts on .sol PRs; report",
+  "   SHIP / NO_SHIP; surface anomalies with evidence, never act destructively.",
+  "",
+  "RULES OF ENGAGEMENT: truth over optics (a refuted invariant honestly reported",
+  "is a win; fake-success is the one unforgivable error). One contract per proof",
+  "file; honor non-vacuity. Defensive only \u2014 refuse mass targeting, live attacks,",
+  "or anything outside an authorized engagement."
+].join("\n");
 var DEFAULT_REGISTRY = (() => {
   const r = new PromptRegistry();
   r.registerSystem("zeta-g", ZETA_G_SYSTEM);
@@ -1754,6 +2132,7 @@ var DEFAULT_REGISTRY = (() => {
   r.registerOverlay({ id: "verify", body: VERIFY_OVERLAY });
   r.registerRole({ role: "coder", body: ROLE_CODER });
   r.registerRole({ role: "planner", body: ROLE_PLANNER });
+  r.registerRole({ role: "nzt-48", body: ROLE_NZT_48 });
   return r;
 })();
 
@@ -2377,6 +2756,208 @@ import {
   streamText,
   stepCountIs
 } from "ai";
+
+// src/markdown.ts
+var useColor2 = process.stdout.isTTY && !process.env.NO_COLOR;
+var truecolor = /truecolor|24bit/i.test(process.env.COLORTERM ?? "");
+function fg2(r, g, b, c256) {
+  if (!useColor2) return "";
+  return truecolor ? `\x1B[38;2;${r};${g};${b}m` : `\x1B[38;5;${c256}m`;
+}
+var RESET = useColor2 ? "\x1B[0m" : "";
+var SY = {
+  keyword: fg2(198, 120, 221, 176),
+  // violet
+  string: fg2(152, 195, 121, 114),
+  // green
+  number: fg2(209, 154, 102, 173),
+  // orange
+  comment: fg2(106, 115, 125, 244),
+  // gray
+  fn: fg2(97, 175, 239, 75),
+  // blue
+  punct: fg2(160, 168, 180, 247),
+  type: fg2(229, 192, 123, 180)
+  // yellow
+};
+var KEYWORDS = /\b(const|let|var|function|return|if|else|for|while|switch|case|break|continue|new|class|extends|import|export|from|default|async|await|try|catch|finally|throw|typeof|instanceof|in|of|this|super|yield|static|public|private|protected|readonly|interface|type|enum|namespace|implements|as|void|null|undefined|true|false|def|elif|lambda|pass|with|fn|let|mut|pub|use|struct|impl|match|where|select|insert|update|delete|create|table|primary|key|foreign|references|contract|mapping|address|uint256|require|emit|modifier|memory|storage|payable)\b/g;
+function highlightLine(src, _lang) {
+  if (!useColor2) return src;
+  const cm = src.match(/^(\s*)(\/\/.*|#.*)$/);
+  if (cm) return cm[1] + SY.comment + cm[2] + RESET;
+  let out = "";
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      let j = i + 1;
+      while (j < src.length && src[j] !== ch) {
+        if (src[j] === "\\") j++;
+        j++;
+      }
+      out += SY.string + src.slice(i, Math.min(j + 1, src.length)) + RESET;
+      i = j + 1;
+      continue;
+    }
+    if (/[0-9]/.test(ch) && (i === 0 || /[^A-Za-z0-9_]/.test(src[i - 1]))) {
+      let j = i;
+      while (j < src.length && /[0-9a-fx._]/i.test(src[j])) j++;
+      out += SY.number + src.slice(i, j) + RESET;
+      i = j;
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(ch)) {
+      let j = i;
+      while (j < src.length && /[A-Za-z0-9_$]/.test(src[j])) j++;
+      const word = src.slice(i, j);
+      KEYWORDS.lastIndex = 0;
+      if (KEYWORDS.test(word)) out += SY.keyword + word + RESET;
+      else if (src[j] === "(") out += SY.fn + word + RESET;
+      else if (/^[A-Z]/.test(word)) out += SY.type + word + RESET;
+      else out += word;
+      i = j;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+function inline(s) {
+  if (!useColor2) return s.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)");
+  let out = s;
+  out = out.replace(/`([^`]+)`/g, (_m, code) => fg2(229, 192, 123, 180) + code + RESET);
+  out = out.replace(/\*\*([^*]+)\*\*/g, (_m, t) => "\x1B[1m" + t + "\x1B[22m");
+  out = out.replace(/(^|[^*])\*([^*]+)\*/g, (_m, p, t) => p + "\x1B[3m" + t + "\x1B[23m");
+  out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, t, u) => "\x1B[4m" + t + "\x1B[24m" + c.dim(` (${u})`));
+  return out;
+}
+function renderMarkdown(md, width = 76) {
+  const lines = md.replace(/\r/g, "").split("\n");
+  const out = [];
+  let inCode = false;
+  let codeLang = "";
+  for (let li = 0; li < lines.length; li++) {
+    const raw = lines[li];
+    if (!inCode && raw.includes("|") && li + 1 < lines.length && /^\s*\|?[\s:|-]*-{2,}[\s:|-]*\|?\s*$/.test(lines[li + 1]) && lines[li + 1].includes("-")) {
+      const header = splitTableRow(raw);
+      li++;
+      const body = [];
+      while (li + 1 < lines.length && lines[li + 1].includes("|") && lines[li + 1].trim()) {
+        li++;
+        body.push(splitTableRow(lines[li]));
+      }
+      for (const tl of renderTable(header, body, width)) out.push(tl);
+      continue;
+    }
+    const fence = raw.match(/^\s*```(\w*)\s*$/);
+    if (fence) {
+      if (!inCode) {
+        inCode = true;
+        codeLang = fence[1] || "";
+        out.push(c.dim("  \u250C" + (codeLang ? ` ${codeLang} ` : "\u2500").padEnd(Math.min(width, 40), "\u2500")));
+      } else {
+        inCode = false;
+        out.push(c.dim("  \u2514" + "\u2500".repeat(Math.min(width, 38))));
+      }
+      continue;
+    }
+    if (inCode) {
+      out.push(c.dim("  \u2502 ") + highlightLine(raw, codeLang));
+      continue;
+    }
+    const h = raw.match(/^(#{1,6})\s+(.*)$/);
+    if (h) {
+      const txt = inline(h[2]);
+      out.push("");
+      out.push("  " + (useColor2 ? "\x1B[1m" : "") + (h[1].length <= 2 ? c.cyan(txt) : txt) + RESET);
+      continue;
+    }
+    if (/^\s*([-*_])\1{2,}\s*$/.test(raw)) {
+      out.push("  " + c.dim("\u2500".repeat(Math.min(width, 40))));
+      continue;
+    }
+    const q = raw.match(/^\s*>\s?(.*)$/);
+    if (q) {
+      out.push("  " + c.dim("\u258F ") + c.italic(inline(q[1])));
+      continue;
+    }
+    const ul = raw.match(/^(\s*)[-*+]\s+(.*)$/);
+    const ol = raw.match(/^(\s*)(\d+)\.\s+(.*)$/);
+    if (ul) {
+      out.push("  " + ul[1] + c.cyan("\u2022 ") + inline(ul[2]));
+      continue;
+    }
+    if (ol) {
+      out.push("  " + ol[1] + c.cyan(ol[2] + ". ") + inline(ol[3]));
+      continue;
+    }
+    if (!raw.trim()) {
+      out.push("");
+      continue;
+    }
+    for (const w of wrap2(inline(raw), width)) out.push("  " + w);
+  }
+  return out;
+}
+function vlen(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+function splitTableRow(row) {
+  let s = row.trim();
+  if (s.startsWith("|")) s = s.slice(1);
+  if (s.endsWith("|")) s = s.slice(0, -1);
+  return s.split("|").map((cell) => inline(cell.trim()));
+}
+function renderTable(header, body, width) {
+  const cols = Math.max(header.length, ...body.map((r) => r.length));
+  const rows = [header, ...body].map((r) => {
+    const cp = r.slice();
+    while (cp.length < cols) cp.push("");
+    return cp;
+  });
+  let w = Array.from({ length: cols }, (_, ci) => Math.max(...rows.map((r) => vlen(r[ci]))));
+  const overhead = cols * 3 + 1;
+  const budget = Math.max(cols * 3, width - overhead);
+  const total = w.reduce((a, b) => a + b, 0);
+  if (total > budget) w = w.map((x) => Math.max(3, Math.floor(x / total * budget)));
+  const pad = (s, n) => {
+    const v = vlen(s);
+    if (v > n) {
+      const plain = s.replace(/\x1b\[[0-9;]*m/g, "");
+      return plain.slice(0, Math.max(0, n - 1)) + "\u2026";
+    }
+    return s + " ".repeat(n - v);
+  };
+  const bar = (l, m, r) => c.dim("  " + l + w.map((n) => "\u2500".repeat(n + 2)).join(m) + r);
+  const rowLine = (r, head) => "  " + c.dim("\u2502") + r.map((cell, ci) => " " + (head ? c.bold(c.cyan(pad(cell, w[ci]))) : pad(cell, w[ci])) + " ").join(c.dim("\u2502")) + c.dim("\u2502");
+  const out = [bar("\u250C", "\u252C", "\u2510"), rowLine(rows[0], true), bar("\u251C", "\u253C", "\u2524")];
+  for (const r of rows.slice(1)) out.push(rowLine(r, false));
+  out.push(bar("\u2514", "\u2534", "\u2518"));
+  return out;
+}
+function wrap2(s, width) {
+  const words = s.split(/(\s+)/);
+  const rows = [];
+  let cur = "";
+  let len = 0;
+  const vlen2 = (x) => x.replace(/\x1b\[[0-9;]*m/g, "").length;
+  for (const w of words) {
+    const wl = vlen2(w);
+    if (len + wl > width && cur) {
+      rows.push(cur);
+      cur = w.trimStart();
+      len = vlen2(cur);
+    } else {
+      cur += w;
+      len += wl;
+    }
+  }
+  if (cur.trim()) rows.push(cur);
+  return rows.length ? rows : [""];
+}
+
+// src/agent.ts
 var BASE_SYSTEM = `You are Zeta-G, a terminal coding agent for the ZETA engine.
 
 ZETA turns a plain-language idea into a real, verified application: it writes
@@ -2528,6 +3109,10 @@ var Agent = class {
   replaceHistory(messages) {
     this.history = messages;
   }
+  /** A shallow copy of the current message history (for /export, inspection). */
+  snapshot() {
+    return [...this.history];
+  }
   /** % of the model's context window the current history occupies. */
   contextPct() {
     return Math.min(100, estimateTokens(this.history) / this.contextWindow * 100);
@@ -2536,7 +3121,7 @@ var Agent = class {
     const native = this.toolNames.filter((t) => !isMcpTool(t));
     const mcp = this.toolNames.filter((t) => isMcpTool(t));
     const blocks = [
-      DEFAULT_REGISTRY.composeSystem({ id: "zeta-g", overlayIds: [] }),
+      DEFAULT_REGISTRY.composeSystem({ id: "zeta-g", role: this.opts.persona, overlayIds: [] }),
       this.policy.authorityPreamble(),
       `Tools available to you: ${native.join(", ")}.`
     ];
@@ -2582,7 +3167,7 @@ ${this.opts.memoryText}`);
     return false;
   }
   /** Run one user turn end-to-end; streams to stdout, updates history. */
-  async send(userInput, signal) {
+  async send(userInput, signal, images) {
     let input = userInput;
     if (this.opts.hooks?.has("UserPromptSubmit")) {
       const outcome = await this.opts.hooks.run("UserPromptSubmit", { prompt: userInput });
@@ -2598,11 +3183,22 @@ ${outcome.context.join("\n")}`;
       }
     }
     this.session?.appendUser(userInput);
-    this.history.push({ role: "user", content: input });
+    if (images && images.length > 0) {
+      this.history.push({
+        role: "user",
+        content: [
+          { type: "text", text: input },
+          ...images.map((img) => ({ type: "image", image: img.dataUrl }))
+        ]
+      });
+    } else {
+      this.history.push({ role: "user", content: input });
+    }
     await this.maybeCompact();
     const providerOptions = buildProviderOptions(this.modelKey, this.thinking);
+    const turnStart = Date.now();
     const spinner = new Spinner();
-    spinner.start("working\u2026  " + c.dim("esc to interrupt"));
+    spinner.start("", { phrases: thinkingWords(this.opts.yolo), hint: "esc to interrupt" });
     let spinning = true;
     const stopSpin = () => {
       if (spinning) {
@@ -2623,11 +3219,21 @@ ${outcome.context.join("\n")}`;
     let aborted = false;
     let textBuf = "";
     let genFirstAt = 0;
+    const toolStart = /* @__PURE__ */ new Map();
     const flushText = () => {
       const t = textBuf.trim();
       textBuf = "";
       phase = "none";
-      if (t) responseBox(t);
+      if (!t) return;
+      const inner = boxInnerWidth();
+      const label = " Zeta-G1.0 ";
+      const rem = Math.max(0, inner - label.length);
+      const lft = Math.floor(rem / 2);
+      line();
+      line("  " + c.cyan("\u256D" + "\u2500".repeat(lft) + label + "\u2500".repeat(rem - lft) + "\u256E"));
+      for (const ln of renderMarkdown(t, inner - 2)) line(ln);
+      line("  " + c.cyan("\u2570" + "\u2500".repeat(inner) + "\u256F"));
+      line();
     };
     try {
       for await (const part of result.fullStream) {
@@ -2658,7 +3264,7 @@ ${outcome.context.join("\n")}`;
           }
           case "start-step":
             if (phase !== "none" && !spinning) {
-              spinner.start("working\u2026  " + c.dim("esc to interrupt"));
+              spinner.start("", { phrases: thinkingWords(this.opts.yolo), hint: "esc to interrupt" });
               spinning = true;
             }
             break;
@@ -2670,7 +3276,20 @@ ${outcome.context.join("\n")}`;
               line();
               phase = "none";
             }
+            {
+              const id = part.toolCallId;
+              if (id) toolStart.set(id, Date.now());
+            }
+            break;
+          case "tool-result": {
+            const id = part.toolCallId;
+            const nm = String(part.toolName ?? "tool");
+            const started = id ? toolStart.get(id) : void 0;
+            const ms = started ? Date.now() - started : 0;
+            if (ms >= 300) line(c.dim(`  \u2713 ${nm} ${(ms / 1e3).toFixed(1)}s`));
+            if (id) toolStart.delete(id);
             break;
+          }
           case "tool-error": {
             stopSpin();
             if (phase === "text") flushText();
@@ -2756,6 +3375,7 @@ ${outcome.context.join("\n")}`;
     } catch {
     }
     if (!aborted) await this.maybeCompact();
+    if (!aborted && Date.now() - turnStart > 8e3) bell();
     return { aborted, usage };
   }
 };
@@ -2773,12 +3393,14 @@ function isPermissionMode(v) {
 }
 var PLAN_REFUSAL = "refused: plan mode is read-only \u2014 present a plan for approval, don't act. The user can switch with /mode default or approve with /approve.";
 var Permissions = class {
-  constructor(mode, confirm) {
+  constructor(mode, confirm, persistMode) {
     this.mode = mode;
     this.confirm = confirm;
+    this.persistMode = persistMode;
   }
   mode;
   confirm;
+  persistMode;
   alwaysCommands = /* @__PURE__ */ new Set();
   acceptAllEdits = false;
   isPlan() {
@@ -2801,8 +3423,15 @@ var Permissions = class {
     const ans = await this.confirm(`apply this edit to ${c.bold(path)}?`, [
       { key: "y", label: "yes" },
       { key: "n", label: "no" },
-      { key: "a", label: "yes to all edits this session" }
+      { key: "a", label: "yes to all edits this session" },
+      { key: "r", label: "yes to all edits, every session (remember)" }
     ]);
+    if (ans === "r") {
+      this.acceptAllEdits = true;
+      this.mode = "acceptEdits";
+      this.persistMode?.("acceptEdits");
+      return "allow";
+    }
     if (ans === "a") {
       this.acceptAllEdits = true;
       return "allow";
@@ -3023,6 +3652,139 @@ var Session = class _Session {
 import { writeFileSync as writeFileSync2, existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join8 } from "path";
+
+// src/git.ts
+import { execFileSync } from "child_process";
+function git(args, cwd) {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 32 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
+}
+function gitSafe(args, cwd) {
+  try {
+    return git(args, cwd);
+  } catch {
+    return null;
+  }
+}
+function isRepo(cwd) {
+  return gitSafe(["rev-parse", "--is-inside-work-tree"], cwd) === "true";
+}
+var SECRET_HINTS = [
+  { re: /\bAKIA[0-9A-Z]{16}\b/, label: "AWS access key id" },
+  { re: /\bsk-[A-Za-z0-9]{20,}\b/, label: "OpenAI-style key" },
+  { re: /\bsk_live_[A-Za-z0-9]{20,}\b/, label: "Stripe live secret" },
+  { re: /\bghp_[A-Za-z0-9]{30,}\b/, label: "GitHub token" },
+  { re: /\bvbfl_[A-Za-z0-9]{8}_[A-Za-z0-9_-]{20,}\b/, label: "Wholestack PAT" },
+  { re: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/, label: "private key" }
+];
+function scanSecrets(diff) {
+  const hits = /* @__PURE__ */ new Set();
+  for (const { re, label } of SECRET_HINTS) {
+    if (re.test(diff)) hits.add(label);
+  }
+  return [...hits];
+}
+var MAX_DIFF_CHARS = 12e3;
+var gitCommands = [
+  {
+    name: "diff",
+    summary: "show working changes (/diff [--staged] [path])",
+    source: "builtin",
+    run: (ctx) => {
+      if (!isRepo(ctx.cwd)) {
+        ctx.print("  " + c.yellow("not a git repository."));
+        return { type: "handled" };
+      }
+      const parts = ctx.args.split(/\s+/).filter(Boolean);
+      const staged = parts.includes("--staged") || parts.includes("--cached");
+      const paths = parts.filter((p) => p !== "--staged" && p !== "--cached");
+      const args = ["--no-pager", "diff"];
+      if (staged) args.push("--staged");
+      if (paths.length) args.push("--", ...paths);
+      const out = gitSafe(args, ctx.cwd) ?? "";
+      if (!out) {
+        ctx.print("  " + c.dim(staged ? "no staged changes." : "no unstaged changes."));
+        return { type: "handled" };
+      }
+      const secrets = scanSecrets(out);
+      if (secrets.length) {
+        ctx.print("  " + c.red(`\u26A0 possible secret(s) in diff: ${secrets.join(", ")}`));
+      }
+      const shown = out.length > MAX_DIFF_CHARS ? out.slice(0, MAX_DIFF_CHARS) : out;
+      ctx.print(shown);
+      if (out.length > MAX_DIFF_CHARS) {
+        ctx.print("  " + c.dim(`\u2026 (${out.length - MAX_DIFF_CHARS} more chars \u2014 run \`git diff\` for the rest)`));
+      }
+      return { type: "handled" };
+    }
+  },
+  {
+    name: "commit",
+    summary: "commit changes (/commit [message] \u2014 omit to auto-write one)",
+    source: "builtin",
+    run: (ctx) => {
+      if (!isRepo(ctx.cwd)) {
+        ctx.print("  " + c.yellow("not a git repository. Run `git init` first."));
+        return { type: "handled" };
+      }
+      const full = (gitSafe(["--no-pager", "diff", "HEAD"], ctx.cwd) ?? "") + (gitSafe(["--no-pager", "diff", "--staged"], ctx.cwd) ?? "");
+      const secrets = scanSecrets(full);
+      if (secrets.length) {
+        ctx.print("  " + c.red(`\u2717 refusing to commit \u2014 possible secret(s): ${secrets.join(", ")}`));
+        ctx.print("  " + c.dim("remove them (or add to .gitignore) and try again."));
+        return { type: "handled" };
+      }
+      const msg = ctx.args.trim();
+      if (msg) {
+        try {
+          git(["add", "-A"], ctx.cwd);
+          const out = git(["commit", "-m", msg], ctx.cwd);
+          ctx.print("  " + c.green("\u2713 committed"));
+          ctx.print("  " + c.dim(out.split("\n")[0] ?? ""));
+        } catch (e) {
+          ctx.print("  " + c.red(e.message.split("\n")[0]));
+        }
+        return { type: "handled" };
+      }
+      const branch = gitSafe(["rev-parse", "--abbrev-ref", "HEAD"], ctx.cwd) ?? "?";
+      return {
+        type: "prompt",
+        text: `Create a git commit for the current changes. Steps, using run_command:
+1. \`git status --porcelain\` and \`git --no-pager diff HEAD\` to see what changed.
+2. If nothing is staged, \`git add -A\` (but NEVER stage .env, secrets, or key files).
+3. Write ONE Conventional Commit message: \`type(scope): summary\` (\u226472 chars), a body only if the change needs it. Base it strictly on the actual diff \u2014 no invented changes.
+4. \`git commit -m "\u2026"\` (current branch: ${branch}). Show me the message you used.
+Do NOT push. Do NOT commit anything that looks like a credential.`
+      };
+    }
+  },
+  {
+    name: "pr",
+    summary: "push the branch and open a pull request (/pr [title])",
+    source: "builtin",
+    run: (ctx) => {
+      if (!isRepo(ctx.cwd)) {
+        ctx.print("  " + c.yellow("not a git repository."));
+        return { type: "handled" };
+      }
+      const branch = gitSafe(["rev-parse", "--abbrev-ref", "HEAD"], ctx.cwd) ?? "?";
+      const title = ctx.args.trim();
+      return {
+        type: "prompt",
+        text: `Open a pull request for the current branch. Steps, using run_command:
+1. Confirm the branch (\`${branch}\`) is not the default; if it is, create a feature branch first.
+2. \`git push -u origin HEAD\`.
+3. \`gh pr create\` with a clear title` + (title ? ` (use: "${title}")` : " summarizing the change") + " and a concise body listing the key changes from the commit log/diff.\nIf `gh` is not installed or not authenticated, stop and tell me the manual PR URL instead."
+      };
+    }
+  }
+];
+
+// src/commands.ts
 var ZETA_MD_TEMPLATE = `# ZETA.md \u2014 project memory for Zeta-G
 
 Tell the agent how this project works. It reads this file into its system prompt.
@@ -3359,6 +4121,39 @@ var BUILTINS = [
       ctx.print("  " + c.dim("run ") + c.cyan("zeta-g login") + c.dim(" in your shell, then restart the session."));
       return { type: "handled" };
     }
+  },
+  ...gitCommands,
+  {
+    name: "export",
+    aliases: ["save"],
+    summary: "write the transcript to markdown (/export [file.md])",
+    source: "builtin",
+    run: (ctx) => ({ type: "export", file: ctx.args.trim() || void 0 })
+  },
+  {
+    name: "tasks",
+    aliases: ["jobs"],
+    summary: "list background tasks (/tasks \xB7 /tasks kill <id>)",
+    source: "builtin",
+    run: (ctx) => {
+      const parts = ctx.args.split(/\s+/).filter(Boolean);
+      if (parts[0] === "kill" && parts[1]) {
+        const ok = tasks.kill(parts[1]);
+        ctx.print("  " + (ok ? c.green(`signaled ${parts[1]}`) : c.red(`no task ${parts[1]}`)));
+        return { type: "handled" };
+      }
+      const list = tasks.list();
+      if (list.length === 0) {
+        ctx.print("  " + c.dim("no background tasks. The agent starts them with run_background."));
+        return { type: "handled" };
+      }
+      for (const t of list) {
+        const dot = t.status === "running" ? c.yellow("\u25CF") : t.status === "exited" ? c.green("\u2713") : c.red("\u2717");
+        const code = t.exitCode == null ? "" : c.dim(` (exit ${t.exitCode})`);
+        ctx.print(`  ${dot} ${c.cyan(t.id)} ${c.dim(`${tasks.runtimeSeconds(t)}s`)}  ${t.display}${code}`);
+      }
+      return { type: "handled" };
+    }
   }
 ];
 function parseCustom(name, body, source = "custom") {
@@ -3859,8 +4654,16 @@ var InputController = class {
     }
     return [[], line2];
   }
-  /** Read one logical line, joining trailing-backslash continuations. */
+  /** Read one logical line. On a TTY this renders a live bordered input box
+   *  (the box appears WHILE you type, not as an after-the-fact echo). On a
+   *  non-TTY / piped stdin it falls back to plain readline. */
   async readLine(promptStr) {
+    if (stdin.isTTY && !process.env.NO_COLOR) {
+      const text = await this.readBoxed();
+      const trimmed2 = text.trim();
+      if (trimmed2) this.saveHistory(trimmed2);
+      return trimmed2;
+    }
     let acc = "";
     let prompt = promptStr;
     for (; ; ) {
@@ -3877,6 +4680,230 @@ var InputController = class {
     if (trimmed) this.saveHistory(trimmed);
     return trimmed;
   }
+  /**
+   * Live bordered input editor. Redraws a 4-side box on every keystroke with
+   * the caret tracked inside it. Supports: insert/backspace/delete, ←/→,
+   * Home/End (Ctrl-A/E), ↑/↓ history, Tab completion (/commands + @paths),
+   * Shift/Alt-Enter or a trailing "\\" for a newline, Enter to submit,
+   * Ctrl-C to quit, Ctrl-U to clear, Esc to clear the line.
+   */
+  readBoxed() {
+    const PROMPT = "\u203A ";
+    const history = loadHistory();
+    let histIdx = history.length;
+    let draft = "";
+    let buf = "";
+    let cur = 0;
+    let prevRows = 0;
+    let F = Math.max(8, boxInnerWidth() - 2);
+    let W = F + 2;
+    const up = (n) => n > 0 ? `\x1B[${n}A` : "";
+    const right = (n) => n > 0 ? `\x1B[${n}C` : "";
+    const layout = (s) => {
+      const rows = [""];
+      const map = [];
+      let r = 0;
+      let col = 0;
+      for (let i = 0; i < s.length; i++) {
+        map[i] = { r, c: col };
+        const ch = s[i];
+        if (ch === "\n") {
+          r++;
+          col = 0;
+          rows[r] = "";
+          continue;
+        }
+        rows[r] += ch;
+        col++;
+        if (col >= F) {
+          r++;
+          col = 0;
+          rows[r] = "";
+        }
+      }
+      map[s.length] = { r, c: col };
+      return { rows, map };
+    };
+    const render = () => {
+      const S = PROMPT + buf;
+      const { rows, map } = layout(S);
+      const caret = map[PROMPT.length + cur];
+      const contentRows = rows.length;
+      let out = "";
+      if (prevRows > 0) out += up(prevCaretR + 1) + "\r";
+      out += "\x1B[J";
+      out += "\r  " + c.dim("\u256D" + "\u2500".repeat(W) + "\u256E") + "\n";
+      rows.forEach((row, i) => {
+        let cell = row;
+        let body;
+        if (i === 0 && cell.startsWith(PROMPT)) {
+          body = c.cyan(PROMPT) + cell.slice(PROMPT.length).padEnd(F - PROMPT.length);
+        } else {
+          body = cell.padEnd(F);
+        }
+        out += "\r  " + c.dim("\u2502") + " " + body + " " + c.dim("\u2502") + "\n";
+      });
+      out += "\r  " + c.dim("\u2570" + "\u2500".repeat(W) + "\u256F");
+      out += up(contentRows - caret.r) + "\r" + right(4 + caret.c);
+      stdout.write(out);
+      prevRows = contentRows;
+      prevCaretR = caret.r;
+    };
+    let prevCaretR = 0;
+    return new Promise((resolve3) => {
+      emitKeypressEvents(stdin);
+      const watching = this.activeWatch;
+      if (watching) this.stopWatch();
+      this.rl.pause();
+      if (stdin.isTTY) stdin.setRawMode(true);
+      stdin.resume();
+      stdout.write("\x1B[?2004h");
+      const onResize = () => {
+        F = Math.max(8, boxInnerWidth() - 2);
+        W = F + 2;
+        prevRows = 0;
+        render();
+      };
+      process.stdout.on("resize", onResize);
+      const finish = (val) => {
+        stdin.off("keypress", onKey);
+        process.stdout.off("resize", onResize);
+        stdout.write("\x1B[?2004l");
+        if (stdin.isTTY) stdin.setRawMode(false);
+        const down = prevRows - prevCaretR;
+        stdout.write("\x1B[" + Math.max(1, down) + "B\r\n");
+        this.rl.resume();
+        if (watching) this.startWatch(watching);
+        resolve3(val);
+      };
+      const replaceLine = (s) => {
+        buf = s;
+        cur = buf.length;
+      };
+      const onKey = (s, key) => {
+        const name = key?.name;
+        if (key?.ctrl && name === "c") {
+          stdout.write("\n");
+          this.opts.onExit();
+          return;
+        }
+        if (key?.ctrl && name === "u") {
+          buf = "";
+          cur = 0;
+          return render();
+        }
+        if (key?.ctrl && name === "w") {
+          const before = buf.slice(0, cur).replace(/\s*\S+\s*$/, "");
+          const after = buf.slice(cur);
+          buf = before + after;
+          cur = before.length;
+          return render();
+        }
+        if (key?.ctrl && name === "k") {
+          buf = buf.slice(0, cur);
+          return render();
+        }
+        if (key?.meta && name === "left") {
+          const m = buf.slice(0, cur).match(/\S+\s*$/);
+          cur -= m ? m[0].length : cur;
+          return render();
+        }
+        if (key?.meta && name === "right") {
+          const m = buf.slice(cur).match(/^\s*\S+/);
+          cur += m ? m[0].length : buf.length - cur;
+          return render();
+        }
+        if (name === "return" || name === "enter") {
+          if (key?.shift || key?.meta || buf.endsWith("\\")) {
+            if (buf.endsWith("\\")) {
+              buf = buf.slice(0, cur - 1) + "\n" + buf.slice(cur);
+            } else {
+              buf = buf.slice(0, cur) + "\n" + buf.slice(cur);
+            }
+            cur += 1;
+            return render();
+          }
+          return finish(buf);
+        }
+        if (name === "backspace") {
+          if (cur > 0) {
+            buf = buf.slice(0, cur - 1) + buf.slice(cur);
+            cur--;
+          }
+          return render();
+        }
+        if (name === "delete") {
+          if (cur < buf.length) buf = buf.slice(0, cur) + buf.slice(cur + 1);
+          return render();
+        }
+        if (name === "left") {
+          if (cur > 0) cur--;
+          return render();
+        }
+        if (name === "right") {
+          if (cur < buf.length) cur++;
+          return render();
+        }
+        if (name === "home" || key?.ctrl && name === "a") {
+          cur = 0;
+          return render();
+        }
+        if (name === "end" || key?.ctrl && name === "e") {
+          cur = buf.length;
+          return render();
+        }
+        if (name === "up") {
+          if (histIdx === history.length) draft = buf;
+          if (histIdx > 0) {
+            histIdx--;
+            replaceLine(history[histIdx]);
+          }
+          return render();
+        }
+        if (name === "down") {
+          if (histIdx < history.length) {
+            histIdx++;
+            replaceLine(histIdx === history.length ? draft : history[histIdx]);
+          }
+          return render();
+        }
+        if (name === "escape") {
+          buf = "";
+          cur = 0;
+          return render();
+        }
+        if (name === "tab") {
+          const [hits] = this.complete(buf.slice(0, cur));
+          if (hits.length) {
+            const prefix = longestCommonPrefix(hits);
+            const before = buf.slice(0, cur);
+            const ws = Math.max(before.lastIndexOf(" "), before.lastIndexOf("\n"));
+            const tokenStart = before.startsWith("/") && ws < 0 ? 0 : ws + 1;
+            buf = buf.slice(0, tokenStart) + prefix + buf.slice(cur);
+            cur = tokenStart + prefix.length;
+          }
+          return render();
+        }
+        const seq = key?.sequence ?? s ?? "";
+        if (seq.includes("\x1B[200~") || seq.includes("\x1B[201~")) {
+          const pasted = seq.replace(/\x1b\[20[01]~/g, "");
+          buf = buf.slice(0, cur) + pasted + buf.slice(cur);
+          cur += pasted.length;
+          return render();
+        }
+        const ins = s && !key?.ctrl && !key?.meta ? s : "";
+        if (ins && !ins.includes("\x1B")) {
+          buf = buf.slice(0, cur) + ins + buf.slice(cur);
+          cur += ins.length;
+          return render();
+        }
+      };
+      const bar = this.opts.contextBar?.();
+      if (bar) stdout.write("  " + bar + "\n");
+      stdin.on("keypress", onKey);
+      render();
+    });
+  }
   saveHistory(entry) {
     try {
       mkdirSync3(dirname5(HISTORY_FILE), { recursive: true });
@@ -3948,6 +4975,17 @@ var InputController = class {
     this.rl.close();
   }
 };
+function longestCommonPrefix(items) {
+  if (!items.length) return "";
+  let prefix = items[0];
+  for (const it of items.slice(1)) {
+    let i = 0;
+    while (i < prefix.length && i < it.length && prefix[i] === it[i]) i++;
+    prefix = prefix.slice(0, i);
+    if (!prefix) break;
+  }
+  return prefix;
+}
 
 export {
   c,
@@ -3961,6 +4999,7 @@ export {
   PROPERTY_KINDS,
   runProver,
   killRunningApps,
+  tasks,
   buildTools,
   HookRunner,
   mergeHookSets,
@@ -3971,6 +5010,7 @@ export {
   resolveModelKey,
   modelLabel,
   modelId,
+  visionCapable,
   modelContextWindow,
   supportsThinking,
   listModels,