@aayambansal/squint 0.4.5 → 0.4.7

package/dist/cli.js

@@ -1,72 +1,35 @@
 #!/usr/bin/env node
 import {
-  completeCommand
-} from "./chunk-43NQNIJY.js";
+  connectDaemon,
+  socketPath,
+  startDaemon
+} from "./chunk-NX7XQY2X.js";
 import {
-  applySandbox,
-  discardSandbox,
-  openSandbox,
-  sandboxDiffStat,
-  sandboxDir,
-  sandboxExists,
-  sandboxFiles
-} from "./chunk-XEQ6JXXL.js";
-import {
-  diffStatSince,
-  isGitRepo,
-  restoreSnapshot,
-  takeSnapshot
-} from "./chunk-YHRAOBI2.js";
-import {
-  DevServer,
-  buildFixPrompt,
-  detectDevCommand,
-  screenshotVariants
-} from "./chunk-QCHBDP46.js";
-import {
-  applyVariant,
-  cleanVariants,
-  listVariants,
-  runVariants
-} from "./chunk-YGSF2TSO.js";
-import {
-  buildGatePrompt,
-  detectFastGates,
-  detectGates,
-  runGates
-} from "./chunk-62JNF5M2.js";
-import {
-  buildReviewPrompt,
-  buildRuntimeFixPrompt,
-  captureViewports,
-  comparePulse,
-  probeRuntime,
-  runtimeSummary
-} from "./chunk-CV5WVKHU.js";
-import {
-  clearState,
-  loadState,
-  saveState
-} from "./chunk-O2S6PAJE.js";
+  App
+} from "./chunk-M25IQ7C7.js";
+import "./chunk-43NQNIJY.js";
+import "./chunk-7MOKOZOR.js";
+import "./chunk-ARDV4XH6.js";
+import "./chunk-AUJJGMZG.js";
+import "./chunk-YHRAOBI2.js";
+import "./chunk-QCHBDP46.js";
+import "./chunk-YGSF2TSO.js";
 import {
   runAgent
 } from "./chunk-VH7OOFQP.js";
+import "./chunk-K5QJMSJH.js";
 import {
-  findChrome
-} from "./chunk-IMDRXXFU.js";
+  composePrompt
+} from "./chunk-WAJXATCO.js";
+import "./chunk-62JNF5M2.js";
+import "./chunk-ZSDCMYZR.js";
+import "./chunk-7CAGWFAQ.js";
+import "./chunk-HC4E42SV.js";
+import "./chunk-IMDRXXFU.js";
 import {
   detectEngines,
   getEngine
 } from "./chunk-KVYGPLWW.js";
-import "./chunk-RQHOE5MV.js";
-import {
-  appendDecision,
-  enrich
-} from "./chunk-ZLEP2TWF.js";
-import "./chunk-K5QJMSJH.js";
-import {
-  composePrompt
-} from "./chunk-WAJXATCO.js";
 
 // src/cli.tsx
 import { Command } from "commander";
@@ -189,36 +152,143 @@ function registerConfig(program2) {
   });
 }
 
-// src/cli/env.ts
+// src/cli/daemon.ts
+import readline from "readline";
 import pc2 from "picocolors";
