@codacy/verity-cli 0.31.1-experimental.80cf3ac → 0.31.1-experimental.83a8619

package/bin/verity.js

@@ -10395,6 +10395,7 @@ var MAX_DELTA_BYTES = 194560;
 var MAX_FILES = 40;
 var MAX_FILE_BYTES = 51200;
 var DEBOUNCE_SECONDS = 30;
+var MAX_ITERATIONS = 2;
 var MAX_SPEC_FILES = 6;
 var MAX_SPEC_FILE_BYTES = 512e3;
 var MAX_TOTAL_SPEC_BYTES = 512e3;
@@ -10519,13 +10520,20 @@ var ADVISORY_EPISODE_FILE = `${VERITY_DIR}/.advisory-episode`;
 var IGNORE_DECLARATION_FILE = `${VERITY_DIR}/.ignore-declaration`;
 
 // src/lib/output.ts
-var RED = "\x1B[0;31m";
-var YELLOW = "\x1B[1;33m";
-var GREEN = "\x1B[0;32m";
-var CYAN = "\x1B[0;36m";
-var BOLD = "\x1B[1m";
-var DIM = "\x1B[2m";
-var NC = "\x1B[0m";
+function colorEnabled() {
+  if (process.env.FORCE_COLOR) return true;
+  if (process.env.NO_COLOR !== void 0) return false;
+  if (process.env.TERM === "dumb") return false;
+  return !!process.stderr.isTTY;
+}
+var COLOR = colorEnabled();
+var RED = COLOR ? "\x1B[0;31m" : "";
+var YELLOW = COLOR ? "\x1B[1;33m" : "";
+var GREEN = COLOR ? "\x1B[0;32m" : "";
+var CYAN = COLOR ? "\x1B[0;36m" : "";
+var BOLD = COLOR ? "\x1B[1m" : "";
+var DIM = COLOR ? "\x1B[2m" : "";
+var NC = COLOR ? "\x1B[0m" : "";
 function printJson(data) {
   process.stdout.write(JSON.stringify(data, null, 2) + "\n");
 }
