@aayambansal/squint 0.1.3 → 0.2.1

package/dist/cli.js

@@ -2,19 +2,27 @@
 import {
   DevServer,
   buildFixPrompt,
-  detectDevCommand
-} from "./chunk-FQDSJRTY.js";
+  detectDevCommand,
+  screenshotVariants
+} from "./chunk-2IW2MMCY.js";
 import {
-  runAgent
-} from "./chunk-MGHJSERZ.js";
+  applyVariant,
+  cleanVariants,
+  listVariants,
+  runVariants
+} from "./chunk-LCS47EAG.js";
 import {
   composePrompt
-} from "./chunk-NT2HR4RD.js";
+} from "./chunk-P3H4N2EN.js";
+import {
+  runAgent
+} from "./chunk-OTG4ZB4R.js";
 import {
   buildGatePrompt,
+  detectFastGates,
   detectGates,
   runGates
-} from "./chunk-43VZK47W.js";
+} from "./chunk-DLCRYRWQ.js";
 import {
   buildReviewPrompt,
   buildRuntimeFixPrompt,
@@ -24,15 +32,20 @@ import {
   probeRuntime,
   runtimeSummary,
   saveState
-} from "./chunk-MOYLED4S.js";
-import "./chunk-ABF4QAMZ.js";
-import "./chunk-MURKQ7SI.js";
+} from "./chunk-REDPR3KI.js";
+import "./chunk-VJGE7HSP.js";
+import {
+  findChrome
+} from "./chunk-P3V5CWH5.js";
 import {
   detectEngines,
-  engines,
   getEngine
-} from "./chunk-YIVPCWSG.js";
+} from "./chunk-2LRIKWBU.js";
+import {
+  enrich
+} from "./chunk-XZKQZKEE.js";
 import {
+  isGitRepo,
   restoreSnapshot,
   takeSnapshot
 } from "./chunk-WTA6YYBY.js";