+function registerDaemon(program2) {
+  program2.command("serve").description("run the session as a detachable daemon on .squint/daemon.sock").option("-e, --engine <id>", "engine to drive").option("-m, --model <model>", "model override").action(async (opts) => {
+    const cwd = process.cwd();
+    const config = loadConfig(defaultPaths(cwd));
+    const engineId = opts.engine ?? resolveEngineId(config);
+    const daemon = await startDaemon({
+      cwd,
+      engineId,
+      model: opts.model ?? resolveModel(config, engineId),
+      autoDev: config.autoDev,
+      autoFix: config.autoFix,
+      autoProbe: config.autoProbe,
+      autoCheck: config.autoCheck,
+      autoReview: config.autoReview,
+      fixModel: config.fixModel,
+      budgetUsd: config.budgetUsd,
+      onQuit: () => {
+        daemon.close();
+        process.exit(0);
+      }
+    });
+    console.log(`squint daemon on ${socketPath(cwd)} (engine: ${engineId})`);
+    console.log("attach from another terminal with: squint attach");
+    const stop = () => {
+      daemon.close();
+      process.exit(0);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+  });
+  program2.command("attach").description("attach this terminal to a running squint daemon (full TUI; --plain for line mode)").option("--plain", "line-mode attach instead of the full TUI").action(async (opts) => {
+    const cwd = process.cwd();
+    if (!opts.plain) {
+      try {
+        const { RemoteSession } = await import("./remote-6O6FPTUF.js");
+        const remote = await RemoteSession.connect(cwd);
+        const config = loadConfig(defaultPaths(cwd));
+        const { render: render2 } = await import("ink");
+        const { App: App2 } = await import("./App-HWMVSRMF.js");
+        const React = await import("react");
+        render2(
+          React.createElement(App2, {
+            cwd,
+            attachTo: remote,
+            initialEngine: remote.getState().engineId,
+            bell: config.bell,
+            initialTheme: config.theme
+          })
+        );
+      } catch {
+        console.error(`no daemon at ${socketPath(cwd)} \u2014 start one with: squint serve`);
+        process.exitCode = 1;
+      }
+      return;
+    }
+    let client;
+    try {
+      client = await connectDaemon(socketPath(cwd));
+    } catch {
+      console.error(`no daemon at ${socketPath(cwd)} \u2014 start one with: squint serve`);
+      process.exitCode = 1;
+      return;
+    }
+    let seen = 0;
+    let role = "observer";
+    client.onMessage((msg) => {
+      if (msg.type === "hello") {
+        role = String(msg.role);
+        console.log(pc2.dim(`attached as ${role} (engine: ${msg.engineId})`));
+        if (role === "observer") console.log(pc2.dim("read-only until the driver detaches"));
+        return;
+      }
+      if (msg.type === "denied") {
+        console.log(pc2.yellow(`\u2717 ${msg.reason}`));
+        return;
+      }
+      if (msg.type !== "state") return;
+      const state = msg.state;
+      const items = state.items ?? [];
+      const fresh = seen === 0 ? items.slice(-20) : items.slice(seen);
+      seen = items.length;
+      for (const item of fresh) {
+        const line = item.role === "user" ? pc2.cyan(`> ${item.text}`) : item.role === "error" ? pc2.red(item.text) : item.role === "status" ? pc2.dim(item.text) : item.text;
+        if (item.role !== "image") console.log(line);
+      }
+    });
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.on("line", (line) => {
+      const text = line.trim();
+      if (!text) return;
+      if (text === "/detach") {
+        client.close();
+        rl.close();
+        return;
+      }
+      client.send(text.startsWith("/") ? { type: "command", text } : { type: "input", text });
+    });
+    rl.on("close", () => {
+      client.close();
+      process.exit(0);
+    });
+  });
+}
+
+// src/cli/env.ts
+import pc3 from "picocolors";
 function registerEnv(program2) {
   program2.command("engines").description("List engines: installed, streaming, session resume").action(() => {
-    console.log(pc2.dim("   id         name           stream  resume  where"));
+    console.log(pc3.dim("   id         name           stream  resume  where"));
     for (const { engine, path: binaryPath } of detectEngines()) {
-      const status = binaryPath ? pc2.green("\u2713") : pc2.red("\u2717");
-      const stream = engine.createParser ? pc2.green("yes") : pc2.dim("text");
-      const resume = engine.supportsResume ? pc2.green("yes") : pc2.dim("no");
-      const location = binaryPath ?? pc2.dim(`not found \u2014 ${engine.install}`);
+      const status = binaryPath ? pc3.green("\u2713") : pc3.red("\u2717");
+      const stream = engine.createParser ? pc3.green("yes") : pc3.dim("text");
+      const resume = engine.supportsResume ? pc3.green("yes") : pc3.dim("no");
+      const location = binaryPath ?? pc3.dim(`not found \u2014 ${engine.install}`);
       console.log(
         `${status} ${engine.id.padEnd(10)} ${engine.name.padEnd(14)} ${stream.padEnd(15)} ${resume.padEnd(14)} ${location}`
       );
     }
-    console.log(pc2.dim("\nplan/safe/yolo modes map onto every engine \xB7 squint doctor --probe verifies auth"));
+    console.log(pc3.dim("\nplan/safe/yolo modes map onto every engine \xB7 squint doctor --probe verifies auth"));
   });
   program2.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) >= 22;
     console.log(
-      `${nodeOk ? pc2.green("\u2713") : pc2.red("\u2717")} node ${process.versions.node}${nodeOk ? "" : " (need >= 22)"}`
+      `${nodeOk ? pc3.green("\u2713") : pc3.red("\u2717")} node ${process.versions.node}${nodeOk ? "" : " (need >= 22)"}`
     );
     const detected = detectEngines();
     for (const { engine, path: binaryPath } of detected) {
-      const status = binaryPath ? pc2.green("\u2713") : pc2.yellow("\u25CB");
-      console.log(`${status} ${engine.name}${binaryPath ? "" : pc2.dim(` \u2014 install: ${engine.install}`)}`);
+      const status = binaryPath ? pc3.green("\u2713") : pc3.yellow("\u25CB");
+      console.log(`${status} ${engine.name}${binaryPath ? "" : pc3.dim(` \u2014 install: ${engine.install}`)}`);
     }
     if (options.probe) {
       const { runAgent: runAgent2 } = await import("./run-NDSNTVYP.js");
-      console.log(pc2.dim("\nprobing engines with a one-word prompt (verifies auth end to end)\u2026"));
+      console.log(pc3.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();
@@ -235,135 +305,135 @@ function registerEnv(program2) {
         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 ? `${pc2.green("\u2713")} ${engine.id.padEnd(10)} responded in ${secs}s` : `${pc2.red("\u2717")} ${engine.id.padEnd(10)} ${pc2.dim(detail.slice(0, 110))}`
+          result.ok ? `${pc3.green("\u2713")} ${engine.id.padEnd(10)} responded in ${secs}s` : `${pc3.red("\u2717")} ${engine.id.padEnd(10)} ${pc3.dim(detail.slice(0, 110))}`
         );
       }
     }
-    const { findChrome: findChrome2 } = await import("./chrome-SBV3H77F.js");
-    const { hasWebSocket } = await import("./cdp-Q4H6ZHPT.js");
-    const chrome = findChrome2();
+    const { findChrome } = await import("./chrome-SBV3H77F.js");
+    const { hasWebSocket } = await import("./cdp-PBQKXC6R.js");
+    const chrome = findChrome();
     console.log(
-      chrome ? `${pc2.green("\u2713")} Chrome ${pc2.dim(chrome)}` : `${pc2.yellow("\u25CB")} Chrome ${pc2.dim("\u2014 screenshots and runtime probing disabled")}`
+      chrome ? `${pc3.green("\u2713")} Chrome ${pc3.dim(chrome)}` : `${pc3.yellow("\u25CB")} Chrome ${pc3.dim("\u2014 screenshots and runtime probing disabled")}`
     );
     console.log(
-      hasWebSocket() ? `${pc2.green("\u2713")} WebSocket ${pc2.dim("runtime console/network capture available")}` : `${pc2.yellow("\u25CB")} WebSocket ${pc2.dim("\u2014 node 22+ enables runtime capture; screenshots still work")}`
+      hasWebSocket() ? `${pc3.green("\u2713")} WebSocket ${pc3.dim("runtime console/network capture available")}` : `${pc3.yellow("\u25CB")} WebSocket ${pc3.dim("\u2014 node 22+ enables runtime capture; screenshots still work")}`
     );
     const available = detected.filter((d) => d.path !== null);
     if (available.length === 0) {
-      console.log(pc2.red("\nNo engines found. Install at least one to use squint."));
+      console.log(pc3.red("\nNo engines found. Install at least one to use squint."));
       process.exitCode = 1;
     } else {
-      console.log(pc2.dim(`
+      console.log(pc3.dim(`
 ${available.length} engine(s) ready.`));
     }
   });
 }
 
 // src/cli/project.ts
-import pc3 from "picocolors";
+import pc4 from "picocolors";
 function registerProject(program2) {
   const skillsCommand = program2.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-6NZP67QT.js");
+    const { loadRules, loadSkills } = await import("./skills-POB4ZZY5.js");
     const cwd = process.cwd();
     const rules = loadRules(cwd);
     console.log(
-      rules ? `${pc3.green("\u2713")} rules.md ${pc3.dim(`(${rules.split("\n").length} lines, always on)`)}` : pc3.dim("\u25CB no .squint/rules.md")
+      rules ? `${pc4.green("\u2713")} rules.md ${pc4.dim(`(${rules.split("\n").length} lines, always on)`)}` : pc4.dim("\u25CB no .squint/rules.md")
     );
     const skills = loadSkills(cwd);
     if (skills.length === 0) {
-      console.log(pc3.dim("\u25CB no skills \u2014 squint skills init writes an example"));
+      console.log(pc4.dim("\u25CB no skills \u2014 squint skills init writes an example"));
       return;
     }
     for (const skill of skills) {
-      console.log(`${pc3.green("\u2713")} ${skill.name.padEnd(20)} ${pc3.dim(`triggers: ${skill.triggers.join(", ")}`)}`);
+      console.log(`${pc4.green("\u2713")} ${skill.name.padEnd(20)} ${pc4.dim(`triggers: ${skill.triggers.join(", ")}`)}`);
     }
   });
   skillsCommand.command("init").description("Scaffold .squint/rules.md and an example skill").action(async () => {
-    const fs4 = await import("fs");
+    const fs2 = await import("fs");
     const nodePath = await import("path");
     const cwd = process.cwd();
     const skillsDir = nodePath.join(cwd, ".squint", "skills");
-    fs4.mkdirSync(skillsDir, { recursive: true });
+    fs2.mkdirSync(skillsDir, { recursive: true });
     const rules = nodePath.join(cwd, ".squint", "rules.md");
-    if (!fs4.existsSync(rules)) {
-      fs4.writeFileSync(
+    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(pc3.green("\u2713 .squint/rules.md"));
+      console.log(pc4.green("\u2713 .squint/rules.md"));
     }
     const example = nodePath.join(skillsDir, "example.md");
-    if (!fs4.existsSync(example)) {
-      fs4.writeFileSync(
+    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(pc3.green("\u2713 .squint/skills/example.md"));
+      console.log(pc4.green("\u2713 .squint/skills/example.md"));
     }
-    console.log(pc3.dim("rules are always-on; skills inject when an ask mentions a trigger"));
+    console.log(pc4.dim("rules are always-on; skills inject when an ask mentions a trigger"));
   });
   program2.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 fs4 = await import("fs");
+    const fs2 = await import("fs");
     const nodePath = await import("path");
     const { FAMILIES, getFamily, renderFamilyBrief } = await import("./families-3ARYRBMH.js");
     if (!familyId) {
-      console.log(pc3.bold("Aesthetic families") + pc3.dim(" \u2014 squint brief <id>\n"));
+      console.log(pc4.bold("Aesthetic families") + pc4.dim(" \u2014 squint brief <id>\n"));
       for (const family2 of FAMILIES) {
-        console.log(`${pc3.green(family2.id.padEnd(18))} ${family2.name.padEnd(22)} ${pc3.dim(family2.summary)}`);
+        console.log(`${pc4.green(family2.id.padEnd(18))} ${family2.name.padEnd(22)} ${pc4.dim(family2.summary)}`);
       }
-      console.log(pc3.dim("\nThe brief wraps every ask; edit .squint/brief.md to remix."));
+      console.log(pc4.dim("\nThe brief wraps every ask; edit .squint/brief.md to remix."));
       return;
     }
     const family = getFamily(familyId);
     if (!family) {
-      console.error(pc3.red(`\u2717 unknown family "${familyId}" \u2014 run squint brief to list`));
+      console.error(pc4.red(`\u2717 unknown family "${familyId}" \u2014 run squint brief to list`));
       process.exitCode = 1;
       return;
     }
     const target = nodePath.join(process.cwd(), ".squint", "brief.md");
-    if (fs4.existsSync(target) && !options.force) {
-      console.error(pc3.red(`\u2717 ${target} exists \u2014 use --force to overwrite`));
+    if (fs2.existsSync(target) && !options.force) {
+      console.error(pc4.red(`\u2717 ${target} exists \u2014 use --force to overwrite`));
       process.exitCode = 1;
       return;
     }
-    fs4.mkdirSync(nodePath.dirname(target), { recursive: true });
-    fs4.writeFileSync(target, renderFamilyBrief(family) + "\n");
-    console.log(pc3.green(`\u2713 ${family.name} direction written to .squint/brief.md`));
-    console.log(pc3.dim("every squint ask in this repo now holds this direction \u2014 edit the file to remix"));
+    fs2.mkdirSync(nodePath.dirname(target), { recursive: true });
+    fs2.writeFileSync(target, renderFamilyBrief(family) + "\n");
+    console.log(pc4.green(`\u2713 ${family.name} direction written to .squint/brief.md`));
+    console.log(pc4.dim("every squint ask in this repo now holds this direction \u2014 edit the file to remix"));
   });
   const sandboxCommand = program2.command("sandbox").description("Cumulative diff worktree \u2014 asks accumulate until you apply");
   sandboxCommand.command("diff").description("Show accumulated sandbox changes").action(async () => {
-    const { sandboxDiffStat: sandboxDiffStat2, sandboxExists: sandboxExists2, sandboxFiles: sandboxFiles2 } = await import("./sandbox-J2NCPYHJ.js");
+    const { sandboxDiffStat, sandboxExists, sandboxFiles } = await import("./sandbox-MK7Q2YNO.js");
     const cwd = process.cwd();
-    if (!sandboxExists2(cwd)) {
-      console.log(pc3.dim("no sandbox open \u2014 /sandbox on inside the TUI"));
+    if (!sandboxExists(cwd)) {
+      console.log(pc4.dim("no sandbox open \u2014 /sandbox on inside the TUI"));
       return;
     }
-    const stat = sandboxDiffStat2(cwd);
+    const stat = sandboxDiffStat(cwd);
     if (!stat) {
-      console.log(pc3.dim("sandbox is clean"));
+      console.log(pc4.dim("sandbox is clean"));
       return;
     }
     console.log(stat);
-    for (const line of sandboxFiles2(cwd)) console.log(pc3.dim(line));
+    for (const line of sandboxFiles(cwd)) console.log(pc4.dim(line));
   });
   sandboxCommand.command("apply").description("Land the sandbox diff on the real tree and close it").action(async () => {
-    const { applySandbox: applySandbox2, discardSandbox: discardSandbox2 } = await import("./sandbox-J2NCPYHJ.js");
+    const { applySandbox, discardSandbox } = await import("./sandbox-MK7Q2YNO.js");
     const cwd = process.cwd();
-    const result = applySandbox2(cwd);
+    const result = applySandbox(cwd);
     if (!result.ok) {
-      console.error(pc3.red(`\u2717 ${result.detail}`));
+      console.error(pc4.red(`\u2717 ${result.detail}`));
       process.exitCode = 1;
       return;
     }
-    discardSandbox2(cwd);
-    console.log(pc3.green("\u2713 sandbox applied to the real tree") + pc3.dim(" \u2014 review with git diff"));
+    discardSandbox(cwd);
+    console.log(pc4.green("\u2713 sandbox applied to the real tree") + pc4.dim(" \u2014 review with git diff"));
   });
   sandboxCommand.command("discard").description("Close the sandbox without touching the real tree").action(async () => {
-    const { discardSandbox: discardSandbox2 } = await import("./sandbox-J2NCPYHJ.js");
-    const had = discardSandbox2(process.cwd());
-    console.log(pc3.dim(had ? "sandbox discarded" : "no sandbox open"));
+    const { discardSandbox } = await import("./sandbox-MK7Q2YNO.js");
+    const had = discardSandbox(process.cwd());
+    console.log(pc4.dim(had ? "sandbox discarded" : "no sandbox open"));
   });
   const variantsCommand = program2.command("variants").description("Parallel design explorations \u2014 one aesthetic family each, pick with your eyes");
   variantsCommand.command("gen").description("Generate n variants of one ask in parallel (n engine runs \u2014 n\xD7 cost)").argument("<n>", "how many variants (max 4)").argument("<prompt...>", "what to build").option("-e, --engine <id>", "engine to use").option("-m, --model <name>", "model override").option("--no-shots", "skip the screenshot pass").action(
@@ -371,119 +441,119 @@ function registerProject(program2) {
       const cwd = process.cwd();
       const n = Number.parseInt(nRaw, 10);
       if (!Number.isInteger(n) || n < 2 || n > 4) {
-        console.error(pc3.red("\u2717 n must be 2\u20134"));
+        console.error(pc4.red("\u2717 n must be 2\u20134"));
         process.exitCode = 1;
         return;
       }
-      const { isGitRepo: isGitRepo2 } = await import("./snapshot-H6VYFHLN.js");
-      if (!isGitRepo2(cwd)) {
-        console.error(pc3.red("\u2717 variants need a git repo with at least one commit"));
+      const { isGitRepo } = await import("./snapshot-H6VYFHLN.js");
+      if (!isGitRepo(cwd)) {
+        console.error(pc4.red("\u2717 variants need a git repo with at least one commit"));
         process.exitCode = 1;
         return;
       }
-      const { runVariants: runVariants2, cleanVariants: cleanVariants2 } = await import("./variants-3IEP7DFY.js");
+      const { runVariants, cleanVariants } = await import("./variants-3IEP7DFY.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(" ");
-      cleanVariants2(cwd);
-      console.log(pc3.dim(`generating ${n} directions in parallel via ${engine.id} \u2014 this runs ${n} engine sessions`));
-      const runs = await runVariants2(
+      cleanVariants(cwd);
+      console.log(pc4.dim(`generating ${n} directions in parallel via ${engine.id} \u2014 this runs ${n} engine sessions`));
+      const runs = await runVariants(
         cwd,
         ask,
         n,
         engine,
         model,
-        (familyId, text) => console.log(`${pc3.cyan(familyId.padEnd(18))} ${pc3.dim(text)}`)
+        (familyId, text) => console.log(`${pc4.cyan(familyId.padEnd(18))} ${pc4.dim(text)}`)
       );
       const succeeded = runs.filter((r) => r.result.ok);
       if (options.shots && succeeded.length > 0) {
-        const { screenshotVariants: screenshotVariants2 } = await import("./shots-OKWOYF7F.js");
-        console.log(pc3.dim("capturing screenshots\u2026"));
-        const shots = await screenshotVariants2(cwd, succeeded.map((r) => r.variant));
+        const { screenshotVariants } = await import("./shots-OKWOYF7F.js");
+        console.log(pc4.dim("capturing screenshots\u2026"));
+        const shots = await screenshotVariants(cwd, succeeded.map((r) => r.variant));
         for (const shot of shots) {
-          console.log(`${pc3.green("\u2713")} ${shot.familyId.padEnd(18)} ${shot.path ?? pc3.dim(shot.error ?? "")}`);
+          console.log(`${pc4.green("\u2713")} ${shot.familyId.padEnd(18)} ${shot.path ?? pc4.dim(shot.error ?? "")}`);
         }
       }
       console.log(
         `
-${succeeded.length}/${runs.length} variants ready in .squint/variants/ \u2014 ` + pc3.bold("squint variants apply <id>") + pc3.dim(" applies the winner, squint variants clean discards all")
+${succeeded.length}/${runs.length} variants ready in .squint/variants/ \u2014 ` + pc4.bold("squint variants apply <id>") + pc4.dim(" applies the winner, squint variants clean discards all")
       );
       if (succeeded.length === 0) process.exitCode = 1;
     }
   );
   variantsCommand.command("list").description("List generated variants").action(async () => {
-    const { listVariants: listVariants2 } = await import("./variants-3IEP7DFY.js");
-    const ids = listVariants2(process.cwd());
+    const { listVariants } = await import("./variants-3IEP7DFY.js");
+    const ids = listVariants(process.cwd());
     if (ids.length === 0) {
-      console.log(pc3.dim('no variants \u2014 squint variants gen <n> "<ask>"'));
+      console.log(pc4.dim('no variants \u2014 squint variants gen <n> "<ask>"'));
       return;
     }
     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: applyVariant2, cleanVariants: cleanVariants2 } = await import("./variants-3IEP7DFY.js");
+    const { applyVariant, cleanVariants } = await import("./variants-3IEP7DFY.js");
     const cwd = process.cwd();
-    const result = applyVariant2(cwd, id);
+    const result = applyVariant(cwd, id);
     if (!result.ok) {
-      console.error(pc3.red(`\u2717 ${result.detail}`));
+      console.error(pc4.red(`\u2717 ${result.detail}`));
       process.exitCode = 1;
       return;
     }
-    cleanVariants2(cwd);
-    console.log(pc3.green(`\u2713 applied ${id} to the working tree`) + pc3.dim(" \u2014 review with git diff"));
+    cleanVariants(cwd);
+    console.log(pc4.green(`\u2713 applied ${id} to the working tree`) + pc4.dim(" \u2014 review with git diff"));
   });
   variantsCommand.command("clean").description("Discard all variants").action(async () => {
-    const { cleanVariants: cleanVariants2 } = await import("./variants-3IEP7DFY.js");
-    const count = cleanVariants2(process.cwd());
-    console.log(pc3.dim(`removed ${count} variant(s)`));
+    const { cleanVariants } = await import("./variants-3IEP7DFY.js");
+    const count = cleanVariants(process.cwd());
+    console.log(pc4.dim(`removed ${count} variant(s)`));
   });
 }
 
 // src/cli/quality.ts
