wholestack 0.5.6 → 0.5.7

package/dist/cli.js

@@ -7,17 +7,35 @@ import {
   PROPERTY_KINDS,
   Permissions,
   Session,
+  SkillRegistry,
   announcePlanMode,
+  apiJson,
   banner,
+  buildEscalateTool,
+  buildEyesTool,
+  buildOpsTools,
+  buildSkillTools,
   buildTools,
+  buildVerifyTools,
   buildWebTools,
   c,
   collectLocalFiles,
+  deployBuild,
+  drawCanvas,
+  escalationBus,
+  fetchGithubInstallations,
+  fetchGithubRepos,
+  generateLegal,
+  getBusiness,
+  getLaunchKit,
+  inspectUrl,
   isPermissionMode,
   killRunningApps,
   line,
+  listBusinesses,
   listProjects,
   loadHookFiles,
+  loadLearnedMemory,
   loadMcpTools,
   loadPlugins,
   loadProjectMemory,
@@ -26,26 +44,42 @@ import {
   modelContextWindow,
   modelLabel,
   openBuildInEditor,
+  pickBootModel,
+  pickGithubRepoInteractive,
+  promoteBuild,
+  proveLocalRepo,
   pullWorkingTree,
   pushWorkingTree,
+  readMetrics,
   readProjectLink,
+  readSourceFile,
+  rememberLesson,
+  renderGtmPlanLines,
+  renderLaunchKitLines,
+  renderMetricsLines,
   resolveModel,
   resolveModelKey,
+  rollbackDeployment,
   runProver,
+  runRepoAuditStream,
   saveKey,
+  searchLessons,
   stateDir,
   statusLine,
   supportsThinking,
   tasks,
+  toolLine,
   userBox,
   visionCapable,
+  waitlistCount,
+  webBaseUrl,
   writeProjectLink,
   writeWorkingTree
-} from "./chunk-K6MSDQJT.js";
+} from "./chunk-TLYCOIEA.js";
 
 // src/cli.ts
 import { createInterface } from "readline/promises";
-import { stdin, stdout, argv, exit, cwd } from "process";
+import { stdin, stdout as stdout3, argv, exit, cwd as cwd2 } from "process";
 
 // src/cli-login.ts
 import { createServer } from "http";
@@ -298,7 +332,7 @@ async function renderTree(absDir, relDir) {
   return `${relDir || "."}/ (directory tree)
 ${lines.join("\n")}`;
 }
