@aayambansal/squint 0.2.0 → 0.2.2

package/dist/cli.js

@@ -2,14 +2,21 @@
 import {
   DevServer,
   buildFixPrompt,
-  detectDevCommand
-} from "./chunk-ZJOU46X4.js";
+  detectDevCommand,
+  screenshotVariants
+} from "./chunk-2IW2MMCY.js";
 import {
-  runAgent
-} from "./chunk-FPTBBHOH.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,
@@ -21,21 +28,29 @@ import {
   buildRuntimeFixPrompt,
   captureViewports,
   clearState,
+  comparePulse,
   loadState,
   probeRuntime,
   runtimeSummary,
   saveState
-} from "./chunk-4MMIJXYD.js";
-import "./chunk-VJGE7HSP.js";
-import "./chunk-Z46MXU64.js";
+} from "./chunk-73ULM6HF.js";
+import "./chunk-OC6RU6XH.js";
+import {
+  findChrome
+} from "./chunk-P3V5CWH5.js";
 import {
   detectEngines,
   getEngine
-} from "./chunk-MCYQXOE7.js";
+} from "./chunk-2LRIKWBU.js";
+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";
@@ -148,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();
@@ -175,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);
@@ -198,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";
@@ -350,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: {
@@ -374,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;
@@ -401,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) {
@@ -457,7 +504,12 @@ ${errors.slice(-5).join("\n")}`);
       if (this.checkpoints.length > 20) this.checkpoints.shift();
     }
     const isFirstTurn = this.sessionId === void 0;
-    const prompt = isFirstTurn ? composePrompt(ask, { cwd: this.opts.cwd, firstTurn: true }) : ask;
+    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. */
@@ -479,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) {
@@ -502,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;
   }
@@ -561,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 {
-          void this.runTurn(this.pendingFix.prompt, this.pendingFix.display);
+          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 {
+          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":
@@ -587,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");
           }
         })();
@@ -659,6 +783,75 @@ ${result.a11y.slice(0, 5).join("\n")}`);
         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;
+          }
+          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;
+        }
+        if (sub === "clean") {
+          this.push("status", `removed ${cleanVariants(this.opts.cwd)} variant(s)`);
+          break;
+        }
+        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;
+        }
+        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;
+        }
+        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);
@@ -667,7 +860,7 @@ ${result.a11y.slice(0, 5).join("\n")}`);
       case "help":
         this.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 /checkpoints \xB7 /restore <n> \xB7 /resume (last session) \xB7 /clear (new session) \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":
@@ -1138,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: ",
@@ -1169,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.0";
+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(
@@ -1210,18 +1415,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-K4BKFOYS.js");
-  const { hasWebSocket } = await import("./cdp-RTWPFIX5.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-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")}`
   );
@@ -1238,7 +1466,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 });
@@ -1262,10 +1490,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);
@@ -1301,21 +1568,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-H6VYFHLN.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-4NCQXTP7.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,
@@ -1325,9 +1592,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-VJBLDMF3.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 ?? "")}`);
       }
@@ -1340,8 +1607,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-4NCQXTP7.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;
@@ -1349,26 +1616,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-4NCQXTP7.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-4NCQXTP7.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) {
@@ -1411,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-LTWJK3LF.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"));