@aayambansal/squint 0.2.1 → 0.2.2

package/README.md

@@ -123,9 +123,10 @@ squint check                      # gates: typecheck -> lint -> test -> build
 squint shot http://localhost:5173 # screenshots at 390/768/1440
 squint brief                      # list design directions
 squint brief cinematic-dark       # commit one for this repo
-squint tag                        # add the Alt+S element picker to any Vite app
+squint tag                        # Alt+S element picker: pin elements + notes, alt+enter copies all
 squint variants gen 3 "<ask>"     # 3 parallel design explorations
 squint variants apply terminal    # keep the winner
+squint skills init                # scaffold .squint/rules.md + a trigger-matched skill
 squint config set engine claude
 squint config set models.claude claude-sonnet-5
 squint config set autoDev true    # dev server starts with the TUI
@@ -134,6 +135,7 @@ squint config set autoCheck false # skip the per-turn typecheck+lint pass
 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
+squint doctor --probe             # run every engine end to end, verify auth actually works
 ```
 
 **Inside the TUI:**
@@ -144,10 +146,21 @@ squint doctor                     # engines + Chrome + WebSocket check
   order; `/queue clear` drops them. `Esc` interrupts the current turn.
 - **Editing**: a real line editor — arrows move, `alt+←/→` jump words, `ctrl+a/e/k/u/w`,
   `↑/↓` history. `ctrl+c` twice exits with a session summary.
-- **Commands**: `/dev` `/check` `/fix` `/shot` `/review [focus]` `/undo` `/checkpoints`
-  `/restore <n>` `/mode` `/theme` `/resume` `/engine <id>` `/model <name>` `/clear`.
-- Assistant output renders as markdown; the footer tracks session turns and cost; a bell
-  rings when a turn finishes.
+- **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.
+- **Variants without leaving**: `/variants 3 <ask>` runs parallel explorations with
+  streaming per-family status; `/variants apply <id>` keeps the winner.
+- **Commands**: `/dev` `/check` `/problems` `/fix [n]` `/shot` `/review [focus]`
+  `/variants` `/undo` `/checkpoints` `/restore <n>` `/mode` `/theme` `/resume`
+  `/engine <id>` `/model <name>` `/clear`.
+- Assistant output renders as markdown; the done line measures real work via git
+  (`3 files +42 −7`); the footer tracks session turns and cost; a bell rings when a
+  turn finishes.
+
+**Project knowledge** rides along automatically: `.squint/rules.md` on every ask, and
+`.squint/skills/*.md` (frontmatter `triggers: auth, login`) only when an ask mentions a
+trigger — deterministic context routing, no embeddings.
 
 ## Design directions
 

package/dist/cdp-SFWNP7OA.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  cdpCapture,
+  hasWebSocket,
+  pixelDiffPct
+} from "./chunk-OC6RU6XH.js";
+export {
+  cdpCapture,
+  hasWebSocket,
+  pixelDiffPct
+};

package/dist/{chunk-REDPR3KI.js → chunk-73ULM6HF.js}

@@ -2,7 +2,7 @@
 import {
   cdpCapture,
   hasWebSocket
-} from "./chunk-VJGE7HSP.js";
+} from "./chunk-OC6RU6XH.js";
 import {
   findChrome,
   screenshot
@@ -126,16 +126,29 @@ ${blocks.join("\n\n")}
 
 Fix these first \u2014 a page that errors is broken regardless of how it looks.`;
 }
-async function probeRuntime(url) {
+async function probeRuntime(url, cwd) {
   const chrome = findChrome();
   if (!chrome || !hasWebSocket()) return null;
   try {
-    const { report } = await cdpCapture(chrome, url, os.tmpdir(), [], 1500);
-    return report;
+    const dir = cwd ? previewDir(cwd) : os.tmpdir();
+    const { report, shots } = await cdpCapture(
+      chrome,
+      url,
+      dir,
+      cwd ? [{ name: "pulse", width: 1280, height: 800 }] : [],
+      1500
+    );
+    return { report, pulsePath: shots[0]?.path };
   } catch {
     return null;
   }
 }
+async function comparePulse(previous, current) {
+  const chrome = findChrome();
+  if (!chrome || !hasWebSocket()) return null;
+  const { pixelDiffPct } = await import("./cdp-SFWNP7OA.js");
+  return pixelDiffPct(chrome, previous, current);
+}
 function buildRuntimeFixPrompt(report) {
   return `The running app has runtime problems.${runtimeSection(report)}
 
@@ -169,6 +182,7 @@ export {
   captureViewports,
   runtimeSummary,
   probeRuntime,
+  comparePulse,
   buildRuntimeFixPrompt,
   buildReviewPrompt
 };

package/dist/{chunk-VJGE7HSP.js → chunk-OC6RU6XH.js}

@@ -152,6 +152,55 @@ var describe = (value) => {
   }
   return String(value);
 };
+async function pixelDiffPct(chromePath, pngA, pngB) {
+  const { child, wsUrl, profileDir } = await launchChrome(chromePath);
+  let connection = null;
+  try {
+    connection = await CdpConnection.connect(wsUrl, 1e4);
+    const { targetId } = await connection.send("Target.createTarget", { url: "about:blank" });
+    const { sessionId } = await connection.send("Target.attachToTarget", { targetId, flatten: true });
+    await connection.send("Runtime.enable", {}, sessionId);
+    const expression = `(async () => {
+      const load = (src) => new Promise((resolve, reject) => {
+        const img = new Image();
+        img.onload = () => resolve(img);
+        img.onerror = () => reject(new Error('decode'));
+        img.src = src;
+      });
+      const a = await load('data:image/png;base64,${pngA.toString("base64")}');
+      const b = await load('data:image/png;base64,${pngB.toString("base64")}');
+      const w = Math.min(a.width, b.width), h = Math.min(a.height, b.height);
+      if (w === 0 || h === 0) return null;
+      const draw = (img) => {
+        const c = document.createElement('canvas');
+        c.width = w; c.height = h;
+        const ctx = c.getContext('2d');
+        ctx.drawImage(img, 0, 0);
+        return ctx.getImageData(0, 0, w, h).data;
+      };
+      const da = draw(a), db = draw(b);
+      let differ = 0, total = 0;
+      for (let i = 0; i < da.length; i += 8) {
+        total++;
+        if (Math.abs(da[i] - db[i]) > 8 || Math.abs(da[i + 1] - db[i + 1]) > 8 || Math.abs(da[i + 2] - db[i + 2]) > 8) differ++;
+      }
+      const sizePenalty = (a.width !== b.width || a.height !== b.height) ? 1 : 0;
+      return Math.min(100, (differ / total) * 100 + sizePenalty);
+    })()`;
+    const { result } = await connection.send(
+      "Runtime.evaluate",
+      { expression, awaitPromise: true, returnByValue: true },
+      sessionId
+    );
+    return typeof result?.value === "number" ? result.value : null;
+  } catch {
+    return null;
+  } finally {
+    connection?.close();
+    child.kill("SIGKILL");
+    setTimeout(() => fs.rmSync(profileDir, { recursive: true, force: true }), 500).unref?.();
+  }
+}
 async function cdpCapture(chromePath, url, outDir, viewports, settleMs = 2500, audit = false) {
   const { child, wsUrl, profileDir } = await launchChrome(chromePath);
   const report = { consoleErrors: [], pageErrors: [], failedRequests: [] };
@@ -239,5 +288,6 @@ async function cdpCapture(chromePath, url, outDir, viewports, settleMs = 2500, a
 
 export {
   hasWebSocket,
+  pixelDiffPct,
   cdpCapture
 };

package/dist/{chunk-WTA6YYBY.js → chunk-YHRAOBI2.js}

@@ -28,6 +28,22 @@ function takeSnapshot(cwd) {
     return null;
   }
 }
+function diffStatSince(cwd, snapshot) {
+  try {
+    const source = snapshot.stashHash ?? "HEAD";
+    const stat = git(cwd, ["diff", "--shortstat", source]);
+    const files = /(\d+) files? changed/.exec(stat);
+    if (!files) return null;
+    const insertions = /(\d+) insertions?/.exec(stat);
+    const deletions = /(\d+) deletions?/.exec(stat);
+    let out = `${files[1]} file${files[1] === "1" ? "" : "s"}`;
+    if (insertions) out += ` +${insertions[1]}`;
+    if (deletions) out += ` \u2212${deletions[1]}`;
+    return out;
+  } catch {
+    return null;
+  }
+}
 function restoreSnapshot(cwd, snapshot) {
   try {
     const before = new Set(snapshot.untracked);
@@ -50,5 +66,6 @@ function restoreSnapshot(cwd, snapshot) {
 export {
   isGitRepo,
   takeSnapshot,
+  diffStatSince,
   restoreSnapshot
 };

package/dist/cli.js

@@ -28,12 +28,13 @@ import {
   buildRuntimeFixPrompt,
   captureViewports,
   clearState,
+  comparePulse,
   loadState,
   probeRuntime,
   runtimeSummary,
   saveState
-} from "./chunk-REDPR3KI.js";
-import "./chunk-VJGE7HSP.js";
+} from "./chunk-73ULM6HF.js";
+import "./chunk-OC6RU6XH.js";
 import {
   findChrome
 } from "./chunk-P3V5CWH5.js";
@@ -45,10 +46,11 @@ import {
   enrich
 } from "./chunk-XZKQZKEE.js";
 import {
+  diffStatSince,
   isGitRepo,
   restoreSnapshot,
   takeSnapshot
-} from "./chunk-WTA6YYBY.js";
+} from "./chunk-YHRAOBI2.js";
 
 // src/cli.tsx
 import { Command } from "commander";
@@ -161,7 +163,8 @@ var Session = class {
       devUrl: null,
       totals: { costUsd: 0, turns: 0 },
       queue: [],
-      mode: "safe"
+      mode: "safe",
+      problems: []
     };
     if (opts.autoDev && detectDevCommand(opts.cwd)) {
       this.devServer().start();
@@ -188,10 +191,13 @@ var Session = class {
   sessionId;
   dev = null;
   abort = null;
-  pendingFix = null;
+  /** Full problem records; state carries the summaries. */
+  problemPrompts = /* @__PURE__ */ new Map();
+  nextProblemId = 0;
   checkpoints = [];
   fixAttempts = 0;
   reviewTipShown = false;
