@codacy/verity-cli 0.31.1-experimental.be74f71 → 0.31.2

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;
@@ -10404,6 +10405,8 @@ var MAX_INTENT_CHARS = 2e3;
 var SNAPSHOT_DIR = `${VERITY_DIR}/.snapshot`;
 var BASELINE_DIR = `${VERITY_DIR}/.baseline`;
 var CONVERSATION_BUFFER_FILE = `${VERITY_DIR}/.conversation-buffer`;
+var PLUGIN_MARKER_FILE = `${VERITY_DIR}/.plugin-active`;
+var PROJECT_CONFIG_FILE = `${VERITY_DIR}/config.json`;
 var CONVERSATION_MAX_ENTRIES = 10;
 var CONVERSATION_WINDOW_MINUTES = 15;
 var MAX_FINDINGS = 25;
@@ -10506,7 +10509,7 @@ var SECURITY_PATTERNS = [
   /Dockerfile/
 ];
 var PROD_SERVICE_URL = "https://ofcamwrjwrkazqvdchko.supabase.co/functions/v1";
-var DEFAULT_SERVICE_URL = "https://wukeddyzpijoegyajtnc.supabase.co/functions/v1".length > 0 ? "https://wukeddyzpijoegyajtnc.supabase.co/functions/v1" : PROD_SERVICE_URL;
+var DEFAULT_SERVICE_URL = "".length > 0 ? "" : PROD_SERVICE_URL;
 var GITHUB_CLIENT_ID = "Iv23li88HxAi3ZrbYzWh";
 var GITHUB_DEVICE_CODE_URL = "https://github.com/login/device/code";
 var GITHUB_ACCESS_TOKEN_URL = "https://github.com/login/oauth/access_token";
@@ -12700,9 +12703,155 @@ async function applyMomentSelection(moments) {
   return settings;
 }
 
