@aayambansal/squint 0.2.7 → 0.2.9

package/README.md

@@ -132,6 +132,7 @@ squint config set models.claude claude-sonnet-5
 squint config set autoDev true    # dev server starts with the TUI
 squint config set autoFix true    # errors auto-route back (max 2 tries)
 squint config set autoCheck false # skip the per-turn typecheck+lint pass
+squint config set autoReview true # big visual change → automatic self-critique
 squint config set theme ocean     # amber · ocean · moss · rose · mono
 squint config set bell false      # no bell on turn completion
 squint doctor                     # engines + Chrome + WebSocket check
@@ -149,6 +150,9 @@ squint doctor --probe             # run every engine end to end, verify auth act
 - **Problems**: findings from gates, the dev server, the runtime probe, and a11y sweeps
   collect into a list — `/problems` shows it, `/fix` sends everything as one turn,
   `/fix <n>` targets one. The footer counts what's open.
+- **Sandbox**: `/sandbox on` and asks accumulate in a shadow worktree — the dev server,
+  gates, and probes all run there; `/sandbox diff` shows what is staged, `apply` lands it
+  as one diff, `discard` walks away with the real tree untouched.
 - **Variants without leaving**: `/variants 3 <ask>` runs parallel explorations with
   streaming per-family status; `/variants apply <id>` keeps the winner.
 - **Commands**: type `/` and matching commands appear with descriptions; tab completes.
@@ -227,6 +231,7 @@ All product behavior lives in the harness, so a new engine is ~80 lines.
 
 - [Engine setup guide](./docs/engines.md) — install + auth for all eight, and how to choose
 - [Configuration](./docs/configuration.md) — every key, every `.squint/` file
+- [The loops](./docs/loops.md) — everything that runs automatically around each turn
 - [Architecture](./docs/design/2026-07-25-architecture.md)
 - [How Lovable works under the hood](./docs/research/lovable.md)
 - [Making agents produce excellent frontend work](./docs/research/frontend-quality.md)

package/dist/{chunk-CHZE3UHK.js → chunk-GOAFH2VN.js}

@@ -7,56 +7,14 @@ import {
   cdpCapture,
   hasWebSocket
 } from "./chunk-OC6RU6XH.js";
+import {
+  ensureSquintIgnore
+} from "./chunk-O2S6PAJE.js";
 
 // src/preview/preview.ts
-import fs2 from "fs";
-import os from "os";
-import path2 from "path";
-
-// src/state/state.ts
 import fs from "fs";
+import os from "os";
 import path from "path";
