@aayambansal/squint 0.2.1 → 0.2.3

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,24 @@ 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**: type `/` and matching commands appear with descriptions; tab completes.
+  `/dev` `/check` `/problems` `/fix [n]` `/shot` `/review [focus]` `/variants` `/undo`
+  `/checkpoints` `/restore <n>` `/mode` `/theme` `/copy` `/save` `/resume` `/clear`.
+- **Visual pulse**: every clean turn is screenshotted and pixel-compared with the last —
+  drift shows up as a number, not a surprise. `.squint/locks` lists paths the engine must
+  never touch; `/save` exports the transcript as markdown.
+- 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-XZKQZKEE.js → chunk-4LAU5TGK.js}

@@ -51,12 +51,29 @@ function matchSkills(skills, ask) {
   const haystack = ask.toLowerCase();
   return skills.filter((skill) => skill.triggers.some((t) => haystack.includes(t)));
 }
+function loadLocks(cwd) {
+  try {
+    return fs.readFileSync(path.join(cwd, ".squint", "locks"), "utf8").split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  } catch {
+    return [];
+  }
+}
 function enrich(cwd, ask) {
   const parts = [];
   const rules = loadRules(cwd);
   if (rules) parts.push(`## Project rules (always apply)
 
 ${rules}`);
+  const locks = loadLocks(cwd);
+  if (locks.length > 0) {
+    parts.push(
+      `## Locked files (hard constraint)
+
+Never modify these paths, no matter what the task seems to need:
+${locks.map((l) => `- ${l}`).join("\n")}
+If the task appears to require changing them, stop and explain instead.`
+    );
+  }
   const matched = matchSkills(loadSkills(cwd), ask);
   for (const skill of matched) {
     parts.push(`## Project notes: ${skill.name}
@@ -76,5 +93,6 @@ export {
   loadSkills,
   loadRules,
   matchSkills,
+  loadLocks,
   enrich
 };

package/dist/chunk-EECGXFRX.js

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

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-REDPR3KI.js → chunk-SU6YRRMF.js}

@@ -2,7 +2,7 @@
 import {
   cdpCapture,
   hasWebSocket
-} from "./chunk-VJGE7HSP.js";
+} from "./chunk-OC6RU6XH.js";
 import {
   findChrome,
   screenshot
@@ -16,7 +16,7 @@ import path2 from "path";
 // src/state/state.ts
 import fs from "fs";
 import path from "path";
-var IGNORED = ["preview/", "state.json", "variants/"];
+var IGNORED = ["preview/", "state.json", "variants/", "transcripts/"];
 function ensureSquintIgnore(cwd) {
   const dir = path.join(cwd, ".squint");
   fs.mkdirSync(dir, { recursive: true });
@@ -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-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

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+import {
+  diffStatSince,
+  isGitRepo,
+  restoreSnapshot,
+  takeSnapshot
+} from "./chunk-YHRAOBI2.js";
 import {
   DevServer,
   buildFixPrompt,
@@ -17,6 +23,9 @@ import {
 import {
   runAgent
 } from "./chunk-OTG4ZB4R.js";
+import {
+  completeCommand
+} from "./chunk-EECGXFRX.js";
 import {
   buildGatePrompt,
   detectFastGates,
@@ -28,12 +37,13 @@ import {
   buildRuntimeFixPrompt,
   captureViewports,
   clearState,
+  comparePulse,
   loadState,
   probeRuntime,
   runtimeSummary,
   saveState
-} from "./chunk-REDPR3KI.js";
-import "./chunk-VJGE7HSP.js";
+} from "./chunk-SU6YRRMF.js";
+import "./chunk-OC6RU6XH.js";
 import {
   findChrome
 } from "./chunk-P3V5CWH5.js";
@@ -43,12 +53,7 @@ import {
 } from "./chunk-2LRIKWBU.js";
 import {
   enrich
-} from "./chunk-XZKQZKEE.js";
-import {
-  isGitRepo,
-  restoreSnapshot,
-  takeSnapshot
-} from "./chunk-WTA6YYBY.js";
+} from "./chunk-4LAU5TGK.js";
 
 // src/cli.tsx
 import { Command } from "commander";
@@ -161,7 +166,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 +194,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 +220,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 +413,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 +439,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 +462,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 +534,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 +583,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 +654,79 @@ ${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 "save": {
+        void (async () => {
+          const fs2 = await import("fs");
+          const path4 = await import("path");
+          const dir = path4.join(this.opts.cwd, ".squint", "transcripts");
+          fs2.mkdirSync(dir, { recursive: true });
+          const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+          const file = path4.join(dir, `${stamp}.md`);
+          const lines = [`# squint session \u2014 ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)}`, ""];
+          for (const item of this.state.items) {
+            switch (item.role) {
+              case "user":
+                lines.push(`## \u276F ${item.text}`, "");
+                break;
+              case "assistant":
+                lines.push(item.text, "");
+                break;
+              case "tool":
+                lines.push(`- \u2699 ${item.text}`);
+                break;
+              case "thinking":
+                break;
+              default:
+                lines.push(`> ${item.role === "error" ? "\u2717 " : ""}${item.text.split("\n").join("\n> ")}`);
+            }
+          }
+          lines.push("", `> ${this.summary()}`);
+          fs2.writeFileSync(file, lines.join("\n") + "\n");
+          this.push("status", `saved transcript \u2192 ${path4.relative(this.opts.cwd, file)}`);
+        })();
+        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 +748,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");
           }
         })();