+  lastPulse = null;
   startedAt = Date.now();
   subscribe(listener) {
     this.listeners.add(listener);
@@ -211,6 +217,47 @@ var Session = class {
   note(text) {
     this.push("status", text);
   }
+  /** Register a finding; a fresh finding from a source supersedes its old one. */
+  addProblem(source, summary, prompt) {
+    const kept = this.state.problems.filter((p) => p.source !== source);
+    for (const gone of this.state.problems) {
+      if (gone.source === source) this.problemPrompts.delete(gone.id);
+    }
+    this.nextProblemId += 1;
+    this.problemPrompts.set(this.nextProblemId, prompt);
+    this.notify({ problems: [...kept, { id: this.nextProblemId, source, summary }] });
+  }
+  clearProblems(source) {
+    const removed = this.state.problems.filter((p) => p.source === source);
+    if (removed.length === 0) return;
+    for (const problem of removed) this.problemPrompts.delete(problem.id);
+    this.notify({ problems: this.state.problems.filter((p) => p.source !== source) });
+  }
+  /** One prompt covering the given problems, oldest first. */
+  combinedFixPrompt(problems) {
+    const sections = problems.map(
+      (p) => this.problemPrompts.get(p.id) ?? `Fix this reported problem: ${p.summary}`
+    );
+    return sections.join("\n\n---\n\n");
+  }
+  dispatchFix(problems) {
+    if (problems.length === 0) return;
+    const prompt = this.combinedFixPrompt(problems);
+    const display = `\u26D1 fix: ${problems.map((p) => p.source).join(" + ")}`;
+    for (const problem of problems) this.problemPrompts.delete(problem.id);
+    this.notify({ problems: this.state.problems.filter((p) => !problems.includes(p)) });
+    void this.runTurn(prompt, display);
+  }
+  /** Launch a capped auto-fix turn over all open problems. Returns true if launched. */
+  maybeAutoFix() {
+    if (!this.opts.autoFix || this.fixAttempts >= MAX_AUTO_FIX_ATTEMPTS) return false;
+    if (this.state.problems.length === 0) return false;
+    this.fixAttempts += 1;
+    this.push("status", `auto-fix attempt ${this.fixAttempts}/${MAX_AUTO_FIX_ATTEMPTS}`);
+    this.notify({ running: false });
+    this.dispatchFix([...this.state.problems]);
+    return true;
+  }
   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";
@@ -363,7 +410,9 @@ var Session = class {
     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"}` : "";
+      const checkpoint = this.checkpoints.at(-1);
+      const stat = checkpoint ? diffStatSince(this.opts.cwd, checkpoint.snapshot) : null;
+      const work = stat ? ` \xB7 ${stat}` : 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: {
@@ -387,26 +436,22 @@ var Session = class {
         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`
-          };
+          this.addProblem(
+            "gates",
+            failures.map((f) => f.gate.id).join(" + "),
+            buildGatePrompt(failures)
+          );
           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;
-          }
-          this.push("status", "type /fix to send them to the engine");
+          if (this.maybeAutoFix()) return;
+          this.push("status", "/fix sends open problems to the engine \xB7 /problems lists them");
           this.notify({ running: false });
           this.drainQueue();
           return;
         }
+        this.clearProblems("gates");
       }
     }
     const dev = this.dev;
@@ -414,39 +459,28 @@ var Session = class {
       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.addProblem(
+          "dev",
+          `${errors.length} dev server error line(s)`,
+          buildFixPrompt(errors, dev.tail(30))
+        );
         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");
+        if (this.maybeAutoFix()) return;
+        this.push("status", "/fix sends open problems to the engine \xB7 /problems lists them");
       } else {
-        this.pendingFix = null;
+        this.clearProblems("dev");
         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"
-            };
+          const probe = await probeRuntime(this.state.devUrl, this.opts.cwd);
+          const summary = probe ? runtimeSummary(probe.report) : null;
+          if (probe && summary) {
+            this.addProblem("runtime", summary, buildRuntimeFixPrompt(probe.report));
             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 (this.maybeAutoFix()) return;
+            this.push("status", "/fix sends open problems to the engine \xB7 /problems lists them");
+          } else if (probe) {
+            this.clearProblems("runtime");
+            await this.visualPulse(probe.pulsePath);
           }
         }
         if (!this.reviewTipShown && this.state.devUrl) {
@@ -497,6 +531,32 @@ ${errors.slice(-5).join("\n")}`);
       this.push("error", `restore failed: ${result.detail ?? "unknown error"}`);
     }
   }
+  /**
+   * Cross-turn visual drift check: compare this turn's pulse screenshot
+   * with the previous one and report how much of the page changed.
+   * Informational — changes are usually intended; surprises shouldn't be.
+   */
+  async visualPulse(pulsePath) {
+    if (!pulsePath) return;
+    let current;
+    try {
+      current = (await import("fs")).readFileSync(pulsePath);
+    } catch {
+      return;
+    }
+    const previous = this.lastPulse;
+    this.lastPulse = current;
+    if (!previous) {
+      this.push("status", "visual pulse: baseline captured");
+      return;
+    }
+    const pct = await comparePulse(previous, current);
+    if (pct === null) return;
+    this.push(
+      "status",
+      pct < 0.5 ? "visual pulse: stable vs last turn" : `visual pulse: ${pct.toFixed(1)}% of the page changed vs last turn`
+    );
+  }
   /** Screenshot the running app (and watch its runtime where CDP is available). */
   async capture() {
     if (!this.state.devUrl) {
@@ -520,16 +580,28 @@ ${errors.slice(-5).join("\n")}`);
       const summary = runtimeSummary(result.runtime);
       if (summary) {
         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");
+        this.addProblem("runtime", summary, buildRuntimeFixPrompt(result.runtime));
+        this.push("status", "/fix sends open problems to the engine");
       } else {
+        this.clearProblems("runtime");
         this.push("status", "runtime clean \u2014 no console errors, exceptions, or failed requests");
       }
     }
     if (result.a11y && result.a11y.length > 0) {
       this.push("error", `a11y: ${result.a11y.length} finding(s)
 ${result.a11y.slice(0, 5).join("\n")}`);
-      this.push("status", "/review folds these into the fix pass");
+      this.addProblem(
+        "a11y",
+        `${result.a11y.length} accessibility finding(s)`,
+        `Fix these accessibility defects found by an automated sweep of the running app:
+
+${result.a11y.join("\n")}
+
+They are objective defects, not style preferences.`
+      );
+      this.push("status", "/review folds these into the fix pass \xB7 /fix sends them directly");
+    } else if (result.runtime) {
+      this.clearProblems("a11y");
     }
     return result.shots.length > 0 ? result : null;
   }
@@ -579,11 +651,47 @@ ${result.a11y.slice(0, 5).join("\n")}`);
         }
         break;
       }
-      case "fix":
-        if (!this.pendingFix) {
-          this.push("status", "nothing to fix \u2014 no captured errors or failed gates");
+      case "fix": {
+        if (this.state.problems.length === 0) {
+          this.push("status", "nothing to fix \u2014 no open problems");
+          break;
+        }
+        const index = Number.parseInt(arg, 10);
+        if (arg && Number.isInteger(index)) {
+          const target = this.state.problems[index - 1];
+          if (!target) {
+            this.push("status", `usage: /fix [1\u2013${this.state.problems.length}] \u2014 see /problems`);
+            break;
+          }
+          this.dispatchFix([target]);
+        } else {
+          this.dispatchFix([...this.state.problems]);
+        }
+        break;
+      }
+      case "copy": {
+        const last = this.state.items.findLast((i) => i.role === "assistant");
+        if (!last) {
+          this.push("status", "nothing to copy yet");
+          break;
+        }
+        void import("child_process").then(({ spawn }) => {
+          const cmd = process.platform === "darwin" ? spawn("pbcopy") : process.platform === "win32" ? spawn("clip") : spawn("xclip", ["-selection", "clipboard"]);
+          cmd.on("error", () => this.push("error", "no clipboard tool found"));
+          cmd.on("close", (code) => {
+            if (code === 0) this.push("status", `copied last reply (${last.text.length} chars)`);
+          });
+          cmd.stdin?.end(last.text);
+        });
+        break;
+      }
+      case "problems":
+        if (this.state.problems.length === 0) {
+          this.push("status", "no open problems");
         } else {
-          void this.runTurn(this.pendingFix.prompt, this.pendingFix.display);
+          const lines = this.state.problems.map((p, i) => `${i + 1}. [${p.source}] ${p.summary}`);
+          this.push("status", `${lines.join("\n")}
+/fix sends all \xB7 /fix <n> targets one`);
         }
         break;
       case "check":
@@ -605,12 +713,10 @@ ${result.a11y.slice(0, 5).join("\n")}`);
           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");
+            this.addProblem("gates", failures.map((f) => f.gate.id).join(" + "), buildGatePrompt(failures));
+            this.push("status", "/fix sends open problems to the engine \xB7 /problems lists them");
           } else {
+            this.clearProblems("gates");
             this.push("status", "all gates passed");
           }
         })();
@@ -754,7 +860,7 @@ ${result.a11y.slice(0, 5).join("\n")}`);
       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"
+          "/engine <id> \xB7 /model <name> \xB7 /mode plan|safe|yolo \xB7 /dev \xB7 /check (gates) \xB7 /problems \xB7 /fix [n] \xB7 /shot \xB7 /review [focus] \xB7 /variants <2-4> <ask> \xB7 /undo \xB7 /checkpoints \xB7 /restore <n> \xB7 /copy (last reply) \xB7 /resume \xB7 /clear \xB7 /quit"
         );
         break;
       case "quit":
