wholestack 0.5.5 → 0.5.6

package/README.md

@@ -43,6 +43,23 @@ on wholestack.ai.
 | `-p, --print` | non-interactive, print result and exit |
 | `--zeta-url <url>` | override the engine origin (defaults to https://wholestack.ai) |
 
+## Projects — one spine with the web IDE
+
+Everything you build (terminal, wholestack.ai/build, /demo) lands in the same
+project list. The terminal can read and write the exact working tree the web
+IDE edits:
+
+```bash
+wholestack projects            # list your platform projects
+wholestack pull <id> [dir]     # download a project's working tree
+wholestack push [dir]          # sync local edits back to the web IDE
+wholestack open [buildId]      # open a generated build in the web IDE
+```
+
+`pull` links the directory via `.wholestack/project.json`, so a later `push`
+(and `open` inside a delivered app) needs no arguments. Pushes skip
+`node_modules`, build output, `.env*` and binaries.
+
 ## Security verification
 
 Run ShipGate's gates on a generated contract:

package/dist/{chunk-7NZ77Q7Q.js → chunk-K6MSDQJT.js}

@@ -455,16 +455,149 @@ function renderNewFileDiff(path, content, opts = {}) {
   line();
 }
 
+// src/platform.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join, resolve, sep, dirname, normalize as pathNormalize } from "path";
+import fg from "fast-glob";
+function authHeaders() {
+  const key = process.env.ZETA_API_KEY?.trim();
+  if (!key) return null;
+  return { authorization: `Bearer ${key}`, "content-type": "application/json" };
+}
+var NO_KEY = "set ZETA_API_KEY (run `wholestack login`) first.";
+async function apiJson(url, init) {
+  const headers = authHeaders();
+  if (!headers) return { ok: false, error: NO_KEY };
+  let resp;
+  try {
+    resp = await fetch(url, { ...init, headers: { ...headers, ...init?.headers ?? {} } });
+  } catch (e) {
+    return { ok: false, error: `cannot reach the platform: ${e.message}` };
+  }
+  const data = await resp.json().catch(() => null);
+  if (!resp.ok) {
+    return {
+      ok: false,
+      status: resp.status,
+      error: data?.error ?? (resp.status === 401 ? "token rejected \u2014 run `wholestack login` again." : `platform returned ${resp.status}`)
+    };
+  }
+  return { ok: true, data };
+}
+async function listProjects(apiUrl) {
+  const r = await apiJson(`${apiUrl}/api/projects`);
+  if (!r.ok) return { ok: false, error: r.error };
+  return { ok: true, projects: r.data.projects ?? [] };
+}
+async function pullWorkingTree(apiUrl, projectId) {
+  const r = await apiJson(
+    `${apiUrl}/api/projects/${encodeURIComponent(projectId)}/working-tree`
+  );
+  if (!r.ok) return { ok: false, error: r.error };
+  return { ok: true, name: r.data.project?.name, files: r.data.files ?? [] };
+}
+async function pushWorkingTree(apiUrl, projectId, files) {
+  const r = await apiJson(
+    `${apiUrl}/api/projects/${encodeURIComponent(projectId)}/working-tree`,
+    { method: "PATCH", body: JSON.stringify({ files }) }
+  );
+  if (!r.ok) return { ok: false, error: r.error };
+  return { ok: true };
+}
+async function openBuildInEditor(apiUrl, buildId) {
+  const r = await apiJson(
+    `${apiUrl}/api/zeta/build/${encodeURIComponent(buildId)}/open-in-editor`,
+    { method: "POST" }
+  );
+  if (!r.ok) return { ok: false, error: r.error };
+  return { ok: true, projectId: r.data.projectId, editorUrl: r.data.editorUrl };
+}
+var LINK_DIR = ".wholestack";
+var LINK_FILE = "project.json";
+function readProjectLink(dir) {
+  try {
+    const raw = readFileSync(join(dir, LINK_DIR, LINK_FILE), "utf8");
+    const json = JSON.parse(raw);
+    return json && typeof json === "object" ? json : null;
+  } catch {
+    return null;
+  }
+}
+function writeProjectLink(dir, link) {
+  try {
+    const prev = readProjectLink(dir) ?? {};
+    mkdirSync(join(dir, LINK_DIR), { recursive: true });
+    writeFileSync(
+      join(dir, LINK_DIR, LINK_FILE),
+      JSON.stringify({ ...prev, ...link }, null, 2) + "\n"
+    );
+  } catch {
+  }
+}
+function writeWorkingTree(destDir, files) {
+  const root = resolve(destDir);
+  let written = 0;
+  for (const f of files) {
+    if (!f?.path || typeof f.content !== "string") continue;
+    const rel = pathNormalize(f.path).replace(/^(\.\.(\/|\\|$))+/, "").replace(/^\/+/, "");
+    const full = resolve(root, rel);
+    if (full !== root && !full.startsWith(root + sep)) continue;
+    mkdirSync(dirname(full), { recursive: true });
+    writeFileSync(full, f.content);
+    written += 1;
+  }
+  return written;
+}
+var PUSH_IGNORE = [
+  "**/node_modules/**",
+  "**/.next/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/.turbo/**",
+  "**/.wholestack/**",
+  "**/.zeta-g/**",
+  "**/*.lock",
+  "**/pnpm-lock.yaml",
+  "**/.env*"
+];
+var MAX_PUSH_FILES = 2e3;
+var MAX_FILE_BYTES = 512 * 1024;
+async function collectLocalFiles(dir) {
+  const paths = await fg("**/*", {
+    cwd: dir,
+    dot: true,
+    onlyFiles: true,
+    ignore: PUSH_IGNORE,
+    followSymbolicLinks: false
+  });
+  const files = [];
+  let skipped = 0;
+  for (const rel of paths.slice(0, MAX_PUSH_FILES)) {
+    try {
+      const buf = readFileSync(join(dir, rel));
+      if (buf.length > MAX_FILE_BYTES || buf.includes(0)) {
+        skipped += 1;
+        continue;
+      }
+      files.push({ path: rel.split(sep).join("/"), content: buf.toString("utf8") });
+    } catch {
+      skipped += 1;
+    }
+  }
+  skipped += Math.max(0, paths.length - MAX_PUSH_FILES);
+  return { files, skipped };
+}
+
 // src/prover.ts
 import { spawn as spawn2 } from "child_process";
-import { join as join2 } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
 
 // src/zeta-engine.ts
 import { spawn } from "child_process";
 import { tmpdir } from "os";
-import { join, dirname, normalize as pathNormalize, resolve, sep } from "path";
-import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join as join2, dirname as dirname2, normalize as pathNormalize2, resolve as resolve2, sep as sep2 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { fileURLToPath } from "url";
 function normalize(result) {
   const files = Array.isArray(result.files) ? result.files : [];
@@ -651,25 +784,26 @@ async function deliverBuild(zetaApiUrl, buildId, destDir, onPhase) {
   }
   const data = await resp.json().catch(() => ({}));
   const files = Array.isArray(data.files) ? data.files : [];
-  const root = resolve(destDir);
+  const root = resolve2(destDir);
   let written = 0;
   for (const f of files) {
     if (!f?.path || typeof f.content !== "string") continue;
-    const rel = pathNormalize(f.path).replace(/^(\.\.(\/|\\|$))+/, "");
-    const full = resolve(root, rel);
-    if (full !== root && !full.startsWith(root + sep)) continue;
-    mkdirSync(dirname(full), { recursive: true });
-    writeFileSync(full, f.content);
+    const rel = pathNormalize2(f.path).replace(/^(\.\.(\/|\\|$))+/, "");
+    const full = resolve2(root, rel);
+    if (full !== root && !full.startsWith(root + sep2)) continue;
+    mkdirSync2(dirname2(full), { recursive: true });
+    writeFileSync2(full, f.content);
     written += 1;
     onPhase?.(`wrote ${rel}`);
   }
+  writeProjectLink(root, { buildId });
   return { ok: true, written, dir: root };
 }
 function findRepoRoot(start) {
-  let dir = start ?? dirname(fileURLToPath(import.meta.url));
+  let dir = start ?? dirname2(fileURLToPath(import.meta.url));
   for (let i = 0; i < 12; i++) {
-    if (existsSync(join(dir, "scripts", "zeta-build-worker.mts"))) return dir;
-    const up = dirname(dir);
+    if (existsSync2(join2(dir, "scripts", "zeta-build-worker.mts"))) return dir;
+    const up = dirname2(dir);
     if (up === dir) break;
     dir = up;
   }
@@ -689,9 +823,9 @@ async function localBuild(body, onPhase, repoRoot) {
       error: "local build needs the ZETA monorepo (scripts/zeta-build-worker.mts not found). Run from inside the repo, or use the http engine (--zeta-url)."
     };
   }
-  const worker = join(root, "scripts", "zeta-build-worker.mts");
+  const worker = join2(root, "scripts", "zeta-build-worker.mts");
   const buildId = `zeta-build-${Date.now().toString(36)}-${Math.floor(performance.now())}`;
-  const projectDir = join(tmpdir(), buildId);
+  const projectDir = join2(tmpdir(), buildId);
   const ideaB64 = Buffer.from(body.idea, "utf8").toString("base64");
   const args = [
     "--import",
@@ -753,11 +887,11 @@ var PROPERTY_KINDS = [
 function resolveProver(repoRoot) {
   const root = repoRoot ?? findRepoRoot();
   if (!root) return null;
-  const base = join2(root, "packages", "shipgate-contract-prover");
-  const dist = join2(base, "dist", "cli.js");
-  if (existsSync2(dist)) return { nodeArgs: [dist] };
-  const src = join2(base, "src", "cli.ts");
-  if (existsSync2(src)) return { nodeArgs: ["--import", "tsx", src] };
+  const base = join3(root, "packages", "shipgate-contract-prover");
+  const dist = join3(base, "dist", "cli.js");
+  if (existsSync3(dist)) return { nodeArgs: [dist] };
+  const src = join3(base, "src", "cli.ts");
+  if (existsSync3(src)) return { nodeArgs: ["--import", "tsx", src] };
   return null;
 }
 function runProver(proverArgs, opts) {
@@ -802,8 +936,8 @@ ${e.message}` });
 // src/app-runner.ts
 import { spawn as spawn3, spawnSync } from "child_process";
 import { readFile } from "fs/promises";
-import { existsSync as existsSync3, readFileSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4, dirname as dirname3 } from "path";
 var running = [];
 function killRunningApps() {
   for (const a of running.splice(0)) {
@@ -816,8 +950,8 @@ function killRunningApps() {
 var URL_RE = /(https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0)(?::\d+)?[^\s)]*)/i;
 var FATAL_RE = /(Error:|error TS\d+|Cannot find module|EADDRINUSE|Failed to compile|SyntaxError|Module not found|exited with)/i;
 async function detectRun(dir) {
-  const pkgPath = join3(dir, "package.json");
-  if (!existsSync3(pkgPath)) {
+  const pkgPath = join4(dir, "package.json");
+  if (!existsSync4(pkgPath)) {
     return { error: `no package.json in ${dir} \u2014 not a runnable app directory` };
   }
   let scripts = {};
@@ -827,7 +961,7 @@ async function detectRun(dir) {
   } catch (e) {
     return { error: `unreadable package.json: ${e.message}` };
   }
-  const pm = existsSync3(join3(dir, "pnpm-lock.yaml")) ? "pnpm" : existsSync3(join3(dir, "yarn.lock")) ? "yarn" : "npm";
+  const pm = existsSync4(join4(dir, "pnpm-lock.yaml")) ? "pnpm" : existsSync4(join4(dir, "yarn.lock")) ? "yarn" : "npm";
   for (const s of ["dev", "start", "serve"]) {
     if (scripts[s]) return { command: pm, args: ["run", s], reason: `${pm} run ${s}` };
   }
@@ -844,44 +978,44 @@ function pnpmAvailable() {
   return _pnpmOnPath;
 }
 function installPmFor(dir) {
-  if (existsSync3(join3(dir, "yarn.lock"))) return "yarn";
-  if (existsSync3(join3(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync4(join4(dir, "yarn.lock"))) return "yarn";
+  if (existsSync4(join4(dir, "pnpm-lock.yaml"))) return "pnpm";
   return pnpmAvailable() ? "pnpm" : "npm";
 }
 function ensureNpmrc(dir, lines) {
   try {
-    const npmrc = join3(dir, ".npmrc");
-    const prev = existsSync3(npmrc) ? readFileSync(npmrc, "utf8") : "";
+    const npmrc = join4(dir, ".npmrc");
+    const prev = existsSync4(npmrc) ? readFileSync2(npmrc, "utf8") : "";
     const missing = lines.filter((l) => !prev.includes(l.split("=")[0]));
     if (missing.length === 0) return;
-    const sep3 = prev && !prev.endsWith("\n") ? "\n" : "";
-    writeFileSync2(npmrc, prev + sep3 + missing.join("\n") + "\n");
+    const sep4 = prev && !prev.endsWith("\n") ? "\n" : "";
+    writeFileSync3(npmrc, prev + sep4 + missing.join("\n") + "\n");
   } catch {
   }
 }
 function isolateFromWorkspace(dir) {
-  if (existsSync3(join3(dir, "pnpm-workspace.yaml"))) return;
-  let cur = dirname2(dir);
+  if (existsSync4(join4(dir, "pnpm-workspace.yaml"))) return;
+  let cur = dirname3(dir);
   let nested = false;
   for (let i = 0; i < 12; i++) {
-    if (existsSync3(join3(cur, "pnpm-workspace.yaml"))) {
+    if (existsSync4(join4(cur, "pnpm-workspace.yaml"))) {
       nested = true;
       break;
     }
-    const up = dirname2(cur);
+    const up = dirname3(cur);
     if (up === cur) break;
     cur = up;
   }
   if (!nested) return;
   try {
-    writeFileSync2(join3(dir, "pnpm-workspace.yaml"), "packages:\n  - .\n");
+    writeFileSync3(join4(dir, "pnpm-workspace.yaml"), "packages:\n  - .\n");
     ensureNpmrc(dir, ["ignore-workspace-root-check=true"]);
   } catch {
   }
 }
 function installDeps(dir, onLog, signal) {
   const pm = installPmFor(dir);
-  if (pm === "pnpm" && !existsSync3(join3(dir, "pnpm-lock.yaml"))) {
+  if (pm === "pnpm" && !existsSync4(join4(dir, "pnpm-lock.yaml"))) {
     ensureNpmrc(dir, ["shamefully-hoist=true", "prefer-offline=true"]);
   }
   const args = pm === "pnpm" ? (
@@ -891,7 +1025,7 @@ function installDeps(dir, onLog, signal) {
     ["install", "--ignore-workspace", "--no-frozen-lockfile", "--prefer-offline", "--config.confirmModulesPurge=false"]
   ) : pm === "yarn" ? ["install"] : ["install", "--legacy-peer-deps", "--no-audit", "--no-fund", "--prefer-offline"];
   onLog?.(`installing dependencies (${pm})\u2026`);
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const child = spawn3(pm, args, { cwd: dir, shell: false, env: process.env });
     let log = "";
     const timer = setTimeout(() => child.kill("SIGKILL"), 8 * 6e4);
@@ -904,18 +1038,18 @@ function installDeps(dir, onLog, signal) {
     child.stderr.on("data", sink);
     child.on("error", (e) => {
       clearTimeout(timer);
-      resolve3({ ok: false, log: log + `
+      resolve4({ ok: false, log: log + `
 ${e.message}` });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
       signal?.removeEventListener("abort", onAbort);
-      resolve3({ ok: code === 0, log: log.slice(-4e3) });
+      resolve4({ ok: code === 0, log: log.slice(-4e3) });
     });
   });
 }
 async function runApp(dir, opts = {}) {
-  if (!existsSync3(join3(dir, "node_modules"))) {
+  if (!existsSync4(join4(dir, "node_modules"))) {
     isolateFromWorkspace(dir);
     const inst = await installDeps(dir, void 0, opts.signal);
     if (!inst.ok) {
@@ -929,7 +1063,7 @@ async function runApp(dir, opts = {}) {
   let command;
   let cmdArgs;
   if (opts.script) {
-    const pm = existsSync3(join3(dir, "pnpm-lock.yaml")) ? "pnpm" : "npm";
+    const pm = existsSync4(join4(dir, "pnpm-lock.yaml")) ? "pnpm" : "npm";
     command = pm;
     cmdArgs = ["run", opts.script];
   } else {
@@ -940,7 +1074,7 @@ async function runApp(dir, opts = {}) {
   }
   const timeoutMs = opts.timeoutMs ?? 9e4;
   const child = spawn3(command, cmdArgs, { cwd: dir, shell: false, env: process.env });
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let log = "";
     let settled = false;
     const finish = (r) => {
@@ -948,7 +1082,7 @@ async function runApp(dir, opts = {}) {
       settled = true;
       clearTimeout(timer);
       opts.signal?.removeEventListener("abort", onAbort);
-      resolve3(r);
+      resolve4(r);
     };
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
@@ -1091,13 +1225,13 @@ import { tool } from "ai";
 import { z } from "zod";
 import { spawn as spawn5 } from "child_process";
 import { readFile as readFile2, writeFile, mkdir, readdir, stat } from "fs/promises";
-import { resolve as resolve2, dirname as dirname3, relative, join as join4, sep as sep2 } from "path";
-import fg from "fast-glob";
+import { resolve as resolve3, dirname as dirname4, relative, join as join5, sep as sep3 } from "path";
+import fg2 from "fast-glob";
 var IGNORE = ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/.next/**", "**/build/**", "**/.turbo/**"];
 function inside(ctx, p) {
-  const abs = resolve2(ctx.cwd, p);
+  const abs = resolve3(ctx.cwd, p);
   const rel = relative(ctx.cwd, abs);
-  if (rel === ".." || rel.startsWith(".." + sep2)) {
+  if (rel === ".." || rel.startsWith(".." + sep3)) {
     throw new Error(`path "${p}" escapes the workspace root`);
   }
   return abs;
@@ -1141,9 +1275,9 @@ ${CWD_MARK}:`);
         const p = (nl >= 0 ? rest.slice(0, nl) : rest).trim();
         out = out.slice(0, idx);
         if (p) {
-          const cand = resolve2(p);
+          const cand = resolve3(p);
           const rel = relative(opts.root, cand);
-          nextCwd = rel === "" || rel !== ".." && !rel.startsWith(".." + sep2) ? cand : opts.root;
+          nextCwd = rel === "" || rel !== ".." && !rel.startsWith(".." + sep3) ? cand : opts.root;
         }
       }
       res({ code: code ?? 1, out, cwd: nextCwd });
@@ -1180,7 +1314,7 @@ async function search(ctx, pattern, searchPath, globPat, ignoreCase, maxResults,
   });
   if (viaRg) return viaRg;
   const re = new RegExp(pattern, ignoreCase ? "i" : "");
-  const files = await fg(fgPat, {
+  const files = await fg2(fgPat, {
     cwd: abs,
     ignore: IGNORE,
     onlyFiles: true,
@@ -1298,7 +1432,7 @@ function buildTools(ctx) {
             }
           }
           if (keep !== false && viaHosted && result.ok && result.buildId && !result.paywalled) {
-            const dest = join4(ctx.cwd, `zeta-${String(result.buildId).slice(-8)}`);
+            const dest = join5(ctx.cwd, `zeta-${String(result.buildId).slice(-8)}`);
             line(c.dim("    \u21B3 saving your code\u2026"));
             const delivered = await deliverBuild(
               ctx.zetaApiUrl,
@@ -1414,7 +1548,7 @@ function buildTools(ctx) {
           ctx.checkpoints?.begin();
           ctx.checkpoints?.capture(abs, before);
           ctx.checkpoints?.commit(before == null ? `create ${path}` : `write ${path}`);
-          await mkdir(dirname3(abs), { recursive: true });
+          await mkdir(dirname4(abs), { recursive: true });
           await writeFile(abs, content, "utf8");
           toolLine("write_file", c.dim(path));
           return { ok: true, path, bytes: Buffer.byteLength(content) };
@@ -1546,7 +1680,7 @@ function buildTools(ctx) {
           const names = await readdir(abs);
           const entries = await Promise.all(
             names.map(async (n) => {
-              const s = await stat(join4(abs, n)).catch(() => null);
+              const s = await stat(join5(abs, n)).catch(() => null);
               return { name: n, dir: s?.isDirectory() ?? false };
             })
           );
@@ -1565,7 +1699,7 @@ function buildTools(ctx) {
       execute: async ({ pattern, path }) => {
         try {
           const abs = inside(ctx, path);
-          const files = await fg(pattern, {
+          const files = await fg2(pattern, {
             cwd: abs,
             ignore: IGNORE,
             onlyFiles: true,
@@ -1721,23 +1855,23 @@ function buildTools(ctx) {
 }
 
 // src/config.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync4, chmodSync, renameSync } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, existsSync as existsSync5, chmodSync, renameSync } from "fs";
 import { homedir } from "os";
-import { join as join5 } from "path";
-var LEGACY_DIR = join5(homedir(), ".zeta-g");
-var STATE_DIR = join5(homedir(), ".wholestack");
+import { join as join6 } from "path";
+var LEGACY_DIR = join6(homedir(), ".zeta-g");
+var STATE_DIR = join6(homedir(), ".wholestack");
 try {
-  if (existsSync4(LEGACY_DIR) && !existsSync4(STATE_DIR)) renameSync(LEGACY_DIR, STATE_DIR);
+  if (existsSync5(LEGACY_DIR) && !existsSync5(STATE_DIR)) renameSync(LEGACY_DIR, STATE_DIR);
 } catch {
 }
 function stateDir() {
   return STATE_DIR;
 }
 function projectDirs(cwd) {
-  return [join5(cwd, ".wholestack"), join5(cwd, ".zeta-g")];
+  return [join6(cwd, ".wholestack"), join6(cwd, ".zeta-g")];
 }
 var CONFIG_DIR = STATE_DIR;
-var CONFIG_PATH = join5(CONFIG_DIR, "config.json");
+var CONFIG_PATH = join6(CONFIG_DIR, "config.json");
 function parseDotenv(text) {
   const out = {};
   for (const raw of text.split("\n")) {
@@ -1760,16 +1894,16 @@ function fill(src) {
   }
 }
 function loadStoredEnv() {
-  const localEnv = join5(process.cwd(), ".env");
-  if (existsSync4(localEnv)) {
+  const localEnv = join6(process.cwd(), ".env");
+  if (existsSync5(localEnv)) {
     try {
-      fill(parseDotenv(readFileSync2(localEnv, "utf8")));
+      fill(parseDotenv(readFileSync3(localEnv, "utf8")));
     } catch {
     }
   }
-  if (existsSync4(CONFIG_PATH)) {
+  if (existsSync5(CONFIG_PATH)) {
     try {
-      const json = JSON.parse(readFileSync2(CONFIG_PATH, "utf8"));
+      const json = JSON.parse(readFileSync3(CONFIG_PATH, "utf8"));
       const flat = {};
       for (const [k, v] of Object.entries(json)) if (typeof v === "string") flat[k] = v;
       fill(flat);
@@ -1778,25 +1912,25 @@ function loadStoredEnv() {
   }
 }
 function saveKey(name, value) {
-  mkdirSync2(CONFIG_DIR, { recursive: true });
+  mkdirSync3(CONFIG_DIR, { recursive: true });
   let current = {};
-  if (existsSync4(CONFIG_PATH)) {
+  if (existsSync5(CONFIG_PATH)) {
     try {
-      current = JSON.parse(readFileSync2(CONFIG_PATH, "utf8"));
+      current = JSON.parse(readFileSync3(CONFIG_PATH, "utf8"));
     } catch {
       current = {};
     }
   }
   current[name] = value;
-  writeFileSync3(CONFIG_PATH, JSON.stringify(current, null, 2) + "\n", { mode: 384 });
+  writeFileSync4(CONFIG_PATH, JSON.stringify(current, null, 2) + "\n", { mode: 384 });
   chmodSync(CONFIG_PATH, 384);
   return CONFIG_PATH;
 }
 
 // src/hooks.ts
 import { spawn as spawn6 } from "child_process";
-import { readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
+import { join as join7 } from "path";
 var HOOK_TIMEOUT_MS = 15e3;
 function runOne(def, event, payload, cwd) {
   return new Promise((res) => {
@@ -1882,12 +2016,12 @@ function mergeHookSets(...sets) {
   return out;
 }
 function loadHookFiles(cwd) {
-  const files = [join6(stateDir(), "hooks.json"), ...projectDirs(cwd).map((d) => join6(d, "hooks.json"))];
+  const files = [join7(stateDir(), "hooks.json"), ...projectDirs(cwd).map((d) => join7(d, "hooks.json"))];
   const sets = [];
   for (const f of files) {
-    if (!existsSync5(f)) continue;
+    if (!existsSync6(f)) continue;
     try {
-      sets.push(JSON.parse(readFileSync3(f, "utf8")));
+      sets.push(JSON.parse(readFileSync4(f, "utf8")));
     } catch {
     }
   }
@@ -3019,24 +3153,24 @@ import {
 // src/markdown.ts
 var useColor2 = process.stdout.isTTY && !process.env.NO_COLOR;
 var truecolor = /truecolor|24bit/i.test(process.env.COLORTERM ?? "");
-function fg2(r, g, b, c256) {
+function fg3(r, g, b, c256) {
   if (!useColor2) return "";
   return truecolor ? `\x1B[38;2;${r};${g};${b}m` : `\x1B[38;5;${c256}m`;
 }
 var RESET = useColor2 ? "\x1B[0m" : "";
 var SY = {
-  keyword: fg2(198, 120, 221, 176),
+  keyword: fg3(198, 120, 221, 176),
   // violet
-  string: fg2(152, 195, 121, 114),
+  string: fg3(152, 195, 121, 114),
   // green
-  number: fg2(209, 154, 102, 173),
+  number: fg3(209, 154, 102, 173),
   // orange
-  comment: fg2(106, 115, 125, 244),
+  comment: fg3(106, 115, 125, 244),
   // gray
-  fn: fg2(97, 175, 239, 75),
+  fn: fg3(97, 175, 239, 75),
   // blue
-  punct: fg2(160, 168, 180, 247),
-  type: fg2(229, 192, 123, 180)
+  punct: fg3(160, 168, 180, 247),
+  type: fg3(229, 192, 123, 180)
   // yellow
 };
 var KEYWORDS = /\b(const|let|var|function|return|if|else|for|while|switch|case|break|continue|new|class|extends|import|export|from|default|async|await|try|catch|finally|throw|typeof|instanceof|in|of|this|super|yield|static|public|private|protected|readonly|interface|type|enum|namespace|implements|as|void|null|undefined|true|false|def|elif|lambda|pass|with|fn|let|mut|pub|use|struct|impl|match|where|select|insert|update|delete|create|table|primary|key|foreign|references|contract|mapping|address|uint256|require|emit|modifier|memory|storage|payable)\b/g;
@@ -3085,7 +3219,7 @@ function highlightLine(src, _lang) {
 function inline(s) {
   if (!useColor2) return s.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)");
   let out = s;
-  out = out.replace(/`([^`]+)`/g, (_m, code) => fg2(229, 192, 123, 180) + code + RESET);
+  out = out.replace(/`([^`]+)`/g, (_m, code) => fg3(229, 192, 123, 180) + code + RESET);
   out = out.replace(/\*\*([^*]+)\*\*/g, (_m, t) => "\x1B[1m" + t + "\x1B[22m");
   out = out.replace(/(^|[^*])\*([^*]+)\*/g, (_m, p, t) => p + "\x1B[3m" + t + "\x1B[23m");
   out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, t, u) => "\x1B[4m" + t + "\x1B[24m" + c.dim(` (${u})`));
@@ -3880,16 +4014,16 @@ function announcePlanMode() {
 
 // src/memory.ts
 import { readFile as readFile3, stat as stat2 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { join as join7, dirname as dirname4 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { join as join8, dirname as dirname5 } from "path";
 var FILE_NAMES = ["ZETA.md", "AGENTS.md", "CLAUDE.md"];
 var MAX_TOTAL = 14e3;
 var MAX_PER_FILE = 8e3;
 function repoRootFrom(start) {
   let dir = start;
   for (let i = 0; i < 24; i++) {
-    if (existsSync6(join7(dir, ".git"))) return dir;
-    const up = dirname4(dir);
+    if (existsSync7(join8(dir, ".git"))) return dir;
+    const up = dirname5(dir);
     if (up === dir) break;
     dir = up;
   }
@@ -3906,22 +4040,22 @@ async function readBounded(path, limit) {
 }
 async function loadProjectMemory(cwd) {
   const candidates = [];
-  const globalFile = join7(stateDir(), "ZETA.md");
-  if (existsSync6(globalFile)) candidates.push(globalFile);
+  const globalFile = join8(stateDir(), "ZETA.md");
+  if (existsSync7(globalFile)) candidates.push(globalFile);
   const root = repoRootFrom(cwd);
   const chain = [];
   let dir = cwd;
   for (let i = 0; i < 24; i++) {
     chain.unshift(dir);
     if (dir === root) break;
-    const up = dirname4(dir);
+    const up = dirname5(dir);
     if (up === dir) break;
     dir = up;
   }
   for (const d of chain) {
     for (const name of FILE_NAMES) {
-      const p = join7(d, name);
-      if (existsSync6(p) && !candidates.includes(p)) {
+      const p = join8(d, name);
+      if (existsSync7(p) && !candidates.includes(p)) {
         candidates.push(p);
         break;
       }
@@ -3948,20 +4082,20 @@ ${r.text.trim()}
 // src/session.ts
 import {
   appendFileSync,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync4,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync5,
   readdirSync,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   statSync
 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { randomUUID } from "crypto";
-var SESSIONS_DIR = join8(stateDir(), "sessions");
+var SESSIONS_DIR = join9(stateDir(), "sessions");
 function ensureDir() {
-  mkdirSync3(SESSIONS_DIR, { recursive: true });
+  mkdirSync4(SESSIONS_DIR, { recursive: true });
 }
 function fileFor(id) {
-  return join8(SESSIONS_DIR, `${id}.jsonl`);
+  return join9(SESSIONS_DIR, `${id}.jsonl`);
 }
 function previewOf(message) {
   if (message.role !== "user") return "";
@@ -3992,8 +4126,8 @@ var Session = class _Session {
   /** Reopen an existing session and replay its messages. */
   static resume(id) {
     const path = fileFor(id);
-    if (!existsSync7(path)) return null;
-    const lines = readFileSync4(path, "utf8").split("\n").filter(Boolean);
+    if (!existsSync8(path)) return null;
+    const lines = readFileSync5(path, "utf8").split("\n").filter(Boolean);
     let meta = null;
     const messages = [];
     for (const l of lines) {
@@ -4016,16 +4150,16 @@ var Session = class _Session {
   }
   /** List sessions newest-first, with a preview of the first user message. */
   static list(limit = 30, cwd) {
-    if (!existsSync7(SESSIONS_DIR)) return [];
+    if (!existsSync8(SESSIONS_DIR)) return [];
     const out = [];
     for (const name of readdirSync(SESSIONS_DIR)) {
       if (!name.endsWith(".jsonl")) continue;
-      const path = join8(SESSIONS_DIR, name);
+      const path = join9(SESSIONS_DIR, name);
       let meta = null;
       let preview = "";
       let turns = 0;
       try {
-        const lines = readFileSync4(path, "utf8").split("\n").filter(Boolean);
+        const lines = readFileSync5(path, "utf8").split("\n").filter(Boolean);
         for (const l of lines) {
           const rec = JSON.parse(l);
           if (rec.kind === "meta") meta = { id: rec.id, cwd: rec.cwd, model: rec.model, startedAt: rec.startedAt };
@@ -4058,8 +4192,8 @@ var Session = class _Session {
 };
 
 // src/commands.ts
-import { writeFileSync as writeFileSync4, existsSync as existsSync8, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
-import { join as join9 } from "path";
+import { writeFileSync as writeFileSync5, existsSync as existsSync9, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
+import { join as join10 } from "path";
 
 // src/git.ts
 import { execFileSync } from "child_process";
@@ -4385,13 +4519,13 @@ var BUILTINS = [
     summary: "create a ZETA.md memory scaffold here",
     source: "builtin",
     run: (ctx) => {
-      const path = join9(ctx.cwd, "ZETA.md");
-      if (existsSync8(path)) {
+      const path = join10(ctx.cwd, "ZETA.md");
+      if (existsSync9(path)) {
         ctx.print("  " + c.yellow(`ZETA.md already exists at ${path}`));
         return { type: "handled" };
       }
       try {
-        writeFileSync4(path, ZETA_MD_TEMPLATE, "utf8");
+        writeFileSync5(path, ZETA_MD_TEMPLATE, "utf8");
         ctx.print("  " + c.green(`\u2713 wrote ${path}`) + c.dim("  \xB7 edit it, then /clear to reload"));
       } catch (e) {
         ctx.print("  " + c.red(e.message));
@@ -4588,12 +4722,12 @@ function parseCustom(name, body, source = "custom") {
   };
 }
 function loadMdCommands(dir, source) {
-  if (!existsSync8(dir)) return [];
+  if (!existsSync9(dir)) return [];
   const cmds = [];
   for (const file of readdirSync2(dir)) {
     if (!file.endsWith(".md")) continue;
     try {
-      const body = readFileSync5(join9(dir, file), "utf8");
+      const body = readFileSync6(join10(dir, file), "utf8");
       cmds.push(parseCustom(file.replace(/\.md$/, ""), body, source));
     } catch {
     }
@@ -4629,7 +4763,7 @@ var CommandRegistry = class {
   }
   /** Load *.md commands from ~/.wholestack/commands and <cwd>/.wholestack/commands (or legacy .zeta-g/). */
   loadCustom(cwd) {
-    const dirs = [join9(stateDir(), "commands"), ...projectDirs(cwd).map((d) => join9(d, "commands"))];
+    const dirs = [join10(stateDir(), "commands"), ...projectDirs(cwd).map((d) => join10(d, "commands"))];
     for (const dir of dirs) {
       for (const cmd of loadMdCommands(dir, "custom")) this.register(cmd);
     }
@@ -4649,16 +4783,16 @@ var CommandRegistry = class {
 };
 
 // src/plugins.ts
-import { readFileSync as readFileSync6, existsSync as existsSync9, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync7, existsSync as existsSync10, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join11 } from "path";
 function pluginRoots(cwd) {
-  return [join10(stateDir(), "plugins"), ...projectDirs(cwd).map((d) => join10(d, "plugins"))];
+  return [join11(stateDir(), "plugins"), ...projectDirs(cwd).map((d) => join11(d, "plugins"))];
 }
 function resolveSystemPrompt(dir, value) {
-  const asFile = join10(dir, value);
-  if (value.length < 200 && existsSync9(asFile)) {
+  const asFile = join11(dir, value);
+  if (value.length < 200 && existsSync10(asFile)) {
     try {
-      return readFileSync6(asFile, "utf8").trim();
+      return readFileSync7(asFile, "utf8").trim();
     } catch {
       return "";
     }
@@ -4677,9 +4811,9 @@ function loadPlugins(cwd) {
   const systemBlocks = [];
   const hookSets = [];
   for (const root of pluginRoots(cwd)) {
-    if (!existsSync9(root)) continue;
+    if (!existsSync10(root)) continue;
     for (const entry of readdirSync3(root)) {
-      const dir = join10(root, entry);
+      const dir = join11(root, entry);
       let info = null;
       try {
         info = statSync2(dir);
@@ -4687,10 +4821,10 @@ function loadPlugins(cwd) {
         continue;
       }
       if (!info.isDirectory()) continue;
-      const manifestPath = join10(dir, "zeta-plugin.json");
-      if (!existsSync9(manifestPath)) continue;
+      const manifestPath = join11(dir, "zeta-plugin.json");
+      if (!existsSync10(manifestPath)) continue;
       try {
-        const manifest = JSON.parse(readFileSync6(manifestPath, "utf8"));
+        const manifest = JSON.parse(readFileSync7(manifestPath, "utf8"));
         const name = manifest.name ?? entry;
         if (manifest.systemPrompt) {
           const text = resolveSystemPrompt(dir, manifest.systemPrompt);
@@ -4698,7 +4832,7 @@ function loadPlugins(cwd) {
 ${text}
 </plugin>`);
         }
-        const cmdDir = join10(dir, manifest.commandsDir ?? "commands");
+        const cmdDir = join11(dir, manifest.commandsDir ?? "commands");
         result.commands.push(...loadMdCommands(cmdDir, name));
         if (manifest.mcpServers) Object.assign(result.mcpServers, manifest.mcpServers);
         if (manifest.hooks) hookSets.push(tagHooks(manifest.hooks, name));
@@ -4726,14 +4860,14 @@ import { dynamicTool, jsonSchema } from "ai";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { readFileSync as readFileSync7, existsSync as existsSync10 } from "fs";
-import { join as join11, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync11 } from "fs";
+import { join as join12, dirname as dirname6 } from "path";
 function isHttp(c2) {
   return typeof c2.url === "string";
 }
 function readConfigFile(path) {
   try {
-    const json = JSON.parse(readFileSync7(path, "utf8"));
+    const json = JSON.parse(readFileSync8(path, "utf8"));
     return json.mcpServers ?? {};
   } catch {
     return {};
@@ -4741,28 +4875,28 @@ function readConfigFile(path) {
 }
 function discoverConfigs(cwd) {
   const merged = {};
-  const global = join11(stateDir(), "mcp.json");
-  if (existsSync10(global)) Object.assign(merged, readConfigFile(global));
+  const global = join12(stateDir(), "mcp.json");
+  if (existsSync11(global)) Object.assign(merged, readConfigFile(global));
   let dir = cwd;
   for (let i = 0; i < 24; i++) {
-    const p = join11(dir, ".mcp.json");
-    if (existsSync10(p)) {
+    const p = join12(dir, ".mcp.json");
+    if (existsSync11(p)) {
       Object.assign(merged, readConfigFile(p));
       break;
     }
-    const up = dirname5(dir);
+    const up = dirname6(dir);
     if (up === dir) break;
     dir = up;
   }
   return merged;
 }
 function withTimeout(p, ms, label) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const t = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
     p.then(
       (v) => {
         clearTimeout(t);
-        resolve3(v);
+        resolve4(v);
       },
       (e) => {
         clearTimeout(t);
@@ -4793,7 +4927,7 @@ async function loadMcpTools(opts) {
   await Promise.all(
     keys.map(async (key) => {
       const cfg = configs[key];
-      const client = new Client({ name: "wholestack", version: "0.5.5" }, { capabilities: {} });
+      const client = new Client({ name: "wholestack", version: "0.5.6" }, { capabilities: {} });
       try {
         const transport = isHttp(cfg) ? new StreamableHTTPClientTransport(new URL(cfg.url), {
           requestInit: cfg.headers ? { headers: cfg.headers } : void 0
@@ -5003,13 +5137,13 @@ function buildWebTools() {
 import { createInterface } from "readline/promises";
 import { emitKeypressEvents } from "readline";
 import { stdin, stdout } from "process";
-import { readFileSync as readFileSync8, appendFileSync as appendFileSync2, mkdirSync as mkdirSync4, existsSync as existsSync11, readdirSync as readdirSync4 } from "fs";
-import { join as join12, dirname as dirname6, basename } from "path";
-var HISTORY_FILE = join12(stateDir(), "history");
+import { readFileSync as readFileSync9, appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, existsSync as existsSync12, readdirSync as readdirSync4 } from "fs";
+import { join as join13, dirname as dirname7, basename } from "path";
+var HISTORY_FILE = join13(stateDir(), "history");
 var HISTORY_MAX = 1e3;
 function loadHistory() {
   try {
-    return readFileSync8(HISTORY_FILE, "utf8").split("\n").filter(Boolean).slice(-HISTORY_MAX);
+    return readFileSync9(HISTORY_FILE, "utf8").split("\n").filter(Boolean).slice(-HISTORY_MAX);
   } catch {
     return [];
   }
@@ -5045,12 +5179,12 @@ var InputController = class {
     const at = line2.lastIndexOf("@");
     if (at >= 0 && at >= line2.lastIndexOf(" ")) {
       const partial = line2.slice(at + 1);
-      const dir = partial.includes("/") ? dirname6(partial) : ".";
+      const dir = partial.includes("/") ? dirname7(partial) : ".";
       const base = basename(partial);
       try {
         const entries = readdirSync4(dir, { withFileTypes: true });
         const hits = entries.filter((e) => e.name.startsWith(base)).map((e) => {
-          const full = dir === "." ? e.name : join12(dir, e.name);
+          const full = dir === "." ? e.name : join13(dir, e.name);
           return line2.slice(0, at + 1) + full + (e.isDirectory() ? "/" : "");
         });
         if (hits.length) return [hits, line2];
@@ -5155,7 +5289,7 @@ var InputController = class {
       prevCaretR = caret.r;
     };
     let prevCaretR = 0;
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       emitKeypressEvents(stdin);
       const watching = this.activeWatch;
       if (watching) this.stopWatch();
@@ -5179,7 +5313,7 @@ var InputController = class {
         stdout.write("\x1B[" + Math.max(1, down) + "B\r\n");
         this.rl.resume();
         if (watching) this.startWatch(watching);
-        resolve3(val);
+        resolve4(val);
       };
       const replaceLine = (s) => {
         buf = s;
@@ -5311,8 +5445,8 @@ var InputController = class {
   }
   saveHistory(entry) {
     try {
-      mkdirSync4(dirname6(HISTORY_FILE), { recursive: true });
-      if (!existsSync11(HISTORY_FILE) || entry !== loadHistory().slice(-1)[0]) {
+      mkdirSync5(dirname7(HISTORY_FILE), { recursive: true });
+      if (!existsSync12(HISTORY_FILE) || entry !== loadHistory().slice(-1)[0]) {
         appendFileSync2(HISTORY_FILE, entry.replace(/\n/g, " ") + "\n", "utf8");
       }
     } catch {
@@ -5401,6 +5535,14 @@ export {
   diffStat,
   renderEditDiff,
   renderNewFileDiff,
+  listProjects,
+  pullWorkingTree,
+  pushWorkingTree,
+  openBuildInEditor,
+  readProjectLink,
+  writeProjectLink,
+  writeWorkingTree,
+  collectLocalFiles,
   PROPERTY_KINDS,
   runProver,
   killRunningApps,

package/dist/cli.js

@@ -12,9 +12,11 @@ import {
   buildTools,
   buildWebTools,
   c,
+  collectLocalFiles,
   isPermissionMode,
   killRunningApps,
   line,
+  listProjects,
   loadHookFiles,
   loadMcpTools,
   loadPlugins,
@@ -23,6 +25,10 @@ import {
   mergeHookSets,
   modelContextWindow,
   modelLabel,
+  openBuildInEditor,
+  pullWorkingTree,
+  pushWorkingTree,
+  readProjectLink,
   resolveModel,
   resolveModelKey,
   runProver,
@@ -32,8 +38,10 @@ import {
   supportsThinking,
   tasks,
   userBox,
-  visionCapable
-} from "./chunk-7NZ77Q7Q.js";
+  visionCapable,
+  writeProjectLink,
+  writeWorkingTree
+} from "./chunk-K6MSDQJT.js";
 
 // src/cli.ts
 import { createInterface } from "readline/promises";
@@ -871,6 +879,12 @@ ${c.bold("Usage")}
   wholestack "build me a todo app" run one prompt and exit
   wholestack -m zeta-g1-max "..."  drive it with the most capable brain
 
+${c.bold("Projects")} ${c.dim("(one spine across terminal, dashboard and the web IDE)")}
+  wholestack projects              list your platform projects
+  wholestack pull <id> [dir]       download a project's working tree
+  wholestack push [dir]            sync local edits back to the web IDE
+  wholestack open [buildId]        open a generated build in the web IDE
+
 ${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 prove  <dir> <Contract> --property <k>  prove one invariant
@@ -1023,6 +1037,87 @@ async function runLogin(raw) {
   line(c.dim("  now just run `wholestack`."));
   return 0;
 }
+async function runProjectSubcommand(raw) {
+  const verb = raw[0];
+  if (verb !== "projects" && verb !== "pull" && verb !== "push" && verb !== "open") return null;
+  const base = webBaseUrl();
+  if (verb === "projects") {
+    const r2 = await listProjects(base);
+    if (!r2.ok) {
+      line(c.red(`  ${r2.error}`));
+      return 1;
+    }
+    if (!r2.projects?.length) {
+      line(c.dim('  no projects yet \u2014 build something (`wholestack "an idea"`) or create one in the web IDE.'));
+      return 0;
+    }
+    line();
+    for (const p of r2.projects) {
+      const when = p.updatedAt ? new Date(p.updatedAt).toISOString().slice(0, 10) : "";
+      line("  " + c.cyan(p.id) + "  " + c.bold(p.name) + (when ? c.dim(`  \xB7 ${when}`) : ""));
+      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>`));
+    return 0;
+  }
+  if (verb === "pull") {
+    const projectId = raw[1];
+    if (!projectId) {
+      line(c.red("  usage: wholestack pull <projectId> [dir]"));
+      return 1;
+    }
+    const r2 = await pullWorkingTree(base, projectId);
+    if (!r2.ok) {
+      line(c.red(`  ${r2.error}`));
+      return 1;
+    }
+    const dest = raw[2] ?? (r2.name ? r2.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") : projectId);
+    const written = writeWorkingTree(dest, r2.files ?? []);
+    writeProjectLink(dest, { projectId });
+    line(c.green(`  \u2713 pulled ${written} files`) + c.dim(` \u2192 ${dest}/`));
+    line(c.dim("  edit locally, then ") + c.cyan(`wholestack push ${dest === "." ? "" : dest}`).trimEnd() + c.dim(" to sync back to the web IDE."));
+    return 0;
+  }
+  if (verb === "push") {
+    const dir = raw[1] ?? ".";
+    const link = readProjectLink(dir);
+    const flagIdx = raw.indexOf("--project");
+    const projectId = (flagIdx >= 0 ? raw[flagIdx + 1] : void 0) ?? link?.projectId;
+    if (!projectId) {
+      line(c.red("  no linked project \u2014 pull first, or pass --project <id>."));
+      return 1;
+    }
+    const { files, skipped } = await collectLocalFiles(dir);
+    if (!files.length) {
+      line(c.red("  nothing to push (no readable text files found)."));
+      return 1;
+    }
+    const r2 = await pushWorkingTree(base, 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}`));
+    return 0;
+  }
+  const buildId = raw[1] ?? readProjectLink(".")?.buildId;
+  if (!buildId) {
+    line(c.red("  usage: wholestack open <buildId>  (or run it inside a delivered app dir)"));
+    return 1;
+  }
+  const r = await openBuildInEditor(base, 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}`}`));
+  return 0;
+}
 var EMPTY_PLUGINS = {
   plugins: [],
   systemText: "",
@@ -1051,6 +1146,8 @@ async function main() {
   if (loggedIn !== null) exit(loggedIn);
   const sub = await runSecuritySubcommand(rawArgs);
   if (sub !== null) exit(sub);
+  const proj = await runProjectSubcommand(rawArgs);
+  if (proj !== null) exit(proj);
   const args = parse(rawArgs);
   if (args.version) {
     line(`wholestack ${VERSION}`);

package/dist/index.js

@@ -49,7 +49,7 @@ import {
   resolveModelKey,
   severityRank,
   supportsThinking
-} from "./chunk-7NZ77Q7Q.js";
+} from "./chunk-K6MSDQJT.js";
 
 // src/prompts/template.ts
 var PLACEHOLDER = /\{\{([A-Za-z0-9_.]+)\}\}/g;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wholestack",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "description": "Wholestack — a pro-grade conversational terminal agent for the Wholestack codegen engine. Talk to it in plain language: it writes ISL, generates full-stack or Solidity apps, and proves them with ShipGate. Browser login, membership-gated builds, slash commands, sessions, plan mode, diffs, MCP, plugins.",
   "type": "module",
   "main": "./dist/index.js",