+// src/lib/project-config.ts
+var import_node_fs4 = require("node:fs");
+var DEFAULTS = { git_moments: [] };
+function isMoment(value) {
+  return value === "commit" || value === "push";
+}
+function parseMoments(raw) {
+  return [...new Set(raw.split(",").map((s) => s.trim()).filter(isMoment))];
+}
+function readProjectConfig() {
+  try {
+    if (!(0, import_node_fs4.existsSync)(PROJECT_CONFIG_FILE)) return DEFAULTS;
+    const raw = JSON.parse((0, import_node_fs4.readFileSync)(PROJECT_CONFIG_FILE, "utf-8"));
+    const moments = Array.isArray(raw.git_moments) ? raw.git_moments.filter(isMoment) : [];
+    return { git_moments: [...new Set(moments)] };
+  } catch {
+    return DEFAULTS;
+  }
+}
+function writeProjectConfig(patch) {
+  const next = { ...readProjectConfig(), ...patch };
+  (0, import_node_fs4.mkdirSync)(VERITY_DIR, { recursive: true });
+  (0, import_node_fs4.writeFileSync)(PROJECT_CONFIG_FILE, JSON.stringify(next, null, 2) + "\n");
+  return next;
+}
+function resolveGuardMoments(explicit) {
+  if (explicit !== void 0) return parseMoments(explicit);
+  return readProjectConfig().git_moments;
+}
+
+// src/lib/plugin-ownership.ts
+var import_node_fs6 = require("node:fs");
+
+// src/lib/stderr-log.ts
+var import_node_fs5 = require("node:fs");
+var TOKEN_RE2 = /verity_[0-9a-f]{16,}/g;
+var ANSI_RE = /\u001b\[[0-?]*[ -/]*[@-~]/g;
+function scrub(s) {
+  return s.replace(TOKEN_RE2, "verity_***REDACTED***").replace(ANSI_RE, "");
+}
+var installed = false;
+var wroteBanner = false;
+var banner = "";
+function append(text) {
+  try {
+    const dir = projectPath(DEBUG_LOG_DIR);
+    const file = projectPath(STDERR_LOG_FILE);
+    (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
+    rotateIfNeeded(file);
+    (0, import_node_fs5.appendFileSync)(file, text);
+  } catch {
+  }
+}
+function ensureBanner() {
+  if (wroteBanner) return;
+  wroteBanner = true;
+  append(banner);
+}
+function installStderrLog(cmd, argv, version) {
+  if (installed || !isDebugEnabled()) return;
+  installed = true;
+  banner = `
+\u2501\u2501 verity ${cmd} \xB7 ${(/* @__PURE__ */ new Date()).toISOString()} \xB7 pid ${process.pid}
+   v${version} \xB7 ${process.cwd()}
+   argv: ${scrub(argv.join(" "))}
+`;
+  const original = process.stderr.write.bind(process.stderr);
+  const tee = (...args) => {
+    const result = original(...args);
+    try {
+      const chunk = args[0];
+      const text = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf-8") : String(chunk);
+      ensureBanner();
+      append(scrub(text));
+    } catch {
+    }
+    return result;
+  };
+  process.stderr.write = tee;
+}
+function logToFileOnly(text) {
+  if (!installed) return;
+  ensureBanner();
+  append(text.endsWith("\n") ? text : `${text}
+`);
+}
+
+// src/lib/plugin-ownership.ts
+var MARKER_TTL_SECONDS = 24 * 60 * 60;
+function isPluginInvocation() {
+  return !!process.env.VERITY_PLUGIN_ROOT;
+}
+function readMarker() {
+  try {
+    if (!(0, import_node_fs6.existsSync)(PLUGIN_MARKER_FILE)) return null;
+    const raw = JSON.parse((0, import_node_fs6.readFileSync)(PLUGIN_MARKER_FILE, "utf-8"));
+    const pluginRoot = typeof raw.plugin_root === "string" ? raw.plugin_root : "";
+    if (!pluginRoot) return null;
+    return {
+      session_id: typeof raw.session_id === "string" ? raw.session_id : null,
+      plugin_root: pluginRoot,
+      version: typeof raw.version === "string" ? raw.version : null,
+      ts: typeof raw.ts === "number" ? raw.ts : 0
+    };
+  } catch {
+    return null;
+  }
+}
+function recordPluginOwnership(sessionId) {
+  const pluginRoot = process.env.VERITY_PLUGIN_ROOT;
+  if (!pluginRoot) return;
+  try {
+    (0, import_node_fs6.mkdirSync)(VERITY_DIR, { recursive: true });
+    const marker = {
+      session_id: sessionId,
+      plugin_root: pluginRoot,
+      version: process.env.VERITY_PLUGIN_VERSION || null,
+      ts: Math.floor(Date.now() / 1e3)
+    };
+    (0, import_node_fs6.writeFileSync)(PLUGIN_MARKER_FILE, JSON.stringify(marker));
+  } catch {
+  }
+}
+function shouldDeferToPlugin(sessionId) {
+  if (isPluginInvocation()) {
+    recordPluginOwnership(sessionId);
+    return false;
+  }
+  const marker = readMarker();
+  if (!marker) return false;
+  if (!(0, import_node_fs6.existsSync)(marker.plugin_root)) return false;
+  if (sessionId && marker.session_id) return sessionId === marker.session_id;
+  return Math.floor(Date.now() / 1e3) - marker.ts < MARKER_TTL_SECONDS;
+}
+function pluginActiveHere() {
+  const marker = readMarker();
+  return !!marker && (0, import_node_fs6.existsSync)(marker.plugin_root);
+}
+function deferredToPlugin(command, sessionId) {
+  if (!shouldDeferToPlugin(sessionId)) return false;
+  logToFileOnly(
+    `${command}: the Verity Claude Code plugin owns this session's hooks \u2014 standing down so the turn is not gated twice. Remove the duplicate settings.json hooks with \`verity init --plugin-mode\`.`
+  );
+  return true;
+}
+
 // src/commands/hooks.ts
 var ALL_MOMENTS = ["stop", "pre-commit", "pre-push"];
-function parseMoments(raw) {
+function parseMoments2(raw) {
   const seen = /* @__PURE__ */ new Set();
   for (const part of raw.split(",").map((s) => s.trim()).filter(Boolean)) {
     if (ALL_MOMENTS.includes(part)) seen.add(part);
@@ -12714,7 +12863,22 @@ function registerHooksCommands(program2) {
   hooks.command("install").description("Install Verity hooks into Claude Code settings").option("--force", "Overwrite existing Verity hooks").option("--moments <list>", "Reconcile to exactly these moments: stop,pre-commit,pre-push").action(async (opts) => {
     const force = opts.force ?? false;
     if (opts.moments != null) {
-      const moments = parseMoments(opts.moments);
+      const moments = parseMoments2(opts.moments);
+      const gitMoments = [
+        ...moments.includes("pre-commit") ? ["commit"] : [],
+        ...moments.includes("pre-push") ? ["push"] : []
+      ];
+      writeProjectConfig({ git_moments: gitMoments });
+      if (pluginActiveHere()) {
+        printInfo("The Verity plugin wires the hooks; recorded your selection in .verity/config.json:");
+        printInfo(`  Stop (analysis on every turn): ${moments.includes("stop") ? "on" : "off \u2014 the plugin still wires it; see below"}`);
+        printInfo(`  Pre-commit gate: ${gitMoments.includes("commit") ? "on" : "off"}`);
+        printInfo(`  Pre-push/PR gate: ${gitMoments.includes("push") ? "on" : "off"}`);
+        if (!moments.includes("stop")) {
+          printWarn("  Turning the Stop review off is not yet supported under the plugin \u2014 it stays on.");
+        }
+        return;
+      }
       await applyMomentSelection(moments);
       const status = await checkAllVerityHooks();
       printInfo("Verity hooks reconciled in .claude/settings.json:");
@@ -12761,6 +12925,24 @@ function registerHooksCommands(program2) {
   });
   hooks.command("check").description("Check if Verity hooks are installed").action(async () => {
     const status = await checkAllVerityHooks();
+    if (pluginActiveHere()) {
+      const moments = readProjectConfig().git_moments;
+      printInfo("Wired by the Verity Claude Code plugin (not .claude/settings.json):");
+      printInfo("  Stop hook (verity analyze): installed");
+      printInfo("  Intent hook (verity intent capture): installed");
+      printInfo("  Baseline hook (verity baseline capture): installed");
+      printInfo(
+        `  Git-moment gate (verity guard): ${moments.length ? `installed [${moments.join(", ")}]` : "wired but gating nothing"}`
+      );
+      if (!moments.length) {
+        printInfo('  Enable it with "verity config git-moments commit,push".');
+      }
+      if (status.stop || status.intent || status.baseline || status.guard) {
+        printWarn("  Duplicate hooks also exist in .claude/settings.json. They stand down at run time,");
+        printWarn('  but remove them with "verity init --plugin-mode" so the wiring says what it does.');
+      }
+      return;
+    }
     printInfo(`Stop hook (verity analyze): ${status.stop ? "installed" : "not installed"}`);
     printInfo(`Intent hook (verity intent capture): ${status.intent ? "installed" : "not installed"}`);
     printInfo(`Baseline hook (verity baseline capture): ${status.baseline ? "installed" : "not installed"}`);
@@ -12786,7 +12968,7 @@ var import_node_crypto8 = require("node:crypto");
 
 // src/lib/conversation-buffer.ts
 var import_promises5 = require("node:fs/promises");
-var import_node_fs4 = require("node:fs");
+var import_node_fs7 = require("node:fs");
 var import_node_child_process5 = require("node:child_process");
 var import_node_crypto = require("node:crypto");
 function stripImageReferences(text) {
@@ -12822,7 +13004,7 @@ async function appendToConversationBuffer(prompt, sessionId) {
 }
 async function readAndClearConversationBuffer(currentSessionId) {
   try {
-    if ((0, import_node_fs4.existsSync)(CONVERSATION_BUFFER_FILE)) {
+    if ((0, import_node_fs7.existsSync)(CONVERSATION_BUFFER_FILE)) {
       const entries = await readBufferEntries();
       let mine = entries;
       let others = [];
@@ -12846,7 +13028,7 @@ async function readAndClearConversationBuffer(currentSessionId) {
         };
       }
     }
-    if ((0, import_node_fs4.existsSync)(INTENT_FILE)) {
+    if ((0, import_node_fs7.existsSync)(INTENT_FILE)) {
       try {
         const content = await (0, import_promises5.readFile)(INTENT_FILE, "utf-8");
         await (0, import_promises5.unlink)(INTENT_FILE).catch(() => {
@@ -12903,7 +13085,7 @@ function getRecentCommitMessages() {
 
 // src/lib/context-identity.ts
 var import_node_crypto2 = require("node:crypto");
-var import_node_fs5 = require("node:fs");
+var import_node_fs8 = require("node:fs");
 var import_node_os2 = require("node:os");
 var import_node_path6 = require("node:path");
 var SHARED_SENTINELS = /* @__PURE__ */ new Set([
@@ -12943,7 +13125,7 @@ function contextIdentity(input) {
   if (rawTree && !isSharedSentinel(rawTree)) {
     let resolved = rawTree;
     try {
-      resolved = import_node_fs5.realpathSync.native(rawTree);
+      resolved = import_node_fs8.realpathSync.native(rawTree);
     } catch {
     }
     treeKey = (0, import_node_crypto2.createHash)("sha256").update(resolved).digest("hex").slice(0, 12);
@@ -12980,7 +13162,7 @@ function sessionScopeKey(token, sessionId) {
 
 // src/lib/task-context-buffer.ts
 var import_promises6 = require("node:fs/promises");
-var import_node_fs6 = require("node:fs");
+var import_node_fs9 = require("node:fs");
 var import_node_path7 = require("node:path");
 var TASK_CONTEXT_DIR = `${VERITY_DIR}/.task-context`;
 var MAX_BUFFER_BYTES = 500 * 1024;
@@ -13020,7 +13202,7 @@ async function appendResponseToTaskBuffer(taskId, assistantResponse, actionSumma
 }
 async function readTaskContextBuffer(taskId) {
   const filePath = bufferPath(taskId);
-  if (!(0, import_node_fs6.existsSync)(filePath)) return null;
+  if (!(0, import_node_fs9.existsSync)(filePath)) return null;
   try {
     const content = await (0, import_promises6.readFile)(filePath, "utf-8");
     if (!content.trim()) return null;
@@ -13054,7 +13236,7 @@ async function readTaskContextBuffer(taskId) {
 }
 async function cleanupTaskContextBuffers() {
   try {
-    if (!(0, import_node_fs6.existsSync)(TASK_CONTEXT_DIR)) return;
+    if (!(0, import_node_fs9.existsSync)(TASK_CONTEXT_DIR)) return;
     const files = await (0, import_promises6.readdir)(TASK_CONTEXT_DIR);
     const cutoffMs = Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1e3;
     for (const file of files) {
@@ -13079,7 +13261,7 @@ async function appendEntry(taskId, entry) {
   try {
     await (0, import_promises6.mkdir)(TASK_CONTEXT_DIR, { recursive: true });
     const filePath = bufferPath(taskId);
-    if ((0, import_node_fs6.existsSync)(filePath)) {
+    if ((0, import_node_fs9.existsSync)(filePath)) {
       const stats = await (0, import_promises6.stat)(filePath);
       if (stats.size >= MAX_BUFFER_BYTES) {
         const content = await (0, import_promises6.readFile)(filePath, "utf-8");
@@ -13090,7 +13272,7 @@ async function appendEntry(taskId, entry) {
       }
     }
     const line = JSON.stringify(entry) + "\n";
-    const existing = (0, import_node_fs6.existsSync)(filePath) ? await (0, import_promises6.readFile)(filePath, "utf-8") : "";
+    const existing = (0, import_node_fs9.existsSync)(filePath) ? await (0, import_promises6.readFile)(filePath, "utf-8") : "";
     await (0, import_promises6.writeFile)(filePath, existing + line);
   } catch {
   }
@@ -13098,7 +13280,7 @@ async function appendEntry(taskId, entry) {
 
 // src/lib/memory-retrieval.ts
 var import_promises7 = require("node:fs/promises");
-var import_node_fs7 = require("node:fs");
+var import_node_fs10 = require("node:fs");
 var import_node_path8 = require("node:path");
 var memoryDir = () => projectPath(`${VERITY_DIR}/memory`);
 var DOMAINS = ["decisions", "quality", "security", "intent", "gotchas", "patterns", "domain", "integrations"];
@@ -13192,13 +13374,13 @@ function parseFrontmatter(content) {
   return { fm, body: match[2].trim() };
 }
 async function retrieveForInjection(promptText, taskFiles = [], budgetTokens = DEFAULT_BUDGET_TOKENS) {
-  if (!(0, import_node_fs7.existsSync)(memoryDir())) return null;
+  if (!(0, import_node_fs10.existsSync)(memoryDir())) return null;
   const budget = Math.min(budgetTokens, MAX_BUDGET_TOKENS);
   const promptTokens = tokenize(promptText);
   const nodes = [];
   for (const domain of DOMAINS) {
     const domainDir = (0, import_node_path8.join)(memoryDir(), domain);
-    if (!(0, import_node_fs7.existsSync)(domainDir)) continue;
+    if (!(0, import_node_fs10.existsSync)(domainDir)) continue;
     try {
       const files = await (0, import_promises7.readdir)(domainDir);
       for (const file of files) {
@@ -13263,12 +13445,12 @@ async function retrieveForInjection(promptText, taskFiles = [], budgetTokens = D
 
 // src/lib/memory-sync.ts
 var import_promises8 = require("node:fs/promises");
-var import_node_fs9 = require("node:fs");
+var import_node_fs12 = require("node:fs");
 var import_node_path10 = require("node:path");
 var import_node_crypto3 = require("node:crypto");
 
 // src/lib/safe-path.ts
-var import_node_fs8 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 var import_node_path9 = require("node:path");
 function resolveInside(baseDir, candidate) {
   if (typeof candidate !== "string" || candidate.length === 0) return null;
@@ -13278,16 +13460,16 @@ function resolveInside(baseDir, candidate) {
   const baseSep = baseAbs.endsWith(import_node_path9.sep) ? baseAbs : baseAbs + import_node_path9.sep;
   if (full !== baseAbs && !full.startsWith(baseSep)) return null;
   try {
-    if ((0, import_node_fs8.existsSync)(baseAbs)) {
-      const realBase = (0, import_node_fs8.realpathSync)(baseAbs);
+    if ((0, import_node_fs11.existsSync)(baseAbs)) {
+      const realBase = (0, import_node_fs11.realpathSync)(baseAbs);
       const realBaseSep = realBase.endsWith(import_node_path9.sep) ? realBase : realBase + import_node_path9.sep;
       let probe = full;
-      while (!(0, import_node_fs8.existsSync)(probe)) {
+      while (!(0, import_node_fs11.existsSync)(probe)) {
         const parent = (0, import_node_path9.dirname)(probe);
         if (parent === probe) break;
         probe = parent;
       }
-      const realProbe = (0, import_node_fs8.realpathSync)(probe);
+      const realProbe = (0, import_node_fs11.realpathSync)(probe);
       if (realProbe !== realBase && !realProbe.startsWith(realBaseSep)) return null;
     }
   } catch {
@@ -13366,24 +13548,24 @@ async function ensureMemoryDir() {
   for (const domain of DOMAINS2) {
     await (0, import_promises8.mkdir)((0, import_node_path10.join)(memoryDir2(), domain), { recursive: true });
   }
-  if (!(0, import_node_fs9.existsSync)((0, import_node_path10.join)(memoryDir2(), "SCHEMA.md"))) {
+  if (!(0, import_node_fs12.existsSync)((0, import_node_path10.join)(memoryDir2(), "SCHEMA.md"))) {
     await (0, import_promises8.writeFile)((0, import_node_path10.join)(memoryDir2(), "SCHEMA.md"), SCHEMA_TEMPLATE);
   }
-  if (!(0, import_node_fs9.existsSync)((0, import_node_path10.join)(memoryDir2(), "index.md"))) {
+  if (!(0, import_node_fs12.existsSync)((0, import_node_path10.join)(memoryDir2(), "index.md"))) {
     await (0, import_promises8.writeFile)((0, import_node_path10.join)(memoryDir2(), "index.md"), "# Project Memory Index\n\nNo nodes yet. Run an analysis to start building the knowledge graph.\n");
   }
-  if (!(0, import_node_fs9.existsSync)((0, import_node_path10.join)(memoryDir2(), "log.md"))) {
+  if (!(0, import_node_fs12.existsSync)((0, import_node_path10.join)(memoryDir2(), "log.md"))) {
     await (0, import_promises8.writeFile)((0, import_node_path10.join)(memoryDir2(), "log.md"), "# Memory Log\n\n");
   }
 }
 async function buildManifest() {
-  if (!(0, import_node_fs9.existsSync)(memoryDir2())) {
+  if (!(0, import_node_fs12.existsSync)(memoryDir2())) {
     return { schema_version: 1, nodes: [], index_hash: null, log_length: 0 };
   }
   const nodes = [];
   for (const domain of DOMAINS2) {
     const domainDir = (0, import_node_path10.join)(memoryDir2(), domain);
-    if (!(0, import_node_fs9.existsSync)(domainDir)) continue;
+    if (!(0, import_node_fs12.existsSync)(domainDir)) continue;
     try {
       const files = await (0, import_promises8.readdir)(domainDir);
       for (const file of files) {
@@ -13419,10 +13601,10 @@ function hashContent(content) {
 }
 async function readOnDiskNodes() {
   const out = /* @__PURE__ */ new Map();
-  if (!(0, import_node_fs9.existsSync)(memoryDir2())) return out;
+  if (!(0, import_node_fs12.existsSync)(memoryDir2())) return out;
   for (const domain of DOMAINS2) {
     const domainDir = (0, import_node_path10.join)(memoryDir2(), domain);
-    if (!(0, import_node_fs9.existsSync)(domainDir)) continue;
+    if (!(0, import_node_fs12.existsSync)(domainDir)) continue;
     try {
       for (const file of await (0, import_promises8.readdir)(domainDir)) {
         if (!file.endsWith(".md")) continue;
@@ -13474,7 +13656,7 @@ async function computeEditedNodeUploads() {
   for (const [path, prevHash] of prev) {
     if (prevHash == null) continue;
     const full = (0, import_node_path10.join)(memoryDir2(), path);
-    if (!(0, import_node_fs9.existsSync)(full)) continue;
+    if (!(0, import_node_fs12.existsSync)(full)) continue;
     let content;
     try {
       content = await (0, import_promises8.readFile)(full, "utf-8");
@@ -13510,7 +13692,7 @@ async function applyMemoryWrites(writes, opts = {}) {
   const logLines = [`- ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)} \u2014 Applied ${count} write(s) from server`];
   for (const n of notes) logLines.push(`  - ${n}`);
   try {
-    const existing = (0, import_node_fs9.existsSync)((0, import_node_path10.join)(memoryDir2(), "log.md")) ? await (0, import_promises8.readFile)((0, import_node_path10.join)(memoryDir2(), "log.md"), "utf-8") : "# Memory Log\n\n";
+    const existing = (0, import_node_fs12.existsSync)((0, import_node_path10.join)(memoryDir2(), "log.md")) ? await (0, import_promises8.readFile)((0, import_node_path10.join)(memoryDir2(), "log.md"), "utf-8") : "# Memory Log\n\n";
     await (0, import_promises8.writeFile)((0, import_node_path10.join)(memoryDir2(), "log.md"), existing + logLines.join("\n") + "\n");
   } catch {
   }
@@ -13531,7 +13713,7 @@ async function applyOneWrite(write, treePaths) {
       notes.push(`${write.path}: dropped unmatched file_globs [${grounded.dropped.join(", ")}]`);
     }
   }
-  if ((0, import_node_fs9.existsSync)(fullPath)) {
+  if ((0, import_node_fs12.existsSync)(fullPath)) {
     let existing = "";
     try {
       existing = await (0, import_promises8.readFile)(fullPath, "utf-8");
@@ -13585,7 +13767,7 @@ async function regenerateIndex() {
   let totalNodes = 0;
   for (const domain of DOMAINS2.filter((d) => d !== "_archive")) {
     const domainDir = (0, import_node_path10.join)(memoryDir2(), domain);
-    if (!(0, import_node_fs9.existsSync)(domainDir)) continue;
+    if (!(0, import_node_fs12.existsSync)(domainDir)) continue;
     try {
       const files = await (0, import_promises8.readdir)(domainDir);
       const mdFiles = files.filter((f) => f.endsWith(".md"));
@@ -13855,7 +14037,7 @@ function hasLegacyMemoryBlock(text) {
 async function ensureClaudeMdPointer(cwd = repoRoot()) {
   const claudeMdPath = (0, import_node_path10.join)(cwd, "CLAUDE.md");
   let existing = "";
-  if ((0, import_node_fs9.existsSync)(claudeMdPath)) {
+  if ((0, import_node_fs12.existsSync)(claudeMdPath)) {
     existing = await (0, import_promises8.readFile)(claudeMdPath, "utf-8");
   }
   let startTag = CLAUDE_MD_START;
@@ -13991,7 +14173,7 @@ Body content (\u22648KB). Use [[node-id]] wikilinks for cross-references.
 `;
 
 // src/lib/dossier-session.ts
-var import_node_fs14 = require("node:fs");
+var import_node_fs17 = require("node:fs");
 var import_node_crypto7 = require("node:crypto");
 var import_node_path13 = require("node:path");
 
@@ -14325,7 +14507,7 @@ function statementAnchorKey(file, patternId) {
 
 // src/lib/dossier/log.ts
 var import_node_crypto4 = require("node:crypto");
-var import_node_fs10 = require("node:fs");
+var import_node_fs13 = require("node:fs");
 var import_node_path11 = require("node:path");
 var CRC_TABLE = (() => {
   const t = new Int32Array(256);
@@ -14345,7 +14527,7 @@ function crc32(s) {
 function openDossier(identity) {
   try {
     const dir = dossierDir(identity);
-    (0, import_node_fs10.mkdirSync)(dir, { recursive: true, mode: 448 });
+    (0, import_node_fs13.mkdirSync)(dir, { recursive: true, mode: 448 });
     return {
       dir,
       identity,
@@ -14413,7 +14595,7 @@ function appendEvent(d, ev) {
       at: ev.at ?? (/* @__PURE__ */ new Date()).toISOString(),
       ...ev
     });
-    (0, import_node_fs10.appendFileSync)(d.eventsPath, line, { mode: 384 });
+    (0, import_node_fs13.appendFileSync)(d.eventsPath, line, { mode: 384 });
     return true;
   } catch {
     return false;
@@ -14421,14 +14603,14 @@ function appendEvent(d, ev) {
 }
 function rotateIfNeeded2(d) {
   try {
-    if (!(0, import_node_fs10.existsSync)(d.eventsPath)) return;
-    if ((0, import_node_fs10.statSync)(d.eventsPath).size < ROTATE_BYTES) return;
-    (0, import_node_fs10.mkdirSync)(d.rotatedDir, { recursive: true, mode: 448 });
-    (0, import_node_fs10.renameSync)(d.eventsPath, (0, import_node_path11.join)(d.rotatedDir, `events.${Date.now()}.jsonl`));
-    const kept = (0, import_node_fs10.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).sort();
+    if (!(0, import_node_fs13.existsSync)(d.eventsPath)) return;
+    if ((0, import_node_fs13.statSync)(d.eventsPath).size < ROTATE_BYTES) return;
+    (0, import_node_fs13.mkdirSync)(d.rotatedDir, { recursive: true, mode: 448 });
+    (0, import_node_fs13.renameSync)(d.eventsPath, (0, import_node_path11.join)(d.rotatedDir, `events.${Date.now()}.jsonl`));
+    const kept = (0, import_node_fs13.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).sort();
     for (const stale of kept.slice(0, Math.max(0, kept.length - ROTATE_KEEP))) {
       try {
-        (0, import_node_fs10.renameSync)((0, import_node_path11.join)(d.rotatedDir, stale), (0, import_node_path11.join)(d.rotatedDir, `${stale}.pruned`));
+        (0, import_node_fs13.renameSync)((0, import_node_path11.join)(d.rotatedDir, stale), (0, import_node_path11.join)(d.rotatedDir, `${stale}.pruned`));
       } catch {
       }
     }
@@ -14438,7 +14620,7 @@ function rotateIfNeeded2(d) {
 
 // src/lib/dossier/fold-dossier.ts
 var import_node_crypto5 = require("node:crypto");
-var import_node_fs11 = require("node:fs");
+var import_node_fs14 = require("node:fs");
 var import_node_path12 = require("node:path");
 var EMPTY_CAPABILITIES = () => ({
   human_reachable: { value: "unknown", tier: "unknown" },
@@ -14490,12 +14672,12 @@ function foldDossier(d, opts = {}) {
     }
   };
   try {
-    if ((0, import_node_fs11.existsSync)(d.rotatedDir)) {
-      const files = (0, import_node_fs11.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).sort();
+    if ((0, import_node_fs14.existsSync)(d.rotatedDir)) {
+      const files = (0, import_node_fs14.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).sort();
       state.meta.rotations = files.length;
       for (const f of files) {
         try {
-          ingest((0, import_node_fs11.readFileSync)((0, import_node_path12.join)(d.rotatedDir, f), "utf8"));
+          ingest((0, import_node_fs14.readFileSync)((0, import_node_path12.join)(d.rotatedDir, f), "utf8"));
         } catch {
           state.meta.dropped_lines++;
         }
@@ -14504,9 +14686,9 @@ function foldDossier(d, opts = {}) {
   } catch {
   }
   try {
-    if ((0, import_node_fs11.existsSync)(d.eventsPath)) {
-      state.meta.upto_offset = (0, import_node_fs11.statSync)(d.eventsPath).size;
-      ingest((0, import_node_fs11.readFileSync)(d.eventsPath, "utf8"));
+    if ((0, import_node_fs14.existsSync)(d.eventsPath)) {
+      state.meta.upto_offset = (0, import_node_fs14.statSync)(d.eventsPath).size;
+      ingest((0, import_node_fs14.readFileSync)(d.eventsPath, "utf8"));
     }
   } catch {
   }
@@ -14777,7 +14959,7 @@ function applyBounds(state, input) {
 }
 
 // src/lib/dossier/cache.ts
-var import_node_fs12 = require("node:fs");
+var import_node_fs15 = require("node:fs");
 function compactState(s) {
   const ms = (iso) => Date.parse(iso) || 0;
   return {
@@ -14906,20 +15088,20 @@ function encodeState(s) {
 function writeFoldCache(d, state) {
   try {
     const tmp = `${d.foldPath}.${process.pid}.tmp`;
-    (0, import_node_fs12.writeFileSync)(tmp, encodeState(state), { mode: 384 });
-    (0, import_node_fs12.renameSync)(tmp, d.foldPath);
+    (0, import_node_fs15.writeFileSync)(tmp, encodeState(state), { mode: 384 });
+    (0, import_node_fs15.renameSync)(tmp, d.foldPath);
   } catch {
   }
 }
 function readFoldCache(d) {
   try {
-    if (!(0, import_node_fs12.existsSync)(d.foldPath)) return null;
-    const raw = JSON.parse((0, import_node_fs12.readFileSync)(d.foldPath, "utf8"));
+    if (!(0, import_node_fs15.existsSync)(d.foldPath)) return null;
+    const raw = JSON.parse((0, import_node_fs15.readFileSync)(d.foldPath, "utf8"));
     if (raw?.v !== 1) return null;
     const cached2 = expandState(raw);
     if (!cached2?.meta) return null;
-    const size = (0, import_node_fs12.existsSync)(d.eventsPath) ? (0, import_node_fs12.statSync)(d.eventsPath).size : 0;
-    const rotations = (0, import_node_fs12.existsSync)(d.rotatedDir) ? (0, import_node_fs12.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).length : 0;
+    const size = (0, import_node_fs15.existsSync)(d.eventsPath) ? (0, import_node_fs15.statSync)(d.eventsPath).size : 0;
+    const rotations = (0, import_node_fs15.existsSync)(d.rotatedDir) ? (0, import_node_fs15.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).length : 0;
     if (cached2.meta.upto_offset !== size || cached2.meta.rotations !== rotations) return null;
     return cached2;
   } catch {
@@ -14970,13 +15152,13 @@ function assessContinuity(i) {
 
 // src/lib/dossier/reanchor.ts
 var import_node_crypto6 = require("node:crypto");
-var import_node_fs13 = require("node:fs");
+var import_node_fs16 = require("node:fs");
 function lineSha(text) {
   return (0, import_node_crypto6.createHash)("sha256").update(text.trim()).digest("hex").slice(0, HASH_WIDTH);
 }
 function fileHash(path) {
   try {
-    return (0, import_node_crypto6.createHash)("sha256").update((0, import_node_fs13.readFileSync)(path)).digest("hex").slice(0, HASH_WIDTH);
+    return (0, import_node_crypto6.createHash)("sha256").update((0, import_node_fs16.readFileSync)(path)).digest("hex").slice(0, HASH_WIDTH);
   } catch {
     return null;
   }
@@ -15348,14 +15530,14 @@ function foreignAuthoredPaths(identity, opts = {}) {
   let sessions = 0;
   try {
     const dir = treeDir(identity);
-    if (!(0, import_node_fs14.existsSync)(dir)) return { paths: [], sessions: 0 };
-    for (const entry of (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true })) {
+    if (!(0, import_node_fs17.existsSync)(dir)) return { paths: [], sessions: 0 };
+    for (const entry of (0, import_node_fs17.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       if (entry.name === identity.sessionKey) continue;
       const log = (0, import_node_path13.join)(dir, entry.name, "events.jsonl");
       try {
-        if (!(0, import_node_fs14.existsSync)(log)) continue;
-        if (now - (0, import_node_fs14.statSync)(log).mtimeMs > windowMs) continue;
+        if (!(0, import_node_fs17.existsSync)(log)) continue;
+        if (now - (0, import_node_fs17.statSync)(log).mtimeMs > windowMs) continue;
         const sib = {
           dir: (0, import_node_path13.join)(dir, entry.name),
           identity,
@@ -15390,13 +15572,13 @@ function pruneOldDossiers(identity, maxAgeMs = 7 * 24 * 60 * 60 * 1e3) {
   try {
     const mine = dossierDir(identity);
     const userDir = (0, import_node_path13.dirname)((0, import_node_path13.dirname)(mine));
-    if (!(0, import_node_fs14.existsSync)(userDir)) return 0;
+    if (!(0, import_node_fs17.existsSync)(userDir)) return 0;
     const cutoff = Date.now() - maxAgeMs;
-    for (const tree of (0, import_node_fs14.readdirSync)(userDir, { withFileTypes: true })) {
+    for (const tree of (0, import_node_fs17.readdirSync)(userDir, { withFileTypes: true })) {
       if (!tree.isDirectory()) continue;
       const treePath = (0, import_node_path13.join)(userDir, tree.name);
       let live = 0;
-      for (const entry of (0, import_node_fs14.readdirSync)(treePath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs17.readdirSync)(treePath, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         const dir = (0, import_node_path13.join)(treePath, entry.name);
         if (dir === mine) {
@@ -15405,9 +15587,9 @@ function pruneOldDossiers(identity, maxAgeMs = 7 * 24 * 60 * 60 * 1e3) {
         }
         try {
           const log = (0, import_node_path13.join)(dir, "events.jsonl");
-          const at = (0, import_node_fs14.existsSync)(log) ? (0, import_node_fs14.statSync)(log).mtimeMs : (0, import_node_fs14.statSync)(dir).mtimeMs;
+          const at = (0, import_node_fs17.existsSync)(log) ? (0, import_node_fs17.statSync)(log).mtimeMs : (0, import_node_fs17.statSync)(dir).mtimeMs;
           if (at < cutoff) {
-            (0, import_node_fs14.rmSync)(dir, { recursive: true, force: true });
+            (0, import_node_fs17.rmSync)(dir, { recursive: true, force: true });
             removed++;
           } else {
             live++;
@@ -15417,7 +15599,7 @@ function pruneOldDossiers(identity, maxAgeMs = 7 * 24 * 60 * 60 * 1e3) {
       }
       if (live === 0) {
         try {
-          (0, import_node_fs14.rmSync)(treePath, { recursive: false, force: false });
+          (0, import_node_fs17.rmSync)(treePath, { recursive: false, force: false });
         } catch {
         }
       }
@@ -15434,8 +15616,8 @@ function sessionDossier(token, sessionId) {
 }
 function hasActiveGoal(d) {
   try {
-    if (!(0, import_node_fs14.existsSync)(d.eventsPath)) return false;
-    return (0, import_node_fs14.readFileSync)(d.eventsPath, "utf8").includes('"k":"goal"');
+    if (!(0, import_node_fs17.existsSync)(d.eventsPath)) return false;
+    return (0, import_node_fs17.readFileSync)(d.eventsPath, "utf8").includes('"k":"goal"');
   } catch {
     return false;
   }
@@ -15528,7 +15710,7 @@ function recordVerdict(d, v) {
     if (!lines.has(f.file)) {
       try {
         const abs = (0, import_node_path13.join)(root, f.file);
-        lines.set(f.file, (0, import_node_fs14.existsSync)(abs) ? (0, import_node_fs14.readFileSync)(abs, "utf8").split("\n") : null);
+        lines.set(f.file, (0, import_node_fs17.existsSync)(abs) ? (0, import_node_fs17.readFileSync)(abs, "utf8").split("\n") : null);
       } catch {
         lines.set(f.file, null);
       }
@@ -15629,7 +15811,7 @@ function recallMemory(d, identity, opts) {
       readFileLines: (file) => {
         try {
           const abs = (0, import_node_path13.join)(root, file);
-          return (0, import_node_fs14.existsSync)(abs) ? (0, import_node_fs14.readFileSync)(abs, "utf8").split("\n") : null;
+          return (0, import_node_fs17.existsSync)(abs) ? (0, import_node_fs17.readFileSync)(abs, "utf8").split("\n") : null;
         } catch {
           return null;
         }
@@ -15678,6 +15860,9 @@ function registerIntentCommands(program2) {
       if (!prompt) {
         process.exit(0);
       }
+      if (deferredToPlugin("intent capture", event.session_id ?? process.env.CLAUDE_SESSION_ID ?? null)) {
+        process.exit(0);
+      }
       const authForScope = await resolveToken(program2.opts().token);
       const scopeToken = authForScope.ok ? authForScope.data.token : void 0;
       const scopeSession = event.session_id || process.env.CLAUDE_SESSION_ID || "";
@@ -15767,21 +15952,21 @@ async function fireClassify(prompt, sessionId, globals) {
 }
 
 // src/commands/lifecycle.ts
-var import_node_fs18 = require("node:fs");
+var import_node_fs21 = require("node:fs");
 var import_node_path17 = require("node:path");
 
 // src/lib/baseline.ts
-var import_node_fs17 = require("node:fs");
+var import_node_fs20 = require("node:fs");
 var import_node_path16 = require("node:path");
 var import_node_crypto9 = require("node:crypto");
 
 // src/lib/snapshot.ts
-var import_node_fs16 = require("node:fs");
+var import_node_fs19 = require("node:fs");
 var import_node_path15 = require("node:path");
 var import_node_child_process6 = require("node:child_process");
 
 // src/lib/files.ts
-var import_node_fs15 = require("node:fs");
+var import_node_fs18 = require("node:fs");
 var import_node_path14 = require("node:path");
 var LANG_MAP = {
   // Analyzable (static analysis + Gemini)
@@ -15858,7 +16043,7 @@ function sortByMtime(files) {
     const resolved = resolveFile(f);
     if (!resolved) return null;
     try {
-      const stat3 = (0, import_node_fs15.statSync)(resolved);
+      const stat3 = (0, import_node_fs18.statSync)(resolved);
       return { path: f, resolved, mtime: stat3.mtimeMs };
     } catch {
       return null;
@@ -15891,7 +16076,7 @@ function collectCodeDelta(files, opts) {
     }
     let size;
     try {
-      size = (0, import_node_fs15.statSync)(resolved).size;
+      size = (0, import_node_fs18.statSync)(resolved).size;
     } catch {
       exclude(filepath, "not-stattable");
       continue;
@@ -15908,7 +16093,7 @@ function collectCodeDelta(files, opts) {
     }
     let content;
     try {
-      content = (0, import_node_fs15.readFileSync)(resolved, "utf-8");
+      content = (0, import_node_fs18.readFileSync)(resolved, "utf-8");
     } catch {
       exclude(filepath, "not-readable");
       continue;
@@ -15947,7 +16132,7 @@ function collectCodeDelta(files, opts) {
 
 // src/lib/snapshot.ts
 function generateSnapshotDiffs(files) {
-  if (!(0, import_node_fs16.existsSync)(SNAPSHOT_DIR)) {
+  if (!(0, import_node_fs19.existsSync)(SNAPSHOT_DIR)) {
     return { diffs: [], has_snapshots: false };
   }
   const diffs = [];
@@ -15955,8 +16140,8 @@ function generateSnapshotDiffs(files) {
     if (!resolveInside(SNAPSHOT_DIR, file.path)) continue;
     const snapshotPath = (0, import_node_path15.join)(SNAPSHOT_DIR, file.path);
     const language = file.language ?? detectLanguage(file.path);
-    if ((0, import_node_fs16.existsSync)(snapshotPath)) {
-      const oldContent = (0, import_node_fs16.readFileSync)(snapshotPath, "utf-8");
+    if ((0, import_node_fs19.existsSync)(snapshotPath)) {
+      const oldContent = (0, import_node_fs19.readFileSync)(snapshotPath, "utf-8");
       if (oldContent === file.content) continue;
       const diff = computeDiff(oldContent, file.content, file.path);
       if (diff) {
@@ -15983,8 +16168,8 @@ function saveSnapshots(files) {
     if (!resolveInside(SNAPSHOT_DIR, file.path)) continue;
     const snapshotPath = (0, import_node_path15.join)(SNAPSHOT_DIR, file.path);
     snapshotPaths.add(snapshotPath);
-    (0, import_node_fs16.mkdirSync)((0, import_node_path15.dirname)(snapshotPath), { recursive: true });
-    (0, import_node_fs16.writeFileSync)(snapshotPath, file.content);
+    (0, import_node_fs19.mkdirSync)((0, import_node_path15.dirname)(snapshotPath), { recursive: true });
+    (0, import_node_fs19.writeFileSync)(snapshotPath, file.content);
   }
   cleanStaleSnapshots(SNAPSHOT_DIR, snapshotPaths);
 }
@@ -15992,9 +16177,9 @@ function computeDiff(oldContent, newContent, filePath) {
   const tmpOld = (0, import_node_path15.join)(SNAPSHOT_DIR, ".diff-old.tmp");
   const tmpNew = (0, import_node_path15.join)(SNAPSHOT_DIR, ".diff-new.tmp");
   try {
-    (0, import_node_fs16.mkdirSync)(SNAPSHOT_DIR, { recursive: true });
-    (0, import_node_fs16.writeFileSync)(tmpOld, oldContent);
-    (0, import_node_fs16.writeFileSync)(tmpNew, newContent);
+    (0, import_node_fs19.mkdirSync)(SNAPSHOT_DIR, { recursive: true });
+    (0, import_node_fs19.writeFileSync)(tmpOld, oldContent);
+    (0, import_node_fs19.writeFileSync)(tmpNew, newContent);
     const result = (0, import_node_child_process6.execSync)(
       `git diff --no-index --unified=10 -- "${tmpOld}" "${tmpNew}"`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
@@ -16008,32 +16193,32 @@ function computeDiff(oldContent, newContent, filePath) {
     return null;
   } finally {
     try {
-      (0, import_node_fs16.unlinkSync)(tmpOld);
+      (0, import_node_fs19.unlinkSync)(tmpOld);
     } catch {
     }
     try {
-      (0, import_node_fs16.unlinkSync)(tmpNew);
+      (0, import_node_fs19.unlinkSync)(tmpNew);
     } catch {
     }
   }
 }
 function cleanStaleSnapshots(dir, keepSet) {
-  if (!(0, import_node_fs16.existsSync)(dir)) return;
+  if (!(0, import_node_fs19.existsSync)(dir)) return;
   try {
-    const entries = (0, import_node_fs16.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_node_fs19.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (dir === SNAPSHOT_DIR && (entry.name === ".diff-old.tmp" || entry.name === ".diff-new.tmp")) continue;
       const fullPath = (0, import_node_path15.join)(dir, entry.name);
       if (entry.isDirectory()) {
         cleanStaleSnapshots(fullPath, keepSet);
         try {
-          const remaining = (0, import_node_fs16.readdirSync)(fullPath);
-          if (remaining.length === 0) (0, import_node_fs16.rmdirSync)(fullPath);
+          const remaining = (0, import_node_fs19.readdirSync)(fullPath);
+          if (remaining.length === 0) (0, import_node_fs19.rmdirSync)(fullPath);
         } catch {
         }
       } else if (!keepSet.has(fullPath)) {
         try {
-          (0, import_node_fs16.unlinkSync)(fullPath);
+          (0, import_node_fs19.unlinkSync)(fullPath);
         } catch {
         }
       }
@@ -16064,8 +16249,8 @@ var CARRY_FILE = `${BASELINE_DIR}/.carry`;
 var CARRY_WINDOW_MS = 12e4;
 function writeCarry(sessionId, headSha) {
   try {
-    (0, import_node_fs17.mkdirSync)(projectPath(BASELINE_DIR), { recursive: true });
-    (0, import_node_fs17.writeFileSync)(
+    (0, import_node_fs20.mkdirSync)(projectPath(BASELINE_DIR), { recursive: true });
+    (0, import_node_fs20.writeFileSync)(
       projectPath(CARRY_FILE),
       JSON.stringify({ from_key: sessionKey(sessionId), head_sha: headSha, ts: Date.now() })
     );
@@ -16075,10 +16260,10 @@ function writeCarry(sessionId, headSha) {
 function claimCarry(newKey) {
   const carryPath = projectPath(CARRY_FILE);
   try {
-    if (!(0, import_node_fs17.existsSync)(carryPath)) return null;
-    const carry = JSON.parse((0, import_node_fs17.readFileSync)(carryPath, "utf-8"));
+    if (!(0, import_node_fs20.existsSync)(carryPath)) return null;
+    const carry = JSON.parse((0, import_node_fs20.readFileSync)(carryPath, "utf-8"));
     try {
-      (0, import_node_fs17.rmSync)(carryPath, { force: true });
+      (0, import_node_fs20.rmSync)(carryPath, { force: true });
     } catch {
     }
     if (!carry?.from_key || typeof carry.ts !== "number") return null;
@@ -16089,11 +16274,11 @@ function claimCarry(newKey) {
     if (!prior) return null;
     const toDir = sessionDir(newKey);
     try {
-      (0, import_node_fs17.rmSync)(toDir, { recursive: true, force: true });
+      (0, import_node_fs20.rmSync)(toDir, { recursive: true, force: true });
     } catch {
     }
-    (0, import_node_fs17.renameSync)(fromDir, toDir);
-    (0, import_node_fs17.writeFileSync)(manifestPath(toDir), JSON.stringify({ ...prior, session_id: newKey }) + "\n");
+    (0, import_node_fs20.renameSync)(fromDir, toDir);
+    (0, import_node_fs20.writeFileSync)(manifestPath(toDir), JSON.stringify({ ...prior, session_id: newKey }) + "\n");
     return readManifest(toDir);
   } catch {
     return null;
@@ -16117,21 +16302,21 @@ function captureBaseline(opts = {}) {
   const head_sha = getCurrentCommit();
   const dirty = getDirtyFiles();
   try {
-    (0, import_node_fs17.rmSync)(dir, { recursive: true, force: true });
+    (0, import_node_fs20.rmSync)(dir, { recursive: true, force: true });
   } catch {
   }
   const filesDir = (0, import_node_path16.join)(dir, "files");
   const mirrored = [];
   try {
-    (0, import_node_fs17.mkdirSync)(filesDir, { recursive: true });
+    (0, import_node_fs20.mkdirSync)(filesDir, { recursive: true });
     for (const p of dirty) {
       if (p.includes("..")) continue;
       const content = safeReadForMirror(projectPath(p));
       if (content === null) continue;
       const dest = mirrorPath(dir, p);
       try {
-        (0, import_node_fs17.mkdirSync)((0, import_node_path16.dirname)(dest), { recursive: true });
-        (0, import_node_fs17.writeFileSync)(dest, content);
+        (0, import_node_fs20.mkdirSync)((0, import_node_path16.dirname)(dest), { recursive: true });
+        (0, import_node_fs20.writeFileSync)(dest, content);
         mirrored.push(p);
       } catch {
       }
@@ -16146,8 +16331,8 @@ function captureBaseline(opts = {}) {
     version: BASELINE_VERSION
   };
   try {
-    (0, import_node_fs17.mkdirSync)(dir, { recursive: true });
-    (0, import_node_fs17.writeFileSync)(manifestPath(dir), JSON.stringify(baseline));
+    (0, import_node_fs20.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs20.writeFileSync)(manifestPath(dir), JSON.stringify(baseline));
   } catch {
   }
   pruneOldBaselines();
@@ -16158,9 +16343,9 @@ function readBaseline(sessionId) {
 }
 function readManifest(dir) {
   const mp = manifestPath(dir);
-  if (!(0, import_node_fs17.existsSync)(mp)) return null;
+  if (!(0, import_node_fs20.existsSync)(mp)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs17.readFileSync)(mp, "utf-8"));
+    const parsed = JSON.parse((0, import_node_fs20.readFileSync)(mp, "utf-8"));
     if (typeof parsed.head_sha !== "string" || typeof parsed.captured_at !== "number" || !Array.isArray(parsed.dirty_paths) || parsed.version !== BASELINE_VERSION) {
       return null;
     }
@@ -16191,9 +16376,9 @@ function preImage(repoRelPath, baseline) {
 function resolvePreImage(repoRelPath, baseline) {
   if (baseline.dirty_paths.includes(repoRelPath)) {
     const mp = mirrorPath(sessionDir(sessionKey(baseline.session_id)), repoRelPath);
-    if ((0, import_node_fs17.existsSync)(mp)) {
+    if ((0, import_node_fs20.existsSync)(mp)) {
       try {
-        return { content: (0, import_node_fs17.readFileSync)(mp, "utf-8"), existed: true };
+        return { content: (0, import_node_fs20.readFileSync)(mp, "utf-8"), existed: true };
       } catch {
       }
     }
@@ -16238,8 +16423,8 @@ function absorbIntoBaseline(paths, sessionId) {
       const content = safeReadForMirror(projectPath(p));
       if (content === null) continue;
       const dest = mirrorPath(dir, p);
-      (0, import_node_fs17.mkdirSync)((0, import_node_path16.dirname)(dest), { recursive: true });
-      (0, import_node_fs17.writeFileSync)(dest, content);
+      (0, import_node_fs20.mkdirSync)((0, import_node_path16.dirname)(dest), { recursive: true });
+      (0, import_node_fs20.writeFileSync)(dest, content);
       dirty.add(p);
       adopted++;
     } catch {
@@ -16248,7 +16433,7 @@ function absorbIntoBaseline(paths, sessionId) {
   if (adopted === 0) return 0;
   try {
     const updated = { ...baseline, dirty_paths: [...dirty] };
-    (0, import_node_fs17.writeFileSync)(manifestPath(dir), JSON.stringify(updated));
+    (0, import_node_fs20.writeFileSync)(manifestPath(dir), JSON.stringify(updated));
     preImageCache.delete(baseline);
   } catch {
     return 0;
@@ -16259,7 +16444,7 @@ function changedSinceBaseline(repoRelPath, baseline) {
   const pre = preImage(repoRelPath, baseline);
   let current;
   try {
-    current = (0, import_node_fs17.readFileSync)(projectPath(repoRelPath), "utf-8");
+    current = (0, import_node_fs20.readFileSync)(projectPath(repoRelPath), "utf-8");
   } catch {
     return pre.existed;
   }
@@ -16268,8 +16453,8 @@ function changedSinceBaseline(repoRelPath, baseline) {
 }
 function safeReadForMirror(absPath) {
   try {
-    if ((0, import_node_fs17.statSync)(absPath).size > MIRROR_MAX_BYTES) return null;
-    const buf = (0, import_node_fs17.readFileSync)(absPath);
+    if ((0, import_node_fs20.statSync)(absPath).size > MIRROR_MAX_BYTES) return null;
+    const buf = (0, import_node_fs20.readFileSync)(absPath);
     if (buf.includes(0)) return null;
     return buf.toString("utf-8");
   } catch {
@@ -16280,7 +16465,7 @@ function pruneOldBaselines() {
   const root = projectPath(BASELINE_DIR);
   let entries;
   try {
-    entries = (0, import_node_fs17.readdirSync)(root);
+    entries = (0, import_node_fs20.readdirSync)(root);
   } catch {
     return;
   }
@@ -16290,8 +16475,8 @@ function pruneOldBaselines() {
     const manifest = readManifest(dir);
     if (!manifest) {
       try {
-        if (now - (0, import_node_fs17.statSync)(dir).mtimeMs > BASELINE_TTL_MS) {
-          (0, import_node_fs17.rmSync)(dir, { recursive: true, force: true });
+        if (now - (0, import_node_fs20.statSync)(dir).mtimeMs > BASELINE_TTL_MS) {
+          (0, import_node_fs20.rmSync)(dir, { recursive: true, force: true });
         }
       } catch {
       }
@@ -16299,7 +16484,7 @@ function pruneOldBaselines() {
     }
     if (now - manifest.captured_at <= BASELINE_TTL_MS) continue;
     try {
-      (0, import_node_fs17.rmSync)(dir, { recursive: true, force: true });
+      (0, import_node_fs20.rmSync)(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -16393,6 +16578,7 @@ function registerLifecycleCommands(program2) {
       if (!verityConfigured()) process.exit(0);
       const event = await readHookStdin();
       const sessionId = opts.sessionId ?? event.session_id ?? process.env.CLAUDE_SESSION_ID ?? null;
+      if (deferredToPlugin("compact", sessionId)) process.exit(0);
       const globals = program2.opts();
       const tok = await resolveToken(globals.token);
       const session2 = sessionDossier(tok.ok ? tok.data.token : null, sessionId);
@@ -16421,6 +16607,7 @@ function registerLifecycleCommands(program2) {
       if (!verityConfigured()) process.exit(0);
       const event = await readHookStdin();
       const sessionId = opts.sessionId ?? event.session_id ?? process.env.CLAUDE_SESSION_ID ?? null;
+      if (deferredToPlugin("session end", sessionId)) process.exit(0);
       const reason = opts.reason ?? event.session_end_reason ?? event.reason ?? "other";
       if (reason === "clear") {
         writeCarry(sessionId ?? void 0, getCurrentCommit());
@@ -16473,7 +16660,7 @@ function buildCompactionContext(session) {
     readFileLines: (file) => {
       try {
         const abs = (0, import_node_path17.join)(root, file);
-        return (0, import_node_fs18.existsSync)(abs) ? (0, import_node_fs18.readFileSync)(abs, "utf8").split("\n") : null;
+        return (0, import_node_fs21.existsSync)(abs) ? (0, import_node_fs21.readFileSync)(abs, "utf8").split("\n") : null;
       } catch {
         return null;
       }
@@ -16530,11 +16717,11 @@ async function readHookStdin() {
 
 // src/commands/standard.ts
 var import_promises9 = require("node:fs/promises");
-var import_node_fs20 = require("node:fs");
+var import_node_fs23 = require("node:fs");
 var import_yaml = __toESM(require_dist());
 
 // src/lib/verityignore.ts
-var import_node_fs19 = require("node:fs");
+var import_node_fs22 = require("node:fs");
 var EMPTY = { rules: [], securityOverlap: [], problems: [] };
 var SECURITY_PROBES = [
   ".env",
@@ -16627,9 +16814,9 @@ function isIgnored(ig, path) {
 }
 function loadVerityIgnore() {
   const file = projectPath(VERITYIGNORE_FILE);
-  if (!(0, import_node_fs19.existsSync)(file)) return EMPTY;
+  if (!(0, import_node_fs22.existsSync)(file)) return EMPTY;
   try {
-    return parseVerityIgnore((0, import_node_fs19.readFileSync)(file, "utf-8"));
+    return parseVerityIgnore((0, import_node_fs22.readFileSync)(file, "utf-8"));
   } catch {
     return EMPTY;
   }
@@ -16699,9 +16886,9 @@ function registerStandardCommands(program2) {
     }
     let ignoreRaw = null;
     const ignorePath = projectPath(VERITYIGNORE_FILE);
-    if ((0, import_node_fs20.existsSync)(ignorePath)) {
+    if ((0, import_node_fs23.existsSync)(ignorePath)) {
       try {
-        ignoreRaw = (0, import_node_fs20.readFileSync)(ignorePath, "utf-8");
+        ignoreRaw = (0, import_node_fs23.readFileSync)(ignorePath, "utf-8");
         const overlap = describeSecurityOverlap(parseVerityIgnore(ignoreRaw));
         if (overlap) printWarn(overlap);
       } catch {
@@ -16801,6 +16988,22 @@ function registerConfigCommands(program2) {
     }
     process.stdout.write(urlResult.data + "\n");
   });
+  config.command("git-moments [moments]").description('Get or set the git moments the guard reviews: commit,push \u2014 or "none"').action((moments) => {
+    if (moments === void 0) {
+      const current = readProjectConfig().git_moments;
+      process.stdout.write((current.length ? current.join(",") : "none") + "\n");
+      return;
+    }
+    const next = moments === "none" ? [] : parseMoments(moments);
+    if (moments !== "none" && next.length === 0) {
+      printError(`Unrecognised moments: ${moments}. Use "commit", "push", "commit,push", or "none".`);
+      process.exit(1);
+    }
+    writeProjectConfig({ git_moments: next });
+    printInfo(
+      next.length ? `Git-moment review enabled for: ${next.join(", ")}` : "Git-moment review disabled \u2014 commits and pushes are no longer gated."
+    );
+  });
   config.command("push").description("Upload the analysis config to the service").option("--file <path>", "Path to config file", CODACY_CONFIG_FILE).action(async (opts) => {
     const globals = program2.opts();
     const tokenResult = await resolveToken(globals.token);
@@ -16943,10 +17146,10 @@ function formatRunDetail(run2) {
 }
 
 // src/lib/ignore-declaration.ts
-var import_node_fs22 = require("node:fs");
+var import_node_fs25 = require("node:fs");
 
 // src/lib/debounce.ts
-var import_node_fs21 = require("node:fs");
+var import_node_fs24 = require("node:fs");
 var import_node_crypto10 = require("node:crypto");
 function scopedFile(base, sessionId) {
   if (!sessionId) return base;
@@ -16954,9 +17157,9 @@ function scopedFile(base, sessionId) {
 }
 function checkDebounce(debounceSeconds = DEBOUNCE_SECONDS, sessionId) {
   const file = scopedFile(DEBOUNCE_FILE, sessionId);
-  if (!(0, import_node_fs21.existsSync)(file)) return null;
+  if (!(0, import_node_fs24.existsSync)(file)) return null;
   try {
-    const lastTs = parseInt((0, import_node_fs21.readFileSync)(file, "utf-8").trim(), 10);
+    const lastTs = parseInt((0, import_node_fs24.readFileSync)(file, "utf-8").trim(), 10);
     const nowTs = Math.floor(Date.now() / 1e3);
     const elapsed = nowTs - lastTs;
     if (elapsed < debounceSeconds) {
@@ -16969,10 +17172,10 @@ function checkDebounce(debounceSeconds = DEBOUNCE_SECONDS, sessionId) {
 function checkMtime(files, bypassForRecentCommits, sessionId) {
   if (bypassForRecentCommits) return null;
   const file = scopedFile(DEBOUNCE_FILE, sessionId);
-  if (!(0, import_node_fs21.existsSync)(file)) return null;
+  if (!(0, import_node_fs24.existsSync)(file)) return null;
   let debounceTime;
   try {
-    debounceTime = (0, import_node_fs21.statSync)(file).mtimeMs;
+    debounceTime = (0, import_node_fs24.statSync)(file).mtimeMs;
   } catch {
     return null;
   }
@@ -16980,7 +17183,7 @@ function checkMtime(files, bypassForRecentCommits, sessionId) {
     const resolved = resolveFile(f);
     if (!resolved) continue;
     try {
-      const stat3 = (0, import_node_fs21.statSync)(resolved);
+      const stat3 = (0, import_node_fs24.statSync)(resolved);
       if (stat3.mtimeMs > debounceTime) {
         return null;
       }
@@ -16996,8 +17199,8 @@ function computeContentHash(files) {
   for (const f of sorted) {
     const resolved = resolveFile(f) ?? f;
     try {
-      if ((0, import_node_fs21.existsSync)(resolved)) {
-        hash.update((0, import_node_fs21.readFileSync)(resolved));
+      if ((0, import_node_fs24.existsSync)(resolved)) {
+        hash.update((0, import_node_fs24.readFileSync)(resolved));
       }
     } catch {
     }
@@ -17007,9 +17210,9 @@ function computeContentHash(files) {
 function checkContentHash(files, sessionId) {
   const hash = computeContentHash(files);
   const file = scopedFile(HASH_FILE, sessionId);
-  if ((0, import_node_fs21.existsSync)(file)) {
+  if ((0, import_node_fs24.existsSync)(file)) {
     try {
-      const storedHash = (0, import_node_fs21.readFileSync)(file, "utf-8").trim();
+      const storedHash = (0, import_node_fs24.readFileSync)(file, "utf-8").trim();
       if (hash === storedHash) {
         return { skip: "No source changes since last analysis", hash };
       }
@@ -17019,24 +17222,24 @@ function checkContentHash(files, sessionId) {
   return { skip: null, hash };
 }
 function recordAnalysisStart(sessionId) {
-  (0, import_node_fs21.mkdirSync)(VERITY_DIR, { recursive: true });
-  (0, import_node_fs21.writeFileSync)(scopedFile(DEBOUNCE_FILE, sessionId), String(Math.floor(Date.now() / 1e3)));
+  (0, import_node_fs24.mkdirSync)(VERITY_DIR, { recursive: true });
+  (0, import_node_fs24.writeFileSync)(scopedFile(DEBOUNCE_FILE, sessionId), String(Math.floor(Date.now() / 1e3)));
 }
 function recordPassHash(hash, sessionId) {
-  (0, import_node_fs21.writeFileSync)(scopedFile(HASH_FILE, sessionId), hash);
+  (0, import_node_fs24.writeFileSync)(scopedFile(HASH_FILE, sessionId), hash);
 }
 function narrowToRecent(files, sessionId) {
   const file = scopedFile(DEBOUNCE_FILE, sessionId);
-  if (!(0, import_node_fs21.existsSync)(file)) return files;
+  if (!(0, import_node_fs24.existsSync)(file)) return files;
   let debounceTime;
   try {
-    debounceTime = (0, import_node_fs21.statSync)(file).mtimeMs;
+    debounceTime = (0, import_node_fs24.statSync)(file).mtimeMs;
   } catch {
     return files;
   }
   const recent = files.filter((f) => {
     try {
-      return (0, import_node_fs21.existsSync)(f) && (0, import_node_fs21.statSync)(f).mtimeMs > debounceTime;
+      return (0, import_node_fs24.existsSync)(f) && (0, import_node_fs24.statSync)(f).mtimeMs > debounceTime;
     } catch {
       return false;
     }
@@ -17049,9 +17252,9 @@ function readIteration(currentCommit, _contentHash) {
 var NO_BLOCKS = { attempts: 0, blocks: 0, fingerprint: null };
 function readBlockState(currentCommit, opts) {
   if (opts?.newUserPrompt) return NO_BLOCKS;
-  if (!(0, import_node_fs21.existsSync)(ITERATION_FILE)) return NO_BLOCKS;
+  if (!(0, import_node_fs24.existsSync)(ITERATION_FILE)) return NO_BLOCKS;
   try {
-    const stored = (0, import_node_fs21.readFileSync)(ITERATION_FILE, "utf-8").trim();
+    const stored = (0, import_node_fs24.readFileSync)(ITERATION_FILE, "utf-8").trim();
     const parsed = stored.startsWith("{") ? parseJsonState(stored) : parseLegacyState(stored);
     if (!parsed) return NO_BLOCKS;
     if (parsed.commit !== currentCommit) return NO_BLOCKS;
@@ -17097,8 +17300,8 @@ function isSameProblem(previous, current) {
   return current.split(",").some((k) => prev.has(k));
 }
 function writeBlockState(commit, state) {
-  (0, import_node_fs21.mkdirSync)(VERITY_DIR, { recursive: true });
-  (0, import_node_fs21.writeFileSync)(
+  (0, import_node_fs24.mkdirSync)(VERITY_DIR, { recursive: true });
+  (0, import_node_fs24.writeFileSync)(
     ITERATION_FILE,
     JSON.stringify({
       v: 2,
@@ -17203,9 +17406,9 @@ function resolveIgnoreState(keys) {
 }
 function readIgnoreState(sessionId) {
   const file = stateFile(sessionId);
-  if (!(0, import_node_fs22.existsSync)(file)) return null;
+  if (!(0, import_node_fs25.existsSync)(file)) return null;
   try {
-    const o = JSON.parse((0, import_node_fs22.readFileSync)(file, "utf-8")) ?? {};
+    const o = JSON.parse((0, import_node_fs25.readFileSync)(file, "utf-8")) ?? {};
     const spent = typeof o.spent === "number" ? o.spent : 0;
     const raw = o.active;
     let active = null;
@@ -17229,8 +17432,8 @@ function readIgnoreState(sessionId) {
 }
 function writeIgnoreState(state, sessionId) {
   try {
-    (0, import_node_fs22.mkdirSync)(projectPath(VERITY_DIR), { recursive: true });
-    (0, import_node_fs22.writeFileSync)(stateFile(sessionId), JSON.stringify({ v: 1, active: state.active, spent: state.spent }));
+    (0, import_node_fs25.mkdirSync)(projectPath(VERITY_DIR), { recursive: true });
+    (0, import_node_fs25.writeFileSync)(stateFile(sessionId), JSON.stringify({ v: 1, active: state.active, spent: state.spent }));
   } catch {
   }
 }
@@ -17567,7 +17770,6 @@ function createRun(opts, globals) {
     token: "",
     modeDecision: null,
     sessionIdForMemory: "",
-    contextFilePaths: [],
     analysisMode: "standard",
     sessionAuthoredCode: false,
     staticResults: {
@@ -17577,6 +17779,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: "",
@@ -17604,58 +17807,702 @@ function createRun(opts, globals) {
   };
 }
 
-// src/lib/stderr-log.ts
-var import_node_fs23 = require("node:fs");
-var TOKEN_RE2 = /verity_[0-9a-f]{16,}/g;
-var ANSI_RE = /\u001b\[[0-?]*[ -/]*[@-~]/g;
-function scrub(s) {
-  return s.replace(TOKEN_RE2, "verity_***REDACTED***").replace(ANSI_RE, "");
+// 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 installed = false;
-var wroteBanner = false;
-var banner = "";
-function append(text) {
-  try {
-    const dir = projectPath(DEBUG_LOG_DIR);
-    const file = projectPath(STDERR_LOG_FILE);
-    (0, import_node_fs23.mkdirSync)(dir, { recursive: true });
-    rotateIfNeeded(file);
-    (0, import_node_fs23.appendFileSync)(file, text);
-  } catch {
+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 ensureBanner() {
-  if (wroteBanner) return;
-  wroteBanner = true;
-  append(banner);
+function declNameOn(line, rules) {
+  for (const r of rules) {
+    const m = r.exec(line);
+    if (m?.[1]) return m[1];
+  }
+  return null;
 }
-function installStderrLog(cmd, argv, version) {
-  if (installed || !isDebugEnabled()) return;
-  installed = true;
-  banner = `
-\u2501\u2501 verity ${cmd} \xB7 ${(/* @__PURE__ */ new Date()).toISOString()} \xB7 pid ${process.pid}
-   v${version} \xB7 ${process.cwd()}
-   argv: ${scrub(argv.join(" "))}
-`;
-  const original = process.stderr.write.bind(process.stderr);
-  const tee = (...args) => {
-    const result = original(...args);
-    try {
-      const chunk = args[0];
-      const text = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf-8") : String(chunk);
-      ensureBanner();
-      append(scrub(text));
-    } catch {
+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);
     }
-    return result;
   };
-  process.stderr.write = tee;
+  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 logToFileOnly(text) {
-  if (!installed) return;
-  ensureBanner();
-  append(text.endsWith("\n") ? text : `${text}
-`);
+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
@@ -17696,6 +18543,7 @@ function formatRunEvidence(run2, startedAt) {
   }
   out += row("sent", `${sent.length} \xB7 ${list(sent)}`);
   if (context.length > 0) out += row("context", `${context.length} \xB7 ${list(context)}`);
+  if (run2.repoContext) out += row("repo", describeRepoContext(run2.repoContext));
   const withheld = run2.reviewCoverage.notReviewed;
   if (withheld.length > 0) {
     const byReason = /* @__PURE__ */ new Map();
@@ -17777,9 +18625,9 @@ function installRunEvidence(run2) {
 }
 
 // src/lib/git-frame.ts
-var import_node_child_process7 = require("node:child_process");
-var import_node_fs24 = require("node:fs");
-var import_node_os3 = require("node:os");
+var import_node_child_process8 = require("node:child_process");
+var import_node_fs26 = require("node:fs");
+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+)`;
@@ -17827,14 +18675,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];
@@ -17853,7 +18701,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);
     }
   }
@@ -17910,21 +18758,21 @@ 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 "";
   }
 }
 function realpathOr(p) {
   try {
-    return import_node_fs24.realpathSync.native(p);
+    return import_node_fs26.realpathSync.native(p);
   } catch {
     return (0, import_node_path18.resolve)(p);
   }
 }
 function resolveFrame(input) {
   const found = findMomentSegment(input.command, input.on);
-  const hookDirUsable = !!input.hookCwd && (0, import_node_fs24.existsSync)(input.hookCwd);
+  const hookDirUsable = !!input.hookCwd && (0, import_node_fs26.existsSync)(input.hookCwd);
   const baseDir = hookDirUsable ? input.hookCwd : process.cwd();
   let anchor = hookDirUsable ? "hook-cwd" : "process-cwd";
   const refuse = (refusal) => ({
@@ -17947,7 +18795,7 @@ function resolveFrame(input) {
     if (dirs.size > 1) return refuse(`target:multiple ${found.moment} targets in one command`);
     const targetDir = dirs.size === 1 ? [...dirs][0] : baseDir;
     if (targetDir !== baseDir) {
-      if (!(0, import_node_fs24.existsSync)(targetDir)) return refuse(`target:directory does not exist: ${targetDir}`);
+      if (!(0, import_node_fs26.existsSync)(targetDir)) return refuse(`target:directory does not exist: ${targetDir}`);
       dir = targetDir;
     }
   }
@@ -17986,7 +18834,7 @@ var SHA_RE2 = /^[0-9a-f]{40}$/;
 function baselineShaAt(frame) {
   if (!frame.worktreeRoot) return null;
   try {
-    const sha = (0, import_node_fs24.readFileSync)((0, import_node_path19.join)(frame.worktreeRoot, BASELINE_SHA_FILE), "utf-8").trim();
+    const sha = (0, import_node_fs26.readFileSync)((0, import_node_path19.join)(frame.worktreeRoot, BASELINE_SHA_FILE), "utf-8").trim();
     if (!SHA_RE2.test(sha)) return null;
     return refResolves(frame, sha) ? sha : null;
   } catch {
@@ -18049,6 +18897,40 @@ function rangeFiles(frame, range) {
   }
   return out.split("\n").filter((l) => l.length > 0).filter((f) => !isVerityOwnedPath(f));
 }
+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");
@@ -18099,7 +18981,7 @@ function truthy(v) {
 }
 
 // src/lib/transcript.ts
-var import_node_fs25 = require("node:fs");
+var import_node_fs27 = require("node:fs");
 var MAX_READ_BYTES = 256 * 1024;
 var SMALL_FILE_BYTES = 64 * 1024;
 var MAX_FILES_LIST = 20;
@@ -18108,6 +18990,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)>/;
@@ -18125,7 +19008,7 @@ async function extractActionSummary(transcriptPath) {
 function readTurnLines(transcriptPath) {
   let size;
   try {
-    size = (0, import_node_fs25.statSync)(transcriptPath).size;
+    size = (0, import_node_fs27.statSync)(transcriptPath).size;
   } catch {
     return null;
   }
@@ -18133,7 +19016,7 @@ function readTurnLines(transcriptPath) {
   let raw;
   let windowed = false;
   if (size <= SMALL_FILE_BYTES) {
-    raw = (0, import_node_fs25.readFileSync)(transcriptPath, "utf-8");
+    raw = (0, import_node_fs27.readFileSync)(transcriptPath, "utf-8");
   } else {
     windowed = true;
     const buf = Buffer.alloc(Math.min(MAX_READ_BYTES, size));
@@ -18193,6 +19076,7 @@ function buildSummary(lines) {
   let userCommandsTruncated = false;
   let commandsTruncated = false;
   let searches = 0;
+  const searchesDetail = [];
   let subagents = 0;
   let webFetches = 0;
   let totalToolCalls = 0;
@@ -18264,9 +19148,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":
@@ -18301,6 +19195,7 @@ function buildSummary(lines) {
       ...cappedOut(filesCreated, MAX_CREATED_LIST)
     ],
     searches,
+    ...searchesDetail.length > 0 ? { searches_detail: searchesDetail } : {},
     commands,
     ...commandsTruncated ? { commands_truncated: true } : {},
     user_commands: userCommands,
@@ -18311,6 +19206,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;
@@ -18435,6 +19333,9 @@ async function bootstrap(run2) {
     isTTY: process.stdout.isTTY === true
   });
   const { assistantMessage: assistantResponse, stopReason, transcriptPath, sessionId } = await readStopHookStdin();
+  if (deferredToPlugin("analyze", sessionId ?? process.env.CLAUDE_SESSION_ID ?? null)) {
+    process.exit(0);
+  }
   const actionSummary = transcriptPath ? await extractActionSummary(transcriptPath) : null;
   const tokenResult = await resolveToken(globals.token);
   const scopeToken = tokenResult.ok ? tokenResult.data.token : void 0;
@@ -18614,7 +19515,7 @@ function channelSilence(input) {
 // src/lib/cli-version.ts
 function cliVersion() {
   try {
-    return true ? "0.31.1-experimental.be74f71" : "dev";
+    return true ? "0.31.2" : "dev";
   } catch {
     return "dev";
   }
@@ -18654,8 +19555,8 @@ async function sendSkipBeacon(ctx, reason) {
 }
 
 // src/lib/static-analysis.ts
-var import_node_child_process8 = require("node:child_process");
-var import_node_fs26 = require("node:fs");
+var import_node_child_process9 = require("node:child_process");
+var import_node_fs28 = require("node:fs");
 var SEVERITY_ORDER = {
   Error: 0,
   Critical: 0,
@@ -18667,7 +19568,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;
@@ -18703,13 +19604,13 @@ function runCodacyAnalysis(files) {
   if (files.length === 0) return empty;
   const existingFiles = files.filter((f) => {
     try {
-      return (0, import_node_fs26.existsSync)(f);
+      return (0, import_node_fs28.existsSync)(f);
     } catch {
       return false;
     }
   });
   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
   });
@@ -18972,7 +19873,7 @@ async function scope(run2) {
 }
 
 // src/lib/specs.ts
-var import_node_fs27 = require("node:fs");
+var import_node_fs29 = require("node:fs");
 var import_node_path20 = require("node:path");
 var SPEC_CANDIDATES = [
   "CLAUDE.md",
@@ -19004,16 +19905,16 @@ function discoverSpecs(consulted = []) {
     const totalCap = relevant ? MAX_TOTAL_SPEC_BYTES : UNCONSULTED_TOTAL_BYTES;
     if (totalBytes >= totalCap) return false;
     if (seen.has(specPath)) return true;
-    if (!(0, import_node_fs27.existsSync)(specPath)) return true;
+    if (!(0, import_node_fs29.existsSync)(specPath)) return true;
     seen.add(specPath);
     const remaining = totalCap - totalBytes;
     const fileCap = relevant ? MAX_SPEC_FILE_BYTES : UNCONSULTED_FILE_BYTES;
     const readBytes = Math.min(fileCap, remaining);
     try {
       const buf = Buffer.alloc(readBytes);
-      const fd = (0, import_node_fs27.openSync)(specPath, "r");
-      const bytesRead = (0, import_node_fs27.readSync)(fd, buf, 0, readBytes, 0);
-      (0, import_node_fs27.closeSync)(fd);
+      const fd = (0, import_node_fs29.openSync)(specPath, "r");
+      const bytesRead = (0, import_node_fs29.readSync)(fd, buf, 0, readBytes, 0);
+      (0, import_node_fs29.closeSync)(fd);
       const content = buf.slice(0, bytesRead).toString("utf-8");
       if (!content) return true;
       result.push({ path: specPath, content });
@@ -19029,7 +19930,7 @@ function discoverSpecs(consulted = []) {
     if (!addSpec(candidate)) break;
   }
   for (const dir of ["spec", "docs"]) {
-    if (!(0, import_node_fs27.existsSync)(dir)) continue;
+    if (!(0, import_node_fs29.existsSync)(dir)) continue;
     try {
       const mdFiles = findMdFiles(dir, 2).sort();
       for (const mdFile of mdFiles) {
@@ -19044,7 +19945,7 @@ function findMdFiles(dir, maxDepth, depth = 0) {
   if (depth >= maxDepth) return [];
   const result = [];
   try {
-    const entries = (0, import_node_fs27.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_node_fs29.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = (0, import_node_path20.join)(dir, entry.name);
       if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -19063,14 +19964,14 @@ function discoverPlans() {
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
   for (const plansDir of [localPlansDir, homePlansDir]) {
-    if (!(0, import_node_fs27.existsSync)(plansDir)) continue;
+    if (!(0, import_node_fs29.existsSync)(plansDir)) continue;
     try {
-      for (const f of (0, import_node_fs27.readdirSync)(plansDir)) {
+      for (const f of (0, import_node_fs29.readdirSync)(plansDir)) {
         if (!f.endsWith(".md") || seen.has(f)) continue;
         seen.add(f);
         const fullPath = (0, import_node_path20.join)(plansDir, f);
         try {
-          const stat3 = (0, import_node_fs27.statSync)(fullPath);
+          const stat3 = (0, import_node_fs29.statSync)(fullPath);
           candidates.push({ name: f, path: fullPath, mtime: stat3.mtimeMs, size: stat3.size });
         } catch {
         }
@@ -19083,7 +19984,7 @@ function discoverPlans() {
   for (const entry of candidates.slice(0, MAX_PLAN_FILES)) {
     if (entry.size > MAX_PLAN_FILE_BYTES) continue;
     try {
-      const content = (0, import_node_fs27.readFileSync)(entry.path, "utf-8");
+      const content = (0, import_node_fs29.readFileSync)(entry.path, "utf-8");
       result.push({ name: entry.name, content });
     } catch {
     }
@@ -19098,12 +19999,12 @@ function discoverGuardDocs(rangeFiles2) {
     if (result.length >= MAX_SPEC_FILES) break;
     if (!GUARD_DOC_EXT.test(path)) continue;
     if (path.startsWith("/") || path.includes("..")) continue;
-    if (!(0, import_node_fs27.existsSync)(path)) continue;
+    if (!(0, import_node_fs29.existsSync)(path)) continue;
     try {
-      const stat3 = (0, import_node_fs27.statSync)(path);
+      const stat3 = (0, import_node_fs29.statSync)(path);
       if (stat3.size > MAX_PLAN_FILE_BYTES) continue;
       if (totalBytes + stat3.size > MAX_TOTAL_SPEC_BYTES) continue;
-      const content = (0, import_node_fs27.readFileSync)(path, "utf-8");
+      const content = (0, import_node_fs29.readFileSync)(path, "utf-8");
       if (!content) continue;
       result.push({ name: path, content });
       totalBytes += content.length;
@@ -19214,7 +20115,6 @@ 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";
@@ -19228,9 +20128,6 @@ async function mode(run2) {
       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;
@@ -19279,11 +20176,11 @@ async function mode(run2) {
       turnAuthoredCode ? "capacity" : void 0
     );
   }
-  Object.assign(run2, { analysisMode, contextFilePaths, sessionAuthoredCode, sessionIdForMemory });
+  Object.assign(run2, { analysisMode, sessionAuthoredCode, sessionIdForMemory });
 }
 
 // src/lib/fold.ts
-var import_node_fs28 = require("node:fs");
+var import_node_fs30 = require("node:fs");
 var import_node_path21 = require("node:path");
 var KNOWN_RECORD_TYPES = /* @__PURE__ */ new Set([
   "user",
@@ -19421,7 +20318,7 @@ function candidateRoots(repoRoot2) {
   const norm = repoRoot2.replace(/\\/g, "/").replace(/\/+$/, "");
   const out = [norm];
   try {
-    const real = import_node_fs28.realpathSync.native(norm).replace(/\\/g, "/").replace(/\/+$/, "");
+    const real = import_node_fs30.realpathSync.native(norm).replace(/\\/g, "/").replace(/\/+$/, "");
     if (real !== norm) out.push(real);
   } catch {
   }
@@ -19509,8 +20406,8 @@ function fold(transcriptPath, opts = {}) {
     }
   };
   try {
-    if (!(0, import_node_fs28.existsSync)(transcriptPath)) return result;
-    ingest((0, import_node_fs28.readFileSync)(transcriptPath, "utf8"), "agent");
+    if (!(0, import_node_fs30.existsSync)(transcriptPath)) return result;
+    ingest((0, import_node_fs30.readFileSync)(transcriptPath, "utf8"), "agent");
     result.coverage.complete = true;
   } catch {
     return result;
@@ -19521,19 +20418,19 @@ function fold(transcriptPath, opts = {}) {
       (0, import_node_path21.basename)(transcriptPath).replace(/\.jsonl$/, ""),
       "subagents"
     );
-    if ((0, import_node_fs28.existsSync)(sidecarDir)) {
+    if ((0, import_node_fs30.existsSync)(sidecarDir)) {
       const maxFiles = opts.maxSidecars ?? 200;
       const maxBytes = opts.maxSidecarBytes ?? 16 * 1024 * 1024;
       const found = [];
       const walk = (d, depth) => {
         if (depth > 4) return;
-        for (const e of (0, import_node_fs28.readdirSync)(d, { withFileTypes: true })) {
+        for (const e of (0, import_node_fs30.readdirSync)(d, { withFileTypes: true })) {
           const p = (0, import_node_path21.join)(d, e.name);
           if (e.isDirectory()) {
             walk(p, depth + 1);
           } else if (e.name.startsWith("agent-") && e.name.endsWith(".jsonl")) {
             try {
-              const st = (0, import_node_fs28.statSync)(p);
+              const st = (0, import_node_fs30.statSync)(p);
               found.push({ path: p, size: st.size, mtimeMs: st.mtimeMs });
             } catch {
               result.coverage.malformed++;
@@ -19550,7 +20447,7 @@ function fold(transcriptPath, opts = {}) {
           continue;
         }
         try {
-          ingest((0, import_node_fs28.readFileSync)(f.path, "utf8"), "subagent");
+          ingest((0, import_node_fs30.readFileSync)(f.path, "utf8"), "subagent");
           bytes += f.size;
           result.coverage.subagentFiles++;
         } catch {
@@ -19585,7 +20482,7 @@ function fold(transcriptPath, opts = {}) {
 }
 function classifyUnobserved(path) {
   try {
-    const st = (0, import_node_fs28.statSync)(path);
+    const st = (0, import_node_fs30.statSync)(path);
     if (!st.isFile()) return "unreadable";
   } catch {
     return "unreadable";
@@ -19889,20 +20786,20 @@ async function evidence(run2) {
 }
 
 // src/lib/cache-cleanup.ts
-var import_node_fs29 = require("node:fs");
+var import_node_fs31 = require("node:fs");
 var import_node_path22 = require("node:path");
 var CACHE_TTL_DAYS = 7;
 function pruneStaleCache() {
   try {
     const dir = projectPath(CACHE_DIR);
     const cutoff = Date.now() - CACHE_TTL_DAYS * 24 * 3600 * 1e3;
-    for (const entry of (0, import_node_fs29.readdirSync)(dir)) {
+    for (const entry of (0, import_node_fs31.readdirSync)(dir)) {
       if (!entry.startsWith("pending-")) continue;
       const path = (0, import_node_path22.join)(dir, entry);
       try {
-        const stat3 = (0, import_node_fs29.statSync)(path);
+        const stat3 = (0, import_node_fs31.statSync)(path);
         if (stat3.mtimeMs < cutoff) {
-          (0, import_node_fs29.unlinkSync)(path);
+          (0, import_node_fs31.unlinkSync)(path);
           logEvent("cache_entry_pruned", {
             path: entry,
             age_days: Math.round((Date.now() - stat3.mtimeMs) / 864e5)
@@ -19916,16 +20813,53 @@ function pruneStaleCache() {
 }
 
 // src/lib/context-files.ts
-var import_node_fs30 = require("node:fs");
+var import_node_fs32 = 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" });
@@ -19937,7 +20871,7 @@ function gatherContextFiles(contextPaths, deltaFiles) {
       continue;
     }
     try {
-      const content = (0, import_node_fs30.readFileSync)(safePath, "utf8");
+      const content = (0, import_node_fs32.readFileSync)(safePath, "utf8");
       const bytes = Buffer.byteLength(content);
       if (bytes > MAX_CONTEXT_FILE_BYTES) {
         logEvent("context_file_skipped", { path: filePath, reason: "too_large", bytes });
@@ -19983,9 +20917,14 @@ function gatherContextFiles(contextPaths, deltaFiles) {
 
 // src/commands/analyze/phases/07-context-files.ts
 async function contextFiles(run2) {
-  const { codeDelta, contextFilePaths } = run2;
-  const { kept: externalContext } = partitionVerityOwned(contextFilePaths ?? []);
-  const contextFiles2 = gatherContextFiles(externalContext, codeDelta.files);
+  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";
   }
@@ -19997,9 +20936,33 @@ async function contextFiles(run2) {
   });
 }
 
+// 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");
+var import_node_fs33 = require("node:fs");
 var import_node_path23 = require("node:path");
 var import_yaml2 = __toESM(require_dist());
 
@@ -20239,7 +21202,7 @@ function renderNodeMarkdown(candidate, nodeId, createdAt) {
   return fm;
 }
 async function runSeed(opts) {
-  if (!(0, import_node_fs31.existsSync)(STANDARD_FILE)) {
+  if (!(0, import_node_fs33.existsSync)(STANDARD_FILE)) {
     return { created: 0, failed: 0, skipped: "no_standard", candidates: [] };
   }
   let standardDoc;
@@ -20251,7 +21214,7 @@ async function runSeed(opts) {
   }
   const knowledgeSpec = standardDoc.knowledge_spec ?? {};
   let readmeContent;
-  if ((0, import_node_fs31.existsSync)("README.md")) {
+  if ((0, import_node_fs33.existsSync)("README.md")) {
     try {
       readmeContent = await (0, import_promises11.readFile)("README.md", "utf-8");
     } catch {
@@ -20259,7 +21222,7 @@ async function runSeed(opts) {
   }
   let claudeMdContent;
   for (const p of ["CLAUDE.md", ".claude/CLAUDE.md"]) {
-    if ((0, import_node_fs31.existsSync)(p)) {
+    if ((0, import_node_fs33.existsSync)(p)) {
       try {
         claudeMdContent = await (0, import_promises11.readFile)(p, "utf-8");
         break;
@@ -20283,7 +21246,7 @@ async function runSeed(opts) {
     return { created: 0, failed: 0, skipped: "no_candidates", candidates: [] };
   }
   const overviewPath = (0, import_node_path23.join)(MEMORY_DIR, "domain", "project-overview.md");
-  if ((0, import_node_fs31.existsSync)(overviewPath) && !opts.force) {
+  if ((0, import_node_fs33.existsSync)(overviewPath) && !opts.force) {
     return { created: 0, failed: 0, skipped: "already_seeded", candidates };
   }
   if (opts.dryRun) {
@@ -20338,7 +21301,7 @@ async function runSeed(opts) {
 }
 
 // src/commands/analyze/phases/08-memory-manifest.ts
-var import_node_fs32 = require("node:fs");
+var import_node_fs34 = require("node:fs");
 var import_node_path24 = require("node:path");
 async function memoryManifest(run2) {
   const { globals } = run2;
@@ -20350,8 +21313,8 @@ async function memoryManifest(run2) {
   try {
     await ensureMemoryDir();
     const seedMarker = (0, import_node_path24.join)(VERITY_DIR, ".seeded");
-    const hasStandard = (0, import_node_fs32.existsSync)(STANDARD_FILE);
-    const alreadyTried = (0, import_node_fs32.existsSync)(seedMarker);
+    const hasStandard = (0, import_node_fs34.existsSync)(STANDARD_FILE);
+    const alreadyTried = (0, import_node_fs34.existsSync)(seedMarker);
     if (hasStandard && !alreadyTried) {
       const preManifest = await buildManifest();
       if (preManifest.nodes.length === 0) {
@@ -20364,7 +21327,7 @@ async function memoryManifest(run2) {
             dryRun: false
           });
           if (seedResult.created > 0) {
-            (0, import_node_fs32.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} created=${seedResult.created}
+            (0, import_node_fs34.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} created=${seedResult.created}
 `);
             autoSeedNotice = `Seeded ${seedResult.created} knowledge node(s) from your existing Standard (one-time).`;
             logEvent("auto_seed_ran", {
@@ -20372,7 +21335,7 @@ async function memoryManifest(run2) {
               failed: seedResult.failed
             });
           } else if (seedResult.skipped === "already_seeded") {
-            (0, import_node_fs32.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} skipped=already_seeded
+            (0, import_node_fs34.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} skipped=already_seeded
 `);
           } else {
             logEvent("auto_seed_noop", {
@@ -20561,7 +21524,7 @@ async function workingMemory(run2) {
 }
 
 // src/lib/note-budget.ts
-var import_node_fs33 = require("node:fs");
+var import_node_fs35 = require("node:fs");
 var ADVISORY_BUDGET = { PASS: 1, WARN: 2 };
 var EPISODE_STALE_SECONDS = 30 * 60;
 var FRESH = { delivered: 0, tasksCompleted: 0, ts: 0 };
@@ -20583,9 +21546,9 @@ function advisoryBudgetSpent(episode, rawDecision) {
 }
 function readAdvisoryEpisode(sessionId) {
   const file = scopedFile(ADVISORY_EPISODE_FILE, sessionId);
-  if (!(0, import_node_fs33.existsSync)(file)) return null;
+  if (!(0, import_node_fs35.existsSync)(file)) return null;
   try {
-    const o = JSON.parse((0, import_node_fs33.readFileSync)(file, "utf-8")) ?? {};
+    const o = JSON.parse((0, import_node_fs35.readFileSync)(file, "utf-8")) ?? {};
     const delivered = typeof o.delivered === "number" ? o.delivered : NaN;
     if (isNaN(delivered)) return null;
     return {
@@ -20599,8 +21562,8 @@ function readAdvisoryEpisode(sessionId) {
 }
 function writeAdvisoryEpisode(episode, sessionId) {
   try {
-    (0, import_node_fs33.mkdirSync)(VERITY_DIR, { recursive: true });
-    (0, import_node_fs33.writeFileSync)(
+    (0, import_node_fs35.mkdirSync)(VERITY_DIR, { recursive: true });
+    (0, import_node_fs35.writeFileSync)(
       scopedFile(ADVISORY_EPISODE_FILE, sessionId),
       JSON.stringify({ v: 1, ...episode })
     );
@@ -20630,7 +21593,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) {
@@ -20646,7 +21609,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 "";
   }
@@ -20853,6 +21816,9 @@ async function buildRequest(run2) {
   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;
@@ -20914,14 +21880,14 @@ async function buildRequest(run2) {
 }
 
 // src/lib/offline.ts
-var import_node_fs34 = require("node:fs");
+var import_node_fs36 = require("node:fs");
 var import_node_crypto11 = require("node:crypto");
 function cacheRequest(body) {
   try {
-    (0, import_node_fs34.mkdirSync)(CACHE_DIR, { recursive: true });
+    (0, import_node_fs36.mkdirSync)(CACHE_DIR, { recursive: true });
     const suffix = (0, import_node_crypto11.randomBytes)(4).toString("hex");
     const filename = `pending-${Math.floor(Date.now() / 1e3)}-${suffix}.json`;
-    (0, import_node_fs34.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(redactRequest(body)));
+    (0, import_node_fs36.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(redactRequest(body)));
   } catch {
   }
 }
@@ -21040,7 +22006,7 @@ async function transmit(run2) {
 }
 
 // src/commands/analyze/phases/13-reconcile.ts
-var import_node_fs35 = require("node:fs");
+var import_node_fs37 = require("node:fs");
 var import_node_path26 = require("node:path");
 async function reconcile(run2) {
   const { actionSummary, allChanged, analyzable, baseline, baselineSessionId, codeDelta, contentHash, conversation, decision, foldResult, memory, memorySession, response, reviewable, securityFiles, turnId } = run2;
@@ -21070,7 +22036,7 @@ async function reconcile(run2) {
       const st = foldDossier(memorySession.d);
       openElsewhere = openBlockingElsewhere(st.statements, sentPaths, (file, line) => {
         try {
-          const src = (0, import_node_fs35.readFileSync)((0, import_node_path26.join)(repoRoot(), file), "utf8").split("\n");
+          const src = (0, import_node_fs37.readFileSync)((0, import_node_path26.join)(repoRoot(), file), "utf8").split("\n");
           const at = src[line - 1];
           return at === void 0 ? null : lineSha(at);
         } catch {
@@ -21701,6 +22667,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],
@@ -21717,7 +22685,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);
@@ -21750,7 +22718,7 @@ async function runAnalyze(opts, globals) {
 }
 
 // src/commands/baseline.ts
-var import_node_fs36 = require("node:fs");
+var import_node_fs38 = require("node:fs");
 function registerBaselineCommands(program2) {
   const baseline = program2.command("baseline").description("Manage the task-start working-tree baseline");
   baseline.command("capture").description("Snapshot the working tree at task start (used by SessionStart hook)").option("--session-id <id>", "Session id (overrides any value from stdin)").option("--source <source>", "Lifecycle hint: startup|resume|clear|compact").action(async (opts) => {
@@ -21759,7 +22727,7 @@ function registerBaselineCommands(program2) {
         process.chdir(repoRoot());
       } catch {
       }
-      if (!(0, import_node_fs36.existsSync)(VERITY_DIR)) {
+      if (!(0, import_node_fs38.existsSync)(VERITY_DIR)) {
         process.exit(0);
       }
       let sessionId = opts.sessionId;
@@ -21775,6 +22743,9 @@ function registerBaselineCommands(program2) {
           }
         }
       }
+      if (deferredToPlugin("baseline capture", sessionId ?? process.env.CLAUDE_SESSION_ID ?? null)) {
+        process.exit(0);
+      }
       const authForScope = await resolveToken(program2.opts().token);
       const scopeToken = authForScope.ok ? authForScope.data.token : void 0;
       const scopeSession = sessionId || process.env.CLAUDE_SESSION_ID || void 0;
@@ -21799,7 +22770,7 @@ async function readStdin() {
 }
 
 // src/commands/review.ts
-var import_node_fs37 = require("node:fs");
+var import_node_fs39 = require("node:fs");
 function registerReviewCommand(program2) {
   program2.command("review").description("Run on-demand Verity analysis (advisory, never blocks)").requiredOption("--files <paths>", "Comma-separated file list").option("--changed <paths>", "Subset of --files that were modified").option("--intent <text>", "User intent description (max 2000 chars)").option("--specs <paths>", "Comma-separated spec file paths").option("--json", "Output raw JSON response").action(async (opts) => {
     const globals = program2.opts();
@@ -21818,7 +22789,7 @@ async function runReview(opts, globals) {
   const securityFiles = filterSecurity(allFiles);
   let staticResults;
   if (isCodacyAvailable()) {
-    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).filter((f) => (0, import_node_fs37.existsSync)(f) || resolveFile(f) !== null);
+    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).filter((f) => (0, import_node_fs39.existsSync)(f) || resolveFile(f) !== null);
     staticResults = runCodacyAnalysis(scannable);
   } else {
     staticResults = {
@@ -21844,10 +22815,10 @@ async function runReview(opts, globals) {
     const specPaths = opts.specs.split(",").map((f) => f.trim()).filter(Boolean);
     specs = [];
     for (const p of specPaths) {
-      if (!(0, import_node_fs37.existsSync)(p)) continue;
+      if (!(0, import_node_fs39.existsSync)(p)) continue;
       try {
-        const { readFileSync: readFileSync25 } = await import("node:fs");
-        const content = readFileSync25(p, "utf-8");
+        const { readFileSync: readFileSync27 } = await import("node:fs");
+        const content = readFileSync27(p, "utf-8");
         specs.push({ path: p, content: content.slice(0, 10240) });
       } catch {
       }
@@ -21904,7 +22875,7 @@ async function runReview(opts, globals) {
 }
 
 // src/commands/guard.ts
-var import_node_fs38 = require("node:fs");
+var import_node_fs40 = require("node:fs");
 var import_node_path27 = require("node:path");
 var GUARD_BLOCK_CAP = 2;
 var GUARD_ITER_FILE = (0, import_node_path27.join)(VERITY_DIR, ".guard-iteration");
@@ -21952,7 +22923,7 @@ function readPreToolUseStdin() {
 }
 function readIterMap() {
   try {
-    const raw = JSON.parse((0, import_node_fs38.readFileSync)(GUARD_ITER_FILE, "utf-8"));
+    const raw = JSON.parse((0, import_node_fs40.readFileSync)(GUARD_ITER_FILE, "utf-8"));
     if (raw && typeof raw === "object") {
       if (typeof raw.moment === "string" && typeof raw.count === "number") {
         return { [raw.moment]: raw.count };
@@ -21972,10 +22943,10 @@ function readIter(moment) {
 }
 function writeIter(moment, count) {
   try {
-    (0, import_node_fs38.mkdirSync)(VERITY_DIR, { recursive: true });
+    (0, import_node_fs40.mkdirSync)(VERITY_DIR, { recursive: true });
     const map = readIterMap();
     map[moment] = count;
-    (0, import_node_fs38.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
+    (0, import_node_fs40.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
   } catch {
   }
 }
@@ -21985,16 +22956,16 @@ function resetIter(moment) {
     if (!(moment in map)) return;
     delete map[moment];
     if (Object.keys(map).length === 0) {
-      if ((0, import_node_fs38.existsSync)(GUARD_ITER_FILE)) (0, import_node_fs38.unlinkSync)(GUARD_ITER_FILE);
+      if ((0, import_node_fs40.existsSync)(GUARD_ITER_FILE)) (0, import_node_fs40.unlinkSync)(GUARD_ITER_FILE);
     } else {
-      (0, import_node_fs38.mkdirSync)(VERITY_DIR, { recursive: true });
-      (0, import_node_fs38.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
+      (0, import_node_fs40.mkdirSync)(VERITY_DIR, { recursive: true });
+      (0, import_node_fs40.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
     }
   } catch {
   }
 }
 function registerGuardCommand(program2) {
-  program2.command("guard").description("Git-moment gate: review staged/to-push changes before a commit/push (PreToolUse hook)").option("--on <moments>", "Which git moments to gate: commit,push", "commit,push").option("--json", "Output raw JSON response (debug)").action(async (opts) => {
+  program2.command("guard").description("Git-moment gate: review staged/to-push changes before a commit/push (PreToolUse hook)").option("--on <moments>", "Which git moments to gate: commit,push (default: the project config)").option("--json", "Output raw JSON response (debug)").action(async (opts) => {
     const globals = program2.opts();
     try {
       await runGuard(opts, globals);
@@ -22059,7 +23030,7 @@ function buildGuardRequest(moment, files, codeDelta, iter, sessionId, statedInte
   const securityFiles = filterSecurity(files);
   let staticResults;
   if (isCodacyAvailable()) {
-    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).map((f) => (0, import_node_fs38.existsSync)(f) ? f : resolveFile(f)).filter((f) => f !== null);
+    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).map((f) => (0, import_node_fs40.existsSync)(f) ? f : resolveFile(f)).filter((f) => f !== null);
     staticResults = runCodacyAnalysis(scannable);
   } else {
     staticResults = { tool: "@codacy/analysis-cli", findings: [], summary: { total_findings: 0, by_severity: {}, tools_run: [] } };
@@ -22116,6 +23087,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}):`);
@@ -22131,8 +23103,10 @@ function emitAllowNotice(userMsg, agentMsg) {
   process.exit(0);
 }
 async function runGuard(opts, globals) {
-  const on = opts.on.split(",").map((s) => s.trim()).filter((s) => s === "commit" || s === "push");
+  const on = resolveGuardMoments(opts.on);
+  if (on.length === 0) process.exit(0);
   const { command, cwd, sessionId } = await readPreToolUseStdin();
+  if (deferredToPlugin("guard", sessionId)) process.exit(0);
   const moment = classifyCommand(command, on);
   if (!moment) process.exit(0);
   const verb = moment === "pre-commit" ? "commit" : "push";
@@ -22182,6 +23156,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_fs40.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,
@@ -22189,7 +23196,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();
@@ -22382,7 +23390,7 @@ function registerIgnoreCommand(program2) {
 
 // src/commands/waive.ts
 var import_node_crypto12 = require("node:crypto");
-var import_node_fs39 = require("node:fs");
+var import_node_fs41 = require("node:fs");
 function registerWaiveCommand(program2) {
   program2.command("waive <pattern-id>").description("Record an accepted-risk disposition for an open finding (voids when the file changes)").option("--file <path>", "File the finding is anchored to, REPO-RELATIVE (recommended \u2014 narrows the waive)").requiredOption("--reason <text>", "The human disposition this records (reviewer finding, ADR, \u2026)").action(async (patternId, opts) => {
     const globals = program2.opts();
@@ -22411,7 +23419,7 @@ function registerWaiveCommand(program2) {
     if (opts.file) {
       body.file = opts.file;
       try {
-        body.file_sha256 = (0, import_node_crypto12.createHash)("sha256").update((0, import_node_fs39.readFileSync)(opts.file)).digest("hex");
+        body.file_sha256 = (0, import_node_crypto12.createHash)("sha256").update((0, import_node_fs41.readFileSync)(opts.file)).digest("hex");
       } catch {
         printError(`Cannot read ${opts.file} \u2014 run from the repo root, or omit --file to waive by pattern.`);
         process.exit(1);
@@ -22436,10 +23444,10 @@ function registerWaiveCommand(program2) {
 }
 
 // src/commands/init.ts
-var import_node_fs44 = require("node:fs");
+var import_node_fs46 = require("node:fs");
 var import_promises14 = require("node:fs/promises");
 var import_node_path29 = require("node:path");
-var import_node_child_process13 = require("node:child_process");
+var import_node_child_process14 = require("node:child_process");
 
 // src/lib/banner.ts
 var WORDMARK = [
@@ -22517,14 +23525,14 @@ function printPhase(n, of, title, subtitle) {
 }
 
 // src/commands/doctor.ts
-var import_node_fs42 = require("node:fs");
+var import_node_fs44 = require("node:fs");
 
 // src/lib/prereqs.ts
-var import_node_child_process10 = require("node:child_process");
+var import_node_child_process11 = require("node:child_process");
 var MIN_NODE_MAJOR = 20;
 function which(bin) {
   try {
-    const out = (0, import_node_child_process10.execSync)(`command -v ${bin}`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    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;
@@ -22546,7 +23554,7 @@ function checkNode() {
 function checkGit() {
   let detail = "";
   try {
-    detail = (0, import_node_child_process10.execSync)("git --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    detail = (0, import_node_child_process11.execSync)("git --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
     return {
       id: "git",
@@ -22584,7 +23592,7 @@ function checkAnalysisCli() {
 var INSTALL_TIMEOUT_MS = 12e4;
 function run(command, args, opts = {}) {
   return new Promise((resolve4) => {
-    const child = (0, import_node_child_process10.spawn)(command, args, {
+    const child = (0, import_node_child_process11.spawn)(command, args, {
       stdio: opts.inherit ? "inherit" : "pipe",
       timeout: INSTALL_TIMEOUT_MS
     });
@@ -22636,8 +23644,8 @@ async function checkPrereqs(opts = {}) {
 var import_promises12 = require("node:fs/promises");
 
 // src/lib/gitignore.ts
-var import_node_child_process11 = require("node:child_process");
-var import_node_fs40 = require("node:fs");
+var import_node_child_process12 = require("node:child_process");
+var import_node_fs42 = require("node:fs");
 var VERITY_GITIGNORE_MARKER = "# Verity \u2014 machine-local state.";
 var SETTINGS_LOCAL_IGNORE_ENTRY = ".claude/settings.local.json";
 var VERITY_GITIGNORE_BLOCK = [
@@ -22653,7 +23661,7 @@ var VERITY_GITIGNORE_BLOCK = [
 var BREAKING_ENTRIES = /* @__PURE__ */ new Set([".verity/", ".verity"]);
 function isIgnored2(path) {
   try {
-    (0, import_node_child_process11.execSync)(`git check-ignore -q -- "${path}"`, { stdio: "pipe" });
+    (0, import_node_child_process12.execSync)(`git check-ignore -q -- "${path}"`, { stdio: "pipe" });
     return true;
   } catch (err) {
     return err.status === 1 ? false : null;
@@ -22670,7 +23678,7 @@ function semanticsHold() {
 function ensureVerityGitignore() {
   let content = "";
   try {
-    content = (0, import_node_fs40.readFileSync)(".gitignore", "utf-8");
+    content = (0, import_node_fs42.readFileSync)(".gitignore", "utf-8");
   } catch {
   }
   const hasMarker = content.includes(VERITY_GITIGNORE_MARKER);
@@ -22691,7 +23699,7 @@ function ensureVerityGitignore() {
       const sep2 = next === "" ? "" : next.endsWith("\n") ? "\n" : "\n\n";
       next = next + sep2 + VERITY_GITIGNORE_BLOCK;
     }
-    (0, import_node_fs40.writeFileSync)(".gitignore", next);
+    (0, import_node_fs42.writeFileSync)(".gitignore", next);
     return verified(needsRepair ? "repaired" : "added");
   } catch {
     return "failed";
@@ -22700,7 +23708,7 @@ function ensureVerityGitignore() {
 function committedVerityState() {
   let out = "";
   try {
-    out = (0, import_node_child_process11.execSync)("git ls-files -z -- .verity", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    out = (0, import_node_child_process12.execSync)("git ls-files -z -- .verity", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
   } catch {
     return [];
   }
@@ -22710,10 +23718,10 @@ function untrackVerityState() {
   const tracked = committedVerityState();
   if (tracked.length === 0) return "none";
   try {
-    (0, import_node_child_process11.execSync)("git rm -r --cached --quiet -- .verity", { stdio: "pipe" });
+    (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_process11.execSync)(`git add -- "${keep}"`, { stdio: "pipe" });
+        (0, import_node_child_process12.execSync)(`git add -- "${keep}"`, { stdio: "pipe" });
       } catch {
       }
     }
@@ -22814,11 +23822,11 @@ async function uninstallTelemetry() {
 
 // src/lib/setup-state.ts
 var import_promises13 = require("node:fs/promises");
-var import_node_fs41 = require("node:fs");
+var import_node_fs43 = 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;
+  if (!(0, import_node_fs43.existsSync)(path)) return null;
   try {
     const parsed = JSON.parse(await (0, import_promises13.readFile)(path, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : null;
@@ -22840,9 +23848,9 @@ async function buildReport() {
   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))
+    standard: (0, import_node_fs44.existsSync)(projectPath(STANDARD_FILE)),
+    analysisConfig: (0, import_node_fs44.existsSync)(projectPath(CODACY_CONFIG_FILE)),
+    verityMd: (0, import_node_fs44.existsSync)(projectPath(VERITY_MD_FILE))
   };
   const next = [];
   for (const c of prereqs.checks) {
@@ -22915,16 +23923,16 @@ function registerDoctorCommand(program2) {
 }
 
 // src/commands/migrate.ts
-var import_node_fs43 = require("node:fs");
+var import_node_fs45 = require("node:fs");
 var import_node_path28 = require("node:path");
-var import_node_child_process12 = require("node:child_process");
+var import_node_child_process13 = require("node:child_process");
 var LEGACY_NPM_PACKAGE = "@codacy/gate-cli";
 function defaultNpmRemover(pkg) {
-  (0, import_node_child_process12.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_process12.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;
@@ -22932,7 +23940,7 @@ function isGitTracked(cwd, relPath) {
 }
 function isGitRepo(cwd) {
   try {
-    (0, import_node_child_process12.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;
@@ -22955,10 +23963,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_fs43.existsSync)(gateDir) && !(0, import_node_fs43.existsSync)(verityDir)) {
+  if ((0, import_node_fs45.existsSync)(gateDir) && !(0, import_node_fs45.existsSync)(verityDir)) {
     return migrateProjectDirRename(root, gateDir, verityDir, actions);
   }
-  if ((0, import_node_fs43.existsSync)(gateDir) && (0, import_node_fs43.existsSync)(verityDir)) {
+  if ((0, import_node_fs45.existsSync)(gateDir) && (0, import_node_fs45.existsSync)(verityDir)) {
     return migrateProjectDirCarry(gateDir, verityDir, actions);
   }
   return false;
@@ -22972,20 +23980,20 @@ function migrateProjectDirRename(root, gateDir, verityDir, actions) {
       );
     }
     try {
-      (0, import_node_child_process12.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_fs43.existsSync)(gateDir)) {
+    if ((0, import_node_fs45.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_fs43.rmSync)(gateDir, { recursive: true, force: true });
+        (0, import_node_fs45.rmSync)(gateDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -23001,7 +24009,7 @@ function migrateProjectDirCarry(gateDir, verityDir, actions) {
     actions.push(`Carried ${carried} legacy file(s) from .gate/ into .verity/`);
   }
   try {
-    (0, import_node_fs43.rmSync)(gateDir, { recursive: true, force: true });
+    (0, import_node_fs45.rmSync)(gateDir, { recursive: true, force: true });
   } catch {
   }
   return carried > 0;
@@ -23010,9 +24018,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_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 });
+  if (!(0, import_node_fs45.existsSync)(gateCreds)) return;
+  if (!(0, import_node_fs45.existsSync)(verityCreds)) {
+    (0, import_node_fs45.mkdirSync)((0, import_node_path28.join)(home, ".verity"), { recursive: true });
     moveFile(gateCreds, verityCreds);
     actions.push("Moved ~/.gate/credentials \u2192 ~/.verity/credentials");
     return;
@@ -23035,7 +24043,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_fs43.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
+  const hadLegacyBlock = (0, import_node_fs45.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
   if (!hadLegacyBlock) return;
   try {
     await ensureClaudeMdPointer(root);
@@ -23047,11 +24055,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_fs43.existsSync)(gateMd) || (0, import_node_fs43.existsSync)(verityMd)) return;
+  if (!(0, import_node_fs45.existsSync)(gateMd) || (0, import_node_fs45.existsSync)(verityMd)) return;
   let moved = false;
   if (isGitRepo(root) && isGitTracked(root, "GATE.md")) {
     try {
-      (0, import_node_child_process12.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 {
     }
@@ -23059,12 +24067,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_fs43.writeFileSync)(verityMd, refreshed);
+  if (refreshed !== content) (0, import_node_fs45.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_fs43.existsSync)(file)) return;
+  if (!(0, import_node_fs45.existsSync)(file)) return;
   let settings;
   try {
     settings = JSON.parse(readFileSyncSafe(file) || "{}");
@@ -23112,21 +24120,21 @@ function mergeGlobalCredentials(gateCreds, verityCreds) {
   }
   if (toAppend.length > 0) {
     const sep2 = verityContent.endsWith("\n") || verityContent === "" ? "" : "\n";
-    (0, import_node_fs43.writeFileSync)(verityCreds, verityContent + sep2 + toAppend.join("\n") + "\n");
+    (0, import_node_fs45.writeFileSync)(verityCreds, verityContent + sep2 + toAppend.join("\n") + "\n");
   }
-  (0, import_node_fs43.rmSync)(gateCreds, { force: true });
+  (0, import_node_fs45.rmSync)(gateCreds, { force: true });
   return toAppend.length;
 }
 function readFileSyncSafe(path) {
   try {
-    return (0, import_node_fs43.readFileSync)(path, "utf-8");
+    return (0, import_node_fs45.readFileSync)(path, "utf-8");
   } catch {
     return "";
   }
 }
 function hasStagedChanges(root) {
   try {
-    (0, import_node_child_process12.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;
@@ -23134,35 +24142,35 @@ function hasStagedChanges(root) {
 }
 function moveDir(from, to) {
   try {
-    (0, import_node_fs43.renameSync)(from, to);
+    (0, import_node_fs45.renameSync)(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
-    (0, import_node_fs43.cpSync)(from, to, { recursive: true });
-    (0, import_node_fs43.rmSync)(from, { recursive: true, force: true });
+    (0, import_node_fs45.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs45.rmSync)(from, { recursive: true, force: true });
   }
 }
 function moveFile(from, to) {
   try {
-    (0, import_node_fs43.renameSync)(from, to);
+    (0, import_node_fs45.renameSync)(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
-    (0, import_node_fs43.cpSync)(from, to);
-    (0, import_node_fs43.rmSync)(from, { force: true });
+    (0, import_node_fs45.cpSync)(from, to);
+    (0, import_node_fs45.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_fs43.readdirSync)(srcDir)) {
+    for (const entry of (0, import_node_fs45.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_fs43.statSync)(src).isDirectory()) {
+      if ((0, import_node_fs45.statSync)(src).isDirectory()) {
         walk(rel);
-      } 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);
+      } else if (!(0, import_node_fs45.existsSync)(dest)) {
+        (0, import_node_fs45.mkdirSync)((0, import_node_path28.dirname)(dest), { recursive: true });
+        (0, import_node_fs45.cpSync)(src, dest);
         copied++;
       }
     }
@@ -23173,20 +24181,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_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"))) {
+  if ((0, import_node_fs45.existsSync)(gateDir) && !(0, import_node_fs45.existsSync)(verityDir)) return true;
+  if ((0, import_node_fs45.existsSync)(gateDir) && (0, import_node_fs45.existsSync)(verityDir)) {
+    if ((0, import_node_fs45.existsSync)((0, import_node_path28.join)(gateDir, "credentials")) && !(0, import_node_fs45.existsSync)((0, import_node_path28.join)(verityDir, "credentials"))) {
       return true;
     }
-    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"))) {
+    if ((0, import_node_fs45.existsSync)((0, import_node_path28.join)(gateDir, "memory")) && !(0, import_node_fs45.existsSync)((0, import_node_path28.join)(verityDir, "memory"))) {
       return true;
     }
   }
   const claudeMd = (0, import_node_path28.join)(root, "CLAUDE.md");
-  if ((0, import_node_fs43.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd))) {
+  if ((0, import_node_fs45.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd))) {
     return true;
   }
-  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"))) {
+  if ((0, import_node_fs45.existsSync)((0, import_node_path28.join)(root, "GATE.md")) && !(0, import_node_fs45.existsSync)((0, import_node_path28.join)(root, "VERITY.md"))) {
     return true;
   }
   if (await hasLegacyHooksAt(root)) return true;
@@ -23358,7 +24366,7 @@ async function runOptionalAuth(resolution, opts = {}) {
   }
   let remote = "";
   try {
-    remote = (0, import_node_child_process13.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) {
@@ -23412,7 +24420,7 @@ function resolveDataDir() {
     // local dev: running from repo root
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs44.existsSync)((0, import_node_path29.join)(candidate, "skills"))) {
+    if ((0, import_node_fs46.existsSync)((0, import_node_path29.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -23428,7 +24436,7 @@ 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 })) {
+      for (const e of (0, import_node_fs46.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);
@@ -23578,20 +24586,76 @@ async function handoffToSetup(enabled, claudeInstalled) {
   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_process13.spawnSync)("claude", ["/verity-setup"], { stdio: "inherit" });
+  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);
 }
+async function installSkills(force, step) {
+  step("Installing skills");
+  const dataDir = resolveDataDir();
+  const skillsSource = (0, import_node_path29.join)(dataDir, "skills");
+  const skillsDest = ".claude/skills";
+  let skillsInstalled = 0;
+  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_fs46.existsSync)(src)) {
+      printWarn(`  Skill data not found: ${skill}`);
+      continue;
+    }
+    if ((0, import_node_fs46.existsSync)(dest) && !force && await skillIsCurrent(src, dest)) {
+      skillsInstalled++;
+      continue;
+    }
+    await copyDir(src, dest);
+    skillsInstalled++;
+  }
+  printInfo(`  ${skillsInstalled}/${SKILLS.length} skills installed to .claude/skills/ \u2713`);
+}
+async function adoptPluginWiring(gitMoments, moments) {
+  const settings = await readSettings();
+  const stripped = removeVerityHooks(settings);
+  const hadAny = JSON.stringify(settings.hooks ?? {}) !== JSON.stringify(stripped.hooks ?? {});
+  if (hadAny) {
+    await writeSettings(stripped);
+    printInfo("  Removed this project's Verity hooks from .claude/settings.json \u2713");
+    printInfo("    The plugin wires them now, so each turn is reviewed once.");
+  } else {
+    printInfo("  Wired by the Verity plugin \u2014 nothing to reconcile here \u2713");
+  }
+  printInfo(`  Pre-commit gate: ${gitMoments.includes("commit") ? "on" : "off"}`);
+  printInfo(`  Pre-push/PR gate: ${gitMoments.includes("push") ? "on" : "off"}`);
+  printInfo("  Stop + intent + baseline + compact + session-end: always on \u2713");
+  if (!moments.includes("stop")) {
+    printWarn("  Turning the Stop review off is not yet supported under the plugin \u2014 it stays on.");
+  }
+}
+async function reconcileOwnWiring(moments) {
+  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");
+  }
+}
 function registerInitCommand(program2) {
-  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) => {
+  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").option(
+    "--plugin-mode",
+    "The Claude Code plugin owns the skills and hooks: install neither, and remove any this project already has"
+  ).action(async (opts) => {
     const force = opts.force ?? false;
     const wantsHandoff = opts.setup !== false;
     const defaultsOnly = (opts.yes ?? false) || !interactive();
+    const pluginMode = opts.pluginMode ?? pluginActiveHere();
     const projectMarkers = [".git", "package.json", "pyproject.toml", "go.mod", "Cargo.toml", "Gemfile", "pom.xml", "build.gradle"];
-    const isProject = projectMarkers.some((m) => (0, import_node_fs44.existsSync)(m));
+    const isProject = projectMarkers.some((m) => (0, import_node_fs46.existsSync)(m));
     if (!isProject) {
       printError("No project detected in the current directory.");
       printInfo('Run "verity init" from your project root.');
@@ -23639,26 +24703,11 @@ function registerInitCommand(program2) {
     }
     const claudeInstalled = prereqs.checks.some((c) => c.id === "claude" && c.status === "ok");
     console.log("");
-    step("Installing skills");
-    const dataDir = resolveDataDir();
-    const skillsSource = (0, import_node_path29.join)(dataDir, "skills");
-    const skillsDest = ".claude/skills";
-    let skillsInstalled = 0;
-    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_fs44.existsSync)(src)) {
-        printWarn(`  Skill data not found: ${skill}`);
-        continue;
-      }
-      if ((0, import_node_fs44.existsSync)(dest) && !force && await skillIsCurrent(src, dest)) {
-        skillsInstalled++;
-        continue;
-      }
-      await copyDir(src, dest);
-      skillsInstalled++;
+    if (pluginMode) {
+      printInfo("Skipping skills \u2014 the Verity plugin provides them, namespaced as /verity:<name>.");
+    } else {
+      await installSkills(force, step);
     }
-    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);
@@ -23705,15 +24754,15 @@ function registerInitCommand(program2) {
     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");
+    const gitMoments = [
+      ...moments.includes("pre-commit") ? ["commit"] : [],
+      ...moments.includes("pre-push") ? ["push"] : []
+    ];
+    writeProjectConfig({ git_moments: gitMoments });
+    if (pluginMode) {
+      await adoptPluginWiring(gitMoments, moments);
+    } else {
+      await reconcileOwnWiring(moments);
     }
     console.log("");
     step("Sign in to Verity (optional)");
@@ -23762,7 +24811,7 @@ function registerInitCommand(program2) {
         ...telemetryChoice ? { telemetry: telemetryChoice } : {},
         init: {
           completed_at: (/* @__PURE__ */ new Date()).toISOString(),
-          cli_version: true ? "0.31.1-experimental.be74f71" : "dev"
+          cli_version: true ? "0.31.2" : "dev"
         }
       });
     } catch (err) {
@@ -23771,9 +24820,13 @@ function registerInitCommand(program2) {
     console.log("");
     printInfo("This machine is set up.");
     console.log("");
-    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");
+    if (pluginMode) {
+      console.log("    (skills and hooks come from the Verity plugin, not this project)");
+    } else {
+      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)");
@@ -23786,7 +24839,7 @@ function registerInitCommand(program2) {
 }
 
 // src/commands/uninstall.ts
-var import_node_fs45 = require("node:fs");
+var import_node_fs47 = require("node:fs");
 var import_node_path30 = require("node:path");
 var SKILL_NAMES = [
   "verity-setup",
@@ -23807,10 +24860,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_fs45.existsSync)(dir)) {
+      if ((0, import_node_fs47.existsSync)(dir)) {
         actions.push({
           label: `Remove .claude/skills/${name}/`,
-          apply: () => (0, import_node_fs45.rmSync)(dir, { recursive: true, force: true })
+          apply: () => (0, import_node_fs47.rmSync)(dir, { recursive: true, force: true })
         });
       }
     }
@@ -23824,24 +24877,24 @@ function registerUninstallCommand(program2) {
       });
     }
     const verityDir = projectPath(VERITY_DIR);
-    if ((0, import_node_fs45.existsSync)(verityDir)) {
+    if ((0, import_node_fs47.existsSync)(verityDir)) {
       actions.push({
         label: `Remove ${VERITY_DIR}/`,
-        apply: () => (0, import_node_fs45.rmSync)(verityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs47.rmSync)(verityDir, { recursive: true, force: true })
       });
     }
     if (!keepVerityMd) {
       const verityMd = projectPath(VERITY_MD_FILE);
-      if ((0, import_node_fs45.existsSync)(verityMd)) {
+      if ((0, import_node_fs47.existsSync)(verityMd)) {
         actions.push({
           label: `Remove ${VERITY_MD_FILE}`,
-          apply: () => (0, import_node_fs45.rmSync)(verityMd, { force: true })
+          apply: () => (0, import_node_fs47.rmSync)(verityMd, { force: true })
         });
       }
     }
     const cleanupEmptyDir = (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);
+      if ((0, import_node_fs47.existsSync)(path) && (0, import_node_fs47.statSync)(path).isDirectory() && (0, import_node_fs47.readdirSync)(path).length === 0) {
+        (0, import_node_fs47.rmdirSync)(path);
       }
     };
     actions.push({
@@ -23853,10 +24906,10 @@ function registerUninstallCommand(program2) {
     });
     const home = process.env.HOME ?? "";
     const globalVerityDir = (0, import_node_path30.join)(home, ".verity");
-    if (purgeGlobal && (0, import_node_fs45.existsSync)(globalVerityDir)) {
+    if (purgeGlobal && (0, import_node_fs47.existsSync)(globalVerityDir)) {
       actions.push({
         label: `Remove ~/.verity/ (global credentials \u2014 reconnect requires re-registration)`,
-        apply: () => (0, import_node_fs45.rmSync)(globalVerityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs47.rmSync)(globalVerityDir, { recursive: true, force: true })
       });
     }
     if (actions.length === 0) {
@@ -24050,7 +25103,7 @@ function registerTaskCommands(program2) {
 }
 
 // src/commands/reset.ts
-var import_node_fs46 = require("node:fs");
+var import_node_fs48 = 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) => {
@@ -24088,11 +25141,11 @@ function registerResetCommand(program2) {
     }
     const cacheDir = projectPath(CACHE_DIR);
     let purged = 0;
-    if ((0, import_node_fs46.existsSync)(cacheDir)) {
-      for (const entry of (0, import_node_fs46.readdirSync)(cacheDir)) {
+    if ((0, import_node_fs48.existsSync)(cacheDir)) {
+      for (const entry of (0, import_node_fs48.readdirSync)(cacheDir)) {
         if (entry.startsWith("pending-")) {
           try {
-            (0, import_node_fs46.unlinkSync)((0, import_node_path31.join)(cacheDir, entry));
+            (0, import_node_fs48.unlinkSync)((0, import_node_path31.join)(cacheDir, entry));
             purged++;
           } catch {
           }
@@ -24107,19 +25160,19 @@ function registerResetCommand(program2) {
       projectPath(`${VERITY_DIR}/.last-analysis`)
     ];
     for (const file of filesToClear) {
-      if ((0, import_node_fs46.existsSync)(file)) {
+      if ((0, import_node_fs48.existsSync)(file)) {
         try {
-          (0, import_node_fs46.writeFileSync)(file, "");
+          (0, import_node_fs48.writeFileSync)(file, "");
         } catch {
         }
       }
     }
     if (opts.all) {
       const logsDir = projectPath(`${VERITY_DIR}/.logs`);
-      if ((0, import_node_fs46.existsSync)(logsDir)) {
-        for (const entry of (0, import_node_fs46.readdirSync)(logsDir)) {
+      if ((0, import_node_fs48.existsSync)(logsDir)) {
+        for (const entry of (0, import_node_fs48.readdirSync)(logsDir)) {
           try {
-            (0, import_node_fs46.unlinkSync)((0, import_node_path31.join)(logsDir, entry));
+            (0, import_node_fs48.unlinkSync)((0, import_node_path31.join)(logsDir, entry));
           } catch {
           }
         }
@@ -24427,8 +25480,8 @@ function registerTelemetryCommands(program2) {
 }
 
 // src/cli.ts
-program.name("verity").description("CLI for Verity quality gate service").version("0.31.1-experimental.be74f71").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.be74f71");
+program.name("verity").description("CLI for Verity quality gate service").version("0.31.2").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.2");
   setUserNamedServiceUrl(program.opts().serviceUrl);
   try {
     await foldLegacyLocalCredential();