@@ -1225,6 +1331,11 @@ function App({
   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.items.length === 0 && state.liveText.length === 0 && !state.running && /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: theme2.dim, children: "describe what to build \u2014 or try:" }),
+      /* @__PURE__ */ jsx3(Text3, { color: theme2.dim, children: "  /dev start the preview server \xB7 /review after a change \xB7 /variants 3 explore wide" }),
+      /* @__PURE__ */ jsx3(Text3, { color: theme2.dim, children: "  shift+tab cycles plan/safe/yolo \xB7 type while the agent works to queue asks" })
+    ] }),
     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: ",
@@ -1256,14 +1367,21 @@ function App({
       path3.basename(cwd),
       devBadge,
       totalsBadge,
-      " \xB7 shift+tab mode \xB7 /help"
+      state.problems.length > 0 && /* @__PURE__ */ jsxs3(Text3, { color: theme2.error, children: [
+        " \xB7 ",
+        state.problems.length,
+        " problem",
+        state.problems.length === 1 ? "" : "s"
+      ] }),
+      " ",
+      "\xB7 shift+tab mode \xB7 /help"
     ] }) })
   ] }) });
 }
 
 // src/cli.tsx
 import { jsx as jsx4 } from "react/jsx-runtime";
-var VERSION = "0.2.1";
+var VERSION = "0.2.2";
 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(
@@ -1330,7 +1448,7 @@ program.command("doctor").description("Check squint prerequisites and engine ava
     }
   }
   const { findChrome: findChrome2 } = await import("./chrome-RD7XQ767.js");