-var IGNORED = ["preview/", "state.json", "variants/", "transcripts/"];
-function ensureSquintIgnore(cwd) {
-  const dir = path.join(cwd, ".squint");
-  fs.mkdirSync(dir, { recursive: true });
-  const file = path.join(dir, ".gitignore");
-  let existing = "";
-  try {
-    existing = fs.readFileSync(file, "utf8");
-  } catch {
-  }
-  const lines = existing.split("\n").filter((l) => l.trim().length > 0);
-  const missing = IGNORED.filter((entry) => !lines.includes(entry));
-  if (missing.length > 0) {
-    fs.writeFileSync(file, [...lines, ...missing].join("\n") + "\n");
-  }
-}
-function stateFile(cwd) {
-  return path.join(cwd, ".squint", "state.json");
-}
-function loadState(cwd) {
-  try {
-    const raw = JSON.parse(fs.readFileSync(stateFile(cwd), "utf8"));
-    if (typeof raw?.engine === "string" && typeof raw?.sessionId === "string" && typeof raw?.at === "number") {
-      return raw;
-    }
-  } catch {
-  }
-  return null;
-}
-function saveState(cwd, state) {
-  ensureSquintIgnore(cwd);
-  fs.writeFileSync(stateFile(cwd), JSON.stringify(state, null, 2) + "\n");
-}
-function clearState(cwd) {
-  try {
-    fs.rmSync(stateFile(cwd));
-  } catch {
-  }
-}
-
-// src/preview/preview.ts
 var VIEWPORTS = [
   { name: "mobile", width: 390, height: 844 },
   { name: "tablet", width: 768, height: 1024 },
@@ -65,7 +23,7 @@ var VIEWPORTS = [
 function loadRoutes(cwd) {
   let lines = [];
   try {
-    lines = fs2.readFileSync(path2.join(cwd, ".squint", "routes"), "utf8").split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
+    lines = fs.readFileSync(path.join(cwd, ".squint", "routes"), "utf8").split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
   } catch {
   }
   const routes = ["/", ...lines.filter((l) => l !== "/")];
@@ -76,8 +34,8 @@ function routeShotName(route) {
   return clean.length > 0 ? clean : "root";
 }
 function previewDir(cwd) {
-  const dir = path2.join(cwd, ".squint", "preview");
-  fs2.mkdirSync(dir, { recursive: true });
+  const dir = path.join(cwd, ".squint", "preview");
+  fs.mkdirSync(dir, { recursive: true });
   ensureSquintIgnore(cwd);
   return dir;
 }
@@ -111,7 +69,7 @@ async function captureViewports(cwd, url) {
   const shots = [];
   const errors = [];
   for (const viewport of VIEWPORTS) {
-    const outPath = path2.join(dir, `${viewport.name}.png`);
+    const outPath = path.join(dir, `${viewport.name}.png`);
     const result = await screenshot(chrome, url, outPath, {
       width: viewport.width,
       height: viewport.height
@@ -203,9 +161,6 @@ Read each screenshot and review the rendered UI against the design standards you
 }
 
 export {
-  loadState,
-  saveState,
-  clearState,
   VIEWPORTS,
   loadRoutes,
   routeShotName,

package/dist/chunk-O2S6PAJE.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+// src/state/state.ts
+import fs from "fs";
+import path from "path";
+var IGNORED = ["preview/", "state.json", "variants/", "sandbox/", "sandbox.patch", "transcripts/"];
+function ensureSquintIgnore(cwd) {
+  const dir = path.join(cwd, ".squint");
+  fs.mkdirSync(dir, { recursive: true });
+  const file = path.join(dir, ".gitignore");
+  let existing = "";
+  try {
+    existing = fs.readFileSync(file, "utf8");
+  } catch {
+  }
+  const lines = existing.split("\n").filter((l) => l.trim().length > 0);
+  const missing = IGNORED.filter((entry) => !lines.includes(entry));
+  if (missing.length > 0) {
+    fs.writeFileSync(file, [...lines, ...missing].join("\n") + "\n");
+  }
+}
+function stateFile(cwd) {
+  return path.join(cwd, ".squint", "state.json");
+}
+function loadState(cwd) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(stateFile(cwd), "utf8"));
+    if (typeof raw?.engine === "string" && typeof raw?.sessionId === "string" && typeof raw?.at === "number") {
+      return raw;
+    }
+  } catch {
+  }
+  return null;
+}
+function saveState(cwd, state) {
+  ensureSquintIgnore(cwd);
+  fs.writeFileSync(stateFile(cwd), JSON.stringify(state, null, 2) + "\n");
+}
+function clearState(cwd) {
+  try {
+    fs.rmSync(stateFile(cwd));
+  } catch {
+  }
+}
+
+export {
+  ensureSquintIgnore,
+  loadState,
+  saveState,
+  clearState
+};

package/dist/chunk-RMNG2NTU.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+// src/session/commands.ts
+var COMMANDS = [
+  { name: "dev", args: "[restart|logs]", group: "build", description: "start/stop the dev server; restart or show recent output" },
+  { name: "mode", args: "plan|safe|yolo", group: "build", description: "how much the engine may do (shift+tab cycles)" },
+  { name: "engine", args: "<id>", group: "build", description: "switch backend (new session)" },
+  { name: "engines", group: "build", description: "list installed engines with streaming/resume support" },
+  { name: "model", args: "[name]", group: "build", description: "model override for the engine" },
+  { name: "queue", args: "clear", group: "build", description: "drop queued asks" },
+  { name: "check", group: "verify", description: "run all quality gates (typecheck, lint, format, test, build)" },
+  { name: "problems", group: "verify", description: "list open findings from gates, dev server, runtime, a11y" },
+  { name: "fix", args: "[n]", group: "verify", description: "send all open problems to the engine, or just problem n" },
+  { name: "shot", args: "[url]", group: "verify", description: "screenshot the app (or any url) at mobile/tablet/desktop" },
+  { name: "review", args: "[focus]", group: "verify", description: "screenshots + the engine critiques its own rendered work" },
+  { name: "variants", args: "<2-4> <ask>", group: "explore", description: "parallel design explorations; apply/list/clean" },
+  { name: "sandbox", args: "[on|diff|apply|discard]", group: "explore", description: "asks accumulate in a shadow worktree until you apply" },
+  { name: "undo", group: "explore", description: "revert the last ask (files only)" },
+  { name: "checkpoints", group: "explore", description: "list per-ask checkpoints" },
+  { name: "restore", args: "<n>", group: "explore", description: "rewind files to before ask n" },
+  { name: "theme", args: "[name]", group: "session", description: "switch the TUI theme", viewLevel: true },
+  { name: "copy", group: "session", description: "copy the last reply to the clipboard" },
+  { name: "save", group: "session", description: "export the transcript to .squint/transcripts/" },
+  { name: "resume", group: "session", description: "pick up the previous session for this repo" },
+  { name: "clear", group: "session", description: "new session (transcript, totals, persisted state)" },
+  { name: "help", group: "session", description: "list commands" },
+  { name: "quit", group: "session", description: "exit with a session summary" }
+];
+function completeCommand(partial) {
+  const query = partial.toLowerCase();
+  return COMMANDS.filter((c) => c.name.startsWith(query));
+}
+var GROUP_TITLES = {
+  build: "build",
+  verify: "verify",
+  explore: "explore & rewind",
+  session: "session"
+};
+function commandHelp() {
+  const sections = [];
+  for (const group of ["build", "verify", "explore", "session"]) {
+    const rows = COMMANDS.filter((c) => c.group === group).map(
+      (c) => `  /${c.name}${c.args ? ` ${c.args}` : ""} \u2014 ${c.description}`
+    );
+    sections.push(`${GROUP_TITLES[group]}
+${rows.join("\n")}`);
+  }
+  return sections.join("\n");
+}
+
+export {
+  COMMANDS,
+  completeCommand,
+  commandHelp
+};

package/dist/chunk-XEQ6JXXL.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+// src/vcs/sandbox.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+import path from "path";
+function git(cwd, args) {
+  return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+function sandboxDir(cwd) {
+  return path.join(cwd, ".squint", "sandbox");
+}
+function sandboxExists(cwd) {
+  return fs.existsSync(path.join(sandboxDir(cwd), ".git"));
+}
+function openSandbox(cwd) {
+  const dir = sandboxDir(cwd);
+  void import("./state-QOS7WCZO.js").then(({ ensureSquintIgnore }) => ensureSquintIgnore(cwd)).catch(() => {
+  });
+  if (sandboxExists(cwd)) return { dir, reused: true };
+  fs.rmSync(dir, { recursive: true, force: true });
+  fs.mkdirSync(path.dirname(dir), { recursive: true });
+  git(cwd, ["worktree", "add", "--force", "--detach", dir, "HEAD"]);
+  const mainModules = path.join(cwd, "node_modules");
+  const sandboxModules = path.join(dir, "node_modules");
+  if (fs.existsSync(mainModules) && !fs.existsSync(sandboxModules)) {
+    fs.symlinkSync(mainModules, sandboxModules, "dir");
+  }
+  return { dir, reused: false };
+}
+function sandboxDiffStat(cwd) {
+  if (!sandboxExists(cwd)) return null;
+  const dir = sandboxDir(cwd);
+  try {
+    git(dir, ["add", "-A"]);
+    const stat = git(dir, ["diff", "--cached", "--shortstat", "HEAD"]);
+    return stat.length > 0 ? stat : null;
+  } catch {
+    return null;
+  }
+}
+function sandboxFiles(cwd) {
+  if (!sandboxExists(cwd)) return [];
+  const dir = sandboxDir(cwd);
+  try {
+    git(dir, ["add", "-A"]);
+    const out = git(dir, ["diff", "--cached", "--name-status", "HEAD"]);
+    return out.length > 0 ? out.split("\n") : [];
+  } catch {
+    return [];
+  }
+}
+function applySandbox(cwd) {
+  if (!sandboxExists(cwd)) return { ok: false, detail: "no sandbox open" };
+  const dir = sandboxDir(cwd);
+  try {
+    git(dir, ["add", "-A"]);
+    const patch = git(dir, ["diff", "--binary", "--cached", "HEAD"]);
+    if (patch.length === 0) return { ok: false, detail: "sandbox has no changes" };
+    const patchFile = path.join(cwd, ".squint", "sandbox.patch");
+    fs.writeFileSync(patchFile, patch + "\n");
+    git(cwd, ["apply", "--whitespace=nowarn", patchFile]);
+    fs.rmSync(patchFile, { force: true });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, detail: err instanceof Error ? err.message.split("\n")[0] : String(err) };
+  }
+}
+function discardSandbox(cwd) {
+  if (!sandboxExists(cwd)) return false;
+  const dir = sandboxDir(cwd);
+  try {
+    const link = path.join(dir, "node_modules");
+    if (fs.existsSync(link) && fs.lstatSync(link).isSymbolicLink()) fs.rmSync(link);
+  } catch {
+  }
+  try {
+    git(cwd, ["worktree", "remove", "--force", dir]);
+  } catch {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+  try {
+    git(cwd, ["worktree", "prune"]);
+  } catch {
+  }
+  return true;
+}
+
+export {
+  sandboxDir,
+  sandboxExists,
+  openSandbox,
+  sandboxDiffStat,
+  sandboxFiles,
+  applySandbox,
+  discardSandbox
+};

package/dist/cli.js

@@ -1,4 +1,22 @@
 #!/usr/bin/env node
+import {
+  completeCommand
+} from "./chunk-RMNG2NTU.js";
+import {
+  applySandbox,
+  discardSandbox,
+  openSandbox,
+  sandboxDiffStat,
+  sandboxDir,
+  sandboxExists,
+  sandboxFiles
+} from "./chunk-XEQ6JXXL.js";
+import {
+  diffStatSince,
+  isGitRepo,
+  restoreSnapshot,
+  takeSnapshot
+} from "./chunk-YHRAOBI2.js";
 import {
   DevServer,
   buildFixPrompt,
@@ -21,16 +39,10 @@ import {
   buildReviewPrompt,
   buildRuntimeFixPrompt,
   captureViewports,
-  clearState,
   comparePulse,
-  loadState,
   probeRuntime,
-  runtimeSummary,
-  saveState
-} from "./chunk-CHZE3UHK.js";
-import {
-  completeCommand
-} from "./chunk-RZOQPFXC.js";
+  runtimeSummary
+} from "./chunk-GOAFH2VN.js";
 import {
   runAgent
 } from "./chunk-C7WKNJG6.js";
@@ -49,11 +61,10 @@ import {
   composePrompt
 } from "./chunk-P3H4N2EN.js";
 import {
-  diffStatSince,
-  isGitRepo,
-  restoreSnapshot,
-  takeSnapshot
-} from "./chunk-YHRAOBI2.js";
+  clearState,
+  loadState,
+  saveState
+} from "./chunk-O2S6PAJE.js";
 
 // src/cli.tsx
 import { Command } from "commander";
@@ -317,6 +328,39 @@ function registerProject(program2) {
     console.log(pc3.green(`\u2713 ${family.name} direction written to .squint/brief.md`));
     console.log(pc3.dim("every squint ask in this repo now holds this direction \u2014 edit the file to remix"));
   });
+  const sandboxCommand = program2.command("sandbox").description("Cumulative diff worktree \u2014 asks accumulate until you apply");
+  sandboxCommand.command("diff").description("Show accumulated sandbox changes").action(async () => {
+    const { sandboxDiffStat: sandboxDiffStat2, sandboxExists: sandboxExists2, sandboxFiles: sandboxFiles2 } = await import("./sandbox-J2NCPYHJ.js");
+    const cwd = process.cwd();
+    if (!sandboxExists2(cwd)) {
+      console.log(pc3.dim("no sandbox open \u2014 /sandbox on inside the TUI"));
+      return;
+    }
+    const stat = sandboxDiffStat2(cwd);
+    if (!stat) {
+      console.log(pc3.dim("sandbox is clean"));
+      return;
+    }
+    console.log(stat);
+    for (const line of sandboxFiles2(cwd)) console.log(pc3.dim(line));
+  });
+  sandboxCommand.command("apply").description("Land the sandbox diff on the real tree and close it").action(async () => {
+    const { applySandbox: applySandbox2, discardSandbox: discardSandbox2 } = await import("./sandbox-J2NCPYHJ.js");
+    const cwd = process.cwd();
+    const result = applySandbox2(cwd);
+    if (!result.ok) {
+      console.error(pc3.red(`\u2717 ${result.detail}`));
+      process.exitCode = 1;
+      return;
+    }
+    discardSandbox2(cwd);
+    console.log(pc3.green("\u2713 sandbox applied to the real tree") + pc3.dim(" \u2014 review with git diff"));
+  });
+  sandboxCommand.command("discard").description("Close the sandbox without touching the real tree").action(async () => {
+    const { discardSandbox: discardSandbox2 } = await import("./sandbox-J2NCPYHJ.js");
+    const had = discardSandbox2(process.cwd());
+    console.log(pc3.dim(had ? "sandbox discarded" : "no sandbox open"));
+  });
   const variantsCommand = program2.command("variants").description("Parallel design explorations \u2014 one aesthetic family each, pick with your eyes");
   variantsCommand.command("gen").description("Generate n variants of one ask in parallel (n engine runs \u2014 n\xD7 cost)").argument("<n>", "how many variants (max 4)").argument("<prompt...>", "what to build").option("-e, --engine <id>", "engine to use").option("-m, --model <name>", "model override").option("--no-shots", "skip the screenshot pass").action(
     async (nRaw, promptWords, options) => {
@@ -415,7 +459,7 @@ function registerQuality(program2) {
     if (results.some((r) => !r.ok)) process.exitCode = 1;
   });
   program2.command("shot").description("Screenshot a running app at mobile/tablet/desktop viewports (+ .squint/routes)").argument("<url>", "URL of the running app (e.g. http://localhost:5173)").action(async (url) => {
-    const { captureViewports: captureViewports2 } = await import("./preview-XGASKUXR.js");
+    const { captureViewports: captureViewports2 } = await import("./preview-VW5DAJNV.js");
     const result = await captureViewports2(process.cwd(), url);
     if (!result) {
       console.error(pc4.red("\u2717 no Chrome/Chromium found"));
@@ -592,7 +636,8 @@ var Session = class {
       totals: { costUsd: 0, turns: 0 },
       queue: [],
       mode: "safe",
-      problems: []
+      problems: [],
+      sandbox: false
     };
     if (opts.autoDev && detectDevCommand(opts.cwd)) {
       this.devServer().start();
@@ -762,15 +807,33 @@ var Session = class {
       this.push("assistant", text);
     }
   }
+  /** Where engines run and servers start: the sandbox worktree when on. */
+  execCwd() {
+    return this.state.sandbox ? sandboxDir(this.opts.cwd) : this.opts.cwd;
+  }
   devServer() {
     if (!this.dev) {
-      this.dev = new DevServer(this.opts.cwd, {
+      this.dev = new DevServer(this.execCwd(), {
         onStateChange: (devState) => this.notify({ devState }),
         onUrl: (url) => this.notify({ devUrl: url })
       });
     }
     return this.dev;
   }
+  /** Rebind the dev server after the execution tree changes. */
+  resetDevServer() {
+    const wasRunning = this.dev && this.dev.state !== "stopped";
+    this.dev?.stop();
+    this.dev = null;
+    this.notify({ devUrl: null, devState: "stopped" });
+    if (wasRunning) {
+      const command = detectDevCommand(this.execCwd());
+      if (command) {
+        this.devServer().start(command);
+        this.push("status", `dev server restarting in ${this.state.sandbox ? "the sandbox" : "the real tree"}`);
+      }
+    }
+  }
   turnEdits = 0;
   turnTools = 0;
   toolStreak = 0;
@@ -849,7 +912,7 @@ var Session = class {
       engine,
       {
         prompt,
-        cwd: this.opts.cwd,
+        cwd: this.execCwd(),
         model: this.state.model,
         mode: this.state.mode,
         sessionId: engine.supportsResume ? this.sessionId : void 0
@@ -892,9 +955,9 @@ var Session = class {
       }
     }
     if (result.ok && this.opts.autoCheck !== false) {
-      const fastGates = detectFastGates(this.opts.cwd);
+      const fastGates = detectFastGates(this.execCwd());
       if (fastGates.length > 0) {
-        const gateResults = await runGates(this.opts.cwd, fastGates);
+        const gateResults = await runGates(this.execCwd(), fastGates);
         const failures = gateResults.filter((r) => !r.ok);
         if (failures.length > 0) {
           this.addProblem(
@@ -969,7 +1032,7 @@ ${errors.slice(-5).join("\n")}`);
   async submit(ask) {
     this.fixAttempts = 0;
     this.autoReviewedThisAsk = false;
-    const snapshot = takeSnapshot(this.opts.cwd);
+    const snapshot = this.state.sandbox ? null : takeSnapshot(this.opts.cwd);
     if (snapshot) {
       this.checkpoints.push({
         snapshot,
@@ -1034,13 +1097,14 @@ ${errors.slice(-5).join("\n")}`);
     return pct;
   }
   /** Screenshot the running app (and watch its runtime where CDP is available). */
-  async capture() {
-    if (!this.state.devUrl) {
-      this.push("error", "dev server not running \u2014 /dev first");
+  async capture(urlOverride) {
+    const url = urlOverride || this.state.devUrl;
+    if (!url) {
+      this.push("error", "dev server not running \u2014 /dev first, or /shot <url>");
       return null;
     }
     this.push("status", "capturing screenshots\u2026");
-    const result = await captureViewports(this.opts.cwd, this.state.devUrl);
+    const result = await captureViewports(this.opts.cwd, url);
     if (!result) {
       this.push("error", "no Chrome/Chromium found for screenshots");
       return null;
@@ -1259,7 +1323,7 @@ They are objective defects, not style preferences.`
         })();
         break;
       case "shot":
-        void this.capture();
+        void this.capture(arg || void 0);
         break;
       case "review":
         void (async () => {
@@ -1320,6 +1384,57 @@ They are objective defects, not style preferences.`
         this.push("status", `resumed ${saved.engine} session${saved.lastAsk ? ` \xB7 "${saved.lastAsk}"` : ""}`);
         break;
       }
+      case "sandbox": {
+        if (this.state.running) {
+          this.push("status", "wait for the current turn before changing sandbox state");
+          break;
+        }
+        if (arg === "diff") {
+          const stat = sandboxDiffStat(this.opts.cwd);
+          if (!stat) {
+            this.push("status", sandboxExists(this.opts.cwd) ? "sandbox is clean" : "no sandbox open \u2014 /sandbox on");
+          } else {
+            this.push("status", `${stat}
+${sandboxFiles(this.opts.cwd).join("\n")}`);
+          }
+          break;
+        }
+        if (arg === "apply") {
+          const applied = applySandbox(this.opts.cwd);
+          if (applied.ok) {
+            discardSandbox(this.opts.cwd);
+            this.notify({ sandbox: false });
+            this.resetDevServer();
+            this.push("status", "sandbox applied to the real tree \u2014 review with git diff");
+          } else {
+            this.push("error", applied.detail ?? "apply failed");
+          }
+          break;
+        }
+        if (arg === "discard" || arg === "off") {
+          const had = discardSandbox(this.opts.cwd);
+          this.notify({ sandbox: false });
+          this.resetDevServer();
+          this.push("status", had ? "sandbox discarded \u2014 the real tree was never touched" : "no sandbox open");
+          break;
+        }
+        if (arg === "on" || arg === "") {
+          if (!isGitRepo(this.opts.cwd)) {
+            this.push("error", "sandbox needs a git repo with at least one commit");
+            break;
+          }
+          const { reused } = openSandbox(this.opts.cwd);
+          this.notify({ sandbox: true });
+          this.resetDevServer();
+          this.push(
+            "status",
+            `${reused ? "rejoined the open sandbox" : "sandbox opened"} \u2014 asks now accumulate in a shadow worktree; /sandbox diff \xB7 apply \xB7 discard`
+          );
+          break;
+        }
+        this.push("status", "usage: /sandbox [on] \xB7 diff \xB7 apply \xB7 discard");
+        break;
+      }
       case "variants": {
         const [sub, ...subRest] = arg.split(/\s+/);
         if (sub === "apply") {
@@ -1395,7 +1510,7 @@ They are objective defects, not style preferences.`
         this.notify({ items: [], totals: { costUsd: 0, turns: 0 } });
         break;
       case "help": {
-        void import("./commands-TYAKF276.js").then(({ commandHelp }) => this.push("status", commandHelp()));
+        void import("./commands-TERCCWFM.js").then(({ commandHelp }) => this.push("status", commandHelp()));
         break;
       }
       case "quit":
@@ -1925,6 +2040,7 @@ function App({
           ]
         }
       ),
+      state.sandbox && /* @__PURE__ */ jsx3(Text3, { color: theme2.accent, bold: true, children: " [sandbox]" }),
       " ",
       state.engineId,
       state.model ? ` \xB7 ${state.model}` : "",
@@ -1979,7 +2095,7 @@ function registerTui(program2) {
 }
 
 // src/cli.tsx
-var VERSION = "0.2.7";
+var VERSION = true ? "0.2.9" : "0.0.0-dev";
 var program = new Command();
 program.name("squint").description("Lovable for your terminal \u2014 a frontend harness on top of Claude Code, Codex, and friends.").version(VERSION);
 registerRun(program);

package/dist/{commands-TYAKF276.js → commands-TERCCWFM.js}

@@ -3,7 +3,7 @@ import {
   COMMANDS,
   commandHelp,
   completeCommand
-} from "./chunk-RZOQPFXC.js";
+} from "./chunk-RMNG2NTU.js";
 export {
   COMMANDS,
   commandHelp,

package/dist/{preview-XGASKUXR.js → preview-VW5DAJNV.js}

@@ -10,10 +10,11 @@ import {
   probeRuntime,
   routeShotName,
   runtimeSummary
-} from "./chunk-CHZE3UHK.js";
+} from "./chunk-GOAFH2VN.js";
 import "./chunk-B7LOERSP.js";
 import "./chunk-BWZFACBT.js";
 import "./chunk-OC6RU6XH.js";
+import "./chunk-O2S6PAJE.js";
 export {
   VIEWPORTS,
   buildReviewPrompt,

package/dist/sandbox-J2NCPYHJ.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import {
+  applySandbox,
+  discardSandbox,
+  openSandbox,
+  sandboxDiffStat,
+  sandboxDir,
+  sandboxExists,
+  sandboxFiles
+} from "./chunk-XEQ6JXXL.js";
+export {
+  applySandbox,
+  discardSandbox,
+  openSandbox,
+  sandboxDiffStat,
+  sandboxDir,
+  sandboxExists,
+  sandboxFiles
+};

package/dist/state-QOS7WCZO.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  clearState,
+  ensureSquintIgnore,
+  loadState,
+  saveState
+} from "./chunk-O2S6PAJE.js";
+export {
+  clearState,
+  ensureSquintIgnore,
+  loadState,
+  saveState
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aayambansal/squint",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Lovable for your terminal — a frontend harness on top of Claude Code, Codex, and other coding agents.",
   "type": "module",
   "license": "MIT",

package/dist/chunk-RZOQPFXC.js

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-
-// src/session/commands.ts
-var COMMANDS = [
-  { name: "dev", args: "[restart|logs]", description: "start/stop the dev server; restart or show recent output" },
-  { name: "check", description: "run all quality gates (typecheck, lint, test, build)" },
-  { name: "problems", description: "list open findings from gates, dev server, runtime, a11y" },
-  { name: "fix", args: "[n]", description: "send all open problems to the engine, or just problem n" },
-  { name: "shot", description: "screenshot the app at mobile/tablet/desktop" },
-  { name: "review", args: "[focus]", description: "screenshots + the engine critiques its own rendered work" },
-  { name: "variants", args: "<2-4> <ask>", description: "parallel design explorations; apply/list/clean" },
-  { name: "undo", description: "revert the last ask (files only)" },
-  { name: "checkpoints", description: "list per-ask checkpoints" },
-  { name: "restore", args: "<n>", description: "rewind files to before ask n" },
-  { name: "mode", args: "plan|safe|yolo", description: "how much the engine may do (shift+tab cycles)" },
-  { name: "engine", args: "<id>", description: "switch backend (new session)" },
-  { name: "engines", description: "list installed engines with streaming/resume support" },
-  { name: "model", args: "[name]", description: "model override for the engine" },
-  { name: "theme", args: "[name]", description: "switch the TUI theme", viewLevel: true },
-  { name: "copy", description: "copy the last reply to the clipboard" },
-  { name: "save", description: "export the transcript to .squint/transcripts/" },
-  { name: "queue", args: "clear", description: "drop queued asks" },
-  { name: "resume", description: "pick up the previous session for this repo" },
-  { name: "clear", description: "new session (transcript, totals, persisted state)" },
-  { name: "help", description: "list commands" },
-  { name: "quit", description: "exit with a session summary" }
-];
-function completeCommand(partial) {
-  const query = partial.toLowerCase();
-  return COMMANDS.filter((c) => c.name.startsWith(query));
-}
-function commandHelp() {
-  return COMMANDS.map((c) => `/${c.name}${c.args ? ` ${c.args}` : ""} \u2014 ${c.description}`).join("\n");
-}
-
-export {
-  COMMANDS,
-  completeCommand,
-  commandHelp
-};