@@ -11252,7 +11260,7 @@ async function resolveServiceUrlDetailed(flagUrl, opts = {}) {
   }
   return {
     ok: false,
-    error: 'No Verity service URL found. Run "verity login" to get started, or /verity-setup to configure this project.'
+    error: 'No Verity service URL found. Run "verity login" to get started, or "verity init" to set up this project.'
   };
 }
 async function resolveServiceUrlForAuth(flagUrl) {
@@ -11299,7 +11307,7 @@ async function resolveToken(flagToken) {
   }
   return {
     ok: false,
-    error: 'No Verity token found. Run "verity login" to sign in, or /verity-setup to set up this project.'
+    error: 'No Verity token found. Run "verity login" to sign in, or "verity init" to set up this project.'
   };
 }
 async function whoami(token, serviceUrl, verbose) {
@@ -11393,6 +11401,91 @@ async function maybeHealServiceUrl(resolution, verbose) {
 var readline = __toESM(require("node:readline/promises"));
 var import_node_os = require("node:os");
 
+// src/lib/spinner.ts
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var FRAME_MS = 80;
+var DIM2 = "\x1B[2m";
+var GREEN2 = "\x1B[0;32m";
+var YELLOW2 = "\x1B[1;33m";
+var RESET = "\x1B[0m";
+function secondsSince(start) {
+  return `${Math.round((Date.now() - start) / 1e3)}s`;
+}
+function startSpinner(label2, opts = {}) {
+  const stream = process.stderr;
+  const color = colorEnabled();
+  const animate = opts.animate ?? !!stream.isTTY;
+  const showElapsed = opts.elapsed ?? true;
+  const start = Date.now();
+  let current = label2;
+  let frame = 0;
+  let timer = null;
+  let done = false;
+  const fit = (label3, clock, columns) => {
+    const budget = columns - 5;
+    if (budget <= 0) return { label: "", clock: "" };
+    if (label3.length + clock.length <= budget) return { label: label3, clock };
+    if (clock.length >= budget) return { label: "", clock: clock.slice(0, budget) };
+    const room = budget - clock.length;
+    return { label: room <= 1 ? label3.slice(0, room) : `${label3.slice(0, room - 1)}\u2026`, clock };
+  };
+  const paint = () => {
+    const glyph = FRAMES[frame++ % FRAMES.length];
+    const columns = stream.columns ?? 80;
+    const { label: label3, clock } = fit(current, showElapsed ? ` ${secondsSince(start)}` : "", columns);
+    const line = color ? `  ${GREEN2}${glyph}${RESET} ${label3}${DIM2}${clock}${RESET}` : `  ${glyph} ${label3}${clock}`;
+    stream.write(`\r\x1B[2K${line}`);
+  };
+  const clearLine = () => {
+    if (animate) stream.write("\r\x1B[2K");
+  };
+  if (animate) {
+    paint();
+    timer = setInterval(paint, FRAME_MS);
+    timer.unref?.();
+  } else {
+    stream.write(`  ${current}\u2026
+`);
+  }
+  const finish = (render2) => {
+    if (done) return;
+    done = true;
+    if (timer) clearInterval(timer);
+    clearLine();
+    render2();
+  };
+  return {
+    update(next) {
+      current = next;
+      if (animate) paint();
+      else stream.write(`  ${next}\u2026
+`);
+    },
+    succeed(message) {
+      finish(() => {
+        const text = message ?? current;
+        const clock = showElapsed ? ` (${secondsSince(start)})` : "";
+        stream.write(
+          color ? `  ${GREEN2}\u2713${RESET} ${text}${DIM2}${clock}${RESET}
+` : `  \u2713 ${text}${clock}
+`
+        );
+      });
+    },
+    warn(message) {
+      finish(() => {
+        stream.write(color ? `  ${YELLOW2}\u26A0${RESET} ${message}
+` : `  \u26A0 ${message}
+`);
+      });
+    },
+    stop() {
+      finish(() => {
+      });
+    }
+  };
+}
+
 // src/lib/provider-auth.ts
 var sleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
 var form = (fields) => new URLSearchParams(fields).toString();
@@ -11459,42 +11552,49 @@ async function githubDeviceFlow() {
   printInfo("");
   printInfo(`To authorize Verity, open:  ${dc.verification_uri}`);
   printInfo(`And enter the code:         ${dc.user_code}`);
-  printInfo("Waiting for authorization\u2026");
+  const spinner = startSpinner(`Waiting for you to approve in the browser \xB7 code ${dc.user_code}`);
   const deadline = Date.now() + (dc.expires_in || 900) * 1e3;
   let interval = dc.interval || 5;
-  while (Date.now() < deadline) {
-    await sleep(interval * 1e3);
-    let data;
-    try {
-      const res = await fetch(GITHUB_ACCESS_TOKEN_URL, {
-        method: "POST",
-        headers: { Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded" },
-        body: form({
-          client_id: GITHUB_CLIENT_ID,
-          device_code: dc.device_code,
-          grant_type: "urn:ietf:params:oauth:grant-type:device_code"
-        })
-      });
-      data = await res.json().catch(() => ({}));
-    } catch {
-      continue;
-    }
-    if (data.access_token) return { ok: true, data: data.access_token };
-    switch (data.error) {
-      case "authorization_pending":
-        break;
-      case "slow_down":
-        interval += 5;
-        break;
-      case "access_denied":
-        return { ok: false, error: "Authorization was denied on GitHub." };
-      case "expired_token":
-        return { ok: false, error: "The authorization code expired. Re-run register." };
-      default:
-        if (data.error) return { ok: false, error: `GitHub auth error: ${data.error}` };
+  try {
+    while (Date.now() < deadline) {
+      await sleep(interval * 1e3);
+      let data;
+      try {
+        const res = await fetch(GITHUB_ACCESS_TOKEN_URL, {
+          method: "POST",
+          headers: { Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded" },
+          body: form({
+            client_id: GITHUB_CLIENT_ID,
+            device_code: dc.device_code,
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+          })
+        });
+        data = await res.json().catch(() => ({}));
+      } catch {
+        continue;
+      }
+      if (data.access_token) {
+        spinner.succeed("Authorized on GitHub");
+        return { ok: true, data: data.access_token };
+      }
+      switch (data.error) {
+        case "authorization_pending":
+          break;
+        case "slow_down":
+          interval += 5;
+          break;
+        case "access_denied":
+          return { ok: false, error: "Authorization was denied on GitHub." };
+        case "expired_token":
+          return { ok: false, error: "The authorization code expired. Re-run register." };
+        default:
+          if (data.error) return { ok: false, error: `GitHub auth error: ${data.error}` };
+      }
     }
+    return { ok: false, error: "Timed out waiting for GitHub authorization." };
+  } finally {
+    spinner.stop();
   }
-  return { ok: false, error: "Timed out waiting for GitHub authorization." };
 }
 
 // src/lib/register.ts
@@ -12263,12 +12363,20 @@ var VERITY_STOP_RE = /(?:^|[\/\s"'])verity\s+analyze\b/;
 var VERITY_INTENT_RE = /(?:^|[\/\s"'])verity\s+intent\s+capture\b/;
 var VERITY_GUARD_RE = /(?:^|[\/\s"'])verity\s+guard\b/;
 var VERITY_BASELINE_RE = /(?:^|[\/\s"'])verity\s+baseline\s+capture\b/;
+var VERITY_COMPACT_RE = /(?:^|[\/\s"'])verity\s+compact\b/;
+var VERITY_SESSION_END_RE = /(?:^|[\/\s"'])verity\s+session\s+end\b/;
 function isVerityGuardHook(entry) {
   return VERITY_GUARD_RE.test(entry.command ?? "");
 }
 function isVerityBaselineHook(entry) {
   return VERITY_BASELINE_RE.test(entry.command ?? "");
 }
+function isVerityCompactHook(entry) {
+  return VERITY_COMPACT_RE.test(entry.command ?? "");
+}
+function isVeritySessionEndHook(entry) {
+  return VERITY_SESSION_END_RE.test(entry.command ?? "");
+}
 var LEGACY_STOP_RE = /(?:^|[\/\s"'])gate\s+analyze\b/;
 var LEGACY_INTENT_RE = /(?:^|[\/\s"'])gate\s+intent\s+capture\b/;
 function isVerityStopHook(entry) {
@@ -12280,7 +12388,7 @@ function isVerityIntentHook(entry) {
   return VERITY_INTENT_RE.test(c) || LEGACY_INTENT_RE.test(c) || c.includes(".verity/hooks/capture-intent.sh") || c.includes(".gate/hooks/capture-intent.sh");
 }
 function isVerityHook(entry) {
-  return isVerityStopHook(entry) || isVerityIntentHook(entry) || isVerityGuardHook(entry) || isVerityBaselineHook(entry);
+  return isVerityStopHook(entry) || isVerityIntentHook(entry) || isVerityGuardHook(entry) || isVerityBaselineHook(entry) || isVerityCompactHook(entry) || isVeritySessionEndHook(entry);
 }
 function isCurrentVerityStopHook(entry) {
   const c = entry.command ?? "";
@@ -12291,7 +12399,7 @@ function isCurrentVerityIntentHook(entry) {
   return VERITY_INTENT_RE.test(c) || c.includes(".verity/hooks/capture-intent.sh");
 }
 function isCurrentVerityHook(entry) {
-  return isCurrentVerityStopHook(entry) || isCurrentVerityIntentHook(entry) || isVerityGuardHook(entry) || isVerityBaselineHook(entry);
+  return isCurrentVerityStopHook(entry) || isCurrentVerityIntentHook(entry) || isVerityGuardHook(entry) || isVerityBaselineHook(entry) || isVerityCompactHook(entry) || isVeritySessionEndHook(entry);
 }
 function settingsHasLegacyHook(settings) {
   for (const groups of Object.values(settings.hooks ?? {})) {
@@ -12353,6 +12461,8 @@ async function checkAllVerityHooks() {
 async function checkExternalVerityHooks() {
   let stop = false;
   let intent = false;
+  let compact = false;
+  let sessionEnd = false;
   let guardOn = [];
   for (const f of [SETTINGS_LOCAL_FILE, globalSettingsFile()]) {
     let settings;
@@ -12364,9 +12474,11 @@ async function checkExternalVerityHooks() {
     const r = checkVerityHooks(settings);
     stop = stop || r.stop;
     intent = intent || r.intent;
+    compact = compact || r.compact;
+    sessionEnd = sessionEnd || r.sessionEnd;
     if (r.guardOn.length > guardOn.length) guardOn = r.guardOn;
   }
-  return { stop, intent, guardOn };
+  return { stop, intent, compact, sessionEnd, guardOn };
 }
 async function checkAllVerityHooksDetailed() {
   let stop = false;
@@ -12446,11 +12558,11 @@ function checkVerityHooks(settings) {
   }
   const compactGroups = hooks["PostCompact"] ?? [];
   const hasCompact = compactGroups.some(
-    (g) => g.hooks?.some((h) => h.command?.trim() === "verity compact")
+    (g) => g.hooks?.some((h) => isVerityCompactHook(h))
   );
   const endGroups = hooks["SessionEnd"] ?? [];
   const hasSessionEnd = endGroups.some(
-    (g) => g.hooks?.some((h) => h.command?.trim() === "verity session end")
+    (g) => g.hooks?.some((h) => isVeritySessionEndHook(h))
   );
   return {
     stop: hasStop,
@@ -12564,6 +12676,8 @@ function reconcileMomentHooks(settings, moments, externalPresent = {
   };
   if (!externalPresent.intent) push("UserPromptSubmit", { hooks: [VERITY_INTENT_HOOK] });
   push("SessionStart", { hooks: [VERITY_BASELINE_HOOK] });
+  if (!externalPresent.compact) push("PostCompact", { hooks: [VERITY_COMPACT_HOOK] });
+  if (!externalPresent.sessionEnd) push("SessionEnd", { hooks: [VERITY_SESSION_END_HOOK] });
   if (moments.includes("stop") && !externalPresent.stop) {
     push("Stop", { hooks: [VERITY_STOP_HOOK] });
   }
@@ -13540,6 +13654,74 @@ var LEGACY_MD_END = "<!-- gate-memory:end -->";
 var LEGACY_PRESERVE_START = "<!-- gate-memory:preserve -->";
 var LEGACY_PRESERVE_END = "<!-- /gate-memory:preserve -->";
 var CLAUDE_MD_PROSE = [
+  "## Project Memory",
+  "",
+  "This project has a knowledge graph maintained at `.verity/memory/`. Before starting",
+  "non-trivial work, scan `.verity/memory/index.md` for decisions, gotchas, and patterns",
+  "that may apply to the change you are about to make. Open specific node files via",
+  "the Read tool when the title or scope suggests relevance.",
+  "",
+  "The graph is auto-maintained by Verity. Files at `.verity/memory/_archive/` are",
+  "superseded \u2014 ignore them unless investigating history.",
+  "",
+  "## Quality gate: accepted risks",
+  "",
+  "When the Verity pre-commit/pre-push gate FAILs, fix the findings \u2014 that is the",
+  'default. Use `verity waive <pattern-id> --file <path> --reason "\u2026"` ONLY to relay',
+  "a risk a human has explicitly accepted: a named code-review finding, an ADR, or",
+  "the user saying so in this conversation. The --reason must cite that source.",
+  "",
+  "Never waive on your own judgment, to get past a block, or pre-emptively. A waive",
+  "binds to the file's current bytes and voids automatically when the file changes,",
+  "and every waive is recorded in the run ledger. For a pattern-level false positive",
+  "use `verity feedback finding <run-id> <pattern-id> false_positive` instead.",
+  "",
+  "## Post-task reflection",
+  "",
+  `When a task is complete (you've created a PR, the user says "done" or "ship it",`,
+  "or the work is clearly finished), **draft the reflection yourself first** \u2014 1\u20133",
+  "concrete things worth remembering (a decision, a gotcha, or a pattern), each",
+  "cited with the files / PR / commands / error-signatures it came from. Skip",
+  "entirely if nothing non-obvious happened.",
+  "",
+  "Then, depending on how the session is running:",
+  "",
+  "- **Interactive** (a person is at the keyboard): show your draft and ask one",
+  `  question before recording \u2014 "Here's my reflection draft for the project`,
+  "  memory: <draft>. Anything to confirm, correct, or add before I record it?",
+  `  (Say 'skip' to drop it.)" Record the final text (with their corrections) via`,
+  '  `verity reflect --user-input "<final reflection>" --kind <kind>`. If they say',
+  '  "skip", do not record.',
+  "- **Autonomous** (headless / CI / cron, or `VERITY_AUTONOMOUS=1`): record your",
+  '  draft directly, never blocking \u2014 `verity reflect --user-input "<your draft>"',
+  "  --kind <kind> --autonomous`.",
+  "",
+  "> Durable, hand-curated guidance goes in the preserve region below (it survives",
+  "> regeneration) or anywhere OUTSIDE these markers. Everything else between the",
+  "> markers is tool-owned and overwritten on each run.",
+  "",
+  "## Housekeeping Turns",
+  "",
+  "When a turn will be pure housekeeping \u2014 pulling, installing dependencies,",
+  "rebasing, a formatting sweep you are not authoring \u2014 declare it BEFORE doing it:",
+  "",
+  "```bash",
+  'verity ignore --turn --agent --reason "pulling latest before starting"',
+  "```",
+  "",
+  "This skips the review for that turn, which saves the turn Verity would",
+  "otherwise spend saying it had nothing to say. Use `--for 30m` instead of",
+  "`--turn` when a single piece of housekeeping spans several turns.",
+  "",
+  "**It is a claim about the turn, not a way to silence review.** The declaration",
+  "is checked against what the turn actually did: if anything is authored \u2014 by you,",
+  "by a subagent, or by a shell command that can write files \u2014 it voids, the review",
+  "runs anyway, and the broken declaration is reported. So declare housekeeping you",
+  "are about to do, never work you have already done, and never as a way to get past",
+  "a finding. Declarations are budgeted per session and every one is recorded with",
+  "its reason."
+].join("\n");
+var CLAUDE_MD_PROSE_PRE_REFLECT = [
   "## Project Memory",
   "",
   "This project has a knowledge graph maintained at `.verity/memory/`. Before starting",
@@ -13750,6 +13932,7 @@ function stripKnownProse(interior) {
   const trimmed = interior.replace(/^\n+/, "");
   for (const prose of [
     CLAUDE_MD_PROSE,
+    CLAUDE_MD_PROSE_PRE_REFLECT,
     CLAUDE_MD_PROSE_PRE_WAIVE,
     CLAUDE_MD_PROSE_PRE_IGNORE,
     CLAUDE_MD_PROSE_LEGACY
@@ -15795,33 +15978,6 @@ ${addedLines}`,
   }
   return { diffs, has_snapshots: true };
 }
-function ensureSnapshotGitignored() {
-  let content = "";
-  try {
-    content = (0, import_node_fs16.readFileSync)(".gitignore", "utf-8");
-  } catch {
-  }
-  let ignored = null;
-  try {
-    (0, import_node_child_process6.execSync)("git check-ignore -q -- .verity/.snapshot/__probe__", { stdio: "pipe" });
-    ignored = true;
-  } catch (err) {
-    ignored = err.status === 1 ? false : null;
-  }
-  if (ignored === true) return "covered";
-  if (ignored === null) {
-    const lines = content.split("\n").map((l) => l.trim());
-    const covering = [".verity/.snapshot/", ".verity/.snapshot", ".verity/", ".verity", ".verity/*"];
-    if (lines.some((l) => covering.includes(l))) return "covered";
-  }
-  try {
-    const block = "# Verity \u2014 snapshots of analyzed files (machine state, never commit)\n.verity/.snapshot/\n";
-    (0, import_node_fs16.writeFileSync)(".gitignore", content ? content + (content.endsWith("\n") ? "" : "\n") + "\n" + block : block);
-    return "added";
-  } catch {
-    return "failed";
-  }
-}
 function saveSnapshots(files) {
   const snapshotPaths = /* @__PURE__ */ new Set();
   for (const file of files) {
@@ -16743,19 +16899,19 @@ function loc(f) {
   if (!f.file) return "";
   return f.line != null ? `${f.file}:${f.line}` : f.file;
 }
-function formatRunDetail(run) {
+function formatRunDetail(run2) {
   const lines = [];
-  const q = run.assessment?.quality_score;
-  const s = run.assessment?.security_score;
+  const q = run2.assessment?.quality_score;
+  const s = run2.assessment?.security_score;
   const qStr = q != null ? `${q}` : "-";
   const sStr = s != null ? `${s}` : "-";
-  lines.push(`${run.run_id}   ${run.gate_decision}   Q ${qStr}/10  S ${sStr}/10`);
+  lines.push(`${run2.run_id}   ${run2.gate_decision}   Q ${qStr}/10  S ${sStr}/10`);
   const meta = [];
-  if (run.trigger) meta.push(`trigger: ${run.trigger}`);
-  if (run.standard_version != null) meta.push(`standard v${run.standard_version}`);
-  if (run.created_at) meta.push(run.created_at.slice(0, 19).replace("T", " "));
+  if (run2.trigger) meta.push(`trigger: ${run2.trigger}`);
+  if (run2.standard_version != null) meta.push(`standard v${run2.standard_version}`);
+  if (run2.created_at) meta.push(run2.created_at.slice(0, 19).replace("T", " "));
   if (meta.length > 0) lines.push(meta.join(" \xB7 "));
-  const findings = run.findings ?? [];
+  const findings = run2.findings ?? [];
   if (findings.length === 0) {
     lines.push("");
     lines.push("No findings \u2014 clean.");
@@ -16772,7 +16928,7 @@ function formatRunDetail(run) {
       if (f.scope === "pre-existing") lines.push("      (pre-existing)");
     }
   }
-  const pending = run.pending_items ?? [];
+  const pending = run2.pending_items ?? [];
   if (pending.length > 0) {
     lines.push("");
     lines.push(`PENDING (${pending.length})`);
@@ -16780,9 +16936,9 @@ function formatRunDetail(run) {
       lines.push(`  [${(p.priority ?? "").toUpperCase()}] ${p.description}`);
     }
   }
-  if (run.assessment?.narrative) {
+  if (run2.assessment?.narrative) {
     lines.push("");
-    lines.push(run.assessment.narrative);
+    lines.push(run2.assessment.narrative);
   }
   return lines;
 }
@@ -17154,7 +17310,7 @@ function registerStatusCommand(program2) {
       return;
     }
     if (mem?.configured === false) {
-      printInfo("Verity is not configured for this project. Run /verity-setup.");
+      printInfo('Verity is not configured for this project. Run "verity init".');
       return;
     }
     printInfo("=== Verity Status ===");
@@ -17186,7 +17342,7 @@ function registerStatusCommand(program2) {
     if (hookStatus.stop) moments.push("stop");
     if (hookStatus.guardOn.includes("commit")) moments.push("pre-commit");
     if (hookStatus.guardOn.includes("push")) moments.push("pre-push/PR");
-    printInfo(`Moments:     ${moments.length > 0 ? moments.join(", ") : "none (run /verity-setup)"}`);
+    printInfo(`Moments:     ${moments.length > 0 ? moments.join(", ") : 'none (run "verity init")'}`);
     if (!mem) return;
     if (mem.recent_runs) {
       const r = mem.recent_runs;
@@ -17272,12 +17428,12 @@ function registerStatusCommand(program2) {
         printInfo("");
         printInfo("--- Recent Runs ---");
         printInfo(`${"Run ID".padEnd(32)} ${"Decision".padEnd(10)}${"Q".padEnd(4)}${"S".padEnd(4)}${"Findings".padEnd(32)}Date`);
-        for (const run of runsResult.data.runs) {
-          const q = run.quality_score != null ? `${run.quality_score}` : "-";
-          const s = run.security_score != null ? `${run.security_score}` : "-";
-          const findings = formatFindingsSummary(run.findings_count);
-          const date = run.created_at.slice(0, 19).replace("T", " ");
-          printInfo(`${run.run_id.padEnd(32)} ${run.gate_decision.padEnd(10)}${q.padEnd(4)}${s.padEnd(4)}${findings.padEnd(32)}${date}`);
+        for (const run2 of runsResult.data.runs) {
+          const q = run2.quality_score != null ? `${run2.quality_score}` : "-";
+          const s = run2.security_score != null ? `${run2.security_score}` : "-";
+          const findings = formatFindingsSummary(run2.findings_count);
+          const date = run2.created_at.slice(0, 19).replace("T", " ");
+          printInfo(`${run2.run_id.padEnd(32)} ${run2.gate_decision.padEnd(10)}${q.padEnd(4)}${s.padEnd(4)}${findings.padEnd(32)}${date}`);
         }
       }
     }
@@ -17412,7 +17568,6 @@ function createRun(opts, globals) {
     token: "",
     modeDecision: null,
     sessionIdForMemory: "",
-    contextFilePaths: [],
     analysisMode: "standard",
     sessionAuthoredCode: false,
     staticResults: {
@@ -17422,6 +17577,7 @@ function createRun(opts, globals) {
     },
     codeDelta: { files: [], total_lines: 0, total_files: 0, excluded: [] },
     snapshotResult: { has_snapshots: false, diffs: [] },
+    repoContext: null,
     contentHash: null,
     iteration: 1,
     currentCommit: "",
@@ -17503,6 +17659,704 @@ function logToFileOnly(text) {
 `);
 }
 
+// src/lib/repo-context.ts
+var import_node_child_process7 = require("node:child_process");
+var import_node_os3 = require("node:os");
+function rgInvocations(env = process.env) {
+  const out = [{ cmd: "rg" }];
+  if (env.CLAUDE_CODE_EXECPATH) out.push({ cmd: env.CLAUDE_CODE_EXECPATH, argv0: "rg" });
+  out.push({ cmd: `${(0, import_node_os3.homedir)()}/.local/bin/claude`, argv0: "rg" });
+  return out;
+}
+var MAX_SYMBOLS = 12;
+var MAX_SITES = 24;
+var MAX_SITES_PER_FILE = 3;
+var MAX_HITS_PER_SYMBOL = 50;
+var MAX_TEST_SLOTS = 8;
+var SITE_TEXT_MAX = 160;
+var ENCLOSING_SCAN_LINES = 200;
+var RG_TIMEOUT_MS = 1500;
+var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var STOPLIST = /* @__PURE__ */ new Set([
+  // keyword-shaped captures
+  "if",
+  "for",
+  "while",
+  "switch",
+  "catch",
+  "return",
+  "function",
+  "class",
+  "const",
+  "let",
+  "var",
+  "new",
+  "else",
+  "try",
+  "finally",
+  "throw",
+  "await",
+  "async",
+  "yield",
+  "delete",
+  "typeof",
+  "instanceof",
+  "void",
+  "this",
+  "super",
+  "import",
+  "export",
+  "default",
+  "extends",
+  "implements",
+  "interface",
+  "enum",
+  "type",
+  "public",
+  "private",
+  "protected",
+  "static",
+  "get",
+  "set",
+  "constructor",
+  "def",
+  "elif",
+  "lambda",
+  "with",
+  "pass",
+  "self",
+  "cls",
+  "not",
+  "and",
+  "or",
+  "raise",
+  "except",
+  "func",
+  "defer",
+  "chan",
+  "select",
+  "range",
+  "module",
+  "struct",
+  "trait",
+  "impl",
+  "using",
+  "namespace",
+  // universal noise
+  "main",
+  "init",
+  "index",
+  "data",
+  "value",
+  "result",
+  "item",
+  "name",
+  "key",
+  "run",
+  "test",
+  "setup",
+  "update",
+  "create",
+  "handle",
+  "check",
+  "load",
+  "save",
+  "list",
+  "map",
+  "args",
+  "params",
+  "props",
+  "state",
+  "error",
+  "err",
+  "res",
+  "req",
+  "ctx",
+  "config",
+  "options",
+  "util",
+  "utils",
+  "helper",
+  "render",
+  "build",
+  "parse",
+  "format",
+  "apply",
+  "process",
+  "start",
+  "stop"
+]);
+var TS_RULES = [
+  /\b(?:function|class|interface|enum)\s+([A-Za-z_][A-Za-z0-9_]*)/,
+  /\btype\s+([A-Za-z_][A-Za-z0-9_]*)\s*=/,
+  // const foo = (…) => ·  const foo = x => ·  const foo = function.
+  // ⚠ REQUIRES the arrow or `function` ON THE LINE. The first version accepted
+  // any `= (` — and `const started = (rows?.[0] as Row)?.at` is a PARENTHESIZED
+  // CAST, not a function. Replayed over 12 real commits, that one shape put
+  // three local variables into the symbol set per commit. A multi-line arrow
+  // is the accepted false negative; a cast is not an accepted false positive.
+  /\b(?:const|let|var)\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?::[^=\n]+)?=\s*(?:async\s+)?(?:function\b|\([^)]*\)(?:\s*:[^=\n]+)?\s*=>|[A-Za-z_$][\w$]*\s*=>)/,
+  // method shape: name(…) {  — keyword captures die at the stoplist
+  /^\s*(?:(?:public|private|protected|static|readonly|async|override)\s+)*(?:\*\s*)?([A-Za-z_][A-Za-z0-9_]*)\s*\([^)]*\)\s*(?::[^{;\n]+)?\s*\{/
+];
+var PY_RULES = [
+  /^\s*(?:async\s+)?def\s+([A-Za-z_]\w*)/,
+  /^\s*class\s+([A-Za-z_]\w*)/
+];
+var GO_RULES = [
+  /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)/,
+  /^type\s+([A-Za-z_]\w*)/
+];
+var CLIKE_RULES = [
+  /\b(?:class|interface|enum|record|struct)\s+([A-Za-z_]\w*)/,
+  // access-modifier method shape: `public async Task<Foo> BarBaz(…`
+  /(?:public|private|protected|internal|static|final|virtual|override|sealed|abstract)[\w<>[\],?\s]*?\s([A-Za-z_]\w*)\s*\(/
+];
+var RB_RULES = [
+  /^\s*def\s+(?:self\.)?([A-Za-z_]\w*)/,
+  /^\s*(?:class|module)\s+([A-Z]\w*)/
+];
+var RS_RULES = [
+  /\bfn\s+([A-Za-z_]\w*)/,
+  /\b(?:struct|enum|trait)\s+([A-Za-z_]\w*)/
+];
+var PHP_RULES = [
+  /\bfunction\s+([A-Za-z_]\w*)/,
+  /\bclass\s+([A-Za-z_]\w*)/
+];
+var C_RULES = [
+  /^(?:static\s+|inline\s+|extern\s+|constexpr\s+)*(?:struct\s+|enum\s+|union\s+|unsigned\s+|const\s+)*[A-Za-z_]\w*(?:\s*[*&]+\s*|\s+)([A-Za-z_]\w*)\s*\([^;]*$/,
+  /\b(?:struct|enum|union|class)\s+([A-Za-z_]\w*)/,
+  /::\s*~?([A-Za-z_]\w*)\s*\([^;]*$/
+  // out-of-line C++ method definition
+];
+var SH_RULES = [
+  /^\s*(?:function\s+)?([A-Za-z_]\w*)\s*\(\)\s*\{/,
+  /^function\s+([A-Za-z_]\w*)/
+];
+var SQL_RULES = [
+  /\bcreate\s+(?:or\s+replace\s+)?(?:table|view|materialized\s+view|function|procedure|index|trigger|type|policy)\s+(?:if\s+not\s+exists\s+)?(?:[\w".]*\.)?"?([A-Za-z_]\w*)"?/i
+];
+var TF_RULES = [
+  /^\s*(?:resource|data)\s+"[^"]+"\s+"([A-Za-z_]\w*)"/,
+  /^\s*(?:module|variable|output)\s+"([A-Za-z_]\w*)"/
+];
+var SWIFT_RULES = [
+  /\bfunc\s+([A-Za-z_]\w*)/,
+  /\b(?:class|struct|enum|protocol|extension|actor)\s+([A-Za-z_]\w*)/
+];
+var DART_RULES = [
+  /\b(?:class|enum|mixin|extension)\s+([A-Za-z_]\w*)/,
+  /^\s*(?:static\s+)?(?:Future<[^>]*>|Stream<[^>]*>|void|int|double|bool|String|num|dynamic|[A-Z]\w*(?:<[^>]*>)?)\s+([a-z_]\w*)\s*\(/
+];
+var LUA_RULES = [
+  /^\s*(?:local\s+)?function\s+(?:[\w.]+[.:])?([A-Za-z_]\w*)/
+];
+var EX_RULES = [
+  /^\s*def(?:p|macro)?\s+([a-z_]\w*)/,
+  /^\s*defmodule\s+(?:[\w.]*\.)?([A-Z]\w*)/
+];
+var PROTO_RULES = [
+  /^\s*(?:message|service|enum)\s+([A-Za-z_]\w*)/,
+  /^\s*rpc\s+([A-Za-z_]\w*)/
+];
+var GRAPHQL_RULES = [
+  /^\s*(?:type|interface|enum|input|union|scalar)\s+([A-Za-z_]\w*)/
+];
+var RULES_BY_EXT = {
+  ts: TS_RULES,
+  tsx: TS_RULES,
+  js: TS_RULES,
+  jsx: TS_RULES,
+  mjs: TS_RULES,
+  cjs: TS_RULES,
+  svelte: TS_RULES,
+  vue: TS_RULES,
+  // script blocks
+  py: PY_RULES,
+  go: GO_RULES,
+  java: CLIKE_RULES,
+  cs: CLIKE_RULES,
+  kt: CLIKE_RULES,
+  scala: CLIKE_RULES,
+  rb: RB_RULES,
+  rs: RS_RULES,
+  php: PHP_RULES,
+  c: C_RULES,
+  cpp: C_RULES,
+  cc: C_RULES,
+  h: C_RULES,
+  hpp: C_RULES,
+  sh: SH_RULES,
+  bash: SH_RULES,
+  zsh: SH_RULES,
+  sql: SQL_RULES,
+  tf: TF_RULES,
+  hcl: TF_RULES,
+  swift: SWIFT_RULES,
+  dart: DART_RULES,
+  lua: LUA_RULES,
+  ex: EX_RULES,
+  exs: EX_RULES,
+  proto: PROTO_RULES,
+  graphql: GRAPHQL_RULES,
+  gql: GRAPHQL_RULES
+};
+var HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+function parseDiffSignals(diff) {
+  const addedRanges = [];
+  const touchPoints = [];
+  const deletedLines = [];
+  let newLine = 0;
+  let oldRemaining = 0;
+  let newRemaining = 0;
+  let runStart = -1;
+  let deletionRun = false;
+  const closeAddedRun = () => {
+    if (runStart >= 0) addedRanges.push([runStart, newLine - 1]);
+    runStart = -1;
+  };
+  const closeDeletionRun = () => {
+    if (deletionRun) touchPoints.push(Math.max(1, newLine));
+    deletionRun = false;
+  };
+  for (const line of diff.split("\n")) {
+    const inHunk = oldRemaining > 0 || newRemaining > 0;
+    if (!inHunk) {
+      closeAddedRun();
+      closeDeletionRun();
+      const header = HUNK_HEADER.exec(line);
+      if (header) {
+        newLine = parseInt(header[3], 10);
+        oldRemaining = header[2] === void 0 ? 1 : parseInt(header[2], 10);
+        newRemaining = header[4] === void 0 ? 1 : parseInt(header[4], 10);
+        if (newRemaining === 0) newLine = Math.max(1, newLine);
+      }
+      continue;
+    }
+    if (line.startsWith("\\")) continue;
+    if (line.startsWith("+") && newRemaining > 0) {
+      deletionRun = false;
+      if (runStart < 0) runStart = newLine;
+      newLine++;
+      newRemaining--;
+      continue;
+    }
+    if (line.startsWith("-") && oldRemaining > 0) {
+      closeAddedRun();
+      deletionRun = true;
+      deletedLines.push(line.slice(1));
+      oldRemaining--;
+      continue;
+    }
+    closeAddedRun();
+    closeDeletionRun();
+    newLine++;
+    if (oldRemaining > 0) oldRemaining--;
+    if (newRemaining > 0) newRemaining--;
+  }
+  closeAddedRun();
+  closeDeletionRun();
+  return { addedRanges, touchPoints, deletedLines };
+}
+function declNameOn(line, rules) {
+  for (const r of rules) {
+    const m = r.exec(line);
+    if (m?.[1]) return m[1];
+  }
+  return null;
+}
+function acceptable(name) {
+  if (!name || !IDENTIFIER.test(name) || STOPLIST.has(name.toLowerCase())) return false;
+  if (name.length < 3) return false;
+  if (name.length === 3 && name === name.toLowerCase() && !name.includes("_")) return false;
+  return true;
+}
+function isMultiSegment(name) {
+  return /[a-z][A-Z]/.test(name) || name.includes("_");
+}
+function extractFileSymbols(path, content, signals) {
+  const ext = path.split(".").pop()?.toLowerCase() ?? "";
+  const rules = RULES_BY_EXT[ext];
+  if (!rules) return [];
+  if (signals.addedRanges.length === 0 && signals.touchPoints.length === 0 && signals.deletedLines.length === 0) return [];
+  const lines = content.split("\n");
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (name) => {
+    if (acceptable(name) && !seen.has(name)) {
+      seen.add(name);
+      found.push(name);
+    }
+  };
+  for (const deleted of signals.deletedLines) {
+    add(declNameOn(deleted, rules));
+  }
+  for (const [start, end] of signals.addedRanges) {
+    for (let n = start; n <= Math.min(end, lines.length); n++) {
+      add(declNameOn(lines[n - 1] ?? "", rules));
+    }
+  }
+  const scanStarts = [
+    ...signals.addedRanges.map(([start]) => start),
+    ...signals.touchPoints
+  ];
+  for (const start of scanStarts) {
+    const floor = Math.max(1, start - ENCLOSING_SCAN_LINES);
+    for (let n = Math.min(start, lines.length); n >= floor; n--) {
+      const name = declNameOn(lines[n - 1] ?? "", rules);
+      if (acceptable(name)) {
+        add(name);
+        break;
+      }
+    }
+  }
+  return found;
+}
+function rankSymbols(symbols) {
+  return symbols.map((s, i) => ({ s, i })).sort((a, b) => {
+    const seg = Number(isMultiSegment(b.s)) - Number(isMultiSegment(a.s));
+    if (seg !== 0) return seg;
+    if (b.s.length !== a.s.length) return b.s.length - a.s.length;
+    return a.i - b.i;
+  }).slice(0, MAX_SYMBOLS).map((x) => x.s);
+}
+var TEST_PATH = /(^|\/)(tests?|specs?|__tests__|e2e)(\/|$)/i;
+var TEST_FILE = /(\.(test|spec|e2e)\.[^./]+|_test\.[^./]+|_spec\.rb)$/i;
+var TEST_PY_PREFIX = /(^|\/)test_[^/]+\.py$/i;
+var IMPORT_LINE = /^\s*(import\s|from\s+\S+\s+import\s|const\s+.*=\s*require\s*\(|require\s*\(|using\s+[\w.]+;|#include|export\s+\{[^}]*\}\s+from|export\s+\*\s+from)/;
+var BARE_MEMBER_LINE = /^(type\s+)?[A-Za-z_$][\w$]*\s*,?$/;
+var GO_IMPORT_PATH_LINE = /^"[^"]+",?$/;
+var SITE_CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "py",
+  "go",
+  "java",
+  "kt",
+  "rb",
+  "rs",
+  "scala",
+  "c",
+  "cpp",
+  "cc",
+  "h",
+  "hpp",
+  "cs",
+  "php",
+  "swift",
+  "dart",
+  "lua",
+  "sh",
+  "bash",
+  "zsh",
+  "svelte",
+  "vue",
+  "ex",
+  "exs",
+  // sql/tf carry REAL call sites (SELECT my_function(...), module.name) —
+  // excluded in an earlier round because of migration-comment noise, which the
+  // COMMENT_LINE filter now handles on its own.
+  "sql",
+  "tf",
+  "hcl"
+]);
+var COMMENT_LINE = /^(\/\/|#(?!\[)|\*|\/\*|--\s|<!--)/;
+function isCodeSiteFile(path) {
+  const ext = path.split(".").pop()?.toLowerCase() ?? "";
+  return SITE_CODE_EXTENSIONS.has(ext);
+}
+function isTestPath(path) {
+  return TEST_PATH.test(path) || TEST_FILE.test(path) || TEST_PY_PREFIX.test(path);
+}
+function parseRgLine(line) {
+  const first = line.indexOf(":");
+  if (first <= 0) return null;
+  const second = line.indexOf(":", first + 1);
+  if (second < 0) return null;
+  const n = parseInt(line.slice(first + 1, second), 10);
+  if (!Number.isFinite(n) || n < 1) return null;
+  return { file: line.slice(0, first), line: n, text: line.slice(second + 1) };
+}
+var isWordChar = (c) => c !== void 0 && /[A-Za-z0-9_]/.test(c);
+function wordHit(text, symbol) {
+  let from = 0;
+  for (; ; ) {
+    const at = text.indexOf(symbol, from);
+    if (at < 0) return false;
+    const before = at === 0 ? void 0 : text[at - 1];
+    const after = text[at + symbol.length];
+    if (!isWordChar(before) && !isWordChar(after)) return true;
+    from = at + 1;
+  }
+}
+function isContractLine(text, symbol) {
+  for (const kw of ["implements", "extends"]) {
+    let from = 0;
+    for (; ; ) {
+      const at = text.indexOf(kw, from);
+      if (at < 0) break;
+      from = at + 1;
+      const before = at === 0 ? void 0 : text[at - 1];
+      const after = text[at + kw.length];
+      if (isWordChar(before) || isWordChar(after)) continue;
+      let clause = text.slice(at + kw.length);
+      const stop = Math.min(
+        ...[clause.indexOf(";"), clause.indexOf("{")].filter((i) => i >= 0)
+      );
+      if (Number.isFinite(stop)) clause = clause.slice(0, stop);
+      if (wordHit(clause, symbol)) return true;
+    }
+  }
+  return false;
+}
+function partitionSites(rgLines, symbols, opts) {
+  const hits = [];
+  const hitCount = /* @__PURE__ */ new Map();
+  for (const line of rgLines) {
+    const hit = parseRgLine(line);
+    if (!hit) continue;
+    const matched = symbols.filter((s) => wordHit(hit.text, s));
+    for (const s of matched) hitCount.set(s, (hitCount.get(s) ?? 0) + 1);
+    if (matched.length === 0) continue;
+    hits.push({ ...hit, symbol: matched[0] });
+  }
+  hits.sort((a, b) => a.file < b.file ? -1 : a.file > b.file ? 1 : a.line - b.line);
+  const dropped = symbols.filter((s) => (hitCount.get(s) ?? 0) > MAX_HITS_PER_SYMBOL);
+  const droppedSet = new Set(dropped);
+  const perFile = /* @__PURE__ */ new Map();
+  const callers = [];
+  const tests = [];
+  for (const h of hits) {
+    if (droppedSet.has(h.symbol)) continue;
+    if (opts.sentPaths.has(h.file)) continue;
+    if (opts.isExcluded(h.file)) continue;
+    if (!isCodeSiteFile(h.file)) continue;
+    const text = h.text.trim();
+    if (text.length === 0 || IMPORT_LINE.test(h.text)) continue;
+    if (COMMENT_LINE.test(text)) continue;
+    if (BARE_MEMBER_LINE.test(text) || GO_IMPORT_PATH_LINE.test(text)) continue;
+    const n = perFile.get(h.file) ?? 0;
+    if (n >= MAX_SITES_PER_FILE) continue;
+    const site = {
+      file: h.file,
+      line: h.line,
+      text: text.slice(0, SITE_TEXT_MAX),
+      symbol: h.symbol,
+      // R2 falls out of R1 for free: a word search for `Sym` already matches
+      // `implements Sym` / `extends Sym` lines — classification is all R2 is.
+      ...isContractLine(text, h.symbol) ? { kind: "contract" } : {}
+    };
+    if (isTestPath(h.file)) {
+      if (tests.length < MAX_TEST_SLOTS) {
+        tests.push(site);
+        perFile.set(h.file, n + 1);
+      }
+    } else if (callers.length + tests.length < MAX_SITES) {
+      callers.push(site);
+      perFile.set(h.file, n + 1);
+    }
+  }
+  while (callers.length + tests.length > MAX_SITES) callers.pop();
+  return { callers, tests, dropped };
+}
+function buildRepoContext(input) {
+  const started = Date.now();
+  let signalsByPath;
+  if (input.signalsByPath) {
+    if (input.signalsByPath.size === 0) return { state: "absent", reason: "no-diffs" };
+    signalsByPath = input.signalsByPath;
+  } else {
+    if (input.diffs.length === 0) return { state: "absent", reason: "no-diffs" };
+    signalsByPath = /* @__PURE__ */ new Map();
+    for (const d of input.diffs) signalsByPath.set(d.path, parseDiffSignals(d.diff));
+  }
+  const collected = [];
+  const unsupported = /* @__PURE__ */ new Set();
+  const noteUnsupported = (path) => {
+    const ext = path.split(".").pop()?.toLowerCase() ?? "";
+    if (ext && !RULES_BY_EXT[ext]) unsupported.add(ext);
+  };
+  const deltaPathSet = new Set(input.deltaFiles.map((f) => f.path));
+  for (const f of input.deltaFiles) {
+    const signals = signalsByPath.get(f.path);
+    if (!signals) continue;
+    noteUnsupported(f.path);
+    collected.push(...extractFileSymbols(f.path, f.content, signals));
+  }
+  for (const [path, signals] of signalsByPath) {
+    if (deltaPathSet.has(path)) continue;
+    if (signals.deletedLines.length > 0) {
+      noteUnsupported(path);
+      collected.push(...extractFileSymbols(path, "", signals));
+    }
+  }
+  const unsupportedExts = [...unsupported].sort().slice(0, 8);
+  const audit = unsupportedExts.length > 0 ? { unsupported_exts: unsupportedExts } : {};
+  const symbols = rankSymbols([...new Set(collected)]);
+  if (symbols.length === 0) {
+    const everySupportedFileFoundNothing = unsupportedExts.length > 0;
+    return {
+      state: "absent",
+      reason: everySupportedFileFoundNothing ? "unsupported-language" : "no-symbols",
+      ...audit
+    };
+  }
+  const args = [
+    "-n",
+    "-w",
+    "-F",
+    "--no-heading",
+    "--color",
+    "never",
+    // ⚠ NO `--sort path` — it single-threads rg, and on a large worktree that
+    // is the difference between 17ms and a timeout. Determinism is restored by
+    // sorting the hits in partitionSites instead.
+    //
+    // `-m 8` bounds output PER FILE (shared across all patterns), so a noisy
+    // repo cannot blow the 4MB read buffer and turn the whole feature into
+    // `absent/error`. Cost, accepted: the frequency gate sees per-file-capped
+    // counts, so a symbol concentrated in a handful of files can slip a gate
+    // a full count would have tripped — but the ≤3-sites-per-file cap already
+    // bounds exactly that shape's damage; the gate exists for the many-file
+    // 'init' shape, which 8-per-file still trips (>6 files ⇒ >50).
+    "-m",
+    "8",
+    "--max-columns",
+    "300",
+    "--max-columns-preview",
+    ...symbols.flatMap((s) => ["-e", s]),
+    "-g",
+    "!**/{dist,build,out,vendor,node_modules,.git,coverage,target,__pycache__}/**",
+    "./"
+  ];
+  let res = null;
+  for (const inv of rgInvocations()) {
+    res = (0, import_node_child_process7.spawnSync)(inv.cmd, args, {
+      ...inv.argv0 ? { argv0: inv.argv0 } : {},
+      cwd: input.cwd ?? process.cwd(),
+      timeout: input.timeoutMs ?? RG_TIMEOUT_MS,
+      maxBuffer: 4 * 1024 * 1024,
+      encoding: "utf8"
+    });
+    if (res.error?.code !== "ENOENT") break;
+  }
+  if (!res || res.error?.code === "ENOENT") {
+    return { state: "absent", reason: "no-tool", symbols, ...audit };
+  }
+  if (res.error) {
+    const code = res.error.code;
+    if (code === "ETIMEDOUT") return { state: "absent", reason: "timeout", symbols, ...audit };
+    return { state: "absent", reason: "error", symbols, ...audit };
+  }
+  if (res.signal) return { state: "absent", reason: "timeout", symbols, ...audit };
+  if (res.status !== 0 && res.status !== 1) return { state: "absent", reason: "error", symbols, ...audit };
+  const lines = (res.stdout ?? "").split("\n").map((l) => l.replace(/^\.\//, "")).filter(Boolean);
+  const { callers, tests, dropped } = partitionSites(lines, symbols, {
+    sentPaths: input.sentPaths,
+    isExcluded: input.isExcluded
+  });
+  if (callers.length === 0 && tests.length === 0) {
+    return {
+      state: "absent",
+      reason: "no-sites",
+      symbols,
+      ...dropped.length > 0 ? { dropped_symbols: dropped } : {},
+      ...audit,
+      elapsed_ms: Date.now() - started
+    };
+  }
+  return {
+    state: "ok",
+    symbols,
+    ...dropped.length > 0 ? { dropped_symbols: dropped } : {},
+    ...audit,
+    callers,
+    tests,
+    elapsed_ms: Date.now() - started
+  };
+}
+var MAX_EXCERPTS = 12;
+var MAX_EXCERPTS_PER_FILE = 2;
+var EXCERPT_MAX_LINES = 30;
+var EXCERPT_MAX_CHARS = 2400;
+var EXCERPT_TOTAL_BYTES = 24576;
+var EXCERPT_DECL_SCAN = 40;
+function extractEnclosingExcerpt(content, siteLine, path) {
+  const ext = path.split(".").pop()?.toLowerCase() ?? "";
+  const rules = RULES_BY_EXT[ext] ?? [];
+  const lines = content.split("\n");
+  if (siteLine < 1 || siteLine > lines.length) return null;
+  let declStart = null;
+  const floor = Math.max(1, siteLine - EXCERPT_DECL_SCAN);
+  for (let n = siteLine; n >= floor; n--) {
+    if (declNameOn(lines[n - 1] ?? "", rules) !== null) {
+      declStart = n;
+      break;
+    }
+  }
+  let start;
+  if (declStart !== null && siteLine - declStart < EXCERPT_MAX_LINES) {
+    start = declStart;
+  } else {
+    start = Math.max(1, siteLine - (EXCERPT_MAX_LINES - 6));
+  }
+  const end = Math.min(lines.length, start + EXCERPT_MAX_LINES - 1);
+  const text = lines.slice(start - 1, end).join("\n").slice(0, EXCERPT_MAX_CHARS);
+  return { start_line: start, text };
+}
+function upgradeToExcerpts(rc, opts) {
+  if (rc.state !== "ok") return;
+  const ranked = [
+    ...(rc.callers ?? []).filter((s) => s.kind === "contract"),
+    ...rc.tests ?? [],
+    ...(rc.callers ?? []).filter((s) => s.kind !== "contract")
+  ];
+  const perFile = /* @__PURE__ */ new Map();
+  const contentCache = /* @__PURE__ */ new Map();
+  const excerpts = [];
+  let totalBytes = 0;
+  for (const site of ranked) {
+    if (excerpts.length >= MAX_EXCERPTS) break;
+    const used = perFile.get(site.file) ?? 0;
+    if (used >= MAX_EXCERPTS_PER_FILE) continue;
+    if (!contentCache.has(site.file)) contentCache.set(site.file, opts.readFile(site.file));
+    const content = contentCache.get(site.file);
+    if (content === null || content === void 0) continue;
+    const ex = extractEnclosingExcerpt(content, site.line, site.file);
+    if (!ex) continue;
+    if (totalBytes + ex.text.length > EXCERPT_TOTAL_BYTES) break;
+    excerpts.push({
+      file: site.file,
+      start_line: ex.start_line,
+      symbol: site.symbol,
+      kind: site.kind === "contract" ? "contract" : isTestPath(site.file) ? "test" : "caller",
+      text: ex.text
+    });
+    totalBytes += ex.text.length;
+    perFile.set(site.file, used + 1);
+  }
+  if (excerpts.length > 0) rc.excerpts = excerpts;
+}
+function describeRepoContext(rc) {
+  if (rc.state !== "ok") {
+    const exts = rc.unsupported_exts?.length ? ` \xB7 no rules for: ${rc.unsupported_exts.join(", ")}` : "";
+    return `absent (${rc.reason ?? "unknown"})${exts}`;
+  }
+  const parts = [
+    `${rc.symbols?.length ?? 0} symbol(s) \u2192 ${rc.callers?.length ?? 0} caller(s) \xB7 ${rc.tests?.length ?? 0} test(s)`
+  ];
+  if (rc.excerpts?.length) parts.push(`${rc.excerpts.length} excerpt(s)`);
+  if (rc.dropped_symbols?.length) parts.push(`dropped too-common: ${rc.dropped_symbols.join(", ")}`);
+  if (rc.unsupported_exts?.length) parts.push(`no rules for: ${rc.unsupported_exts.join(", ")}`);
+  if (typeof rc.elapsed_ms === "number") parts.push(`${rc.elapsed_ms}ms`);
+  return parts.join(" \xB7 ");
+}
+
 // src/commands/analyze/evidence-log.ts
 function list(paths, cap = 12) {
   if (paths.length === 0) return "(none)";
@@ -17513,35 +18367,36 @@ function row(label2, value) {
   return `   \u25B8 ${label2.padEnd(10)} ${value}
 `;
 }
-function formatRunEvidence(run, startedAt) {
+function formatRunEvidence(run2, startedAt) {
   const ms = Date.now() - startedAt;
-  const sent = run.codeDelta.files.filter((f) => f.role !== "context").map((f) => f.path);
-  const context = run.codeDelta.files.filter((f) => f.role === "context").map((f) => f.path);
+  const sent = run2.codeDelta.files.filter((f) => f.role !== "context").map((f) => f.path);
+  const context = run2.codeDelta.files.filter((f) => f.role === "context").map((f) => f.path);
   let out = `   \u2500\u2500 what verity saw \u2500\u2500
 `;
-  out += row("turn", `${run.turnId || "(unminted)"}${run.sessionId ? ` \xB7 session ${run.sessionId}` : ""}`);
-  out += row("reached", `${run.phaseReached || "(none)"}${run.skipReason ? ` \xB7 SKIPPED: ${run.skipReason}` : ""} \xB7 ${ms}ms`);
-  if (run.treeFrame) {
-    const f = run.treeFrame;
+  out += row("turn", `${run2.turnId || "(unminted)"}${run2.sessionId ? ` \xB7 session ${run2.sessionId}` : ""}`);
+  out += row("reached", `${run2.phaseReached || "(none)"}${run2.skipReason ? ` \xB7 SKIPPED: ${run2.skipReason}` : ""} \xB7 ${ms}ms`);
+  if (run2.treeFrame) {
+    const f = run2.treeFrame;
     out += row("tree", f.worktreeRoot ? `${f.worktreeRoot}${f.isLinkedWorktree ? " \xB7 linked worktree" : ""}${f.branch ? ` \xB7 branch ${f.branch}` : " \xB7 detached"}` : `(unresolved: ${f.refusal ?? "unknown"})`);
   }
-  out += row("changed", `${run.changedUniverse.length} from git \xB7 analyzable ${run.analyzable.length} \xB7 reviewable ${run.reviewable.length} \xB7 security ${run.securityFiles.length} \xB7 forReview ${run.allForReview.length}`);
-  const done = (phase) => run.phasesCompleted.includes(phase);
+  out += row("changed", `${run2.changedUniverse.length} from git \xB7 analyzable ${run2.analyzable.length} \xB7 reviewable ${run2.reviewable.length} \xB7 security ${run2.securityFiles.length} \xB7 forReview ${run2.allForReview.length}`);
+  const done = (phase) => run2.phasesCompleted.includes(phase);
   const ifDone = (phase, value) => done(phase) ? value : "?";
-  const md = run.modeDecision;
+  const md = run2.modeDecision;
   if (md) {
     const how = md.forced ? "forced by --mode" : `predicted=${md.predicted ?? "none"} \u2192 ${md.resolved}`;
     out += row("mode", `${md.resolved} \xB7 ${how}` + (md.flip ? ` (flipped to plan: no delta at ${md.flip})` : "") + ` \xB7 authored=${md.authored ? "yes" : "no"} \xB7 investigated=${md.investigated ? "yes" : "no"}`);
   } else {
-    out += row("mode", `? (this run stopped in ${run.phaseReached || "no phase"}, before the mode was decided)`);
+    out += row("mode", `? (this run stopped in ${run2.phaseReached || "no phase"}, before the mode was decided)`);
   }
-  out += row("signals", `baseline=${ifDone("bootstrap", run.baseline ? "yes" : "no")} \xB7 authored=${ifDone("intentInputs", run.turnAuthoredCode ? "yes" : "no")} \xB7 observable=${ifDone("intentInputs", run.authorshipIsObservable ? "yes" : "no")}` + (run.actionSummary?.transcript_windowed ? ` \xB7 window=${run.actionSummary.transcript_windowed}` : ""));
+  out += row("signals", `baseline=${ifDone("bootstrap", run2.baseline ? "yes" : "no")} \xB7 authored=${ifDone("intentInputs", run2.turnAuthoredCode ? "yes" : "no")} \xB7 observable=${ifDone("intentInputs", run2.authorshipIsObservable ? "yes" : "no")}` + (run2.actionSummary?.transcript_windowed ? ` \xB7 window=${run2.actionSummary.transcript_windowed}` : ""));
   if (!done("intentInputs")) {
-    out += row("", `(\`?\` = the phase that determines it did not complete \u2014 this run stopped in ${run.phaseReached})`);
+    out += row("", `(\`?\` = the phase that determines it did not complete \u2014 this run stopped in ${run2.phaseReached})`);
   }
   out += row("sent", `${sent.length} \xB7 ${list(sent)}`);
   if (context.length > 0) out += row("context", `${context.length} \xB7 ${list(context)}`);
-  const withheld = run.reviewCoverage.notReviewed;
+  if (run2.repoContext) out += row("repo", describeRepoContext(run2.repoContext));
+  const withheld = run2.reviewCoverage.notReviewed;
   if (withheld.length > 0) {
     const byReason = /* @__PURE__ */ new Map();
     for (const w of withheld) {
@@ -17554,18 +18409,18 @@ function formatRunEvidence(run, startedAt) {
       first = false;
     }
   } else {
-    const sentSet = new Set(run.codeDelta.files.map((f) => f.path));
-    const notSent = run.changedUniverse.filter((p) => !sentSet.has(p));
+    const sentSet = new Set(run2.codeDelta.files.map((f) => f.path));
+    const notSent = run2.changedUniverse.filter((p) => !sentSet.has(p));
     if (notSent.length > 0) {
       out += row("not sent", `${list(notSent)}`);
-      out += row("", `(stage unknown \u2014 the coverage ledger is built in phase 13, and this run reached ${run.phaseReached || "no phase"})`);
-    } else if (run.changedUniverse.length > 0) {
+      out += row("", `(stage unknown \u2014 the coverage ledger is built in phase 13, and this run reached ${run2.phaseReached || "no phase"})`);
+    } else if (run2.changedUniverse.length > 0) {
       out += row("withheld", "(nothing \u2014 every changed file was reviewed)");
     }
   }
-  const cov = run.foldResult?.coverage;
+  const cov = run2.foldResult?.coverage;
   if (cov) {
-    const delegated = run.foldResult.authored.filter((a) => a.owner === "subagent").length;
+    const delegated = run2.foldResult.authored.filter((a) => a.owner === "subagent").length;
     if (cov.dispatched > 0 || cov.subagentFiles > 0 || cov.subagentSkipped > 0) {
       out += row("delegated", `${cov.dispatched} dispatched \xB7 ${cov.subagentFiles} agent log(s) read \xB7 ${delegated} path(s) attributed to subagents`);
     }
@@ -17579,52 +18434,52 @@ function formatRunEvidence(run, startedAt) {
       out += row("", `${cov.outsideRepo} authored path(s) refused as outside the repo`);
     }
   }
-  if (run.foldResult?.tools?.length) {
-    const shown = run.foldResult.tools.slice(0, 6).map((t) => {
+  if (run2.foldResult?.tools?.length) {
+    const shown = run2.foldResult.tools.slice(0, 6).map((t) => {
       const outcome = t.failed > 0 ? `${t.failed} failed` : t.last_status === 0 ? "ok" : "?";
       const where = t.targets.length > 0 ? ` \u2192 ${t.targets.slice(0, 2).join(", ")}` : "";
       return `${t.runs}\xD7 ${t.name} (${outcome})${where}`;
     });
-    const more = run.foldResult.tools.length > 6 ? ` \u2026 +${run.foldResult.tools.length - 6} more` : "";
+    const more = run2.foldResult.tools.length > 6 ? ` \u2026 +${run2.foldResult.tools.length - 6} more` : "";
     out += row("tools", shown.join(" \xB7 ") + more);
-    if (run.foldResult.coverage.toolNamesDropped > 0) {
-      out += row("", `\u26A0 ${run.foldResult.coverage.toolNamesDropped} tool name(s) refused by the cap`);
+    if (run2.foldResult.coverage.toolNamesDropped > 0) {
+      out += row("", `\u26A0 ${run2.foldResult.coverage.toolNamesDropped} tool name(s) refused by the cap`);
     }
   }
-  if (run.foldResult?.tasks?.length) {
-    const t = run.foldResult.tasks;
+  if (run2.foldResult?.tasks?.length) {
+    const t = run2.foldResult.tasks;
     const done2 = t.filter((x) => x.status === "completed").length;
     out += row("tasks", `${t.length} \xB7 ${done2} completed \xB7 ` + list(t.slice(0, 4).map((x) => `#${x.id} ${x.name} [${x.status}]`), 4));
   }
-  if (run.specs?.length) {
-    const readThisSession = new Set(run.actionSummary?.files_read ?? []);
-    const labelled = run.specs.map(
+  if (run2.specs?.length) {
+    const readThisSession = new Set(run2.actionSummary?.files_read ?? []);
+    const labelled = run2.specs.map(
       (s) => `${s.path}${readThisSession.has(s.path) ? " (read)" : " (positional)"}`
     );
-    out += row("specs", `${run.specs.length} \xB7 ${list(labelled, 5)}`);
+    out += row("specs", `${run2.specs.length} \xB7 ${list(labelled, 5)}`);
   }
-  if (run.staticResults.findings.length > 0) {
-    out += row("static", `${run.staticResults.findings.length} finding(s) from ${run.staticResults.summary.tools_run.join(", ") || "no tools"}`);
+  if (run2.staticResults.findings.length > 0) {
+    out += row("static", `${run2.staticResults.findings.length} finding(s) from ${run2.staticResults.summary.tools_run.join(", ") || "no tools"}`);
   }
-  if (run.decision && run.decision !== "(unrecognised)") {
-    out += row("verdict", run.decision + (run.silenced ? ` \xB7 agent channel silenced (${run.silenced})` : ""));
+  if (run2.decision && run2.decision !== "(unrecognised)") {
+    out += row("verdict", run2.decision + (run2.silenced ? ` \xB7 agent channel silenced (${run2.silenced})` : ""));
   }
   return out;
 }
-function installRunEvidence(run) {
+function installRunEvidence(run2) {
   const startedAt = Date.now();
   process.on("exit", () => {
     try {
-      logToFileOnly(formatRunEvidence(run, startedAt));
+      logToFileOnly(formatRunEvidence(run2, startedAt));
     } catch {
     }
   });
 }
 
 // src/lib/git-frame.ts
-var import_node_child_process7 = require("node:child_process");
+var import_node_child_process8 = require("node:child_process");
 var import_node_fs24 = require("node:fs");
-var import_node_os3 = require("node:os");
+var import_node_os4 = require("node:os");
 var import_node_path18 = require("node:path");
 var import_node_path19 = require("node:path");
 var VALUE_TOKEN = `(?:'[^']*'|"[^"]*"|\\S+)`;
@@ -17672,14 +18527,14 @@ function extractCommandTarget(command, segmentIndex, baseDir) {
     if (!m) continue;
     named = true;
     if (m[1] === void 0) {
-      dir = (0, import_node_os3.homedir)();
+      dir = (0, import_node_os4.homedir)();
       continue;
     }
     const raw = unquote(m[1]);
     if (SHELL_DYNAMIC.test(raw) || raw === "-") {
       return { dir: null, named: true, unresolvable: `cd target not statically resolvable: ${raw}` };
     }
-    const expanded = raw === "~" ? (0, import_node_os3.homedir)() : raw.startsWith("~/") ? (0, import_node_path19.join)((0, import_node_os3.homedir)(), raw.slice(2)) : raw;
+    const expanded = raw === "~" ? (0, import_node_os4.homedir)() : raw.startsWith("~/") ? (0, import_node_path19.join)((0, import_node_os4.homedir)(), raw.slice(2)) : raw;
     dir = (0, import_node_path18.isAbsolute)(expanded) ? expanded : (0, import_node_path18.resolve)(dir, expanded);
   }
   const seg = segments[segmentIndex];
@@ -17698,7 +18553,7 @@ function extractCommandTarget(command, segmentIndex, baseDir) {
       if (SHELL_DYNAMIC.test(raw)) {
         return { dir: null, named: true, unresolvable: `-C target not statically resolvable: ${raw}` };
       }
-      const expanded = raw === "~" ? (0, import_node_os3.homedir)() : raw.startsWith("~/") ? (0, import_node_path19.join)((0, import_node_os3.homedir)(), raw.slice(2)) : raw;
+      const expanded = raw === "~" ? (0, import_node_os4.homedir)() : raw.startsWith("~/") ? (0, import_node_path19.join)((0, import_node_os4.homedir)(), raw.slice(2)) : raw;
       dir = (0, import_node_path18.isAbsolute)(expanded) ? expanded : (0, import_node_path18.resolve)(dir, expanded);
     }
   }
@@ -17755,7 +18610,7 @@ function parsePushTarget(segment) {
 }
 function gitAt(dir, args) {
   try {
-    return (0, import_node_child_process7.execFileSync)("git", args, { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return (0, import_node_child_process8.execFileSync)("git", args, { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
     return "";
   }
@@ -17894,16 +18749,50 @@ function rangeFiles(frame, range) {
   }
   return out.split("\n").filter((l) => l.length > 0).filter((f) => !isVerityOwnedPath(f));
 }
-function rangeMessages(frame, range) {
-  if (range.kind === "staged" || range.kind === "nothing" || !range.base) return "";
-  return frameGit(frame, ["log", `${range.base}..${range.head === "INDEX" ? "HEAD" : range.head}`, "--format=%B%x00"]).split("\0").map((s) => s.trim()).filter(Boolean).join("\n\n");
-}
-function frameTelemetry(frame, range, divergence) {
-  const t = {
-    anchor: frame.anchor,
-    linked_worktree: frame.isLinkedWorktree,
-    range_via: range?.via ?? null,
-    refusal: frame.refusal
+function rangeChangeSignals(frame, range, paths) {
+  const out = /* @__PURE__ */ new Map();
+  if (range.kind === "nothing" || paths.length === 0) return out;
+  const args = range.kind === "staged" ? ["diff", "--cached", "--unified=0"] : ["diff", "--unified=0", range.base, range.head === "INDEX" ? "HEAD" : range.head];
+  const diff = frameGit(frame, [...args, "--", ...paths]);
+  let current = null;
+  let oldSide = null;
+  let buf = [];
+  const flush = () => {
+    if (current !== null && buf.length > 0) out.set(current, parseDiffSignals(buf.join("\n")));
+    buf = [];
+  };
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      flush();
+      current = null;
+      oldSide = null;
+      continue;
+    }
+    const minusM = /^--- (?:a\/)?(.+)$/.exec(line);
+    if (minusM) {
+      oldSide = minusM[1] === "/dev/null" ? null : minusM[1];
+      continue;
+    }
+    const plusM = /^\+\+\+ (?:b\/)?(.+)$/.exec(line);
+    if (plusM) {
+      current = plusM[1] === "/dev/null" ? oldSide : plusM[1];
+      continue;
+    }
+    if (current !== null) buf.push(line);
+  }
+  flush();
+  return out;
+}
+function rangeMessages(frame, range) {
+  if (range.kind === "staged" || range.kind === "nothing" || !range.base) return "";
+  return frameGit(frame, ["log", `${range.base}..${range.head === "INDEX" ? "HEAD" : range.head}`, "--format=%B%x00"]).split("\0").map((s) => s.trim()).filter(Boolean).join("\n\n");
+}
+function frameTelemetry(frame, range, divergence) {
+  const t = {
+    anchor: frame.anchor,
+    linked_worktree: frame.isLinkedWorktree,
+    range_via: range?.via ?? null,
+    refusal: frame.refusal
   };
   if (divergence) {
     t.root_differs = !!frame.worktreeRoot && !!divergence.actualRoot && realpathOr(frame.worktreeRoot) !== realpathOr(divergence.actualRoot);
@@ -17953,6 +18842,7 @@ var MAX_COMMANDS = 10;
 var MAX_COMMAND_CHARS = 80;
 var MAX_TOOL_BLOCKS = 200;
 var MAX_SUMMARY_BYTES = 4096;
+var MAX_SEARCHES_DETAIL = 10;
 var HOME = process.env.HOME ?? "";
 var BASH_INPUT_RE = /^\s*<bash-input>([\s\S]*?)<\/bash-input>/;
 var BASH_ECHO_RE = /^\s*<bash-(?:stdout|stderr)>/;
@@ -18038,6 +18928,7 @@ function buildSummary(lines) {
   let userCommandsTruncated = false;
   let commandsTruncated = false;
   let searches = 0;
+  const searchesDetail = [];
   let subagents = 0;
   let webFetches = 0;
   let totalToolCalls = 0;
@@ -18109,9 +19000,19 @@ function buildSummary(lines) {
           break;
         }
         case "Grep":
-        case "Glob":
+        case "Glob": {
           searches++;
+          const pattern = typeof input.pattern === "string" ? input.pattern.slice(0, 120) : "";
+          if (pattern && searchesDetail.length < MAX_SEARCHES_DETAIL) {
+            const scopePath = typeof input.path === "string" ? input.path.slice(0, 200) : void 0;
+            searchesDetail.push({
+              tool: toolName,
+              pattern,
+              ...scopePath ? { path: scopePath } : {}
+            });
+          }
           break;
+        }
         case "Agent":
         case "Task":
         case "Workflow":
@@ -18146,6 +19047,7 @@ function buildSummary(lines) {
       ...cappedOut(filesCreated, MAX_CREATED_LIST)
     ],
     searches,
+    ...searchesDetail.length > 0 ? { searches_detail: searchesDetail } : {},
     commands,
     ...commandsTruncated ? { commands_truncated: true } : {},
     user_commands: userCommands,
@@ -18156,6 +19058,9 @@ function buildSummary(lines) {
     turn_messages: turnMessages,
     turn_duration_ms: turnDurationMs
   };
+  if (JSON.stringify(summary).length > MAX_SUMMARY_BYTES) {
+    delete summary.searches_detail;
+  }
   if (JSON.stringify(summary).length > MAX_SUMMARY_BYTES) {
     summary.commands = [];
     summary.commands_truncated = true;
@@ -18266,13 +19171,13 @@ async function readStopHookStdin() {
     return empty;
   }
 }
-async function bootstrap(run) {
-  const { opts, globals } = run;
+async function bootstrap(run2) {
+  const { opts, globals } = run2;
   try {
     process.chdir(repoRoot());
   } catch {
   }
-  run.treeFrame = resolveFrame({ command: "", on: [], hookCwd: null }).frame;
+  run2.treeFrame = resolveFrame({ command: "", on: [], hookCwd: null }).frame;
   const turnId = `t-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
   let reachability = resolveReachability({
     autonomousFlag: process.env.VERITY_AUTONOMOUS === "1" || opts.mode === "autonomous",
@@ -18286,7 +19191,7 @@ async function bootstrap(run) {
   const rawSessionId = sessionId || process.env.CLAUDE_SESSION_ID || void 0;
   const baselineSessionId = sessionScopeKey(scopeToken, rawSessionId);
   if (tokenResult.ok) {
-    run.beacon = {
+    run2.beacon = {
       resolveServiceUrl: async () => {
         const u = await resolveServiceUrl(globals.serviceUrl);
         return u.ok ? u.data : null;
@@ -18306,7 +19211,7 @@ async function bootstrap(run) {
       age_ms: Date.now() - baseline.captured_at
     });
   }
-  Object.assign(run, { actionSummary, assistantResponse, baseline, baselineSessionId, reachability, sessionId, stopReason, tokenResult, transcriptPath, turnId });
+  Object.assign(run2, { actionSummary, assistantResponse, baseline, baselineSessionId, reachability, sessionId, stopReason, tokenResult, transcriptPath, turnId });
 }
 
 // src/lib/self-scope.ts
@@ -18459,7 +19364,7 @@ function channelSilence(input) {
 // src/lib/cli-version.ts
 function cliVersion() {
   try {
-    return true ? "0.31.1-experimental.80cf3ac" : "dev";
+    return true ? "0.31.1-experimental.83a8619" : "dev";
   } catch {
     return "dev";
   }
@@ -18499,7 +19404,7 @@ async function sendSkipBeacon(ctx, reason) {
 }
 
 // src/lib/static-analysis.ts
-var import_node_child_process8 = require("node:child_process");
+var import_node_child_process9 = require("node:child_process");
 var import_node_fs26 = require("node:fs");
 var SEVERITY_ORDER = {
   Error: 0,
@@ -18512,7 +19417,7 @@ var SEVERITY_ORDER = {
 };
 function isCodacyAvailable() {
   try {
-    (0, import_node_child_process8.execSync)("which codacy-analysis", { stdio: "pipe" });
+    (0, import_node_child_process9.execSync)("which codacy-analysis", { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -18554,7 +19459,7 @@ function runCodacyAnalysis(files) {
     }
   });
   if (existingFiles.length === 0) return empty;
-  const proc = (0, import_node_child_process8.spawnSync)("codacy-analysis", buildAnalyzerArgv(existingFiles), {
+  const proc = (0, import_node_child_process9.spawnSync)("codacy-analysis", buildAnalyzerArgv(existingFiles), {
     encoding: "utf-8",
     maxBuffer: 10 * 1024 * 1024
   });
@@ -18565,12 +19470,12 @@ function runCodacyAnalysis(files) {
     spawnError: proc.error?.message
   });
 }
-function interpretAnalyzerRun(run) {
-  const output = run.stdout ?? "";
+function interpretAnalyzerRun(run2) {
+  const output = run2.stdout ?? "";
   if (!output.trim()) {
     return withFailure(
-      run.spawnError ? "spawn_failed" : "no_output",
-      run.spawnError ?? run.stderr ?? `exit ${run.status}`
+      run2.spawnError ? "spawn_failed" : "no_output",
+      run2.spawnError ?? run2.stderr ?? `exit ${run2.status}`
     );
   }
   let parsed;
@@ -18737,9 +19642,9 @@ function localOnlyAndExit(staticResults) {
   });
   process.exit(0);
 }
-async function passAndExit(run, reason, skip, kindOverride) {
-  run.skipReason = skip;
-  const sent = await sendSkipBeacon(run.beacon, skip);
+async function passAndExit(run2, reason, skip, kindOverride) {
+  run2.skipReason = skip;
+  const sent = await sendSkipBeacon(run2.beacon, skip);
   logEvent("skip", { reason: skip, beacon: sent });
   const POLICY_SKIPS = /* @__PURE__ */ new Set([
     "no-analyzable-files",
@@ -18754,7 +19659,7 @@ async function passAndExit(run, reason, skip, kindOverride) {
     "no-delta-since-last-review"
   ]);
   const skipKind = kindOverride ?? (POLICY_SKIPS.has(skip) ? "policy" : "capacity");
-  const changed = run.changedUniverse;
+  const changed = run2.changedUniverse;
   const { coverage, unaccounted } = reconcileCoverage(changed, {
     reviewed: [],
     notReviewed: changed.map((path) => ({ path, reason: skip, stage: "pre-flight", kind: skipKind }))
@@ -18782,10 +19687,10 @@ async function passAndExit(run, reason, skip, kindOverride) {
 }
 
 // src/commands/analyze/phases/02-scope.ts
-async function scope(run) {
-  const { assistantResponse } = run;
+async function scope(run2) {
+  const { assistantResponse } = run2;
   const { files: allChanged, hasRecentCommitFiles } = getChangedFiles();
-  run.changedUniverse = allChanged;
+  run2.changedUniverse = allChanged;
   const { kept: external } = partitionVerityOwned(allChanged);
   const verityIgnore = loadVerityIgnore();
   const ignored = partitionIgnored(external, verityIgnore);
@@ -18810,10 +19715,10 @@ async function scope(run) {
   const securityFiles = filterSecurity(inScope);
   const noFilesChanged = analyzable.length === 0 && reviewable.length === 0 && securityFiles.length === 0;
   if (noFilesChanged && !assistantResponse) {
-    await passAndExit(run, "No analyzable files changed", "no-analyzable-files");
+    await passAndExit(run2, "No analyzable files changed", "no-analyzable-files");
   }
   const allForReview = Array.from(/* @__PURE__ */ new Set([...analyzable, ...reviewable]));
-  Object.assign(run, { allChanged, allForReview, analyzable, hasRecentCommitFiles, noFilesChanged, reviewable, securityFiles, verityIgnored: ignored });
+  Object.assign(run2, { allChanged, allForReview, analyzable, hasRecentCommitFiles, noFilesChanged, reviewable, securityFiles, verityIgnored: ignored });
 }
 
 // src/lib/specs.ts
@@ -18959,8 +19864,8 @@ function discoverGuardDocs(rangeFiles2) {
 }
 
 // src/commands/analyze/phases/03-intent-inputs.ts
-async function intentInputs(run) {
-  const { actionSummary, allForReview, assistantResponse, baseline, baselineSessionId } = run;
+async function intentInputs(run2) {
+  const { actionSummary, allForReview, assistantResponse, baseline, baselineSessionId } = run2;
   if (isCommandOnlyTurn({
     userCommands: actionSummary?.user_commands,
     userCommandsTruncated: actionSummary?.user_commands_truncated,
@@ -18968,11 +19873,11 @@ async function intentInputs(run) {
     agentToolCalls: actionSummary?.total_tool_calls ?? 0,
     authorshipIsObservable: !!actionSummary && actionSummary.transcript_windowed !== "orphaned"
   })) {
-    await passAndExit(run, "User command only \u2014 skipping analysis", "command-only-turn");
+    await passAndExit(run2, "User command only \u2014 skipping analysis", "command-only-turn");
   }
   {
     const ignoreKeys = ignoreStateKeys(
-      run.tokenResult.ok ? run.tokenResult.data.token : void 0,
+      run2.tokenResult.ok ? run2.tokenResult.data.token : void 0,
       null
     );
     const found = resolveIgnoreState([baselineSessionId, ...ignoreKeys]);
@@ -18996,7 +19901,7 @@ async function intentInputs(run) {
         if (declaration.scope === "turn" && found) clearActiveDeclaration(found.key);
         logEvent("ignore_honoured", { scope: declaration.scope, origin: declaration.origin });
         await passAndExit(
-          run,
+          run2,
           `skipping this turn \u2014 declared housekeeping ("${declaration.reason}")`,
           "declared-ignore"
         );
@@ -19010,7 +19915,7 @@ async function intentInputs(run) {
         const notice = `Verity: the ignore declared for this window ("${declaration.reason}") was voided \u2014 ${outcome.why}. Reviewing normally.`;
         process.stderr.write(`${notice}
 `);
-        run.voidedIgnoreNotice = notice;
+        run2.voidedIgnoreNotice = notice;
       }
     }
   }
@@ -19032,34 +19937,33 @@ async function intentInputs(run) {
       const adopted = absorbIntoBaseline(setupAuthored, baselineSessionId);
       logEvent("baseline_absorbed", { skip: "verity-command", offered: setupAuthored.length, adopted });
     }
-    await passAndExit(run, "Verity command \u2014 skipping analysis", "verity-command");
+    await passAndExit(run2, "Verity command \u2014 skipping analysis", "verity-command");
   }
   if (shouldSkipForBareAck({ prompt: latestPrompt, turnAuthoredCode, canSeeTurnAuthorship })) {
-    await passAndExit(run, "Bare acknowledgment \u2014 skipping analysis", "bare-acknowledgment");
+    await passAndExit(run2, "Bare acknowledgment \u2014 skipping analysis", "bare-acknowledgment");
   }
   if (isReflectionQuestion(assistantResponse) && !turnAuthoredCode && canSeeTurnAuthorship) {
-    await passAndExit(run, "Reflection-prompt turn \u2014 skipping analysis", "reflection-prompt");
+    await passAndExit(run2, "Reflection-prompt turn \u2014 skipping analysis", "reflection-prompt");
   }
-  Object.assign(run, { authorshipIsObservable, conversation, earlyFold, plans, specs, turnAuthoredCode });
+  Object.assign(run2, { authorshipIsObservable, conversation, earlyFold, plans, specs, turnAuthoredCode });
 }
 
 // src/commands/analyze/phases/04-connect.ts
-async function connect(run) {
-  const { opts, globals } = run;
-  const { analyzable, baseline, securityFiles, tokenResult } = run;
+async function connect(run2) {
+  const { opts, globals } = run2;
+  const { analyzable, baseline, securityFiles, tokenResult } = run2;
   const urlResult = await resolveServiceUrl(globals.serviceUrl);
   if (!tokenResult.ok || !urlResult.ok) {
     localOnlyAndExit(runLocalStatic(analyzable, securityFiles, baseline, !!opts.skipStatic));
   }
-  Object.assign(run, { urlResult, serviceUrl: urlResult.data, token: tokenResult.data.token });
+  Object.assign(run2, { urlResult, serviceUrl: urlResult.data, token: tokenResult.data.token });
 }
 
 // src/commands/analyze/phases/05-mode.ts
-async function mode(run) {
-  const { opts, globals } = run;
-  const { actionSummary, allForReview, assistantResponse, baseline, conversation, memory, noFilesChanged, serviceUrl, sessionId, token, turnAuthoredCode } = run;
+async function mode(run2) {
+  const { opts, globals } = run2;
+  const { actionSummary, allForReview, assistantResponse, baseline, conversation, memory, noFilesChanged, serviceUrl, sessionId, token, turnAuthoredCode } = run2;
   const sessionIdForMemory = sessionId || process.env.CLAUDE_SESSION_ID || "";
-  let contextFilePaths = [];
   let predictedMode;
   try {
     const memoryPath2 = sessionIdForMemory ? `/memory?session_id=${encodeURIComponent(sessionIdForMemory)}` : "/memory";
@@ -19073,9 +19977,6 @@ async function mode(run) {
       cmd: "analyze_context"
     });
     if (memoryResult.ok) {
-      if (Array.isArray(memoryResult.data.context_files)) {
-        contextFilePaths = memoryResult.data.context_files;
-      }
       const rawMode = memoryResult.data.predicted_mode;
       if (rawMode && ["standard", "plan", "debug", "skip"].includes(rawMode)) {
         predictedMode = rawMode;
@@ -19098,7 +19999,7 @@ async function mode(run) {
     );
   }
   const investigated = didAgentInvestigate(actionSummary);
-  run.modeDecision = {
+  run2.modeDecision = {
     predicted: predictedMode ?? null,
     resolved: analysisMode,
     authored: turnAuthoredCode,
@@ -19118,13 +20019,13 @@ async function mode(run) {
   });
   if (analysisMode === "skip") {
     await passAndExit(
-      run,
+      run2,
       "Skip mode \u2014 no code work to analyze",
       "skip-mode",
       turnAuthoredCode ? "capacity" : void 0
     );
   }
-  Object.assign(run, { analysisMode, contextFilePaths, sessionAuthoredCode, sessionIdForMemory });
+  Object.assign(run2, { analysisMode, sessionAuthoredCode, sessionIdForMemory });
 }
 
 // src/lib/fold.ts
@@ -19584,12 +20485,12 @@ function checkConservation(changedFiles, result, repoRoot2) {
 }
 
 // src/commands/analyze/phases/06-evidence.ts
-async function evidence(run) {
-  const { opts } = run;
-  const { actionSummary, allForReview, analyzable, assistantResponse, authorshipIsObservable, baseline, baselineSessionId, hasRecentCommitFiles, reviewable, securityFiles, sessionAuthoredCode, transcriptPath, turnAuthoredCode } = run;
-  let { analysisMode, earlyFold } = run;
+async function evidence(run2) {
+  const { opts } = run2;
+  const { actionSummary, allForReview, analyzable, assistantResponse, authorshipIsObservable, baseline, baselineSessionId, hasRecentCommitFiles, reviewable, securityFiles, sessionAuthoredCode, transcriptPath, turnAuthoredCode } = run2;
+  let { analysisMode, earlyFold } = run2;
   const recordFlip = (stage) => {
-    if (run.modeDecision) run.modeDecision = { ...run.modeDecision, resolved: "plan", flip: stage };
+    if (run2.modeDecision) run2.modeDecision = { ...run2.modeDecision, resolved: "plan", flip: stage };
     logEvent("mode_flipped", { stage, to: "plan" });
   };
   const planWorthy = !!assistantResponse && !turnAuthoredCode;
@@ -19616,7 +20517,7 @@ async function evidence(run) {
         analysisMode = "plan";
         recordFlip("debounce");
       } else {
-        await passAndExit(run, debounceSkip, "debounce");
+        await passAndExit(run2, debounceSkip, "debounce");
       }
     }
     if (analysisMode !== "plan") {
@@ -19627,7 +20528,7 @@ async function evidence(run) {
           analysisMode = "plan";
           recordFlip("mtime");
         } else {
-          await passAndExit(run, mtimeSkip, "no-delta-since-last-review");
+          await passAndExit(run2, mtimeSkip, "no-delta-since-last-review");
         }
       }
     }
@@ -19640,7 +20541,7 @@ async function evidence(run) {
           analysisMode = "plan";
           recordFlip("content-hash");
         } else {
-          await passAndExit(run, hashResult.skip, "no-delta-since-last-review");
+          await passAndExit(run2, hashResult.skip, "no-delta-since-last-review");
         }
       }
       contentHash = hashResult.hash;
@@ -19648,7 +20549,7 @@ async function evidence(run) {
         const scoped = scopeToAuthored(allForReview, actionSummary);
         const canTrustNoneAuthored = scoped.signal === "none-authored" && authorshipIsObservable;
         if (canTrustNoneAuthored && !hasNonEditAuthorship(actionSummary, sessionAuthoredCode)) {
-          await passAndExit(run, "No agent-authored code this turn \u2014 working-tree changes were not authored by this session", "zero-increment");
+          await passAndExit(run2, "No agent-authored code this turn \u2014 working-tree changes were not authored by this session", "zero-increment");
         }
         if (scoped.signal === "none-authored" && !authorshipIsObservable) {
           logEvent("none_authored_unverifiable", {
@@ -19705,7 +20606,7 @@ async function evidence(run) {
             recordFlip("empty-after-scoping");
           } else {
             await passAndExit(
-              run,
+              run2,
               "No files within size limits to analyze",
               "size-limit",
               codeDelta.excluded.length > 0 ? "capacity" : "policy"
@@ -19730,7 +20631,7 @@ async function evidence(run) {
     currentCommit = getCurrentCommit();
     iteration = readIteration(currentCommit);
   }
-  Object.assign(run, { analysisMode, codeDelta, contentHash, currentCommit, earlyFold, iteration, snapshotResult, staticResults });
+  Object.assign(run2, { analysisMode, codeDelta, contentHash, currentCommit, earlyFold, iteration, snapshotResult, staticResults });
 }
 
 // src/lib/cache-cleanup.ts
@@ -19762,15 +20663,52 @@ function pruneStaleCache() {
 
 // src/lib/context-files.ts
 var import_node_fs30 = require("node:fs");
+var import_node_os5 = require("node:os");
 var MAX_CONTEXT_FILES = 10;
 var MAX_CONTEXT_FILE_BYTES = 10240;
-var MAX_CONTEXT_TOTAL_BYTES = 51200;
-function gatherContextFiles(contextPaths, deltaFiles) {
+var MAX_CONTEXT_TOTAL_BYTES = 24576;
+function readSetContextPaths(summary, deltaFiles) {
+  const reads = summary?.files_read ?? [];
+  if (reads.length === 0) return [];
+  const root = process.cwd().replace(/\/+$/, "");
+  const home = (0, import_node_os5.homedir)();
+  const toRepoRelative2 = (p) => {
+    if (!p) return null;
+    let abs;
+    if (p.startsWith("/")) {
+      abs = p;
+    } else {
+      const rebuilt = `${home}/${p}`;
+      abs = rebuilt.startsWith(`${root}/`) ? rebuilt : `${root}/${p}`;
+    }
+    if (!abs.startsWith(`${root}/`)) return null;
+    return abs.slice(root.length + 1);
+  };
+  const authored = /* @__PURE__ */ new Set();
+  for (const p of [...summary?.files_edited ?? [], ...summary?.files_created ?? []]) {
+    const rel = toRepoRelative2(p);
+    if (rel) authored.add(rel);
+  }
+  for (const f of deltaFiles) authored.add(f.path);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of reads) {
+    const rel = toRepoRelative2(p);
+    if (!rel || seen.has(rel) || authored.has(rel)) continue;
+    seen.add(rel);
+    const ext = rel.split(".").pop()?.toLowerCase() ?? "";
+    if (!ANALYZABLE_EXTENSIONS.has(ext) && !REVIEWABLE_EXTENSIONS.has(ext)) continue;
+    out.push(rel);
+  }
+  return out;
+}
+function gatherContextFiles(contextPaths, deltaFiles, opts) {
+  const fileCap = Math.max(0, Math.min(MAX_CONTEXT_FILES, opts?.maxFiles ?? MAX_CONTEXT_FILES));
   const deltaPaths = new Set(deltaFiles.map((f) => f.path));
   const result = [];
   let totalBytes = 0;
   for (const filePath of contextPaths) {
-    if (result.length >= MAX_CONTEXT_FILES) break;
+    if (result.length >= fileCap) break;
     if (deltaPaths.has(filePath)) continue;
     if (isVerityOwnedPath(filePath)) {
       logEvent("context_file_skipped", { path: filePath, reason: "verity_owned" });
@@ -19827,10 +20765,15 @@ function gatherContextFiles(contextPaths, deltaFiles) {
 }
 
 // src/commands/analyze/phases/07-context-files.ts
-async function contextFiles(run) {
-  const { codeDelta, contextFilePaths } = run;
-  const { kept: externalContext } = partitionVerityOwned(contextFilePaths ?? []);
-  const contextFiles2 = gatherContextFiles(externalContext, codeDelta.files);
+async function contextFiles(run2) {
+  const { codeDelta } = run2;
+  const readSet = readSetContextPaths(run2.actionSummary, codeDelta.files);
+  const { kept: externalContext } = partitionVerityOwned(readSet);
+  const ig = loadVerityIgnore();
+  const unfenced = run2.verityIgnored.suspended ? externalContext : externalContext.filter((p) => !isIgnored(ig, p));
+  const contextFiles2 = gatherContextFiles(unfenced, codeDelta.files, {
+    maxFiles: MAX_FILES - codeDelta.files.length
+  });
   for (const f of codeDelta.files) {
     f.role = "delta";
   }
@@ -19842,6 +20785,30 @@ async function contextFiles(run) {
   });
 }
 
+// src/commands/analyze/phases/07b-repo-context.ts
+async function repoContext(run2) {
+  const { codeDelta, snapshotResult } = run2;
+  const deltaFiles = codeDelta.files.filter((f) => f.role !== "context");
+  const sentPaths = new Set(codeDelta.files.map((f) => f.path));
+  const ig = loadVerityIgnore();
+  const isExcluded = (p) => isVerityOwnedPath(p) || !run2.verityIgnored.suspended && isIgnored(ig, p);
+  run2.repoContext = buildRepoContext({
+    deltaFiles,
+    diffs: snapshotResult.diffs,
+    sentPaths,
+    isExcluded
+  });
+  logEvent("repo_context", {
+    state: run2.repoContext.state,
+    reason: run2.repoContext.reason ?? null,
+    symbols: run2.repoContext.symbols?.length ?? 0,
+    dropped: run2.repoContext.dropped_symbols?.length ?? 0,
+    callers: run2.repoContext.callers?.length ?? 0,
+    tests: run2.repoContext.tests?.length ?? 0,
+    elapsed_ms: run2.repoContext.elapsed_ms ?? null
+  });
+}
+
 // src/lib/seed-runner.ts
 var import_promises11 = require("node:fs/promises");
 var import_node_fs31 = require("node:fs");
@@ -20185,9 +21152,9 @@ async function runSeed(opts) {
 // src/commands/analyze/phases/08-memory-manifest.ts
 var import_node_fs32 = require("node:fs");
 var import_node_path24 = require("node:path");
-async function memoryManifest(run) {
-  const { globals } = run;
-  const { serviceUrl, token } = run;
+async function memoryManifest(run2) {
+  const { globals } = run2;
+  const { serviceUrl, token } = run2;
   let memoryManifest2;
   let deletedNodePaths = [];
   let editedUploads = [];
@@ -20239,12 +21206,12 @@ async function memoryManifest(run) {
     editedUploads = await computeEditedNodeUploads();
   } catch {
   }
-  Object.assign(run, { autoSeedNotice, deletedNodePaths, editedUploads, memoryManifest: memoryManifest2 });
+  Object.assign(run2, { autoSeedNotice, deletedNodePaths, editedUploads, memoryManifest: memoryManifest2 });
 }
 
 // src/commands/analyze/phases/09-fold-transcript.ts
-async function foldTranscript(run) {
-  const { allForReview, earlyFold, transcriptPath } = run;
+async function foldTranscript(run2) {
+  const { allForReview, earlyFold, transcriptPath } = run2;
   let foldResult = null;
   let foldConservation = null;
   if (transcriptPath) {
@@ -20261,7 +21228,7 @@ async function foldTranscript(run) {
       foldResult = null;
     }
   }
-  Object.assign(run, { foldConservation, foldResult });
+  Object.assign(run2, { foldConservation, foldResult });
 }
 
 // src/lib/increment.ts
@@ -20313,10 +21280,10 @@ function computeIncrement(reviewedPaths, hashOf, priorAuthored) {
 
 // src/commands/analyze/phases/10-working-memory.ts
 var import_node_path25 = require("node:path");
-async function workingMemory(run) {
-  const { opts } = run;
-  const { allForReview, baseline, conversation, foldResult, sessionId, token, transcriptPath } = run;
-  let { reachability } = run;
+async function workingMemory(run2) {
+  const { opts } = run2;
+  const { allForReview, baseline, conversation, foldResult, sessionId, token, transcriptPath } = run2;
+  let { reachability } = run2;
   const memorySession = sessionDossier(token, sessionId ?? process.env.CLAUDE_SESSION_ID ?? null);
   let memory = null;
   let incrementReport = null;
@@ -20402,7 +21369,7 @@ async function workingMemory(run) {
     hasUserPrompt: (conversation?.prompts?.length ?? 0) > 0,
     isTTY: process.stdout.isTTY === true
   });
-  Object.assign(run, { incrementReport, memory, memorySession, reachability });
+  Object.assign(run2, { incrementReport, memory, memorySession, reachability });
 }
 
 // src/lib/note-budget.ts
@@ -20475,7 +21442,7 @@ function isExplicitlyAutonomous(env = process.env) {
 }
 
 // src/lib/task-context.ts
-var import_node_child_process9 = require("node:child_process");
+var import_node_child_process10 = require("node:child_process");
 var CLOSING_RE = /\b(close[sd]?|fix(?:e[sd])?|resolve[sd]?)\b[\s:]*#(\d+)/i;
 var BRANCH_RE = /(?:^|[/_-])(?:issue|gh|fix)[-_/]?(\d+)\b/i;
 function parseLinkedIssue(sources) {
@@ -20491,7 +21458,7 @@ function parseLinkedIssue(sources) {
 }
 function safeExec(cmd, timeout) {
   try {
-    return (0, import_node_child_process9.execSync)(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout }).trim();
+    return (0, import_node_child_process10.execSync)(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout }).trim();
   } catch {
     return "";
   }
@@ -20521,8 +21488,8 @@ function resolveTaskContext(opts) {
 // src/commands/analyze/phases/11-build-request.ts
 var MAX_ASSISTANT_RESPONSE_CHARS_PLAN = 32768;
 var MAX_ASSISTANT_RESPONSE_CHARS_DEFAULT = 8e3;
-async function buildRequest(run) {
-  const { actionSummary, allChanged, allForReview, analysisMode, analyzable, assistantResponse, codeDelta, conversation, deletedNodePaths, editedUploads, foldConservation, foldResult, incrementReport, iteration, memory, memoryManifest: memoryManifest2, memorySession, plans, reachability, reviewable, securityFiles, sessionId, snapshotResult, specs, staticResults, stopReason, turnId } = run;
+async function buildRequest(run2) {
+  const { actionSummary, allChanged, allForReview, analysisMode, analyzable, assistantResponse, codeDelta, conversation, deletedNodePaths, editedUploads, foldConservation, foldResult, incrementReport, iteration, memory, memoryManifest: memoryManifest2, memorySession, plans, reachability, reviewable, securityFiles, sessionId, snapshotResult, specs, staticResults, stopReason, turnId } = run2;
   const excludedByReason = {};
   for (const e of codeDelta.excluded ?? []) {
     excludedByReason[e.reason] = (excludedByReason[e.reason] ?? 0) + 1;
@@ -20552,15 +21519,15 @@ async function buildRequest(run) {
     // the state, so the number is one turn lagged by construction. The
     // degenerate win for the budget is a dead channel that looks like clean
     // code; this is what makes "did delivery rate collapse" a query.
-    advisory_delivered_prior: readAdvisoryEpisode(run.baselineSessionId)?.delivered ?? 0,
+    advisory_delivered_prior: readAdvisoryEpisode(run2.baselineSessionId)?.delivered ?? 0,
     // `.verityignore` — see CoverageTelemetry.verityignore for why the SHARE is
     // the number that matters and why no paths travel with it.
     verityignore: {
-      rules: run.verityIgnored.rules,
-      excluded: run.verityIgnored.ignored.length,
-      share: ignoreShare(run.verityIgnored.kept.length, run.verityIgnored.ignored.length),
-      security_excluded: run.verityIgnored.securityExcluded.length,
-      suspended: run.verityIgnored.suspended
+      rules: run2.verityIgnored.rules,
+      excluded: run2.verityIgnored.ignored.length,
+      share: ignoreShare(run2.verityIgnored.kept.length, run2.verityIgnored.ignored.length),
+      security_excluded: run2.verityIgnored.securityExcluded.length,
+      suspended: run2.verityIgnored.suspended
     }
   };
   const requestBody = {
@@ -20698,6 +21665,9 @@ async function buildRequest(run) {
   if (snapshotResult.has_snapshots && snapshotResult.diffs.length > 0) {
     requestBody.snapshot_diffs = snapshotResult.diffs;
   }
+  if (run2.repoContext) {
+    requestBody.repo_context = run2.repoContext;
+  }
   const noHumanPrompt = (conversation?.prompts?.length ?? 0) === 0;
   const w4Task = noHumanPrompt && isExplicitlyAutonomous() ? resolveTaskContext() : null;
   const planApprovalActive = foldResult?.planApproval?.activeSinceLastPrompt === true;
@@ -20755,7 +21725,7 @@ async function buildRequest(run) {
     }
     requestBody.intent_context = intentContext;
   }
-  Object.assign(run, { requestBody });
+  Object.assign(run2, { requestBody });
 }
 
 // src/lib/offline.ts
@@ -20816,9 +21786,9 @@ function shouldWarmRetryAnalyze(result) {
 }
 
 // src/commands/analyze/phases/12-transmit.ts
-async function transmit(run) {
-  const { globals } = run;
-  const { codeDelta, requestBody, serviceUrl, staticResults, token } = run;
+async function transmit(run2) {
+  const { globals } = run2;
+  const { codeDelta, requestBody, serviceUrl, staticResults, token } = run2;
   const ANALYZE_TIMEOUT_MS = 1e5;
   let result = await analyzeRequest({
     serviceUrl,
@@ -20881,14 +21851,14 @@ async function transmit(run) {
   }
   const response = result.data;
   const decision = response.gate_decision ?? "(unrecognised)";
-  Object.assign(run, { decision, response });
+  Object.assign(run2, { decision, response });
 }
 
 // src/commands/analyze/phases/13-reconcile.ts
 var import_node_fs35 = require("node:fs");
 var import_node_path26 = require("node:path");
-async function reconcile(run) {
-  const { actionSummary, allChanged, analyzable, baseline, baselineSessionId, codeDelta, contentHash, conversation, decision, foldResult, memory, memorySession, response, reviewable, securityFiles, turnId } = run;
+async function reconcile(run2) {
+  const { actionSummary, allChanged, analyzable, baseline, baselineSessionId, codeDelta, contentHash, conversation, decision, foldResult, memory, memorySession, response, reviewable, securityFiles, turnId } = run2;
   const sentPaths = codeDelta.files.map((f) => f.path);
   if (memorySession) {
     try {
@@ -20989,7 +21959,7 @@ async function reconcile(run) {
       // below is the signal that replaces the noise.
       //
       // Taken from the run, not recomputed — see context.ts `verityIgnored`.
-      ...run.verityIgnored.ignored.map((path) => ({
+      ...run2.verityIgnored.ignored.map((path) => ({
         path,
         reason: "verityignore",
         stage: "verityignore",
@@ -21109,11 +22079,11 @@ async function reconcile(run) {
 `
     );
   }
-  Object.assign(run, { intentRepeatCount, openElsewhere, priorPendingFingerprints, reviewCoverage, sentPaths, silenced, watermarkHash, watermarkIsPartial });
+  Object.assign(run2, { intentRepeatCount, openElsewhere, priorPendingFingerprints, reviewCoverage, sentPaths, silenced, watermarkHash, watermarkIsPartial });
 }
 
 // src/lib/emit.ts
-var YELLOW2 = "\x1B[33m";
+var YELLOW3 = "\x1B[33m";
 var NC2 = "\x1B[0m";
 function emitVerdict(input) {
   const exit = input.exit ?? ((code) => process.exit(code));
@@ -21124,7 +22094,7 @@ function emitVerdict(input) {
   const note = [describeCoverage(coverage), describeOpenElsewhere(openElsewhere)].filter(Boolean).join("\n\n") || null;
   if (unaccounted.length > 0) {
     process.stderr.write(
-      `${YELLOW2}Verity: ${unaccounted.length} changed file(s) could not be attributed to any review stage \u2014 counted as unreviewed.${NC2}
+      `${YELLOW3}Verity: ${unaccounted.length} changed file(s) could not be attributed to any review stage \u2014 counted as unreviewed.${NC2}
 `
     );
   }
@@ -21136,7 +22106,7 @@ ${input.agentContext}
 `);
     }
     if (note && !input.silenced) process.stderr.write(`
-${YELLOW2}${note}${NC2}
+${YELLOW3}${note}${NC2}
 `);
     return exit(2);
   }
@@ -21222,10 +22192,10 @@ function screenRemediation(fix, findingFile) {
 function agentContextFor(response, intentRepeat = 0, priorPendingFingerprints = []) {
   return buildAgentContext(channelInputFrom(response, intentRepeat, priorPendingFingerprints));
 }
-async function render(run) {
-  const { opts, globals } = run;
-  const { actionSummary, assistantResponse, autoSeedNotice, voidedIgnoreNotice, baselineSessionId, codeDelta, contentHash, conversation, currentCommit, decision, intentRepeatCount, memory, openElsewhere, priorPendingFingerprints, response, reviewCoverage, serviceUrl, sessionIdForMemory, silenced, token, watermarkHash, watermarkIsPartial } = run;
-  let { iteration } = run;
+async function render(run2) {
+  const { opts, globals } = run2;
+  const { actionSummary, assistantResponse, autoSeedNotice, voidedIgnoreNotice, baselineSessionId, codeDelta, contentHash, conversation, currentCommit, decision, intentRepeatCount, memory, openElsewhere, priorPendingFingerprints, response, reviewCoverage, serviceUrl, sessionIdForMemory, silenced, token, watermarkHash, watermarkIsPartial } = run2;
+  let { iteration } = run2;
   const metadata = response.metadata ?? {};
   const intentAmbiguity = metadata.intent_ambiguity;
   if (intentAmbiguity != null && intentAmbiguity > 5) {
@@ -21332,7 +22302,7 @@ async function render(run) {
     const blocks = prior.blocks + 1;
     const decisionNow = mayBlock({
       reviewedFileCount: codeDelta.files.length,
-      staticFindingCount: run.staticResults?.findings?.length ?? 0,
+      staticFindingCount: run2.staticResults?.findings?.length ?? 0,
       cycleCutFired: silenced !== null,
       attempts,
       blocks,
@@ -21363,7 +22333,7 @@ async function render(run) {
     });
     emitVerdict({
       proposed: "WARN",
-      changed: run.changedUniverse,
+      changed: run2.changedUniverse,
       coverage: reviewCoverage,
       userSummary: lines.length > 0 ? `${summary}
 ${lines.join("\n")}` : summary,
@@ -21455,7 +22425,7 @@ ${YELLOW}${grantNudge.trim()}${NC}
 `);
       emitVerdict({
         proposed: "FAIL",
-        changed: run.changedUniverse,
+        changed: run2.changedUniverse,
         coverage: reviewCoverage,
         userSummary: "",
         // Subject to the SAME cycle cut as PASS/WARN. Suppressing here is safe:
@@ -21480,7 +22450,7 @@ ${YELLOW}${grantNudge.trim()}${NC}
       userSummary += loginNudge + grantNudge;
       emitVerdict({
         proposed: "PASS",
-        changed: run.changedUniverse,
+        changed: run2.changedUniverse,
         coverage: reviewCoverage,
         userSummary,
         agentContext: silenced ? null : agentContextFor(response, intentRepeatCount, priorPendingFingerprints),
@@ -21502,7 +22472,7 @@ ${YELLOW}${grantNudge.trim()}${NC}
       userSummary += loginNudge + grantNudge;
       emitVerdict({
         proposed: "WARN",
-        changed: run.changedUniverse,
+        changed: run2.changedUniverse,
         coverage: reviewCoverage,
         userSummary,
         agentContext: silenced ? null : agentContextFor(response, intentRepeatCount, priorPendingFingerprints),
@@ -21527,7 +22497,7 @@ ${YELLOW}${grantNudge.trim()}${NC}
       process.exit(0);
     }
   }
-  Object.assign(run, { iteration });
+  Object.assign(run2, { iteration });
 }
 
 // src/commands/analyze/index.ts
@@ -21546,6 +22516,8 @@ var PIPELINE = [
   // ← THE NARROWING. what gets sent, and why not the rest
   ["contextFiles", contextFiles],
   // supporting files, merged INTO the delta array
+  ["repoContext", repoContext],
+  // R1/R3 — call sites of changed symbols, one line each
   ["memoryManifest", memoryManifest],
   // knowledge-graph manifest + one-time auto-seed
   ["foldTranscript", foldTranscript],
@@ -21562,7 +22534,7 @@ var PIPELINE = [
   // say it — stderr, stdout, disk
 ];
 function registerAnalyzeCommand(program2) {
-  program2.command("analyze").description("Run Verity analysis on changed files (stop hook)").option("--debounce <seconds>", "Skip if last analysis was within N seconds", "30").option("--max-iterations <n>", "Force PASS after N FAIL cycles", "2").option("--max-files <n>", "Max files to send for review", "20").option("--max-file-size <bytes>", "Skip files larger than N bytes", "51200").option("--max-total-size <bytes>", "Stop collecting files at N total bytes", "194560").option("--skip-static", "Skip codacy-analysis").option("--mode <mode>", "Force analysis mode (standard|plan|debug|skip)").option("--json", "Output raw JSON response").action(async (opts) => {
+  program2.command("analyze").description("Run Verity analysis on changed files (stop hook)").option("--debounce <seconds>", "Skip if last analysis was within N seconds", String(DEBOUNCE_SECONDS)).option("--max-iterations <n>", "Force PASS after N FAIL cycles", String(MAX_ITERATIONS)).option("--max-files <n>", "Max files to send for review", String(MAX_FILES)).option("--max-file-size <bytes>", "Skip files larger than N bytes", String(MAX_FILE_BYTES)).option("--max-total-size <bytes>", "Stop collecting files at N total bytes", String(MAX_DELTA_BYTES)).option("--skip-static", "Skip codacy-analysis").option("--mode <mode>", "Force analysis mode (standard|plan|debug|skip)").option("--json", "Output raw JSON response").action(async (opts) => {
     const globals = program2.opts();
     try {
       await runAnalyze(opts, globals);
@@ -21577,18 +22549,18 @@ function registerAnalyzeCommand(program2) {
 }
 var tracing = () => process.env.VERITY_TRACE_PHASES === "1";
 async function runAnalyze(opts, globals) {
-  const run = createRun(opts, globals);
-  installRunEvidence(run);
+  const run2 = createRun(opts, globals);
+  installRunEvidence(run2);
   for (const [name, phase] of PIPELINE) {
-    run.phaseReached = name;
+    run2.phaseReached = name;
     if (!tracing()) {
-      await phase(run);
-      run.phasesCompleted.push(name);
+      await phase(run2);
+      run2.phasesCompleted.push(name);
       continue;
     }
     const started = Date.now();
-    await phase(run);
-    run.phasesCompleted.push(name);
+    await phase(run2);
+    run2.phasesCompleted.push(name);
     process.stderr.write(`verity\xB7phase ${name} ${Date.now() - started}ms
 `);
   }
@@ -21691,8 +22663,8 @@ async function runReview(opts, globals) {
     for (const p of specPaths) {
       if (!(0, import_node_fs37.existsSync)(p)) continue;
       try {
-        const { readFileSync: readFileSync24 } = await import("node:fs");
-        const content = readFileSync24(p, "utf-8");
+        const { readFileSync: readFileSync25 } = await import("node:fs");
+        const content = readFileSync25(p, "utf-8");
         specs.push({ path: p, content: content.slice(0, 10240) });
       } catch {
       }
@@ -21961,6 +22933,7 @@ function coverageBlock(c) {
   const tree = c.root ? `${c.root}${c.linked ? " (linked worktree)" : ""}${c.branch ? ` \xB7 branch ${c.branch}` : ""}` : "(no tree resolved)";
   lines.push(`Reviewed (${c.moment}): ${c.sent.length} file(s)${c.range ? ` @ ${c.range}` : ""}`);
   lines.push(`  Tree: ${tree}`);
+  if (c.repoContext) lines.push(`  Repo context: ${describeRepoContext(c.repoContext)}`);
   for (const f of c.sent) lines.push(`  - ${f}`);
   if (c.excluded.length > 0) {
     lines.push(`  Excluded (${c.excluded.length}):`);
@@ -22027,6 +23000,39 @@ async function runGuard(opts, globals) {
     statedIntent,
     buildGuardCoverage(files, codeDelta, frame, range)
   );
+  try {
+    const ig = loadVerityIgnore();
+    const repoContext2 = buildRepoContext({
+      deltaFiles: codeDelta.files,
+      diffs: [],
+      signalsByPath: rangeChangeSignals(frame, range, codeDelta.files.map((f) => f.path)),
+      sentPaths: new Set(codeDelta.files.map((f) => f.path)),
+      isExcluded: (p) => isVerityOwnedPath(p) || isIgnored(ig, p),
+      cwd: frame.worktreeRoot ?? process.cwd()
+    });
+    upgradeToExcerpts(repoContext2, {
+      readFile: (rel) => {
+        try {
+          return (0, import_node_fs38.readFileSync)((0, import_node_path27.join)(frame.worktreeRoot ?? process.cwd(), rel), "utf8");
+        } catch {
+          return null;
+        }
+      }
+    });
+    requestBody.repo_context = repoContext2;
+    logEvent("repo_context", {
+      moment,
+      state: repoContext2.state,
+      reason: repoContext2.reason ?? null,
+      symbols: repoContext2.symbols?.length ?? 0,
+      callers: repoContext2.callers?.length ?? 0,
+      tests: repoContext2.tests?.length ?? 0,
+      excerpts: repoContext2.excerpts?.length ?? 0,
+      elapsed_ms: repoContext2.elapsed_ms ?? null
+    });
+  } catch (e) {
+    logEvent("repo_context", { moment, state: "absent", reason: "exception", message: e.message });
+  }
   const coverage = {
     moment,
     root: frame.worktreeRoot,
@@ -22034,7 +23040,8 @@ async function runGuard(opts, globals) {
     linked: frame.isLinkedWorktree,
     range: describeRange(range),
     sent: codeDelta.files.map((f) => f.path),
-    excluded: codeDelta.excluded.map((e) => ({ path: e.path, reason: e.reason }))
+    excluded: codeDelta.excluded.map((e) => ({ path: e.path, reason: e.reason })),
+    ...requestBody.repo_context ? { repoContext: requestBody.repo_context } : {}
   };
   logToFileOnly(coverageBlock(coverage));
   const reviewStart = Date.now();
@@ -22281,22 +23288,297 @@ function registerWaiveCommand(program2) {
 }
 
 // src/commands/init.ts
-var import_node_fs41 = require("node:fs");
-var import_promises13 = require("node:fs/promises");
+var import_node_fs44 = require("node:fs");
+var import_promises14 = require("node:fs/promises");
 var import_node_path29 = require("node:path");
+var import_node_child_process14 = require("node:child_process");
+
+// src/lib/banner.ts
+var WORDMARK = [
+  "\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557",
+  "\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D",
+  "\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551    \u255A\u2588\u2588\u2588\u2588\u2554\u255D ",
+  "\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551     \u255A\u2588\u2588\u2554\u255D  ",
+  " \u255A\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551      \u2588\u2588\u2551   ",
+  "  \u255A\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D   \u255A\u2550\u255D      \u255A\u2550\u255D   "
+];
+var WORDMARK_NARROW = [
+  "\u2588   \u2588 \u2588\u2580\u2580\u2580\u2580 \u2588\u2580\u2580\u2580\u2584 \u2580\u2580\u2588\u2580\u2580 \u2580\u2580\u2588\u2580\u2580 \u2588   \u2588",
+  "\u2588   \u2588 \u2588\u2580\u2580\u2580  \u2588\u2584\u2584\u2584\u2580   \u2588     \u2588    \u2580\u2584\u2580 ",
+  " \u2580\u2584\u2580  \u2588\u2584\u2584\u2584\u2584 \u2588  \u2580\u2584 \u2584\u2584\u2588\u2584\u2584   \u2588     \u2588  "
+];
+var TAGLINE = "reviews every turn, remembers every lesson";
+var WORDMARK_COLOR = ["\x1B[0;32m"];
+var DIM3 = "\x1B[2m";
+var RESET2 = "\x1B[0m";
+var INDENT = "  ";
+function artWidth(art) {
+  return Math.max(...art.map((r) => r.length)) + INDENT.length;
+}
+function canRenderArt() {
+  return !!process.stderr.isTTY;
+}
+function printBanner(opts) {
+  if (!opts.interactive) return;
+  const columns = opts.columns ?? process.stderr.columns ?? 80;
+  const color = colorEnabled();
+  const version = `v${cliVersion()}`;
+  const art = [WORDMARK, WORDMARK_NARROW].find((a) => artWidth(a) <= columns) ?? null;
+  const dim = (text) => color ? `${DIM3}${text}${RESET2}` : text;
+  process.stderr.write("\n");
+  if (!art) {
+    const candidates = [`Verity ${version}`, "Verity"];
+    const text = candidates.find((c) => c.length + INDENT.length <= columns);
+    if (text) process.stderr.write(`${INDENT}${dim(text)}
+`);
+    process.stderr.write("\n");
+    return;
+  }
+  art.forEach((row2, i) => {
+    const tint = color && WORDMARK_COLOR.length > 0 ? WORDMARK_COLOR[Math.min(i, WORDMARK_COLOR.length - 1)] : "";
+    const reset = color && tint ? RESET2 : "";
+    process.stderr.write(`${INDENT}${tint}${row2}${reset}
+`);
+  });
+  if (TAGLINE.length + INDENT.length <= columns) {
+    process.stderr.write(`${INDENT}${dim(TAGLINE)}
+`);
+  }
+  if (version.length + INDENT.length <= columns) {
+    process.stderr.write(`${INDENT}${dim(version)}
+`);
+  }
+  process.stderr.write("\n");
+}
+function printPhase(n, of, title, subtitle) {
+  const color = colorEnabled();
+  const columns = process.stderr.columns ?? 72;
+  const width = Math.min(columns, 72);
+  const label2 = `\u2500\u2500 Phase ${n} of ${of} \xB7 ${title} `;
+  const rule = label2 + "\u2500".repeat(Math.max(0, width - label2.length - 2));
+  process.stderr.write("\n");
+  process.stderr.write(color ? `  ${DIM3}${rule}${RESET2}
+` : `  ${rule}
+`);
+  if (subtitle && subtitle.length + INDENT.length <= columns) {
+    process.stderr.write(color ? `  ${DIM3}${subtitle}${RESET2}
+` : `  ${subtitle}
+`);
+  }
+  process.stderr.write("\n");
+}
+
+// src/commands/doctor.ts
+var import_node_fs42 = require("node:fs");
+
+// src/lib/prereqs.ts
 var import_node_child_process11 = require("node:child_process");
-var readline2 = __toESM(require("node:readline/promises"));
+var MIN_NODE_MAJOR = 20;
+function which(bin) {
+  try {
+    const out = (0, import_node_child_process11.execSync)(`command -v ${bin}`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+function checkNode() {
+  const version = process.version;
+  const major = Number.parseInt(version.slice(1), 10);
+  const ok = Number.isFinite(major) && major >= MIN_NODE_MAJOR;
+  return {
+    id: "node",
+    label: "Node.js",
+    status: ok ? "ok" : "missing",
+    detail: version,
+    remedy: ok ? void 0 : `Node.js ${MIN_NODE_MAJOR}+ required \u2014 update from https://nodejs.org`,
+    required: true
+  };
+}
+function checkGit() {
+  let detail = "";
+  try {
+    detail = (0, import_node_child_process11.execSync)("git --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    return {
+      id: "git",
+      label: "git",
+      status: "missing",
+      detail: "not found",
+      remedy: "Install git from https://git-scm.com",
+      required: true
+    };
+  }
+  return { id: "git", label: "git", status: "ok", detail, required: true };
+}
+function checkClaude() {
+  const path = which("claude");
+  return {
+    id: "claude",
+    label: "Claude Code",
+    status: path ? "ok" : "warn",
+    detail: path ?? "not found",
+    remedy: path ? void 0 : "Hooks are wired but need Claude Code to fire \u2014 https://claude.com/claude-code",
+    required: false
+  };
+}
+function checkAnalysisCli() {
+  const path = which("codacy-analysis");
+  return {
+    id: "analysis-cli",
+    label: "@codacy/analysis-cli",
+    status: path ? "ok" : "warn",
+    detail: path ?? "not found",
+    remedy: path ? void 0 : "npm install -g @codacy/analysis-cli (static findings are unavailable until then)",
+    required: false
+  };
+}
+var INSTALL_TIMEOUT_MS = 12e4;
+function run(command, args, opts = {}) {
+  return new Promise((resolve4) => {
+    const child = (0, import_node_child_process11.spawn)(command, args, {
+      stdio: opts.inherit ? "inherit" : "pipe",
+      timeout: INSTALL_TIMEOUT_MS
+    });
+    child.on("error", () => resolve4(false));
+    child.on("close", (code) => resolve4(code === 0));
+  });
+}
+async function installAnalysisCli() {
+  const spinner = startSpinner("Installing @codacy/analysis-cli");
+  const ok = await run("npm", ["install", "-g", "@codacy/analysis-cli"]);
+  if (ok) {
+    const check = checkAnalysisCli();
+    if (check.status === "ok") {
+      spinner.succeed("@codacy/analysis-cli installed");
+      return { ...check, justInstalled: true };
+    }
+    spinner.warn("npm reported success but codacy-analysis is not on PATH");
+    return check;
+  }
+  spinner.stop();
+  {
+    const failed = {
+      id: "analysis-cli",
+      label: "@codacy/analysis-cli",
+      status: "warn",
+      detail: "install failed",
+      remedy: "Install manually: npm install -g @codacy/analysis-cli",
+      required: false
+    };
+    if (!process.stdin.isTTY || !process.stdout.isTTY) return failed;
+    process.stderr.write("  Retrying with sudo (you may be asked for your password)\u2026\n");
+    const sudoOk = await run("sudo", ["npm", "install", "-g", "@codacy/analysis-cli"], { inherit: true });
+    if (!sudoOk) return failed;
+    const check = checkAnalysisCli();
+    return check.status === "ok" ? { ...check, justInstalled: true } : check;
+  }
+}
+async function checkPrereqs(opts = {}) {
+  const checks = [checkNode(), checkGit(), checkClaude()];
+  let analysis = checkAnalysisCli();
+  if (analysis.status !== "ok" && opts.install) {
+    analysis = await installAnalysisCli();
+  }
+  checks.push(analysis);
+  return { checks, blocked: checks.some((c) => c.required && c.status !== "ok") };
+}
 
-// src/commands/migrate.ts
+// src/lib/telemetry.ts
+var import_promises12 = require("node:fs/promises");
+
+// src/lib/gitignore.ts
+var import_node_child_process12 = require("node:child_process");
 var import_node_fs40 = require("node:fs");
-var import_node_path28 = require("node:path");
-var import_node_child_process10 = require("node:child_process");
+var VERITY_GITIGNORE_MARKER = "# Verity \u2014 machine-local state.";
+var SETTINGS_LOCAL_IGNORE_ENTRY = ".claude/settings.local.json";
+var VERITY_GITIGNORE_BLOCK = [
+  "# Verity \u2014 machine-local state. Everything in .verity/ is ignored EXCEPT the",
+  "# shared standard and the knowledge graph, which are meant to be committed.",
+  ".verity/*",
+  "!.verity/standard.yaml",
+  "!.verity/memory/",
+  ".verity/memory/log.md",
+  SETTINGS_LOCAL_IGNORE_ENTRY,
+  ""
+].join("\n");
+var BREAKING_ENTRIES = /* @__PURE__ */ new Set([".verity/", ".verity"]);
+function isIgnored2(path) {
+  try {
+    (0, import_node_child_process12.execSync)(`git check-ignore -q -- "${path}"`, { stdio: "pipe" });
+    return true;
+  } catch (err) {
+    return err.status === 1 ? false : null;
+  }
+}
+function semanticsHold() {
+  const snapshot = isIgnored2(".verity/.snapshot/__probe__");
+  const standard = isIgnored2(".verity/standard.yaml");
+  const node = isIgnored2(".verity/memory/domain/__probe__.md");
+  const futureState = isIgnored2(".verity/.__probe-future-state__");
+  if (snapshot === null || standard === null || node === null || futureState === null) return null;
+  return snapshot === true && futureState === true && standard === false && node === false;
+}
+function ensureVerityGitignore() {
+  let content = "";
+  try {
+    content = (0, import_node_fs40.readFileSync)(".gitignore", "utf-8");
+  } catch {
+  }
+  const hasMarker = content.includes(VERITY_GITIGNORE_MARKER);
+  const lines = content.split("\n");
+  const breakingCount = lines.filter((l) => BREAKING_ENTRIES.has(l.trim())).length;
+  const needsRepair = breakingCount > 0;
+  const verified = (result) => semanticsHold() === false ? "conflict" : result;
+  if (hasMarker && !needsRepair) return verified("covered");
+  if (!hasMarker && !needsRepair) {
+    if (semanticsHold() === true) return "covered";
+  }
+  try {
+    let next = content;
+    if (needsRepair) {
+      next = lines.map((l) => BREAKING_ENTRIES.has(l.trim()) ? ".verity/*" : l).join("\n");
+    }
+    if (!hasMarker) {
+      const sep2 = next === "" ? "" : next.endsWith("\n") ? "\n" : "\n\n";
+      next = next + sep2 + VERITY_GITIGNORE_BLOCK;
+    }
+    (0, import_node_fs40.writeFileSync)(".gitignore", next);
+    return verified(needsRepair ? "repaired" : "added");
+  } catch {
+    return "failed";
+  }
+}
+function committedVerityState() {
+  let out = "";
+  try {
+    out = (0, import_node_child_process12.execSync)("git ls-files -z -- .verity", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+  } catch {
+    return [];
+  }
+  return out.split("\0").filter(Boolean).filter((p) => p !== ".verity/standard.yaml" && !(p.startsWith(".verity/memory/") && p !== ".verity/memory/log.md"));
+}
+function untrackVerityState() {
+  const tracked = committedVerityState();
+  if (tracked.length === 0) return "none";
+  try {
+    (0, import_node_child_process12.execSync)("git rm -r --cached --quiet -- .verity", { stdio: "pipe" });
+    for (const keep of [".verity/standard.yaml", ".verity/memory"]) {
+      try {
+        (0, import_node_child_process12.execSync)(`git add -- "${keep}"`, { stdio: "pipe" });
+      } catch {
+      }
+    }
+    return "untracked";
+  } catch {
+    return "failed";
+  }
+}
 
 // src/lib/telemetry.ts
-var import_promises12 = require("node:fs/promises");
 var SETTINGS_LOCAL_FILE2 = ".claude/settings.local.json";
 var GITIGNORE_FILE = ".gitignore";
-var GITIGNORE_ENTRY = ".claude/settings.local.json";
+var GITIGNORE_ENTRY = SETTINGS_LOCAL_IGNORE_ENTRY;
 var OTEL_HEADERS_HELPER_CMD = "verity telemetry headers";
 var LEGACY_TELEMETRY_ENV_KEYS = ["OTEL_EXPORTER_OTLP_HEADERS"];
 function deriveOtlpEndpoint(serviceUrl) {
@@ -22382,14 +23664,119 @@ async function uninstallTelemetry() {
   return { ok: true, data: { removed } };
 }
 
+// src/lib/setup-state.ts
+var import_promises13 = require("node:fs/promises");
+var import_node_fs41 = require("node:fs");
+var SETUP_STATE_FILE = `${VERITY_DIR}/setup.json`;
+async function readSetupState() {
+  const path = projectPath(SETUP_STATE_FILE);
+  if (!(0, import_node_fs41.existsSync)(path)) return null;
+  try {
+    const parsed = JSON.parse(await (0, import_promises13.readFile)(path, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function writeSetupState(patch) {
+  const current = await readSetupState() ?? { version: 1 };
+  const next = { ...current, ...patch, version: 1 };
+  await writeJsonFilePreservingStyle(projectPath(SETUP_STATE_FILE), next);
+  return next;
+}
+
+// src/commands/doctor.ts
+async function buildReport() {
+  const prereqs = await checkPrereqs({ install: false });
+  const state = await readSetupState();
+  const hooks = await checkAllVerityHooks();
+  const telemetry = await checkTelemetry();
+  const artifacts = {
+    standard: (0, import_node_fs42.existsSync)(projectPath(STANDARD_FILE)),
+    analysisConfig: (0, import_node_fs42.existsSync)(projectPath(CODACY_CONFIG_FILE)),
+    verityMd: (0, import_node_fs42.existsSync)(projectPath(VERITY_MD_FILE))
+  };
+  const next = [];
+  for (const c of prereqs.checks) {
+    if (c.status !== "ok" && c.remedy) next.push(c.remedy);
+  }
+  if (!state?.init) next.push('Run "verity init" \u2014 the deterministic setup phase has not completed here.');
+  if (!artifacts.standard || !artifacts.analysisConfig || !artifacts.verityMd) {
+    next.push("Run /verity-setup in Claude Code \u2014 the Standard, analysis config, and VERITY.md are synthesized there.");
+  }
+  const noAnalysisMoment = !hooks.stop && hooks.guardOn.length === 0;
+  if (noAnalysisMoment) {
+    next.push('No analysis moment is active \u2014 run "verity hooks install --moments stop" or re-run "verity init".');
+  }
+  if (state?.telemetry === "deferred") {
+    next.push('Telemetry was requested but needs a token \u2014 run "verity login", then "verity telemetry install".');
+  }
+  return {
+    prerequisites: prereqs.checks,
+    blocked: prereqs.blocked,
+    phases: {
+      init: { done: !!state?.init, ...state?.init ?? {} },
+      setup: { done: artifacts.standard && artifacts.analysisConfig && artifacts.verityMd }
+    },
+    answers: {
+      intensity: state?.intensity ?? null,
+      moments: state?.moments ?? null,
+      telemetry: state?.telemetry ?? null
+    },
+    hooks: { ...hooks, noAnalysisMoment },
+    telemetry: { enabled: telemetry.enabled, endpoint: telemetry.endpoint },
+    artifacts,
+    next
+  };
+}
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("Report prerequisites, setup phase, hooks, and what is still missing").option("--json", "Output the full report as JSON (what /verity-setup reads)").action(async (opts) => {
+    const report = await buildReport();
+    if (opts.json) {
+      printJson(report);
+      if (report.blocked) process.exit(1);
+      return;
+    }
+    printInfo("Prerequisites:");
+    for (const c of report.prerequisites) {
+      if (c.status === "ok") printInfo(`  ${c.label} ${c.detail} \u2713`);
+      else printWarn(`  ${c.label}: ${c.detail}${c.remedy ? ` \u2014 ${c.remedy}` : ""}`);
+    }
+    printInfo("Setup:");
+    printInfo(`  verity init: ${report.phases.init.done ? `done ${report.phases.init.completed_at ?? ""}`.trim() : "NOT run here"}`);
+    printInfo(`  /verity-setup: ${report.phases.setup.done ? "done" : "not completed"}`);
+    printInfo(`  intensity: ${report.answers.intensity ?? "\u2014"}    moments: ${report.answers.moments?.join(", ") ?? "\u2014"}`);
+    printInfo("Hooks:");
+    printInfo(`  Stop (verity analyze): ${report.hooks.stop ? "on" : "off"}`);
+    printInfo(`  Git-moment gate: ${report.hooks.guardOn.length ? report.hooks.guardOn.join(", ") : "off"}`);
+    printInfo(`  Infra (intent/baseline/compact/session-end): ${[report.hooks.intent, report.hooks.baseline, report.hooks.compact, report.hooks.sessionEnd].filter(Boolean).length}/4`);
+    printInfo(`Telemetry: ${report.telemetry.enabled ? `enabled \u2192 ${report.telemetry.endpoint}` : "disabled"}`);
+    printInfo("Artifacts:");
+    printInfo(`  .verity/standard.yaml: ${report.artifacts.standard ? "\u2713" : "missing"}`);
+    printInfo(`  .codacy/codacy.config.json: ${report.artifacts.analysisConfig ? "\u2713" : "missing"}`);
+    printInfo(`  VERITY.md: ${report.artifacts.verityMd ? "\u2713" : "missing"}`);
+    if (report.next.length > 0) {
+      console.log("");
+      printWarn("Next:");
+      for (const n of report.next) printWarn(`  - ${n}`);
+    } else {
+      printInfo("Setup is complete.");
+    }
+    if (report.blocked) process.exit(1);
+  });
+}
+
 // src/commands/migrate.ts
+var import_node_fs43 = require("node:fs");
+var import_node_path28 = require("node:path");
+var import_node_child_process13 = require("node:child_process");
 var LEGACY_NPM_PACKAGE = "@codacy/gate-cli";
 function defaultNpmRemover(pkg) {
-  (0, import_node_child_process10.execSync)(`npm rm -g ${pkg}`, { stdio: "pipe", timeout: 12e4 });
+  (0, import_node_child_process13.execSync)(`npm rm -g ${pkg}`, { stdio: "pipe", timeout: 12e4 });
 }
 function isGitTracked(cwd, relPath) {
   try {
-    (0, import_node_child_process10.execSync)(`git ls-files --error-unmatch ${relPath}`, { cwd, stdio: "pipe" });
+    (0, import_node_child_process13.execSync)(`git ls-files --error-unmatch ${relPath}`, { cwd, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -22397,7 +23784,7 @@ function isGitTracked(cwd, relPath) {
 }
 function isGitRepo(cwd) {
   try {
-    (0, import_node_child_process10.execSync)("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
+    (0, import_node_child_process13.execSync)("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -22420,10 +23807,10 @@ async function runMigration(opts = {}) {
 function migrateProjectDir(root, actions) {
   const gateDir = (0, import_node_path28.join)(root, ".gate");
   const verityDir = (0, import_node_path28.join)(root, ".verity");
-  if ((0, import_node_fs40.existsSync)(gateDir) && !(0, import_node_fs40.existsSync)(verityDir)) {
+  if ((0, import_node_fs43.existsSync)(gateDir) && !(0, import_node_fs43.existsSync)(verityDir)) {
     return migrateProjectDirRename(root, gateDir, verityDir, actions);
   }
-  if ((0, import_node_fs40.existsSync)(gateDir) && (0, import_node_fs40.existsSync)(verityDir)) {
+  if ((0, import_node_fs43.existsSync)(gateDir) && (0, import_node_fs43.existsSync)(verityDir)) {
     return migrateProjectDirCarry(gateDir, verityDir, actions);
   }
   return false;
@@ -22437,20 +23824,20 @@ function migrateProjectDirRename(root, gateDir, verityDir, actions) {
       );
     }
     try {
-      (0, import_node_child_process10.execSync)("git mv .gate .verity", { cwd: root, stdio: "pipe" });
+      (0, import_node_child_process13.execSync)("git mv .gate .verity", { cwd: root, stdio: "pipe" });
       actions.push("Moved .gate/ \u2192 .verity/ (git mv, staged)");
       moved = true;
     } catch {
     }
   }
   if (moved) {
-    if ((0, import_node_fs40.existsSync)(gateDir)) {
+    if ((0, import_node_fs43.existsSync)(gateDir)) {
       const carried = carryLegacyContents(gateDir, verityDir);
       if (carried > 0) {
         actions.push(`Carried ${carried} untracked legacy file(s) from .gate/ into .verity/`);
       }
       try {
-        (0, import_node_fs40.rmSync)(gateDir, { recursive: true, force: true });
+        (0, import_node_fs43.rmSync)(gateDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -22466,7 +23853,7 @@ function migrateProjectDirCarry(gateDir, verityDir, actions) {
     actions.push(`Carried ${carried} legacy file(s) from .gate/ into .verity/`);
   }
   try {
-    (0, import_node_fs40.rmSync)(gateDir, { recursive: true, force: true });
+    (0, import_node_fs43.rmSync)(gateDir, { recursive: true, force: true });
   } catch {
   }
   return carried > 0;
@@ -22475,9 +23862,9 @@ function migrateGlobalCredentials(home, actions) {
   if (!home) return;
   const gateCreds = (0, import_node_path28.join)(home, ".gate", "credentials");
   const verityCreds = (0, import_node_path28.join)(home, ".verity", "credentials");
-  if (!(0, import_node_fs40.existsSync)(gateCreds)) return;
-  if (!(0, import_node_fs40.existsSync)(verityCreds)) {
-    (0, import_node_fs40.mkdirSync)((0, import_node_path28.join)(home, ".verity"), { recursive: true });
+  if (!(0, import_node_fs43.existsSync)(gateCreds)) return;
+  if (!(0, import_node_fs43.existsSync)(verityCreds)) {
+    (0, import_node_fs43.mkdirSync)((0, import_node_path28.join)(home, ".verity"), { recursive: true });
     moveFile(gateCreds, verityCreds);
     actions.push("Moved ~/.gate/credentials \u2192 ~/.verity/credentials");
     return;
@@ -22500,7 +23887,7 @@ async function migrateLegacyHooks(root, actions) {
 }
 async function migrateClaudeMd(root, actions) {
   const claudeMd = (0, import_node_path28.join)(root, "CLAUDE.md");
-  const hadLegacyBlock = (0, import_node_fs40.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
+  const hadLegacyBlock = (0, import_node_fs43.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
   if (!hadLegacyBlock) return;
   try {
     await ensureClaudeMdPointer(root);
@@ -22512,11 +23899,11 @@ async function migrateClaudeMd(root, actions) {
 function migrateStandardFile(root, actions) {
   const gateMd = (0, import_node_path28.join)(root, "GATE.md");
   const verityMd = (0, import_node_path28.join)(root, "VERITY.md");
-  if (!(0, import_node_fs40.existsSync)(gateMd) || (0, import_node_fs40.existsSync)(verityMd)) return;
+  if (!(0, import_node_fs43.existsSync)(gateMd) || (0, import_node_fs43.existsSync)(verityMd)) return;
   let moved = false;
   if (isGitRepo(root) && isGitTracked(root, "GATE.md")) {
     try {
-      (0, import_node_child_process10.execSync)("git mv GATE.md VERITY.md", { cwd: root, stdio: "pipe" });
+      (0, import_node_child_process13.execSync)("git mv GATE.md VERITY.md", { cwd: root, stdio: "pipe" });
       moved = true;
     } catch {
     }
@@ -22524,12 +23911,12 @@ function migrateStandardFile(root, actions) {
   if (!moved) moveFile(gateMd, verityMd);
   const content = readFileSyncSafe(verityMd);
   const refreshed = content.split("GATE.md").join("VERITY.md");
-  if (refreshed !== content) (0, import_node_fs40.writeFileSync)(verityMd, refreshed);
+  if (refreshed !== content) (0, import_node_fs43.writeFileSync)(verityMd, refreshed);
   actions.push("Renamed GATE.md \u2192 VERITY.md");
 }
 async function migrateTelemetryHeaders(root, actions) {
   const file = (0, import_node_path28.join)(root, ".claude", "settings.local.json");
-  if (!(0, import_node_fs40.existsSync)(file)) return;
+  if (!(0, import_node_fs43.existsSync)(file)) return;
   let settings;
   try {
     settings = JSON.parse(readFileSyncSafe(file) || "{}");
@@ -22577,21 +23964,21 @@ function mergeGlobalCredentials(gateCreds, verityCreds) {
   }
   if (toAppend.length > 0) {
     const sep2 = verityContent.endsWith("\n") || verityContent === "" ? "" : "\n";
-    (0, import_node_fs40.writeFileSync)(verityCreds, verityContent + sep2 + toAppend.join("\n") + "\n");
+    (0, import_node_fs43.writeFileSync)(verityCreds, verityContent + sep2 + toAppend.join("\n") + "\n");
   }
-  (0, import_node_fs40.rmSync)(gateCreds, { force: true });
+  (0, import_node_fs43.rmSync)(gateCreds, { force: true });
   return toAppend.length;
 }
 function readFileSyncSafe(path) {
   try {
-    return (0, import_node_fs40.readFileSync)(path, "utf-8");
+    return (0, import_node_fs43.readFileSync)(path, "utf-8");
   } catch {
     return "";
   }
 }
 function hasStagedChanges(root) {
   try {
-    (0, import_node_child_process10.execSync)("git diff --cached --quiet", { cwd: root, stdio: "pipe" });
+    (0, import_node_child_process13.execSync)("git diff --cached --quiet", { cwd: root, stdio: "pipe" });
     return false;
   } catch {
     return true;
@@ -22599,35 +23986,35 @@ function hasStagedChanges(root) {
 }
 function moveDir(from, to) {
   try {
-    (0, import_node_fs40.renameSync)(from, to);
+    (0, import_node_fs43.renameSync)(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
-    (0, import_node_fs40.cpSync)(from, to, { recursive: true });
-    (0, import_node_fs40.rmSync)(from, { recursive: true, force: true });
+    (0, import_node_fs43.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs43.rmSync)(from, { recursive: true, force: true });
   }
 }
 function moveFile(from, to) {
   try {
-    (0, import_node_fs40.renameSync)(from, to);
+    (0, import_node_fs43.renameSync)(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
-    (0, import_node_fs40.cpSync)(from, to);
-    (0, import_node_fs40.rmSync)(from, { force: true });
+    (0, import_node_fs43.cpSync)(from, to);
+    (0, import_node_fs43.rmSync)(from, { force: true });
   }
 }
 function carryLegacyContents(gateDir, verityDir) {
   let copied = 0;
   const walk = (relDir) => {
     const srcDir = (0, import_node_path28.join)(gateDir, relDir);
-    for (const entry of (0, import_node_fs40.readdirSync)(srcDir)) {
+    for (const entry of (0, import_node_fs43.readdirSync)(srcDir)) {
       const rel = relDir ? (0, import_node_path28.join)(relDir, entry) : entry;
       const src = (0, import_node_path28.join)(gateDir, rel);
       const dest = (0, import_node_path28.join)(verityDir, rel);
-      if ((0, import_node_fs40.statSync)(src).isDirectory()) {
+      if ((0, import_node_fs43.statSync)(src).isDirectory()) {
         walk(rel);
-      } else if (!(0, import_node_fs40.existsSync)(dest)) {
-        (0, import_node_fs40.mkdirSync)((0, import_node_path28.dirname)(dest), { recursive: true });
-        (0, import_node_fs40.cpSync)(src, dest);
+      } else if (!(0, import_node_fs43.existsSync)(dest)) {
+        (0, import_node_fs43.mkdirSync)((0, import_node_path28.dirname)(dest), { recursive: true });
+        (0, import_node_fs43.cpSync)(src, dest);
         copied++;
       }
     }
@@ -22638,20 +24025,20 @@ function carryLegacyContents(gateDir, verityDir) {
 async function needsMigration(root = repoRoot()) {
   const gateDir = (0, import_node_path28.join)(root, ".gate");
   const verityDir = (0, import_node_path28.join)(root, ".verity");
-  if ((0, import_node_fs40.existsSync)(gateDir) && !(0, import_node_fs40.existsSync)(verityDir)) return true;
-  if ((0, import_node_fs40.existsSync)(gateDir) && (0, import_node_fs40.existsSync)(verityDir)) {
-    if ((0, import_node_fs40.existsSync)((0, import_node_path28.join)(gateDir, "credentials")) && !(0, import_node_fs40.existsSync)((0, import_node_path28.join)(verityDir, "credentials"))) {
+  if ((0, import_node_fs43.existsSync)(gateDir) && !(0, import_node_fs43.existsSync)(verityDir)) return true;
+  if ((0, import_node_fs43.existsSync)(gateDir) && (0, import_node_fs43.existsSync)(verityDir)) {
+    if ((0, import_node_fs43.existsSync)((0, import_node_path28.join)(gateDir, "credentials")) && !(0, import_node_fs43.existsSync)((0, import_node_path28.join)(verityDir, "credentials"))) {
       return true;
     }
-    if ((0, import_node_fs40.existsSync)((0, import_node_path28.join)(gateDir, "memory")) && !(0, import_node_fs40.existsSync)((0, import_node_path28.join)(verityDir, "memory"))) {
+    if ((0, import_node_fs43.existsSync)((0, import_node_path28.join)(gateDir, "memory")) && !(0, import_node_fs43.existsSync)((0, import_node_path28.join)(verityDir, "memory"))) {
       return true;
     }
   }
   const claudeMd = (0, import_node_path28.join)(root, "CLAUDE.md");
-  if ((0, import_node_fs40.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd))) {
+  if ((0, import_node_fs43.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd))) {
     return true;
   }
-  if ((0, import_node_fs40.existsSync)((0, import_node_path28.join)(root, "GATE.md")) && !(0, import_node_fs40.existsSync)((0, import_node_path28.join)(root, "VERITY.md"))) {
+  if ((0, import_node_fs43.existsSync)((0, import_node_path28.join)(root, "GATE.md")) && !(0, import_node_fs43.existsSync)((0, import_node_path28.join)(root, "VERITY.md"))) {
     return true;
   }
   if (await hasLegacyHooksAt(root)) return true;
@@ -22676,17 +24063,96 @@ function registerMigrateCommand(program2) {
   });
 }
 
-// src/commands/init.ts
-async function promptYes(question) {
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
-  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+// src/lib/prompt.ts
+var readline2 = __toESM(require("node:readline/promises"));
+function interactive() {
+  return !!process.stdin.isTTY && !!process.stdout.isTTY;
+}
+async function askLine(question, io = {}) {
+  const rl = readline2.createInterface({
+    input: io.input ?? process.stdin,
+    output: io.output ?? process.stdout
+  });
   try {
-    const answer = (await rl.question(question)).trim().toLowerCase();
-    return answer === "" || answer === "y" || answer === "yes";
+    return await new Promise((resolve4) => {
+      rl.question(question).then((a) => resolve4(a.trim())).catch(() => resolve4(null));
+      rl.once("close", () => setImmediate(() => resolve4(null)));
+    });
   } finally {
     rl.close();
   }
 }
+var ask = (question) => askLine(question);
+function parseChoice(answer, choices, fallback) {
+  const a = answer.trim().toLowerCase();
+  if (a === "") return { id: fallback, recognized: true };
+  const byNumber = Number.parseInt(a, 10);
+  if (Number.isInteger(byNumber) && byNumber >= 1 && byNumber <= choices.length) {
+    return { id: choices[byNumber - 1].id, recognized: true };
+  }
+  const byId = choices.find((c) => c.id.toLowerCase() === a || c.label.toLowerCase() === a);
+  if (byId) return { id: byId.id, recognized: true };
+  return { id: fallback, recognized: false };
+}
+function parseMultiSelect(answer, choices, fallback) {
+  const a = answer.trim().toLowerCase();
+  if (a === "") return { ids: [...fallback], recognized: true };
+  const picked = /* @__PURE__ */ new Set();
+  for (const part of a.split(",").map((s) => s.trim()).filter(Boolean)) {
+    const n = Number.parseInt(part, 10);
+    if (Number.isInteger(n) && n >= 1 && n <= choices.length) {
+      picked.add(choices[n - 1].id);
+      continue;
+    }
+    const byId = choices.find((c) => c.id.toLowerCase() === part || c.label.toLowerCase() === part);
+    if (byId) picked.add(byId.id);
+  }
+  if (picked.size === 0) return { ids: [...fallback], recognized: false };
+  return { ids: choices.filter((c) => picked.has(c.id)).map((c) => c.id), recognized: true };
+}
+async function promptYes(question, opts) {
+  if (!interactive()) return opts.nonInteractive;
+  const answer = await ask(question);
+  if (answer === null) return opts.nonInteractive;
+  const a = answer.toLowerCase();
+  return a === "" || a === "y" || a === "yes";
+}
+function printOptions(question, choices) {
+  console.log("");
+  console.log(`  ${question}`);
+  choices.forEach((c, i) => {
+    const tag = c.recommended ? " (recommended)" : "";
+    console.log(`    ${i + 1}. ${c.label}${tag}${c.hint ? ` \u2014 ${c.hint}` : ""}`);
+  });
+}
+async function promptChoice(question, choices, fallback) {
+  if (!interactive()) return fallback;
+  printOptions(question, choices);
+  const defaultIdx = choices.findIndex((c) => c.id === fallback);
+  const answer = await ask(`  Choose [${defaultIdx + 1}]: `);
+  if (answer === null) {
+    console.log(`  (no answer \u2014 using ${fallback})`);
+    return fallback;
+  }
+  const parsed = parseChoice(answer, choices, fallback);
+  if (!parsed.recognized) console.log(`  Unrecognized answer "${answer}" \u2014 using ${fallback}.`);
+  return parsed.id;
+}
+async function promptMultiSelect(question, choices, fallback) {
+  if (!interactive()) return [...fallback];
+  printOptions(question, choices);
+  const defaultLabel = choices.map((c, i) => fallback.includes(c.id) ? String(i + 1) : null).filter(Boolean).join(",");
+  const answer = await ask(`  Choose one or more, comma-separated [${defaultLabel}]: `);
+  if (answer === null) {
+    console.log("  (no answer \u2014 using the default)");
+    return [...fallback];
+  }
+  const parsed = parseMultiSelect(answer, choices, fallback);
+  if (!parsed.recognized) console.log(`  Unrecognized answer "${answer}" \u2014 using the default.`);
+  return parsed.ids;
+}
+
+// src/commands/init.ts
 async function confirmExistingLogin(serviceUrl, remote, opts) {
   const existing = await resolveToken(opts.token);
   if (!existing.ok) return "drive-login";
@@ -22744,7 +24210,7 @@ async function runOptionalAuth(resolution, opts = {}) {
   }
   let remote = "";
   try {
-    remote = (0, import_node_child_process11.execSync)("git remote get-url origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    remote = (0, import_node_child_process14.execSync)("git remote get-url origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
   }
   if (!healed) {
@@ -22755,7 +24221,7 @@ async function runOptionalAuth(resolution, opts = {}) {
     printInfo("Verity runs in local-only mode: the gate still runs and shows static findings, but nothing uploads.");
     printInfo('  Authenticate anytime: run "verity login" (one login covers every repo you can write to).');
   };
-  if (process.stdin.isTTY && process.stdout.isTTY) {
+  if (interactive() && !opts.yes) {
     console.log("");
     console.log("  Signing in is optional. What it does:");
     console.log("    - Confirms which repositories you can write to. The GitHub token is");
@@ -22770,9 +24236,12 @@ async function runOptionalAuth(resolution, opts = {}) {
     console.log("      findings, but nothing is uploaded.");
     console.log("");
   }
-  const wantsAuth = await promptYes("Authenticate with GitHub now to upload results to Verity? [Y/skip] ");
+  const wantsAuth = opts.yes ? false : await promptYes(
+    "Authenticate with GitHub now to upload results to Verity? [Y/skip] ",
+    { nonInteractive: false }
+  );
   if (!wantsAuth) {
-    printInfo("Skipped authentication.");
+    printInfo(opts.yes ? "Skipped authentication (unattended run)." : "Skipped authentication.");
     localOnlyNote();
     return;
   }
@@ -22795,7 +24264,7 @@ function resolveDataDir() {
     // local dev: running from repo root
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs41.existsSync)((0, import_node_path29.join)(candidate, "skills"))) {
+    if ((0, import_node_fs44.existsSync)((0, import_node_path29.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -22804,22 +24273,197 @@ function resolveDataDir() {
   );
 }
 async function copyDir(src, dest) {
-  await (0, import_promises13.mkdir)(dest, { recursive: true });
-  await (0, import_promises13.cp)(src, dest, { recursive: true, force: true });
+  await (0, import_promises14.mkdir)(dest, { recursive: true });
+  await (0, import_promises14.cp)(src, dest, { recursive: true, force: true });
+}
+async function skillIsCurrent(src, dest) {
+  const list2 = (dir) => {
+    const out = [];
+    const walk = (d, prefix) => {
+      for (const e of (0, import_node_fs44.readdirSync)(d, { withFileTypes: true })) {
+        const rel = prefix ? `${prefix}/${e.name}` : e.name;
+        if (e.isDirectory()) walk((0, import_node_path29.join)(d, e.name), rel);
+        else if (e.isFile()) out.push(rel);
+      }
+    };
+    walk(dir, "");
+    return out.sort();
+  };
+  try {
+    const shipped = list2(src);
+    if (JSON.stringify(shipped) !== JSON.stringify(list2(dest))) return false;
+    for (const rel of shipped) {
+      const a = await (0, import_promises14.readFile)((0, import_node_path29.join)(src, rel), "utf-8");
+      const b = await (0, import_promises14.readFile)((0, import_node_path29.join)(dest, rel), "utf-8");
+      if (a !== b) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+var SKILLS = [
+  "verity-setup",
+  "verity-analyze",
+  "verity-status",
+  "verity-feedback",
+  "verity-learn",
+  "verity-memory",
+  "verity-insights",
+  "verity-reflect"
+];
+var INTENSITY_CHOICES = [
+  { id: "lightweight", label: "lightweight", hint: "critical security only, fastest (~3s)" },
+  { id: "balanced", label: "balanced", hint: "security + quality (~8s)", recommended: true },
+  { id: "thorough", label: "thorough", hint: "all tools, all rules (~15s)" }
+];
+var MOMENT_CHOICES = [
+  { id: "stop", label: "On stop", hint: "after every agent turn \u2014 fast feedback while you work", recommended: true },
+  { id: "pre-commit", label: "Before commit", hint: "reviews the staged diff, blocks the commit on FAIL" },
+  { id: "pre-push", label: "Before push / PR", hint: "reviews the to-be-pushed commits, blocks on FAIL" }
+];
+var DEFAULT_MOMENTS = ["stop"];
+async function askSetupQuestions(defaultsOnly, previous) {
+  const intensityDefault = previous?.intensity ?? "balanced";
+  const momentsDefault = previous?.moments?.length ? previous.moments : DEFAULT_MOMENTS;
+  if (defaultsOnly) {
+    return { intensity: intensityDefault, moments: momentsDefault, telemetry: "not-asked" };
+  }
+  if (previous?.intensity || previous?.moments) {
+    printInfo(`Current: ${intensityDefault} \xB7 ${momentsDefault.join(", ")} \u2014 press Enter to keep either.`);
+  }
+  const intensity = await promptChoice(
+    "Analysis intensity \u2014 how deeply should Verity review?",
+    INTENSITY_CHOICES,
+    intensityDefault
+  );
+  const moments = await promptMultiSelect(
+    "When should Verity review your code?",
+    MOMENT_CHOICES,
+    momentsDefault
+  );
+  const current = await checkTelemetry();
+  if (current.enabled) {
+    printInfo(`Cost & usage telemetry: already enabled \u2192 ${current.endpoint}`);
+    printInfo('  (turn it off with "verity telemetry uninstall")');
+    return { intensity, moments, telemetry: "already-on" };
+  }
+  console.log("");
+  console.log("  Cost & usage telemetry (opt-in) \u2014 powers the /usage dashboard.");
+  console.log("    Sends Claude Code's own OpenTelemetry metrics and traces only: model names,");
+  console.log("    token counts, USD cost, agent types, session ids. NOT your prompts, code, or");
+  console.log("    tool input/output. Without it, /usage stays empty.");
+  const wants = await promptYes("  Enable cost & usage telemetry? [Y/n] ", { nonInteractive: false });
+  return { intensity, moments, telemetry: wants ? "yes" : "no" };
+}
+function insideClaudeCode() {
+  return !!process.env.CLAUDECODE || !!process.env.CLAUDE_SESSION_ID;
+}
+function resumeDeferredPending(previous) {
+  return previous?.telemetry === "deferred";
+}
+var PHASE_TWO_ARTIFACTS = [
+  {
+    path: ".verity/standard.yaml",
+    what: "the Standard, synthesized from your codebase",
+    // The presence flag travels WITH the row. Read positionally from a parallel
+    // array, a reorder of this list would silently move every ✓ onto the wrong
+    // path — a report that is confidently wrong about what got created.
+    present: (a) => a.standard
+  },
+  {
+    path: ".codacy/codacy.config.json",
+    what: "curated static-analysis patterns",
+    present: (a) => a.analysisConfig
+  },
+  {
+    path: "VERITY.md",
+    what: "project quality overview",
+    present: (a) => a.verityMd
+  }
+];
+async function reportPhaseTwo(startedAt) {
+  const elapsed = Math.round((Date.now() - startedAt) / 1e3);
+  let report = null;
+  try {
+    report = await buildReport();
+  } catch {
+  }
+  console.log("");
+  if (!report) {
+    printWarn('Could not verify what the setup session produced \u2014 run "verity doctor".');
+    return;
+  }
+  const { artifacts } = report;
+  const complete = PHASE_TWO_ARTIFACTS.every((a) => a.present(artifacts));
+  printInfo(complete ? `Setup complete (${elapsed}s).` : `Setup session ended after ${elapsed}s.`);
+  for (const { path, what, present } of PHASE_TWO_ARTIFACTS) {
+    const ok = present(artifacts);
+    console.log(`    ${ok ? "\u2713" : "\xB7"} ${path.padEnd(30)} ${ok ? what : `${what} \u2014 NOT created`}`);
+  }
+  if (!complete) {
+    console.log("");
+    printWarn('Setup did not finish. Re-run "/verity-setup" in Claude Code to complete it \u2014');
+    printWarn("  nothing is lost; it picks up from what is already on disk.");
+  }
+}
+async function handoffToSetup(enabled, claudeInstalled) {
+  const instruct = (why) => {
+    console.log("");
+    printInfo("Still to do \u2014 this is what /verity-setup does (it needs a model):");
+    for (const { path, what } of PHASE_TWO_ARTIFACTS) {
+      console.log(`    ${path.padEnd(30)} ${what}`);
+    }
+    console.log("");
+    printInfo("Next step: run /verity-setup in Claude Code.");
+    printInfo(`  (${why})`);
+  };
+  if (!enabled) return instruct("--no-setup was passed");
+  if (insideClaudeCode()) return instruct("you are already in a Claude Code session \u2014 invoke the skill there");
+  if (!interactive()) return instruct("no interactive terminal here");
+  if (!claudeInstalled) return instruct("Claude Code is not installed on this machine yet");
+  printPhase(2, 2, "your Standard", "reading the codebase \xB7 synthesizing the Standard \xB7 curating patterns");
+  console.log("  Claude Code takes over the screen from here. It will:");
+  console.log("    \xB7 read your codebase \u2014 languages, frameworks, architecture");
+  console.log("    \xB7 synthesize .verity/standard.yaml and show it to you");
+  console.log("    \xB7 write the analysis config, then VERITY.md");
+  console.log("  Usually a minute or two. Quit any time \u2014 re-running /verity-setup resumes.");
+  console.log("");
+  const startedAt = Date.now();
+  const run2 = (0, import_node_child_process14.spawnSync)("claude", ["/verity-setup"], { stdio: "inherit" });
+  if (run2.error) {
+    printWarn(`Could not start Claude Code: ${run2.error.message}`);
+    return instruct("start it yourself and run the skill there");
+  }
+  await reportPhaseTwo(startedAt);
 }
 function registerInitCommand(program2) {
-  program2.command("init").description("Initialize Verity in the current project").option("--force", "Overwrite existing skills and hooks").action(async (opts) => {
+  program2.command("init").alias("setup").description("Set up Verity in the current project (asks the setup questions, then hands off to /verity-setup)").option("--force", "Reinstall the skills even when they are already up to date (hooks are always reconciled)").option("-y, --yes", "Take the recommended answer for every question (no prompts)").option("--no-setup", "Skip the /verity-setup handoff at the end").action(async (opts) => {
     const force = opts.force ?? false;
+    const wantsHandoff = opts.setup !== false;
+    const defaultsOnly = (opts.yes ?? false) || !interactive();
     const projectMarkers = [".git", "package.json", "pyproject.toml", "go.mod", "Cargo.toml", "Gemfile", "pom.xml", "build.gradle"];
-    const isProject = projectMarkers.some((m) => (0, import_node_fs41.existsSync)(m));
+    const isProject = projectMarkers.some((m) => (0, import_node_fs44.existsSync)(m));
     if (!isProject) {
       printError("No project detected in the current directory.");
       printInfo('Run "verity init" from your project root.');
       process.exit(1);
     }
-    console.log("");
-    printInfo("Initializing Verity in this project...");
-    console.log("");
+    const showArt = canRenderArt() && !insideClaudeCode();
+    printBanner({ interactive: showArt });
+    if (!showArt) {
+      console.log("");
+      printInfo("Initializing Verity in this project...");
+      console.log("");
+    } else {
+      printPhase(1, 2, "this machine", "prerequisites \xB7 skills \xB7 hooks \xB7 sign-in");
+    }
+    const TOTAL_STEPS = 8;
+    let stepNo = 0;
+    const step = (label2) => {
+      stepNo++;
+      printInfo(`${DIM}[${stepNo}/${TOTAL_STEPS}]${NC} ${label2}`);
+    };
     if (await needsMigration()) {
       printInfo("Legacy GATE.md install detected \u2014 migrating to Verity...");
       try {
@@ -22830,143 +24474,171 @@ function registerInitCommand(program2) {
       }
       console.log("");
     }
-    printInfo("Checking prerequisites...");
-    const nodeVersion = process.version;
-    const nodeMajor = parseInt(nodeVersion.slice(1), 10);
-    if (nodeMajor < 20) {
-      printError(`Node.js 20+ required (found ${nodeVersion}). Update from https://nodejs.org`);
-      process.exit(1);
+    step("Checking prerequisites");
+    const prereqs = await checkPrereqs({ install: true });
+    for (const c of prereqs.checks) {
+      if (c.status === "ok") {
+        if (c.justInstalled) continue;
+        printInfo(`  ${c.label} ${c.detail} \u2713`);
+      } else {
+        printWarn(`  ${c.label}: ${c.detail}`);
+        if (c.remedy) printWarn(`    ${c.remedy}`);
+      }
     }
-    printInfo(`  Node.js ${nodeVersion} \u2713`);
-    try {
-      const gitVersion = (0, import_node_child_process11.execSync)("git --version", { encoding: "utf-8" }).trim();
-      printInfo(`  ${gitVersion} \u2713`);
-    } catch {
-      printError("git is required but not installed. Install from https://git-scm.com");
+    if (prereqs.blocked) {
+      printError("A required prerequisite is missing \u2014 cannot continue.");
       process.exit(1);
     }
-    try {
-      (0, import_node_child_process11.execSync)("which claude", { encoding: "utf-8" });
-      printInfo("  Claude Code \u2713");
-    } catch {
-      printWarn("  Claude Code not found \u2014 hooks will be configured but need Claude Code to run.");
-    }
-    try {
-      (0, import_node_child_process11.execSync)("which codacy-analysis", { encoding: "utf-8", stdio: "pipe" });
-      printInfo("  @codacy/analysis-cli \u2713");
-    } catch {
-      printInfo("  Installing @codacy/analysis-cli...");
-      try {
-        (0, import_node_child_process11.execSync)("npm install -g @codacy/analysis-cli", { encoding: "utf-8", stdio: "pipe", timeout: 12e4 });
-        printInfo("  @codacy/analysis-cli installed \u2713");
-      } catch {
-        try {
-          printWarn("  Retrying with sudo...");
-          (0, import_node_child_process11.execSync)("sudo npm install -g @codacy/analysis-cli", { encoding: "utf-8", stdio: "inherit", timeout: 12e4 });
-          printInfo("  @codacy/analysis-cli installed \u2713");
-        } catch {
-          printWarn("  Could not install @codacy/analysis-cli automatically.");
-          printWarn("  Install manually: npm install -g @codacy/analysis-cli");
-          printWarn("  Static analysis will be unavailable until installed.");
-        }
-      }
-    }
+    const claudeInstalled = prereqs.checks.some((c) => c.id === "claude" && c.status === "ok");
     console.log("");
-    printInfo("Installing skills...");
+    step("Installing skills");
     const dataDir = resolveDataDir();
     const skillsSource = (0, import_node_path29.join)(dataDir, "skills");
     const skillsDest = ".claude/skills";
-    const skills = ["verity-setup", "verity-analyze", "verity-status", "verity-feedback", "verity-learn", "verity-memory", "verity-insights", "verity-reflect"];
     let skillsInstalled = 0;
-    for (const skill of skills) {
+    for (const skill of SKILLS) {
       const src = (0, import_node_path29.join)(skillsSource, skill);
       const dest = (0, import_node_path29.join)(skillsDest, skill);
-      if (!(0, import_node_fs41.existsSync)(src)) {
+      if (!(0, import_node_fs44.existsSync)(src)) {
         printWarn(`  Skill data not found: ${skill}`);
         continue;
       }
-      if ((0, import_node_fs41.existsSync)(dest) && !force) {
-        const srcSkill = (0, import_node_path29.join)(src, "SKILL.md");
-        const destSkill = (0, import_node_path29.join)(dest, "SKILL.md");
-        if ((0, import_node_fs41.existsSync)(destSkill)) {
-          try {
-            const srcContent = await (0, import_promises13.readFile)(srcSkill, "utf-8");
-            const destContent = await (0, import_promises13.readFile)(destSkill, "utf-8");
-            if (srcContent === destContent) {
-              skillsInstalled++;
-              continue;
-            }
-          } catch {
-          }
-        }
+      if ((0, import_node_fs44.existsSync)(dest) && !force && await skillIsCurrent(src, dest)) {
+        skillsInstalled++;
+        continue;
       }
       await copyDir(src, dest);
       skillsInstalled++;
     }
-    printInfo(`  ${skillsInstalled}/${skills.length} skills installed to .claude/skills/ \u2713`);
-    printInfo("Wiring Claude Code hooks...");
-    const present = await checkAllVerityHooks();
-    const settings = await readSettings();
-    const hookResult = installVerityHooks(settings, force, present);
-    if (hookResult.ok) {
-      await writeSettings(hookResult.data);
-      printInfo("  Stop hook: verity analyze \u2713");
-      printInfo("  Intent hook: verity intent capture \u2713");
-      printInfo("  Baseline hook: verity baseline capture \u2713");
-    } else {
-      printWarn(`  ${hookResult.error}`);
-      printInfo('  Run "verity hooks install --force" to overwrite.');
+    printInfo(`  ${skillsInstalled}/${SKILLS.length} skills installed to .claude/skills/ \u2713`);
+    step(defaultsOnly ? "Setup answers (defaults)" : "Your setup answers");
+    const previous = await readSetupState();
+    const answers = await askSetupQuestions(defaultsOnly, previous);
+    const { intensity, moments } = answers;
+    if (defaultsOnly) {
+      printInfo(`  intensity: ${intensity} \xB7 moments: ${moments.join(", ") || "none"} (no questions asked)`);
     }
-    await (0, import_promises13.mkdir)(VERITY_DIR, { recursive: true });
+    step("Knowledge base, .gitignore and CLAUDE.md");
+    await (0, import_promises14.mkdir)(VERITY_DIR, { recursive: true });
     await ensureMemoryDir();
-    const ignoreResult = ensureSnapshotGitignored();
+    const ignoreResult = ensureVerityGitignore();
     if (ignoreResult === "failed") {
-      printWarn("  .gitignore: could not add .verity/.snapshot/ \u2014 add it manually (it holds copies of analyzed files)");
+      printWarn("  .gitignore: could not write the Verity block \u2014 add it manually");
+      printWarn("    (.verity/ holds copies of analyzed files, including any secret the gate flagged)");
+    } else if (ignoreResult === "conflict") {
+      printWarn("  .gitignore: the Verity block is in place but git still ignores .verity/standard.yaml");
+      printWarn("    Something outside this file covers it \u2014 a global (~/.gitignore) or nested");
+      printWarn("    .gitignore, or a pattern we do not recognise. Check: git check-ignore -v .verity/standard.yaml");
+      printWarn("    Until it is fixed, the Standard and the knowledge graph cannot be committed.");
+    } else if (ignoreResult === "repaired") {
+      printInfo("  .gitignore: rewrote `.verity/` to `.verity/*` so the standard stays committable \u2713");
     } else {
-      printInfo(`  .gitignore: .verity/.snapshot/ ${ignoreResult === "added" ? "added" : "already covered"} \u2713`);
+      printInfo(`  .gitignore: Verity block ${ignoreResult === "added" ? "added" : "already covered"} \u2713`);
+    }
+    const tracked = committedVerityState();
+    if (tracked.length > 0) {
+      printWarn(`  ${tracked.length} Verity state file(s) are tracked in git (e.g. ${tracked[0]}).`);
+      const untrack = defaultsOnly ? false : await promptYes("  Untrack them now (files stay on disk)? [Y/n] ", { nonInteractive: false });
+      if (untrack) {
+        const result = untrackVerityState();
+        if (result === "untracked") printInfo("  Untracked (staged) \u2014 commit to finish \u2713");
+        else if (result === "failed") printWarn('  Could not untrack \u2014 run "git rm -r --cached .verity" manually');
+      } else {
+        printWarn("  Left tracked. Fix with: git rm -r --cached .verity && git add .verity/standard.yaml .verity/memory");
+      }
     }
     try {
       await ensureClaudeMdPointer();
-      printInfo("  CLAUDE.md memory pointer \u2713");
+      printInfo("  CLAUDE.md instructions \u2713");
     } catch (err) {
       printWarn(`  Could not update CLAUDE.md: ${err.message}`);
     }
     const globalVerityDir = (0, import_node_path29.join)(process.env.HOME ?? "", ".verity");
-    await (0, import_promises13.mkdir)(globalVerityDir, { recursive: true });
+    await (0, import_promises14.mkdir)(globalVerityDir, { recursive: true });
     console.log("");
+    step("Wiring Claude Code hooks");
+    await applyMomentSelection(moments);
+    const hookStatus = await checkAllVerityHooks();
+    printInfo(`  Stop (verity analyze): ${hookStatus.stop ? "on" : "off"}`);
+    printInfo(`  Pre-commit gate: ${hookStatus.guardOn.includes("commit") ? "on" : "off"}`);
+    printInfo(`  Pre-push/PR gate: ${hookStatus.guardOn.includes("push") ? "on" : "off"}`);
+    printInfo(`  Intent + baseline + compact + session-end: always on \u2713`);
+    if (!hookStatus.stop && hookStatus.guardOn.length === 0) {
+      printWarn("  No analysis moment is active \u2014 code changes will NOT be reviewed.");
+      printWarn("  Enable one: verity hooks install --moments stop");
+    }
+    console.log("");
+    step("Sign in to Verity (optional)");
     try {
       const globals = program2.opts();
       const resolution = await resolveServiceUrlForAuth(globals.serviceUrl);
       await runOptionalAuth(resolution, {
         token: globals.token,
-        verbose: globals.verbose
+        verbose: globals.verbose,
+        yes: defaultsOnly
       });
     } catch (err) {
       printWarn(`Authentication step skipped: ${err.message}`);
     }
+    const resumeDeferred = answers.telemetry === "not-asked" && resumeDeferredPending(previous);
+    const wantsTelemetry = answers.telemetry === "yes" || resumeDeferred;
+    step("Cost & usage telemetry");
+    if (answers.telemetry === "not-asked" && !resumeDeferredPending(previous)) {
+      printInfo('  not asked (unattended run) \u2014 enable later with "verity telemetry install"');
+    } else if (answers.telemetry === "no") {
+      printInfo('  declined \u2014 enable later with "verity telemetry install"');
+    }
+    let telemetryChoice = answers.telemetry === "already-on" ? "enabled" : answers.telemetry === "no" ? "declined" : wantsTelemetry ? "deferred" : void 0;
+    if (wantsTelemetry) {
+      const globals = program2.opts();
+      const token = await resolveToken(globals.token);
+      const url = await resolveServiceUrl(globals.serviceUrl);
+      if (token.ok && url.ok) {
+        const installed2 = await installTelemetry(url.data);
+        if (installed2.ok) {
+          telemetryChoice = "enabled";
+          printInfo(`Telemetry enabled \u2192 ${installed2.data.endpoint}`);
+          printInfo("  takes effect on your NEXT Claude Code session; view cost & usage at /usage");
+        } else {
+          printWarn(`Could not enable telemetry: ${installed2.error}`);
+        }
+      } else {
+        printWarn('Telemetry needs a Verity token \u2014 run "verity login", then "verity telemetry install".');
+      }
+    }
+    step("Recording your answers");
+    try {
+      await writeSetupState({
+        intensity,
+        moments,
+        ...telemetryChoice ? { telemetry: telemetryChoice } : {},
+        init: {
+          completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+          cli_version: true ? "0.31.1-experimental.83a8619" : "dev"
+        }
+      });
+    } catch (err) {
+      printWarn(`Could not record setup answers: ${err.message}`);
+    }
     console.log("");
-    printInfo("Verity initialized!");
+    printInfo("This machine is set up.");
     console.log("");
-    console.log("  Installed:");
-    console.log("    .claude/skills/verity-setup/     \u2014 project configuration");
-    console.log("    .claude/skills/verity-analyze/   \u2014 on-demand analysis");
-    console.log("    .claude/skills/verity-status/    \u2014 project health");
-    console.log("    .claude/skills/verity-feedback/  \u2014 finding feedback + suppressions");
-    console.log("    .claude/skills/verity-learn/     \u2014 view project knowledge");
-    console.log("    .claude/skills/verity-memory/    \u2014 browse knowledge graph");
-    console.log("    .claude/skills/verity-insights/  \u2014 quality metrics + evolution");
-    console.log("    .claude/skills/verity-reflect/   \u2014 capture learnings");
-    console.log("    .claude/settings.json          \u2014 hooks (verity analyze + intent capture)");
-    console.log("    .verity/memory/                  \u2014 knowledge base (8 domains, commit to git)");
+    console.log("    .claude/skills/verity-*/       8 skills (setup, analyze, status, feedback,");
+    console.log("                                   learn, memory, insights, reflect)");
+    console.log("    .claude/settings.json          hooks, reconciled to your chosen moments");
+    console.log("    .verity/memory/                knowledge base (commit to git)");
+    console.log("    .verity/setup.json             your answers, read by /verity-setup");
+    console.log("    .gitignore                     Verity block (whitelist form)");
+    console.log("    CLAUDE.md                      memory pointer, waive policy, reflection");
     console.log("");
-    console.log("  Next step: open this project in Claude Code and run /verity-setup");
-    console.log('  (Not authenticated? Verity runs in local-only mode until you run "verity login".)');
+    console.log(`  Intensity: ${intensity}    Moments: ${moments.join(", ") || "none"}`);
+    await handoffToSetup(wantsHandoff, claudeInstalled);
     console.log("");
   });
 }
 
 // src/commands/uninstall.ts
-var import_node_fs42 = require("node:fs");
+var import_node_fs45 = require("node:fs");
 var import_node_path30 = require("node:path");
 var SKILL_NAMES = [
   "verity-setup",
@@ -22987,10 +24659,10 @@ function registerUninstallCommand(program2) {
     const skillsRoot = projectPath(".claude/skills");
     for (const name of SKILL_NAMES) {
       const dir = (0, import_node_path30.join)(skillsRoot, name);
-      if ((0, import_node_fs42.existsSync)(dir)) {
+      if ((0, import_node_fs45.existsSync)(dir)) {
         actions.push({
           label: `Remove .claude/skills/${name}/`,
-          apply: () => (0, import_node_fs42.rmSync)(dir, { recursive: true, force: true })
+          apply: () => (0, import_node_fs45.rmSync)(dir, { recursive: true, force: true })
         });
       }
     }
@@ -23004,24 +24676,24 @@ function registerUninstallCommand(program2) {
       });
     }
     const verityDir = projectPath(VERITY_DIR);
-    if ((0, import_node_fs42.existsSync)(verityDir)) {
+    if ((0, import_node_fs45.existsSync)(verityDir)) {
       actions.push({
         label: `Remove ${VERITY_DIR}/`,
-        apply: () => (0, import_node_fs42.rmSync)(verityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs45.rmSync)(verityDir, { recursive: true, force: true })
       });
     }
     if (!keepVerityMd) {
       const verityMd = projectPath(VERITY_MD_FILE);
-      if ((0, import_node_fs42.existsSync)(verityMd)) {
+      if ((0, import_node_fs45.existsSync)(verityMd)) {
         actions.push({
           label: `Remove ${VERITY_MD_FILE}`,
-          apply: () => (0, import_node_fs42.rmSync)(verityMd, { force: true })
+          apply: () => (0, import_node_fs45.rmSync)(verityMd, { force: true })
         });
       }
     }
     const cleanupEmptyDir = (path) => {
-      if ((0, import_node_fs42.existsSync)(path) && (0, import_node_fs42.statSync)(path).isDirectory() && (0, import_node_fs42.readdirSync)(path).length === 0) {
-        (0, import_node_fs42.rmdirSync)(path);
+      if ((0, import_node_fs45.existsSync)(path) && (0, import_node_fs45.statSync)(path).isDirectory() && (0, import_node_fs45.readdirSync)(path).length === 0) {
+        (0, import_node_fs45.rmdirSync)(path);
       }
     };
     actions.push({
@@ -23033,10 +24705,10 @@ function registerUninstallCommand(program2) {
     });
     const home = process.env.HOME ?? "";
     const globalVerityDir = (0, import_node_path30.join)(home, ".verity");
-    if (purgeGlobal && (0, import_node_fs42.existsSync)(globalVerityDir)) {
+    if (purgeGlobal && (0, import_node_fs45.existsSync)(globalVerityDir)) {
       actions.push({
         label: `Remove ~/.verity/ (global credentials \u2014 reconnect requires re-registration)`,
-        apply: () => (0, import_node_fs42.rmSync)(globalVerityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs45.rmSync)(globalVerityDir, { recursive: true, force: true })
       });
     }
     if (actions.length === 0) {
@@ -23056,7 +24728,7 @@ function registerUninstallCommand(program2) {
     if (!purgeGlobal) {
       printInfo('Saved tokens at ~/.verity/credentials are preserved \u2014 re-run "verity init" to reconnect.');
     } else {
-      printWarn("Global credentials wiped \u2014 re-register with /verity-setup to reconnect.");
+      printWarn('Global credentials wiped \u2014 run "verity login" (or "verity init") to reconnect.');
     }
   });
 }
@@ -23230,7 +24902,7 @@ function registerTaskCommands(program2) {
 }
 
 // src/commands/reset.ts
-var import_node_fs43 = require("node:fs");
+var import_node_fs46 = require("node:fs");
 var import_node_path31 = require("node:path");
 function registerResetCommand(program2) {
   program2.command("reset").description("Close the current task and clear transient state").option("--keep-task", "Only purge caches; leave the current task open").option("--all", "Also purge diagnostic logs (.verity/.logs/)").action(async (opts) => {
@@ -23268,11 +24940,11 @@ function registerResetCommand(program2) {
     }
     const cacheDir = projectPath(CACHE_DIR);
     let purged = 0;
-    if ((0, import_node_fs43.existsSync)(cacheDir)) {
-      for (const entry of (0, import_node_fs43.readdirSync)(cacheDir)) {
+    if ((0, import_node_fs46.existsSync)(cacheDir)) {
+      for (const entry of (0, import_node_fs46.readdirSync)(cacheDir)) {
         if (entry.startsWith("pending-")) {
           try {
-            (0, import_node_fs43.unlinkSync)((0, import_node_path31.join)(cacheDir, entry));
+            (0, import_node_fs46.unlinkSync)((0, import_node_path31.join)(cacheDir, entry));
             purged++;
           } catch {
           }
@@ -23287,19 +24959,19 @@ function registerResetCommand(program2) {
       projectPath(`${VERITY_DIR}/.last-analysis`)
     ];
     for (const file of filesToClear) {
-      if ((0, import_node_fs43.existsSync)(file)) {
+      if ((0, import_node_fs46.existsSync)(file)) {
         try {
-          (0, import_node_fs43.writeFileSync)(file, "");
+          (0, import_node_fs46.writeFileSync)(file, "");
         } catch {
         }
       }
     }
     if (opts.all) {
       const logsDir = projectPath(`${VERITY_DIR}/.logs`);
-      if ((0, import_node_fs43.existsSync)(logsDir)) {
-        for (const entry of (0, import_node_fs43.readdirSync)(logsDir)) {
+      if ((0, import_node_fs46.existsSync)(logsDir)) {
+        for (const entry of (0, import_node_fs46.readdirSync)(logsDir)) {
           try {
-            (0, import_node_fs43.unlinkSync)((0, import_node_path31.join)(logsDir, entry));
+            (0, import_node_fs46.unlinkSync)((0, import_node_path31.join)(logsDir, entry));
           } catch {
           }
         }
@@ -23607,8 +25279,8 @@ function registerTelemetryCommands(program2) {
 }
 
 // src/cli.ts
-program.name("verity").description("CLI for Verity quality gate service").version("0.31.1-experimental.80cf3ac").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr").hook("preAction", async (_thisCommand, actionCommand) => {
-  installStderrLog(actionCommand.name(), process.argv.slice(2), "0.31.1-experimental.80cf3ac");
+program.name("verity").description("CLI for Verity quality gate service").version("0.31.1-experimental.83a8619").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr").hook("preAction", async (_thisCommand, actionCommand) => {
+  installStderrLog(actionCommand.name(), process.argv.slice(2), "0.31.1-experimental.83a8619");
   setUserNamedServiceUrl(program.opts().serviceUrl);
   try {
     await foldLegacyLocalCredential();
@@ -23634,6 +25306,7 @@ registerGuardCommand(program);
 registerIgnoreCommand(program);
 registerWaiveCommand(program);
 registerInitCommand(program);
+registerDoctorCommand(program);
 registerUninstallCommand(program);
 registerTaskCommands(program);
 registerResetCommand(program);