-  const { hasWebSocket } = await import("./cdp-RTWPFIX5.js");
+  const { hasWebSocket } = await import("./cdp-SFWNP7OA.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")}`
@@ -1450,7 +1568,7 @@ variantsCommand.command("gen").description("Generate n variants of one ask in pa
       process.exitCode = 1;
       return;
     }
-    const { isGitRepo: isGitRepo2 } = await import("./snapshot-KKUY5RR6.js");
+    const { isGitRepo: isGitRepo2 } = await import("./snapshot-H6VYFHLN.js");
     if (!isGitRepo2(cwd)) {
       console.error(pc.red("\u2717 variants need a git repo with at least one commit"));
       process.exitCode = 1;
@@ -1560,7 +1678,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-XQ7EOHV4.js");
+  const { captureViewports: captureViewports2 } = await import("./preview-JJJLDF7H.js");
   const result = await captureViewports2(process.cwd(), url);
   if (!result) {
     console.error(pc.red("\u2717 no Chrome/Chromium found"));

package/dist/{preview-XQ7EOHV4.js → preview-JJJLDF7H.js}

@@ -4,11 +4,12 @@ import {
   buildReviewPrompt,
   buildRuntimeFixPrompt,
   captureViewports,
+  comparePulse,
   previewDir,
   probeRuntime,
   runtimeSummary
-} from "./chunk-REDPR3KI.js";
-import "./chunk-VJGE7HSP.js";
+} from "./chunk-73ULM6HF.js";
+import "./chunk-OC6RU6XH.js";
 import "./chunk-P3V5CWH5.js";
 import "./chunk-2LRIKWBU.js";
 export {
@@ -16,6 +17,7 @@ export {
   buildReviewPrompt,
   buildRuntimeFixPrompt,
   captureViewports,
+  comparePulse,
   previewDir,
   probeRuntime,
   runtimeSummary

package/dist/{snapshot-KKUY5RR6.js → snapshot-H6VYFHLN.js}

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 import {
+  diffStatSince,
   isGitRepo,
   restoreSnapshot,
   takeSnapshot
-} from "./chunk-WTA6YYBY.js";
+} from "./chunk-YHRAOBI2.js";
 export {
+  diffStatSince,
   isGitRepo,
   restoreSnapshot,
   takeSnapshot

package/package.json

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

package/dist/cdp-RTWPFIX5.js

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-import {
-  cdpCapture,
-  hasWebSocket
-} from "./chunk-VJGE7HSP.js";
-export {
-  cdpCapture,
-  hasWebSocket
-};