@@ -57,7 +70,13 @@ var ConfigSchema = z.object({
   /** Automatically send dev-server errors back to the engine (max 2 attempts). */
   autoFix: z.boolean().optional(),
   /** Probe the running app's runtime after each clean turn (default on). */
-  autoProbe: z.boolean().optional()
+  autoProbe: z.boolean().optional(),
+  /** Run typecheck+lint after every turn (default on where detected). */
+  autoCheck: z.boolean().optional(),
+  /** Terminal bell when a turn finishes (default on). */
+  bell: z.boolean().optional(),
+  /** TUI theme name (amber, ocean, moss, rose, mono). */
+  theme: z.string().optional()
 });
 function defaultPaths(cwd) {
   const xdg = process.env.XDG_CONFIG_HOME;
@@ -98,9 +117,9 @@ function resolveModel(config, engineId, override) {
 function setConfigValue(file, key, value) {
   const current = readConfigFile(file);
   let next;
-  if (key === "engine") {
-    next = { ...current, engine: value };
-  } else if (key === "autoDev" || key === "autoFix" || key === "autoProbe") {
+  if (key === "engine" || key === "theme") {
+    next = { ...current, [key]: value };
+  } else if (key === "autoDev" || key === "autoFix" || key === "autoProbe" || key === "autoCheck" || key === "bell") {
     if (value !== "true" && value !== "false") {
       throw new Error(`"${key}" must be true or false`);
     }
@@ -110,7 +129,9 @@ function setConfigValue(file, key, value) {
     if (!engineId) throw new Error("Usage: squint config set models.<engineId> <model>");
     next = { ...current, models: { ...current.models, [engineId]: value } };
   } else {
-    throw new Error(`Unknown config key "${key}". Supported: engine, autoDev, autoFix, autoProbe, models.<engineId>`);
+    throw new Error(
+      `Unknown config key "${key}". Supported: engine, theme, autoDev, autoFix, autoProbe, autoCheck, bell, models.<engineId>`
+    );
   }
   fs.mkdirSync(path.dirname(file), { recursive: true });
   fs.writeFileSync(file, JSON.stringify(next, null, 2) + "\n");
@@ -118,132 +139,39 @@ function setConfigValue(file, key, value) {
 }
 
 // src/tui/App.tsx
-import { Box, Static, Text as Text2, useApp, useInput } from "ink";
-import path2 from "path";
-import { useCallback, useEffect as useEffect2, useRef, useState as useState2 } from "react";
-
-// src/tui/messages.tsx
-import { Text } from "ink";
-import { useEffect, useState } from "react";
-
-// src/tui/theme.ts
-var theme = {
-  accent: "#e8a33d",
-  dim: "gray",
-  user: "#7aa2f7",
-  error: "#f7768e",
-  success: "#9ece6a",
-  tool: "#7dcfff"
-};
-
-// src/tui/messages.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
-var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-function WorkingLine({ startedAt }) {
-  const [frame, setFrame] = useState(0);
-  const [elapsed, setElapsed] = useState(0);
-  useEffect(() => {
-    const timer = setInterval(() => {
-      setFrame((f) => (f + 1) % SPINNER_FRAMES.length);
-      setElapsed(Math.floor((Date.now() - startedAt) / 1e3));
-    }, 80);
-    return () => clearInterval(timer);
-  }, [startedAt]);
-  return /* @__PURE__ */ jsxs(Text, { children: [
-    /* @__PURE__ */ jsx(Text, { color: theme.accent, children: SPINNER_FRAMES[frame] }),
-    /* @__PURE__ */ jsxs(Text, { color: theme.dim, children: [
-      " ",
-      "working\u2026 ",
-      elapsed,
-      "s \xB7 esc to interrupt"
-    ] })
-  ] });
-}
-function MessageLine({ message }) {
-  switch (message.role) {
-    case "user":
-      return /* @__PURE__ */ jsxs(Text, { color: theme.user, wrap: "wrap", children: [
-        "\u276F ",
-        message.text
-      ] });
-    case "assistant":
-      return /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: message.text });
-    case "status":
-      return /* @__PURE__ */ jsxs(Text, { color: theme.dim, wrap: "wrap", children: [
-        "\xB7 ",
-        message.text
-      ] });
-    case "tool":
-      return /* @__PURE__ */ jsxs(Text, { color: theme.tool, wrap: "wrap", children: [
-        "\u2699 ",
-        message.text
-      ] });
-    case "thinking":
-      return /* @__PURE__ */ jsx(Text, { color: theme.dim, italic: true, wrap: "wrap", children: message.text });
-    case "error":
-      return /* @__PURE__ */ jsxs(Text, { color: theme.error, wrap: "wrap", children: [
-        "\u2717 ",
-        message.text
-      ] });
-  }
-}
+import { Box as Box2, Static, Text as Text3, useApp, useInput } from "ink";
+import path3 from "path";
+import { useMemo, useRef, useState as useState2, useSyncExternalStore } from "react";
 
-// src/tui/App.tsx
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+// src/session/engine.ts
+import path2 from "path";
 var MAX_AUTO_FIX_ATTEMPTS = 2;
 var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-function App({ cwd, initialEngine, initialModel, autoDev, autoFix, autoProbe }) {
-  const { exit } = useApp();
-  const [messages, setMessages] = useState2([]);
-  const [input, setInput] = useState2("");
-  const [running, setRunning] = useState2(false);
-  const [runStartedAt, setRunStartedAt] = useState2(0);
-  const [engineId, setEngineId] = useState2(initialEngine);
-  const [model, setModel] = useState2(initialModel);
-  const [liveText, setLiveText] = useState2("");
-  const [devState, setDevState] = useState2("stopped");
-  const [devUrl, setDevUrl] = useState2(null);
-  const liveRef = useRef("");
-  const idRef = useRef(0);
-  const sessionRef = useRef(void 0);
-  const devRef = useRef(null);
-  const abortRef = useRef(null);
-  const pendingFixRef = useRef(null);
-  const snapshotRef = useRef(null);
-  const fixAttemptsRef = useRef(0);
-  const reviewTipShownRef = useRef(false);
-  const historyRef = useRef([]);
-  const historyIndexRef = useRef(-1);
-  const push = useCallback((role, text) => {
-    idRef.current += 1;
-    setMessages((prev) => [...prev, { id: idRef.current, role, text }]);
-  }, []);
-  const commitLive = useCallback(() => {
-    if (liveRef.current.length > 0) {
-      push("assistant", liveRef.current);
-      liveRef.current = "";
-      setLiveText("");
-    }
-  }, [push]);
-  const getDevServer = useCallback(() => {
-    if (!devRef.current) {
-      devRef.current = new DevServer(cwd, {
-        onStateChange: setDevState,
-        onUrl: setDevUrl
-      });
-    }
-    return devRef.current;
-  }, [cwd]);
-  useEffect2(() => {
-    if (autoDev && detectDevCommand(cwd)) {
-      getDevServer().start();
+var Session = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.state = {
+      items: [],
+      liveText: "",
+      running: false,
+      runStartedAt: 0,
+      engineId: opts.engineId,
+      model: opts.model,
+      devState: "stopped",
+      devUrl: null,
+      totals: { costUsd: 0, turns: 0 },
+      queue: [],
+      mode: "safe"
+    };
+    if (opts.autoDev && detectDevCommand(opts.cwd)) {
+      this.devServer().start();
     }
-    const saved = loadState(cwd);
+    const saved = loadState(opts.cwd);
     if (saved) {
       try {
         if (getEngine(saved.engine).supportsResume) {
           const mins = Math.max(1, Math.round((Date.now() - saved.at) / 6e4));
-          push(
+          this.push(
             "status",
             `previous session (${mins}m ago${saved.lastAsk ? ` \xB7 "${saved.lastAsk}"` : ""}) \u2014 /resume to continue`
           );
@@ -251,353 +179,988 @@ function App({ cwd, initialEngine, initialModel, autoDev, autoFix, autoProbe })
       } catch {
       }
     }
-    return () => devRef.current?.stop();
-  }, [autoDev, cwd, getDevServer, push]);
-  const handleEvent = useCallback(
-    (event) => {
-      switch (event.type) {
-        case "status":
-          commitLive();
-          push("status", event.text);
-          break;
-        case "delta":
-          liveRef.current += event.text;
-          setLiveText(liveRef.current);
-          break;
-        case "text":
-          if (event.streamed) {
-            liveRef.current = "";
-            setLiveText("");
-            push("assistant", event.text);
-          } else {
-            liveRef.current += (liveRef.current.length > 0 ? "\n" : "") + event.text;
-            setLiveText(liveRef.current);
-          }
-          break;
-        case "thinking":
-          commitLive();
-          push("thinking", event.text);
-          break;
-        case "tool":
-          commitLive();
-          push("tool", event.detail ? `${event.name} \xB7 ${event.detail}` : event.name);
-          break;
-        case "error":
-          commitLive();
-          push("error", event.text);
-          break;
-        case "result":
-          if (event.sessionId) sessionRef.current = event.sessionId;
-          break;
-        case "raw":
-          break;
+  }
+  opts;
+  state;
+  listeners = /* @__PURE__ */ new Set();
+  nextId = 0;
+  live = "";
+  sessionId;
+  dev = null;
+  abort = null;
+  pendingFix = null;
+  checkpoints = [];
+  fixAttempts = 0;
+  reviewTipShown = false;
+  startedAt = Date.now();
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  getState() {
+    return this.state;
+  }
+  dispose() {
+    this.abort?.abort();
+    this.dev?.stop();
+  }
+  interrupt() {
+    this.abort?.abort();
+  }
+  /** Frontend-originated status line (view-level commands like /theme). */
+  note(text) {
+    this.push("status", text);
+  }
+  setMode(mode) {
+    this.notify({ mode });
+    const hint = mode === "plan" ? "read-only: the engine investigates and proposes, edits nothing" : mode === "yolo" ? "no approval friction \u2014 the engine can do anything" : "edits auto-approved inside the workspace";
+    this.push("status", `mode \u2192 ${mode} \xB7 ${hint}`);
+  }
+  cycleMode() {
+    const order = ["safe", "plan", "yolo"];
+    const next = order[(order.indexOf(this.state.mode) + 1) % order.length];
+    this.setMode(next);
+  }
+  /** One-line goodbye: what this session amounted to. */
+  summary() {
+    const mins = Math.max(1, Math.round((Date.now() - this.startedAt) / 6e4));
+    const { turns, costUsd } = this.state.totals;
+    const parts = [`${turns} turn${turns === 1 ? "" : "s"}`];
+    if (costUsd > 0) parts.push(`$${costUsd.toFixed(2)}`);
+    parts.push(`${mins}m`);
+    return `session: ${parts.join(" \xB7 ")}`;
+  }
+  /**
+   * Route one line of user input: slash command or an ask for the engine.
+   * Asks arriving mid-turn queue up and dispatch in order once the
+   * current turn (including its fix cycle) settles.
+   */
+  input(raw) {
+    const value = raw.trim();
+    if (value.length === 0) return;
+    if (this.state.running) {
+      if (value === "/queue clear") {
+        this.notify({ queue: [] });
+        this.push("status", "queue cleared");
+        return;
       }
-    },
-    [push, commitLive]
-  );
-  const runTurn = useCallback(
-    async (prompt, display) => {
-      push("user", display);
-      setRunning(true);
-      setRunStartedAt(Date.now());
-      const runStart = Date.now();
-      const engine = getEngine(engineId);
-      const abort = new AbortController();
-      abortRef.current = abort;
-      const result = await runAgent(
-        engine,
-        {
-          prompt,
-          cwd,
-          model,
-          sessionId: engine.supportsResume ? sessionRef.current : void 0
-        },
-        handleEvent,
-        abort.signal
-      );
-      abortRef.current = null;
-      commitLive();
-      if (result.ok) {
-        const cost = result.costUsd !== void 0 ? ` \xB7 $${result.costUsd.toFixed(2)}` : "";
-        const secs = result.durationMs !== void 0 ? ` \xB7 ${(result.durationMs / 1e3).toFixed(0)}s` : "";
-        push("status", `done${secs}${cost}`);
-        if (sessionRef.current) {
-          saveState(cwd, {
-            engine: engineId,
-            sessionId: sessionRef.current,
-            model,
-            lastAsk: display.length > 80 ? `${display.slice(0, 79)}\u2026` : display,
-            at: Date.now()
-          });
+      this.notify({ queue: [...this.state.queue, value] });
+      return;
+    }
+    if (value.startsWith("/")) {
+      this.command(value);
+    } else {
+      void this.submit(value);
+    }
+  }
+  /** Dispatch queued input after the current work settles. */
+  drainQueue() {
+    if (this.state.running) return;
+    const [next, ...rest] = this.state.queue;
+    if (next === void 0) return;
+    this.notify({ queue: rest });
+    this.input(next);
+  }
+  // ---------- internals ----------
+  notify(patch) {
+    this.state = { ...this.state, ...patch };
+    for (const listener of this.listeners) listener();
+  }
+  push(role, text) {
+    this.nextId += 1;
+    this.notify({ items: [...this.state.items, { id: this.nextId, role, text }] });
+  }
+  setLive(text) {
+    this.live = text;
+    this.notify({ liveText: text });
+  }
+  /**
+   * Static transcript items are immutable once rendered, so in-progress
+   * assistant text accumulates in a live buffer and commits as one block.
+   */
+  commitLive() {
+    if (this.live.length > 0) {
+      const text = this.live;
+      this.live = "";
+      this.state = { ...this.state, liveText: "" };
+      this.push("assistant", text);
+    }
+  }
+  devServer() {
+    if (!this.dev) {
+      this.dev = new DevServer(this.opts.cwd, {
+        onStateChange: (devState) => this.notify({ devState }),
+        onUrl: (url) => this.notify({ devUrl: url })
+      });
+    }
+    return this.dev;
+  }
+  turnEdits = 0;
+  turnTools = 0;
+  handleEvent = (event) => {
+    switch (event.type) {
+      case "status":
+        this.commitLive();
+        this.push("status", event.text);
+        break;
+      case "delta":
+        this.setLive(this.live + event.text);
+        break;
+      case "text":
+        if (event.streamed) {
+          this.live = "";
+          this.state = { ...this.state, liveText: "" };
+          this.push("assistant", event.text);
+        } else {
+          this.setLive(this.live + (this.live.length > 0 ? "\n" : "") + event.text);
         }
+        break;
+      case "thinking":
+        this.commitLive();
+        this.push("thinking", event.text);
+        break;
+      case "tool": {
+        this.commitLive();
+        this.turnTools += 1;
+        if (/edit|write|patch|apply/i.test(event.name)) this.turnEdits += 1;
+        this.push("tool", event.detail ? `${event.name} \xB7 ${event.detail}` : event.name);
+        break;
       }
-      const dev = devRef.current;
-      if (result.error !== "interrupted" && dev && (dev.state === "running" || dev.state === "starting")) {
-        await delay(1500);
-        const errors = dev.errorsSince(runStart);
-        if (errors.length > 0) {
-          pendingFixRef.current = {
-            prompt: buildFixPrompt(errors, dev.tail(30)),
-            display: "\u26D1 fix dev server errors"
+      case "error":
+        this.commitLive();
+        this.push("error", event.text);
+        break;
+      case "result":
+        if (event.sessionId) this.sessionId = event.sessionId;
+        break;
+      case "raw":
+        break;
+    }
+  };
+  /** Run one engine turn. `display` is what the transcript shows as the ask. */
+  async runTurn(prompt, display) {
+    this.push("user", display);
+    this.turnEdits = 0;
+    this.turnTools = 0;
+    this.notify({ running: true, runStartedAt: Date.now() });
+    const runStart = Date.now();
+    const engine = getEngine(this.state.engineId);
+    this.abort = new AbortController();
+    const result = await runAgent(
+      engine,
+      {
+        prompt,
+        cwd: this.opts.cwd,
+        model: this.state.model,
+        mode: this.state.mode,
+        sessionId: engine.supportsResume ? this.sessionId : void 0
+      },
+      this.handleEvent,
+      this.abort.signal
+    );
+    this.abort = null;
+    this.commitLive();
+    if (result.ok) {
+      const cost = result.costUsd !== void 0 ? ` \xB7 $${result.costUsd.toFixed(2)}` : "";
+      const secs = result.durationMs !== void 0 ? ` \xB7 ${(result.durationMs / 1e3).toFixed(0)}s` : "";
+      const work = this.turnEdits > 0 ? ` \xB7 ${this.turnEdits} edit${this.turnEdits === 1 ? "" : "s"}` : this.turnTools > 0 ? ` \xB7 ${this.turnTools} tool call${this.turnTools === 1 ? "" : "s"}` : "";
+      this.push("status", `done${secs}${cost}${work}`);
+      this.notify({
+        totals: {
+          costUsd: this.state.totals.costUsd + (result.costUsd ?? 0),
+          turns: this.state.totals.turns + 1
+        }
+      });
+      if (this.sessionId) {
+        saveState(this.opts.cwd, {
+          engine: this.state.engineId,
+          sessionId: this.sessionId,
+          model: this.state.model,
+          lastAsk: display.length > 80 ? `${display.slice(0, 79)}\u2026` : display,
+          at: Date.now()
+        });
+      }
+    }
+    if (result.ok && this.opts.autoCheck !== false) {
+      const fastGates = detectFastGates(this.opts.cwd);
+      if (fastGates.length > 0) {
+        const gateResults = await runGates(this.opts.cwd, fastGates);
+        const failures = gateResults.filter((r) => !r.ok);
+        if (failures.length > 0) {
+          this.pendingFix = {
+            prompt: buildGatePrompt(failures),
+            display: `\u26D1 fix ${failures.map((f) => f.gate.id).join(" + ")} errors`
           };
-          push("error", `dev server: ${errors.length} error line(s)
-${errors.slice(-5).join("\n")}`);
-          if (autoFix && fixAttemptsRef.current < MAX_AUTO_FIX_ATTEMPTS) {
-            fixAttemptsRef.current += 1;
-            push("status", `auto-fix attempt ${fixAttemptsRef.current}/${MAX_AUTO_FIX_ATTEMPTS}`);
-            setRunning(false);
-            await runTurn(pendingFixRef.current.prompt, pendingFixRef.current.display);
+          this.push(
+            "error",
+            failures.map((f) => `\u2717 ${f.gate.id} \xB7 ${f.outputTail.split("\n").slice(-3).join("\n")}`).join("\n")
+          );
+          if (this.opts.autoFix && this.fixAttempts < MAX_AUTO_FIX_ATTEMPTS) {
+            this.fixAttempts += 1;
+            this.push("status", `auto-fix attempt ${this.fixAttempts}/${MAX_AUTO_FIX_ATTEMPTS}`);
+            this.notify({ running: false });
+            await this.runTurn(this.pendingFix.prompt, this.pendingFix.display);
             return;
           }
-          push("status", "type /fix to send them to the engine");
-        } else {
-          pendingFixRef.current = null;
-          if (autoProbe !== false && devUrl) {
-            const report = await probeRuntime(devUrl);
-            const summary = report ? runtimeSummary(report) : null;
-            if (report && summary) {
-              pendingFixRef.current = {
-                prompt: buildRuntimeFixPrompt(report),
-                display: "\u26D1 fix runtime errors"
-              };
-              push("error", `runtime: ${summary}`);
-              if (autoFix && fixAttemptsRef.current < MAX_AUTO_FIX_ATTEMPTS) {
-                fixAttemptsRef.current += 1;
-                push("status", `auto-fix attempt ${fixAttemptsRef.current}/${MAX_AUTO_FIX_ATTEMPTS}`);
-                setRunning(false);
-                await runTurn(pendingFixRef.current.prompt, pendingFixRef.current.display);
-                return;
-              }
-              push("status", "type /fix to send them to the engine");
+          this.push("status", "type /fix to send them to the engine");
+          this.notify({ running: false });
+          this.drainQueue();
+          return;
+        }
+      }
+    }
+    const dev = this.dev;
+    if (result.error !== "interrupted" && dev && (dev.state === "running" || dev.state === "starting")) {
+      await delay(1500);
+      const errors = dev.errorsSince(runStart);
+      if (errors.length > 0) {
+        this.pendingFix = {
+          prompt: buildFixPrompt(errors, dev.tail(30)),
+          display: "\u26D1 fix dev server errors"
+        };
+        this.push("error", `dev server: ${errors.length} error line(s)
+${errors.slice(-5).join("\n")}`);
+        if (this.opts.autoFix && this.fixAttempts < MAX_AUTO_FIX_ATTEMPTS) {
+          this.fixAttempts += 1;
+          this.push("status", `auto-fix attempt ${this.fixAttempts}/${MAX_AUTO_FIX_ATTEMPTS}`);
+          this.notify({ running: false });
+          await this.runTurn(this.pendingFix.prompt, this.pendingFix.display);
+          return;
+        }
+        this.push("status", "type /fix to send them to the engine");
+      } else {
+        this.pendingFix = null;
+        if (this.opts.autoProbe !== false && this.state.devUrl) {
+          const report = await probeRuntime(this.state.devUrl);
+          const summary = report ? runtimeSummary(report) : null;
+          if (report && summary) {
+            this.pendingFix = {
+              prompt: buildRuntimeFixPrompt(report),
+              display: "\u26D1 fix runtime errors"
+            };
+            this.push("error", `runtime: ${summary}`);
+            if (this.opts.autoFix && this.fixAttempts < MAX_AUTO_FIX_ATTEMPTS) {
+              this.fixAttempts += 1;
+              this.push("status", `auto-fix attempt ${this.fixAttempts}/${MAX_AUTO_FIX_ATTEMPTS}`);
+              this.notify({ running: false });
+              await this.runTurn(this.pendingFix.prompt, this.pendingFix.display);
+              return;
             }
+            this.push("status", "type /fix to send them to the engine");
           }
-          if (!reviewTipShownRef.current && devUrl) {
-            reviewTipShownRef.current = true;
-            push("status", "tip: /review screenshots the app and has the engine critique its own work");
-          }
+        }
+        if (!this.reviewTipShown && this.state.devUrl) {
+          this.reviewTipShown = true;
+          this.push("status", "tip: /review screenshots the app and has the engine critique its own work");
         }
       }
-      setRunning(false);
-    },
-    [cwd, engineId, model, push, handleEvent, commitLive, autoFix, autoProbe, devUrl]
-  );
-  const capture = useCallback(async () => {
-    if (!devUrl) {
-      push("error", "dev server not running \u2014 /dev first");
+    }
+    this.notify({ running: false });
+    this.drainQueue();
+  }
+  async submit(ask) {
+    this.fixAttempts = 0;
+    const snapshot = takeSnapshot(this.opts.cwd);
+    if (snapshot) {
+      this.checkpoints.push({
+        snapshot,
+        label: ask.length > 60 ? `${ask.slice(0, 59)}\u2026` : ask,
+        at: Date.now()
+      });
+      if (this.checkpoints.length > 20) this.checkpoints.shift();
+    }
+    const isFirstTurn = this.sessionId === void 0;
+    let prompt = isFirstTurn ? composePrompt(ask, { cwd: this.opts.cwd, firstTurn: true }) : ask;
+    const enrichment = enrich(this.opts.cwd, ask);
+    if (enrichment.matchedSkills.length > 0) {
+      this.push("status", `skills: ${enrichment.matchedSkills.join(", ")}`);
+    }
+    prompt += enrichment.sections;
+    await this.runTurn(prompt, ask);
+  }
+  /** Restore files to the state before checkpoint `index`; drop it and everything after. */
+  restoreTo(index) {
+    const checkpoint = this.checkpoints[index];
+    if (!checkpoint) {
+      this.push("status", "no such checkpoint \u2014 /checkpoints lists them");
+      return;
+    }
+    const result = restoreSnapshot(this.opts.cwd, checkpoint.snapshot);
+    if (result.restored) {
+      const dropped = this.checkpoints.length - index;
+      this.checkpoints = this.checkpoints.slice(0, index);
+      this.push(
+        "status",
+        `restored files to before "${checkpoint.label}"${dropped > 1 ? ` \xB7 ${dropped} asks rolled back` : ""}${result.deletedFiles > 0 ? ` \xB7 removed ${result.deletedFiles} created file(s)` : ""} \u2014 the conversation continues from here`
+      );
+    } else {
+      this.push("error", `restore failed: ${result.detail ?? "unknown error"}`);
+    }
+  }
+  /** 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");
       return null;
     }
-    push("status", "capturing screenshots\u2026");
-    const result = await captureViewports(cwd, devUrl);
+    this.push("status", "capturing screenshots\u2026");
+    const result = await captureViewports(this.opts.cwd, this.state.devUrl);
     if (!result) {
-      push("error", "no Chrome/Chromium found for screenshots");
+      this.push("error", "no Chrome/Chromium found for screenshots");
       return null;
     }
-    for (const err of result.errors) push("error", `screenshot ${err}`);
+    for (const err of result.errors) this.push("error", `screenshot ${err}`);
     if (result.shots.length > 0) {
-      push("status", `captured ${result.shots.map((s) => s.name).join(", ")} \u2192 ${path2.dirname(result.shots[0].path)}`);
+      this.push(
+        "status",
+        `captured ${result.shots.map((s) => s.name).join(", ")} \u2192 ${path2.dirname(result.shots[0].path)}`
+      );
     }
     if (result.runtime) {
       const summary = runtimeSummary(result.runtime);
       if (summary) {
-        push("error", `runtime: ${summary}`);
-        pendingFixRef.current = {
-          prompt: buildRuntimeFixPrompt(result.runtime),
-          display: "\u26D1 fix runtime errors"
-        };
-        push("status", "type /fix to send them to the engine");
+        this.push("error", `runtime: ${summary}`);
+        this.pendingFix = { prompt: buildRuntimeFixPrompt(result.runtime), display: "\u26D1 fix runtime errors" };
+        this.push("status", "type /fix to send them to the engine");
       } else {
-        push("status", "runtime clean \u2014 no console errors, exceptions, or failed requests");
+        this.push("status", "runtime clean \u2014 no console errors, exceptions, or failed requests");
       }
     }
     if (result.a11y && result.a11y.length > 0) {
-      push("error", `a11y: ${result.a11y.length} finding(s)
+      this.push("error", `a11y: ${result.a11y.length} finding(s)
 ${result.a11y.slice(0, 5).join("\n")}`);
-      push("status", "/review folds these into the fix pass");
+      this.push("status", "/review folds these into the fix pass");
     }
     return result.shots.length > 0 ? result : null;
-  }, [cwd, devUrl, push]);
-  const submit = useCallback(
-    async (ask) => {
-      fixAttemptsRef.current = 0;
-      snapshotRef.current = takeSnapshot(cwd);
-      const isFirstTurn = sessionRef.current === void 0;
-      const prompt = isFirstTurn ? composePrompt(ask, { cwd, firstTurn: true }) : ask;
-      await runTurn(prompt, ask);
-    },
-    [cwd, runTurn]
-  );
-  const handleCommand = useCallback(
-    (command) => {
-      const [name, ...rest] = command.slice(1).split(/\s+/);
-      const arg = rest.join(" ").trim();
-      switch (name) {
-        case "engine":
-          if (!arg) {
-            push("status", `engines: ${engines.map((e) => e.id).join(", ")}`);
-          } else {
-            try {
-              getEngine(arg);
-              setEngineId(arg);
-              sessionRef.current = void 0;
-              push("status", `engine \u2192 ${arg} (new session)`);
-            } catch (err) {
-              push("error", err instanceof Error ? err.message : String(err));
-            }
-          }
-          break;
-        case "model":
-          setModel(arg || void 0);
-          push("status", arg ? `model \u2192 ${arg}` : "model \u2192 engine default");
-          break;
-        case "dev": {
-          const dev = getDevServer();
-          if (dev.state === "stopped" || dev.state === "crashed") {
-            const devCommand = detectDevCommand(cwd);
-            if (!devCommand) {
-              push("error", "no dev/start script found in package.json");
-            } else {
-              dev.start(devCommand);
-              push("status", `dev server starting \xB7 ${devCommand.display}`);
-            }
-          } else {
-            dev.stop();
-            setDevUrl(null);
-            push("status", "dev server stopped");
+  }
+  command(commandLine) {
+    const [name, ...rest] = commandLine.slice(1).split(/\s+/);
+    const arg = rest.join(" ").trim();
+    switch (name) {
+      case "engine":
+        if (!arg) {
+          this.push("status", "usage: /engine <id> \u2014 see squint engines");
+        } else {
+          try {
+            getEngine(arg);
+            this.sessionId = void 0;
+            this.notify({ engineId: arg });
+            this.push("status", `engine \u2192 ${arg} (new session)`);
+          } catch (err) {
+            this.push("error", err instanceof Error ? err.message : String(err));
           }
-          break;
         }
-        case "fix":
-          if (!pendingFixRef.current) {
-            push("status", "nothing to fix \u2014 no captured errors or failed gates");
+        break;
+      case "model":
+        this.notify({ model: arg || void 0 });
+        this.push("status", arg ? `model \u2192 ${arg}` : "model \u2192 engine default");
+        break;
+      case "mode":
+        if (arg === "plan" || arg === "safe" || arg === "yolo") {
+          this.setMode(arg);
+        } else {
+          this.push("status", "usage: /mode plan|safe|yolo \u2014 or shift+tab to cycle");
+        }
+        break;
+      case "dev": {
+        const dev = this.devServer();
+        if (dev.state === "stopped" || dev.state === "crashed") {
+          const devCommand = detectDevCommand(this.opts.cwd);
+          if (!devCommand) {
+            this.push("error", "no dev/start script found in package.json");
           } else {
-            void runTurn(pendingFixRef.current.prompt, pendingFixRef.current.display);
+            dev.start(devCommand);
+            this.push("status", `dev server starting \xB7 ${devCommand.display}`);
           }
-          break;
-        case "check":
-          void (async () => {
-            const gates = detectGates(cwd);
-            if (gates.length === 0) {
-              push("status", "no gates detected in this project");
-              return;
-            }
-            push("status", `running gates: ${gates.map((g) => g.id).join(" \u2192 ")}`);
-            setRunning(true);
-            setRunStartedAt(Date.now());
-            const results = await runGates(cwd, gates, (result) => {
-              push(
-                result.ok ? "status" : "error",
-                `${result.ok ? "\u2713" : "\u2717"} ${result.gate.id} \xB7 ${(result.durationMs / 1e3).toFixed(1)}s`
-              );
-            });
-            setRunning(false);
-            const failures = results.filter((r) => !r.ok);
-            if (failures.length > 0) {
-              pendingFixRef.current = {
-                prompt: buildGatePrompt(failures),
-                display: `\u26D1 fix failing gates: ${failures.map((f) => f.gate.id).join(", ")}`
-              };
-              push("status", "type /fix to send failures to the engine");
-            } else {
-              push("status", "all gates passed");
-            }
-          })();
-          break;
-        case "shot":
-          void capture();
-          break;
-        case "review":
-          void (async () => {
-            const result = await capture();
-            if (result) {
-              await runTurn(
-                buildReviewPrompt(result.shots, arg || void 0, result.runtime, result.a11y),
-                `\u{1F441} review rendered UI${arg ? ` \xB7 ${arg}` : ""}`
-              );
-            }
-          })();
-          break;
-        case "undo": {
-          const snapshot = snapshotRef.current;
-          if (!snapshot) {
-            push("status", "nothing to undo \u2014 no ask this session, or not a git repo with commits");
-            break;
+        } else {
+          dev.stop();
+          this.notify({ devUrl: null });
+          this.push("status", "dev server stopped");
+        }
+        break;
+      }
+      case "fix":
+        if (!this.pendingFix) {
+          this.push("status", "nothing to fix \u2014 no captured errors or failed gates");
+        } else {
+          void this.runTurn(this.pendingFix.prompt, this.pendingFix.display);
+        }
+        break;
+      case "check":
+        void (async () => {
+          const gates = detectGates(this.opts.cwd);
+          if (gates.length === 0) {
+            this.push("status", "no gates detected in this project");
+            return;
           }
-          const result = restoreSnapshot(cwd, snapshot);
-          if (result.restored) {
-            snapshotRef.current = null;
-            push(
-              "status",
-              `reverted the last ask${result.deletedFiles > 0 ? ` \xB7 removed ${result.deletedFiles} created file(s)` : ""}`
+          this.push("status", `running gates: ${gates.map((g) => g.id).join(" \u2192 ")}`);
+          this.notify({ running: true, runStartedAt: Date.now() });
+          const results = await runGates(this.opts.cwd, gates, (result) => {
+            this.push(
+              result.ok ? "status" : "error",
+              `${result.ok ? "\u2713" : "\u2717"} ${result.gate.id} \xB7 ${(result.durationMs / 1e3).toFixed(1)}s`
             );
+          });
+          this.notify({ running: false });
+          this.drainQueue();
+          const failures = results.filter((r) => !r.ok);
+          if (failures.length > 0) {
+            this.pendingFix = {
+              prompt: buildGatePrompt(failures),
+              display: `\u26D1 fix failing gates: ${failures.map((f) => f.gate.id).join(", ")}`
+            };
+            this.push("status", "type /fix to send failures to the engine");
           } else {
-            push("error", `undo failed: ${result.detail ?? "unknown error"}`);
+            this.push("status", "all gates passed");
+          }
+        })();
+        break;
+      case "shot":
+        void this.capture();
+        break;
+      case "review":
+        void (async () => {
+          const result = await this.capture();
+          if (result) {
+            await this.runTurn(
+              buildReviewPrompt(result.shots, arg || void 0, result.runtime, result.a11y),
+              `\u{1F441} review rendered UI${arg ? ` \xB7 ${arg}` : ""}`
+            );
           }
+        })();
+        break;
+      case "undo":
+        if (this.checkpoints.length === 0) {
+          this.push("status", "nothing to undo \u2014 no ask this session, or not a git repo with commits");
+        } else {
+          this.restoreTo(this.checkpoints.length - 1);
+        }
+        break;
+      case "checkpoints":
+        if (this.checkpoints.length === 0) {
+          this.push("status", "no checkpoints yet \u2014 one is taken before every ask in a git repo");
+        } else {
+          const lines = this.checkpoints.map((c, i) => {
+            const mins = Math.max(0, Math.round((Date.now() - c.at) / 6e4));
+            return `${i + 1}. ${c.label} \xB7 ${mins}m ago`;
+          });
+          this.push("status", `${lines.join("\n")}
+/restore <n> rewinds files to before that ask \xB7 /undo pops the last`);
+        }
+        break;
+      case "restore": {
+        const index = Number.parseInt(arg, 10);
+        if (!Number.isInteger(index) || index < 1 || index > this.checkpoints.length) {
+          this.push("status", `usage: /restore <1\u2013${Math.max(this.checkpoints.length, 1)}> \u2014 see /checkpoints`);
+        } else {
+          this.restoreTo(index - 1);
+        }
+        break;
+      }
+      case "resume": {
+        const saved = loadState(this.opts.cwd);
+        if (!saved) {
+          this.push("status", "no previous session for this project");
           break;
         }
-        case "resume": {
-          const saved = loadState(cwd);
-          if (!saved) {
-            push("status", "no previous session for this project");
+        try {
+          if (!getEngine(saved.engine).supportsResume) {
+            this.push("status", `previous engine ${saved.engine} cannot resume sessions`);
             break;
           }
-          try {
-            if (!getEngine(saved.engine).supportsResume) {
-              push("status", `previous engine ${saved.engine} cannot resume sessions`);
-              break;
-            }
-          } catch {
-            push("error", `previous engine ${saved.engine} is no longer available`);
+        } catch {
+          this.push("error", `previous engine ${saved.engine} is no longer available`);
+          break;
+        }
+        this.sessionId = saved.sessionId;
+        this.notify({ engineId: saved.engine, model: saved.model ?? this.state.model });
+        this.push("status", `resumed ${saved.engine} session${saved.lastAsk ? ` \xB7 "${saved.lastAsk}"` : ""}`);
+        break;
+      }
+      case "variants": {
+        const [sub, ...subRest] = arg.split(/\s+/);
+        if (sub === "apply") {
+          const id = subRest[0];
+          if (!id) {
+            this.push("status", "usage: /variants apply <id>");
             break;
           }
-          setEngineId(saved.engine);
-          if (saved.model) setModel(saved.model);
-          sessionRef.current = saved.sessionId;
-          push("status", `resumed ${saved.engine} session${saved.lastAsk ? ` \xB7 "${saved.lastAsk}"` : ""}`);
+          const applied = applyVariant(this.opts.cwd, id);
+          if (applied.ok) {
+            cleanVariants(this.opts.cwd);
+            this.push("status", `applied ${id} to the working tree \u2014 review with git diff`);
+          } else {
+            this.push("error", applied.detail ?? "apply failed");
+          }
           break;
         }
-        case "clear":
-          setMessages([]);
-          sessionRef.current = void 0;
-          clearState(cwd);
+        if (sub === "clean") {
+          this.push("status", `removed ${cleanVariants(this.opts.cwd)} variant(s)`);
           break;
-        case "help":
-          push(
-            "status",
-            "/engine <id> \xB7 /model <name> \xB7 /dev (start/stop server) \xB7 /check (quality gates) \xB7 /fix (send failures) \xB7 /shot (screenshots) \xB7 /review [focus] (visual self-critique) \xB7 /undo (revert last ask) \xB7 /resume (last session) \xB7 /clear (new session) \xB7 /quit"
-          );
+        }
+        if (sub === "list") {
+          const ids = listVariants(this.opts.cwd);
+          this.push("status", ids.length > 0 ? ids.join(" \xB7 ") : "no variants \u2014 /variants <2-4> <ask>");
           break;
-        case "quit":
-        case "exit":
-          devRef.current?.stop();
-          exit();
+        }
+        const n = Number.parseInt(sub ?? "", 10);
+        const ask = subRest.join(" ").trim();
+        if (!Number.isInteger(n) || n < 2 || n > 4 || ask.length === 0) {
+          this.push("status", "usage: /variants <2-4> <ask> \xB7 /variants apply <id> \xB7 list \xB7 clean");
           break;
-        default:
-          push("error", `unknown command /${name} \u2014 try /help`);
+        }
+        if (!isGitRepo(this.opts.cwd)) {
+          this.push("error", "variants need a git repo with at least one commit");
+          break;
+        }
+        void (async () => {
+          cleanVariants(this.opts.cwd);
+          this.push("status", `generating ${n} directions in parallel \u2014 this runs ${n} engine sessions`);
+          this.notify({ running: true, runStartedAt: Date.now() });
+          const engine = getEngine(this.state.engineId);
+          const runs = await runVariants(
+            this.opts.cwd,
+            ask,
+            n,
+            engine,
+            this.state.model,
+            (familyId, text) => this.push("status", `[${familyId}] ${text}`)
+          );
+          const succeeded = runs.filter((r) => r.result.ok);
+          if (succeeded.length > 0 && findChrome() && detectDevCommand(this.opts.cwd)) {
+            this.push("status", "capturing one screenshot per variant\u2026");
+            const shots = await screenshotVariants(this.opts.cwd, succeeded.map((r) => r.variant));
+            for (const shot of shots) {
+              this.push(
+                shot.path ? "status" : "error",
+                `[${shot.familyId}] ${shot.path ?? shot.error ?? "screenshot failed"}`
+              );
+            }
+          }
+          this.notify({ running: false });
+          this.push(
+            succeeded.length > 0 ? "status" : "error",
+            `${succeeded.length}/${runs.length} variants ready \u2014 /variants apply <id> keeps one, /variants clean discards`
+          );
+          this.drainQueue();
+        })();
+        break;
+      }
+      case "clear":
+        this.sessionId = void 0;
+        clearState(this.opts.cwd);
+        this.notify({ items: [], totals: { costUsd: 0, turns: 0 } });
+        break;
+      case "help":
+        this.push(
+          "status",
+          "/engine <id> \xB7 /model <name> \xB7 /mode plan|safe|yolo \xB7 /dev \xB7 /check (gates) \xB7 /fix \xB7 /shot \xB7 /review [focus] \xB7 /variants <2-4> <ask> \xB7 /undo \xB7 /checkpoints \xB7 /restore <n> \xB7 /resume \xB7 /clear \xB7 /quit"
+        );
+        break;
+      case "quit":
+      case "exit":
+        this.push("status", this.summary());
+        this.dispose();
+        this.opts.onQuit?.();
+        break;
+      default:
+        this.push("error", `unknown command /${name} \u2014 try /help`);
+    }
+  }
+};
+
+// src/tui/lineEditor.ts
+var emptyLine = { text: "", cursor: 0 };
+function fromText(text) {
+  return { text, cursor: text.length };
+}
+function insert(line, str) {
+  const clean = str.replace(/\r/g, "").replace(/\n+/g, " ");
+  return {
+    text: line.text.slice(0, line.cursor) + clean + line.text.slice(line.cursor),
+    cursor: line.cursor + clean.length
+  };
+}
+function backspace(line) {
+  if (line.cursor === 0) return line;
+  return {
+    text: line.text.slice(0, line.cursor - 1) + line.text.slice(line.cursor),
+    cursor: line.cursor - 1
+  };
+}
+function left(line) {
+  return { ...line, cursor: Math.max(0, line.cursor - 1) };
+}
+function right(line) {
+  return { ...line, cursor: Math.min(line.text.length, line.cursor + 1) };
+}
+function home(line) {
+  return { ...line, cursor: 0 };
+}
+function end(line) {
+  return { ...line, cursor: line.text.length };
+}
+var isWordChar = (ch) => /[\p{L}\p{N}_/@.-]/u.test(ch);
+function wordLeft(line) {
+  let i = line.cursor;
+  while (i > 0 && !isWordChar(line.text[i - 1])) i--;
+  while (i > 0 && isWordChar(line.text[i - 1])) i--;
+  return { ...line, cursor: i };
+}
+function wordRight(line) {
+  let i = line.cursor;
+  const n = line.text.length;
+  while (i < n && !isWordChar(line.text[i])) i++;
+  while (i < n && isWordChar(line.text[i])) i++;
+  return { ...line, cursor: i };
+}
+function killToEnd(line) {
+  return { text: line.text.slice(0, line.cursor), cursor: line.cursor };
+}
+function killToStart(line) {
+  return { text: line.text.slice(line.cursor), cursor: 0 };
+}
+function killWordBack(line) {
+  const target = wordLeft(line).cursor;
+  return {
+    text: line.text.slice(0, target) + line.text.slice(line.cursor),
+    cursor: target
+  };
+}
+
+// src/tui/markdown.tsx
+import { Box, Text } from "ink";
+
+// src/tui/themeContext.tsx
+import { createContext, useContext } from "react";
+
+// src/tui/theme.ts
+var THEMES = {
+  amber: {
+    name: "amber",
+    accent: "#e8a33d",
+    dim: "gray",
+    user: "#7aa2f7",
+    error: "#f7768e",
+    success: "#9ece6a",
+    tool: "#7dcfff"
+  },
+  ocean: {
+    name: "ocean",
+    accent: "#56b6c2",
+    dim: "gray",
+    user: "#61afef",
+    error: "#e06c75",
+    success: "#98c379",
+    tool: "#c678dd"
+  },
+  moss: {
+    name: "moss",
+    accent: "#a7c080",
+    dim: "gray",
+    user: "#7fbbb3",
+    error: "#e67e80",
+    success: "#83c092",
+    tool: "#d699b6"
+  },
+  rose: {
+    name: "rose",
+    accent: "#ebbcba",
+    dim: "gray",
+    user: "#9ccfd8",
+    error: "#eb6f92",
+    success: "#31748f",
+    tool: "#c4a7e7"
+  },
+  mono: {
+    name: "mono",
+    accent: "white",
+    dim: "gray",
+    user: "white",
+    error: "white",
+    success: "white",
+    tool: "gray"
+  }
+};
+var DEFAULT_THEME = "amber";
+function resolveTheme(name, env = process.env) {
+  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return THEMES.mono;
+  return THEMES[name ?? DEFAULT_THEME] ?? THEMES[DEFAULT_THEME];
+}
+var theme = THEMES[DEFAULT_THEME];
+
+// src/tui/themeContext.tsx
+var ThemeContext = createContext(theme);
+var ThemeProvider = ThemeContext.Provider;
+function useTheme() {
+  return useContext(ThemeContext);
+}
+
+// src/tui/markdown.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var INLINE_RE = /(\*\*[^*]+\*\*|\*[^*\s][^*]*\*|`[^`]+`)/g;
+function parseInline(text) {
+  const segments = [];
+  let last = 0;
+  for (const match of text.matchAll(INLINE_RE)) {
+    if (match.index > last) segments.push({ text: text.slice(last, match.index) });
+    const token = match[0];
+    if (token.startsWith("**")) segments.push({ text: token.slice(2, -2), bold: true });
+    else if (token.startsWith("`")) segments.push({ text: token.slice(1, -1), code: true });
+    else segments.push({ text: token.slice(1, -1), italic: true });
+    last = match.index + token.length;
+  }
+  if (last < text.length) segments.push({ text: text.slice(last) });
+  return segments;
+}
+function parseBlocks(text) {
+  const blocks = [];
+  let code = null;
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.replace(/\s+$/, "");
+    if (code) {
+      if (/^\s*```/.test(line)) {
+        blocks.push({ type: "code", ...code });
+        code = null;
+      } else {
+        code.lines.push(rawLine);
       }
-    },
-    [push, exit, cwd, getDevServer, runTurn, capture]
+      continue;
+    }
+    const fence = /^\s*```(\S*)/.exec(line);
+    if (fence) {
+      code = { lang: fence[1] ?? "", lines: [] };
+      continue;
+    }
+    const heading = /^(#{1,4})\s+(.*)$/.exec(line);
+    if (heading) {
+      blocks.push({ type: "heading", level: heading[1].length, text: heading[2] });
+      continue;
+    }
+    if (/^\s*([-*_])\s*\1\s*\1[\s\-*_]*$/.test(line) && line.trim().length >= 3) {
+      blocks.push({ type: "hr" });
+      continue;
+    }
+    const item = /^(\s*)[-*+]\s+(.*)$/.exec(line);
+    if (item) {
+      blocks.push({ type: "item", text: item[2], indent: Math.floor(item[1].length / 2) });
+      continue;
+    }
+    const ordered = /^(\s*)(\d+)[.)]\s+(.*)$/.exec(line);
+    if (ordered) {
+      blocks.push({
+        type: "item",
+        text: ordered[3],
+        indent: Math.floor(ordered[1].length / 2),
+        ordered: ordered[2]
+      });
+      continue;
+    }
+    const quote = /^\s*>\s?(.*)$/.exec(line);
+    if (quote) {
+      blocks.push({ type: "quote", text: quote[1] });
+      continue;
+    }
+    blocks.push({ type: "para", text: line });
+  }
+  if (code) blocks.push({ type: "code", ...code });
+  return blocks;
+}
+function Inline({ text, dim }) {
+  const theme2 = useTheme();
+  const segments = parseInline(text);
+  return /* @__PURE__ */ jsx(Text, { wrap: "wrap", dimColor: dim, children: segments.map(
+    (segment, index) => segment.code ? /* @__PURE__ */ jsx(Text, { color: theme2.tool, children: segment.text }, index) : /* @__PURE__ */ jsx(Text, { bold: segment.bold, italic: segment.italic, children: segment.text }, index)
+  ) });
+}
+function Markdown({ text }) {
+  const theme2 = useTheme();
+  const blocks = parseBlocks(text);
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: blocks.map((block, index) => {
+    switch (block.type) {
+      case "heading":
+        return /* @__PURE__ */ jsx(Text, { bold: true, color: block.level <= 2 ? theme2.accent : void 0, wrap: "wrap", children: block.text }, index);
+      case "item":
+        return /* @__PURE__ */ jsxs(Box, { paddingLeft: 1 + block.indent * 2, children: [
+          /* @__PURE__ */ jsxs(Text, { color: theme2.accent, children: [
+            block.ordered ? `${block.ordered}.` : "\u2022",
+            " "
+          ] }),
+          /* @__PURE__ */ jsx(Inline, { text: block.text })
+        ] }, index);
+      case "quote":
+        return /* @__PURE__ */ jsxs(Box, { paddingLeft: 1, children: [
+          /* @__PURE__ */ jsx(Text, { color: theme2.dim, children: "\u2502 " }),
+          /* @__PURE__ */ jsx(Inline, { text: block.text, dim: true })
+        ] }, index);
+      case "code":
+        return /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingLeft: 1, children: block.lines.map((line, lineIndex) => /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: theme2.dim, children: "\u258F " }),
+          /* @__PURE__ */ jsx(Text, { color: theme2.tool, children: line.length > 0 ? line : " " })
+        ] }, lineIndex)) }, index);
+      case "hr":
+        return /* @__PURE__ */ jsx(Text, { color: theme2.dim, children: "\u2500".repeat(32) }, index);
+      case "para":
+        return block.text.length === 0 ? /* @__PURE__ */ jsx(Text, { children: " " }, index) : /* @__PURE__ */ jsx(Inline, { text: block.text }, index);
+    }
+  }) });
+}
+
+// src/tui/messages.tsx
+import { Text as Text2 } from "ink";
+import { useEffect, useState } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var PHRASES = ["working", "thinking", "squinting", "crafting", "still at it"];
+function WorkingLine({ startedAt }) {
+  const theme2 = useTheme();
+  const [frame, setFrame] = useState(0);
+  const [elapsed, setElapsed] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((f) => (f + 1) % SPINNER_FRAMES.length);
+      setElapsed(Math.floor((Date.now() - startedAt) / 1e3));
+    }, 80);
+    return () => clearInterval(timer);
+  }, [startedAt]);
+  const phrase = PHRASES[Math.min(Math.floor(elapsed / 8), PHRASES.length - 1)];
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { color: theme2.accent, children: SPINNER_FRAMES[frame] }),
+    /* @__PURE__ */ jsxs2(Text2, { color: theme2.dim, children: [
+      " ",
+      phrase,
+      "\u2026 ",
+      elapsed,
+      "s \xB7 esc to interrupt"
+    ] })
+  ] });
+}
+function toolGlyph(text) {
+  const name = text.split(/[\s·]/, 1)[0]?.toLowerCase() ?? "";
+  if (name.includes("todo")) return "\u2630";
+  if (name.includes("read") || name.includes("view") || name.includes("cat")) return "\u2299";
+  if (name.includes("edit") || name.includes("write") || name.includes("patch") || name.includes("apply")) return "\u270E";
+  if (name.includes("bash") || name.includes("shell") || name.includes("exec") || name.includes("command")) return "$";
+  if (name.includes("grep") || name.includes("glob") || name.includes("search") || name.includes("find")) return "\u2315";
+  if (name.includes("web") || name.includes("fetch") || name.includes("http")) return "\u21E3";
+  if (name.includes("task") || name.includes("agent")) return "\u25C7";
+  return "\u2699";
+}
+function MessageLine({ message }) {
+  const theme2 = useTheme();
+  switch (message.role) {
+    case "user":
+      return /* @__PURE__ */ jsxs2(Text2, { color: theme2.user, wrap: "wrap", children: [
+        "\u276F ",
+        message.text
+      ] });
+    case "assistant":
+      return /* @__PURE__ */ jsx2(Markdown, { text: message.text });
+    case "status":
+      return /* @__PURE__ */ jsxs2(Text2, { color: theme2.dim, wrap: "wrap", children: [
+        "\xB7 ",
+        message.text
+      ] });
+    case "tool":
+      return /* @__PURE__ */ jsxs2(Text2, { color: theme2.tool, wrap: "wrap", children: [
+        toolGlyph(message.text),
+        " ",
+        message.text
+      ] });
+    case "thinking":
+      return /* @__PURE__ */ jsx2(Text2, { color: theme2.dim, italic: true, wrap: "wrap", children: message.text });
+    case "error":
+      return /* @__PURE__ */ jsxs2(Text2, { color: theme2.error, wrap: "wrap", children: [
+        "\u2717 ",
+        message.text
+      ] });
+  }
+}
+
+// src/tui/App.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function App({
+  cwd,
+  initialEngine,
+  initialModel,
+  autoDev,
+  autoFix,
+  autoProbe,
+  autoCheck,
+  bell,
+  initialTheme
+}) {
+  const { exit } = useApp();
+  const [themeName, setThemeName] = useState2(() => resolveTheme(initialTheme).name);
+  const theme2 = resolveTheme(themeName);
+  const sessionRef = useRef(null);
+  if (!sessionRef.current) {
+    sessionRef.current = new Session({
+      cwd,
+      engineId: initialEngine,
+      model: initialModel,
+      autoDev,
+      autoFix,
+      autoProbe,
+      autoCheck,
+      // Delay lets the goodbye summary land in the Static scrollback.
+      onQuit: () => setTimeout(() => exit(), 60)
+    });
+  }
+  const session = sessionRef.current;
+  const state = useSyncExternalStore(
+    useMemo(() => (listener) => session.subscribe(listener), [session]),
+    () => session.getState()
   );
+  const [line, setLine] = useState2(emptyLine);
+  const historyRef = useRef([]);
+  const historyIndexRef = useRef(-1);
+  const ctrlCArmedAtRef = useRef(0);
+  const wasRunningRef = useRef(false);
+  if (wasRunningRef.current && !state.running && bell !== false) {
+    process.stdout.write("\x07");
+  }
+  wasRunningRef.current = state.running;
   useInput((char, key) => {
     if (key.ctrl && char === "c") {
-      devRef.current?.stop();
-      exit();
+      const now = Date.now();
+      if (now - ctrlCArmedAtRef.current < 2e3) {
+        session.note(session.summary());
+        session.dispose();
+        setTimeout(() => exit(), 60);
+      } else {
+        ctrlCArmedAtRef.current = now;
+        session.note("press ctrl+c again to exit");
+      }
       return;
     }
-    if (running) {
-      if (key.escape) abortRef.current?.abort();
+    if (key.escape && state.running) {
+      session.interrupt();
+      return;
+    }
+    if (key.tab && key.shift) {
+      session.cycleMode();
       return;
     }
     if (key.return) {
-      const value = input.trim();
-      setInput("");
+      const value = line.text.trim();
+      setLine(emptyLine);
       historyIndexRef.current = -1;
       if (!value) return;
       historyRef.current.push(value);
-      if (value.startsWith("/")) {
-        handleCommand(value);
-      } else {
-        void submit(value);
+      if (value === "/theme" || value.startsWith("/theme ")) {
+        const requested = value.slice("/theme".length).trim();
+        if (!requested) {
+          session.note(`themes: ${Object.keys(THEMES).join(", ")} \u2014 /theme <name>`);
+        } else if (THEMES[requested]) {
+          setThemeName(requested);
+          session.note(`theme \u2192 ${requested}`);
+        } else {
+          session.note(`unknown theme "${requested}" \u2014 themes: ${Object.keys(THEMES).join(", ")}`);
+        }
+        return;
       }
+      session.input(value);
       return;
     }
     if (key.upArrow) {
@@ -605,7 +1168,7 @@ ${result.a11y.slice(0, 5).join("\n")}`);
       if (history.length === 0) return;
       const next = historyIndexRef.current === -1 ? history.length - 1 : Math.max(historyIndexRef.current - 1, 0);
       historyIndexRef.current = next;
-      setInput(history[next] ?? "");
+      setLine(fromText(history[next] ?? ""));
       return;
     }
     if (key.downArrow) {
@@ -614,44 +1177,93 @@ ${result.a11y.slice(0, 5).join("\n")}`);
       const next = historyIndexRef.current + 1;
       if (next >= history.length) {
         historyIndexRef.current = -1;
-        setInput("");
+        setLine(emptyLine);
       } else {
         historyIndexRef.current = next;
-        setInput(history[next] ?? "");
+        setLine(fromText(history[next] ?? ""));
       }
       return;
     }
+    if (key.leftArrow) {
+      setLine((prev) => key.meta ? wordLeft(prev) : left(prev));
+      return;
+    }
+    if (key.rightArrow) {
+      setLine((prev) => key.meta ? wordRight(prev) : right(prev));
+      return;
+    }
     if (key.backspace || key.delete) {
-      setInput((prev) => prev.slice(0, -1));
+      setLine((prev) => key.meta ? killWordBack(prev) : backspace(prev));
       return;
     }
-    if (char && !key.ctrl && !key.meta) {
-      setInput((prev) => prev + char);
+    if (key.ctrl) {
+      switch (char) {
+        case "a":
+          setLine(home);
+          return;
+        case "e":
+          setLine(end);
+          return;
+        case "k":
+          setLine(killToEnd);
+          return;
+        case "u":
+          setLine(killToStart);
+          return;
+        case "w":
+          setLine(killWordBack);
+          return;
+      }
+      return;
+    }
+    if (char && !key.meta) {
+      setLine((prev) => insert(prev, char));
     }
   });
-  const devBadge = devState === "running" ? ` \xB7 ${devUrl ?? "dev running"}` : devState === "starting" ? " \xB7 dev starting\u2026" : devState === "crashed" ? " \xB7 dev crashed" : "";
-  return /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", paddingX: 1, children: [
-    /* @__PURE__ */ jsx2(Static, { items: messages, children: (message) => /* @__PURE__ */ jsx2(Box, { children: /* @__PURE__ */ jsx2(MessageLine, { message }) }, message.id) }),
-    liveText.length > 0 && /* @__PURE__ */ jsx2(Box, { children: /* @__PURE__ */ jsx2(Text2, { wrap: "wrap", children: liveText }) }),
-    /* @__PURE__ */ jsx2(Box, { marginTop: 1, children: running ? /* @__PURE__ */ jsx2(WorkingLine, { startedAt: runStartedAt }) : /* @__PURE__ */ jsxs2(Text2, { children: [
-      /* @__PURE__ */ jsx2(Text2, { color: theme.accent, children: "\u276F " }),
-      input,
-      /* @__PURE__ */ jsx2(Text2, { color: theme.accent, children: "\u258F" })
+  const devBadge = state.devState === "running" ? ` \xB7 ${state.devUrl ?? "dev running"}` : state.devState === "starting" ? " \xB7 dev starting\u2026" : state.devState === "crashed" ? " \xB7 dev crashed" : "";
+  const totalsBadge = state.totals.turns > 0 ? ` \xB7 ${state.totals.turns} turn${state.totals.turns === 1 ? "" : "s"}${state.totals.costUsd > 0 ? ` \xB7 $${state.totals.costUsd.toFixed(2)}` : ""}` : "";
+  return /* @__PURE__ */ jsx3(ThemeProvider, { value: theme2, children: /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx3(Static, { items: state.items, children: (item) => /* @__PURE__ */ jsx3(Box2, { children: /* @__PURE__ */ jsx3(MessageLine, { message: item }) }, item.id) }),
+    state.liveText.length > 0 && /* @__PURE__ */ jsx3(Box2, { children: /* @__PURE__ */ jsx3(Markdown, { text: state.liveText }) }),
+    state.running && /* @__PURE__ */ jsx3(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx3(WorkingLine, { startedAt: state.runStartedAt }) }),
+    state.queue.map((queued, index) => /* @__PURE__ */ jsx3(Box2, { children: /* @__PURE__ */ jsxs3(Text3, { color: theme2.dim, children: [
+      "\u22EF queued: ",
+      queued
+    ] }) }, index)),
+    /* @__PURE__ */ jsx3(Box2, { marginTop: state.running ? 0 : 1, children: /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: theme2.accent, children: "\u276F " }),
+      line.text.slice(0, line.cursor),
+      /* @__PURE__ */ jsx3(Text3, { inverse: true, children: line.text[line.cursor] ?? " " }),
+      line.text.slice(line.cursor + 1)
     ] }) }),
-    /* @__PURE__ */ jsx2(Box, { children: /* @__PURE__ */ jsxs2(Text2, { color: theme.dim, children: [
-      engineId,
-      model ? ` \xB7 ${model}` : "",
+    /* @__PURE__ */ jsx3(Box2, { children: /* @__PURE__ */ jsxs3(Text3, { color: theme2.dim, children: [
+      /* @__PURE__ */ jsxs3(
+        Text3,
+        {
+          color: state.mode === "yolo" ? theme2.error : state.mode === "plan" ? theme2.user : theme2.dim,
+          bold: state.mode !== "safe",
+          children: [
+            "[",
+            state.mode,
+            "]"
+          ]
+        }
+      ),
+      " ",
+      state.engineId,
+      state.model ? ` \xB7 ${state.model}` : "",
       " \xB7 ",
-      path2.basename(cwd),
+      path3.basename(cwd),
       devBadge,
-      " \xB7 /help"
+      totalsBadge,
+      " \xB7 shift+tab mode \xB7 /help"
     ] }) })
-  ] });
+  ] }) });
 }
 
 // src/cli.tsx