-async function expandMentions(message, cwd2, tokenBudget = DEFAULT_TOKEN_BUDGET) {
+async function expandMentions(message, cwd3, tokenBudget = DEFAULT_TOKEN_BUDGET) {
   const mentions = extractMentions(message);
   if (mentions.length === 0) return { context: "", notice: null };
   const blocks = [];
@@ -308,7 +342,7 @@ async function expandMentions(message, cwd2, tokenBudget = DEFAULT_TOKEN_BUDGET)
   for (const mention of mentions) {
     if (spent >= tokenBudget) break;
     const raw = mention.startsWith("~/") ? join(process.env.HOME ?? "", mention.slice(2)) : mention;
-    const direct = isAbsolute(raw) ? raw : resolve(cwd2, raw);
+    const direct = isAbsolute(raw) ? raw : resolve(cwd3, raw);
     let isDir = false;
     try {
       isDir = (await stat(direct)).isDirectory();
@@ -316,7 +350,7 @@ async function expandMentions(message, cwd2, tokenBudget = DEFAULT_TOKEN_BUDGET)
       isDir = false;
     }
     if (isDir) {
-      const rel = relative(cwd2, direct);
+      const rel = relative(cwd3, direct);
       const tree = await renderTree(direct, rel);
       const cost = estTokens(tree);
       if (spent + cost <= tokenBudget) {
@@ -329,7 +363,7 @@ async function expandMentions(message, cwd2, tokenBudget = DEFAULT_TOKEN_BUDGET)
     let files = [];
     try {
       files = await fg(raw, {
-        cwd: cwd2,
+        cwd: cwd3,
         ignore: IGNORE,
         onlyFiles: true,
         dot: true,
@@ -341,7 +375,7 @@ async function expandMentions(message, cwd2, tokenBudget = DEFAULT_TOKEN_BUDGET)
     }
     if (files.length === 0) {
       try {
-        if ((await stat(direct)).isFile()) files = [relative(cwd2, direct)];
+        if ((await stat(direct)).isFile()) files = [relative(cwd3, direct)];
       } catch {
       }
     }
@@ -352,7 +386,7 @@ async function expandMentions(message, cwd2, tokenBudget = DEFAULT_TOKEN_BUDGET)
       seen.add(rel);
       let buf;
       try {
-        buf = await readFile2(resolve(cwd2, rel), "utf8");
+        buf = await readFile2(resolve(cwd3, rel), "utf8");
       } catch {
         continue;
       }
@@ -432,11 +466,528 @@ function buildSubagentTool(deps) {
   };
 }
 
+// src/eyes-cli.ts
+function flagValue(args, flag) {
+  const i = args.indexOf(flag);
+  return i >= 0 && i + 1 < args.length ? args[i + 1] : void 0;
+}
+function printFinding(f) {
+  line();
+  line(f.loaded ? c.green("  \u2713 loaded") + c.dim(`  ${f.url}`) : c.red("  \u2717 not healthy") + c.dim(`  ${f.url}`));
+  if (f.httpStatus !== null) line(c.dim(`  HTTP ${f.httpStatus}`) + (f.title ? c.dim(`  \xB7 ${f.title}`) : ""));
+  if (f.pageErrors.length) {
+    line(c.red(`  page errors (${f.pageErrors.length}):`));
+    for (const e of f.pageErrors.slice(0, 8)) line("    " + c.dim(e));
+  }
+  if (f.consoleErrors.length) {
+    line(c.yellow(`  console errors (${f.consoleErrors.length}):`));
+    for (const e of f.consoleErrors.slice(0, 8)) line("    " + c.dim(e));
+  }
+  if (f.failedRequests.length) {
+    line(c.yellow(`  failed requests (${f.failedRequests.length}):`));
+    for (const r of f.failedRequests.slice(0, 8)) line("    " + c.dim(`${r.method} ${r.url}`));
+  }
+  if (f.screenshot) line(c.cyan(`  screenshot \u2192 ${f.screenshot}`));
+  line(c.dim("  " + f.verdict));
+}
+async function runEyesSubcommand(raw) {
+  if (raw[0] !== "eyes" && raw[0] !== "see") return null;
+  const rest = raw.slice(1);
+  const wantsJson = rest.includes("--json");
+  const noShot = rest.includes("--no-screenshot");
+  const shotPath = flagValue(rest, "--out");
+  const url = rest.find((t) => !t.startsWith("-"));
+  if (!url) {
+    if (wantsJson) {
+      process.stdout.write(JSON.stringify({ ok: false, error: "missing URL" }) + "\n");
+    } else {
+      line(c.red("  usage: wholestack eyes <url> [--json] [--no-screenshot] [--out file.png]"));
+    }
+    return 1;
+  }
+  const res = await inspectUrl({
+    cwd: process.cwd(),
+    url,
+    capture: !noShot,
+    screenshotPath: shotPath
+  });
+  if (!("ok" in res) || res.ok !== true) {
+    const error = res.error;
+    if (wantsJson) {
+      process.stdout.write(JSON.stringify({ ok: false, error }) + "\n");
+    } else {
+      const lines = error.split("\n");
+      line(c.red("  \u2717 " + lines[0]));
+      for (const l of lines.slice(1)) line(c.dim("  " + l));
+    }
+    return 1;
+  }
+  if (wantsJson) {
+    const { dataUrl, ...rest2 } = res;
+    void dataUrl;
+    process.stdout.write(JSON.stringify(rest2) + "\n");
+    return res.loaded ? 0 : 1;
+  }
+  printFinding(res);
+  return res.loaded ? 0 : 1;
+}
+
+// src/workers.ts
+import { spawn as spawn2 } from "child_process";
+import { mkdtemp, rm as rm2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import { generateText as generateText2, stepCountIs as stepCountIs2, tool as tool2 } from "ai";
+import { z as z2 } from "zod";
+var WORKER_TOOLS = [
+  "read_file",
+  "write_file",
+  "edit_file",
+  "multi_edit",
+  "list_dir",
+  "glob",
+  "grep",
+  "run_command",
+  "todo_write",
+  "todo_read"
+];
+function workerToolset(worktreeCtx) {
+  const all = buildTools(worktreeCtx);
+  const out = {};
+  for (const k of WORKER_TOOLS) if (all[k]) out[k] = all[k];
+  return out;
+}
+var WORKER_SYSTEM = "You are an autonomous engineer spawned by a lead engineer to complete ONE focused, self-contained slice of a larger task. You have a full coding toolset (read_file, write_file, edit_file, multi_edit, list_dir, glob, grep, run_command) and you are working in your OWN isolated git worktree \u2014 your edits cannot affect anyone else, so edit freely. Approach: (1) explore the relevant files, (2) make the change, (3) verify it (build/test/typecheck where it makes sense), (4) report. Stay strictly within your assigned slice \u2014 do not refactor unrelated code. When done, return a tight summary: what you changed, which files, and how you verified it.";
+function git(args, cwd3, timeoutMs = 3e4) {
+  return new Promise((res) => {
+    const child = spawn2("git", args, { cwd: cwd3, shell: false });
+    let out = "";
+    const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+    const sink = (b) => {
+      out += b.toString();
+    };
+    child.stdout.on("data", sink);
+    child.stderr.on("data", sink);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      res({ code: 1, out: e.message });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      res({ code: code ?? 1, out });
+    });
+  });
+}
+async function repoRoot(dir) {
+  const r = await git(["rev-parse", "--show-toplevel"], dir);
+  if (r.code !== 0) return null;
+  const top = r.out.trim();
+  return top || null;
+}
+function slug(label) {
+  const base2 = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 24) || "worker";
+  const rand = Math.random().toString(36).slice(2, 8);
+  return `${base2}-${rand}`;
+}
+var MAX_DIFF_CHARS = 24e3;
+function clampDiff(s) {
+  if (s.length <= MAX_DIFF_CHARS) return s;
+  return s.slice(0, MAX_DIFF_CHARS) + `
+\u2026 [diff truncated at ${MAX_DIFF_CHARS} chars \u2014 ${s.length} total]`;
+}
+async function runOneWorker(deps, root, label, task, maxSteps, timeoutMs) {
+  const name = slug(label);
+  const branch = `zeta-worker/${name}`;
+  let worktree = null;
+  try {
+    const parent = await mkdtemp(join2(tmpdir(), "zeta-worker-"));
+    worktree = join2(parent, name);
+    const add = await git(["worktree", "add", "-b", branch, worktree, "HEAD"], root);
+    if (add.code !== 0) {
+      return { label, ok: false, error: `git worktree add failed: ${add.out.trim()}` };
+    }
+    const worktreeCtx = {
+      ...deps.ctx,
+      cwd: worktree,
+      permissions: new Permissions("yolo")
+    };
+    const tools = workerToolset(worktreeCtx);
+    const ac = new AbortController();
+    const killer = setTimeout(() => ac.abort(), timeoutMs);
+    let summary = "";
+    try {
+      const r = await generateText2({
+        model: deps.model,
+        system: WORKER_SYSTEM,
+        prompt: task,
+        tools,
+        stopWhen: stepCountIs2(maxSteps),
+        abortSignal: ac.signal
+      });
+      summary = r.text.trim();
+    } catch (e) {
+      summary = `(worker aborted or errored before reporting: ${e.message})`;
+    } finally {
+      clearTimeout(killer);
+    }
+    await git(["add", "-A"], worktree);
+    const statusR = await git(["status", "--porcelain"], worktree);
+    const files = statusR.out.split("\n").map((l) => l.trim()).filter(Boolean);
+    const diffR = await git(["diff", "--cached", "HEAD"], worktree);
+    const diff = diffR.code === 0 ? clampDiff(diffR.out) : "";
+    line(c.dim(`    \u21B3 ${c.cyan(label)} done \xB7 ${files.length} file(s) changed`));
+    return {
+      label,
+      ok: true,
+      summary,
+      diff,
+      files,
+      worktree
+    };
+  } catch (e) {
+    line(c.dim(`    \u21B3 ${c.cyan(label)} ${c.red("failed")}`));
+    return { label, ok: false, error: e.message, worktree: worktree ?? void 0 };
+  } finally {
+    if (worktree) {
+      await git(["worktree", "remove", "--force", worktree], root);
+      await git(["branch", "-D", branch], root);
+      const parent = join2(worktree, "..");
+      await rm2(parent, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+}
+function buildWorkersTool(deps) {
+  const maxSteps = deps.maxSteps ?? 24;
+  const maxWorkers = deps.maxWorkers ?? 4;
+  const timeoutMs = deps.timeoutMs ?? 3e5;
+  return {
+    spawn_workers: tool2({
+      description: "Run several WRITABLE engineer sub-agents IN PARALLEL, each on its own focused, self-contained slice \u2014 each works in its OWN isolated git worktree so their edits can never stomp the main tree or each other. Each worker can read, write, edit, and run commands inside its sandbox, then returns a summary + the diff of what it changed. Nothing is auto-merged: review each returned diff and apply the good ones yourself. Use for parallel edit-heavy work (scaffold N modules, refactor N files at once). For a single linear edit, just do it directly.",
+      inputSchema: z2.object({
+        tasks: z2.array(
+          z2.object({
+            label: z2.string().describe("Short label for this slice, e.g. 'api-route' or 'refactor-auth'."),
+            task: z2.string().describe(
+              "The complete, self-contained instruction for this worker. It must be doable WITHOUT coordinating with the other workers (they run concurrently in separate worktrees)."
+            )
+          })
+        ).min(1).max(maxWorkers).describe(`1\u2013${maxWorkers} INDEPENDENT, edit-heavy tasks to run concurrently in isolated worktrees.`)
+      }),
+      execute: async ({ tasks: tasks2 }) => {
+        if (deps.ctx.permissions.guardMutation() === "deny") {
+          return { ok: false, error: deps.ctx.permissions.planRefusal() };
+        }
+        const root = await repoRoot(deps.ctx.cwd);
+        if (!root) {
+          return {
+            ok: false,
+            error: "spawn_workers needs a git repository (it isolates each worker in a `git worktree`). Run `git init` in the workspace first, or make the edits directly."
+          };
+        }
+        line(c.dim(`    \u21C9 spawning ${tasks2.length} writable worker(s) in isolated worktrees`));
+        const results = await Promise.all(
+          tasks2.map(({ label, task }) => runOneWorker(deps, root, label, task, maxSteps, timeoutMs))
+        );
+        const changed = results.filter((r) => r.ok && (r.files?.length ?? 0) > 0).length;
+        return {
+          ok: true,
+          count: results.length,
+          changed,
+          note: "Each result carries a `diff` (unified patch vs HEAD) and `files` (touched paths). The worktrees are already removed \u2014 apply the diffs you want into the main tree yourself (e.g. via write_file/edit_file or by piping the diff through `git apply`), then verify.",
+          results
+        };
+      }
+    })
+  };
+}
+
+// src/ops-subcommand.ts
+import { stdout, cwd } from "process";
+function jsonOut(obj) {
+  stdout.write(JSON.stringify(obj) + "\n");
+}
+function base() {
+  return webBaseUrl().replace(/\/$/, "");
+}
+async function probe(url, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const started = Date.now();
+  try {
+    const resp = await fetch(url, { redirect: "follow", signal: controller.signal });
+    return { status: resp.status, latencyMs: Date.now() - started };
+  } catch (e) {
+    const err = e;
+    return {
+      latencyMs: Date.now() - started,
+      error: err.name === "AbortError" ? `timed out after ${timeoutMs}ms` : err.message
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function runOpsSubcommand(raw) {
+  if (raw[0] !== "ops") return null;
+  const rest = raw.slice(1);
+  const verb = rest[0];
+  const wantsJson = rest.includes("--json");
+  const positional = rest.slice(1).filter((a) => !a.startsWith("-"));
+  if (verb === "health") {
+    const arg = positional[0];
+    if (!arg) {
+      line(c.red("  usage: wholestack ops health <url>"));
+      return 1;
+    }
+    const origin = (/^https?:\/\//i.test(arg) ? arg : `https://${arg}`).replace(/\/$/, "");
+    const root = await probe(origin + "/", 15e3);
+    const health = await probe(origin + "/api/health", 15e3);
+    const healthy = root.status != null && root.status >= 200 && root.status < 400;
+    if (wantsJson) {
+      jsonOut({ url: origin, healthy, root, health });
+      return healthy ? 0 : 1;
+    }
+    line("");
+    if (root.error) line("  " + c.red(`\u2717 /  ${root.error}`));
+    else
+      line(
+        "  " + (healthy ? c.green("\u2713 /") : c.yellow("\u2022 /")) + c.dim(`  ${root.status}  ${root.latencyMs}ms`)
+      );
+    if (health.error) line("  " + c.dim(`\u2022 /api/health  ${health.error}`));
+    else line("  " + c.dim(`\u2022 /api/health  ${health.status}  ${health.latencyMs}ms`));
+    return healthy ? 0 : 1;
+  }
+  if (verb === "status") {
+    const deploymentId = positional[0];
+    if (!deploymentId) {
+      line(c.red("  usage: wholestack ops status <deploymentId> [buildId]"));
+      return 1;
+    }
+    const buildId = positional[1] ?? readProjectLink(cwd())?.buildId;
+    if (!buildId) {
+      line(c.red("  no build id \u2014 pass one or run inside a linked project."));
+      return 1;
+    }
+    const r = await apiJson(
+      `${base()}/api/zeta/build/${encodeURIComponent(buildId)}/deploy?deploymentId=${encodeURIComponent(deploymentId)}`
+    );
+    if (wantsJson) {
+      jsonOut(r.ok ? { ok: true, ...r.data } : { ok: false, error: r.error });
+      return r.ok && r.data.status === "ready" ? 0 : 1;
+    }
+    line("");
+    if (!r.ok) {
+      line("  " + c.red(`\u2717 ${r.error}`));
+      return 1;
+    }
+    const status = r.data.status ?? "unknown";
+    line("  " + (status === "ready" ? c.green(`\u2713 ${status}`) : c.cyan(`\u2022 ${status}`)));
+    if (r.data.url) line("  " + c.cyan(r.data.url));
+    return status === "ready" ? 0 : status === "error" ? 1 : 0;
+  }
+  if (verb === "metrics") {
+    const r = await readMetrics(base());
+    if (wantsJson) {
+      jsonOut(r.ok ? { ok: true, metrics: r.metrics } : { ok: false, error: r.error });
+      return r.ok ? 0 : 1;
+    }
+    line("");
+    if (!r.ok || !r.metrics) {
+      line("  " + c.red(`\u2717 ${r.error ?? "no metrics"}`));
+      return 1;
+    }
+    const m = r.metrics;
+    line(
+      "  connected: " + (m.connected.posthog ? c.green("posthog") : c.dim("posthog")) + " \xB7 " + (m.connected.stripe ? c.green("stripe") : c.dim("stripe"))
+    );
+    if (m.traffic) line("  " + c.dim(`visitors 7d ${m.traffic.visitors7d} \xB7 signups 7d ${m.traffic.signups7d}`));
+    if (m.revenue) line("  " + c.dim(`MRR $${m.revenue.mrr} \xB7 subs ${m.revenue.activeSubscriptions}`));
+    return 0;
+  }
+  if (verb === "errors") {
+    const r = await readMetrics(base());
+    const errs = r.ok && r.metrics ? r.metrics.errors ?? [] : [];
+    const connected = r.ok && r.metrics ? r.metrics.connected.posthog : false;
+    if (wantsJson) {
+      jsonOut(r.ok ? { ok: true, connected, errors: errs } : { ok: false, error: r.error });
+      return r.ok ? 0 : 1;
+    }
+    line("");
+    if (!r.ok || !r.metrics) {
+      line("  " + c.red(`\u2717 ${r.error ?? "no metrics"}`));
+      return 1;
+    }
+    if (!connected) {
+      line("  " + c.dim("no error provider connected \u2014 connect PostHog (or set SENTRY_* env)."));
+      return 0;
+    }
+    if (errs.length === 0) {
+      line("  " + c.green("\u2713 no recent errors"));
+      return 0;
+    }
+    for (const e of errs.slice(0, 10)) {
+      line("  " + c.red("\u2022 ") + e.title + c.dim(`  \xD7${e.count}`));
+    }
+    return 0;
+  }
+  line(c.red(`  unknown: wholestack ops ${verb ?? ""}`));
+  line(c.dim("  verbs: health <url> \xB7 status <deploymentId> [buildId] \xB7 metrics \xB7 errors   (+ --json)"));
+  return 1;
+}
+
+// src/learned-tools.ts
+import { tool as tool3 } from "ai";
+import { z as z3 } from "zod";
+import { basename } from "path";
+var KIND_VALUES = ["worked", "failed", "quirk", "note"];
+function defaultScope(ctx) {
+  return basename(ctx.cwd) || "global";
+}
+function buildLearnedMemoryTools(deps) {
+  const { ctx } = deps;
+  const { permissions } = ctx;
+  return {
+    remember: tool3({
+      description: "Record ONE durable lesson learned this session so future sessions inherit it (cross-session memory). Use after finishing a non-trivial task to capture: a pattern that WORKED, an approach that FAILED, or a project QUIRK. Keep it to a single atomic fact \u2014 one lesson per call. Auto-loaded into the system prompt at the start of every session.",
+      inputSchema: z3.object({
+        text: z3.string().min(4).describe("The lesson \u2014 one self-contained, durable fact. Be specific and actionable."),
+        kind: z3.enum(KIND_VALUES).default("note").describe("worked = a pattern that worked; failed = a dead end to avoid; quirk = a project gotcha; note = general."),
+        tags: z3.array(z3.string()).optional().describe("Optional keywords to make this lesson findable later, e.g. ['prisma','migrations']."),
+        scope: z3.string().optional().describe("Project/repo this applies to. Omit to use the current project; use 'global' for everywhere.")
+      }),
+      execute: async ({ text, kind, tags, scope }) => {
+        if (permissions.guardMutation() === "deny") return { ok: false, error: permissions.planRefusal() };
+        try {
+          const saved = rememberLesson({
+            text,
+            kind,
+            tags,
+            scope: scope ?? defaultScope(ctx)
+          });
+          toolLine("remember", `${saved.kind} \xB7 ${saved.scope}`);
+          line(c.dim(`    \u21B3 saved ${c.cyan(saved.slug)}`));
+          return {
+            ok: true,
+            slug: saved.slug,
+            kind: saved.kind,
+            scope: saved.scope,
+            tags: saved.tags,
+            note: "Lesson stored. It will auto-load into the system prompt next session."
+          };
+        } catch (e) {
+          return { ok: false, error: e.message };
+        }
+      }
+    }),
+    recall: tool3({
+      description: "Search the lessons you learned in earlier sessions (cross-session memory). Use to check whether you've already solved something here, or to review what worked/failed before. Returns matching lessons newest-first. Lessons from the current project plus any 'global' lessons are always eligible.",
+      inputSchema: z3.object({
+        query: z3.string().optional().describe("Free-text search over lesson bodies, tags, and kind. Omit to list everything."),
+        scope: z3.string().optional().describe("Limit to a project/repo (plus global). Omit to use the current project."),
+        limit: z3.number().int().min(1).max(50).default(10).describe("Max lessons to return.")
+      }),
+      execute: async ({ query, scope, limit }) => {
+        try {
+          const results = searchLessons({ query, scope: scope ?? defaultScope(ctx), limit });
+          toolLine("recall", query ? `"${query}"` : "all lessons");
+          line(c.dim(`    \u21B3 ${results.length} lesson(s)`));
+          return {
+            ok: true,
+            count: results.length,
+            lessons: results.map((l) => ({
+              slug: l.slug,
+              kind: l.kind,
+              scope: l.scope,
+              tags: l.tags,
+              text: l.text
+            }))
+          };
+        } catch (e) {
+          return { ok: false, error: e.message };
+        }
+      }
+    })
+  };
+}
+
+// src/skills-cli.ts
+import { stdout as stdout2 } from "process";
+async function runSkillsSubcommand(raw) {
+  if (raw[0] !== "skills") return null;
+  const rest = raw.slice(1);
+  const sub = rest[0] && !rest[0].startsWith("-") ? rest[0] : "list";
+  const registry = SkillRegistry.load(process.cwd());
+  if (sub === "show") {
+    const name = rest[1];
+    if (!name) {
+      line(c.red("usage: wholestack skills show <name>"));
+      return 1;
+    }
+    const skill = registry.get(name);
+    if (!skill) {
+      line(c.red(`no skill named "${name}"`));
+      const suggestions = registry.suggest(name);
+      if (suggestions.length) line(c.dim(`did you mean: ${suggestions.join(", ")}`));
+      return 1;
+    }
+    if (rest.includes("--json")) {
+      stdout2.write(
+        JSON.stringify(
+          {
+            name: skill.name,
+            description: skill.description,
+            whenToUse: skill.whenToUse,
+            source: skill.source,
+            procedure: skill.body
+          },
+          null,
+          2
+        ) + "\n"
+      );
+      return 0;
+    }
+    line(c.bold(skill.name) + c.dim(`  \xB7 ${skill.source}`));
+    line(c.dim(skill.whenToUse));
+    line("");
+    line(skill.body);
+    return 0;
+  }
+  const skills = registry.list();
+  if (rest.includes("--json")) {
+    stdout2.write(
+      JSON.stringify(
+        skills.map((s) => ({
+          name: s.name,
+          description: s.description,
+          whenToUse: s.whenToUse,
+          source: s.source
+        })),
+        null,
+        2
+      ) + "\n"
+    );
+    return 0;
+  }
+  if (skills.length === 0) {
+    line(c.dim("no skills installed."));
+    line(c.dim("add *.md files under ~/.wholestack/skills or <cwd>/.wholestack/skills"));
+    return 0;
+  }
+  line(c.bold("skills"));
+  const width = Math.max(...skills.map((s) => s.name.length));
+  for (const s of skills) {
+    line("  " + c.cyan(s.name.padEnd(width)) + "  " + s.whenToUse + c.dim(`  \xB7 ${s.source}`));
+  }
+  line("");
+  line(c.dim("view one:  wholestack skills show <name>"));
+  return 0;
+}
+
 // 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 join2 } from "path";
+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";
+import { tmpdir as tmpdir2, platform as platform2 } from "os";
 var EXT_TO_MEDIA = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -455,7 +1006,7 @@ function run(cmd, args) {
   });
 }
 async function grabClipboardImage() {
-  const out = join2(tmpdir(), `zeta-clip-${process.pid}-${process.hrtime.bigint()}.png`);
+  const out = join3(tmpdir2(), `zeta-clip-${process.pid}-${process.hrtime.bigint()}.png`);
   const os = platform2();
   if (os === "darwin") {
     const script = `set thePath to "${out}"
@@ -489,7 +1040,7 @@ function imageTokens(message) {
   for (let m = re.exec(message); m; m = re.exec(message)) out.add(m[1]);
   return [...out];
 }
-async function scanImages(message, cwd2) {
+async function scanImages(message, cwd3) {
   const tokens = imageTokens(message);
   const images = [];
   const skipped = [];
@@ -518,8 +1069,8 @@ async function scanImages(message, cwd2) {
     }
   }
   for (const tok of tokens) {
-    const raw = tok.startsWith("~/") ? join2(process.env.HOME ?? "", tok.slice(2)) : tok;
-    const abs = isAbsolute2(raw) ? raw : resolve2(cwd2, raw);
+    const raw = tok.startsWith("~/") ? join3(process.env.HOME ?? "", tok.slice(2)) : tok;
+    const abs = isAbsolute2(raw) ? raw : resolve2(cwd3, raw);
     const mediaType = EXT_TO_MEDIA[extname(abs).toLowerCase()];
     if (!mediaType) continue;
     let bytes;
@@ -530,7 +1081,7 @@ async function scanImages(message, cwd2) {
     } catch {
       continue;
     }
-    const label = isAbsolute2(raw) ? raw : relative2(cwd2, abs);
+    const label = isAbsolute2(raw) ? raw : relative2(cwd3, abs);
     if (bytes > PER_IMAGE_BYTES || total + bytes > TOTAL_BYTES) {
       skipped.push(`${label} (${Math.round(bytes / 1024)}KB \u2014 over the size cap)`);
       continue;
@@ -664,21 +1215,21 @@ ${text}`;
 ${body}
 `;
 }
-function writeTranscript(messages, meta, file, cwd2) {
-  const abs = resolve3(cwd2, file);
+function writeTranscript(messages, meta, file, cwd3) {
+  const abs = resolve3(cwd3, file);
   writeFileSync(abs, renderTranscript(messages, meta), "utf8");
   return abs;
 }
 
 // src/cli.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/update-check.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var PKG = "wholestack";
-var CACHE = join3(stateDir(), "update-check.json");
+var CACHE = join4(stateDir(), "update-check.json");
 var DAY_MS = 24 * 60 * 60 * 1e3;
 function readCache() {
   try {
@@ -732,8 +1283,8 @@ async function checkForUpdate(current) {
 
 // src/access.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
-var CACHE2 = join4(stateDir(), "access.json");
+import { join as join5 } from "path";
+var CACHE2 = join5(stateDir(), "access.json");
 var TTL_MS = 60 * 60 * 1e3;
 function readCache2() {
   try {
@@ -756,10 +1307,18 @@ function clearAccessCache() {
   }
 }
 async function verifyAccess(webUrl, token, force = false) {
-  if (!token) return { active: false, tier: null, degraded: false };
+  if (!token) {
+    return { active: false, paid: false, tier: null, freeDeliveries: 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 };
+    return {
+      active: cached.active,
+      paid: cached.paid,
+      tier: cached.tier,
+      freeDeliveries: cached.freeDeliveries,
+      degraded: false
+    };
   }
   try {
     const ctrl = new AbortController();
@@ -770,18 +1329,44 @@ async function verifyAccess(webUrl, token, force = false) {
     });
     clearTimeout(t);
     if (res.status >= 500) {
-      return { active: true, tier: cached?.tier ?? null, degraded: true };
+      return {
+        active: true,
+        paid: cached?.paid ?? false,
+        tier: cached?.tier ?? null,
+        freeDeliveries: cached?.freeDeliveries ?? null,
+        degraded: true
+      };
     }
     if (!res.ok) {
-      writeCache2({ checkedAt: Date.now(), active: false, tier: null });
-      return { active: false, tier: null, degraded: false };
+      writeCache2({
+        checkedAt: Date.now(),
+        active: false,
+        paid: false,
+        tier: null,
+        freeDeliveries: null
+      });
+      return { active: false, paid: false, tier: null, freeDeliveries: 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 };
+    const paid = Boolean(json.paid);
+    const freeDeliveries = json.freeDeliveries ?? null;
+    writeCache2({
+      checkedAt: Date.now(),
+      active,
+      paid,
+      tier: json.tier ?? null,
+      freeDeliveries
+    });
+    return { active, paid, tier: json.tier ?? null, freeDeliveries, degraded: false };
   } catch {
-    return { active: true, tier: cached?.tier ?? null, degraded: true };
+    return {
+      active: true,
+      paid: cached?.paid ?? false,
+      tier: cached?.tier ?? null,
+      freeDeliveries: cached?.freeDeliveries ?? null,
+      degraded: true
+    };
   }
 }
 function showPaywall(loggedIn, webUrl) {
@@ -789,36 +1374,36 @@ function showPaywall(loggedIn, webUrl) {
   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(c.bold("wholestack needs you signed in"));
   row("");
   if (!loggedIn) {
     row(c.dim("You're not signed in."));
-    row("Run  " + c.cyan("zeta login") + c.dim("  then subscribe."));
+    row("Run  " + c.cyan("wholestack login") + c.dim("  to start."));
   } else {
-    row(c.dim("No active paid plan on this account."));
-    row("Subscribe to use zeta in the terminal.");
+    row(c.dim("Your token was rejected or expired."));
+    row("Run  " + c.cyan("wholestack login") + c.dim("  again."));
   }
   row("");
-  row(c.dim("Plans: ") + c.cyan(`${webUrl.replace(/\/$/, "")}/pricing`));
+  row(c.dim("Free: 3 delivered apps/month \xB7 then ") + c.cyan(`${webUrl.replace(/\/$/, "")}/pricing`));
   line("  " + c.cyan("\u2570" + "\u2500".repeat(w) + "\u256F"));
   line();
 }
 
 // src/cli.ts
 import { readFileSync as readFileSync3 } from "fs";
-import { basename, dirname as dirname2 } from "path";
+import { basename as basename2, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 var VERSION = (() => {
   try {
     const here = dirname2(fileURLToPath(import.meta.url));
-    return JSON.parse(readFileSync3(join5(here, "..", "package.json"), "utf8")).version;
+    return JSON.parse(readFileSync3(join6(here, "..", "package.json"), "utf8")).version;
   } catch {
     return "0.0.0";
   }
 })();
 function gitBranch(dir) {
   try {
-    const head = readFileSync3(join5(dir, ".git", "HEAD"), "utf8").trim();
+    const head = readFileSync3(join6(dir, ".git", "HEAD"), "utf8").trim();
     const m = head.match(/ref:\s*refs\/heads\/(.+)$/);
     return m ? m[1] : head.slice(0, 7);
   } catch {
@@ -885,13 +1470,39 @@ ${c.bold("Projects")} ${c.dim("(one spine across terminal, dashboard and the web
   wholestack push [dir]            sync local edits back to the web IDE
   wholestack open [buildId]        open a generated build in the web IDE
 
+${c.bold("Ship")} ${c.dim("(go live \u2014 same credits + entitlements as the web app)")}
+  wholestack deploy   [buildId]                      live preview deploy (polls to ready)
+  wholestack promote  [buildId] [--domain d]         durable production deploy (real DB)
+  wholestack rollback [buildId] --deployment <id>    restore the previous production deploy
+  ${c.dim("buildId defaults to the linked build in this dir (after a delivery or `open`)")}
+
+${c.bold("Launch")} ${c.dim("(the studio's Launch HQ \u2014 go-to-market, in the terminal)")}
+  wholestack launch     [buildId] [--prompt "\u2026"]     draw the AI go-to-market plan
+  wholestack launch-kit [buildId]                    show the build's startup kit (brand/pricing/copy/\u2026)
+  wholestack legal <terms|privacy|cookie|refund>     generate a SaaS legal doc (Markdown \u2192 stdout)
+  wholestack metrics                                 your REAL traffic + revenue (PostHog + Stripe)
+  wholestack waitlist [buildId]                      live waitlist signup count
+  wholestack businesses                              every business workspace you own
+  wholestack business  [buildId]                     one workspace + its readiness scorecard
+  ${c.dim("add --json for machine-readable output")}
+
+${c.bold("Prove gate (web2)")} ${c.dim("(deterministic \xB7 fail-closed \xB7 blocking exit code)")}
+  wholestack prove <dir> [--json]                    gate a checked-out repo (local lockstep mirror)
+  wholestack prove --remote --github o/r [--ref b]   hosted, HMAC-signed verdict via /api/v1/prove
+  ${c.dim("checks: secrets/sinks/unauth-mutations + authorization-completeness (no orphan routes)")}
+
 ${c.bold("Web3 security")} ${c.dim("(forge \xB7 slither \xB7 firewall \xB7 halmos \xB7 signed cert)")}
-  wholestack audit  <dir> <Contract>                 full auto-detect security sweep
+  wholestack audit  <dir> <Contract>                 full auto-detect security sweep (local)
+  wholestack audit repo [--github o/r] [--pick]      remote repo audit + live SSE progress
   wholestack prove  <dir> <Contract> --property <k>  prove one invariant
   wholestack verify <dir> <Contract> --cert c.json   passthrough + signed certificate
   ${c.dim("kinds: reentrancy-safety, access-control, conservation, no-value-extraction, \u2026")}
   wholestack --nzt48 "audit ./contracts"            NZT-48 web3 special-ops persona
 
+${c.bold("GitHub")} ${c.dim("(private repos via App installation)")}
+  wholestack github installations                    list linked GitHub App installs
+  wholestack github repos --installation <id>        list repos for an installation
+
 ${c.bold("Session")}
   -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)
@@ -929,10 +1540,218 @@ ${c.bold("In a session")} ${c.dim("(type /help for the full list)")}
   ${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")}`;
+function flagValue2(rest, flag) {
+  const i = rest.indexOf(flag);
+  return i >= 0 ? rest[i + 1] : void 0;
+}
+async function runGithubSubcommand(raw) {
+  if (raw[0] !== "github") return null;
+  const sub = raw[1];
+  const base2 = webBaseUrl();
+  if (sub === "installations") {
+    const r = await fetchGithubInstallations(base2);
+    if (!r.ok) {
+      line(c.red(`  ${r.error}`));
+      return 1;
+    }
+    if (!r.installations.length) {
+      line(c.dim("  no installations \u2014 connect GitHub in the web dashboard."));
+      return 0;
+    }
+    line();
+    for (const row of r.installations) {
+      const suspended = row.suspendedAt ? c.yellow(" \xB7 suspended") : "";
+      line(`  ${c.cyan(String(row.installationId))}  ${row.accountLogin}${suspended}`);
+    }
+    line();
+    return 0;
+  }
+  if (sub === "repos") {
+    const rawId = flagValue2(raw.slice(2), "--installation");
+    const installationId = rawId ? Number(rawId) : NaN;
+    if (!rawId || !Number.isFinite(installationId)) {
+      line(c.red("  usage: wholestack github repos --installation <id>"));
+      return 1;
+    }
+    const r = await fetchGithubRepos(base2, installationId);
+    if (!r.ok) {
+      line(c.red(`  ${r.error}`));
+      return 1;
+    }
+    line();
+    for (const repo of r.repos) {
+      line(
+        `  ${repo.fullName}${repo.private ? c.yellow(" \xB7 private") : ""} ${c.dim(repo.defaultBranch ?? "")}`
+      );
+    }
+    line();
+    return 0;
+  }
+  line(c.red("  usage: wholestack github installations | wholestack github repos --installation <id>"));
+  return 1;
+}
+async function runAuditRepoSubcommand(rest) {
+  const base2 = webBaseUrl();
+  const body = {};
+  if (rest.includes("--pick")) {
+    const picked = await pickGithubRepoInteractive(base2);
+    if (!picked.ok) {
+      line(c.red(`  ${picked.error}`));
+      return 1;
+    }
+    body.githubRepo = picked.githubRepo;
+    body.installationId = picked.installationId;
+  }
+  const github = flagValue2(rest, "--github");
+  if (github) body.githubRepo = github;
+  const installationRaw = flagValue2(rest, "--installation");
+  if (installationRaw) {
+    const n = Number(installationRaw);
+    if (!Number.isFinite(n)) {
+      line(c.red("  --installation must be a number"));
+      return 1;
+    }
+    body.installationId = n;
+  }
+  const gitUrl = flagValue2(rest, "--git-url");
+  if (gitUrl) body.gitUrl = gitUrl;
+  const sourcePath = flagValue2(rest, "--source");
+  if (sourcePath) {
+    const src = readSourceFile(sourcePath);
+    if (!src.ok) {
+      line(c.red(`  ${src.error}`));
+      return 1;
+    }
+    body.source = src.source;
+  }
+  const maxRaw = flagValue2(rest, "--max-contracts");
+  if (maxRaw) {
+    const n = Number(maxRaw);
+    if (!Number.isFinite(n)) {
+      line(c.red("  --max-contracts must be a number"));
+      return 1;
+    }
+    body.maxContracts = n;
+  }
+  if (!body.source && !body.gitUrl && !body.githubRepo) {
+    line(c.red("  provide --github owner/repo, --git-url, --source <file>, or --pick"));
+    return 1;
+  }
+  line();
+  line(c.cyan("  \u259F ShipGate repo audit") + c.dim("  \xB7 streaming progress"));
+  line();
+  const r = await runRepoAuditStream(base2, body);
+  line();
+  if (!r.ok) {
+    line(c.red(`  \u2717 ${r.error}`));
+    if (r.status === 402 && r.upgradeUrl) {
+      line(c.dim(`  upgrade: ${base2}${r.upgradeUrl}`));
+    }
+    return 1;
+  }
+  const verdict = String(r.result.verdict ?? r.result.shipVerdict ?? "unknown");
+  line(verdict === "SHIP" || verdict === "ship" ? c.green("  \u2713 SHIP") : c.yellow(`  verdict: ${verdict}`));
+  if (r.result.certificateUrl) line(c.dim(`  certificate: ${r.result.certificateUrl}`));
+  if (r.result.bundleId) line(c.dim(`  bundle: ${base2}/api/audit/bundle/${r.result.bundleId}`));
+  return 0;
+}
+async function runProveSubcommand(raw) {
+  if (raw[0] !== "prove") return null;
+  const rest = raw.slice(1);
+  if (rest.includes("--property")) return null;
+  const wantsJson = rest.includes("--json");
+  if (rest.includes("--remote")) {
+    const base2 = webBaseUrl().replace(/\/$/, "");
+    const key = process.env.ZETA_API_KEY?.trim();
+    if (!key) {
+      line(c.red("  not signed in \u2014 run `wholestack login` first (--remote needs a token)."));
+      return 1;
+    }
+    const body = {};
+    const github = flagValue2(rest, "--github");
+    if (github) body.githubRepo = github;
+    const gitUrl = flagValue2(rest, "--git-url");
+    if (gitUrl) body.gitUrl = gitUrl;
+    const installationRaw = flagValue2(rest, "--installation");
+    if (installationRaw) {
+      const n = Number(installationRaw);
+      if (!Number.isFinite(n)) {
+        line(c.red("  --installation must be a number"));
+        return 1;
+      }
+      body.installationId = n;
+    }
+    const ref = flagValue2(rest, "--ref");
+    if (ref) body.ref = ref;
+    if (!body.githubRepo && !body.gitUrl) {
+      line(c.red("  --remote needs --github owner/repo or --git-url <url>"));
+      return 1;
+    }
+    let resp;
+    try {
+      resp = await fetch(`${base2}/api/v1/prove`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
+        body: JSON.stringify(body)
+      });
+    } catch (e) {
+      line(c.red(`  cannot reach the platform: ${e.message}`));
+      return 1;
+    }
+    const data = await resp.json().catch(() => null);
+    if (wantsJson) {
+      stdout3.write(JSON.stringify(data) + "\n");
+      return data?.verdict === "SHIP" ? 0 : 1;
+    }
+    if (resp.status === 401 || resp.status === 402 || resp.status === 503 || !data) {
+      line(c.red(`  \u2717 ${data?.error ?? `platform returned ${resp.status}`}`));
+      if (data?.upgradeUrl) line(c.dim(`  upgrade: ${base2}${data.upgradeUrl}`));
+      return 1;
+    }
+    printProveVerdict(data.verdict ?? "NO_SHIP", data.score ?? 0, data.checks ?? [], data.blockingReasons ?? []);
+    return data.verdict === "SHIP" ? 0 : 1;
+  }
+  const path = rest.find((a) => !a.startsWith("-")) ?? cwd2();
+  if (!existsSync2(path)) {
+    line(c.red(`  path not found: ${path}`));
+    return 1;
+  }
+  const result = proveLocalRepo(path);
+  if (wantsJson) {
+    stdout3.write(JSON.stringify(result) + "\n");
+    return result.verdict === "SHIP" ? 0 : 1;
+  }
+  line();
+  line(c.cyan("  \u259F ISL prove-gate") + c.dim("  \xB7 deterministic \xB7 fail-closed \xB7 foreign default-deny"));
+  line();
+  printProveVerdict(result.verdict, result.score, result.checks, result.blockingReasons);
+  return result.verdict === "SHIP" ? 0 : 1;
+}
+function printProveVerdict(verdict, score, checks, blockingReasons) {
+  for (const ch of checks) {
+    const icon = ch.status === "pass" ? c.green("\u2713") : ch.status === "fail" ? c.red("\u2717") : c.dim("\u2205");
+    const label = ch.status === "not-run" ? c.dim(ch.title + " (not run)") : ch.title;
+    line(`  ${icon} ${label}`);
+    line(c.dim(`     ${ch.detail}`));
+  }
+  line();
+  if (blockingReasons.length) {
+    line(c.red(`  ${blockingReasons.length} blocking reason(s):`));
+    for (const r of blockingReasons.slice(0, 25)) line(c.dim(`   - ${r}`));
+    if (blockingReasons.length > 25) line(c.dim(`   \u2026+${blockingReasons.length - 25} more`));
+    line();
+  }
+  line(
+    verdict === "SHIP" ? c.green(`  \u2713 SHIP`) + c.dim(`  \xB7 score ${score}/100`) : c.red(`  \u2717 NO_SHIP`) + c.dim(`  \xB7 score ${score}/100`)
+  );
+}
 async function runSecuritySubcommand(raw) {
   const verb = raw[0];
   if (verb !== "audit" && verb !== "prove" && verb !== "verify") return null;
   const rest = raw.slice(1);
+  if (verb === "audit" && rest[0] === "repo") {
+    return runAuditRepoSubcommand(rest.slice(1));
+  }
   const proverArgs = verb === "verify" && rest[0]?.endsWith(".json") ? ["verify", ...rest] : [...rest];
   if (verb === "prove" && !proverArgs.includes("--property")) {
     line(c.red("  prove needs --property <kind>"));
@@ -942,7 +1761,7 @@ async function runSecuritySubcommand(raw) {
   line();
   line(c.cyan(`  \u259F ShipGate ${verb}`) + c.dim("  \xB7 forge \xB7 slither \xB7 firewall \xB7 halmos"));
   line();
-  const r = await runProver(proverArgs, { cwd: cwd(), inherit: true });
+  const r = await runProver(proverArgs, { cwd: cwd2(), inherit: true });
   if (r.missing) {
     line(c.red(`  ${r.out}`));
     return 1;
@@ -954,7 +1773,7 @@ async function runSecuritySubcommand(raw) {
 function maybeYoloNotice() {
   try {
     const dir = stateDir();
-    const marker = join5(dir, "yolo-notice-seen");
+    const marker = join6(dir, "yolo-notice-seen");
     if (existsSync2(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"
@@ -964,9 +1783,6 @@ function maybeYoloNotice() {
   } catch {
   }
 }
-function webBaseUrl() {
-  return process.env.ZETA_WEB_URL?.trim() || process.env.ZETA_API_URL?.trim() || "https://wholestack.ai";
-}
 async function runLogin(raw) {
   if (raw[0] !== "login" && raw[0] !== "logout") return null;
   const rest = raw.slice(1);
@@ -1018,7 +1834,7 @@ async function runLogin(raw) {
       line(c.red("  usage: wholestack login --member <key> | --brain <key> | --build <key>"));
       return 1;
     }
-    const rl = createInterface({ input: stdin, output: stdout });
+    const rl = createInterface({ input: stdin, output: stdout3 });
     if (!name) {
       const which = (await rl.question(c.cyan("  key for [member/brain/engine]: "))).trim().toLowerCase();
       name = which.startsWith("m") ? "ZETA_API_KEY" : "CEREBRAS_API_KEY";
@@ -1040,9 +1856,9 @@ async function runLogin(raw) {
 async function runProjectSubcommand(raw) {
   const verb = raw[0];
   if (verb !== "projects" && verb !== "pull" && verb !== "push" && verb !== "open") return null;
-  const base = webBaseUrl();
+  const base2 = webBaseUrl();
   if (verb === "projects") {
-    const r2 = await listProjects(base);
+    const r2 = await listProjects(base2);
     if (!r2.ok) {
       line(c.red(`  ${r2.error}`));
       return 1;
@@ -1058,7 +1874,7 @@ async function runProjectSubcommand(raw) {
       if (p.description) line("  " + c.dim(`  ${p.description}`));
     }
     line();
-    line(c.dim("  pull one with ") + c.cyan("wholestack pull <id>") + c.dim(" \xB7 open in the IDE at ") + c.cyan(`${base}/ide/studio?projectId=<id>`));
+    line(c.dim("  pull one with ") + c.cyan("wholestack pull <id>") + c.dim(" \xB7 open in the IDE at ") + c.cyan(`${base2}/ide/studio?projectId=<id>`));
     return 0;
   }
   if (verb === "pull") {
@@ -1067,7 +1883,7 @@ async function runProjectSubcommand(raw) {
       line(c.red("  usage: wholestack pull <projectId> [dir]"));
       return 1;
     }
-    const r2 = await pullWorkingTree(base, projectId);
+    const r2 = await pullWorkingTree(base2, projectId);
     if (!r2.ok) {
       line(c.red(`  ${r2.error}`));
       return 1;
@@ -1093,14 +1909,14 @@ async function runProjectSubcommand(raw) {
       line(c.red("  nothing to push (no readable text files found)."));
       return 1;
     }
-    const r2 = await pushWorkingTree(base, projectId, files);
+    const r2 = await pushWorkingTree(base2, projectId, files);
     if (!r2.ok) {
       line(c.red(`  ${r2.error}`));
       return 1;
     }
     writeProjectLink(dir, { projectId });
     line(c.green(`  \u2713 pushed ${files.length} files`) + c.dim(skipped ? `  (${skipped} skipped: binary/oversize)` : ""));
-    line(c.dim("  open it: ") + c.cyan(`${base}/ide/studio?projectId=${projectId}`));
+    line(c.dim("  open it: ") + c.cyan(`${base2}/ide/studio?projectId=${projectId}`));
     return 0;
   }
   const buildId = raw[1] ?? readProjectLink(".")?.buildId;
@@ -1108,14 +1924,189 @@ async function runProjectSubcommand(raw) {
     line(c.red("  usage: wholestack open <buildId>  (or run it inside a delivered app dir)"));
     return 1;
   }
-  const r = await openBuildInEditor(base, buildId);
+  const r = await openBuildInEditor(base2, buildId);
   if (!r.ok) {
     line(c.red(`  ${r.error}`));
     return 1;
   }
   if (r.projectId) writeProjectLink(".", { buildId, projectId: r.projectId });
   line(c.green("  \u2713 project ready in the web IDE"));
-  line(c.dim("  ") + c.cyan(`${base}${r.editorUrl ?? `/ide/studio?projectId=${r.projectId}`}`));
+  line(c.dim("  ") + c.cyan(`${base2}${r.editorUrl ?? `/ide/studio?projectId=${r.projectId}`}`));
+  return 0;
+}
+async function runShipSubcommand(raw) {
+  const verb = raw[0];
+  if (verb !== "deploy" && verb !== "promote" && verb !== "rollback") return null;
+  const base2 = webBaseUrl();
+  const rest = raw.slice(1);
+  const buildId = (rest.find((a) => !a.startsWith("-")) ?? readProjectLink(".")?.buildId)?.trim();
+  if (!buildId) {
+    line(c.red(`  usage: wholestack ${verb} <buildId>  (or run it inside a delivered app dir)`));
+    return 1;
+  }
+  if (verb === "deploy") {
+    line();
+    line(c.cyan("  \u259F deploy") + c.dim("  \xB7 live preview \xB7 charges one build credit (paid once per build)"));
+    const r2 = await deployBuild(base2, buildId, {
+      poll: true,
+      onPhase: (s) => line(c.dim(`  \xB7 ${s}`))
+    });
+    return printDeploy(r2, base2, "deployed");
+  }
+  if (verb === "promote") {
+    const domain = flagValue2(rest, "--domain");
+    line();
+    line(c.cyan("  \u259F promote") + c.dim("  \xB7 durable production \xB7 real database, dev-auth OFF"));
+    const r2 = await promoteBuild(base2, buildId, domain ? { domain } : {});
+    return printDeploy(r2, base2, "promoted to production");
+  }
+  const deploymentId = flagValue2(rest, "--deployment") ?? flagValue2(rest, "--deployment-id");
+  if (!deploymentId) {
+    line(c.red("  usage: wholestack rollback [buildId] --deployment <currentDeploymentId>"));
+    return 1;
+  }
+  line();
+  line(c.cyan("  \u259F rollback") + c.dim("  \xB7 restore the previous production deployment"));
+  const r = await rollbackDeployment(base2, buildId, deploymentId);
+  return printDeploy(r, base2, "rolled back");
+}
+function printDeploy(r, base2, doneVerb) {
+  line();
+  if (!r.ok) {
+    line(c.red(`  \u2717 ${r.error}`));
+    if (r.hint) line(c.dim(`    ${r.hint}`));
+    if (r.upgradeUrl) line(c.dim(`    upgrade: ${base2.replace(/\/$/, "")}${r.upgradeUrl}`));
+    if (r.connectUrl) line(c.dim(`    connect: ${base2.replace(/\/$/, "")}${r.connectUrl}`));
+    return 1;
+  }
+  line(c.green(`  \u2713 ${doneVerb}`) + (r.status ? c.dim(`  \xB7 ${r.status}`) : ""));
+  if (r.url) line(c.dim("  ") + c.cyan(r.url.startsWith("http") ? r.url : `https://${r.url}`));
+  if (r.deploymentId) line(c.dim(`  deployment ${r.deploymentId}`));
+  if (r.dbNote) line(c.dim(`  ${r.dbNote}`));
+  else if (r.dbProvisioned) line(c.dim("  database provisioned + schema applied"));
+  return 0;
+}
+async function runLaunchSubcommand(raw) {
+  const verb = raw[0];
+  if (verb !== "launch" && verb !== "launch-kit") return null;
+  const base2 = webBaseUrl();
+  const rest = raw.slice(1);
+  const wantsJson = rest.includes("--json");
+  const argBuildId = rest.find((a) => !a.startsWith("-"));
+  const buildId = (argBuildId ?? readProjectLink(".")?.buildId)?.trim();
+  if (verb === "launch") {
+    const prompt = flagValue2(rest, "--prompt");
+    line();
+    line(c.cyan("  \u259F launch canvas") + c.dim("  \xB7 drawing your go-to-market plan\u2026"));
+    const r2 = await drawCanvas(base2, { buildId, prompt });
+    if (!r2.ok || !r2.plan) {
+      line(c.red(`  \u2717 ${r2.error ?? "no plan returned"}`));
+      return 1;
+    }
+    if (wantsJson) {
+      stdout3.write(JSON.stringify(r2.plan, null, 2) + "\n");
+      return 0;
+    }
+    for (const ln of renderGtmPlanLines(r2.plan)) line(ln);
+    return 0;
+  }
+  if (!buildId) {
+    line(c.red("  usage: wholestack launch-kit <buildId>  (or run it inside a delivered app dir)"));
+    return 1;
+  }
+  const r = await getLaunchKit(base2, buildId);
+  if (!r.ok || !r.kit) {
+    line(c.red(`  \u2717 ${r.error ?? "no launch kit"}`));
+    return 1;
+  }
+  if (wantsJson) {
+    stdout3.write(JSON.stringify(r.kit, null, 2) + "\n");
+    return 0;
+  }
+  for (const ln of renderLaunchKitLines(r.kit)) line(ln);
+  return 0;
+}
+async function runHqSubcommand(raw) {
+  const verb = raw[0];
+  if (!["legal", "metrics", "waitlist", "businesses", "business"].includes(verb)) return null;
+  const base2 = webBaseUrl();
+  const rest = raw.slice(1);
+  const wantsJson = rest.includes("--json");
+  const firstArg = rest.find((a) => !a.startsWith("-"));
+  if (verb === "legal") {
+    const kinds = ["terms", "privacy", "cookie", "refund"];
+    const kind = firstArg;
+    if (!kind || !kinds.includes(kind)) {
+      line(c.red("  usage: wholestack legal <terms|privacy|cookie|refund> [--name <business>]"));
+      return 1;
+    }
+    const r2 = await generateLegal(base2, { kind, businessName: flagValue2(rest, "--name") });
+    if (!r2.ok || !r2.markdown) {
+      line(c.red(`  \u2717 ${r2.error ?? "no document produced"}`));
+      return 1;
+    }
+    stdout3.write(r2.markdown.trimEnd() + "\n");
+    return 0;
+  }
+  if (verb === "metrics") {
+    const r2 = await readMetrics(base2);
+    if (!r2.ok || !r2.metrics) {
+      line(c.red(`  \u2717 ${r2.error ?? "could not read metrics"}`));
+      return 1;
+    }
+    if (wantsJson) {
+      stdout3.write(JSON.stringify(r2.metrics, null, 2) + "\n");
+      return 0;
+    }
+    for (const ln of renderMetricsLines(r2.metrics)) line(ln);
+    return 0;
+  }
+  if (verb === "waitlist") {
+    const buildId2 = (firstArg ?? readProjectLink(".")?.buildId)?.trim();
+    if (!buildId2) {
+      line(c.red("  usage: wholestack waitlist <buildId>  (or run it inside a delivered app dir)"));
+      return 1;
+    }
+    const r2 = await waitlistCount(base2, buildId2);
+    if (!r2.ok) {
+      line(c.red(`  \u2717 ${r2.error}`));
+      return 1;
+    }
+    line();
+    line("  " + c.bold(String(r2.count ?? 0)) + c.dim(" waitlist signup(s)"));
+    return 0;
+  }
+  if (verb === "businesses") {
+    const r2 = await listBusinesses(base2);
+    if (!r2.ok) {
+      line(c.red(`  \u2717 ${r2.error}`));
+      return 1;
+    }
+    if (wantsJson) {
+      stdout3.write(JSON.stringify(r2.businesses ?? [], null, 2) + "\n");
+      return 0;
+    }
+    const rows = r2.businesses ?? [];
+    if (!rows.length) {
+      line(c.dim("  no businesses yet \u2014 draw a launch plan (`wholestack launch`) or build an app."));
+      return 0;
+    }
+    line();
+    for (const b of rows) {
+      const id = String(b.id ?? "");
+      const name = typeof b.name === "string" ? b.name : typeof b.brandName === "string" ? b.brandName : "";
+      line("  " + c.cyan(id) + (name ? "  " + c.bold(name) : ""));
+    }
+    line();
+    return 0;
+  }
+  const buildId = (firstArg ?? readProjectLink(".")?.buildId)?.trim();
+  const r = await getBusiness(base2, buildId ? { buildId } : {});
+  if (!r.ok) {
+    line(c.red(`  \u2717 ${r.error}`));
+    return 1;
+  }
+  stdout3.write(JSON.stringify({ business: r.business, readiness: r.readiness }, null, 2) + "\n");
   return 0;
 }
 var EMPTY_PLUGINS = {
@@ -1144,10 +2135,26 @@ async function main() {
   const rawArgs = argv.slice(2);
   const loggedIn = await runLogin(rawArgs);
   if (loggedIn !== null) exit(loggedIn);
+  const gh = await runGithubSubcommand(rawArgs);
+  if (gh !== null) exit(gh);
+  const provePath = await runProveSubcommand(rawArgs);
+  if (provePath !== null) exit(provePath);
   const sub = await runSecuritySubcommand(rawArgs);
   if (sub !== null) exit(sub);
   const proj = await runProjectSubcommand(rawArgs);
   if (proj !== null) exit(proj);
+  const ship = await runShipSubcommand(rawArgs);
+  if (ship !== null) exit(ship);
+  const launch = await runLaunchSubcommand(rawArgs);
+  if (launch !== null) exit(launch);
+  const hq = await runHqSubcommand(rawArgs);
+  if (hq !== null) exit(hq);
+  const eyes = await runEyesSubcommand(rawArgs);
+  if (eyes !== null) exit(eyes);
+  const ops = await runOpsSubcommand(rawArgs);
+  if (ops !== null) exit(ops);
+  const skillsSub = await runSkillsSubcommand(rawArgs);
+  if (skillsSub !== null) exit(skillsSub);
   const args = parse(rawArgs);
   if (args.version) {
     line(`wholestack ${VERSION}`);
@@ -1161,9 +2168,9 @@ async function main() {
     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 rl = createInterface({ input: stdin, output: stdout3 });
       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] ")
+        "\n  " + (token ? c.dim("Token invalid or expired. ") + "Log in again? " : "Log in now? ") + c.dim("[Y/n] ")
       )).trim().toLowerCase();
       rl.close();
       if (ans === "" || ans === "y" || ans === "yes") {
@@ -1179,6 +2186,16 @@ async function main() {
       showPaywall(Boolean(token), webBaseUrl());
       exit(1);
     }
+    if (!access.paid && access.freeDeliveries) {
+      const fd = access.freeDeliveries;
+      line(
+        c.dim(
+          `  free plan \xB7 ${fd.remaining}/${fd.limit} delivered apps left this month \xB7 `
+        ) + c.cyan(`${webBaseUrl().replace(/\/$/, "")}/pricing`)
+      );
+    } else if (access.paid && access.tier) {
+      line(c.dim(`  ${access.tier} plan`));
+    }
   }
   let modelKey;
   try {
@@ -1194,9 +2211,19 @@ async function main() {
     line(c.red(e.message));
     exit(1);
   }
+  if (args.model) {
+    escalationBus.lock();
+  } else {
+    const firstPrompt = args.prompt.length > 0 ? args.prompt : void 0;
+    const boot = pickBootModel(firstPrompt);
+    if (boot && boot.key !== modelKey) {
+      modelKey = boot.key;
+      model = resolveModel(modelKey);
+    }
+  }
   const isTty = !!stdin.isTTY;
   const oneShot = args.prompt.length > 0;
-  const workdir = cwd();
+  const workdir = cwd2();
   const persistedMode = isPermissionMode(
     process.env.ZETA_PERMISSION_MODE
   ) ? process.env.ZETA_PERMISSION_MODE : void 0;
@@ -1204,7 +2231,9 @@ async function main() {
   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;
+  const skills = SkillRegistry.load(workdir);
+  const learned = loadLearnedMemory({ scope: basename2(workdir) });
+  const memoryText = [memory.text, learned.text, plugins.systemText, skills.promptHint()].filter(Boolean).join("\n\n") || void 0;
   const mcp = await loadMcpTools({
     cwd: workdir,
     only: args.mcp,
@@ -1236,7 +2265,7 @@ async function main() {
       },
       // Starship-style context segments above the prompt box.
       contextBar: () => {
-        const seg = [c.cyan(modelLabel(modelKey)), c.dim(basename(workdir))];
+        const seg = [c.cyan(modelLabel(modelKey)), c.dim(basename2(workdir))];
         const br = gitBranch(workdir);
         if (br) seg.push(c.dim("\u2387 " + br));
         seg.push(mode === "yolo" ? c.yellow(mode) : c.dim(mode));
@@ -1258,7 +2287,21 @@ async function main() {
     ...buildWebTools(),
     ...mcp.tools,
     // Parallel read-only sub-agents (needs the model handle the base tools lack).
-    ...buildSubagentTool({ model, modelKey, ctx: toolCtx })
+    ...buildSubagentTool({ model, modelKey, ctx: toolCtx }),
+    // Parallel WRITABLE workers in isolated git worktrees (review-then-merge diffs).
+    ...buildWorkersTool({ model, modelKey, ctx: toolCtx }),
+    // Self-verify + heal: run the web2 ShipGate (prove_app) + the app's own checks (verify_build).
+    ...buildVerifyTools({ ctx: toolCtx }),
+    // Eyes — open a running app in a real browser and report what it sees.
+    ...buildEyesTool({ ctx: toolCtx }),
+    // Living ops — operate the app after ship (health/deploy/metrics/errors).
+    ...buildOpsTools({ ctx: toolCtx }),
+    // Cross-session learned memory (remember / recall).
+    ...buildLearnedMemoryTools({ ctx: toolCtx }),
+    // Composable skills (list_skills / use_skill) from the boot-time registry.
+    ...buildSkillTools({ registry: skills }),
+    // Auto model-routing: the escalate_model tool posts requests the loop drains.
+    ...buildEscalateTool({ ctx: toolCtx, currentKey: modelKey, bus: escalationBus })
   };
   let session;
   let resumedMessages = null;
@@ -1286,7 +2329,7 @@ async function main() {
     persona: args.persona,
     thinking,
     yolo: mode === "yolo",
-    maxSteps: 16,
+    maxSteps: 50,
     contextWindow: modelContextWindow(modelKey),
     session
   });
@@ -1337,6 +2380,19 @@ ${m.context}` : args.prompt;
   const runTurn = async (text, images) => {
     const t0 = Date.now();
     await ic.runInterruptible((sig) => agent.send(text, sig, images));
+    const pending = escalationBus.drain();
+    if (pending && pending.key !== modelKey) {
+      try {
+        modelKey = pending.key;
+        agent.setModel(resolveModel(modelKey), modelKey, modelContextWindow(modelKey));
+        agent.setThinking(supportsThinking(modelKey) ? args.think ?? false : false);
+        line(
+          "  " + c.green(`\u2192 ${modelLabel(modelKey)}`) + c.dim(`  \xB7 auto-route: ${pending.reason}`) + "\n"
+        );
+      } catch (e) {
+        line("  " + c.red(e.message));
+      }
+    }
     statusLine({
       model: modelLabel(modelKey),
       tokens: agent.usage.outputTokens,
@@ -1373,6 +2429,7 @@ ${m.context}` : args.prompt;
           const m = resolveModel(res.modelKey);
           modelKey = res.modelKey;
           agent.setModel(m, modelKey, modelContextWindow(modelKey));
+          escalationBus.lock();
           agent.setThinking(supportsThinking(modelKey) ? args.think ?? false : false);
           line(
             "  " + c.green(`\u2192 ${modelLabel(modelKey)}`) + (agent.thinkingOn ? c.dim("  \xB7 thinking on") : "") + "\n"