wholestack 0.4.0 → 0.5.1

package/dist/cli.js

@@ -9,6 +9,7 @@ import {
   Session,
   announcePlanMode,
   banner,
+  buildTools,
   buildWebTools,
   c,
   isPermissionMode,
@@ -26,8 +27,10 @@ import {
   runProver,
   statusLine,
   supportsThinking,
-  userBox
-} from "./chunk-7DJJXUV4.js";
+  tasks,
+  userBox,
+  visionCapable
+} from "./chunk-TDSLCPQL.js";
 
 // src/cli.ts
 import { createInterface } from "readline/promises";
@@ -120,7 +123,7 @@ async function loginBrowser(opts) {
   const state = randomBytes(16).toString("hex");
   const device = hostname().slice(0, 60);
   const timeoutMs = (opts.timeoutSec ?? 240) * 1e3;
-  return new Promise((resolve) => {
+  return new Promise((resolve4) => {
     let settled = false;
     const finish = (token) => {
       if (settled) return;
@@ -130,20 +133,33 @@ async function loginBrowser(opts) {
         server.close();
       } catch {
       }
-      resolve(token);
+      resolve4(token);
     };
     const server = createServer((req, res) => {
       const url = new URL(req.url ?? "/", "http://127.0.0.1");
+      const corsHeaders = {
+        "access-control-allow-origin": "*",
+        "access-control-allow-methods": "GET, OPTIONS",
+        "access-control-allow-headers": "*",
+        "access-control-allow-private-network": "true"
+      };
+      if (req.method === "OPTIONS") {
+        res.writeHead(204, corsHeaders).end();
+        return;
+      }
       if (url.pathname !== "/callback") {
-        res.writeHead(404).end();
+        res.writeHead(404, corsHeaders).end();
         return;
       }
       if (url.searchParams.get("state") !== state) {
-        res.writeHead(400).end("state mismatch");
+        res.writeHead(400, corsHeaders).end("state mismatch");
         return;
       }
       const token = url.searchParams.get("token")?.trim();
-      res.writeHead(token ? 200 : 400, { "content-type": "text/html; charset=utf-8" });
+      res.writeHead(token ? 200 : 400, {
+        ...corsHeaders,
+        "content-type": "text/html; charset=utf-8"
+      });
       res.end(token ? SUCCESS_HTML : "missing token");
       if (token) {
         const path = saveKey("ZETA_API_KEY", token);
@@ -266,7 +282,624 @@ var CheckpointStore = class {
   }
 };
 
+// src/mentions.ts
+import { readFile as readFile2, stat, readdir } from "fs/promises";
+import { resolve, relative, join as join2, isAbsolute } from "path";
+import fg from "fast-glob";
+var IGNORE = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/.next/**",
+  "**/build/**",
+  "**/.turbo/**"
+];
+var CHARS_PER_TOKEN = 4;
+var DEFAULT_TOKEN_BUDGET = 25e3;
+var PER_FILE_TOKEN_CAP = 8e3;
+var MAX_FILES_PER_MENTION = 60;
+var MAX_TREE_ENTRIES = 200;
+function extractMentions(line2) {
+  const out = [];
+  const re = /(^|\s)@([~A-Za-z0-9._\-/*]+)/g;
+  for (let m = re.exec(line2); m; m = re.exec(line2)) {
+    let p = m[2];
+    p = p.replace(/[.,;:)]+$/g, (tail) => tail.length ? "" : tail);
+    if (p) out.push(p);
+  }
+  return [...new Set(out)];
+}
+function estTokens(s) {
+  return Math.ceil(s.length / CHARS_PER_TOKEN);
+}
+function looksBinary(buf) {
+  if (buf.includes("\0")) return true;
+  let ctrl = 0;
+  const n = Math.min(buf.length, 1e3);
+  for (let i = 0; i < n; i++) {
+    const code = buf.charCodeAt(i);
+    if (code < 9 || code > 13 && code < 32) ctrl++;
+  }
+  return ctrl / Math.max(1, n) > 0.3;
+}
+async function renderTree(absDir, relDir) {
+  const lines = [];
+  let count = 0;
+  async function walk(dir, prefix, depth) {
+    if (count >= MAX_TREE_ENTRIES || depth > 3) return;
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const filtered = entries.filter((e) => !["node_modules", ".git", "dist", ".next", "build", ".turbo"].includes(e.name)).sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name));
+    for (const e of filtered) {
+      if (count >= MAX_TREE_ENTRIES) {
+        lines.push(`${prefix}\u2026 (truncated)`);
+        return;
+      }
+      count++;
+      lines.push(`${prefix}${e.name}${e.isDirectory() ? "/" : ""}`);
+      if (e.isDirectory()) await walk(join2(dir, e.name), prefix + "  ", depth + 1);
+    }
+  }
+  await walk(absDir, "", 0);
+  return `${relDir || "."}/ (directory tree)
+${lines.join("\n")}`;
+}
+async function expandMentions(message, cwd2, tokenBudget = DEFAULT_TOKEN_BUDGET) {
+  const mentions = extractMentions(message);
+  if (mentions.length === 0) return { context: "", notice: null };
+  const blocks = [];
+  const attached = [];
+  const seen = /* @__PURE__ */ new Set();
+  let spent = 0;
+  for (const mention of mentions) {
+    if (spent >= tokenBudget) break;
+    const raw = mention.startsWith("~/") ? join2(process.env.HOME ?? "", mention.slice(2)) : mention;
+    const direct = isAbsolute(raw) ? raw : resolve(cwd2, raw);
+    let isDir = false;
+    try {
+      isDir = (await stat(direct)).isDirectory();
+    } catch {
+      isDir = false;
+    }
+    if (isDir) {
+      const rel = relative(cwd2, direct);
+      const tree = await renderTree(direct, rel);
+      const cost = estTokens(tree);
+      if (spent + cost <= tokenBudget) {
+        blocks.push(tree);
+        spent += cost;
+        attached.push(`${rel || "."}/ (tree)`);
+      }
+      continue;
+    }
+    let files = [];
+    try {
+      files = await fg(raw, {
+        cwd: cwd2,
+        ignore: IGNORE,
+        onlyFiles: true,
+        dot: true,
+        suppressErrors: true,
+        absolute: false
+      });
+    } catch {
+      files = [];
+    }
+    if (files.length === 0) {
+      try {
+        if ((await stat(direct)).isFile()) files = [relative(cwd2, direct)];
+      } catch {
+      }
+    }
+    files = files.sort().slice(0, MAX_FILES_PER_MENTION);
+    for (const rel of files) {
+      if (spent >= tokenBudget) break;
+      if (seen.has(rel)) continue;
+      seen.add(rel);
+      let buf;
+      try {
+        buf = await readFile2(resolve(cwd2, rel), "utf8");
+      } catch {
+        continue;
+      }
+      if (looksBinary(buf)) continue;
+      const cap = Math.min(PER_FILE_TOKEN_CAP, tokenBudget - spent);
+      let body = buf;
+      let truncated = false;
+      if (estTokens(body) > cap) {
+        body = body.slice(0, cap * CHARS_PER_TOKEN);
+        truncated = true;
+      }
+      const fence = body.includes("```") ? "````" : "```";
+      const header = truncated ? `${rel} (truncated to ~${cap} tokens of ${estTokens(buf)})` : rel;
+      blocks.push(`${header}
+${fence}
+${body}
+${fence}`);
+      spent += estTokens(body);
+      attached.push(truncated ? `${rel} (truncated)` : rel);
+    }
+  }
+  if (blocks.length === 0) return { context: "", notice: null };
+  const context = "The user attached these files with @-mentions. Use them as primary context for this turn:\n\n" + blocks.join("\n\n");
+  const notice = `attached ${attached.length} item(s): ${attached.slice(0, 8).join(", ")}${attached.length > 8 ? `, +${attached.length - 8} more` : ""} (~${spent} tokens)`;
+  return { context, notice };
+}
+
+// src/subagent.ts
+import { generateText, stepCountIs, tool } from "ai";
+import { z } from "zod";
+var READONLY_TOOLS = ["read_file", "glob", "grep", "list_dir"];
+function readonlyToolset(ctx) {
+  const all = buildTools(ctx);
+  const out = {};
+  for (const k of READONLY_TOOLS) if (all[k]) out[k] = all[k];
+  return out;
+}
+var SUBAGENT_SYSTEM = "You are a focused sub-agent spawned by a lead engineer. You have READ-ONLY tools (read_file, glob, grep, list_dir). Investigate ONLY the task you are given, then return a tight, factual answer: what you found, with file:line evidence where it applies. Do not pad, do not speculate beyond the evidence, do not attempt edits.";
+function buildSubagentTool(deps) {
+  const maxSteps = deps.maxSteps ?? 12;
+  const maxAgents = deps.maxAgents ?? 6;
+  const subtools = readonlyToolset(deps.ctx);
+  return {
+    spawn_agents: tool({
+      description: "Run several READ-ONLY sub-agents IN PARALLEL, each on its own focused task, and get their answers back together. Use for breadth \u2014 searching/reviewing/investigating multiple areas at once is far faster than doing them one by one yourself. Each sub-agent can read, glob, and grep but CANNOT edit. Returns one result per task.",
+      inputSchema: z.object({
+        tasks: z.array(
+          z.object({
+            label: z.string().describe("Short label for this slice, e.g. 'auth' or 'billing routes'."),
+            task: z.string().describe("The self-contained instruction for this sub-agent.")
+          })
+        ).min(1).max(maxAgents).describe(`1\u2013${maxAgents} independent tasks to run concurrently.`)
+      }),
+      execute: async ({ tasks: tasks2 }) => {
+        line(c.dim(`    \u21C9 spawning ${tasks2.length} sub-agent(s) in parallel`));
+        const results = await Promise.all(
+          tasks2.map(async ({ label, task }) => {
+            try {
+              const r = await generateText({
+                model: deps.model,
+                system: SUBAGENT_SYSTEM,
+                prompt: task,
+                tools: subtools,
+                stopWhen: stepCountIs(maxSteps)
+              });
+              line(c.dim(`    \u21B3 ${c.cyan(label)} done`));
+              return { label, ok: true, result: r.text.trim() };
+            } catch (e) {
+              line(c.dim(`    \u21B3 ${c.cyan(label)} ${c.red("failed")}`));
+              return { label, ok: false, error: e.message };
+            }
+          })
+        );
+        return { ok: true, count: results.length, results };
+      }
+    })
+  };
+}
+
+// src/images.ts
+import { readFile as readFile3, stat as stat2 } from "fs/promises";
+import { resolve as resolve2, extname, relative as relative2, isAbsolute as isAbsolute2, join as join3 } from "path";
+import { execFile } from "child_process";
+import { tmpdir, platform as platform2 } from "os";
+var EXT_TO_MEDIA = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+var PER_IMAGE_BYTES = 6 * 1024 * 1024;
+var TOTAL_BYTES = 15 * 1024 * 1024;
+function wantsClipboard(message) {
+  return /(^|\s)@(clip|clipboard|paste)\b/i.test(message);
+}
+function run(cmd, args) {
+  return new Promise((res) => {
+    execFile(cmd, args, (err) => res(!err));
+  });
+}
+async function grabClipboardImage() {
+  const out = join3(tmpdir(), `zeta-clip-${process.pid}-${process.hrtime.bigint()}.png`);
+  const os = platform2();
+  if (os === "darwin") {
+    const script = `set thePath to "${out}"
+try
+  set pngData to (the clipboard as \xABclass PNGf\xBB)
+on error
+  return "NOIMAGE"
+end try
+set fp to open for access (POSIX file thePath) with write permission
+write pngData to fp
+close access fp
+return "OK"`;
+    const ok = await run("osascript", ["-e", script]);
+    if (!ok) return null;
+  } else if (os === "linux") {
+    const ok = await run("bash", ["-c", `xclip -selection clipboard -t image/png -o > "${out}"`]);
+    if (!ok) return null;
+  } else {
+    return null;
+  }
+  try {
+    const st = await stat2(out);
+    return st.isFile() && st.size > 0 ? out : null;
+  } catch {
+    return null;
+  }
+}
+function imageTokens(message) {
+  const out = /* @__PURE__ */ new Set();
+  const re = /@?([~A-Za-z0-9._\-/]+\.(?:png|jpe?g|gif|webp))\b/gi;
+  for (let m = re.exec(message); m; m = re.exec(message)) out.add(m[1]);
+  return [...out];
+}
+async function scanImages(message, cwd2) {
+  const tokens = imageTokens(message);
+  const images = [];
+  const skipped = [];
+  let total = 0;
+  if (wantsClipboard(message)) {
+    const clip = await grabClipboardImage();
+    if (clip) {
+      try {
+        const buf = await readFile3(clip);
+        if (buf.length <= PER_IMAGE_BYTES) {
+          images.push({
+            path: "clipboard",
+            dataUrl: `data:image/png;base64,${buf.toString("base64")}`,
+            mediaType: "image/png",
+            bytes: buf.length
+          });
+          total += buf.length;
+        } else {
+          skipped.push("clipboard (over the size cap)");
+        }
+      } catch {
+        skipped.push("clipboard (unreadable)");
+      }
+    } else {
+      skipped.push("clipboard (no image found)");
+    }
+  }
+  for (const tok of tokens) {
+    const raw = tok.startsWith("~/") ? join3(process.env.HOME ?? "", tok.slice(2)) : tok;
+    const abs = isAbsolute2(raw) ? raw : resolve2(cwd2, raw);
+    const mediaType = EXT_TO_MEDIA[extname(abs).toLowerCase()];
+    if (!mediaType) continue;
+    let bytes;
+    try {
+      const st = await stat2(abs);
+      if (!st.isFile()) continue;
+      bytes = st.size;
+    } catch {
+      continue;
+    }
+    const label = isAbsolute2(raw) ? raw : relative2(cwd2, abs);
+    if (bytes > PER_IMAGE_BYTES || total + bytes > TOTAL_BYTES) {
+      skipped.push(`${label} (${Math.round(bytes / 1024)}KB \u2014 over the size cap)`);
+      continue;
+    }
+    try {
+      const buf = await readFile3(abs);
+      const dataUrl = `data:${mediaType};base64,${buf.toString("base64")}`;
+      images.push({ path: label, dataUrl, mediaType, bytes });
+      total += bytes;
+    } catch {
+      skipped.push(`${label} (unreadable)`);
+    }
+  }
+  return { images, skipped };
+}
+
+// src/weburl.ts
+var CHARS_PER_TOKEN2 = 4;
+var DEFAULT_TOKEN_BUDGET2 = 12e3;
+var PER_URL_TOKEN_CAP = 6e3;
+var FETCH_TIMEOUT_MS = 12e3;
+var MAX_BYTES = 4 * 1024 * 1024;
+function estTokens2(s) {
+  return Math.ceil(s.length / CHARS_PER_TOKEN2);
+}
+function extractUrls(message) {
+  const out = /* @__PURE__ */ new Set();
+  const re = /@?(https?:\/\/[^\s<>")]+)/gi;
+  for (let m = re.exec(message); m; m = re.exec(message)) {
+    out.add(m[1].replace(/[.,;:)\]]+$/, ""));
+  }
+  return [...out];
+}
+function htmlToText(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<!--[\s\S]*?-->/g, " ").replace(/<\/(p|div|li|h[1-6]|tr|br|section|article)>/gi, "\n").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+async function fetchReadable(url) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      signal: ctrl.signal,
+      redirect: "follow",
+      headers: { "user-agent": "zeta-g-cli/0.4 (+web-context)" }
+    });
+    if (!res.ok) return null;
+    const ctype = res.headers.get("content-type") ?? "";
+    const raw = await res.text();
+    const body = raw.length > MAX_BYTES ? raw.slice(0, MAX_BYTES) : raw;
+    const text = /html/i.test(ctype) ? htmlToText(body) : body.trim();
+    return { text, finalUrl: res.url || url };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function expandUrls(message, tokenBudget = DEFAULT_TOKEN_BUDGET2) {
+  const urls = extractUrls(message);
+  if (urls.length === 0) return { context: "", notice: null };
+  const blocks = [];
+  const fetched = [];
+  const failed = [];
+  let spent = 0;
+  for (const url of urls) {
+    if (spent >= tokenBudget) break;
+    const r = await fetchReadable(url);
+    if (!r || !r.text) {
+      failed.push(url);
+      continue;
+    }
+    const cap = Math.min(PER_URL_TOKEN_CAP, tokenBudget - spent);
+    let body = r.text;
+    let truncated = false;
+    if (estTokens2(body) > cap) {
+      body = body.slice(0, cap * CHARS_PER_TOKEN2);
+      truncated = true;
+    }
+    const header = truncated ? `${r.finalUrl} (truncated to ~${cap} tokens)` : r.finalUrl;
+    blocks.push(`${header}
+${body}`);
+    spent += estTokens2(body);
+    fetched.push(r.finalUrl);
+  }
+  if (blocks.length === 0) {
+    return { context: "", notice: failed.length ? `couldn't fetch: ${failed.join(", ")}` : null };
+  }
+  const context = "The user linked these pages. Use them as context for this turn:\n\n" + blocks.join("\n\n---\n\n");
+  const noticeParts = [`fetched ${fetched.length} URL(s) (~${spent} tokens)`];
+  if (failed.length) noticeParts.push(`failed: ${failed.length}`);
+  return { context, notice: noticeParts.join(" \xB7 ") };
+}
+
+// src/export.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+function renderContent(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const p of content) {
+    const type = p.type;
+    if (type === "text" && typeof p.text === "string") parts.push(p.text.trim());
+    else if (type === "image") parts.push("_[image]_");
+    else if (type === "tool-call") parts.push(`\`\u2192 ${String(p.toolName ?? "tool")}\``);
+    else if (type === "tool-result") parts.push(`\`\u2713 ${String(p.toolName ?? "tool")}\``);
+  }
+  return parts.filter(Boolean).join("\n\n");
+}
+function renderTranscript(messages, meta) {
+  const head = [
+    `# zeta-g transcript`,
+    ``,
+    `- model: ${meta.model}`,
+    meta.startedAt ? `- started: ${meta.startedAt}` : "",
+    `- messages: ${messages.length}`,
+    ``,
+    `---`,
+    ``
+  ].filter((l) => l !== "").join("\n");
+  const body = messages.map((m) => {
+    const text = renderContent(m.content);
+    if (!text) return "";
+    const who = m.role === "user" ? "\u{1F9D1} User" : m.role === "assistant" ? "\u{1F916} Zeta-G" : m.role === "tool" ? "\u{1F527} Tool" : m.role;
+    return `### ${who}
+
+${text}`;
+  }).filter(Boolean).join("\n\n");
+  return `${head}
+
+${body}
+`;
+}
+function writeTranscript(messages, meta, file, cwd2) {
+  const abs = resolve3(cwd2, file);
+  writeFileSync2(abs, renderTranscript(messages, meta), "utf8");
+  return abs;
+}
+
 // src/cli.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join6 } from "path";
+
+// src/update-check.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+var PKG = "wholestack";
+var CACHE = join4(homedir2(), ".zeta-g", "update-check.json");
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function readCache() {
+  try {
+    return JSON.parse(readFileSync2(CACHE, "utf8"));
+  } catch {
+    return { lastCheck: 0, latest: null };
+  }
+}
+function writeCache(c2) {
+  try {
+    mkdirSync2(join4(homedir2(), ".zeta-g"), { recursive: true });
+    writeFileSync3(CACHE, JSON.stringify(c2));
+  } catch {
+  }
+}
+function isNewer(a, b) {
+  const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const x = pa[i] ?? 0;
+    const y = pb[i] ?? 0;
+    if (x !== y) return x > y;
+  }
+  return false;
+}
+async function checkForUpdate(current) {
+  if (process.env.ZETA_NO_UPDATE_CHECK || !existsSync2) return null;
+  const cache = readCache();
+  const fresh = Date.now() - cache.lastCheck < DAY_MS;
+  let latest = cache.latest;
+  if (!fresh) {
+    try {
+      const ctrl = new AbortController();
+      const t = setTimeout(() => ctrl.abort(), 1200);
+      const res = await fetch(`https://registry.npmjs.org/${PKG}/latest`, {
+        signal: ctrl.signal,
+        headers: { accept: "application/json" }
+      });
+      clearTimeout(t);
+      if (res.ok) {
+        const json = await res.json();
+        latest = json.version ?? null;
+      }
+    } catch {
+      latest = cache.latest;
+    }
+    writeCache({ lastCheck: Date.now(), latest });
+  }
+  return latest && isNewer(latest, current) ? latest : null;
+}
+
+// src/access.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
+var CACHE2 = join5(homedir3(), ".zeta-g", "access.json");
+var TTL_MS = 60 * 60 * 1e3;
+function readCache2() {
+  try {
+    return JSON.parse(readFileSync3(CACHE2, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeCache2(c2) {
+  try {
+    mkdirSync3(join5(homedir3(), ".zeta-g"), { recursive: true });
+    writeFileSync4(CACHE2, JSON.stringify(c2));
+  } catch {
+  }
+}
+function clearAccessCache() {
+  try {
+    rmSync(CACHE2, { force: true });
+  } catch {
+  }
+}
+async function verifyAccess(webUrl, token, force = false) {
+  if (!token) return { active: false, tier: null, degraded: false };
+  const cached = force ? null : readCache2();
+  if (cached && Date.now() - cached.checkedAt < TTL_MS) {
+    return { active: cached.active, tier: cached.tier, degraded: false };
+  }
+  try {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 2500);
+    const res = await fetch(`${webUrl.replace(/\/$/, "")}/api/cli/verify`, {
+      headers: { authorization: `Bearer ${token}` },
+      signal: ctrl.signal
+    });
+    clearTimeout(t);
+    if (res.status >= 500) {
+      return { active: true, tier: cached?.tier ?? null, degraded: true };
+    }
+    if (!res.ok) {
+      writeCache2({ checkedAt: Date.now(), active: false, tier: null });
+      return { active: false, tier: null, degraded: false };
+    }
+    const json = await res.json();
+    const active = Boolean(json.active);
+    writeCache2({ checkedAt: Date.now(), active, tier: json.tier ?? null });
+    return { active, tier: json.tier ?? null, degraded: false };
+  } catch {
+    return { active: true, tier: cached?.tier ?? null, degraded: true };
+  }
+}
+function showPaywall(loggedIn, webUrl) {
+  const w = 52;
+  line();
+  line("  " + c.cyan("\u256D" + "\u2500".repeat(w) + "\u256E"));
+  const row = (s) => line("  " + c.cyan("\u2502") + " " + s.padEnd(w - 2) + " " + c.cyan("\u2502"));
+  row(c.bold("zeta needs a subscription"));
+  row("");
+  if (!loggedIn) {
+    row(c.dim("You're not signed in."));
+    row("Run  " + c.cyan("zeta login") + c.dim("  then subscribe."));
+  } else {
+    row(c.dim("No active paid plan on this account."));
+    row("Subscribe to use zeta in the terminal.");
+  }
+  row("");
+  row(c.dim("Plans: ") + c.cyan(`${webUrl.replace(/\/$/, "")}/pricing`));
+  line("  " + c.cyan("\u2570" + "\u2500".repeat(w) + "\u256F"));
+  line();
+}
+
+// src/art.ts
+var ART_PACK = [
+  ["  \u2588\u2588\u2588\u2588\u2588\u2588\u2588", "      \u2588\u2588\u2554\u255D", "    \u2588\u2588\u2554\u255D  ", "  \u2588\u2588\u2554\u255D    ", "  \u2588\u2588\u2588\u2588\u2588\u2588\u2588 "],
+  ["  \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E", "  \u2502  \u2571\u2571   \u2502", "  \u2502 \u2571\u2571    \u2502", "  \u2502\u2571\u2571     \u2502", "  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F"],
+  ["   \u259F\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2599", "      \u259F\u2588\u259B   ", "    \u259F\u2588\u259B     ", "  \u259F\u2588\u259B       ", "  \u259C\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u259B "],
+  ["  \u250C\u2500\u2510\u250C\u2500\u2510\u250C\u252C\u2510\u250C\u2500\u2510", "  \u250C\u2500\u2518\u251C\u2524  \u2502 \u251C\u2500\u2524", "  \u2514\u2500\u2518\u2514\u2500\u2518 \u2534 \u2534 \u2534"],
+  ["   \u2571\u2572    ", "  \u2571\u2500\u2500\u2572   ", " \u2571 \u2571\u2571 \u2572  ", "\u2571 \u2571\u2571   \u2572 ", "\u2572\u2571\u2571\u2500\u2500\u2500\u2500\u2500\u2572"]
+];
+function randomArt(seed) {
+  const i = seed != null ? seed % ART_PACK.length : Math.floor(Math.random() * ART_PACK.length);
+  return ART_PACK[(i % ART_PACK.length + ART_PACK.length) % ART_PACK.length];
+}
+var vlen = (s) => s.replace(/\x1b\[[0-9;]*m/g, "").length;
+function fetchPanel(fields, art = randomArt()) {
+  const shown = fields.filter((f) => f.value);
+  const labelW = Math.max(0, ...shown.map((f) => f.label.length));
+  const artW = Math.max(0, ...art.map(vlen));
+  const rows = Math.max(art.length, shown.length);
+  const out = [];
+  out.push("");
+  for (let i = 0; i < rows; i++) {
+    const left = (art[i] ?? "").padEnd(artW + 2);
+    const f = shown[i];
+    const right = f ? c.dim(f.label.padStart(labelW) + "  ") + c.bold(f.value) : "";
+    out.push("  " + c.cyan(left) + right);
+  }
+  out.push("");
+  for (const l of out) process.stdout.write(l + "\n");
+}
+
+// src/cli.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { basename } from "path";
+var VERSION = "0.5.0";
+function gitBranch(dir) {
+  try {
+    const head = readFileSync4(join6(dir, ".git", "HEAD"), "utf8").trim();
+    const m = head.match(/ref:\s*refs\/heads\/(.+)$/);
+    return m ? m[1] : head.slice(0, 7);
+  } catch {
+    return "";
+  }
+}
 function parse(raw) {
   const a = {
     zetaUrl: process.env.ZETA_API_URL ?? "https://wholestack.ai",
@@ -294,6 +927,8 @@ function parse(raw) {
       const m = raw[++i];
       if (isPermissionMode(m)) a.mode = m;
     } else if (t === "--plan") a.plan = true;
+    else if (t === "--persona") a.persona = raw[++i];
+    else if (t === "--nzt48" || t === "--nzt-48") a.persona = "nzt-48";
     else if (t === "--think") a.think = true;
     else if (t === "--no-think") a.think = false;
     else if (t === "--mcp") a.mcp = (raw[++i] ?? "").split(",").map((s) => s.trim()).filter(Boolean);
@@ -324,12 +959,15 @@ ${c.bold("Web3 security")} ${c.dim("(forge \xB7 slither \xB7 firewall \xB7 halmo
   zeta-g prove  <dir> <Contract> --property <k>  prove one invariant
   zeta-g verify <dir> <Contract> --cert c.json   passthrough + signed certificate
   ${c.dim("kinds: reentrancy-safety, access-control, conservation, no-value-extraction, \u2026")}
+  zeta-g --nzt48 "audit ./contracts"            NZT-48 web3 special-ops persona
 
 ${c.bold("Session")}
-  -m, --model <key>   zeta-g1-lite | zeta-g1 | zeta-g1-max
-                      (lite = light \xB7 g1 = default \xB7 max = most capable)
+  -m, --model <key>   zeta-g1-lite | zeta-g1 | zeta-g1-max | vision
+                      (lite = light \xB7 g1 = default \xB7 max = most capable \xB7 vision = sees images)
       --mode <m>      default | acceptEdits | plan | yolo (permission mode)
       --plan          start in read-only plan mode
+      --nzt48         run as NZT-48, the web3 special-ops persona
+      --persona <id>  layer a named persona on the base agent
       --think/--no-think  toggle extended thinking (when a tier supports it)
       --continue      resume the most recent session
       --resume [id]   resume a session (id, or the latest)
@@ -352,7 +990,14 @@ ${c.bold("Auth")} ${c.dim("(set once, then just run zeta-g)")}
   zeta-g login --build <key>       ZETA build-engine key (for /build)
 
 ${c.bold("In a session")} ${c.dim("(type /help for the full list)")}
-  /model /cost /tools /undo /redo /checkpoints /compact /resume /memory /mcp /mode /think /init /doctor /clear /exit`;
+  /model /cost /tools /undo /redo /checkpoints /compact /resume /memory /mcp /mode /think /init /doctor /clear /exit
+  /diff /commit /pr   ${c.dim("git flow \u2014 review, commit (auto-written msg), open a PR")}
+  /tasks              ${c.dim("background jobs \u2014 run_background runs builds/tests while you work")}
+  /export [file.md]   ${c.dim("write the conversation transcript to markdown")}
+  ${c.dim("@path \xB7 @dir/ \xB7 @glob  attach files to the turn (token-budgeted, Tab-completes)")}
+  ${c.dim("@shot.png \xB7 @clip  attach an image / paste from clipboard (auto-switches to Vision)")}
+  ${c.dim("@https://\u2026  fetch a web page and attach its text to the turn")}
+  ${c.dim("spawn_agents tool  fan a task out to parallel read-only sub-agents")}`;
 async function runSecuritySubcommand(raw) {
   const verb = raw[0];
   if (verb !== "audit" && verb !== "prove" && verb !== "verify") return null;
@@ -375,6 +1020,19 @@ async function runSecuritySubcommand(raw) {
   line(r.ok ? c.green("  \u2713 verified") : c.red("  \u2717 NOT verified"));
   return r.code;
 }
+function maybeYoloNotice() {
+  try {
+    const dir = join6(homedir4(), ".zeta-g");
+    const marker = join6(dir, "yolo-notice-seen");
+    if (existsSync3(marker)) return;
+    line(
+      "  " + c.yellow("\u26A1 yolo mode") + c.dim(" \u2014 actions run without confirmation. ") + c.cyan("/mode default") + c.dim(" to require approvals \xB7 /undo reverts.") + "\n"
+    );
+    mkdirSync4(dir, { recursive: true });
+    writeFileSync5(marker, (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
 function webBaseUrl() {
   return process.env.ZETA_WEB_URL?.trim() || process.env.ZETA_API_URL?.trim() || "https://wholestack.ai";
 }
@@ -382,6 +1040,7 @@ async function runLogin(raw) {
   if (raw[0] !== "login" && raw[0] !== "logout") return null;
   const rest = raw.slice(1);
   if (raw[0] === "logout") {
+    clearAccessCache();
     saveKey("ZETA_API_KEY", "");
     line(c.green("  \u2713 logged out") + c.dim("  (token cleared)"));
     return 0;
@@ -393,7 +1052,9 @@ async function runLogin(raw) {
       line(c.red("  usage: zeta login --token <vbfl_\u2026>"));
       return 1;
     }
-    return loginWithToken(tok) ? 0 : 1;
+    const ok = loginWithToken(tok);
+    if (ok) clearAccessCache();
+    return ok ? 0 : 1;
   }
   const pick = (flag) => {
     const i = rest.indexOf(flag);
@@ -408,6 +1069,7 @@ async function runLogin(raw) {
   if (!hit(memberFlags) && !hit(brainFlags) && !hit(buildFlags)) {
     const noBrowser = rest.includes("--no-browser");
     const token = await loginBrowser({ webBase: webBaseUrl(), noBrowser });
+    if (token) clearAccessCache();
     return token ? 0 : 1;
   }
   if (hit(memberFlags)) {
@@ -439,6 +1101,7 @@ async function runLogin(raw) {
   }
   const what = name === "ZETA_API_KEY" ? "membership (keep + deploy your apps)" : name === "OPENROUTER_API_KEY" ? "brain (Zeta-G1.0 tiers)" : "ZETA build engine";
   const path = saveKey(name, value);
+  if (name === "ZETA_API_KEY") clearAccessCache();
   line(c.green(`  \u2713 saved key for the ${what}`) + c.dim(`  \u2192 ${path} (chmod 600)`));
   line(c.dim("  now just run `zeta-g`."));
   return 0;
@@ -473,13 +1136,36 @@ async function main() {
   if (sub !== null) exit(sub);
   const args = parse(rawArgs);
   if (args.version) {
-    line("wholestack 0.4.0");
+    line(`wholestack ${VERSION}`);
     return;
   }
   if (args.help) {
     line(HELP);
     return;
   }
+  {
+    let token = process.env.ZETA_API_KEY;
+    let access = await verifyAccess(webBaseUrl(), token);
+    if (!access.active && stdin.isTTY) {
+      const rl = createInterface({ input: stdin, output: stdout });
+      const ans = (await rl.question(
+        "\n  " + (token ? c.dim("No active plan on this account. ") + "Log in to a different account? " : "Log in now? ") + c.dim("[Y/n] ")
+      )).trim().toLowerCase();
+      rl.close();
+      if (ans === "" || ans === "y" || ans === "yes") {
+        const minted = await loginBrowser({ webBase: webBaseUrl(), noBrowser: false });
+        if (minted) {
+          token = minted;
+          process.env.ZETA_API_KEY = minted;
+          access = await verifyAccess(webBaseUrl(), token, true);
+        }
+      }
+    }
+    if (!access.active) {
+      showPaywall(Boolean(token), webBaseUrl());
+      exit(1);
+    }
+  }
   let modelKey;
   try {
     modelKey = resolveModelKey(args.model);
@@ -497,7 +1183,11 @@ async function main() {
   const isTty = !!stdin.isTTY;
   const oneShot = args.prompt.length > 0;
   const workdir = cwd();
-  const mode = args.plan ? "plan" : args.mode ? args.mode : args.yes ? "yolo" : isTty ? "default" : "acceptEdits";
+  const persistedMode = isPermissionMode(
+    process.env.ZETA_PERMISSION_MODE
+  ) ? process.env.ZETA_PERMISSION_MODE : void 0;
+  const yoloIsDefault = !args.plan && !args.mode && !args.yes && !persistedMode && isTty;
+  const mode = args.plan ? "plan" : args.mode ? args.mode : args.yes ? "yolo" : persistedMode ?? (isTty ? "yolo" : "acceptEdits");
   const memory = await loadProjectMemory(workdir);
   const plugins = args.noPlugins ? EMPTY_PLUGINS : loadPlugins(workdir);
   const memoryText = [memory.text, plugins.systemText].filter(Boolean).join("\n\n") || void 0;
@@ -507,7 +1197,6 @@ async function main() {
     disabled: args.noMcp,
     extraServers: plugins.mcpServers
   });
-  const extraTools = { ...buildWebTools(), ...mcp.tools };
   const hooks = new HookRunner(mergeHookSets(loadHookFiles(workdir), plugins.hooks), workdir);
   const registry = new CommandRegistry();
   registry.loadCustom(workdir);
@@ -518,6 +1207,7 @@ async function main() {
     if (shuttingDown) return;
     shuttingDown = true;
     killRunningApps();
+    tasks.killAll();
     await mcp.close().catch(() => {
     });
     ic?.close();
@@ -529,12 +1219,33 @@ async function main() {
       onExit: () => {
         line(c.dim("  bye."));
         void shutdown(0);
+      },
+      // Starship-style context segments above the prompt box.
+      contextBar: () => {
+        const seg = [c.cyan(modelLabel(modelKey)), c.dim(basename(workdir))];
+        const br = gitBranch(workdir);
+        if (br) seg.push(c.dim("\u2387 " + br));
+        seg.push(mode === "yolo" ? c.yellow(mode) : c.dim(mode));
+        return seg.join(c.dim("  \xB7  "));
       }
     });
   }
   const confirm = isTty && ic ? ic.confirm.bind(ic) : void 0;
-  const permissions = new Permissions(mode, confirm);
+  const persistMode = (m) => {
+    try {
+      saveKey("ZETA_PERMISSION_MODE", m);
+    } catch {
+    }
+  };
+  const permissions = new Permissions(mode, confirm, persistMode);
   const checkpoints = new CheckpointStore();
+  const toolCtx = { cwd: workdir, zetaApiUrl: args.zetaUrl, buildMode: args.buildMode, permissions, checkpoints };
+  const extraTools = {
+    ...buildWebTools(),
+    ...mcp.tools,
+    // Parallel read-only sub-agents (needs the model handle the base tools lack).
+    ...buildSubagentTool({ model, modelKey, ctx: toolCtx })
+  };
   let session;
   let resumedMessages = null;
   if (args.resume !== void 0 || args.cont) {
@@ -554,19 +1265,27 @@ async function main() {
   const agent = new Agent({
     model,
     modelKey,
-    ctx: { cwd: workdir, zetaApiUrl: args.zetaUrl, buildMode: args.buildMode, permissions, checkpoints },
+    ctx: toolCtx,
     extraTools,
     hooks,
     memoryText,
+    persona: args.persona,
     thinking,
+    yolo: mode === "yolo",
     maxSteps: 16,
     contextWindow: modelContextWindow(modelKey),
     session
   });
   if (resumedMessages) agent.replaceHistory(resumedMessages);
   if (oneShot) {
-    if (ic) await ic.runInterruptible((sig) => agent.send(args.prompt, sig));
-    else await agent.send(args.prompt);
+    const m = await expandMentions(args.prompt, workdir);
+    if (m.notice) line(c.dim(`  @ ${m.notice}`) + "\n");
+    const oneShotText = m.context ? `${args.prompt}
+
+---
+${m.context}` : args.prompt;
+    if (ic) await ic.runInterruptible((sig) => agent.send(oneShotText, sig));
+    else await agent.send(oneShotText);
     await shutdown(0);
     return;
   }
@@ -575,10 +1294,28 @@ async function main() {
     await shutdown(1);
     return;
   }
-  banner();
+  await banner();
+  fetchPanel([
+    { label: "model", value: modelLabel(modelKey) },
+    { label: "mode", value: mode },
+    { label: "dir", value: basename(workdir) },
+    { label: "git", value: gitBranch(workdir) },
+    { label: "node", value: process.version },
+    { label: "memory", value: memory.sources.length ? `${memory.sources.length} file(s)` : "" },
+    { label: "mcp", value: mcp.mounted.length ? `${mcp.mounted.length} mounted` : "" },
+    { label: "zeta", value: VERSION }
+  ]);
   bootSummary(memory, plugins, mcp, mode, thinking);
   if (mode === "plan") announcePlanMode();
+  else if (yoloIsDefault) maybeYoloNotice();
   if (resumedMessages) line("  " + c.dim(`resumed ${session.meta.id} \xB7 ${resumedMessages.length} messages`) + "\n");
+  void checkForUpdate(VERSION).then((latest) => {
+    if (latest) {
+      line(
+        "  " + c.yellow(`\u2191 wholestack ${latest} available`) + c.dim(` (you have ${VERSION}) \xB7 `) + c.cyan("npm i -g wholestack") + "\n"
+      );
+    }
+  });
   const baseCtx = () => ({
     cwd: workdir,
     modelKey,
@@ -593,9 +1330,9 @@ async function main() {
     checkpoints,
     print: (s = "") => line(s)
   });
-  const runTurn = async (text) => {
+  const runTurn = async (text, images) => {
     const t0 = Date.now();
-    await ic.runInterruptible((sig) => agent.send(text, sig));
+    await ic.runInterruptible((sig) => agent.send(text, sig, images));
     statusLine({
       model: modelLabel(modelKey),
       tokens: agent.usage.totalTokens,
@@ -607,6 +1344,11 @@ async function main() {
     });
   };
   for (; ; ) {
+    for (const done of tasks.drainCompleted()) {
+      const mark = done.status === "exited" ? c.green("\u2713") : c.red("\u2717");
+      const code = done.exitCode == null ? "" : ` (exit ${done.exitCode})`;
+      line(`  ${mark} ${c.dim("background")} ${c.cyan(done.id)} ${done.display}${c.dim(code)}`);
+    }
     const input = await ic.readLine(c.cyan("  \u203A "));
     if (!input) continue;
     if (input.startsWith("/")) {
@@ -636,7 +1378,12 @@ async function main() {
         }
       } else if (res.type === "setMode") {
         permissions.setMode(res.mode);
-        line("  " + c.dim(`mode: ${res.mode}`) + "\n");
+        if (res.mode !== "plan") {
+          persistMode(res.mode);
+          line("  " + c.dim(`mode: ${res.mode}  \xB7 remembered for next session`) + "\n");
+        } else {
+          line("  " + c.dim(`mode: ${res.mode}`) + "\n");
+        }
         if (res.mode === "plan") announcePlanMode();
       } else if (res.type === "toggleThinking") {
         if (supportsThinking(modelKey)) {
@@ -655,13 +1402,54 @@ async function main() {
         } else {
           line("  " + c.red(`no session ${res.sessionId}`) + "\n");
         }
+      } else if (res.type === "export") {
+        const file = res.file ?? `zeta-transcript-${gitBranch(workdir) || "session"}.md`;
+        try {
+          const abs = writeTranscript(agent.snapshot(), { model: modelLabel(modelKey) }, file, workdir);
+          line("  " + c.green(`\u2713 transcript \u2192 ${abs}`) + "\n");
+        } catch (e) {
+          line("  " + c.red(e.message) + "\n");
+        }
       }
       continue;
     }
-    userBox(input);
-    await runTurn(input);
+    if (!process.stdin.isTTY || process.env.NO_COLOR) userBox(input);
+    const mentioned = await expandMentions(input, workdir);
+    if (mentioned.notice) line(c.dim(`  @ ${mentioned.notice}`) + "\n");
+    const web = await expandUrls(input);
+    if (web.notice) line(c.dim(`  \u2301 ${web.notice}`) + "\n");
+    const extraContext = [mentioned.context, web.context].filter(Boolean).join("\n\n---\n\n");
+    const imgs = await scanImages(input, workdir);
+    let attachments;
+    if (imgs.images.length > 0) {
+      if (!visionCapable(modelKey) && process.env.OPENROUTER_API_KEY) {
+        try {
+          const vkey = resolveModelKey("vision");
+          modelKey = vkey;
+          agent.setModel(resolveModel(vkey), vkey, modelContextWindow(vkey));
+          agent.setThinking(false);
+          line(c.dim(`  \u29C9 image attached \u2192 switched to ${modelLabel(vkey)} (/model zeta-g1 to switch back)`) + "\n");
+        } catch (e) {
+          line(c.red(`  \u29C9 couldn't switch to the vision lane: ${e.message}`) + "\n");
+        }
+      }
+      if (visionCapable(modelKey)) {
+        attachments = imgs.images.map((i) => ({ dataUrl: i.dataUrl }));
+        line(c.dim(`  \u29C9 attached ${imgs.images.length} image(s): ${imgs.images.map((i) => i.path).join(", ")}`) + "\n");
+      } else {
+        line(
+          c.yellow(`  \u29C9 ${imgs.images.length} image(s) ignored \u2014 ${modelLabel(modelKey)} is text-only.`) + c.dim(" set OPENROUTER_API_KEY (or /model vision) to enable Zeta-G1.0 Vision") + "\n"
+        );
+      }
+    }
+    if (imgs.skipped.length) line(c.dim(`  \u29C9 skipped: ${imgs.skipped.join(", ")}`) + "\n");
+    await runTurn(extraContext ? `${input}
+
+---
+${extraContext}` : input, attachments);
   }
   killRunningApps();
+  tasks.killAll();
   await mcp.close().catch(() => {
   });
   ic.close();