-import pc4 from "picocolors";
+import pc5 from "picocolors";
 function registerQuality(program2) {
   program2.command("check").description("Run this project\u2019s quality gates (typecheck, lint, format, test, build)").action(async () => {
-    const { detectGates: detectGates2, runGates: runGates2 } = await import("./gates-ZC67NMW3.js");
+    const { detectGates, runGates } = await import("./gates-ZC67NMW3.js");
     const cwd = process.cwd();
-    const gates = detectGates2(cwd);
+    const gates = detectGates(cwd);
     if (gates.length === 0) {
-      console.log(pc4.dim("no gates detected (no package.json scripts, tsconfig, or eslint config)"));
+      console.log(pc5.dim("no gates detected (no package.json scripts, tsconfig, or eslint config)"));
       return;
     }
-    console.log(pc4.dim(`running ${gates.map((g) => g.id).join(" \u2192 ")}`));
-    const results = await runGates2(cwd, gates, (result) => {
-      const mark = result.ok ? pc4.green("\u2713") : pc4.red("\u2717");
+    console.log(pc5.dim(`running ${gates.map((g) => g.id).join(" \u2192 ")}`));
+    const results = await runGates(cwd, gates, (result) => {
+      const mark = result.ok ? pc5.green("\u2713") : pc5.red("\u2717");
       console.log(
-        `${mark} ${result.gate.id.padEnd(10)} ${pc4.dim(`${(result.durationMs / 1e3).toFixed(1)}s \xB7 ${result.gate.display}`)}`
+        `${mark} ${result.gate.id.padEnd(10)} ${pc5.dim(`${(result.durationMs / 1e3).toFixed(1)}s \xB7 ${result.gate.display}`)}`
       );
-      if (!result.ok) console.log(pc4.dim(result.outputTail.split("\n").slice(-12).join("\n")));
+      if (!result.ok) console.log(pc5.dim(result.outputTail.split("\n").slice(-12).join("\n")));
     });
     if (results.some((r) => !r.ok)) process.exitCode = 1;
   });
   program2.command("shot").description("Screenshot a running app at mobile/tablet/desktop viewports (+ .squint/routes)").argument("<url>", "URL of the running app (e.g. http://localhost:5173)").action(async (url) => {
-    const { captureViewports: captureViewports2 } = await import("./preview-ZUCVWGZG.js");
-    const result = await captureViewports2(process.cwd(), url);
+    const { captureViewports } = await import("./preview-WT34NVCH.js");
+    const result = await captureViewports(process.cwd(), url);
     if (!result) {
-      console.error(pc4.red("\u2717 no Chrome/Chromium found"));
+      console.error(pc5.red("\u2717 no Chrome/Chromium found"));
       process.exitCode = 1;
       return;
     }
-    for (const shot of result.shots) console.log(`${pc4.green("\u2713")} ${shot.name.padEnd(8)} ${shot.path}`);
-    for (const error of result.errors) console.error(pc4.red(`\u2717 ${error}`));
+    for (const shot of result.shots) console.log(`${pc5.green("\u2713")} ${shot.name.padEnd(8)} ${shot.path}`);
+    for (const error of result.errors) console.error(pc5.red(`\u2717 ${error}`));
     if (result.shots.length === 0) process.exitCode = 1;
   });
 }
 
 // src/cli/run.ts
-import pc5 from "picocolors";
+import pc6 from "picocolors";
 function createPrinter() {
   let streaming = false;
   return (event) => {
     switch (event.type) {
       case "status":
-        console.log(pc5.dim(`\xB7 ${event.text}`));
+        console.log(pc6.dim(`\xB7 ${event.text}`));
         break;
       case "delta":
         streaming = true;
@@ -498,17 +568,17 @@ function createPrinter() {
         streaming = false;
         break;
       case "thinking":
-        console.log(pc5.dim(pc5.italic(event.text)));
+        console.log(pc6.dim(pc6.italic(event.text)));
         break;
       case "tool":
         if (streaming) {
           process.stdout.write("\n");
           streaming = false;
         }
-        console.log(pc5.cyan(`\u2699 ${event.name}${event.detail ? ` \xB7 ${event.detail}` : ""}`));
+        console.log(pc6.cyan(`\u2699 ${event.name}${event.detail ? ` \xB7 ${event.detail}` : ""}`));
         break;
       case "error":
-        console.error(pc5.red(`\u2717 ${event.text}`));
+        console.error(pc6.red(`\u2717 ${event.text}`));
         break;
       case "result":
       case "raw":
@@ -521,7 +591,7 @@ function registerRun(program2) {
     async (promptWords, options) => {
       const cwd = process.cwd();
       if (options.mode && !["plan", "safe", "yolo"].includes(options.mode)) {
-        console.error(pc5.red("\u2717 --mode must be plan, safe, or yolo"));
+        console.error(pc6.red("\u2717 --mode must be plan, safe, or yolo"));
         process.exitCode = 1;
         return;
       }
@@ -537,7 +607,7 @@ function registerRun(program2) {
       } : createPrinter();
       if (!options.json)
         console.log(
-          pc5.dim(`squint \xB7 ${engine.id}${model ? ` \xB7 ${model}` : ""}${mode && mode !== "safe" ? ` \xB7 ${mode}` : ""}`)
+          pc6.dim(`squint \xB7 ${engine.id}${model ? ` \xB7 ${model}` : ""}${mode && mode !== "safe" ? ` \xB7 ${mode}` : ""}`)
         );
       const result = await runAgent(engine, { prompt, cwd, model, mode }, onEvent);
       if (options.json) {
@@ -545,7 +615,7 @@ function registerRun(program2) {
       } else 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` : "";
-        console.log(pc5.green(`\u2713 done${secs}${cost}`));
+        console.log(pc6.green(`\u2713 done${secs}${cost}`));
       }
       if (!result.ok) process.exitCode = 1;
     }
@@ -553,7 +623,7 @@ function registerRun(program2) {
 }
 
 // src/cli/scaffold.ts
-import pc6 from "picocolors";
+import pc7 from "picocolors";
 function registerScaffold(program2) {
   program2.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-YB2IMA4N.js");
@@ -561,1983 +631,74 @@ function registerScaffold(program2) {
     try {
       result = writeTemplate(dir, { force: options.force });
     } catch (err) {
-      console.error(pc6.red(`\u2717 ${err instanceof Error ? err.message : String(err)}`));
+      console.error(pc7.red(`\u2717 ${err instanceof Error ? err.message : String(err)}`));
       process.exitCode = 1;
       return;
     }
-    console.log(pc6.green(`\u2713 scaffolded ${result.files.length} files in ${result.dir}`));
+    console.log(pc7.green(`\u2713 scaffolded ${result.files.length} files in ${result.dir}`));
     if (options.install) {
-      console.log(pc6.dim("installing dependencies\u2026"));
+      console.log(pc7.dim("installing dependencies\u2026"));
       const ok = await installDependencies(result.dir);
       if (!ok) {
-        console.error(pc6.red("\u2717 npm install failed \u2014 run it manually"));
+        console.error(pc7.red("\u2717 npm install failed \u2014 run it manually"));
         process.exitCode = 1;
         return;
       }
     }
     const cd = result.dir === "." ? "" : `cd ${result.dir} && `;
     console.log(`
-Next: ${pc6.bold(`${cd}${options.install ? "" : "npm install && "}squint`)}`);
-    console.log(pc6.dim("then describe what to build \u2014 /dev starts the preview server"));
+Next: ${pc7.bold(`${cd}${options.install ? "" : "npm install && "}squint`)}`);
+    console.log(pc7.dim("then describe what to build \u2014 /dev starts the preview server"));
   });
   program2.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 fs4 = await import("fs");
+    const fs2 = await import("fs");
     const nodePath = await import("path");
     const { patchViteConfig, TAGGER_FILENAME, TAGGER_SOURCE } = await import("./source-ZZU245VN.js");
     const cwd = process.cwd();
     const taggerPath = nodePath.join(cwd, TAGGER_FILENAME);
-    fs4.writeFileSync(taggerPath, TAGGER_SOURCE);
-    console.log(pc6.green(`\u2713 ${TAGGER_FILENAME} written`));
-    const configPath = ["vite.config.ts", "vite.config.js", "vite.config.mjs"].map((name) => nodePath.join(cwd, name)).find((candidate) => fs4.existsSync(candidate));
+    fs2.writeFileSync(taggerPath, TAGGER_SOURCE);
+    console.log(pc7.green(`\u2713 ${TAGGER_FILENAME} written`));
+    const configPath = ["vite.config.ts", "vite.config.js", "vite.config.mjs"].map((name) => nodePath.join(cwd, name)).find((candidate) => fs2.existsSync(candidate));
     if (!configPath) {
-      console.log(pc6.yellow("\u25CB no vite config found \u2014 add the plugin manually:"));
-      console.log(pc6.dim(`  import squintTagger from './${TAGGER_FILENAME}'
+      console.log(pc7.yellow("\u25CB no vite config found \u2014 add the plugin manually:"));
+      console.log(pc7.dim(`  import squintTagger from './${TAGGER_FILENAME}'
   plugins: [squintTagger(), \u2026]`));
       return;
     }
-    const source = fs4.readFileSync(configPath, "utf8");
+    const source = fs2.readFileSync(configPath, "utf8");
     const patched = patchViteConfig(source);
     if (patched === "already") {
-      console.log(pc6.dim("vite config already wired"));
+      console.log(pc7.dim("vite config already wired"));
     } else if (patched === null) {
-      console.log(pc6.yellow(`\u25CB could not patch ${nodePath.basename(configPath)} automatically \u2014 add:`));
-      console.log(pc6.dim(`  import squintTagger from './${TAGGER_FILENAME}'
+      console.log(pc7.yellow(`\u25CB could not patch ${nodePath.basename(configPath)} automatically \u2014 add:`));
+      console.log(pc7.dim(`  import squintTagger from './${TAGGER_FILENAME}'
   plugins: [squintTagger(), \u2026]`));
     } else {
-      fs4.writeFileSync(configPath, patched);
-      console.log(pc6.green(`\u2713 ${nodePath.basename(configPath)} wired`));
+      fs2.writeFileSync(configPath, patched);
+      console.log(pc7.green(`\u2713 ${nodePath.basename(configPath)} wired`));
     }
     console.log(
-      pc6.dim("\nin the running app: Alt+S \u2192 click elements to pin, alt+enter copies all \u2014 paste into squint")
+      pc7.dim("\nin the running app: Alt+S \u2192 click elements to pin, alt+enter copies all \u2014 paste into squint")
     );
   });
 }
 
 // src/cli/tui.tsx
 import { render } from "ink";
-
-// src/tui/App.tsx
-import { Box as Box3, Static, Text as Text3, useApp, useInput } from "ink";
-import { InkPictureProvider } from "ink-picture";
-import path4 from "path";
-import { useMemo, useRef, useState as useState2, useSyncExternalStore } from "react";
-
-// src/session/engine.ts
-import fs3 from "fs";
-import path3 from "path";
-
-// src/session/hooks.ts
-import { spawn } from "child_process";
-import fs2 from "fs";
-import path2 from "path";
-function runHook(cwd, event, payload) {
-  const script = path2.join(cwd, ".squint", "hooks", event);
-  try {
-    fs2.accessSync(script, fs2.constants.X_OK);
-  } catch {
-    return false;
-  }
-  try {
-    const child = spawn(script, [], {
-      cwd,
-      env: { ...process.env, SQUINT_EVENT: event, ...prefixed(payload) },
-      stdio: "ignore",
-      detached: false
-    });
-    const timer = setTimeout(() => child.kill("SIGKILL"), 1e4);
-    child.on("close", () => clearTimeout(timer));
-    child.on("error", () => clearTimeout(timer));
-    return true;
-  } catch {
-    return false;
-  }
-}
-function prefixed(payload) {
-  const out = {};
-  for (const [key, value] of Object.entries(payload)) {
-    out[`SQUINT_${key.toUpperCase()}`] = value;
-  }
-  return out;
-}
-
-// src/session/engine.ts
-var MAX_AUTO_FIX_ATTEMPTS = 2;
-var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var Session = class {
-  constructor(opts) {
-    this.opts = opts;
-    this.state = {
-      items: [],
-      liveText: "",
-      running: false,
-      runStartedAt: 0,
-      engineId: opts.engineId,
-      model: opts.model,
-      devState: "stopped",
-      devUrl: null,
-      totals: { costUsd: 0, turns: 0 },
-      queue: [],
-      mode: "safe",
-      problems: [],
-      sandbox: false
-    };
-    if (opts.autoDev && detectDevCommand(opts.cwd)) {
-      this.devServer().start();
-    }
-    const saved = loadState(opts.cwd);
-    if (saved) {
-      try {
-        if (getEngine(saved.engine).supportsResume) {
-          const mins = Math.max(1, Math.round((Date.now() - saved.at) / 6e4));
-          this.push(
-            "status",
-            `previous session (${mins}m ago${saved.lastAsk ? ` \xB7 "${saved.lastAsk}"` : ""}) \u2014 /resume to continue`
-          );
-        }
-      } catch {
-      }
-    }
-  }
-  opts;
-  state;
-  listeners = /* @__PURE__ */ new Set();
-  nextId = 0;
-  live = "";
-  sessionId;
-  dev = null;
-  abort = null;
-  /** Full problem records; state carries the summaries. */
-  problemPrompts = /* @__PURE__ */ new Map();
-  nextProblemId = 0;
-  checkpoints = [];
-  fixAttempts = 0;
-  reviewTipShown = false;
-  pendingApproval = null;
-  lastPulse = null;
-  lastPerf = null;
-  autoReviewedThisAsk = false;
-  startedAt = Date.now();
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-  getState() {
-    return this.state;
-  }
-  dispose() {
-    this.abort?.abort();
-    this.dev?.stop();
-  }
-  interrupt() {
-    this.abort?.abort();
-  }
-  /** Frontend-originated status line (view-level commands like /theme). */
-  note(text) {
-    this.push("status", text);
-  }
-  /** 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 }] });
-    runHook(this.opts.cwd, "on-problem", { 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 fixModel = this.opts.fixModel;
-    const display = `\u26D1 fix: ${problems.map((p) => p.source).join(" + ")}${fixModel ? ` \xB7 ${fixModel}` : ""}`;
-    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, fixModel);
-  }
-  /** 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;
-  }
-  /**
-   * A side question: read-only, no session resume, so the main thread's
-   * context is untouched (Cursor's /btw). Costs count; loops don't run.
-   */
-  async btw(question) {
-    this.push("user", `\u{1F4AC} btw: ${question}`);
-    this.notify({ running: true, runStartedAt: Date.now() });
-    const engine = getEngine(this.state.engineId);
-    this.abort = new AbortController();
-    const result = await runAgent(
-      engine,
-      {
-        prompt: `Answer this question about the repository. Investigate as needed but make no changes:
-
-${question}`,
-        cwd: this.execCwd(),
-        model: this.state.model,
-        mode: "plan"
-      },
-      this.handleEvent,
-      this.abort.signal
-    );
-    this.abort = null;
-    this.commitLive();
-    this.flushToolCollapse();
-    if (result.ok) {
-      const cost = result.costUsd !== void 0 ? ` \xB7 $${result.costUsd.toFixed(2)}` : "";
-      this.push("status", `btw answered${cost}`);
-      this.notify({
-        totals: { costUsd: this.state.totals.costUsd + (result.costUsd ?? 0), turns: this.state.totals.turns }
-      });
-    }
-    this.notify({ running: false });
-    this.drainQueue();
-  }
-  /**
-   * Unattended polish: n rounds of screenshot-review-fix. Each round is
-   * a full review turn (its own cost); the per-ask auto-fix cap resets
-   * per round so fixes still flow. Fire it and step away.
-   */
-  async polish(rounds) {
-    for (let round = 1; round <= rounds; round++) {
-      this.fixAttempts = 0;
-      const result = await this.capture();
-      if (!result) {
-        this.push("status", `polish stopped at round ${round}: nothing to capture`);
-        return;
-      }
-      await this.runTurn(
-        buildReviewPrompt(result.shots, void 0, result.runtime, result.a11y, result.slop, result.narration, result.phantoms, result.viewTransitions, result.components),
-        `\u{1F441} polish round ${round}/${rounds}`
-      );
-    }
-    this.push("status", `polish complete \u2014 ${rounds} round${rounds === 1 ? "" : "s"} of review and fixes`);
-  }
-  setMode(mode) {
-    this.notify({ mode });
-    const hint = mode === "plan" ? "read-only: the engine investigates and proposes, edits nothing" : mode === "yolo" ? "no approval friction \u2014 the engine can do anything" : "edits auto-approved inside the workspace";
-    this.push("status", `mode \u2192 ${mode} \xB7 ${hint}`);
-  }
-  cycleMode() {
-    const order = ["safe", "plan", "yolo"];
-    const next = order[(order.indexOf(this.state.mode) + 1) % order.length];
-    this.setMode(next);
-  }
-  /** One-line goodbye: what this session amounted to. */
-  summary() {
-    const mins = Math.max(1, Math.round((Date.now() - this.startedAt) / 6e4));
-    const { turns, costUsd } = this.state.totals;
-    const parts = [`${turns} turn${turns === 1 ? "" : "s"}`];
-    if (costUsd > 0) parts.push(`$${costUsd.toFixed(2)}`);
-    parts.push(`${mins}m`);
-    return `session: ${parts.join(" \xB7 ")}`;
-  }
-  /**
-   * Route one line of user input: slash command or an ask for the engine.
-   * Asks arriving mid-turn queue up and dispatch in order once the
-   * current turn (including its fix cycle) settles.
-   */
-  input(raw) {
-    const value = raw.trim();
-    if (value.length === 0) return;
-    if (this.state.running) {
-      if (value === "/queue clear") {
-        this.notify({ queue: [] });
-        this.push("status", "queue cleared");
-        return;
-      }
-      const drop = /^\/queue drop (\d+)$/.exec(value);
-      if (drop) {
-        const index = Number.parseInt(drop[1], 10) - 1;
-        if (index >= 0 && index < this.state.queue.length) {
-          const removed = this.state.queue[index];
-          this.notify({ queue: this.state.queue.filter((_, i) => i !== index) });
-          this.push("status", `dropped from queue: ${removed}`);
-        } else {
-          this.push("status", `queue has ${this.state.queue.length} item(s) \u2014 /queue drop <1-${Math.max(this.state.queue.length, 1)}>`);
-        }
-        return;
-      }
-      this.notify({ queue: [...this.state.queue, value] });
-      return;
-    }
-    if (value.startsWith("/")) {
-      this.command(value);
-    } else {
-      void this.submit(value);
-    }
-  }
-  /** Dispatch queued input after the current work settles. */
-  drainQueue() {
-    if (this.state.running) return;
-    const [next, ...rest] = this.state.queue;
-    if (next === void 0) return;
-    this.notify({ queue: rest });
-    this.input(next);
-  }
-  // ---------- internals ----------
-  notify(patch) {
-    this.state = { ...this.state, ...patch };
-    for (const listener of this.listeners) listener();
-  }
-  push(role, text) {
-    this.nextId += 1;
-    this.notify({ items: [...this.state.items, { id: this.nextId, role, text }] });
-  }
-  setLive(text) {
-    this.live = text;
-    this.notify({ liveText: text });
-  }
-  /**
-   * Static transcript items are immutable once rendered, so in-progress
-   * assistant text accumulates in a live buffer and commits as one block.
-   */
-  commitLive() {
-    if (this.live.length > 0) {
-      const text = this.live;
-      this.live = "";
-      this.state = { ...this.state, liveText: "" };
-      this.push("assistant", text);
-    }
-  }
-  /** Where engines run and servers start: the sandbox worktree when on. */
-  execCwd() {
-    return this.state.sandbox ? sandboxDir(this.opts.cwd) : this.opts.cwd;
-  }
-  devServer() {
-    if (!this.dev) {
-      this.dev = new DevServer(this.execCwd(), {
-        onStateChange: (devState) => this.notify({ devState }),
-        onUrl: (url) => this.notify({ devUrl: url })
-      });
-    }
-    return this.dev;
-  }
-  /** Rebind the dev server after the execution tree changes. */
-  resetDevServer() {
-    const wasRunning = this.dev && this.dev.state !== "stopped";
-    this.dev?.stop();
-    this.dev = null;
-    this.notify({ devUrl: null, devState: "stopped" });
-    if (wasRunning) {
-      const command = detectDevCommand(this.execCwd());
-      if (command) {
-        this.devServer().start(command);
-        this.push("status", `dev server restarting in ${this.state.sandbox ? "the sandbox" : "the real tree"}`);
-      }
-    }
-  }
-  turnEdits = 0;
-  turnTools = 0;
-  toolStreak = 0;
-  collapsedTools = 0;
-  /**
-   * Long tool cascades collapse: the first three of a consecutive burst
-   * render, the rest fold into one "+N more" line pushed when the burst
-   * ends — append-only, so the Static transcript stays valid.
-   */
-  flushToolCollapse() {
-    if (this.collapsedTools > 0) {
-      this.push("tool", `+${this.collapsedTools} more tool call${this.collapsedTools === 1 ? "" : "s"}`);
-      this.collapsedTools = 0;
-    }
-    this.toolStreak = 0;
-  }
-  handleEvent = (event) => {
-    switch (event.type) {
-      case "status":
-        this.commitLive();
-        this.flushToolCollapse();
-        this.push("status", event.text);
-        break;
-      case "delta":
-        this.setLive(this.live + event.text);
-        break;
-      case "text":
-        this.flushToolCollapse();
-        if (event.streamed) {
-          this.live = "";
-          this.state = { ...this.state, liveText: "" };
-          this.push("assistant", event.text);
-        } else {
-          this.setLive(this.live + (this.live.length > 0 ? "\n" : "") + event.text);
-        }
-        break;
-      case "thinking":
-        this.commitLive();
-        this.flushToolCollapse();
-        this.push("thinking", event.text);
-        break;
-      case "tool": {
-        this.commitLive();
-        this.turnTools += 1;
-        this.toolStreak += 1;
-        if (/edit|write|patch|apply/i.test(event.name)) this.turnEdits += 1;
-        if (this.toolStreak <= 3) {
-          this.push("tool", event.detail ? `${event.name} \xB7 ${event.detail}` : event.name);
-        } else {
-          this.collapsedTools += 1;
-        }
-        break;
-      }
-      case "error":
-        this.commitLive();
-        this.flushToolCollapse();
-        this.push("error", event.text);
-        break;
-      case "result":
-        if (event.sessionId) this.sessionId = event.sessionId;
-        break;
-      case "raw":
-        break;
-    }
-  };
-  /** Run one engine turn. `display` is what the transcript shows as the ask. */
-  async runTurn(prompt, display, modelOverride) {
-    this.push("user", display);
-    this.turnEdits = 0;
-    this.turnTools = 0;
-    this.notify({ running: true, runStartedAt: Date.now() });
-    const runStart = Date.now();
-    const engine = getEngine(this.state.engineId);
-    this.abort = new AbortController();
-    const result = await runAgent(
-      engine,
-      {
-        prompt,
-        cwd: this.execCwd(),
-        model: modelOverride ?? this.state.model,
-        mode: this.state.mode,
-        sessionId: engine.supportsResume ? this.sessionId : void 0
-      },
-      this.handleEvent,
-      this.abort.signal
-    );
-    this.abort = null;
-    this.commitLive();
-    this.flushToolCollapse();
-    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 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}`);
-      try {
-        const reqPath = path3.join(this.opts.cwd, ".squint", "approval-request.json");
-        if (fs3.existsSync(reqPath)) {
-          const req = JSON.parse(fs3.readFileSync(reqPath, "utf8"));
-          fs3.rmSync(reqPath, { force: true });
-          if (typeof req?.summary === "string" && req.summary.length > 0) {
-            this.pendingApproval = req.summary;
-            const shot = typeof req.screenshot === "string" ? path3.resolve(this.execCwd(), req.screenshot) : null;
-            if (shot && fs3.existsSync(shot)) this.push("image", shot);
-            this.push("status", `\u23F8 approval requested: ${req.summary}
-/yes approves \xB7 /no rejects \xB7 or type feedback`);
-          }
-        }
-      } catch {
-      }
-      if (checkpoint) {
-        try {
-          const { driftSummary, loadTokenIndex, scanDrift } = await import("./tokens-XYGRRAXC.js");
-          const index = loadTokenIndex(this.execCwd());
-          const drift = scanDrift(this.execCwd(), checkpoint.snapshot.stashHash ?? "HEAD", index);
-          if (drift.length > 0) {
-            this.push("status", `token drift: ${drift.length} hardcoded color(s)
-${driftSummary(drift)}`);
-          }
-        } catch {
-        }
-        try {
-          const { rulePackSummary, scanRulePacks } = await import("./rulepacks-JOA675OJ.js");
-          const findings = scanRulePacks(this.execCwd(), checkpoint.snapshot.stashHash ?? "HEAD");
-          const hard = findings.filter((f) => f.hard);
-          if (hard.length > 0) {
-            this.addProblem(
-              "gates",
-              `${hard.length} class(es)/idiom(s) from an older toolchain major
-${rulePackSummary(hard)}`,
-              `This project's toolchain is newer than the patterns just written. Apply the exact renames below \u2014 do not downgrade dependencies or add compatibility configs:
-${rulePackSummary(hard)}`
-            );
-          }
-          const soft = findings.filter((f) => !f.hard);
-          if (soft.length > 0) {
-            this.push("status", `renamed-scale traps (verify intent):
-${rulePackSummary(soft)}`);
-          }
-        } catch {
-        }
-      }
-      runHook(this.opts.cwd, "on-turn-end", {
-        cost: String(result.costUsd ?? 0),
-        duration_ms: String(result.durationMs ?? 0),
-        stat: stat ?? ""
-      });
-      const before = this.state.totals.costUsd;
-      this.notify({
-        totals: {
-          costUsd: before + (result.costUsd ?? 0),
-          turns: this.state.totals.turns + 1
-        }
-      });
-      const budget = this.opts.budgetUsd;
-      if (budget && before < budget && this.state.totals.costUsd >= budget) {
-        this.push(
-          "error",
-          `session cost $${this.state.totals.costUsd.toFixed(2)} crossed your $${budget.toFixed(2)} budget \u2014 squint keeps working, this is just the flag you asked for`
-        );
-        runHook(this.opts.cwd, "on-budget", { total: this.state.totals.costUsd.toFixed(2), budget: budget.toFixed(2) });
-      }
-      if (this.sessionId) {
-        saveState(this.opts.cwd, {
-          engine: this.state.engineId,
-          sessionId: this.sessionId,
-          model: this.state.model,
-          lastAsk: display.length > 80 ? `${display.slice(0, 79)}\u2026` : display,
-          totals: this.state.totals,
-          at: Date.now()
-        });
-      }
-    }
-    if (result.ok && this.opts.autoCheck !== false) {
-      const fastGates = detectFastGates(this.execCwd());
-      if (fastGates.length > 0) {
-        const gateResults = await runGates(this.execCwd(), fastGates);
-        const failures = gateResults.filter((r) => !r.ok);
-        if (failures.length > 0) {
-          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.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;
-    if (result.error !== "interrupted" && dev && (dev.state === "running" || dev.state === "starting")) {
-      await delay(1500);
-      const errors = dev.errorsSince(runStart);
-      if (this.state.devUrl) {
-        try {
-          const { hasNextMcp, probeNextMcp } = await import("./nextMcp-42Y63M7W.js");
-          if (hasNextMcp(this.execCwd())) {
-            const mcp = await probeNextMcp(this.state.devUrl);
-            if (mcp.available && mcp.errors.length > 0) {
-              for (const err of mcp.errors) errors.push(`[next mcp] ${err}`);
-            }
-          }
-        } catch {
-        }
-      }
-      if (errors.length > 0) {
-        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.maybeAutoFix()) return;
-        this.push("status", "/fix sends open problems to the engine \xB7 /problems lists them");
-      } else {
-        this.clearProblems("dev");
-        if (this.opts.autoProbe !== false && this.state.devUrl) {
-          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.maybeAutoFix()) return;
-            this.push("status", "/fix sends open problems to the engine \xB7 /problems lists them");
-          } else if (probe) {
-            this.clearProblems("runtime");
-            this.perfPulse(probe.perf);
-            const pct = await this.visualPulse(probe.pulsePath);
-            if (this.opts.autoReview && pct !== null && pct >= 10 && !this.autoReviewedThisAsk) {
-              this.autoReviewedThisAsk = true;
-              this.push("status", `auto-review: the page changed ${pct.toFixed(0)}% \u2014 capturing for self-critique`);
-              this.notify({ running: false });
-              const captureResult = await this.capture();
-              if (captureResult) {
-                await this.runTurn(
-                  buildReviewPrompt(captureResult.shots, void 0, captureResult.runtime, captureResult.a11y, captureResult.slop, captureResult.narration, captureResult.phantoms, captureResult.viewTransitions, captureResult.components),
-                  "\u{1F441} auto-review rendered UI"
-                );
-              }
-              return;
-            }
-          }
-        }
-        if (!this.reviewTipShown && this.state.devUrl) {
-          this.reviewTipShown = true;
-          this.push("status", "tip: /review screenshots the app and has the engine critique its own work");
-        }
-      }
-    }
-    this.notify({ running: false });
-    this.drainQueue();
-  }
-  async submit(ask) {
-    this.fixAttempts = 0;
-    this.autoReviewedThisAsk = false;
-    const snapshot = this.state.sandbox ? null : takeSnapshot(this.opts.cwd);
-    if (snapshot) {
-      this.checkpoints.push({
-        snapshot,
-        label: ask.length > 60 ? `${ask.slice(0, 59)}\u2026` : ask,
-        at: Date.now()
-      });
-      if (this.checkpoints.length > 20) this.checkpoints.shift();
-    }
-    const isFirstTurn = this.sessionId === void 0;
-    let prompt = isFirstTurn ? composePrompt(ask, { cwd: this.opts.cwd, firstTurn: true }) : ask;
-    const enrichment = enrich(this.opts.cwd, ask);
-    if (enrichment.matchedSkills.length > 0) {
-      this.push("status", `skills: ${enrichment.matchedSkills.join(", ")}`);
-    }
-    prompt += enrichment.sections;
-    await this.runTurn(prompt, ask);
-  }
-  /** Restore files to the state before checkpoint `index`; drop it and everything after. */
-  restoreTo(index) {
-    const checkpoint = this.checkpoints[index];
-    if (!checkpoint) {
-      this.push("status", "no such checkpoint \u2014 /checkpoints lists them");
-      return;
-    }
-    const result = restoreSnapshot(this.opts.cwd, checkpoint.snapshot);
-    if (result.restored) {
-      const dropped = this.checkpoints.length - index;
-      appendDecision(this.opts.cwd, { decision: `rejected and rolled back: "${checkpoint.label}"`, source: "restore" });
-      this.checkpoints = this.checkpoints.slice(0, index);
-      this.push(
-        "status",
-        `restored files to before "${checkpoint.label}"${dropped > 1 ? ` \xB7 ${dropped} asks rolled back` : ""}${result.deletedFiles > 0 ? ` \xB7 removed ${result.deletedFiles} created file(s)` : ""} \u2014 the conversation continues from here`
-      );
-    } else {
-      this.push("error", `restore failed: ${result.detail ?? "unknown error"}`);
-    }
-  }
-  /** Cross-turn load-performance deltas: the perf twin of the visual pulse. */
-  perfPulse(perf) {
-    if (!perf || perf.lcpMs === void 0 && perf.transferBytes === void 0) return;
-    const previous = this.lastPerf;
-    this.lastPerf = perf;
-    const mb = (bytes) => `${(bytes / 1024 / 1024).toFixed(1)}MB`;
-    const parts = [];
-    if (perf.lcpMs !== void 0) {
-      const delta = previous?.lcpMs !== void 0 && Math.abs(perf.lcpMs - previous.lcpMs) >= 100 ? ` (${perf.lcpMs > previous.lcpMs ? "+" : "\u2212"}${Math.abs(perf.lcpMs - previous.lcpMs)}ms)` : "";
-      parts.push(`LCP ${perf.lcpMs}ms${delta}`);
-    }
-    if (perf.cls !== void 0 && perf.cls > 0.05) parts.push(`CLS ${perf.cls}`);
-    if (perf.transferBytes !== void 0) {
-      const delta = previous?.transferBytes !== void 0 && Math.abs(perf.transferBytes - previous.transferBytes) > 100 * 1024 ? ` (${perf.transferBytes > previous.transferBytes ? "+" : "\u2212"}${mb(Math.abs(perf.transferBytes - previous.transferBytes))})` : "";
-      parts.push(`${mb(perf.transferBytes)}${delta}`);
-    }
-    if (perf.requests !== void 0) parts.push(`${perf.requests} req`);
-    if (parts.length > 0) this.push("status", `perf: ${parts.join(" \xB7 ")}`);
-  }
-  /**
-   * 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 null;
-    let current;
-    try {
-      current = (await import("fs")).readFileSync(pulsePath);
-    } catch {
-      return null;
-    }
-    const previous = this.lastPulse;
-    this.lastPulse = current;
-    if (!previous) {
-      this.push("status", "visual pulse: baseline captured");
-      this.push("image", pulsePath);
-      return null;
-    }
-    const pct = await comparePulse(previous, current);
-    if (pct === null) return null;
-    this.push(
-      "status",
-      pct < 0.5 ? "visual pulse: stable vs last turn" : `visual pulse: ${pct.toFixed(1)}% of the page changed vs last turn`
-    );
-    runHook(this.opts.cwd, "on-pulse-diff", { pct: pct.toFixed(1) });
-    if (pct >= 0.5) this.push("image", pulsePath);
-    return pct;
-  }
-  /** Screenshot the running app (and watch its runtime where CDP is available). */
-  async capture(urlOverride) {
-    const url = urlOverride || this.state.devUrl;
-    if (!url) {
-      this.push("error", "dev server not running \u2014 /dev first, or /shot <url>");
-      return null;
-    }
-    this.push("status", "capturing screenshots\u2026");
-    const result = await captureViewports(this.opts.cwd, url);
-    if (!result) {
-      this.push("error", "no Chrome/Chromium found for screenshots");
-      return null;
-    }
-    for (const err of result.errors) this.push("error", `screenshot ${err}`);
-    if (result.shots.length > 0) {
-      this.push(
-        "status",
-        `captured ${result.shots.map((s) => s.name).join(", ")} \u2192 ${path3.dirname(result.shots[0].path)}`
-      );
-      const desktop = result.shots.find((s) => s.name === "desktop") ?? result.shots[0];
-      this.push("image", desktop.path);
-    }
-    if (result.runtime) {
-      const summary = runtimeSummary(result.runtime);
-      if (summary) {
-        this.push("error", `runtime: ${summary}`);
-        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");
-      }
-    }
-    const vtHard = (result.viewTransitions ?? []).filter((f) => f.startsWith("duplicate"));
-    if (vtHard.length > 0) {
-      this.push("error", `view transitions: ${vtHard.length} broken
-${vtHard.join("\n")}`);
-      this.addProblem(
-        "runtime",
-        `${vtHard.length} view transition(s) the browser will skip`,
-        `Duplicate view-transition-name values make the browser abort the entire transition at runtime:
-
-${vtHard.join("\n")}
-
-Give each simultaneously rendered element a unique name (or scope names per item, e.g. per list key). Do not remove the transitions.`
-      );
-    }
-    const vtSoft = (result.viewTransitions ?? []).filter((f) => !f.startsWith("duplicate"));
-    if (vtSoft.length > 0) {
-      this.push("status", `view transitions: ${vtSoft.join("; ")}`);
-    }
-    if (result.phantoms && result.phantoms.length > 0) {
-      this.push("error", `phantom classes: ${result.phantoms.length} (in the DOM, absent from CSS)
-${result.phantoms.slice(0, 5).join("\n")}`);
-      this.addProblem(
-        "runtime",
-        `${result.phantoms.length} phantom class(es) \u2014 elements silently unstyled`,
-        `These class tokens appear in the DOM but match no CSS rule, so the elements are silently unstyled. Usually a misspelled or version-mismatched utility (e.g. Tailwind v3 spellings in a v4 project) or a concatenated class the scanner never compiled:
-
-${result.phantoms.join("\n")}
-
-Fix the class names or define the styles, then confirm visually.`
-      );
-      this.push("status", "/fix sends open problems to the engine");
-    }
-    if (result.slop && result.slop.length > 0) {
-      this.push("status", `distinctiveness: ${result.slop.length} tell(s)
-${result.slop.join("\n")}`);
-    }
-    if (result.a11y && result.a11y.length > 0) {
-      this.push("error", `a11y: ${result.a11y.length} finding(s)
-${result.a11y.slice(0, 5).join("\n")}`);
-      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;
-  }
-  command(commandLine) {
-    const [name, ...rest] = commandLine.slice(1).split(/\s+/);
-    const arg = rest.join(" ").trim();
-    switch (name) {
-      case "engines": {
-        void import("./registry-MIJ6LSAY.js").then(({ detectEngines: detectEngines2 }) => {
-          const lines = detectEngines2().map(({ engine, path: binaryPath }) => {
-            const mark = binaryPath ? "\u2713" : "\u2717";
-            const traits = [engine.createParser ? "stream" : "text", engine.supportsResume ? "resume" : null].filter(Boolean).join(" \xB7 ");
-            return `${mark} ${engine.id} \u2014 ${traits}${binaryPath ? "" : ` \xB7 install: ${engine.install}`}`;
-          });
-          this.push("status", `${lines.join("\n")}
-/engine <id> switches (new session)`);
-        });
-        break;
-      }
-      case "engine":
-        if (!arg) {
-          this.command("/engines");
-        } else {
-          try {
-            getEngine(arg);
-            this.sessionId = void 0;
-            this.notify({ engineId: arg });
-            this.push("status", `engine \u2192 ${arg} (new session)`);
-          } catch (err) {
-            this.push("error", err instanceof Error ? err.message : String(err));
-          }
-        }
-        break;
-      case "model":
-        this.notify({ model: arg || void 0 });
-        this.push("status", arg ? `model \u2192 ${arg}` : "model \u2192 engine default");
-        break;
-      case "mode":
-        if (arg === "plan" || arg === "safe" || arg === "yolo") {
-          this.setMode(arg);
-        } else {
-          this.push("status", "usage: /mode plan|safe|yolo \u2014 or shift+tab to cycle");
-        }
-        break;
-      case "dev": {
-        const dev = this.devServer();
-        if (arg === "logs") {
-          const tail = dev.tail(15);
-          this.push("status", tail.length > 0 ? tail.join("\n") : "no dev server output captured yet");
-          break;
-        }
-        if (arg === "restart") {
-          if (dev.state !== "stopped") dev.stop();
-          this.notify({ devUrl: null });
-          const devCommand = detectDevCommand(this.opts.cwd);
-          if (!devCommand) {
-            this.push("error", "no dev/start script found in package.json");
-          } else {
-            dev.start(devCommand);
-            this.push("status", `dev server restarting \xB7 ${devCommand.display}`);
-          }
-          break;
-        }
-        if (dev.state === "stopped" || dev.state === "crashed") {
-          const devCommand = detectDevCommand(this.opts.cwd);
-          if (!devCommand) {
-            this.push("error", "no dev/start script found in package.json");
-          } else {
-            dev.start(devCommand);
-            this.push("status", `dev server starting \xB7 ${devCommand.display}`);
-          }
-        } else {
-          dev.stop();
-          this.notify({ devUrl: null });
-          this.push("status", "dev server stopped");
-        }
-        break;
-      }
-      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 "context": {
-        import("./contextDoctor-U3YTDFVG.js").then(({ contextReport, formatContextReport }) => {
-          this.push("status", formatContextReport(contextReport(this.execCwd())));
-        }).catch((error) => {
-          this.push("status", `context report failed: ${error instanceof Error ? error.message : String(error)}`);
-        });
-        break;
-      }
-      case "yes":
-      case "no": {
-        if (!this.pendingApproval) {
-          this.push("status", `nothing awaiting approval \u2014 /${name} answers an engine's approval request`);
-          break;
-        }
-        const summary = this.pendingApproval;
-        this.pendingApproval = null;
-        const approved = name === "yes";
-        appendDecision(this.opts.cwd, {
-          decision: `${approved ? "approved" : "rejected"}: ${summary}${arg ? ` \u2014 ${arg}` : ""}`,
-          source: "approval"
-        });
-        void this.runTurn(
-          approved ? `Approved: "${summary}". Proceed.${arg ? ` Note from the user: ${arg}` : ""}` : `Rejected: "${summary}". Do not proceed with it.${arg ? ` The user says: ${arg}` : " Stop and await direction."}`,
-          approved ? `\u2713 approved${arg ? ` \u2014 ${arg}` : ""}` : `\u2717 rejected${arg ? ` \u2014 ${arg}` : ""}`
-        );
-        break;
-      }
-      case "decide": {
-        if (!arg) {
-          this.push("status", "usage: /decide <the decision> \u2014 recorded in .squint/design-log.jsonl and injected into every future ask");
-          break;
-        }
-        appendDecision(this.opts.cwd, {
-          decision: arg,
-          source: "decide",
-          screenshot: this.lastPulse ? ".squint/preview/pulse.png" : void 0
-        });
-        this.push("status", `decision recorded: ${arg}`);
-        break;
-      }
-      case "find": {
-        if (!arg) {
-          this.push("status", "usage: /find <term> \u2014 searches this session and saved transcripts");
-          break;
-        }
-        const needle = arg.toLowerCase();
-        const matches = [];
-        for (const item of this.state.items) {
-          if ((item.role === "user" || item.role === "assistant") && item.text.toLowerCase().includes(needle)) {
-            const line = item.text.split("\n").find((l) => l.toLowerCase().includes(needle)) ?? item.text;
-            matches.push(`[live] ${item.role === "user" ? "\u276F " : ""}${line.trim().slice(0, 90)}`);
-            if (matches.length >= 8) break;
-          }
-        }
-        if (matches.length < 8) {
-          void (async () => {
-            try {
-              const fs4 = await import("fs");
-              const path5 = await import("path");
-              const dir = path5.join(this.opts.cwd, ".squint", "transcripts");
-              const files = fs4.readdirSync(dir).filter((f) => f.endsWith(".md")).sort().reverse().slice(0, 20);
-              for (const file of files) {
-                if (matches.length >= 8) break;
-                const text = fs4.readFileSync(path5.join(dir, file), "utf8");
-                for (const line of text.split("\n")) {
-                  if (line.toLowerCase().includes(needle)) {
-                    matches.push(`[${file.replace(/\.md$/, "")}] ${line.trim().slice(0, 90)}`);
-                    break;
-                  }
-                }
-              }
-            } catch {
-            }
-            this.push(
-              "status",
-              matches.length > 0 ? `${matches.join("\n")}
-/checkpoints can rewind \xB7 /save archives this session` : `no matches for "${arg}"`
-            );
-          })();
-        } else {
-          this.push("status", matches.join("\n"));
-        }
-        break;
-      }
-      case "save": {
-        void (async () => {
-          const fs4 = await import("fs");
-          const path5 = await import("path");
-          const dir = path5.join(this.opts.cwd, ".squint", "transcripts");
-          fs4.mkdirSync(dir, { recursive: true });
-          const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-          const file = path5.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 "image":
-                lines.push(`![screenshot](${item.text})`, "");
-                break;
-              case "thinking":
-                break;
-              default:
-                lines.push(`> ${item.role === "error" ? "\u2717 " : ""}${item.text.split("\n").join("\n> ")}`);
-            }
-          }
-          lines.push("", `> ${this.summary()}`);
-          fs4.writeFileSync(file, lines.join("\n") + "\n");
-          this.push("status", `saved transcript \u2192 ${path5.relative(this.opts.cwd, file)}`);
-        })();
-        break;
-      }
-      case "flows": {
-        if (!this.state.devUrl) {
-          this.push("error", "dev server not running \u2014 /dev first");
-          break;
-        }
-        void (async () => {
-          const { loadFlows } = await import("./flows-6LK7NGWS.js");
-          const flows = loadFlows(this.opts.cwd);
-          if (flows.length === 0) {
-            this.push("status", "no flows \u2014 add .squint/flows/<name>.flow (goto/click/fill/press/expect/shot lines), or ask the engine to write one");
-            return;
-          }
-          const chrome = findChrome();
-          if (!chrome) {
-            this.push("error", "no Chrome/Chromium found for flows");
-            return;
-          }
-          const { runFlow } = await import("./cdp-Q4H6ZHPT.js");
-          const { previewDir } = await import("./preview-ZUCVWGZG.js");
-          this.push("status", `replaying ${flows.length} flow(s)\u2026`);
-          this.notify({ running: true, runStartedAt: Date.now() });
-          const failures = [];
-          for (const flow of flows) {
-            const wanted = arg.trim();
-            if (wanted && flow.name !== wanted) continue;
-            const result = await runFlow(chrome, this.state.devUrl, flow, previewDir(this.opts.cwd));
-            if (result.ok) {
-              this.push("status", `\u2713 flow ${flow.name} \xB7 ${flow.steps.length} steps${result.shots.length > 0 ? ` \xB7 ${result.shots.length} shot(s)` : ""}`);
-              for (const shot of result.shots) this.push("image", shot);
-            } else {
-              const where = result.failedStep ? ` at step ${result.failedStep}` : "";
-              this.push("error", `\u2717 flow ${flow.name}${where}: ${result.detail}`);
-              failures.push(`Flow "${flow.name}" fails${where}: ${result.detail}. The flow file is .squint/flows/${flow.name}.flow \u2014 fix the app (or the flow if the UI legitimately changed).`);
-            }
-          }
-          this.notify({ running: false });
-          if (failures.length > 0) {
-            this.addProblem("flow", `${failures.length} flow(s) failing`, failures.join("\n\n"));
-            this.push("status", "/fix sends open problems to the engine \xB7 /problems lists them");
-          } else {
-            this.clearProblems("flow");
-          }
-          this.drainQueue();
-        })();
-        break;
-      }
-      case "score": {
-        if (!this.state.devUrl) {
-          this.push("error", "dev server not running \u2014 /dev first");
-          break;
-        }
-        void (async () => {
-          const result = await this.capture();
-          if (!result) return;
-          const a11yCount = result.a11y?.length ?? 0;
-          const slopCount = result.slop?.length ?? 0;
-          const runtimeBad = result.runtime ? runtimeSummary(result.runtime) ? 1 : 0 : 0;
-          const problems = this.state.problems.length;
-          const score = Math.max(
-            0,
-            5 - problems * 0.75 - Math.min(a11yCount, 4) * 0.25 - Math.min(slopCount, 4) * 0.25 - runtimeBad
-          );
-          const lcp = this.lastPerf?.lcpMs !== void 0 ? ` \xB7 LCP ${this.lastPerf.lcpMs}ms` : "";
-          this.push(
-            "status",
-            [
-              `score: ${score.toFixed(2)}/5 (deterministic axes)`,
-              `  open problems: ${problems}${problems > 0 ? ` (${this.state.problems.map((p) => p.source).join(", ")})` : ""}`,
-              `  a11y findings: ${a11yCount} \xB7 distinctiveness tells: ${slopCount} \xB7 runtime ${runtimeBad ? "dirty" : "clean"}${lcp}`,
-              "  /review judges what numbers cannot \u2014 hierarchy, taste, coherence"
-            ].join("\n")
-          );
-        })();
-        break;
-      }
-      case "polish": {
-        const rounds = arg ? Number.parseInt(arg, 10) : 2;
-        if (!Number.isInteger(rounds) || rounds < 1 || rounds > 5) {
-          this.push("status", "usage: /polish [1-5] \u2014 rounds of screenshot \u2192 critique \u2192 fix (each costs a turn)");
-          break;
-        }
-        if (!this.state.devUrl) {
-          this.push("error", "dev server not running \u2014 /dev first");
-          break;
-        }
-        this.push("status", `polishing: ${rounds} round${rounds === 1 ? "" : "s"} of review \u2192 fix`);
-        void this.polish(rounds);
-        break;
-      }
-      case "btw":
-        if (!arg) {
-          this.push("status", "usage: /btw <question> \u2014 read-only side question, main thread untouched");
-        } else {
-          void this.btw(arg);
-        }
-        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: spawn2 }) => {
-          const cmd = process.platform === "darwin" ? spawn2("pbcopy") : process.platform === "win32" ? spawn2("clip") : spawn2("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":
-        void (async () => {
-          const gates = detectGates(this.opts.cwd);
-          if (gates.length === 0) {
-            this.push("status", "no gates detected in this project");
-            return;
-          }
-          this.push("status", `running gates: ${gates.map((g) => g.id).join(" \u2192 ")}`);
-          this.notify({ running: true, runStartedAt: Date.now() });
-          const results = await runGates(this.opts.cwd, gates, (result) => {
-            this.push(
-              result.ok ? "status" : "error",
-              `${result.ok ? "\u2713" : "\u2717"} ${result.gate.id} \xB7 ${(result.durationMs / 1e3).toFixed(1)}s`
-            );
-          });
-          this.notify({ running: false });
-          this.drainQueue();
-          const failures = results.filter((r) => !r.ok);
-          if (failures.length > 0) {
-            this.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");
-          }
-        })();
-        break;
-      case "shot":
-        void this.capture(arg || void 0);
-        break;
-      case "review":
-        void (async () => {
-          const result = await this.capture();
-          if (result) {
-            await this.runTurn(
-              buildReviewPrompt(result.shots, arg || void 0, result.runtime, result.a11y, result.slop, result.narration, result.phantoms, result.viewTransitions, result.components),
-              `\u{1F441} review rendered UI${arg ? ` \xB7 ${arg}` : ""}`
-            );
-          }
-        })();
-        break;
-      case "undo":
-        if (this.checkpoints.length === 0) {
-          this.push("status", "nothing to undo \u2014 no ask this session, or not a git repo with commits");
-        } else {
-          this.restoreTo(this.checkpoints.length - 1);
-        }
-        break;
-      case "checkpoints":
-        if (this.checkpoints.length === 0) {
-          this.push("status", "no checkpoints yet \u2014 one is taken before every ask in a git repo");
-        } else {
-          const lines = this.checkpoints.map((c, i) => {
-            const mins = Math.max(0, Math.round((Date.now() - c.at) / 6e4));
-            return `${i + 1}. ${c.label} \xB7 ${mins}m ago`;
-          });
-          this.push("status", `${lines.join("\n")}
-/restore <n> rewinds files to before that ask \xB7 /undo pops the last`);
-        }
-        break;
-      case "restore": {
-        const index = Number.parseInt(arg, 10);
-        if (!Number.isInteger(index) || index < 1 || index > this.checkpoints.length) {
-          this.push("status", `usage: /restore <1\u2013${Math.max(this.checkpoints.length, 1)}> \u2014 see /checkpoints`);
-        } else {
-          this.restoreTo(index - 1);
-        }
-        break;
-      }
-      case "resume": {
-        const saved = loadState(this.opts.cwd);
-        if (!saved) {
-          this.push("status", "no previous session for this project");
-          break;
-        }
-        try {
-          if (!getEngine(saved.engine).supportsResume) {
-            this.push("status", `previous engine ${saved.engine} cannot resume sessions`);
-            break;
-          }
-        } catch {
-          this.push("error", `previous engine ${saved.engine} is no longer available`);
-          break;
-        }
-        this.sessionId = saved.sessionId;
-        this.notify({
-          engineId: saved.engine,
-          model: saved.model ?? this.state.model,
-          totals: saved.totals ?? this.state.totals
-        });
-        this.push("status", `resumed ${saved.engine} session${saved.lastAsk ? ` \xB7 "${saved.lastAsk}"` : ""}`);
-        break;
-      }
-      case "sandbox": {
-        if (this.state.running) {
-          this.push("status", "wait for the current turn before changing sandbox state");
-          break;
-        }
-        if (arg === "diff") {
-          const stat = sandboxDiffStat(this.opts.cwd);
-          if (!stat) {
-            this.push("status", sandboxExists(this.opts.cwd) ? "sandbox is clean" : "no sandbox open \u2014 /sandbox on");
-          } else {
-            this.push("status", `${stat}
-${sandboxFiles(this.opts.cwd).join("\n")}`);
-          }
-          break;
-        }
-        if (arg === "apply") {
-          const applied = applySandbox(this.opts.cwd);
-          if (applied.ok) {
-            discardSandbox(this.opts.cwd);
-            this.notify({ sandbox: false });
-            this.resetDevServer();
-            appendDecision(this.opts.cwd, { decision: "accepted the sandboxed session onto the real tree", source: "sandbox" });
-            this.push("status", "sandbox applied to the real tree \u2014 review with git diff");
-          } else {
-            this.push("error", applied.detail ?? "apply failed");
-          }
-          break;
-        }
-        if (arg === "discard" || arg === "off") {
-          const had = discardSandbox(this.opts.cwd);
-          this.notify({ sandbox: false });
-          this.resetDevServer();
-          this.push("status", had ? "sandbox discarded \u2014 the real tree was never touched" : "no sandbox open");
-          break;
-        }
-        if (arg === "on" || arg === "") {
-          if (!isGitRepo(this.opts.cwd)) {
-            this.push("error", "sandbox needs a git repo with at least one commit");
-            break;
-          }
-          const { reused } = openSandbox(this.opts.cwd);
-          this.notify({ sandbox: true });
-          this.resetDevServer();
-          this.push(
-            "status",
-            `${reused ? "rejoined the open sandbox" : "sandbox opened"} \u2014 asks now accumulate in a shadow worktree; /sandbox diff \xB7 apply \xB7 discard`
-          );
-          break;
-        }
-        this.push("status", "usage: /sandbox [on] \xB7 diff \xB7 apply \xB7 discard");
-        break;
-      }
-      case "variants": {
-        const [sub, ...subRest] = arg.split(/\s+/);
-        if (sub === "apply") {
-          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);
-            appendDecision(this.opts.cwd, { decision: `chose the ${id} direction over the other variants`, source: "variant" });
-            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);
-        this.notify({ items: [], totals: { costUsd: 0, turns: 0 } });
-        break;
-      case "help": {
-        void import("./commands-BY44HDQ6.js").then(({ commandHelp }) => this.push("status", commandHelp()));
-        break;
-      }
-      case "quit":
-      case "exit":
-        this.push("status", this.summary());
-        this.dispose();
-        this.opts.onQuit?.();
-        break;
-      default:
-        this.push("error", `unknown command /${name} \u2014 try /help`);
-    }
-  }
-};
-
-// src/tui/lineEditor.ts
-var emptyLine = { text: "", cursor: 0 };
-function fromText(text) {
-  return { text, cursor: text.length };
-}
-function insert(line, str) {
-  const clean = str.replace(/\r/g, "").replace(/\n+/g, " ");
-  return {
-    text: line.text.slice(0, line.cursor) + clean + line.text.slice(line.cursor),
-    cursor: line.cursor + clean.length
-  };
-}
-function backspace(line) {
-  if (line.cursor === 0) return line;
-  return {
-    text: line.text.slice(0, line.cursor - 1) + line.text.slice(line.cursor),
-    cursor: line.cursor - 1
-  };
-}
-function left(line) {
-  return { ...line, cursor: Math.max(0, line.cursor - 1) };
-}
-function right(line) {
-  return { ...line, cursor: Math.min(line.text.length, line.cursor + 1) };
-}
-function home(line) {
-  return { ...line, cursor: 0 };
-}
-function end(line) {
-  return { ...line, cursor: line.text.length };
-}
-var isWordChar = (ch) => /[\p{L}\p{N}_/@.-]/u.test(ch);
-function wordLeft(line) {
-  let i = line.cursor;
-  while (i > 0 && !isWordChar(line.text[i - 1])) i--;
-  while (i > 0 && isWordChar(line.text[i - 1])) i--;
-  return { ...line, cursor: i };
-}
-function wordRight(line) {
-  let i = line.cursor;
-  const n = line.text.length;
-  while (i < n && !isWordChar(line.text[i])) i++;
-  while (i < n && isWordChar(line.text[i])) i++;
-  return { ...line, cursor: i };
-}
-function killToEnd(line) {
-  return { text: line.text.slice(0, line.cursor), cursor: line.cursor };
-}
-function killToStart(line) {
-  return { text: line.text.slice(line.cursor), cursor: 0 };
-}
-function killWordBack(line) {
-  const target = wordLeft(line).cursor;
-  return {
-    text: line.text.slice(0, target) + line.text.slice(line.cursor),
-    cursor: target
-  };
-}
-
-// src/tui/markdown.tsx
-import { Box, Text } from "ink";
-
-// src/tui/themeContext.tsx
-import { createContext, useContext } from "react";
-
-// src/tui/theme.ts
-var THEMES = {
-  amber: {
-    name: "amber",
-    accent: "#e8a33d",
-    dim: "gray",
-    user: "#7aa2f7",
-    error: "#f7768e",
-    success: "#9ece6a",
-    tool: "#7dcfff"
-  },
-  ocean: {
-    name: "ocean",
-    accent: "#56b6c2",
-    dim: "gray",
-    user: "#61afef",
-    error: "#e06c75",
-    success: "#98c379",
-    tool: "#c678dd"
-  },
-  moss: {
-    name: "moss",
-    accent: "#a7c080",
-    dim: "gray",
-    user: "#7fbbb3",
-    error: "#e67e80",
-    success: "#83c092",
-    tool: "#d699b6"
-  },
-  rose: {
-    name: "rose",
-    accent: "#ebbcba",
-    dim: "gray",
-    user: "#9ccfd8",
-    error: "#eb6f92",
-    success: "#31748f",
-    tool: "#c4a7e7"
-  },
-  light: {
-    name: "light",
-    accent: "#9a6b1f",
-    dim: "#6b6f76",
-    user: "#2a5db0",
-    error: "#c4322e",
-    success: "#3d7a37",
-    tool: "#0f7b8a"
-  },
-  mono: {
-    name: "mono",
-    accent: "white",
-    dim: "gray",
-    user: "white",
-    error: "white",
-    success: "white",
-    tool: "gray"
-  }
-};
-var DEFAULT_THEME = "amber";
-function resolveTheme(name, env = process.env) {
-  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return THEMES.mono;
-  return THEMES[name ?? DEFAULT_THEME] ?? THEMES[DEFAULT_THEME];
-}
-var theme = THEMES[DEFAULT_THEME];
-
-// src/tui/themeContext.tsx
-var ThemeContext = createContext(theme);
-var ThemeProvider = ThemeContext.Provider;
-function useTheme() {
-  return useContext(ThemeContext);
-}
-
-// src/tui/markdown.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
-var INLINE_RE = /(\*\*[^*]+\*\*|\*[^*\s][^*]*\*|`[^`]+`)/g;
-function parseInline(text) {
-  const segments = [];
-  let last = 0;
-  for (const match of text.matchAll(INLINE_RE)) {
-    if (match.index > last) segments.push({ text: text.slice(last, match.index) });
-    const token = match[0];
-    if (token.startsWith("**")) segments.push({ text: token.slice(2, -2), bold: true });
-    else if (token.startsWith("`")) segments.push({ text: token.slice(1, -1), code: true });
-    else segments.push({ text: token.slice(1, -1), italic: true });
-    last = match.index + token.length;
-  }
-  if (last < text.length) segments.push({ text: text.slice(last) });
-  return segments;
-}
-function parseBlocks(text) {
-  const blocks = [];
-  let code = null;
-  for (const rawLine of text.split("\n")) {
-    const line = rawLine.replace(/\s+$/, "");
-    if (code) {
-      if (/^\s*```/.test(line)) {
-        blocks.push({ type: "code", ...code });
-        code = null;
-      } else {
-        code.lines.push(rawLine);
-      }
-      continue;
-    }
-    const fence = /^\s*```(\S*)/.exec(line);
-    if (fence) {
-      code = { lang: fence[1] ?? "", lines: [] };
-      continue;
-    }
-    const heading = /^(#{1,4})\s+(.*)$/.exec(line);
-    if (heading) {
-      blocks.push({ type: "heading", level: heading[1].length, text: heading[2] });
-      continue;
-    }
-    if (/^\s*([-*_])\s*\1\s*\1[\s\-*_]*$/.test(line) && line.trim().length >= 3) {
-      blocks.push({ type: "hr" });
-      continue;
-    }
-    const item = /^(\s*)[-*+]\s+(.*)$/.exec(line);
-    if (item) {
-      blocks.push({ type: "item", text: item[2], indent: Math.floor(item[1].length / 2) });
-      continue;
-    }
-    const ordered = /^(\s*)(\d+)[.)]\s+(.*)$/.exec(line);
-    if (ordered) {
-      blocks.push({
-        type: "item",
-        text: ordered[3],
-        indent: Math.floor(ordered[1].length / 2),
-        ordered: ordered[2]
-      });
-      continue;
-    }
-    const quote = /^\s*>\s?(.*)$/.exec(line);
-    if (quote) {
-      blocks.push({ type: "quote", text: quote[1] });
-      continue;
-    }
-    blocks.push({ type: "para", text: line });
-  }
-  if (code) blocks.push({ type: "code", ...code });
-  return blocks;
-}
-function Inline({ text, dim }) {
-  const theme2 = useTheme();
-  const segments = parseInline(text);
-  return /* @__PURE__ */ jsx(Text, { wrap: "wrap", dimColor: dim, children: segments.map(
-    (segment, index) => segment.code ? /* @__PURE__ */ jsx(Text, { color: theme2.tool, children: segment.text }, index) : /* @__PURE__ */ jsx(Text, { bold: segment.bold, italic: segment.italic, children: segment.text }, index)
-  ) });
-}
-function Markdown({ text }) {
-  const theme2 = useTheme();
-  const blocks = parseBlocks(text);
-  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: blocks.map((block, index) => {
-    switch (block.type) {
-      case "heading":
-        return /* @__PURE__ */ jsx(Text, { bold: true, color: block.level <= 2 ? theme2.accent : void 0, wrap: "wrap", children: block.text }, index);
-      case "item":
-        return /* @__PURE__ */ jsxs(Box, { paddingLeft: 1 + block.indent * 2, children: [
-          /* @__PURE__ */ jsxs(Text, { color: theme2.accent, children: [
-            block.ordered ? `${block.ordered}.` : "\u2022",
-            " "
-          ] }),
-          /* @__PURE__ */ jsx(Inline, { text: block.text })
-        ] }, index);
-      case "quote":
-        return /* @__PURE__ */ jsxs(Box, { paddingLeft: 1, children: [
-          /* @__PURE__ */ jsx(Text, { color: theme2.dim, children: "\u2502 " }),
-          /* @__PURE__ */ jsx(Inline, { text: block.text, dim: true })
-        ] }, index);
-      case "code":
-        return /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingLeft: 1, children: block.lines.map((line, lineIndex) => /* @__PURE__ */ jsxs(Text, { children: [
-          /* @__PURE__ */ jsx(Text, { color: theme2.dim, children: "\u258F " }),
-          /* @__PURE__ */ jsx(Text, { color: theme2.tool, children: line.length > 0 ? line : " " })
-        ] }, lineIndex)) }, index);
-      case "hr":
-        return /* @__PURE__ */ jsx(Text, { color: theme2.dim, children: "\u2500".repeat(32) }, index);
-      case "para":
-        return block.text.length === 0 ? /* @__PURE__ */ jsx(Text, { children: " " }, index) : /* @__PURE__ */ jsx(Inline, { text: block.text }, index);
-    }
-  }) });
-}
-
-// src/tui/messages.tsx
-import { Box as Box2, Text as Text2 } from "ink";
-import Image from "ink-picture";
-import { useEffect, useState } from "react";
-
-// src/tui/termImage.ts
-function supportsInlineImages(env = process.env) {
-  if (env.TMUX) return false;
-  if (env.TERM === "xterm-kitty" || env.KITTY_WINDOW_ID) return true;
-  if (env.TERM === "xterm-ghostty" || env.GHOSTTY_RESOURCES_DIR) return true;
-  if (env.TERM_PROGRAM === "WezTerm") return true;
-  if (env.TERM_PROGRAM === "iTerm.app") return true;
-  return false;
-}
-
-// src/tui/messages.tsx
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-var INLINE_IMAGES = supportsInlineImages();
-var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-var PHRASES = ["working", "thinking", "squinting", "crafting", "still at it"];
-function WorkingLine({ startedAt }) {
-  const theme2 = useTheme();
-  const [frame, setFrame] = useState(0);
-  const [elapsed, setElapsed] = useState(0);
-  useEffect(() => {
-    const timer = setInterval(() => {
-      setFrame((f) => (f + 1) % SPINNER_FRAMES.length);
-      setElapsed(Math.floor((Date.now() - startedAt) / 1e3));
-    }, 80);
-    return () => clearInterval(timer);
-  }, [startedAt]);
-  const phrase = PHRASES[Math.min(Math.floor(elapsed / 8), PHRASES.length - 1)];
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
-    /* @__PURE__ */ jsx2(Text2, { color: theme2.accent, children: SPINNER_FRAMES[frame] }),
-    /* @__PURE__ */ jsxs2(Text2, { color: theme2.dim, children: [
-      " ",
-      phrase,
-      "\u2026 ",
-      elapsed,
-      "s \xB7 esc to interrupt"
-    ] })
-  ] });
-}
-function toolGlyph(text) {
-  const name = text.split(/[\s·]/, 1)[0]?.toLowerCase() ?? "";
-  if (name.includes("todo")) return "\u2630";
-  if (name.includes("read") || name.includes("view") || name.includes("cat")) return "\u2299";
-  if (name.includes("edit") || name.includes("write") || name.includes("patch") || name.includes("apply")) return "\u270E";
-  if (name.includes("bash") || name.includes("shell") || name.includes("exec") || name.includes("command")) return "$";
-  if (name.includes("grep") || name.includes("glob") || name.includes("search") || name.includes("find")) return "\u2315";
-  if (name.includes("web") || name.includes("fetch") || name.includes("http")) return "\u21E3";
-  if (name.includes("task") || name.includes("agent")) return "\u25C7";
-  return "\u2699";
-}
-function MessageLine({ message }) {
-  const theme2 = useTheme();
-  switch (message.role) {
-    case "user":
-      return /* @__PURE__ */ jsxs2(Text2, { color: theme2.user, wrap: "wrap", children: [
-        "\u276F ",
-        message.text
-      ] });
-    case "assistant":
-      return /* @__PURE__ */ jsx2(Markdown, { text: message.text });
-    case "status":
-      return /* @__PURE__ */ jsxs2(Text2, { color: theme2.dim, wrap: "wrap", children: [
-        "\xB7 ",
-        message.text
-      ] });
-    case "tool":
-      return /* @__PURE__ */ jsxs2(Text2, { color: theme2.tool, wrap: "wrap", children: [
-        toolGlyph(message.text),
-        " ",
-        message.text
-      ] });
-    case "thinking":
-      return /* @__PURE__ */ jsx2(Text2, { color: theme2.dim, italic: true, wrap: "wrap", children: message.text });
-    case "error":
-      return /* @__PURE__ */ jsxs2(Text2, { color: theme2.error, wrap: "wrap", children: [
-        "\u2717 ",
-        message.text
-      ] });
-    case "image":
-      if (!INLINE_IMAGES) {
-        return /* @__PURE__ */ jsxs2(Text2, { color: theme2.dim, wrap: "wrap", children: [
-          "\u25A3 ",
-          message.text
-        ] });
-      }
-      return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
-        /* @__PURE__ */ jsx2(Image, { src: message.text, width: 48, height: 14, alt: "screenshot" }),
-        /* @__PURE__ */ jsxs2(Text2, { color: theme2.dim, children: [
-          "\u25A3 ",
-          message.text
-        ] })
-      ] });
-  }
-}
-
-// src/tui/App.tsx
-import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
-function App({
-  cwd,
-  initialEngine,
-  initialModel,
-  autoDev,
-  autoFix,
-  autoProbe,
-  autoCheck,
-  autoReview,
-  fixModel,
-  bell,
-  budgetUsd,
-  initialTheme
-}) {
-  const { exit } = useApp();
-  const [themeName, setThemeName] = useState2(() => resolveTheme(initialTheme).name);
-  const theme2 = resolveTheme(themeName);
-  const sessionRef = useRef(null);
-  if (!sessionRef.current) {
-    sessionRef.current = new Session({
-      cwd,
-      engineId: initialEngine,
-      model: initialModel,
-      autoDev,
-      autoFix,
-      autoProbe,
-      autoCheck,
-      autoReview,
-      fixModel,
-      budgetUsd,
-      // Delay lets the goodbye summary land in the Static scrollback.
-      onQuit: () => setTimeout(() => exit(), 60)
-    });
-  }
-  const session = sessionRef.current;
-  const state = useSyncExternalStore(
-    useMemo(() => (listener) => session.subscribe(listener), [session]),
-    () => session.getState()
-  );
-  const [line, setLine] = useState2(emptyLine);
-  const historyRef = useRef([]);
-  const historyIndexRef = useRef(-1);
-  const ctrlCArmedAtRef = useRef(0);
-  const wasRunningRef = useRef(false);
-  if (wasRunningRef.current && !state.running && bell !== false) {
-    process.stdout.write("\x07");
-  }
-  wasRunningRef.current = state.running;
-  useInput((char, key) => {
-    if (key.ctrl && char === "c") {
-      const now = Date.now();
-      if (now - ctrlCArmedAtRef.current < 2e3) {
-        session.note(session.summary());
-        session.dispose();
-        setTimeout(() => exit(), 60);
-      } else {
-        ctrlCArmedAtRef.current = now;
-        session.note("press ctrl+c again to exit");
-      }
-      return;
-    }
-    if (key.escape && state.running) {
-      session.interrupt();
-      return;
-    }
-    if (key.tab && key.shift) {
-      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);
-      historyIndexRef.current = -1;
-      if (!value) return;
-      historyRef.current.push(value);
-      if (value === "/theme" || value.startsWith("/theme ")) {
-        const requested = value.slice("/theme".length).trim();
-        if (!requested) {
-          session.note(`themes: ${Object.keys(THEMES).join(", ")} \u2014 /theme <name>`);
-        } else if (THEMES[requested]) {
-          setThemeName(requested);
-          session.note(`theme \u2192 ${requested}`);
-        } else {
-          session.note(`unknown theme "${requested}" \u2014 themes: ${Object.keys(THEMES).join(", ")}`);
-        }
-        return;
-      }
-      session.input(value);
-      return;
-    }
-    if (key.upArrow) {
-      const history = historyRef.current;
-      if (history.length === 0) return;
-      const next = historyIndexRef.current === -1 ? history.length - 1 : Math.max(historyIndexRef.current - 1, 0);
-      historyIndexRef.current = next;
-      setLine(fromText(history[next] ?? ""));
-      return;
-    }
-    if (key.downArrow) {
-      const history = historyRef.current;
-      if (historyIndexRef.current === -1) return;
-      const next = historyIndexRef.current + 1;
-      if (next >= history.length) {
-        historyIndexRef.current = -1;
-        setLine(emptyLine);
-      } else {
-        historyIndexRef.current = next;
-        setLine(fromText(history[next] ?? ""));
-      }
-      return;
-    }
-    if (key.leftArrow) {
-      setLine((prev) => key.meta ? wordLeft(prev) : left(prev));
-      return;
-    }
-    if (key.rightArrow) {
-      setLine((prev) => key.meta ? wordRight(prev) : right(prev));
-      return;
-    }
-    if (key.backspace || key.delete) {
-      setLine((prev) => key.meta ? killWordBack(prev) : backspace(prev));
-      return;
-    }
-    if (key.ctrl) {
-      switch (char) {
-        case "a":
-          setLine(home);
-          return;
-        case "e":
-          setLine(end);
-          return;
-        case "k":
-          setLine(killToEnd);
-          return;
-        case "u":
-          setLine(killToStart);
-          return;
-        case "w":
-          setLine(killWordBack);
-          return;
-      }
-      return;
-    }
-    if (char && !key.meta) {
-      setLine((prev) => insert(prev, char));
-    }
-  });
-  const devBadge = state.devState === "running" ? ` \xB7 ${state.devUrl ?? "dev running"}` : state.devState === "starting" ? " \xB7 dev starting\u2026" : state.devState === "crashed" ? " \xB7 dev crashed" : "";
-  const totalsBadge = state.totals.turns > 0 ? ` \xB7 ${state.totals.turns} turn${state.totals.turns === 1 ? "" : "s"}${state.totals.costUsd > 0 ? ` \xB7 $${state.totals.costUsd.toFixed(2)}` : ""}` : "";
-  return /* @__PURE__ */ jsx3(ThemeProvider, { value: theme2, children: /* @__PURE__ */ jsx3(InkPictureProvider, { children: /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, children: [
-    /* @__PURE__ */ jsx3(Static, { items: state.items, children: (item) => /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(MessageLine, { message: item }) }, item.id) }),
-    state.liveText.length > 0 && /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(Markdown, { text: state.liveText }) }),
-    state.items.length === 0 && state.liveText.length === 0 && !state.running && /* @__PURE__ */ jsxs3(Box3, { 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(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(WorkingLine, { startedAt: state.runStartedAt }) }),
-    state.queue.map((queued, index) => /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs3(Text3, { color: theme2.dim, children: [
-      "\u22EF ",
-      index + 1,
-      ". ",
-      queued,
-      index === state.queue.length - 1 ? "   (/queue drop <n> removes)" : ""
-    ] }) }, index)),
-    line.text.startsWith("/") && !line.text.includes(" ") && /* @__PURE__ */ jsx3(Box3, { 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(Box3, { marginTop: state.running ? 0 : 1, children: /* @__PURE__ */ jsxs3(Text3, { children: [
-      /* @__PURE__ */ jsx3(Text3, { color: theme2.accent, children: "\u276F " }),
-      line.text.slice(0, line.cursor),
-      /* @__PURE__ */ jsx3(Text3, { inverse: true, children: line.text[line.cursor] ?? " " }),
-      line.text.slice(line.cursor + 1)
-    ] }) }),
-    /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs3(Text3, { color: theme2.dim, children: [
-      /* @__PURE__ */ jsxs3(
-        Text3,
-        {
-          color: state.mode === "yolo" ? theme2.error : state.mode === "plan" ? theme2.user : theme2.dim,
-          bold: state.mode !== "safe",
-          children: [
-            "[",
-            state.mode,
-            "]"
-          ]
-        }
-      ),
-      state.sandbox && /* @__PURE__ */ jsx3(Text3, { color: theme2.accent, bold: true, children: " [sandbox]" }),
-      " ",
-      state.engineId,
-      state.model ? ` \xB7 ${state.model}` : "",
-      " \xB7 ",
-      path4.basename(cwd),
-      devBadge,
-      totalsBadge,
-      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/tui.tsx
-import { jsx as jsx4 } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 function registerTui(program2) {
   program2.action(async () => {
     const cwd = process.cwd();
     const config = loadConfig(defaultPaths(cwd));
     const engineId = resolveEngineId(config);
     const model = resolveModel(config, engineId);
-    let theme2 = config.theme;
-    if (!theme2 && !process.env.NO_COLOR) {
+    let theme = config.theme;
+    if (!theme && !process.env.NO_COLOR) {
       const { detectBackground } = await import("./background-J7OQTYEC.js");
-      if (await detectBackground() === "light") theme2 = "light";
+      if (await detectBackground() === "light") theme = "light";
     }
     render(
-      /* @__PURE__ */ jsx4(
+      /* @__PURE__ */ jsx(
         App,
         {
           cwd,
@@ -2551,7 +712,7 @@ function registerTui(program2) {
           fixModel: config.fixModel,
           bell: config.bell,
           budgetUsd: config.budgetUsd,
-          initialTheme: theme2
+          initialTheme: theme
         }
       )
     );
@@ -2559,7 +720,7 @@ function registerTui(program2) {
 }
 
 // src/cli.tsx
-var VERSION = true ? "0.4.5" : "0.0.0-dev";
+var VERSION = true ? "0.4.7" : "0.0.0-dev";
 var program = new Command();
 program.name("squint").description("Lovable for your terminal \u2014 a frontend harness on top of Claude Code, Codex, and friends.").version(VERSION);
 registerRun(program);
@@ -2568,5 +729,6 @@ registerScaffold(program);
 registerProject(program);
 registerQuality(program);
 registerConfig(program);
+registerDaemon(program);
 registerTui(program);
 program.parseAsync(process.argv);