-import { jsx as jsx3 } from "react/jsx-runtime";
-var VERSION = "0.1.3";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var VERSION = "0.2.1";
 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);
 program.command("run").description("Run one prompt headlessly and stream the result").argument("<prompt...>", "what to build or change").option("-e, --engine <id>", "engine to use (claude, codex, gemini, opencode)").option("-m, --model <name>", "model override for the engine").option("--no-brief", "send the prompt without the squint design brief").option("--json", "emit normalized agent events as ndjson").action(
@@ -685,18 +1297,41 @@ program.command("engines").description("List engines and whether they are instal
     console.log(`${status} ${engine.id.padEnd(10)} ${engine.name.padEnd(14)} ${location}`);
   }
 });
-program.command("doctor").description("Check squint prerequisites and engine availability").action(async () => {
+program.command("doctor").description("Check squint prerequisites and engine availability").option("--probe", "run each detected engine with a one-word prompt to verify auth works").action(async (options) => {
   const [major] = process.versions.node.split(".");
-  const nodeOk = Number(major) >= 20;
-  console.log(`${nodeOk ? pc.green("\u2713") : pc.red("\u2717")} node ${process.versions.node}${nodeOk ? "" : " (need >= 20)"}`);
+  const nodeOk = Number(major) >= 22;
+  console.log(`${nodeOk ? pc.green("\u2713") : pc.red("\u2717")} node ${process.versions.node}${nodeOk ? "" : " (need >= 22)"}`);
   const detected = detectEngines();
   for (const { engine, path: binaryPath } of detected) {
     const status = binaryPath ? pc.green("\u2713") : pc.yellow("\u25CB");
     console.log(`${status} ${engine.name}${binaryPath ? "" : pc.dim(` \u2014 install: ${engine.install}`)}`);
   }
-  const { findChrome } = await import("./chrome-4WNYZZ42.js");
-  const { hasWebSocket } = await import("./cdp-R7Y2XSZQ.js");
-  const chrome = findChrome();
+  if (options.probe) {
+    const { runAgent: runAgent2 } = await import("./run-XHLCTF6V.js");
+    console.log(pc.dim("\nprobing engines with a one-word prompt (verifies auth end to end)\u2026"));
+    for (const { engine, path: binaryPath } of detected) {
+      if (!binaryPath) continue;
+      const startedAt = Date.now();
+      const abort = new AbortController();
+      const timer = setTimeout(() => abort.abort(), 9e4);
+      const result = await runAgent2(
+        engine,
+        { prompt: "Reply with exactly: ok", cwd: process.cwd() },
+        () => {
+        },
+        abort.signal
+      );
+      clearTimeout(timer);
+      const secs = ((Date.now() - startedAt) / 1e3).toFixed(1);
+      const detail = (result.error ?? "failed").split("\n").filter((l) => l.trim()).at(-1) ?? "failed";
+      console.log(
+        result.ok ? `${pc.green("\u2713")} ${engine.id.padEnd(10)} responded in ${secs}s` : `${pc.red("\u2717")} ${engine.id.padEnd(10)} ${pc.dim(detail.slice(0, 110))}`
+      );
+    }
+  }
+  const { findChrome: findChrome2 } = await import("./chrome-RD7XQ767.js");
+  const { hasWebSocket } = await import("./cdp-RTWPFIX5.js");
+  const chrome = findChrome2();
   console.log(
     chrome ? `${pc.green("\u2713")} Chrome ${pc.dim(chrome)}` : `${pc.yellow("\u25CB")} Chrome ${pc.dim("\u2014 screenshots and runtime probing disabled")}`
   );
@@ -713,7 +1348,7 @@ ${available.length} engine(s) ready.`));
   }
 });
 program.command("init").description("Scaffold a new Vite + React + TS + Tailwind app with token-first CSS").argument("[dir]", "target directory", ".").option("--force", "write into a non-empty directory").option("--no-install", "skip npm install").action(async (dir, options) => {
-  const { installDependencies, writeTemplate } = await import("./init-7AYGAKOS.js");
+  const { installDependencies, writeTemplate } = await import("./init-LSYB32NS.js");
   let result;
   try {
     result = writeTemplate(dir, { force: options.force });
@@ -737,10 +1372,49 @@ program.command("init").description("Scaffold a new Vite + React + TS + Tailwind
 Next: ${pc.bold(`${cd}${options.install ? "" : "npm install && "}squint`)}`);
   console.log(pc.dim("then describe what to build \u2014 /dev starts the preview server"));
 });
+var skillsCommand = program.command("skills").description("Project knowledge injected into asks (.squint/rules.md + .squint/skills/)");
+skillsCommand.command("list").description("Show always-on rules and trigger-matched skills").action(async () => {
+  const { loadRules, loadSkills } = await import("./skills-UGHU22BS.js");
+  const cwd = process.cwd();
+  const rules = loadRules(cwd);
+  console.log(rules ? `${pc.green("\u2713")} rules.md ${pc.dim(`(${rules.split("\n").length} lines, always on)`)}` : pc.dim("\u25CB no .squint/rules.md"));
+  const skills = loadSkills(cwd);
+  if (skills.length === 0) {
+    console.log(pc.dim("\u25CB no skills \u2014 squint skills init writes an example"));
+    return;
+  }
+  for (const skill of skills) {
+    console.log(`${pc.green("\u2713")} ${skill.name.padEnd(20)} ${pc.dim(`triggers: ${skill.triggers.join(", ")}`)}`);
+  }
+});
+skillsCommand.command("init").description("Scaffold .squint/rules.md and an example skill").action(async () => {
+  const fs2 = await import("fs");
+  const nodePath = await import("path");
+  const cwd = process.cwd();
+  const skillsDir = nodePath.join(cwd, ".squint", "skills");
+  fs2.mkdirSync(skillsDir, { recursive: true });
+  const rules = nodePath.join(cwd, ".squint", "rules.md");
+  if (!fs2.existsSync(rules)) {
+    fs2.writeFileSync(
+      rules,
+      "# Project rules\n\nThese ride along on every squint ask. Keep them short \u2014 cut anything that would not cause a mistake if removed.\n"
+    );
+    console.log(pc.green("\u2713 .squint/rules.md"));
+  }
+  const example = nodePath.join(skillsDir, "example.md");
+  if (!fs2.existsSync(example)) {
+    fs2.writeFileSync(
+      example,
+      "---\ntriggers: example, sample\n---\n\nThis note is injected only when an ask mentions one of the triggers above.\nDocument the parts of this repo an agent would otherwise rediscover every time:\nwhere state lives, which helpers to reuse, what not to touch.\n"
+    );
+    console.log(pc.green("\u2713 .squint/skills/example.md"));
+  }
+  console.log(pc.dim("rules are always-on; skills inject when an ask mentions a trigger"));
+});
 program.command("tag").description("Add the element picker to this Vite app (Alt+S in the browser \u2192 click \u2192 file:line:col)").action(async () => {
   const fs2 = await import("fs");
   const nodePath = await import("path");
-  const { patchViteConfig, TAGGER_FILENAME, TAGGER_SOURCE } = await import("./source-MEXHWVP4.js");
+  const { patchViteConfig, TAGGER_FILENAME, TAGGER_SOURCE } = await import("./source-ZZU245VN.js");
   const cwd = process.cwd();
   const taggerPath = nodePath.join(cwd, TAGGER_FILENAME);
   fs2.writeFileSync(taggerPath, TAGGER_SOURCE);
@@ -776,21 +1450,21 @@ variantsCommand.command("gen").description("Generate n variants of one ask in pa
       process.exitCode = 1;
       return;
     }
-    const { isGitRepo } = await import("./snapshot-KKUY5RR6.js");
-    if (!isGitRepo(cwd)) {
+    const { isGitRepo: isGitRepo2 } = await import("./snapshot-KKUY5RR6.js");
+    if (!isGitRepo2(cwd)) {
       console.error(pc.red("\u2717 variants need a git repo with at least one commit"));
       process.exitCode = 1;
       return;
     }
-    const { runVariants, cleanVariants } = await import("./variants-VVIYT7WI.js");
+    const { runVariants: runVariants2, cleanVariants: cleanVariants2 } = await import("./variants-7A7723L7.js");
     const config = loadConfig(defaultPaths(cwd));
     const engineId = resolveEngineId(config, options.engine);
     const engine = getEngine(engineId);
     const model = resolveModel(config, engineId, options.model);
     const ask = promptWords.join(" ");
-    cleanVariants(cwd);
+    cleanVariants2(cwd);
     console.log(pc.dim(`generating ${n} directions in parallel via ${engine.id} \u2014 this runs ${n} engine sessions`));
-    const runs = await runVariants(
+    const runs = await runVariants2(
       cwd,
       ask,
       n,
@@ -800,9 +1474,9 @@ variantsCommand.command("gen").description("Generate n variants of one ask in pa
     );
     const succeeded = runs.filter((r) => r.result.ok);
     if (options.shots && succeeded.length > 0) {
-      const { screenshotVariants } = await import("./shots-ADBOBALL.js");
+      const { screenshotVariants: screenshotVariants2 } = await import("./shots-LRYYMTPK.js");
       console.log(pc.dim("capturing screenshots\u2026"));
-      const shots = await screenshotVariants(cwd, succeeded.map((r) => r.variant));
+      const shots = await screenshotVariants2(cwd, succeeded.map((r) => r.variant));
       for (const shot of shots) {
         console.log(`${pc.green("\u2713")} ${shot.familyId.padEnd(18)} ${shot.path ?? pc.dim(shot.error ?? "")}`);
       }
@@ -815,8 +1489,8 @@ ${succeeded.length}/${runs.length} variants ready in .squint/variants/ \u2014 `
   }
 );
 variantsCommand.command("list").description("List generated variants").action(async () => {
-  const { listVariants } = await import("./variants-VVIYT7WI.js");
-  const ids = listVariants(process.cwd());
+  const { listVariants: listVariants2 } = await import("./variants-7A7723L7.js");
+  const ids = listVariants2(process.cwd());
   if (ids.length === 0) {
     console.log(pc.dim('no variants \u2014 squint variants gen <n> "<ask>"'));
     return;
@@ -824,26 +1498,26 @@ variantsCommand.command("list").description("List generated variants").action(as
   for (const id of ids) console.log(id);
 });
 variantsCommand.command("apply").description("Apply one variant\u2019s changes to the main tree and discard the rest").argument("<id>", "family id of the winning variant").action(async (id) => {
-  const { applyVariant, cleanVariants } = await import("./variants-VVIYT7WI.js");
+  const { applyVariant: applyVariant2, cleanVariants: cleanVariants2 } = await import("./variants-7A7723L7.js");
   const cwd = process.cwd();
-  const result = applyVariant(cwd, id);
+  const result = applyVariant2(cwd, id);
   if (!result.ok) {
     console.error(pc.red(`\u2717 ${result.detail}`));
     process.exitCode = 1;
     return;
   }
-  cleanVariants(cwd);
+  cleanVariants2(cwd);
   console.log(pc.green(`\u2713 applied ${id} to the working tree`) + pc.dim(" \u2014 review with git diff"));
 });
 variantsCommand.command("clean").description("Discard all variants").action(async () => {
-  const { cleanVariants } = await import("./variants-VVIYT7WI.js");
-  const count = cleanVariants(process.cwd());
+  const { cleanVariants: cleanVariants2 } = await import("./variants-7A7723L7.js");
+  const count = cleanVariants2(process.cwd());
   console.log(pc.dim(`removed ${count} variant(s)`));
 });
 program.command("brief").description("Set a committed design direction for this project (.squint/brief.md)").argument("[family]", "aesthetic family id (omit to list)").option("--force", "overwrite an existing project brief").action(async (familyId, options) => {
   const fs2 = await import("fs");
   const nodePath = await import("path");
-  const { FAMILIES, getFamily, renderFamilyBrief } = await import("./families-RVP5BWQD.js");
+  const { FAMILIES, getFamily, renderFamilyBrief } = await import("./families-2G5SLLY7.js");
   if (!familyId) {
     console.log(pc.bold("Aesthetic families") + pc.dim(" \u2014 squint brief <id>\n"));
     for (const family2 of FAMILIES) {
@@ -870,7 +1544,7 @@ program.command("brief").description("Set a committed design direction for this
   console.log(pc.dim("every squint ask in this repo now holds this direction \u2014 edit the file to remix"));
 });
 program.command("check").description("Run this project\u2019s quality gates (typecheck, lint, test, build)").action(async () => {
-  const { detectGates: detectGates2, runGates: runGates2 } = await import("./gates-G5DABJWQ.js");
+  const { detectGates: detectGates2, runGates: runGates2 } = await import("./gates-I2GGQGMA.js");
   const cwd = process.cwd();
   const gates = detectGates2(cwd);
   if (gates.length === 0) {
@@ -886,7 +1560,7 @@ program.command("check").description("Run this project\u2019s quality gates (typ
   if (results.some((r) => !r.ok)) process.exitCode = 1;
 });
 program.command("shot").description("Screenshot a running app at mobile/tablet/desktop viewports").argument("<url>", "URL of the running app (e.g. http://localhost:5173)").action(async (url) => {
-  const { captureViewports: captureViewports2 } = await import("./preview-AA6YIE5W.js");
+  const { captureViewports: captureViewports2 } = await import("./preview-XQ7EOHV4.js");
   const result = await captureViewports2(process.cwd(), url);
   if (!result) {
     console.error(pc.red("\u2717 no Chrome/Chromium found"));
@@ -919,7 +1593,7 @@ program.action(() => {
   const engineId = resolveEngineId(config);
   const model = resolveModel(config, engineId);
   render(
-    /* @__PURE__ */ jsx3(
+    /* @__PURE__ */ jsx4(
       App,
       {
         cwd,
@@ -927,7 +1601,10 @@ program.action(() => {
         initialModel: model,
         autoDev: config.autoDev,
         autoFix: config.autoFix,
-        autoProbe: config.autoProbe
+        autoProbe: config.autoProbe,
+        autoCheck: config.autoCheck,
+        bell: config.bell,
+        initialTheme: config.theme
       }
     )
   );