@@ -751,12 +892,10 @@ ${result.a11y.slice(0, 5).join("\n")}`);
         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"
-        );
+      case "help": {
+        void import("./commands-6XDXUVO6.js").then(({ commandHelp }) => this.push("status", commandHelp()));
         break;
+      }
       case "quit":
       case "exit":
         this.push("status", this.summary());
@@ -1142,6 +1281,13 @@ function App({
       session.cycleMode();
       return;
     }
+    if (key.tab && line.text.startsWith("/") && !line.text.includes(" ")) {
+      const matches = completeCommand(line.text.slice(1));
+      if (matches.length > 0) {
+        setLine(fromText(`/${matches[0].name}${matches[0].args ? " " : ""}`));
+      }
+      return;
+    }
     if (key.return) {
       const value = line.text.trim();
       setLine(emptyLine);
@@ -1225,11 +1371,26 @@ 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: ",
       queued
     ] }) }, index)),
+    line.text.startsWith("/") && !line.text.includes(" ") && /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", children: completeCommand(line.text.slice(1)).slice(0, 5).map((command, index) => /* @__PURE__ */ jsxs3(Text3, { color: index === 0 ? theme2.accent : theme2.dim, children: [
+      "/",
+      command.name,
+      command.args ? ` ${command.args}` : "",
+      " ",
+      /* @__PURE__ */ jsxs3(Text3, { color: theme2.dim, children: [
+        "\u2014 ",
+        command.description
+      ] })
+    ] }, command.name)) }),
     /* @__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),
@@ -1256,14 +1417,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.3";
 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 +1498,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")}`
@@ -1374,7 +1542,7 @@ Next: ${pc.bold(`${cd}${options.install ? "" : "npm install && "}squint`)}`);
 });
 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 { loadRules, loadSkills } = await import("./skills-DNBHZAAU.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"));
@@ -1450,7 +1618,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 +1728,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-UX4VS4SX.js");
   const result = await captureViewports2(process.cwd(), url);
   if (!result) {
     console.error(pc.red("\u2717 no Chrome/Chromium found"));

package/dist/commands-6XDXUVO6.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  COMMANDS,
+  commandHelp,
+  completeCommand
+} from "./chunk-EECGXFRX.js";
+export {
+  COMMANDS,
+  commandHelp,
+  completeCommand
+};

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

@@ -4,11 +4,12 @@ import {
   buildReviewPrompt,
   buildRuntimeFixPrompt,
   captureViewports,
+  comparePulse,
   previewDir,
   probeRuntime,
   runtimeSummary
-} from "./chunk-REDPR3KI.js";
-import "./chunk-VJGE7HSP.js";
+} from "./chunk-SU6YRRMF.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/{skills-UGHU22BS.js → skills-DNBHZAAU.js}

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
 import {
   enrich,
+  loadLocks,
   loadRules,
   loadSkills,
   matchSkills,
   parseSkill
-} from "./chunk-XZKQZKEE.js";
+} from "./chunk-4LAU5TGK.js";
 export {
   enrich,
+  loadLocks,
   loadRules,
   loadSkills,
   matchSkills,

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.3",
   "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
-};