@aayambansal/squint 0.4.6 → 0.4.8

package/dist/chunk-YGPVP4YB.js

@@ -0,0 +1,1428 @@
+#!/usr/bin/env node
+import {
+  appendDecision,
+  enrich
+} from "./chunk-ARDV4XH6.js";
+import {
+  applySandbox,
+  discardSandbox,
+  openSandbox,
+  sandboxDiffStat,
+  sandboxDir,
+  sandboxExists,
+  sandboxFiles
+} from "./chunk-AUJJGMZG.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 {
+  runAgent
+} from "./chunk-VH7OOFQP.js";
+import {
+  composePrompt
+} from "./chunk-WAJXATCO.js";
+import {
+  buildGatePrompt,
+  detectFastGates,
+  detectGates,
+  runGates
+} from "./chunk-62JNF5M2.js";
+import {
+  buildReviewPrompt,
+  buildRuntimeFixPrompt,
+  captureViewports,
+  comparePulseAttributed,
+  probeRuntime,
+  runtimeSummary
+} from "./chunk-7RFQWOQV.js";
+import {
+  clearState,
+  loadState,
+  saveState
+} from "./chunk-7CAGWFAQ.js";
+import {
+  findChrome
+} from "./chunk-IMDRXXFU.js";
+import {
+  getEngine
+} from "./chunk-KVYGPLWW.js";
+
+// src/session/engine.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/session/hooks.ts
+import { spawn } from "child_process";
+import fs from "fs";
+import path from "path";
+function runHook(cwd, event, payload) {
+  const script = path.join(cwd, ".squint", "hooks", event);
+  try {
+    fs.accessSync(script, fs.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, result.webmcp, result.jank),
+        `\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 = path2.join(this.opts.cwd, ".squint", "approval-request.json");
+        if (fs2.existsSync(reqPath)) {
+          const req = JSON.parse(fs2.readFileSync(reqPath, "utf8"));
+          fs2.rmSync(reqPath, { force: true });
+          if (typeof req?.summary === "string" && req.summary.length > 0) {
+            this.pendingApproval = req.summary;
+            const shot = typeof req.screenshot === "string" ? path2.resolve(this.execCwd(), req.screenshot) : null;
+            if (shot && fs2.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 { scanEvasion, sentinelSummary } = await import("./sentinel-42NZRTTS.js");
+          const evasions = scanEvasion(this.execCwd(), checkpoint.snapshot.stashHash ?? "HEAD");
+          if (evasions.length > 0) {
+            this.push("error", `\u26A0 sentinel: ${evasions.length} gate-evasion pattern(s) this turn
+${sentinelSummary(evasions)}
+Review before trusting green \u2014 /undo rolls the turn back.`);
+            runHook(this.opts.cwd, "on-sentinel", { count: String(evasions.length), summary: sentinelSummary(evasions) });
+          }
+        } 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);
+          if (probe?.checkFailures && probe.checkFailures.length > 0) {
+            this.addProblem(
+              "check",
+              `${probe.checkFailures.length} persistent check failure(s)`,
+              `Repo checks in .squint/checks/ failed against the live page. Each line is <check>: <failure>:
+
+${probe.checkFailures.join("\n")}
+
+Fix the page (or, only if the assertion itself is genuinely outdated, update that check file and say so).`
+            );
+            this.push("error", `checks: ${probe.checkFailures.length} failure(s)
+${probe.checkFailures.slice(0, 5).join("\n")}`);
+          } else {
+            this.clearProblems("check");
+          }
+          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, captureResult.webmcp, captureResult.jank),
+                  "\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 diff = await comparePulseAttributed(previous, current, this.state.devUrl ?? void 0);
+    if (diff === null) return null;
+    const pct = diff.pct;
+    this.push(
+      "status",
+      pct < 0.5 ? "visual pulse: stable vs last turn" : `visual pulse: ${pct.toFixed(1)}% of the page changed vs last turn${diff.sentences.length > 0 ? `
+${diff.sentences.map((s) => `  ${s}`).join("\n")}` : ""}`
+    );
+    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 ${path2.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 }) => {
+          const lines = detectEngines().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-A26C2ZDN.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 fs3 = await import("fs");
+              const path3 = await import("path");
+              const dir = path3.join(this.opts.cwd, ".squint", "transcripts");
+              const files = fs3.readdirSync(dir).filter((f) => f.endsWith(".md")).sort().reverse().slice(0, 20);
+              for (const file of files) {
+                if (matches.length >= 8) break;
+                const text = fs3.readFileSync(path3.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 fs3 = await import("fs");
+          const path3 = await import("path");
+          const dir = path3.join(this.opts.cwd, ".squint", "transcripts");
+          fs3.mkdirSync(dir, { recursive: true });
+          const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+          const file = path3.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()}`);
+          fs3.writeFileSync(file, lines.join("\n") + "\n");
+          this.push("status", `saved transcript \u2192 ${path3.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-2VVQOHWM.js");
+          const { previewDir } = await import("./preview-FBNVDQIV.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, result.webmcp, result.jank),
+              `\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`);
+    }
+  }
+};
+
+export {
+  Session
+};