@codacy/verity-cli 0.29.4-experimental.f2e812c → 0.30.0-experimental.43e7755

package/bin/verity.js

@@ -6974,10 +6974,10 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start, key, sep, value } = collItem;
+        const { start, key, sep: sep2, value } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
-          next: key ?? sep?.[0],
+          next: key ?? sep2?.[0],
           offset,
           onError,
           parentIndent: bm.indent,
@@ -6991,7 +6991,7 @@ var require_resolve_block_map = __commonJS({
             else if ("indent" in key && key.indent !== bm.indent)
               onError(offset, "BAD_INDENT", startColMsg);
           }
-          if (!keyProps.anchor && !keyProps.tag && !sep) {
+          if (!keyProps.anchor && !keyProps.tag && !sep2) {
             commentEnd = keyProps.end;
             if (keyProps.comment) {
               if (map.comment)
@@ -7015,7 +7015,7 @@ var require_resolve_block_map = __commonJS({
         ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
           onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-        const valueProps = resolveProps.resolveProps(sep ?? [], {
+        const valueProps = resolveProps.resolveProps(sep2 ?? [], {
           indicator: "map-value-ind",
           next: value,
           offset: keyNode.range[2],
@@ -7031,7 +7031,7 @@ var require_resolve_block_map = __commonJS({
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep2, null, valueProps, onError);
           if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
           offset = valueNode.range[2];
@@ -7122,7 +7122,7 @@ var require_resolve_end = __commonJS({
       let comment = "";
       if (end) {
         let hasSpace = false;
-        let sep = "";
+        let sep2 = "";
         for (const token of end) {
           const { source, type } = token;
           switch (type) {
@@ -7136,13 +7136,13 @@ var require_resolve_end = __commonJS({
               if (!comment)
                 comment = cb;
               else
-                comment += sep + cb;
-              sep = "";
+                comment += sep2 + cb;
+              sep2 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep += source;
+                sep2 += source;
               hasSpace = true;
               break;
             default:
@@ -7185,18 +7185,18 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
-        const { start, key, sep, value } = collItem;
+        const { start, key, sep: sep2, value } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key ?? sep?.[0],
+          next: key ?? sep2?.[0],
           offset,
           onError,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep && !value) {
+          if (!props.anchor && !props.tag && !sep2 && !value) {
             if (i === 0 && props.comma)
               onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i < fc.items.length - 1)
@@ -7250,8 +7250,8 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep, null, props, onError);
+        if (!isMap && !sep2 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep2, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
           if (isBlock(value))
@@ -7263,7 +7263,7 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(key))
             onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
           ctx.atKey = false;
-          const valueProps = resolveProps.resolveProps(sep ?? [], {
+          const valueProps = resolveProps.resolveProps(sep2 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
             next: value,
@@ -7274,8 +7274,8 @@ var require_resolve_flow_collection = __commonJS({
           });
           if (valueProps.found) {
             if (!isMap && !props.found && ctx.options.strict) {
-              if (sep)
-                for (const st of sep) {
+              if (sep2)
+                for (const st of sep2) {
                   if (st === valueProps.found)
                     break;
                   if (st.type === "newline") {
@@ -7292,7 +7292,7 @@ var require_resolve_flow_collection = __commonJS({
             else
               onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep2, null, valueProps, onError) : null;
           if (valueNode) {
             if (isBlock(value))
               onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -7472,7 +7472,7 @@ var require_resolve_block_scalar = __commonJS({
           chompStart = i + 1;
       }
       let value = "";
-      let sep = "";
+      let sep2 = "";
       let prevMoreIndented = false;
       for (let i = 0; i < contentStart; ++i)
         value += lines[i][0].slice(trimIndent) + "\n";
@@ -7489,24 +7489,24 @@ var require_resolve_block_scalar = __commonJS({
           indent = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep + indent.slice(trimIndent) + content;
-          sep = "\n";
+          value += sep2 + indent.slice(trimIndent) + content;
+          sep2 = "\n";
         } else if (indent.length > trimIndent || content[0] === "	") {
-          if (sep === " ")
-            sep = "\n";
-          else if (!prevMoreIndented && sep === "\n")
-            sep = "\n\n";
-          value += sep + indent.slice(trimIndent) + content;
-          sep = "\n";
+          if (sep2 === " ")
+            sep2 = "\n";
+          else if (!prevMoreIndented && sep2 === "\n")
+            sep2 = "\n\n";
+          value += sep2 + indent.slice(trimIndent) + content;
+          sep2 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep === "\n")
+          if (sep2 === "\n")
             value += "\n";
           else
-            sep = "\n";
+            sep2 = "\n";
         } else {
-          value += sep + content;
-          sep = " ";
+          value += sep2 + content;
+          sep2 = " ";
           prevMoreIndented = false;
         }
       }
@@ -7684,25 +7684,25 @@ var require_resolve_flow_scalar = __commonJS({
       if (!match)
         return source;
       let res = match[1];
-      let sep = " ";
+      let sep2 = " ";
       let pos = first.lastIndex;
       line.lastIndex = pos;
       while (match = line.exec(source)) {
         if (match[1] === "") {
-          if (sep === "\n")
-            res += sep;
+          if (sep2 === "\n")
+            res += sep2;
           else
-            sep = "\n";
+            sep2 = "\n";
         } else {
-          res += sep + match[1];
-          sep = " ";
+          res += sep2 + match[1];
+          sep2 = " ";
         }
         pos = line.lastIndex;
       }
       const last = /[ \t]*(.*)/sy;
       last.lastIndex = pos;
       match = last.exec(source);
-      return res + sep + (match?.[1] ?? "");
+      return res + sep2 + (match?.[1] ?? "");
     }
     function doubleQuotedValue(source, onError) {
       let res = "";
@@ -8509,14 +8509,14 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key, sep, value }) {
+    function stringifyItem({ start, key, sep: sep2, value }) {
       let res = "";
       for (const st of start)
         res += st.source;
       if (key)
         res += stringifyToken(key);
-      if (sep)
-        for (const st of sep)
+      if (sep2)
+        for (const st of sep2)
           res += st.source;
       if (value)
         res += stringifyToken(value);
@@ -9659,18 +9659,18 @@ var require_parser = __commonJS({
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
-          let sep;
+          let sep2;
           if (scalar.end) {
-            sep = scalar.end;
-            sep.push(this.sourceToken);
+            sep2 = scalar.end;
+            sep2.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep = [this.sourceToken];
+            sep2 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start, key: scalar, sep }]
+            items: [{ start, key: scalar, sep: sep2 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
@@ -9822,15 +9822,15 @@ var require_parser = __commonJS({
                 } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                   const start2 = getFirstKeyStartProps(it.start);
                   const key = it.key;
-                  const sep = it.sep;
-                  sep.push(this.sourceToken);
+                  const sep2 = it.sep;
+                  sep2.push(this.sourceToken);
                   delete it.key;
                   delete it.sep;
                   this.stack.push({
                     type: "block-map",
                     offset: this.offset,
                     indent: this.indent,
-                    items: [{ start: start2, key, sep }]
+                    items: [{ start: start2, key, sep: sep2 }]
                   });
                 } else if (start.length > 0) {
                   it.sep = it.sep.concat(start, this.sourceToken);
@@ -10024,13 +10024,13 @@ var require_parser = __commonJS({
             const prev = getPrevProps(parent);
             const start = getFirstKeyStartProps(prev);
             fixFlowSeqItems(fc);
-            const sep = fc.end.splice(1, fc.end.length);
-            sep.push(this.sourceToken);
+            const sep2 = fc.end.splice(1, fc.end.length);
+            sep2.push(this.sourceToken);
             const map = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start, key: fc, sep }]
+              items: [{ start, key: fc, sep: sep2 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map;
@@ -10342,6 +10342,10 @@ function repoRoot() {
   }
   return _repoRoot;
 }
+function _resetRepoRoot() {
+  _repoRoot = null;
+  _mainRoot = void 0;
+}
 var _mainRoot;
 function mainWorktreeRoot() {
   if (_mainRoot !== void 0) return _mainRoot;
@@ -10502,6 +10506,7 @@ var GITHUB_APP_INSTALL_URL = `https://github.com/apps/${GITHUB_APP_SLUG}/install
 function githubAppInstallUrl(accountId) {
   return accountId != null ? `https://github.com/apps/${GITHUB_APP_SLUG}/installations/new/permissions?target_id=${accountId}` : GITHUB_APP_INSTALL_URL;
 }
+var ADVISORY_EPISODE_FILE = `${VERITY_DIR}/.advisory-episode`;
 
 // src/lib/output.ts
 var RED = "\x1B[0;31m";
@@ -10775,7 +10780,7 @@ async function foldLegacyLocalCredential(remoteArg) {
   const existing = await readGlobalCredential(remote);
   const merged = {
     token: existing?.token ?? local.token,
-    serviceUrl: existing?.serviceUrl ?? local.serviceUrl,
+    serviceUrl: existing?.serviceUrl,
     userId: existing?.userId ?? local.userId,
     email: existing?.email ?? local.email
   };
@@ -10869,9 +10874,6 @@ function getChangedFiles() {
   const filtered = Array.from(sets).filter((f) => !isVerityOwnedPath(f));
   return { files: filtered, hasRecentCommitFiles };
 }
-function getStagedFiles() {
-  return splitLines(execGit("git diff --cached --name-only")).filter((f) => !isVerityOwnedPath(f));
-}
 function getDirtyFiles() {
   const set = /* @__PURE__ */ new Set();
   for (const f of splitLines(execGit("git diff --name-only HEAD"))) set.add(f);
@@ -10892,33 +10894,6 @@ function showContentAtRef(ref, repoRelPath) {
     return null;
   }
 }
-function getPushRangeFiles() {
-  const diff = (range) => splitLines(execGit(`git diff --name-only ${range}`)).filter((f) => !f.startsWith(".verity/") && !f.startsWith(".verity\\"));
-  const resolvers = [
-    () => execGit("git rev-parse --abbrev-ref --symbolic-full-name @{push}") ? "@{push}..HEAD" : null,
-    () => execGit("git rev-parse --abbrev-ref --symbolic-full-name @{upstream}") ? "@{upstream}..HEAD" : null,
-    () => {
-      const branch = execGit("git rev-parse --abbrev-ref HEAD");
-      return branch && branch !== "HEAD" && execGit(`git rev-parse --verify -q origin/${branch}`) ? `origin/${branch}..HEAD` : null;
-    }
-  ];
-  for (const resolve2 of resolvers) {
-    const range = resolve2();
-    if (range) return { files: diff(range), range };
-  }
-  const baseline = readBaselineSha();
-  if (baseline) {
-    const files = diff(`${baseline}..HEAD`);
-    if (files.length > 0) return { files, range: `${baseline}..HEAD` };
-  }
-  const last = diff("HEAD~1..HEAD");
-  return { files: last, range: last.length > 0 ? "HEAD~1..HEAD" : null };
-}
-function getPushRangeMessages() {
-  const { range } = getPushRangeFiles();
-  if (!range) return "";
-  return execGit(`git log ${range} --format=%B%x00`).split("\0").map((s) => s.trim()).filter(Boolean).join("\n\n");
-}
 function filterAnalyzable(files) {
   return files.filter((f) => {
     const ext = (0, import_node_path3.extname)(f).slice(1);
@@ -10951,7 +10926,7 @@ function getCurrentBranch() {
 function commitResolves(sha) {
   if (!sha) return false;
   try {
-    (0, import_node_child_process3.execSync)(`git merge-base --is-ancestor ${JSON.stringify(sha)} HEAD`, {
+    (0, import_node_child_process3.execFileSync)("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
       stdio: ["pipe", "pipe", "pipe"]
     });
     return true;
@@ -10962,8 +10937,9 @@ function commitResolves(sha) {
 function commitsSincePaths(sha, paths) {
   if (!sha) return null;
   try {
-    const scope2 = paths.length > 0 ? ` -- ${paths.slice(0, 50).map((p) => JSON.stringify(p)).join(" ")}` : "";
-    const out = (0, import_node_child_process3.execSync)(`git rev-list --count ${JSON.stringify(sha)}..HEAD${scope2}`, {
+    const args = ["rev-list", "--count", `${sha}..HEAD`];
+    if (paths.length > 0) args.push("--", ...paths.slice(0, 50));
+    const out = (0, import_node_child_process3.execFileSync)("git", args, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -11245,7 +11221,8 @@ async function serviceUrlFromVerityMd() {
   }
   return null;
 }
-async function resolveServiceUrlDetailed(flagUrl) {
+async function resolveServiceUrlDetailed(flagUrl, opts = {}) {
+  const allowVerityMd = opts.allowVerityMd ?? true;
   if (flagUrl) {
     return { ok: true, data: { url: flagUrl, source: "flag" } };
   }
@@ -11257,9 +11234,11 @@ async function resolveServiceUrlDetailed(flagUrl) {
   if (credsUrl) {
     return { ok: true, data: { url: credsUrl, source: "credentials" } };
   }
-  const mdUrl = await serviceUrlFromVerityMd();
-  if (mdUrl) {
-    return { ok: true, data: { url: mdUrl, source: "verity_md" } };
+  if (allowVerityMd) {
+    const mdUrl = await serviceUrlFromVerityMd();
+    if (mdUrl) {
+      return { ok: true, data: { url: mdUrl, source: "verity_md" } };
+    }
   }
   return {
     ok: false,
@@ -11267,7 +11246,7 @@ async function resolveServiceUrlDetailed(flagUrl) {
   };
 }
 async function resolveServiceUrlForAuth(flagUrl) {
-  const strict = await resolveServiceUrlDetailed(flagUrl);
+  const strict = await resolveServiceUrlDetailed(flagUrl, { allowVerityMd: false });
   if (strict.ok) return strict.data;
   return { url: DEFAULT_SERVICE_URL, source: "default" };
 }
@@ -11405,7 +11384,7 @@ var readline = __toESM(require("node:readline/promises"));
 var import_node_os = require("node:os");
 
 // src/lib/provider-auth.ts
-var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+var sleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
 var form = (fields) => new URLSearchParams(fields).toString();
 async function githubAccountId(owner) {
   try {
@@ -13161,9 +13140,38 @@ 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_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_path9 = require("node:path");
-var import_node_crypto3 = require("node:crypto");
+function resolveInside(baseDir, candidate) {
+  if (typeof candidate !== "string" || candidate.length === 0) return null;
+  if ((0, import_node_path9.isAbsolute)(candidate)) return null;
+  const baseAbs = (0, import_node_path9.resolve)(baseDir);
+  const full = (0, import_node_path9.resolve)(baseAbs, 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);
+      const realBaseSep = realBase.endsWith(import_node_path9.sep) ? realBase : realBase + import_node_path9.sep;
+      let probe = full;
+      while (!(0, import_node_fs8.existsSync)(probe)) {
+        const parent = (0, import_node_path9.dirname)(probe);
+        if (parent === probe) break;
+        probe = parent;
+      }
+      const realProbe = (0, import_node_fs8.realpathSync)(probe);
+      if (realProbe !== realBase && !realProbe.startsWith(realBaseSep)) return null;
+    }
+  } catch {
+    return null;
+  }
+  return full;
+}
 
 // src/lib/glob-match.ts
 function globToRegex(glob) {
@@ -13233,32 +13241,32 @@ var syncStateFile = () => projectPath(`${VERITY_DIR}/.memory-sync-state.json`);
 async function ensureMemoryDir() {
   await (0, import_promises8.mkdir)(memoryDir2(), { recursive: true });
   for (const domain of DOMAINS2) {
-    await (0, import_promises8.mkdir)((0, import_node_path9.join)(memoryDir2(), domain), { recursive: true });
+    await (0, import_promises8.mkdir)((0, import_node_path10.join)(memoryDir2(), domain), { recursive: true });
   }
-  if (!(0, import_node_fs8.existsSync)((0, import_node_path9.join)(memoryDir2(), "SCHEMA.md"))) {
-    await (0, import_promises8.writeFile)((0, import_node_path9.join)(memoryDir2(), "SCHEMA.md"), SCHEMA_TEMPLATE);
+  if (!(0, import_node_fs9.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_fs8.existsSync)((0, import_node_path9.join)(memoryDir2(), "index.md"))) {
-    await (0, import_promises8.writeFile)((0, import_node_path9.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(), "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_fs8.existsSync)((0, import_node_path9.join)(memoryDir2(), "log.md"))) {
-    await (0, import_promises8.writeFile)((0, import_node_path9.join)(memoryDir2(), "log.md"), "# Memory Log\n\n");
+  if (!(0, import_node_fs9.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_fs8.existsSync)(memoryDir2())) {
+  if (!(0, import_node_fs9.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_path9.join)(memoryDir2(), domain);
-    if (!(0, import_node_fs8.existsSync)(domainDir)) continue;
+    const domainDir = (0, import_node_path10.join)(memoryDir2(), domain);
+    if (!(0, import_node_fs9.existsSync)(domainDir)) continue;
     try {
       const files = await (0, import_promises8.readdir)(domainDir);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
         const filePath = `${domain}/${file}`;
-        const fullPath = (0, import_node_path9.join)(memoryDir2(), filePath);
+        const fullPath = (0, import_node_path10.join)(memoryDir2(), filePath);
         try {
           const content = await (0, import_promises8.readFile)(fullPath, "utf-8");
           const hash = (0, import_node_crypto3.createHash)("sha256").update(content).digest("hex").slice(0, 16);
@@ -13271,13 +13279,13 @@ async function buildManifest() {
   }
   let indexHash = null;
   try {
-    const indexContent = await (0, import_promises8.readFile)((0, import_node_path9.join)(memoryDir2(), "index.md"), "utf-8");
+    const indexContent = await (0, import_promises8.readFile)((0, import_node_path10.join)(memoryDir2(), "index.md"), "utf-8");
     indexHash = `sha256:${(0, import_node_crypto3.createHash)("sha256").update(indexContent).digest("hex").slice(0, 16)}`;
   } catch {
   }
   let logLength = 0;
   try {
-    const logContent = await (0, import_promises8.readFile)((0, import_node_path9.join)(memoryDir2(), "log.md"), "utf-8");
+    const logContent = await (0, import_promises8.readFile)((0, import_node_path10.join)(memoryDir2(), "log.md"), "utf-8");
     logLength = logContent.split("\n").length;
   } catch {
   }
@@ -13288,15 +13296,15 @@ function hashContent(content) {
 }
 async function readOnDiskNodes() {
   const out = /* @__PURE__ */ new Map();
-  if (!(0, import_node_fs8.existsSync)(memoryDir2())) return out;
+  if (!(0, import_node_fs9.existsSync)(memoryDir2())) return out;
   for (const domain of DOMAINS2) {
-    const domainDir = (0, import_node_path9.join)(memoryDir2(), domain);
-    if (!(0, import_node_fs8.existsSync)(domainDir)) continue;
+    const domainDir = (0, import_node_path10.join)(memoryDir2(), domain);
+    if (!(0, import_node_fs9.existsSync)(domainDir)) continue;
     try {
       for (const file of await (0, import_promises8.readdir)(domainDir)) {
         if (!file.endsWith(".md")) continue;
         try {
-          out.set(`${domain}/${file}`, hashContent(await (0, import_promises8.readFile)((0, import_node_path9.join)(domainDir, file), "utf-8")));
+          out.set(`${domain}/${file}`, hashContent(await (0, import_promises8.readFile)((0, import_node_path10.join)(domainDir, file), "utf-8")));
         } catch {
         }
       }
@@ -13342,8 +13350,8 @@ async function computeEditedNodeUploads() {
   const uploads = [];
   for (const [path, prevHash] of prev) {
     if (prevHash == null) continue;
-    const full = (0, import_node_path9.join)(memoryDir2(), path);
-    if (!(0, import_node_fs8.existsSync)(full)) continue;
+    const full = (0, import_node_path10.join)(memoryDir2(), path);
+    if (!(0, import_node_fs9.existsSync)(full)) continue;
     let content;
     try {
       content = await (0, import_promises8.readFile)(full, "utf-8");
@@ -13379,16 +13387,19 @@ 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_fs8.existsSync)((0, import_node_path9.join)(memoryDir2(), "log.md")) ? await (0, import_promises8.readFile)((0, import_node_path9.join)(memoryDir2(), "log.md"), "utf-8") : "# Memory Log\n\n";
-    await (0, import_promises8.writeFile)((0, import_node_path9.join)(memoryDir2(), "log.md"), existing + logLines.join("\n") + "\n");
+    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";
+    await (0, import_promises8.writeFile)((0, import_node_path10.join)(memoryDir2(), "log.md"), existing + logLines.join("\n") + "\n");
   } catch {
   }
   await recordSyncedNodePaths();
   return count;
 }
 async function applyOneWrite(write, treePaths) {
-  const fullPath = (0, import_node_path9.join)(memoryDir2(), write.path);
+  const fullPath = resolveInside(memoryDir2(), write.path);
   const notes = [];
+  if (!fullPath) {
+    return { written: false, notes: [`${String(write.path)}: rejected \u2014 path escapes the memory directory`] };
+  }
   let content = write.content;
   if (treePaths && treePaths.length > 0) {
     const grounded = groundFileGlobs(content, treePaths);
@@ -13397,7 +13408,7 @@ async function applyOneWrite(write, treePaths) {
       notes.push(`${write.path}: dropped unmatched file_globs [${grounded.dropped.join(", ")}]`);
     }
   }
-  if ((0, import_node_fs8.existsSync)(fullPath)) {
+  if ((0, import_node_fs9.existsSync)(fullPath)) {
     let existing = "";
     try {
       existing = await (0, import_promises8.readFile)(fullPath, "utf-8");
@@ -13409,7 +13420,7 @@ async function applyOneWrite(write, treePaths) {
       return { written: false, notes };
     }
   }
-  await (0, import_promises8.mkdir)((0, import_node_path9.dirname)(fullPath), { recursive: true });
+  await (0, import_promises8.mkdir)((0, import_node_path10.dirname)(fullPath), { recursive: true });
   await (0, import_promises8.writeFile)(fullPath, content);
   return { written: true, notes };
 }
@@ -13450,8 +13461,8 @@ async function regenerateIndex() {
   ];
   let totalNodes = 0;
   for (const domain of DOMAINS2.filter((d) => d !== "_archive")) {
-    const domainDir = (0, import_node_path9.join)(memoryDir2(), domain);
-    if (!(0, import_node_fs8.existsSync)(domainDir)) continue;
+    const domainDir = (0, import_node_path10.join)(memoryDir2(), domain);
+    if (!(0, import_node_fs9.existsSync)(domainDir)) continue;
     try {
       const files = await (0, import_promises8.readdir)(domainDir);
       const mdFiles = files.filter((f) => f.endsWith(".md"));
@@ -13461,7 +13472,7 @@ async function regenerateIndex() {
       for (const file of mdFiles.sort()) {
         const slug = file.replace(/\.md$/, "");
         try {
-          const content = await (0, import_promises8.readFile)((0, import_node_path9.join)(domainDir, file), "utf-8");
+          const content = await (0, import_promises8.readFile)((0, import_node_path10.join)(domainDir, file), "utf-8");
           const title = pickFrontmatter(content, "title") ?? slug;
           const kind = pickFrontmatter(content, "kind") ?? "-";
           const confidence = pickFrontmatter(content, "confidence");
@@ -13485,7 +13496,7 @@ async function regenerateIndex() {
     lines.push("No nodes yet. Run an analysis to start building the knowledge graph.");
   }
   const next = lines.join("\n") + "\n";
-  const indexPath = (0, import_node_path9.join)(memoryDir2(), "index.md");
+  const indexPath = (0, import_node_path10.join)(memoryDir2(), "index.md");
   let existing = null;
   try {
     existing = await (0, import_promises8.readFile)(indexPath, "utf-8");
@@ -13567,9 +13578,9 @@ function hasLegacyMemoryBlock(text) {
   return findMarker(text, LEGACY_MD_START) !== -1;
 }
 async function ensureClaudeMdPointer(cwd = repoRoot()) {
-  const claudeMdPath = (0, import_node_path9.join)(cwd, "CLAUDE.md");
+  const claudeMdPath = (0, import_node_path10.join)(cwd, "CLAUDE.md");
   let existing = "";
-  if ((0, import_node_fs8.existsSync)(claudeMdPath)) {
+  if ((0, import_node_fs9.existsSync)(claudeMdPath)) {
     existing = await (0, import_promises8.readFile)(claudeMdPath, "utf-8");
   }
   let startTag = CLAUDE_MD_START;
@@ -13699,9 +13710,9 @@ Body content (\u22648KB). Use [[node-id]] wikilinks for cross-references.
 `;
 
 // src/lib/dossier-session.ts
-var import_node_fs13 = require("node:fs");
+var import_node_fs14 = require("node:fs");
 var import_node_crypto7 = require("node:crypto");
-var import_node_path12 = require("node:path");
+var import_node_path13 = require("node:path");
 
 // src/lib/skip-detection.ts
 function isBareAckPrompt(prompt) {
@@ -13865,8 +13876,8 @@ var DEFAULT_MEMORY_BUDGET_BYTES = 4096;
 
 // src/lib/dossier/log.ts
 var import_node_crypto4 = require("node:crypto");
-var import_node_fs9 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_fs10 = require("node:fs");
+var import_node_path11 = require("node:path");
 var CRC_TABLE = (() => {
   const t = new Int32Array(256);
   for (let i = 0; i < 256; i++) {
@@ -13885,13 +13896,13 @@ function crc32(s) {
 function openDossier(identity) {
   try {
     const dir = dossierDir(identity);
-    (0, import_node_fs9.mkdirSync)(dir, { recursive: true, mode: 448 });
+    (0, import_node_fs10.mkdirSync)(dir, { recursive: true, mode: 448 });
     return {
       dir,
       identity,
-      eventsPath: (0, import_node_path10.join)(dir, "events.jsonl"),
-      foldPath: (0, import_node_path10.join)(dir, "fold.json"),
-      rotatedDir: (0, import_node_path10.join)(dir, "rotated")
+      eventsPath: (0, import_node_path11.join)(dir, "events.jsonl"),
+      foldPath: (0, import_node_path11.join)(dir, "fold.json"),
+      rotatedDir: (0, import_node_path11.join)(dir, "rotated")
     };
   } catch {
     return null;
@@ -13953,7 +13964,7 @@ function appendEvent(d, ev) {
       at: ev.at ?? (/* @__PURE__ */ new Date()).toISOString(),
       ...ev
     });
-    (0, import_node_fs9.appendFileSync)(d.eventsPath, line, { mode: 384 });
+    (0, import_node_fs10.appendFileSync)(d.eventsPath, line, { mode: 384 });
     return true;
   } catch {
     return false;
@@ -13961,14 +13972,14 @@ function appendEvent(d, ev) {
 }
 function rotateIfNeeded2(d) {
   try {
-    if (!(0, import_node_fs9.existsSync)(d.eventsPath)) return;
-    if ((0, import_node_fs9.statSync)(d.eventsPath).size < ROTATE_BYTES) return;
-    (0, import_node_fs9.mkdirSync)(d.rotatedDir, { recursive: true, mode: 448 });
-    (0, import_node_fs9.renameSync)(d.eventsPath, (0, import_node_path10.join)(d.rotatedDir, `events.${Date.now()}.jsonl`));
-    const kept = (0, import_node_fs9.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).sort();
+    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();
     for (const stale of kept.slice(0, Math.max(0, kept.length - ROTATE_KEEP))) {
       try {
-        (0, import_node_fs9.renameSync)((0, import_node_path10.join)(d.rotatedDir, stale), (0, import_node_path10.join)(d.rotatedDir, `${stale}.pruned`));
+        (0, import_node_fs10.renameSync)((0, import_node_path11.join)(d.rotatedDir, stale), (0, import_node_path11.join)(d.rotatedDir, `${stale}.pruned`));
       } catch {
       }
     }
@@ -13978,8 +13989,8 @@ function rotateIfNeeded2(d) {
 
 // src/lib/dossier/fold-dossier.ts
 var import_node_crypto5 = require("node:crypto");
-var import_node_fs10 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_fs11 = require("node:fs");
+var import_node_path12 = require("node:path");
 var EMPTY_CAPABILITIES = () => ({
   human_reachable: { value: "unknown", tier: "unknown" },
   authorship_observability: { value: "unknown", tier: "unknown" },
@@ -14030,12 +14041,12 @@ function foldDossier(d, opts = {}) {
     }
   };
   try {
-    if ((0, import_node_fs10.existsSync)(d.rotatedDir)) {
-      const files = (0, import_node_fs10.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).sort();
+    if ((0, import_node_fs11.existsSync)(d.rotatedDir)) {
+      const files = (0, import_node_fs11.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).sort();
       state.meta.rotations = files.length;
       for (const f of files) {
         try {
-          ingest((0, import_node_fs10.readFileSync)((0, import_node_path11.join)(d.rotatedDir, f), "utf8"));
+          ingest((0, import_node_fs11.readFileSync)((0, import_node_path12.join)(d.rotatedDir, f), "utf8"));
         } catch {
           state.meta.dropped_lines++;
         }
@@ -14044,9 +14055,9 @@ function foldDossier(d, opts = {}) {
   } catch {
   }
   try {
-    if ((0, import_node_fs10.existsSync)(d.eventsPath)) {
-      state.meta.upto_offset = (0, import_node_fs10.statSync)(d.eventsPath).size;
-      ingest((0, import_node_fs10.readFileSync)(d.eventsPath, "utf8"));
+    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"));
     }
   } catch {
   }
@@ -14316,7 +14327,7 @@ function applyBounds(state, input) {
 }
 
 // src/lib/dossier/cache.ts
-var import_node_fs11 = require("node:fs");
+var import_node_fs12 = require("node:fs");
 function compactState(s) {
   const ms = (iso) => Date.parse(iso) || 0;
   return {
@@ -14445,20 +14456,20 @@ function encodeState(s) {
 function writeFoldCache(d, state) {
   try {
     const tmp = `${d.foldPath}.${process.pid}.tmp`;
-    (0, import_node_fs11.writeFileSync)(tmp, encodeState(state), { mode: 384 });
-    (0, import_node_fs11.renameSync)(tmp, d.foldPath);
+    (0, import_node_fs12.writeFileSync)(tmp, encodeState(state), { mode: 384 });
+    (0, import_node_fs12.renameSync)(tmp, d.foldPath);
   } catch {
   }
 }
 function readFoldCache(d) {
   try {
-    if (!(0, import_node_fs11.existsSync)(d.foldPath)) return null;
-    const raw = JSON.parse((0, import_node_fs11.readFileSync)(d.foldPath, "utf8"));
+    if (!(0, import_node_fs12.existsSync)(d.foldPath)) return null;
+    const raw = JSON.parse((0, import_node_fs12.readFileSync)(d.foldPath, "utf8"));
     if (raw?.v !== 1) return null;
     const cached2 = expandState(raw);
     if (!cached2?.meta) return null;
-    const size = (0, import_node_fs11.existsSync)(d.eventsPath) ? (0, import_node_fs11.statSync)(d.eventsPath).size : 0;
-    const rotations = (0, import_node_fs11.existsSync)(d.rotatedDir) ? (0, import_node_fs11.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).length : 0;
+    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;
     if (cached2.meta.upto_offset !== size || cached2.meta.rotations !== rotations) return null;
     return cached2;
   } catch {
@@ -14509,13 +14520,13 @@ function assessContinuity(i) {
 
 // src/lib/dossier/reanchor.ts
 var import_node_crypto6 = require("node:crypto");
-var import_node_fs12 = require("node:fs");
+var import_node_fs13 = 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_fs12.readFileSync)(path)).digest("hex").slice(0, HASH_WIDTH);
+    return (0, import_node_crypto6.createHash)("sha256").update((0, import_node_fs13.readFileSync)(path)).digest("hex").slice(0, HASH_WIDTH);
   } catch {
     return null;
   }
@@ -14887,20 +14898,20 @@ function foreignAuthoredPaths(identity, opts = {}) {
   let sessions = 0;
   try {
     const dir = treeDir(identity);
-    if (!(0, import_node_fs13.existsSync)(dir)) return { paths: [], sessions: 0 };
-    for (const entry of (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true })) {
+    if (!(0, import_node_fs14.existsSync)(dir)) return { paths: [], sessions: 0 };
+    for (const entry of (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       if (entry.name === identity.sessionKey) continue;
-      const log = (0, import_node_path12.join)(dir, entry.name, "events.jsonl");
+      const log = (0, import_node_path13.join)(dir, entry.name, "events.jsonl");
       try {
-        if (!(0, import_node_fs13.existsSync)(log)) continue;
-        if (now - (0, import_node_fs13.statSync)(log).mtimeMs > windowMs) continue;
+        if (!(0, import_node_fs14.existsSync)(log)) continue;
+        if (now - (0, import_node_fs14.statSync)(log).mtimeMs > windowMs) continue;
         const sib = {
-          dir: (0, import_node_path12.join)(dir, entry.name),
+          dir: (0, import_node_path13.join)(dir, entry.name),
           identity,
           eventsPath: log,
-          foldPath: (0, import_node_path12.join)(dir, entry.name, "fold.json"),
-          rotatedDir: (0, import_node_path12.join)(dir, entry.name, "rotated")
+          foldPath: (0, import_node_path13.join)(dir, entry.name, "fold.json"),
+          rotatedDir: (0, import_node_path13.join)(dir, entry.name, "rotated")
         };
         const state = readFoldCache(sib) ?? foldDossier(sib);
         sessions++;
@@ -14928,25 +14939,25 @@ function pruneOldDossiers(identity, maxAgeMs = 7 * 24 * 60 * 60 * 1e3) {
   let removed = 0;
   try {
     const mine = dossierDir(identity);
-    const userDir = (0, import_node_path12.dirname)((0, import_node_path12.dirname)(mine));
-    if (!(0, import_node_fs13.existsSync)(userDir)) return 0;
+    const userDir = (0, import_node_path13.dirname)((0, import_node_path13.dirname)(mine));
+    if (!(0, import_node_fs14.existsSync)(userDir)) return 0;
     const cutoff = Date.now() - maxAgeMs;
-    for (const tree of (0, import_node_fs13.readdirSync)(userDir, { withFileTypes: true })) {
+    for (const tree of (0, import_node_fs14.readdirSync)(userDir, { withFileTypes: true })) {
       if (!tree.isDirectory()) continue;
-      const treePath = (0, import_node_path12.join)(userDir, tree.name);
+      const treePath = (0, import_node_path13.join)(userDir, tree.name);
       let live = 0;
-      for (const entry of (0, import_node_fs13.readdirSync)(treePath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs14.readdirSync)(treePath, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const dir = (0, import_node_path12.join)(treePath, entry.name);
+        const dir = (0, import_node_path13.join)(treePath, entry.name);
         if (dir === mine) {
           live++;
           continue;
         }
         try {
-          const log = (0, import_node_path12.join)(dir, "events.jsonl");
-          const at = (0, import_node_fs13.existsSync)(log) ? (0, import_node_fs13.statSync)(log).mtimeMs : (0, import_node_fs13.statSync)(dir).mtimeMs;
+          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;
           if (at < cutoff) {
-            (0, import_node_fs13.rmSync)(dir, { recursive: true, force: true });
+            (0, import_node_fs14.rmSync)(dir, { recursive: true, force: true });
             removed++;
           } else {
             live++;
@@ -14956,7 +14967,7 @@ function pruneOldDossiers(identity, maxAgeMs = 7 * 24 * 60 * 60 * 1e3) {
       }
       if (live === 0) {
         try {
-          (0, import_node_fs13.rmSync)(treePath, { recursive: false, force: false });
+          (0, import_node_fs14.rmSync)(treePath, { recursive: false, force: false });
         } catch {
         }
       }
@@ -14973,8 +14984,8 @@ function sessionDossier(token, sessionId) {
 }
 function hasActiveGoal(d) {
   try {
-    if (!(0, import_node_fs13.existsSync)(d.eventsPath)) return false;
-    return (0, import_node_fs13.readFileSync)(d.eventsPath, "utf8").includes('"k":"goal"');
+    if (!(0, import_node_fs14.existsSync)(d.eventsPath)) return false;
+    return (0, import_node_fs14.readFileSync)(d.eventsPath, "utf8").includes('"k":"goal"');
   } catch {
     return false;
   }
@@ -14998,7 +15009,7 @@ function recordTurn(d, t) {
   for (const a of t.authored) {
     const origin = a.owner === "subagent" ? "subagent" : "edit_tool";
     const prior = t.known?.authored?.get(a.p);
-    const hash = fileHash((0, import_node_path12.join)(root, a.p));
+    const hash = fileHash((0, import_node_path13.join)(root, a.p));
     const hunks = Math.max(0, a.h - (prior?.hunks ?? 0));
     const adds = Math.max(0, a.a - (prior?.adds ?? 0));
     const dels = Math.max(0, a.d - (prior?.dels ?? 0));
@@ -15031,7 +15042,7 @@ function recordTurn(d, t) {
   }
   const seenDivergence = t.known?.divergence ?? /* @__PURE__ */ new Set();
   for (const u of t.unobserved) {
-    const hash = fileHash((0, import_node_path12.join)(root, u.p));
+    const hash = fileHash((0, import_node_path13.join)(root, u.p));
     if (seenDivergence.has(divergenceKey(u.p, hash))) continue;
     appendEvent(d, { k: "divergence", kind: "external_mutation", path: u.p, hash });
   }
@@ -15060,12 +15071,14 @@ function recordVerdict(d, v) {
     if (summary) appendEvent(d, { k: "goal_delivered", summary });
   }
   const lines = /* @__PURE__ */ new Map();
+  const sent = new Set(v.sentPaths);
   for (const f of v.findings) {
     if (!f.file || typeof f.line !== "number" || !f.pattern_id) continue;
+    if (!sent.has(f.file)) continue;
     if (!lines.has(f.file)) {
       try {
-        const abs = (0, import_node_path12.join)(root, f.file);
-        lines.set(f.file, (0, import_node_fs13.existsSync)(abs) ? (0, import_node_fs13.readFileSync)(abs, "utf8").split("\n") : null);
+        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);
       } catch {
         lines.set(f.file, null);
       }
@@ -15165,8 +15178,8 @@ function recallMemory(d, identity, opts) {
       budgetBytes: opts.budgetBytes,
       readFileLines: (file) => {
         try {
-          const abs = (0, import_node_path12.join)(root, file);
-          return (0, import_node_fs13.existsSync)(abs) ? (0, import_node_fs13.readFileSync)(abs, "utf8").split("\n") : null;
+          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;
         } catch {
           return null;
         }
@@ -15304,22 +15317,22 @@ async function fireClassify(prompt, sessionId, globals) {
 }
 
 // src/commands/lifecycle.ts
-var import_node_fs17 = require("node:fs");
-var import_node_path16 = require("node:path");
+var import_node_fs18 = require("node:fs");
+var import_node_path17 = require("node:path");
 
 // src/lib/baseline.ts
-var import_node_fs16 = require("node:fs");
-var import_node_path15 = require("node:path");
+var import_node_fs17 = require("node:fs");
+var import_node_path16 = require("node:path");
 var import_node_crypto9 = require("node:crypto");
 
 // src/lib/snapshot.ts
-var import_node_fs15 = require("node:fs");
-var import_node_path14 = require("node:path");
+var import_node_fs16 = 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_fs14 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_fs15 = require("node:fs");
+var import_node_path14 = require("node:path");
 var LANG_MAP = {
   // Analyzable (static analysis + Gemini)
   ts: "typescript",
@@ -15387,7 +15400,7 @@ var LANG_MAP = {
   mk: "make"
 };
 function detectLanguage(filepath) {
-  const ext = (0, import_node_path13.extname)(filepath).slice(1);
+  const ext = (0, import_node_path14.extname)(filepath).slice(1);
   return LANG_MAP[ext] ?? ext;
 }
 function sortByMtime(files) {
@@ -15395,7 +15408,7 @@ function sortByMtime(files) {
     const resolved = resolveFile(f);
     if (!resolved) return null;
     try {
-      const stat3 = (0, import_node_fs14.statSync)(resolved);
+      const stat3 = (0, import_node_fs15.statSync)(resolved);
       return { path: f, resolved, mtime: stat3.mtimeMs };
     } catch {
       return null;
@@ -15428,7 +15441,7 @@ function collectCodeDelta(files, opts) {
     }
     let size;
     try {
-      size = (0, import_node_fs14.statSync)(resolved).size;
+      size = (0, import_node_fs15.statSync)(resolved).size;
     } catch {
       exclude(filepath, "not-stattable");
       continue;
@@ -15445,7 +15458,7 @@ function collectCodeDelta(files, opts) {
     }
     let content;
     try {
-      content = (0, import_node_fs14.readFileSync)(resolved, "utf-8");
+      content = (0, import_node_fs15.readFileSync)(resolved, "utf-8");
     } catch {
       exclude(filepath, "not-readable");
       continue;
@@ -15484,15 +15497,16 @@ function collectCodeDelta(files, opts) {
 
 // src/lib/snapshot.ts
 function generateSnapshotDiffs(files) {
-  if (!(0, import_node_fs15.existsSync)(SNAPSHOT_DIR)) {
+  if (!(0, import_node_fs16.existsSync)(SNAPSHOT_DIR)) {
     return { diffs: [], has_snapshots: false };
   }
   const diffs = [];
   for (const file of files) {
-    const snapshotPath = (0, import_node_path14.join)(SNAPSHOT_DIR, file.path);
+    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_fs15.existsSync)(snapshotPath)) {
-      const oldContent = (0, import_node_fs15.readFileSync)(snapshotPath, "utf-8");
+    if ((0, import_node_fs16.existsSync)(snapshotPath)) {
+      const oldContent = (0, import_node_fs16.readFileSync)(snapshotPath, "utf-8");
       if (oldContent === file.content) continue;
       const diff = computeDiff(oldContent, file.content, file.path);
       if (diff) {
@@ -15513,23 +15527,51 @@ ${addedLines}`,
   }
   return { diffs, has_snapshots: true };
 }
+function ensureSnapshotGitignored() {
+  let content = "";
+  try {
+    content = (0, import_node_fs16.readFileSync)(".gitignore", "utf-8");
+  } catch {
+  }
+  let ignored = null;
+  try {
+    (0, import_node_child_process6.execSync)("git check-ignore -q -- .verity/.snapshot/__probe__", { stdio: "pipe" });
+    ignored = true;
+  } catch (err) {
+    ignored = err.status === 1 ? false : null;
+  }
+  if (ignored === true) return "covered";
+  if (ignored === null) {
+    const lines = content.split("\n").map((l) => l.trim());
+    const covering = [".verity/.snapshot/", ".verity/.snapshot", ".verity/", ".verity", ".verity/*"];
+    if (lines.some((l) => covering.includes(l))) return "covered";
+  }
+  try {
+    const block = "# Verity \u2014 snapshots of analyzed files (machine state, never commit)\n.verity/.snapshot/\n";
+    (0, import_node_fs16.writeFileSync)(".gitignore", content ? content + (content.endsWith("\n") ? "" : "\n") + "\n" + block : block);
+    return "added";
+  } catch {
+    return "failed";
+  }
+}
 function saveSnapshots(files) {
   const snapshotPaths = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const snapshotPath = (0, import_node_path14.join)(SNAPSHOT_DIR, file.path);
+    if (!resolveInside(SNAPSHOT_DIR, file.path)) continue;
+    const snapshotPath = (0, import_node_path15.join)(SNAPSHOT_DIR, file.path);
     snapshotPaths.add(snapshotPath);
-    (0, import_node_fs15.mkdirSync)((0, import_node_path14.dirname)(snapshotPath), { recursive: true });
-    (0, import_node_fs15.writeFileSync)(snapshotPath, file.content);
+    (0, import_node_fs16.mkdirSync)((0, import_node_path15.dirname)(snapshotPath), { recursive: true });
+    (0, import_node_fs16.writeFileSync)(snapshotPath, file.content);
   }
   cleanStaleSnapshots(SNAPSHOT_DIR, snapshotPaths);
 }
 function computeDiff(oldContent, newContent, filePath) {
-  const tmpOld = (0, import_node_path14.join)(SNAPSHOT_DIR, ".diff-old.tmp");
-  const tmpNew = (0, import_node_path14.join)(SNAPSHOT_DIR, ".diff-new.tmp");
+  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_fs15.mkdirSync)(SNAPSHOT_DIR, { recursive: true });
-    (0, import_node_fs15.writeFileSync)(tmpOld, oldContent);
-    (0, import_node_fs15.writeFileSync)(tmpNew, newContent);
+    (0, import_node_fs16.mkdirSync)(SNAPSHOT_DIR, { recursive: true });
+    (0, import_node_fs16.writeFileSync)(tmpOld, oldContent);
+    (0, import_node_fs16.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"] }
@@ -15543,32 +15585,32 @@ function computeDiff(oldContent, newContent, filePath) {
     return null;
   } finally {
     try {
-      (0, import_node_fs15.unlinkSync)(tmpOld);
+      (0, import_node_fs16.unlinkSync)(tmpOld);
     } catch {
     }
     try {
-      (0, import_node_fs15.unlinkSync)(tmpNew);
+      (0, import_node_fs16.unlinkSync)(tmpNew);
     } catch {
     }
   }
 }
 function cleanStaleSnapshots(dir, keepSet) {
-  if (!(0, import_node_fs15.existsSync)(dir)) return;
+  if (!(0, import_node_fs16.existsSync)(dir)) return;
   try {
-    const entries = (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_node_fs16.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
-      if (entry.name.startsWith(".")) continue;
-      const fullPath = (0, import_node_path14.join)(dir, entry.name);
+      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_fs15.readdirSync)(fullPath);
-          if (remaining.length === 0) (0, import_node_fs15.rmdirSync)(fullPath);
+          const remaining = (0, import_node_fs16.readdirSync)(fullPath);
+          if (remaining.length === 0) (0, import_node_fs16.rmdirSync)(fullPath);
         } catch {
         }
       } else if (!keepSet.has(fullPath)) {
         try {
-          (0, import_node_fs15.unlinkSync)(fullPath);
+          (0, import_node_fs16.unlinkSync)(fullPath);
         } catch {
         }
       }
@@ -15587,20 +15629,20 @@ function sessionKey(sessionId) {
   return (0, import_node_crypto9.createHash)("sha256").update(sessionId).digest("hex").slice(0, 16);
 }
 function sessionDir(key) {
-  return (0, import_node_path15.join)(projectPath(BASELINE_DIR), key);
+  return (0, import_node_path16.join)(projectPath(BASELINE_DIR), key);
 }
 function manifestPath(dir) {
-  return (0, import_node_path15.join)(dir, "manifest.json");
+  return (0, import_node_path16.join)(dir, "manifest.json");
 }
 function mirrorPath(dir, repoRelPath) {
-  return (0, import_node_path15.join)(dir, "files", repoRelPath);
+  return (0, import_node_path16.join)(dir, "files", repoRelPath);
 }
 var CARRY_FILE = `${BASELINE_DIR}/.carry`;
 var CARRY_WINDOW_MS = 12e4;
 function writeCarry(sessionId, headSha) {
   try {
-    (0, import_node_fs16.mkdirSync)(projectPath(BASELINE_DIR), { recursive: true });
-    (0, import_node_fs16.writeFileSync)(
+    (0, import_node_fs17.mkdirSync)(projectPath(BASELINE_DIR), { recursive: true });
+    (0, import_node_fs17.writeFileSync)(
       projectPath(CARRY_FILE),
       JSON.stringify({ from_key: sessionKey(sessionId), head_sha: headSha, ts: Date.now() })
     );
@@ -15610,10 +15652,10 @@ function writeCarry(sessionId, headSha) {
 function claimCarry(newKey) {
   const carryPath = projectPath(CARRY_FILE);
   try {
-    if (!(0, import_node_fs16.existsSync)(carryPath)) return null;
-    const carry = JSON.parse((0, import_node_fs16.readFileSync)(carryPath, "utf-8"));
+    if (!(0, import_node_fs17.existsSync)(carryPath)) return null;
+    const carry = JSON.parse((0, import_node_fs17.readFileSync)(carryPath, "utf-8"));
     try {
-      (0, import_node_fs16.rmSync)(carryPath, { force: true });
+      (0, import_node_fs17.rmSync)(carryPath, { force: true });
     } catch {
     }
     if (!carry?.from_key || typeof carry.ts !== "number") return null;
@@ -15624,11 +15666,11 @@ function claimCarry(newKey) {
     if (!prior) return null;
     const toDir = sessionDir(newKey);
     try {
-      (0, import_node_fs16.rmSync)(toDir, { recursive: true, force: true });
+      (0, import_node_fs17.rmSync)(toDir, { recursive: true, force: true });
     } catch {
     }
-    (0, import_node_fs16.renameSync)(fromDir, toDir);
-    (0, import_node_fs16.writeFileSync)(manifestPath(toDir), JSON.stringify({ ...prior, session_id: newKey }) + "\n");
+    (0, import_node_fs17.renameSync)(fromDir, toDir);
+    (0, import_node_fs17.writeFileSync)(manifestPath(toDir), JSON.stringify({ ...prior, session_id: newKey }) + "\n");
     return readManifest(toDir);
   } catch {
     return null;
@@ -15652,21 +15694,21 @@ function captureBaseline(opts = {}) {
   const head_sha = getCurrentCommit();
   const dirty = getDirtyFiles();
   try {
-    (0, import_node_fs16.rmSync)(dir, { recursive: true, force: true });
+    (0, import_node_fs17.rmSync)(dir, { recursive: true, force: true });
   } catch {
   }
-  const filesDir = (0, import_node_path15.join)(dir, "files");
+  const filesDir = (0, import_node_path16.join)(dir, "files");
   const mirrored = [];
   try {
-    (0, import_node_fs16.mkdirSync)(filesDir, { recursive: true });
+    (0, import_node_fs17.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_fs16.mkdirSync)((0, import_node_path15.dirname)(dest), { recursive: true });
-        (0, import_node_fs16.writeFileSync)(dest, content);
+        (0, import_node_fs17.mkdirSync)((0, import_node_path16.dirname)(dest), { recursive: true });
+        (0, import_node_fs17.writeFileSync)(dest, content);
         mirrored.push(p);
       } catch {
       }
@@ -15681,8 +15723,8 @@ function captureBaseline(opts = {}) {
     version: BASELINE_VERSION
   };
   try {
-    (0, import_node_fs16.mkdirSync)(dir, { recursive: true });
-    (0, import_node_fs16.writeFileSync)(manifestPath(dir), JSON.stringify(baseline));
+    (0, import_node_fs17.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs17.writeFileSync)(manifestPath(dir), JSON.stringify(baseline));
   } catch {
   }
   pruneOldBaselines();
@@ -15693,9 +15735,9 @@ function readBaseline(sessionId) {
 }
 function readManifest(dir) {
   const mp = manifestPath(dir);
-  if (!(0, import_node_fs16.existsSync)(mp)) return null;
+  if (!(0, import_node_fs17.existsSync)(mp)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs16.readFileSync)(mp, "utf-8"));
+    const parsed = JSON.parse((0, import_node_fs17.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;
     }
@@ -15726,9 +15768,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_fs16.existsSync)(mp)) {
+    if ((0, import_node_fs17.existsSync)(mp)) {
       try {
-        return { content: (0, import_node_fs16.readFileSync)(mp, "utf-8"), existed: true };
+        return { content: (0, import_node_fs17.readFileSync)(mp, "utf-8"), existed: true };
       } catch {
       }
     }
@@ -15773,8 +15815,8 @@ function absorbIntoBaseline(paths, sessionId) {
       const content = safeReadForMirror(projectPath(p));
       if (content === null) continue;
       const dest = mirrorPath(dir, p);
-      (0, import_node_fs16.mkdirSync)((0, import_node_path15.dirname)(dest), { recursive: true });
-      (0, import_node_fs16.writeFileSync)(dest, content);
+      (0, import_node_fs17.mkdirSync)((0, import_node_path16.dirname)(dest), { recursive: true });
+      (0, import_node_fs17.writeFileSync)(dest, content);
       dirty.add(p);
       adopted++;
     } catch {
@@ -15783,7 +15825,7 @@ function absorbIntoBaseline(paths, sessionId) {
   if (adopted === 0) return 0;
   try {
     const updated = { ...baseline, dirty_paths: [...dirty] };
-    (0, import_node_fs16.writeFileSync)(manifestPath(dir), JSON.stringify(updated));
+    (0, import_node_fs17.writeFileSync)(manifestPath(dir), JSON.stringify(updated));
     preImageCache.delete(baseline);
   } catch {
     return 0;
@@ -15794,7 +15836,7 @@ function changedSinceBaseline(repoRelPath, baseline) {
   const pre = preImage(repoRelPath, baseline);
   let current;
   try {
-    current = (0, import_node_fs16.readFileSync)(projectPath(repoRelPath), "utf-8");
+    current = (0, import_node_fs17.readFileSync)(projectPath(repoRelPath), "utf-8");
   } catch {
     return pre.existed;
   }
@@ -15803,8 +15845,8 @@ function changedSinceBaseline(repoRelPath, baseline) {
 }
 function safeReadForMirror(absPath) {
   try {
-    if ((0, import_node_fs16.statSync)(absPath).size > MIRROR_MAX_BYTES) return null;
-    const buf = (0, import_node_fs16.readFileSync)(absPath);
+    if ((0, import_node_fs17.statSync)(absPath).size > MIRROR_MAX_BYTES) return null;
+    const buf = (0, import_node_fs17.readFileSync)(absPath);
     if (buf.includes(0)) return null;
     return buf.toString("utf-8");
   } catch {
@@ -15815,18 +15857,18 @@ function pruneOldBaselines() {
   const root = projectPath(BASELINE_DIR);
   let entries;
   try {
-    entries = (0, import_node_fs16.readdirSync)(root);
+    entries = (0, import_node_fs17.readdirSync)(root);
   } catch {
     return;
   }
   const now = Date.now();
   for (const name of entries) {
-    const dir = (0, import_node_path15.join)(root, name);
+    const dir = (0, import_node_path16.join)(root, name);
     const manifest = readManifest(dir);
     if (!manifest) {
       try {
-        if (now - (0, import_node_fs16.statSync)(dir).mtimeMs > BASELINE_TTL_MS) {
-          (0, import_node_fs16.rmSync)(dir, { recursive: true, force: true });
+        if (now - (0, import_node_fs17.statSync)(dir).mtimeMs > BASELINE_TTL_MS) {
+          (0, import_node_fs17.rmSync)(dir, { recursive: true, force: true });
         }
       } catch {
       }
@@ -15834,7 +15876,7 @@ function pruneOldBaselines() {
     }
     if (now - manifest.captured_at <= BASELINE_TTL_MS) continue;
     try {
-      (0, import_node_fs16.rmSync)(dir, { recursive: true, force: true });
+      (0, import_node_fs17.rmSync)(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -16007,8 +16049,8 @@ function buildCompactionContext(session) {
     commitsSince: commitsSincePaths(watermark, (state.authored ?? []).map((a) => a.path)),
     readFileLines: (file) => {
       try {
-        const abs = (0, import_node_path16.join)(root, file);
-        return (0, import_node_fs17.existsSync)(abs) ? (0, import_node_fs17.readFileSync)(abs, "utf8").split("\n") : null;
+        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;
       } catch {
         return null;
       }
@@ -16044,17 +16086,17 @@ async function readHookStdin() {
   try {
     if (process.stdin.isTTY) return {};
     const chunks = [];
-    const timeout = new Promise((resolve2) => setTimeout(() => resolve2({}), 500));
-    const read = new Promise((resolve2) => {
+    const timeout = new Promise((resolve4) => setTimeout(() => resolve4({}), 500));
+    const read = new Promise((resolve4) => {
       process.stdin.on("data", (c) => chunks.push(c));
       process.stdin.on("end", () => {
         try {
-          resolve2(JSON.parse(Buffer.concat(chunks).toString("utf-8").trim() || "{}"));
+          resolve4(JSON.parse(Buffer.concat(chunks).toString("utf-8").trim() || "{}"));
         } catch {
-          resolve2({});
+          resolve4({});
         }
       });
-      process.stdin.on("error", () => resolve2({}));
+      process.stdin.on("error", () => resolve4({}));
       process.stdin.resume();
     });
     return await Promise.race([read, timeout]);
@@ -16572,6 +16614,7 @@ function createRun(opts, globals) {
     phaseReached: "",
     phasesCompleted: [],
     skipReason: null,
+    treeFrame: null,
     turnId: "",
     // The value `resolveReachability` itself returns when every rung declines.
     reachability: { human_reachable: "unknown", human_reachable_source: "inferred", rung: "none" },
@@ -16640,7 +16683,7 @@ function createRun(opts, globals) {
 }
 
 // src/lib/stderr-log.ts
-var import_node_fs18 = require("node:fs");
+var import_node_fs19 = require("node:fs");
 var TOKEN_RE2 = /verity_[0-9a-f]{16,}/g;
 var ANSI_RE = /\u001b\[[0-?]*[ -/]*[@-~]/g;
 function scrub(s) {
@@ -16653,9 +16696,9 @@ function append(text) {
   try {
     const dir = projectPath(DEBUG_LOG_DIR);
     const file = projectPath(STDERR_LOG_FILE);
-    (0, import_node_fs18.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs19.mkdirSync)(dir, { recursive: true });
     rotateIfNeeded(file);
-    (0, import_node_fs18.appendFileSync)(file, text);
+    (0, import_node_fs19.appendFileSync)(file, text);
   } catch {
   }
 }
@@ -16711,13 +16754,17 @@ function formatRunEvidence(run, startedAt) {
 `;
   out += row("turn", `${run.turnId || "(unminted)"}${run.sessionId ? ` \xB7 session ${run.sessionId}` : ""}`);
   out += row("reached", `${run.phaseReached || "(none)"}${run.skipReason ? ` \xB7 SKIPPED: ${run.skipReason}` : ""} \xB7 ${ms}ms`);
+  if (run.treeFrame) {
+    const f = run.treeFrame;
+    out += row("tree", f.worktreeRoot ? `${f.worktreeRoot}${f.isLinkedWorktree ? " \xB7 linked worktree" : ""}${f.branch ? ` \xB7 branch ${f.branch}` : " \xB7 detached"}` : `(unresolved: ${f.refusal ?? "unknown"})`);
+  }
   out += row("changed", `${run.changedUniverse.length} from git \xB7 analyzable ${run.analyzable.length} \xB7 reviewable ${run.reviewable.length} \xB7 security ${run.securityFiles.length} \xB7 forReview ${run.allForReview.length}`);
   const done = (phase) => run.phasesCompleted.includes(phase);
   const ifDone = (phase, value) => done(phase) ? value : "?";
   const md = run.modeDecision;
   if (md) {
     const how = md.forced ? "forced by --mode" : `predicted=${md.predicted ?? "none"} \u2192 ${md.resolved}`;
-    out += row("mode", `${md.resolved} \xB7 ${how} \xB7 authored=${md.authored ? "yes" : "no"} \xB7 investigated=${md.investigated ? "yes" : "no"}`);
+    out += row("mode", `${md.resolved} \xB7 ${how}` + (md.flip ? ` (flipped to plan: no delta at ${md.flip})` : "") + ` \xB7 authored=${md.authored ? "yes" : "no"} \xB7 investigated=${md.investigated ? "yes" : "no"}`);
   } else {
     out += row("mode", `? (this run stopped in ${run.phaseReached || "no phase"}, before the mode was decided)`);
   }
@@ -16807,6 +16854,301 @@ function installRunEvidence(run) {
   });
 }
 
+// src/lib/git-frame.ts
+var import_node_child_process7 = require("node:child_process");
+var import_node_fs20 = require("node:fs");
+var import_node_os3 = require("node:os");
+var import_node_path18 = require("node:path");
+var import_node_path19 = require("node:path");
+var VALUE_TOKEN = `(?:'[^']*'|"[^"]*"|\\S+)`;
+var GIT_GLOBAL_OPTS = `(?:\\s+(?:-[Cc]\\s+${VALUE_TOKEN}|--?[\\w-]+(?:=\\S+)?))*`;
+var COMMIT_HEAD = `git${GIT_GLOBAL_OPTS}\\s+commit(?![\\w-])`;
+var PUSH_HEAD = `git${GIT_GLOBAL_OPTS}\\s+push\\b`;
+var GH_PR_HEAD = `gh${GIT_GLOBAL_OPTS}\\s+pr\\s+create\\b`;
+var COMMIT_RE = new RegExp(`(?:^|[\\s;&|(])${COMMIT_HEAD}|(?:^|[;&|(])\\s*[^\\s;&|()'"]*\\/${COMMIT_HEAD}`);
+var PUSH_RE = new RegExp(`(?:^|[\\s;&|(])${PUSH_HEAD}|(?:^|[;&|(])\\s*[^\\s;&|()'"]*\\/${PUSH_HEAD}`);
+var GH_PR_RE = new RegExp(`(?:^|[\\s;&|(])${GH_PR_HEAD}|(?:^|[;&|(])\\s*[^\\s;&|()'"]*\\/${GH_PR_HEAD}`);
+function splitSegments(command) {
+  return (command ?? "").split(/&&|\|\||;|\n/);
+}
+function findMomentSegment(command, on) {
+  const segments = splitSegments(command);
+  let commitIdx = -1;
+  let pushIdx = -1;
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (/--dry-run\b/.test(seg)) continue;
+    if (commitIdx === -1 && COMMIT_RE.test(seg)) commitIdx = i;
+    if (pushIdx === -1 && (PUSH_RE.test(seg) || GH_PR_RE.test(seg))) pushIdx = i;
+  }
+  if (commitIdx !== -1 && on.includes("commit")) return { moment: "pre-commit", segmentIndex: commitIdx };
+  if (pushIdx !== -1 && on.includes("push")) return { moment: "pre-push", segmentIndex: pushIdx };
+  return null;
+}
+function classifyCommand(command, on) {
+  return findMomentSegment(command, on)?.moment ?? null;
+}
+function unquote(token) {
+  if (token.length >= 2) {
+    const first = token[0];
+    if ((first === "'" || first === '"') && token.endsWith(first)) return token.slice(1, -1);
+  }
+  return token;
+}
+var SHELL_DYNAMIC = /[$`\\]/;
+function extractCommandTarget(command, segmentIndex, baseDir) {
+  const segments = splitSegments(command);
+  let dir = baseDir;
+  let named = false;
+  for (let i = 0; i < segmentIndex; i++) {
+    const m = segments[i].match(new RegExp(`^\\s*cd(?:\\s+(${VALUE_TOKEN}))?\\s*$`));
+    if (!m) continue;
+    named = true;
+    if (m[1] === void 0) {
+      dir = (0, import_node_os3.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;
+    dir = (0, import_node_path18.isAbsolute)(expanded) ? expanded : (0, import_node_path18.resolve)(dir, expanded);
+  }
+  const seg = segments[segmentIndex];
+  const overrideMatch = /--(?:git-dir|work-tree)(?:=|\s)|\bGIT_(?:DIR|WORK_TREE|INDEX_FILE)=/.exec(seg);
+  if (overrideMatch) {
+    return { dir: null, named: true, unresolvable: `git-dir/work-tree/index override in command: ${overrideMatch[0].trim()}` };
+  }
+  const gitMatch = seg.match(new RegExp(`(?:^|[\\s;&|(])(?:[^\\s;&|()'"]*\\/)?git(${GIT_GLOBAL_OPTS})\\s`));
+  if (gitMatch) {
+    const optsRegion = gitMatch[1] ?? "";
+    const cRe = new RegExp(`-C\\s+(${VALUE_TOKEN})`, "g");
+    let cm;
+    while ((cm = cRe.exec(optsRegion)) !== null) {
+      named = true;
+      const raw = unquote(cm[1]);
+      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;
+      dir = (0, import_node_path18.isAbsolute)(expanded) ? expanded : (0, import_node_path18.resolve)(dir, expanded);
+    }
+  }
+  return { dir, named, unresolvable: null };
+}
+var PUSH_VALUE_FLAGS = /* @__PURE__ */ new Set(["-o", "--push-option", "--receive-pack", "--exec"]);
+function parsePushTarget(segment) {
+  const none = { remote: null, srcRef: null, dstRef: null, isDelete: false };
+  const m = PUSH_RE.exec(segment);
+  if (!m) return none;
+  const rest = segment.slice(m.index + m[0].length);
+  const tokens = (rest.match(new RegExp(`'[^']*'|"[^"]*"|\\S+`, "g")) ?? []).map(unquote);
+  let remote = null;
+  let refspec = null;
+  let isDelete = false;
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t === "-d" || t === "--delete") {
+      isDelete = true;
+      continue;
+    }
+    if (t.startsWith("--repo=")) {
+      remote = t.slice("--repo=".length);
+      continue;
+    }
+    if (t === "--repo") {
+      remote = tokens[++i] ?? null;
+      continue;
+    }
+    if (PUSH_VALUE_FLAGS.has(t)) {
+      i++;
+      continue;
+    }
+    if (t.startsWith("-")) continue;
+    if (SHELL_DYNAMIC.test(t)) return none;
+    if (remote === null) {
+      remote = t;
+      continue;
+    }
+    if (refspec === null) {
+      refspec = t;
+      continue;
+    }
+    break;
+  }
+  if (refspec === null) return { remote, srcRef: null, dstRef: null, isDelete };
+  const spec = refspec.startsWith("+") ? refspec.slice(1) : refspec;
+  const colon = spec.indexOf(":");
+  if (colon === -1) return { remote, srcRef: spec, dstRef: null, isDelete };
+  const src = spec.slice(0, colon);
+  const dst = spec.slice(colon + 1);
+  if (src === "") return { remote, srcRef: null, dstRef: dst || null, isDelete: true };
+  return { remote, srcRef: src, dstRef: dst || null, isDelete };
+}
+function gitAt(dir, args) {
+  try {
+    return (0, import_node_child_process7.execFileSync)("git", args, { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    return "";
+  }
+}
+function realpathOr(p) {
+  try {
+    return import_node_fs20.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_fs20.existsSync)(input.hookCwd);
+  const baseDir = hookDirUsable ? input.hookCwd : process.cwd();
+  let anchor = hookDirUsable ? "hook-cwd" : "process-cwd";
+  const refuse = (refusal) => ({
+    moment: found?.moment ?? null,
+    frame: { worktreeRoot: null, gitDir: null, commonDir: null, isLinkedWorktree: false, branch: null, anchor, refusal }
+  });
+  let dir = baseDir;
+  if (found) {
+    const segments = splitSegments(input.command);
+    const kindRes = found.moment === "pre-commit" ? [COMMIT_RE] : [PUSH_RE, GH_PR_RE];
+    const dirs = /* @__PURE__ */ new Set();
+    for (let i = 0; i < segments.length; i++) {
+      if (/--dry-run\b/.test(segments[i])) continue;
+      if (!kindRes.some((re) => re.test(segments[i]))) continue;
+      const target = extractCommandTarget(input.command, i, baseDir);
+      if (target.named) anchor = "command-target";
+      if (target.unresolvable) return refuse(`target:${target.unresolvable}`);
+      dirs.add(target.dir ?? baseDir);
+    }
+    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_fs20.existsSync)(targetDir)) return refuse(`target:directory does not exist: ${targetDir}`);
+      dir = targetDir;
+    }
+  }
+  const toplevel = gitAt(dir, ["rev-parse", "--show-toplevel"]);
+  if (!toplevel) {
+    return refuse(anchor === "command-target" ? `target:not a git repository: ${dir}` : `anchor:not a git repository: ${dir}`);
+  }
+  const gitDirRaw = gitAt(dir, ["rev-parse", "--absolute-git-dir"]);
+  const commonRaw = gitAt(dir, ["rev-parse", "--git-common-dir"]);
+  const gitDir = gitDirRaw ? realpathOr(gitDirRaw) : null;
+  const commonDir = commonRaw ? realpathOr((0, import_node_path18.isAbsolute)(commonRaw) ? commonRaw : (0, import_node_path18.resolve)(dir, commonRaw)) : null;
+  const branchRaw = gitAt(dir, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  return {
+    moment: found?.moment ?? null,
+    frame: {
+      worktreeRoot: realpathOr(toplevel),
+      gitDir,
+      commonDir,
+      // The one honest definition: a linked worktree's own git dir differs from
+      // the shared one. No path convention involved — see the header.
+      isLinkedWorktree: !!gitDir && !!commonDir && gitDir !== commonDir,
+      branch: !branchRaw || branchRaw === "HEAD" ? null : branchRaw,
+      anchor,
+      refusal: null
+    }
+  };
+}
+function frameGit(frame, args) {
+  if (!frame.worktreeRoot) return "";
+  return gitAt(frame.worktreeRoot, args);
+}
+function refResolves(frame, ref) {
+  return frameGit(frame, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]) !== "";
+}
+var SHA_RE2 = /^[0-9a-f]{40}$/;
+function baselineShaAt(frame) {
+  if (!frame.worktreeRoot) return null;
+  try {
+    const sha = (0, import_node_fs20.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 {
+    return null;
+  }
+}
+function stagedRange() {
+  return { kind: "staged", base: "HEAD", head: "INDEX", via: "index" };
+}
+function resolvePushRange(frame, command, on) {
+  const nothing = (via) => ({ kind: "nothing", base: null, head: "HEAD", via });
+  if (!frame.worktreeRoot) return nothing("refused");
+  const found = findMomentSegment(command, on);
+  const segment = found ? splitSegments(command)[found.segmentIndex] : "";
+  const target = parsePushTarget(segment);
+  if (target.isDelete) return nothing("deletion");
+  const head = target.srcRef ?? "HEAD";
+  if (!refResolves(frame, head)) return nothing(`src-unresolvable:${head}`);
+  const srcName = target.srcRef;
+  const branchForRemote = srcName ?? frame.branch;
+  const candidates = [];
+  if (target.remote && (target.dstRef ?? srcName)) {
+    const dstName = (target.dstRef ?? srcName).replace(/^refs\/heads\//, "");
+    candidates.push({ ref: `refs/remotes/${target.remote}/${dstName}`, via: `refspec:${target.remote}/${dstName}` });
+  }
+  if (target.remote && !srcName && !target.dstRef && frame.branch) {
+    candidates.push({ ref: `refs/remotes/${target.remote}/${frame.branch}`, via: `remote:${target.remote}/${frame.branch}` });
+  }
+  candidates.push({ ref: srcName ? `${srcName}@{push}` : "@{push}", via: "@{push}" });
+  candidates.push({ ref: srcName ? `${srcName}@{upstream}` : "@{upstream}", via: "@{upstream}" });
+  if (branchForRemote) {
+    candidates.push({
+      ref: `refs/remotes/origin/${branchForRemote.replace(/^refs\/heads\//, "")}`,
+      via: `origin/${branchForRemote.replace(/^refs\/heads\//, "")}`
+    });
+  }
+  for (const c of candidates) {
+    if (!refResolves(frame, c.ref)) continue;
+    const mergeBase = frameGit(frame, ["merge-base", c.ref, head]);
+    if (SHA_RE2.test(mergeBase)) return { kind: "push", base: mergeBase, head, via: c.via };
+  }
+  const baseline = baselineShaAt(frame);
+  if (baseline) return { kind: "baseline", base: baseline, head, via: "review-baseline" };
+  if (refResolves(frame, `${head}~1`)) return { kind: "last-commit", base: `${head}~1`, head, via: `${head}~1` };
+  return nothing("no-parent");
+}
+function rangeFiles(frame, range) {
+  let out;
+  switch (range.kind) {
+    case "staged":
+      out = frameGit(frame, ["diff", "--cached", "--name-only"]);
+      break;
+    case "push":
+    case "baseline":
+    case "last-commit":
+      out = frameGit(frame, ["diff", "--name-only", range.base, range.head === "INDEX" ? "HEAD" : range.head]);
+      break;
+    case "nothing":
+      return [];
+  }
+  return out.split("\n").filter((l) => l.length > 0).filter((f) => !isVerityOwnedPath(f));
+}
+function rangeMessages(frame, range) {
+  if (range.kind === "staged" || range.kind === "nothing" || !range.base) return "";
+  return frameGit(frame, ["log", `${range.base}..${range.head === "INDEX" ? "HEAD" : range.head}`, "--format=%B%x00"]).split("\0").map((s) => s.trim()).filter(Boolean).join("\n\n");
+}
+function frameTelemetry(frame, range, divergence) {
+  const t = {
+    anchor: frame.anchor,
+    linked_worktree: frame.isLinkedWorktree,
+    range_via: range?.via ?? null,
+    refusal: frame.refusal
+  };
+  if (divergence) {
+    t.root_differs = !!frame.worktreeRoot && !!divergence.actualRoot && realpathOr(frame.worktreeRoot) !== realpathOr(divergence.actualRoot);
+    const a = [...divergence.actualFiles].sort().join("\n");
+    const b = [...divergence.frameFiles].sort().join("\n");
+    t.files_differ = a !== b;
+    t.frame_file_count = divergence.frameFiles.length;
+    t.actual_file_count = divergence.actualFiles.length;
+  }
+  return t;
+}
+
 // src/lib/reachability.ts
 function resolveReachability(input = {}) {
   const env = input.env ?? {};
@@ -16835,7 +17177,7 @@ function truthy(v) {
 }
 
 // src/lib/transcript.ts
-var import_node_fs19 = require("node:fs");
+var import_node_fs21 = require("node:fs");
 var MAX_READ_BYTES = 256 * 1024;
 var SMALL_FILE_BYTES = 64 * 1024;
 var MAX_FILES_LIST = 20;
@@ -16859,7 +17201,7 @@ async function extractActionSummary(transcriptPath) {
 function readTurnLines(transcriptPath) {
   let size;
   try {
-    size = (0, import_node_fs19.statSync)(transcriptPath).size;
+    size = (0, import_node_fs21.statSync)(transcriptPath).size;
   } catch {
     return null;
   }
@@ -16867,7 +17209,7 @@ function readTurnLines(transcriptPath) {
   let raw;
   let windowed = false;
   if (size <= SMALL_FILE_BYTES) {
-    raw = (0, import_node_fs19.readFileSync)(transcriptPath, "utf-8");
+    raw = (0, import_node_fs21.readFileSync)(transcriptPath, "utf-8");
   } else {
     windowed = true;
     const buf = Buffer.alloc(Math.min(MAX_READ_BYTES, size));
@@ -17047,11 +17389,11 @@ function sanitizeCommand(rawCmd) {
   let cmd = rawCmd.split("\n")[0];
   let cut = -1;
   let marker = "";
-  for (const sep of [" | ", " > ", " >> ", " 2>", " && ", " ; "]) {
-    const idx = cmd.indexOf(sep);
+  for (const sep2 of [" | ", " > ", " >> ", " 2>", " && ", " ; "]) {
+    const idx = cmd.indexOf(sep2);
     if (idx > 0 && (cut === -1 || idx < cut)) {
       cut = idx;
-      marker = sep.trim();
+      marker = sep2.trim();
     }
   }
   if (cut > -1) cmd = cmd.slice(0, cut);
@@ -17075,28 +17417,28 @@ async function readStopHookStdin() {
   try {
     if (process.stdin.isTTY) return empty;
     const chunks = [];
-    const timeout = new Promise((resolve2) => setTimeout(() => resolve2(empty), 500));
-    const read = new Promise((resolve2) => {
+    const timeout = new Promise((resolve4) => setTimeout(() => resolve4(empty), 500));
+    const read = new Promise((resolve4) => {
       process.stdin.on("data", (chunk) => chunks.push(chunk));
       process.stdin.on("end", () => {
         const raw = Buffer.concat(chunks).toString("utf-8").trim();
         if (!raw) {
-          resolve2(empty);
+          resolve4(empty);
           return;
         }
         try {
           const data = JSON.parse(raw);
-          resolve2({
+          resolve4({
             assistantMessage: typeof data.last_assistant_message === "string" ? data.last_assistant_message : null,
             stopReason: typeof data.stop_reason === "string" ? data.stop_reason : null,
             transcriptPath: typeof data.transcript_path === "string" ? data.transcript_path : null,
             sessionId: typeof data.session_id === "string" ? data.session_id : null
           });
         } catch {
-          resolve2(empty);
+          resolve4(empty);
         }
       });
-      process.stdin.on("error", () => resolve2(empty));
+      process.stdin.on("error", () => resolve4(empty));
       process.stdin.resume();
     });
     return await Promise.race([read, timeout]);
@@ -17110,6 +17452,7 @@ async function bootstrap(run) {
     process.chdir(repoRoot());
   } catch {
   }
+  run.treeFrame = resolveFrame({ command: "", on: [], hookCwd: null }).frame;
   const turnId = `t-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
   let reachability = resolveReachability({
     autonomousFlag: process.env.VERITY_AUTONOMOUS === "1" || opts.mode === "autonomous",
@@ -17146,6 +17489,39 @@ async function bootstrap(run) {
   Object.assign(run, { actionSummary, assistantResponse, baseline, baselineSessionId, reachability, sessionId, stopReason, tokenResult, transcriptPath, turnId });
 }
 
+// src/lib/self-scope.ts
+var LEGACY_GATE_SKILLS = /* @__PURE__ */ new Set([
+  "gate-setup",
+  "gate-analyze",
+  "gate-review",
+  "gate-status",
+  "gate-feedback",
+  "gate-insights",
+  "gate-learn",
+  "gate-memory",
+  "gate-reflect"
+]);
+function isVerityOwned(path) {
+  const segments = path.replace(/\\/g, "/").split("/");
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (seg === ".verity" || seg === ".codacy") return true;
+    if (i === segments.length - 1 && (seg === "VERITY.md" || seg === "GATE.md")) return true;
+    if (seg === ".claude" && segments[i + 1] === "skills" && typeof segments[i + 2] === "string") {
+      const skill = segments[i + 2];
+      if (skill.startsWith("verity-") || LEGACY_GATE_SKILLS.has(skill)) return true;
+    }
+    if (seg === ".claude" && segments[i + 1] === "settings.json") return true;
+  }
+  return false;
+}
+function partitionVerityOwned(paths) {
+  const kept = [];
+  const owned = [];
+  for (const p of paths) (isVerityOwned(p) ? owned : kept).push(p);
+  return { kept, owned };
+}
+
 // src/lib/channel.ts
 var MAX_AGENT_CONTEXT_CHARS = 1500;
 var MAX_AGENT_ITEMS = 5;
@@ -17155,6 +17531,29 @@ function renderItem(label2, text, patternId, file, line) {
   const id = patternId ? ` [${patternId}]` : "";
   return `- ${label2}${text}${where}${id}`;
 }
+function channelInputFrom(response, intentRepeat = 0, priorPendingFingerprints = []) {
+  const metadata = response.metadata ?? {};
+  const intent = response.intent_alignment ?? {};
+  return {
+    intentRepeat,
+    priorPendingFingerprints,
+    gateDecision: String(response.gate_decision ?? ""),
+    findings: response.findings ?? [],
+    pendingItems: response.pending_items ?? [],
+    reviewStatus: metadata.review_status,
+    coverage: metadata.coverage,
+    intentVerdict: intent.verdict,
+    intentGaps: intent.gaps
+  };
+}
+function classifyChannelContent(input) {
+  const refusal = input.reviewStatus === "not_reviewed" || input.reviewStatus === "no_authorship_evidence";
+  const intentFlag = input.intentVerdict === "misaligned" || input.intentVerdict === "partial";
+  const advisory = (input.findings ?? []).some((f) => f.scope !== "pre-existing") || (input.pendingItems ?? []).some(
+    (p) => p.pattern_id !== "intent-misalignment" && !!(p.description ?? p.title ?? p.reason)
+  );
+  return { refusal, intentFlag, advisory };
+}
 function buildAgentContext(input) {
   const lines = [];
   if (input.reviewStatus === "not_reviewed") {
@@ -17240,7 +17639,7 @@ function channelSilence(input) {
 // src/lib/cli-version.ts
 function cliVersion() {
   try {
-    return true ? "0.29.4-experimental.f2e812c" : "dev";
+    return true ? "0.30.0-experimental.43e7755" : "dev";
   } catch {
     return "dev";
   }
@@ -17280,8 +17679,8 @@ async function sendSkipBeacon(ctx, reason) {
 }
 
 // src/lib/static-analysis.ts
-var import_node_child_process7 = require("node:child_process");
-var import_node_fs20 = require("node:fs");
+var import_node_child_process8 = require("node:child_process");
+var import_node_fs22 = require("node:fs");
 var SEVERITY_ORDER = {
   Error: 0,
   Critical: 0,
@@ -17293,7 +17692,7 @@ var SEVERITY_ORDER = {
 };
 function isCodacyAvailable() {
   try {
-    (0, import_node_child_process7.execSync)("which codacy-analysis", { stdio: "pipe" });
+    (0, import_node_child_process8.execSync)("which codacy-analysis", { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -17329,13 +17728,13 @@ function runCodacyAnalysis(files) {
   if (files.length === 0) return empty;
   const existingFiles = files.filter((f) => {
     try {
-      return (0, import_node_fs20.existsSync)(f);
+      return (0, import_node_fs22.existsSync)(f);
     } catch {
       return false;
     }
   });
   if (existingFiles.length === 0) return empty;
-  const proc = (0, import_node_child_process7.spawnSync)("codacy-analysis", buildAnalyzerArgv(existingFiles), {
+  const proc = (0, import_node_child_process8.spawnSync)("codacy-analysis", buildAnalyzerArgv(existingFiles), {
     encoding: "utf-8",
     maxBuffer: 10 * 1024 * 1024
   });
@@ -17562,9 +17961,10 @@ async function scope(run) {
   const { assistantResponse } = run;
   const { files: allChanged, hasRecentCommitFiles } = getChangedFiles();
   run.changedUniverse = allChanged;
-  const analyzable = filterAnalyzable(allChanged);
-  const reviewable = filterReviewable(allChanged);
-  const securityFiles = filterSecurity(allChanged);
+  const { kept: external } = partitionVerityOwned(allChanged);
+  const analyzable = filterAnalyzable(external);
+  const reviewable = filterReviewable(external);
+  const securityFiles = filterSecurity(external);
   const noFilesChanged = analyzable.length === 0 && reviewable.length === 0 && securityFiles.length === 0;
   if (noFilesChanged && !assistantResponse) {
     await passAndExit(run, "No analyzable files changed", "no-analyzable-files");
@@ -17574,8 +17974,8 @@ async function scope(run) {
 }
 
 // src/lib/specs.ts
-var import_node_fs21 = require("node:fs");
-var import_node_path17 = require("node:path");
+var import_node_fs23 = require("node:fs");
+var import_node_path20 = require("node:path");
 var SPEC_CANDIDATES = [
   "CLAUDE.md",
   "AGENTS.md",
@@ -17606,16 +18006,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_fs21.existsSync)(specPath)) return true;
+    if (!(0, import_node_fs23.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_fs21.openSync)(specPath, "r");
-      const bytesRead = (0, import_node_fs21.readSync)(fd, buf, 0, readBytes, 0);
-      (0, import_node_fs21.closeSync)(fd);
+      const fd = (0, import_node_fs23.openSync)(specPath, "r");
+      const bytesRead = (0, import_node_fs23.readSync)(fd, buf, 0, readBytes, 0);
+      (0, import_node_fs23.closeSync)(fd);
       const content = buf.slice(0, bytesRead).toString("utf-8");
       if (!content) return true;
       result.push({ path: specPath, content });
@@ -17631,7 +18031,7 @@ function discoverSpecs(consulted = []) {
     if (!addSpec(candidate)) break;
   }
   for (const dir of ["spec", "docs"]) {
-    if (!(0, import_node_fs21.existsSync)(dir)) continue;
+    if (!(0, import_node_fs23.existsSync)(dir)) continue;
     try {
       const mdFiles = findMdFiles(dir, 2).sort();
       for (const mdFile of mdFiles) {
@@ -17646,9 +18046,9 @@ function findMdFiles(dir, maxDepth, depth = 0) {
   if (depth >= maxDepth) return [];
   const result = [];
   try {
-    const entries = (0, import_node_fs21.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_node_fs23.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = (0, import_node_path17.join)(dir, entry.name);
+      const fullPath = (0, import_node_path20.join)(dir, entry.name);
       if (entry.isFile() && entry.name.endsWith(".md")) {
         result.push(fullPath);
       } else if (entry.isDirectory() && depth < maxDepth - 1) {
@@ -17660,19 +18060,19 @@ function findMdFiles(dir, maxDepth, depth = 0) {
   return result;
 }
 function discoverPlans() {
-  const homePlansDir = (0, import_node_path17.join)(process.env.HOME ?? "", ".claude", "plans");
+  const homePlansDir = (0, import_node_path20.join)(process.env.HOME ?? "", ".claude", "plans");
   const localPlansDir = ".claude/plans";
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
   for (const plansDir of [localPlansDir, homePlansDir]) {
-    if (!(0, import_node_fs21.existsSync)(plansDir)) continue;
+    if (!(0, import_node_fs23.existsSync)(plansDir)) continue;
     try {
-      for (const f of (0, import_node_fs21.readdirSync)(plansDir)) {
+      for (const f of (0, import_node_fs23.readdirSync)(plansDir)) {
         if (!f.endsWith(".md") || seen.has(f)) continue;
         seen.add(f);
-        const fullPath = (0, import_node_path17.join)(plansDir, f);
+        const fullPath = (0, import_node_path20.join)(plansDir, f);
         try {
-          const stat3 = (0, import_node_fs21.statSync)(fullPath);
+          const stat3 = (0, import_node_fs23.statSync)(fullPath);
           candidates.push({ name: f, path: fullPath, mtime: stat3.mtimeMs, size: stat3.size });
         } catch {
         }
@@ -17685,7 +18085,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_fs21.readFileSync)(entry.path, "utf-8");
+      const content = (0, import_node_fs23.readFileSync)(entry.path, "utf-8");
       result.push({ name: entry.name, content });
     } catch {
     }
@@ -17960,7 +18360,7 @@ async function mode(run) {
 }
 
 // src/lib/debounce.ts
-var import_node_fs22 = 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;
@@ -17968,9 +18368,9 @@ function scopedFile(base, sessionId) {
 }
 function checkDebounce(debounceSeconds = DEBOUNCE_SECONDS, sessionId) {
   const file = scopedFile(DEBOUNCE_FILE, sessionId);
-  if (!(0, import_node_fs22.existsSync)(file)) return null;
+  if (!(0, import_node_fs24.existsSync)(file)) return null;
   try {
-    const lastTs = parseInt((0, import_node_fs22.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) {
@@ -17983,10 +18383,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_fs22.existsSync)(file)) return null;
+  if (!(0, import_node_fs24.existsSync)(file)) return null;
   let debounceTime;
   try {
-    debounceTime = (0, import_node_fs22.statSync)(file).mtimeMs;
+    debounceTime = (0, import_node_fs24.statSync)(file).mtimeMs;
   } catch {
     return null;
   }
@@ -17994,7 +18394,7 @@ function checkMtime(files, bypassForRecentCommits, sessionId) {
     const resolved = resolveFile(f);
     if (!resolved) continue;
     try {
-      const stat3 = (0, import_node_fs22.statSync)(resolved);
+      const stat3 = (0, import_node_fs24.statSync)(resolved);
       if (stat3.mtimeMs > debounceTime) {
         return null;
       }
@@ -18010,8 +18410,8 @@ function computeContentHash(files) {
   for (const f of sorted) {
     const resolved = resolveFile(f) ?? f;
     try {
-      if ((0, import_node_fs22.existsSync)(resolved)) {
-        hash.update((0, import_node_fs22.readFileSync)(resolved));
+      if ((0, import_node_fs24.existsSync)(resolved)) {
+        hash.update((0, import_node_fs24.readFileSync)(resolved));
       }
     } catch {
     }
@@ -18021,9 +18421,9 @@ function computeContentHash(files) {
 function checkContentHash(files, sessionId) {
   const hash = computeContentHash(files);
   const file = scopedFile(HASH_FILE, sessionId);
-  if ((0, import_node_fs22.existsSync)(file)) {
+  if ((0, import_node_fs24.existsSync)(file)) {
     try {
-      const storedHash = (0, import_node_fs22.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 };
       }
@@ -18033,50 +18433,74 @@ function checkContentHash(files, sessionId) {
   return { skip: null, hash };
 }
 function recordAnalysisStart(sessionId) {
-  (0, import_node_fs22.mkdirSync)(VERITY_DIR, { recursive: true });
-  (0, import_node_fs22.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_fs22.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_fs22.existsSync)(file)) return files;
+  if (!(0, import_node_fs24.existsSync)(file)) return files;
   let debounceTime;
   try {
-    debounceTime = (0, import_node_fs22.statSync)(file).mtimeMs;
+    debounceTime = (0, import_node_fs24.statSync)(file).mtimeMs;
   } catch {
     return files;
   }
   const recent = files.filter((f) => {
     try {
-      return (0, import_node_fs22.existsSync)(f) && (0, import_node_fs22.statSync)(f).mtimeMs > debounceTime;
+      return (0, import_node_fs24.existsSync)(f) && (0, import_node_fs24.statSync)(f).mtimeMs > debounceTime;
     } catch {
       return false;
     }
   });
   return recent.length > 0 ? recent : files;
 }
-function readIterationState(currentCommit) {
-  if (!(0, import_node_fs22.existsSync)(ITERATION_FILE)) return { iteration: 1, fingerprint: null };
+function readIteration(currentCommit, _contentHash) {
+  return Math.max(1, readBlockState(currentCommit).attempts);
+}
+var NO_BLOCKS = { attempts: 0, blocks: 0, fingerprint: null };
+function readBlockState(currentCommit, opts) {
+  if (opts?.newUserPrompt) return NO_BLOCKS;
+  if (!(0, import_node_fs24.existsSync)(ITERATION_FILE)) return NO_BLOCKS;
   try {
-    const stored = (0, import_node_fs22.readFileSync)(ITERATION_FILE, "utf-8").trim();
-    const parts = stored.split(":");
-    const iter = parseInt(parts[0], 10);
-    const storedCommit = parts[1] ?? "";
-    const storedTimestamp = parseInt(parts[2] ?? "0", 10);
-    const fingerprint = parts.slice(3).join(":") || null;
-    if (isNaN(iter)) return { iteration: 1, fingerprint: null };
-    if (storedCommit !== currentCommit) return { iteration: 1, fingerprint: null };
-    if (storedTimestamp > 0) {
-      const elapsed = Math.floor(Date.now() / 1e3) - storedTimestamp;
-      if (elapsed > 600) return { iteration: 1, fingerprint: null };
-    }
-    return { iteration: iter, fingerprint };
+    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;
+    if (parsed.ts > 0 && Math.floor(Date.now() / 1e3) - parsed.ts > 600) return NO_BLOCKS;
+    return { attempts: parsed.attempts, blocks: parsed.blocks, fingerprint: parsed.fingerprint };
   } catch {
-    return { iteration: 1, fingerprint: null };
+    return NO_BLOCKS;
   }
 }
+function parseJsonState(raw) {
+  const o = JSON.parse(raw);
+  const attempts = typeof o.attempts === "number" ? o.attempts : NaN;
+  if (isNaN(attempts)) return null;
+  return {
+    attempts,
+    blocks: typeof o.blocks === "number" ? o.blocks : attempts,
+    fingerprint: typeof o.fingerprint === "string" && o.fingerprint ? o.fingerprint : null,
+    commit: typeof o.commit === "string" ? o.commit : "",
+    ts: typeof o.ts === "number" ? o.ts : 0
+  };
+}
+function parseLegacyState(raw) {
+  const parts = raw.split(":");
+  const n = parseInt(parts[0], 10);
+  if (isNaN(n)) return null;
+  return {
+    attempts: n,
+    // The old file has no separate block count; the old counter is the closest
+    // honest answer, and it errs toward releasing sooner rather than later.
+    blocks: n,
+    fingerprint: parts.slice(3).join(":") || null,
+    commit: parts[1] ?? "",
+    ts: parseInt(parts[2] ?? "0", 10)
+  };
+}
 function findingsFingerprint(findings) {
   const keys = findings.map((f) => `${String(f.pattern_id ?? "?")}|${String(f.file ?? "?")}`).filter((k) => k !== "?|?");
   return [...new Set(keys)].sort().join(",");
@@ -18086,16 +18510,27 @@ function isSameProblem(previous, current) {
   const prev = new Set(previous.split(","));
   return current.split(",").some((k) => prev.has(k));
 }
-function writeIteration(iteration, commit, _contentHash, fingerprint) {
-  (0, import_node_fs22.mkdirSync)(VERITY_DIR, { recursive: true });
-  const ts = Math.floor(Date.now() / 1e3);
-  const fp = fingerprint ? `:${fingerprint}` : "";
-  (0, import_node_fs22.writeFileSync)(ITERATION_FILE, `${iteration}:${commit}:${ts}${fp}`);
+function writeBlockState(commit, state) {
+  (0, import_node_fs24.mkdirSync)(VERITY_DIR, { recursive: true });
+  (0, import_node_fs24.writeFileSync)(
+    ITERATION_FILE,
+    JSON.stringify({
+      v: 2,
+      attempts: state.attempts,
+      blocks: state.blocks,
+      commit,
+      ts: Math.floor(Date.now() / 1e3),
+      fingerprint: state.fingerprint ?? void 0
+    })
+  );
+}
+function resetBlockState(commit) {
+  writeBlockState(commit, { attempts: 0, blocks: 0, fingerprint: null });
 }
 
 // src/lib/fold.ts
-var import_node_fs23 = require("node:fs");
-var import_node_path18 = require("node:path");
+var import_node_fs25 = require("node:fs");
+var import_node_path21 = require("node:path");
 var KNOWN_RECORD_TYPES = /* @__PURE__ */ new Set([
   "user",
   "assistant",
@@ -18133,7 +18568,7 @@ var COMMAND_CLASSES = [
   [/\btsc\b|\bmypy\b|\btypecheck\b/, "typecheck"],
   [/^git\s/, "git"]
 ];
-function classifyCommand(cmd) {
+function classifyCommand2(cmd) {
   for (const [re, cls] of COMMAND_CLASSES) if (re.test(cmd)) return cls;
   return "other";
 }
@@ -18232,7 +18667,7 @@ function candidateRoots(repoRoot2) {
   const norm = repoRoot2.replace(/\\/g, "/").replace(/\/+$/, "");
   const out = [norm];
   try {
-    const real = import_node_fs23.realpathSync.native(norm).replace(/\\/g, "/").replace(/\/+$/, "");
+    const real = import_node_fs25.realpathSync.native(norm).replace(/\\/g, "/").replace(/\/+$/, "");
     if (real !== norm) out.push(real);
   } catch {
   }
@@ -18282,8 +18717,10 @@ function fold(transcriptPath, opts = {}) {
       subagentSkipped: 0,
       compactions: 0,
       complete: false
-    }
+    },
+    planApproval: { approvals: 0, activeSinceLastPrompt: false }
   };
+  const flow = { seq: 0, lastPrompt: -1, lastApproval: -1, approvals: 0 };
   const byPath = /* @__PURE__ */ new Map();
   const commandStats = /* @__PURE__ */ new Map();
   const pendingByToolUse = /* @__PURE__ */ new Map();
@@ -18309,36 +18746,40 @@ function fold(transcriptPath, opts = {}) {
       if (type === "system" && record.subtype === "compact_boundary") {
         result.coverage.compactions++;
       }
-      if (type === "user" && hasUserText(record)) result.coverage.userMessages++;
-      collectFromRecord(record, owner, byPath, commandStats, pendingByToolUse, toolStats, pendingToolName, taskById, pendingTaskName, opts.repoRoot, result.coverage);
+      if (type === "user" && hasUserText(record)) {
+        result.coverage.userMessages++;
+        if (owner === "agent") flow.lastPrompt = flow.seq;
+      }
+      if (owner === "agent") flow.seq++;
+      collectFromRecord(record, owner, byPath, commandStats, pendingByToolUse, toolStats, pendingToolName, taskById, pendingTaskName, opts.repoRoot, result.coverage, flow);
     }
   };
   try {
-    if (!(0, import_node_fs23.existsSync)(transcriptPath)) return result;
-    ingest((0, import_node_fs23.readFileSync)(transcriptPath, "utf8"), "agent");
+    if (!(0, import_node_fs25.existsSync)(transcriptPath)) return result;
+    ingest((0, import_node_fs25.readFileSync)(transcriptPath, "utf8"), "agent");
     result.coverage.complete = true;
   } catch {
     return result;
   }
   try {
-    const sidecarDir = (0, import_node_path18.join)(
-      (0, import_node_path18.dirname)(transcriptPath),
-      (0, import_node_path18.basename)(transcriptPath).replace(/\.jsonl$/, ""),
+    const sidecarDir = (0, import_node_path21.join)(
+      (0, import_node_path21.dirname)(transcriptPath),
+      (0, import_node_path21.basename)(transcriptPath).replace(/\.jsonl$/, ""),
       "subagents"
     );
-    if ((0, import_node_fs23.existsSync)(sidecarDir)) {
+    if ((0, import_node_fs25.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_fs23.readdirSync)(d, { withFileTypes: true })) {
-          const p = (0, import_node_path18.join)(d, e.name);
+        for (const e of (0, import_node_fs25.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_fs23.statSync)(p);
+              const st = (0, import_node_fs25.statSync)(p);
               found.push({ path: p, size: st.size, mtimeMs: st.mtimeMs });
             } catch {
               result.coverage.malformed++;
@@ -18355,7 +18796,7 @@ function fold(transcriptPath, opts = {}) {
           continue;
         }
         try {
-          ingest((0, import_node_fs23.readFileSync)(f.path, "utf8"), "subagent");
+          ingest((0, import_node_fs25.readFileSync)(f.path, "utf8"), "subagent");
           bytes += f.size;
           result.coverage.subagentFiles++;
         } catch {
@@ -18382,11 +18823,15 @@ function fold(transcriptPath, opts = {}) {
     if (!p || authoredPaths.has(p)) continue;
     result.unobserved.push({ p, cause: classifyUnobserved(raw) });
   }
+  result.planApproval = {
+    approvals: flow.approvals,
+    activeSinceLastPrompt: flow.lastApproval >= 0 && flow.lastApproval > flow.lastPrompt
+  };
   return result;
 }
 function classifyUnobserved(path) {
   try {
-    const st = (0, import_node_fs23.statSync)(path);
+    const st = (0, import_node_fs25.statSync)(path);
     if (!st.isFile()) return "unreadable";
   } catch {
     return "unreadable";
@@ -18394,7 +18839,7 @@ function classifyUnobserved(path) {
   if (/\.(png|jpg|jpeg|gif|pdf|zip|woff2?|ico|mp4)$/i.test(path)) return "binary";
   return "no_edit_record";
 }
-function collectFromRecord(record, owner, byPath, commandStats, pendingByToolUse, toolStats, pendingToolName, taskById, pendingTaskName, repoRoot2, tally) {
+function collectFromRecord(record, owner, byPath, commandStats, pendingByToolUse, toolStats, pendingToolName, taskById, pendingTaskName, repoRoot2, tally, flow) {
   const message = record.message;
   const content = message?.content ?? record.content;
   const blocks = Array.isArray(content) ? content : content && typeof content === "object" ? [content] : [];
@@ -18452,7 +18897,7 @@ function collectFromRecord(record, owner, byPath, commandStats, pendingByToolUse
       if (name === "Bash") {
         const cmd = typeof input.command === "string" ? input.command : "";
         if (cmd) {
-          const cls = classifyCommand(cmd);
+          const cls = classifyCommand2(cmd);
           const prev = commandStats.get(cls) ?? { last_status: null, runs: 0, head: "" };
           commandStats.set(cls, {
             // UNKNOWN until this command's OWN result arrives. Inheriting the
@@ -18478,6 +18923,13 @@ function collectFromRecord(record, owner, byPath, commandStats, pendingByToolUse
         }
       }
       const toolName = id ? pendingToolName.get(id) : void 0;
+      if (toolName === "ExitPlanMode" && flow && block.is_error !== true) {
+        const body = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.map((c) => typeof c.text === "string" ? c.text : "").join(" ") : "";
+        if (/approved your plan/i.test(body)) {
+          flow.lastApproval = flow.seq;
+          flow.approvals += 1;
+        }
+      }
       if (toolName) {
         pendingToolName.delete(id);
         const prevTool = toolStats.get(toolName);
@@ -18535,8 +18987,13 @@ function checkConservation(changedFiles, result, repoRoot2) {
 // src/commands/analyze/phases/06-evidence.ts
 async function evidence(run) {
   const { opts } = run;
-  const { actionSummary, allForReview, analyzable, assistantResponse, authorshipIsObservable, baseline, baselineSessionId, hasRecentCommitFiles, reviewable, securityFiles, sessionAuthoredCode, transcriptPath } = run;
+  const { actionSummary, allForReview, analyzable, assistantResponse, authorshipIsObservable, baseline, baselineSessionId, hasRecentCommitFiles, reviewable, securityFiles, sessionAuthoredCode, transcriptPath, turnAuthoredCode } = run;
   let { analysisMode, earlyFold } = run;
+  const recordFlip = (stage) => {
+    if (run.modeDecision) run.modeDecision = { ...run.modeDecision, resolved: "plan", flip: stage };
+    logEvent("mode_flipped", { stage, to: "plan" });
+  };
+  const planWorthy = !!assistantResponse && !turnAuthoredCode;
   let staticResults = {
     tool: "@codacy/analysis-cli",
     findings: [],
@@ -18556,8 +19013,9 @@ async function evidence(run) {
     const debounceSeconds = parseInt(opts.debounce, 10);
     const debounceSkip = checkDebounce(debounceSeconds, baselineSessionId);
     if (debounceSkip) {
-      if (assistantResponse) {
+      if (planWorthy) {
         analysisMode = "plan";
+        recordFlip("debounce");
       } else {
         await passAndExit(run, debounceSkip, "debounce");
       }
@@ -18566,8 +19024,9 @@ async function evidence(run) {
       const allCheckable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...reviewable, ...securityFiles]));
       const mtimeSkip = checkMtime(allCheckable, hasRecentCommitFiles, baselineSessionId);
       if (mtimeSkip) {
-        if (assistantResponse) {
+        if (planWorthy) {
           analysisMode = "plan";
+          recordFlip("mtime");
         } else {
           await passAndExit(run, mtimeSkip, "no-delta-since-last-review");
         }
@@ -18578,8 +19037,9 @@ async function evidence(run) {
       const allCheckable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...reviewable, ...securityFiles]));
       const hashResult = checkContentHash(allCheckable, baselineSessionId);
       if (hashResult.skip) {
-        if (assistantResponse) {
+        if (planWorthy) {
           analysisMode = "plan";
+          recordFlip("content-hash");
         } else {
           await passAndExit(run, hashResult.skip, "no-delta-since-last-review");
         }
@@ -18641,8 +19101,9 @@ async function evidence(run) {
           maxTotalBytes: parseInt(opts.maxTotalSize, 10)
         });
         if (codeDelta.files.length === 0 && staticResults.findings.length === 0) {
-          if (assistantResponse) {
+          if (planWorthy) {
             analysisMode = "plan";
+            recordFlip("empty-after-scoping");
           } else {
             await passAndExit(
               run,
@@ -18662,32 +19123,32 @@ async function evidence(run) {
         snapshotResult = generateSnapshotDiffs(codeDelta.files);
       }
       currentCommit = getCurrentCommit();
-      iteration = readIterationState(currentCommit).iteration;
+      iteration = readIteration(currentCommit);
     }
   }
   if (analysisMode === "plan") {
     recordAnalysisStart();
     currentCommit = getCurrentCommit();
-    iteration = readIterationState(currentCommit).iteration;
+    iteration = readIteration(currentCommit);
   }
   Object.assign(run, { analysisMode, codeDelta, contentHash, currentCommit, earlyFold, iteration, snapshotResult, staticResults });
 }
 
 // src/lib/cache-cleanup.ts
-var import_node_fs24 = require("node:fs");
-var import_node_path19 = require("node:path");
+var import_node_fs26 = 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_fs24.readdirSync)(dir)) {
+    for (const entry of (0, import_node_fs26.readdirSync)(dir)) {
       if (!entry.startsWith("pending-")) continue;
-      const path = (0, import_node_path19.join)(dir, entry);
+      const path = (0, import_node_path22.join)(dir, entry);
       try {
-        const stat3 = (0, import_node_fs24.statSync)(path);
+        const stat3 = (0, import_node_fs26.statSync)(path);
         if (stat3.mtimeMs < cutoff) {
-          (0, import_node_fs24.unlinkSync)(path);
+          (0, import_node_fs26.unlinkSync)(path);
           logEvent("cache_entry_pruned", {
             path: entry,
             age_days: Math.round((Date.now() - stat3.mtimeMs) / 864e5)
@@ -18701,7 +19162,7 @@ function pruneStaleCache() {
 }
 
 // src/lib/context-files.ts
-var import_node_fs25 = require("node:fs");
+var import_node_fs27 = require("node:fs");
 var MAX_CONTEXT_FILES = 10;
 var MAX_CONTEXT_FILE_BYTES = 10240;
 var MAX_CONTEXT_TOTAL_BYTES = 51200;
@@ -18716,8 +19177,13 @@ function gatherContextFiles(contextPaths, deltaFiles) {
       logEvent("context_file_skipped", { path: filePath, reason: "verity_owned" });
       continue;
     }
+    const safePath = resolveInside(process.cwd(), filePath);
+    if (!safePath) {
+      logEvent("context_file_skipped", { path: filePath, reason: "outside_repo" });
+      continue;
+    }
     try {
-      const content = (0, import_node_fs25.readFileSync)(filePath, "utf8");
+      const content = (0, import_node_fs27.readFileSync)(safePath, "utf8");
       const bytes = Buffer.byteLength(content);
       if (bytes > MAX_CONTEXT_FILE_BYTES) {
         logEvent("context_file_skipped", { path: filePath, reason: "too_large", bytes });
@@ -18764,7 +19230,8 @@ function gatherContextFiles(contextPaths, deltaFiles) {
 // src/commands/analyze/phases/07-context-files.ts
 async function contextFiles(run) {
   const { codeDelta, contextFilePaths } = run;
-  const contextFiles2 = gatherContextFiles(contextFilePaths, codeDelta.files);
+  const { kept: externalContext } = partitionVerityOwned(contextFilePaths ?? []);
+  const contextFiles2 = gatherContextFiles(externalContext, codeDelta.files);
   for (const f of codeDelta.files) {
     f.role = "delta";
   }
@@ -18778,8 +19245,8 @@ async function contextFiles(run) {
 
 // src/lib/seed-runner.ts
 var import_promises11 = require("node:fs/promises");
-var import_node_fs26 = require("node:fs");
-var import_node_path20 = require("node:path");
+var import_node_fs28 = require("node:fs");
+var import_node_path23 = require("node:path");
 var import_yaml2 = __toESM(require_dist());
 
 // src/lib/seed.ts
@@ -19018,7 +19485,7 @@ function renderNodeMarkdown(candidate, nodeId, createdAt) {
   return fm;
 }
 async function runSeed(opts) {
-  if (!(0, import_node_fs26.existsSync)(STANDARD_FILE)) {
+  if (!(0, import_node_fs28.existsSync)(STANDARD_FILE)) {
     return { created: 0, failed: 0, skipped: "no_standard", candidates: [] };
   }
   let standardDoc;
@@ -19030,7 +19497,7 @@ async function runSeed(opts) {
   }
   const knowledgeSpec = standardDoc.knowledge_spec ?? {};
   let readmeContent;
-  if ((0, import_node_fs26.existsSync)("README.md")) {
+  if ((0, import_node_fs28.existsSync)("README.md")) {
     try {
       readmeContent = await (0, import_promises11.readFile)("README.md", "utf-8");
     } catch {
@@ -19038,7 +19505,7 @@ async function runSeed(opts) {
   }
   let claudeMdContent;
   for (const p of ["CLAUDE.md", ".claude/CLAUDE.md"]) {
-    if ((0, import_node_fs26.existsSync)(p)) {
+    if ((0, import_node_fs28.existsSync)(p)) {
       try {
         claudeMdContent = await (0, import_promises11.readFile)(p, "utf-8");
         break;
@@ -19061,8 +19528,8 @@ async function runSeed(opts) {
   if (candidates.length === 0) {
     return { created: 0, failed: 0, skipped: "no_candidates", candidates: [] };
   }
-  const overviewPath = (0, import_node_path20.join)(MEMORY_DIR, "domain", "project-overview.md");
-  if ((0, import_node_fs26.existsSync)(overviewPath) && !opts.force) {
+  const overviewPath = (0, import_node_path23.join)(MEMORY_DIR, "domain", "project-overview.md");
+  if ((0, import_node_fs28.existsSync)(overviewPath) && !opts.force) {
     return { created: 0, failed: 0, skipped: "already_seeded", candidates };
   }
   if (opts.dryRun) {
@@ -19097,9 +19564,14 @@ async function runSeed(opts) {
     }
     const nodeId = res.data.node_id;
     const filePathRel = res.data.file_path;
-    const targetPath = (0, import_node_path20.join)(MEMORY_DIR, filePathRel);
+    const targetPath = resolveInside(MEMORY_DIR, filePathRel);
+    if (!targetPath) {
+      opts.onFailed?.(c, `Server returned an out-of-bounds file_path (${String(filePathRel)}); refusing to write outside the memory directory.`);
+      failed++;
+      continue;
+    }
     try {
-      await (0, import_promises11.mkdir)((0, import_node_path20.dirname)(targetPath), { recursive: true });
+      await (0, import_promises11.mkdir)((0, import_node_path23.dirname)(targetPath), { recursive: true });
       await (0, import_promises11.writeFile)(targetPath, renderNodeMarkdown(c, nodeId, createdAt));
       created++;
       opts.onCreated?.(nodeId, filePathRel, c);
@@ -19112,8 +19584,8 @@ async function runSeed(opts) {
 }
 
 // src/commands/analyze/phases/08-memory-manifest.ts
-var import_node_fs27 = require("node:fs");
-var import_node_path21 = require("node:path");
+var import_node_fs29 = require("node:fs");
+var import_node_path24 = require("node:path");
 async function memoryManifest(run) {
   const { globals } = run;
   const { serviceUrl, token } = run;
@@ -19123,9 +19595,9 @@ async function memoryManifest(run) {
   let autoSeedNotice = null;
   try {
     await ensureMemoryDir();
-    const seedMarker = (0, import_node_path21.join)(VERITY_DIR, ".seeded");
-    const hasStandard = (0, import_node_fs27.existsSync)(STANDARD_FILE);
-    const alreadyTried = (0, import_node_fs27.existsSync)(seedMarker);
+    const seedMarker = (0, import_node_path24.join)(VERITY_DIR, ".seeded");
+    const hasStandard = (0, import_node_fs29.existsSync)(STANDARD_FILE);
+    const alreadyTried = (0, import_node_fs29.existsSync)(seedMarker);
     if (hasStandard && !alreadyTried) {
       const preManifest = await buildManifest();
       if (preManifest.nodes.length === 0) {
@@ -19138,7 +19610,7 @@ async function memoryManifest(run) {
             dryRun: false
           });
           if (seedResult.created > 0) {
-            (0, import_node_fs27.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} created=${seedResult.created}
+            (0, import_node_fs29.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", {
@@ -19146,7 +19618,7 @@ async function memoryManifest(run) {
               failed: seedResult.failed
             });
           } else if (seedResult.skipped === "already_seeded") {
-            (0, import_node_fs27.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} skipped=already_seeded
+            (0, import_node_fs29.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} skipped=already_seeded
 `);
           } else {
             logEvent("auto_seed_noop", {
@@ -19241,7 +19713,7 @@ function computeIncrement(reviewedPaths, hashOf, priorAuthored) {
 }
 
 // src/commands/analyze/phases/10-working-memory.ts
-var import_node_path22 = require("node:path");
+var import_node_path25 = require("node:path");
 async function workingMemory(run) {
   const { opts } = run;
   const { allForReview, baseline, conversation, foldResult, sessionId, token, transcriptPath } = run;
@@ -19253,7 +19725,7 @@ async function workingMemory(run) {
     const priorState = foldForMarks(memorySession.d);
     incrementReport = computeIncrement(
       allForReview,
-      (p) => fileHash((0, import_node_path22.join)(repoRoot(), p)),
+      (p) => fileHash((0, import_node_path25.join)(repoRoot(), p)),
       priorState.authored_all.map((a) => ({
         path: a.path,
         hash_at_last_verdict: a.hash_at_last_verdict
@@ -19334,6 +19806,54 @@ async function workingMemory(run) {
   Object.assign(run, { incrementReport, memory, memorySession, reachability });
 }
 
+// src/lib/note-budget.ts
+var import_node_fs30 = require("node:fs");
+var ADVISORY_BUDGET = { PASS: 1, WARN: 2 };
+var EPISODE_STALE_SECONDS = 30 * 60;
+var FRESH = { delivered: 0, tasksCompleted: 0, ts: 0 };
+function resolveEpisode(prev, signals) {
+  if (!prev) return { ...FRESH, tasksCompleted: signals.tasksCompleted, ts: signals.now };
+  if (signals.humanSpoke) return { ...FRESH, tasksCompleted: signals.tasksCompleted, ts: signals.now };
+  if (signals.rawFail) return { ...FRESH, tasksCompleted: signals.tasksCompleted, ts: signals.now };
+  if (prev.tasksCompleted !== signals.tasksCompleted) {
+    return { ...FRESH, tasksCompleted: signals.tasksCompleted, ts: signals.now };
+  }
+  if (prev.ts > 0 && signals.now - prev.ts > EPISODE_STALE_SECONDS) {
+    return { ...FRESH, tasksCompleted: signals.tasksCompleted, ts: signals.now };
+  }
+  return prev;
+}
+function advisoryBudgetSpent(episode, rawDecision) {
+  const budget = ADVISORY_BUDGET[rawDecision] ?? ADVISORY_BUDGET.WARN;
+  return episode.delivered >= budget;
+}
+function readAdvisoryEpisode(sessionId) {
+  const file = scopedFile(ADVISORY_EPISODE_FILE, sessionId);
+  if (!(0, import_node_fs30.existsSync)(file)) return null;
+  try {
+    const o = JSON.parse((0, import_node_fs30.readFileSync)(file, "utf-8")) ?? {};
+    const delivered = typeof o.delivered === "number" ? o.delivered : NaN;
+    if (isNaN(delivered)) return null;
+    return {
+      delivered,
+      tasksCompleted: typeof o.tasksCompleted === "number" ? o.tasksCompleted : 0,
+      ts: typeof o.ts === "number" ? o.ts : 0
+    };
+  } catch {
+    return null;
+  }
+}
+function writeAdvisoryEpisode(episode, sessionId) {
+  try {
+    (0, import_node_fs30.mkdirSync)(VERITY_DIR, { recursive: true });
+    (0, import_node_fs30.writeFileSync)(
+      scopedFile(ADVISORY_EPISODE_FILE, sessionId),
+      JSON.stringify({ v: 1, ...episode })
+    );
+  } catch {
+  }
+}
+
 // src/lib/run-mode.ts
 function parseAutonomousEnv(raw) {
   if (raw === void 0) return void 0;
@@ -19356,7 +19876,7 @@ function isExplicitlyAutonomous(env = process.env) {
 }
 
 // src/lib/task-context.ts
-var import_node_child_process8 = require("node:child_process");
+var import_node_child_process9 = 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) {
@@ -19372,7 +19892,7 @@ function parseLinkedIssue(sources) {
 }
 function safeExec(cmd, timeout) {
   try {
-    return (0, import_node_child_process8.execSync)(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout }).trim();
+    return (0, import_node_child_process9.execSync)(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout }).trim();
   } catch {
     return "";
   }
@@ -19427,7 +19947,13 @@ async function buildRequest(run) {
     excluded_by_reason: excludedByReason,
     // was the transcript itself truncated? The 256 KB window means "this turn"
     // can quietly mean "the last 256 KB of it".
-    transcript_windowed: actionSummary?.transcript_windowed ?? null
+    transcript_windowed: actionSummary?.transcript_windowed ?? null,
+    // The advisory budget's fleet counter-metric (note-budget.ts): deliveries in
+    // the episode as of the PREVIOUS turn — this runs before phase 13 updates
+    // the state, so the number is one turn lagged by construction. The
+    // degenerate win for the budget is a dead channel that looks like clean
+    // code; this is what makes "did delivery rate collapse" a query.
+    advisory_delivered_prior: readAdvisoryEpisode(run.baselineSessionId)?.delivered ?? 0
   };
   const requestBody = {
     coverage_telemetry: coverageTelemetry,
@@ -19566,7 +20092,8 @@ async function buildRequest(run) {
   }
   const noHumanPrompt = (conversation?.prompts?.length ?? 0) === 0;
   const w4Task = noHumanPrompt && isExplicitlyAutonomous() ? resolveTaskContext() : null;
-  const hasIntent = (conversation?.prompts?.length ?? 0) > 0 || specs.length > 0 || plans.length > 0 || !!assistantResponse || !!w4Task;
+  const planApprovalActive = foldResult?.planApproval?.activeSinceLastPrompt === true;
+  const hasIntent = (conversation?.prompts?.length ?? 0) > 0 || specs.length > 0 || plans.length > 0 || !!assistantResponse || !!w4Task || planApprovalActive;
   if (hasIntent) {
     const intentContext = {};
     if (conversation && conversation.prompts.length > 0) {
@@ -19598,6 +20125,10 @@ async function buildRequest(run) {
       intentContext.user_prompt = w4Task.goal;
       logEvent("w4_issue_anchor", { issue: w4Task.number, via: w4Task.via });
     }
+    if (planApprovalActive) {
+      intentContext.plan_approved = true;
+      logEvent("plan_approval_carried", { approvals: foldResult.planApproval.approvals });
+    }
     if (assistantResponse) {
       const cap = analysisMode === "plan" ? MAX_ASSISTANT_RESPONSE_CHARS_PLAN : MAX_ASSISTANT_RESPONSE_CHARS_DEFAULT;
       intentContext.assistant_response = assistantResponse.length > cap ? assistantResponse.slice(0, cap) : assistantResponse;
@@ -19617,14 +20148,14 @@ async function buildRequest(run) {
 }
 
 // src/lib/offline.ts
-var import_node_fs28 = require("node:fs");
+var import_node_fs31 = require("node:fs");
 var import_node_crypto11 = require("node:crypto");
 function cacheRequest(body) {
   try {
-    (0, import_node_fs28.mkdirSync)(CACHE_DIR, { recursive: true });
+    (0, import_node_fs31.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_fs28.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(redactRequest(body)));
+    (0, import_node_fs31.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(redactRequest(body)));
   } catch {
   }
 }
@@ -19743,10 +20274,10 @@ async function transmit(run) {
 }
 
 // src/commands/analyze/phases/13-reconcile.ts
-var import_node_fs29 = require("node:fs");
-var import_node_path23 = require("node:path");
+var import_node_fs32 = require("node:fs");
+var import_node_path26 = require("node:path");
 async function reconcile(run) {
-  const { actionSummary, allChanged, analyzable, baseline, codeDelta, contentHash, conversation, decision, memory, memorySession, response, reviewable, securityFiles, turnId } = run;
+  const { actionSummary, allChanged, analyzable, baseline, baselineSessionId, codeDelta, contentHash, conversation, decision, foldResult, memory, memorySession, response, reviewable, securityFiles, turnId } = run;
   const sentPaths = codeDelta.files.map((f) => f.path);
   let openElsewhere = [];
   if (memorySession) {
@@ -19754,7 +20285,7 @@ async function reconcile(run) {
       const st = foldDossier(memorySession.d);
       openElsewhere = openBlockingElsewhere(st.statements, sentPaths, (file, line) => {
         try {
-          const src = (0, import_node_fs29.readFileSync)((0, import_node_path23.join)(repoRoot(), file), "utf8").split("\n");
+          const src = (0, import_node_fs32.readFileSync)((0, import_node_path26.join)(repoRoot(), file), "utf8").split("\n");
           const at = src[line - 1];
           return at === void 0 ? null : lineSha(at);
         } catch {
@@ -19764,6 +20295,7 @@ async function reconcile(run) {
     } catch {
     }
   }
+  const { kept: externalChanged, owned: verityOwned } = partitionVerityOwned(allChanged);
   const reviewCoverage = {
     reviewed: sentPaths,
     // Declared drops from the stages that DO report themselves today. The other
@@ -19805,11 +20337,20 @@ async function reconcile(run) {
         stage: "baseline-scoping",
         kind: "policy"
       })),
+      // ⚠ VERITY'S OWN FILES, named as such — not laundered into the
+      // extension bucket below, where "we do not review our own installer's
+      // dirt" would read as "a changed README". See self-scope.ts.
+      ...verityOwned.map((path) => ({
+        path,
+        reason: "verity-owned",
+        stage: "self-scope",
+        kind: "policy"
+      })),
       // The extension allowlist. POLICY: a changed README was never going to be
       // reviewed, and calling that a coverage gap would downgrade nearly every
       // PASS to WARN until WARN meant nothing. Recorded so the ledger balances and
       // so "what did Verity ignore entirely" is answerable.
-      ...allChanged.filter((p) => !analyzable.includes(p) && !reviewable.includes(p) && !securityFiles.includes(p)).map((path) => ({
+      ...externalChanged.filter((p) => !analyzable.includes(p) && !reviewable.includes(p) && !securityFiles.includes(p)).map((path) => ({
         path,
         reason: "not-a-reviewed-file-type",
         stage: "extension-allowlist",
@@ -19846,6 +20387,29 @@ async function reconcile(run) {
       decision
     });
   }
+  const episodeSignals = {
+    humanSpoke: (conversation?.prompts?.length ?? 0) > 0,
+    rawFail: decision === "FAIL",
+    tasksCompleted: (foldResult?.tasks ?? []).filter((t) => t.status === "completed").length,
+    now: Math.floor(Date.now() / 1e3)
+  };
+  let episode = resolveEpisode(readAdvisoryEpisode(baselineSessionId), episodeSignals);
+  const contentClass = classifyChannelContent(channelInputFrom(response));
+  const wouldCarryAdvisory = contentClass.advisory || openElsewhere.length > 0;
+  if (decision !== "FAIL" && !silenced && wouldCarryAdvisory && !contentClass.refusal && !contentClass.intentFlag && advisoryBudgetSpent(episode, decision)) {
+    silenced = "note-budget";
+    logEvent("channel_silenced", {
+      reason: silenced,
+      run_id: response.run_id ?? turnId,
+      decision,
+      episode_delivered: episode.delivered
+    });
+  }
+  const deliveringAdvisory = decision !== "FAIL" && !silenced && wouldCarryAdvisory;
+  writeAdvisoryEpisode(
+    { ...episode, delivered: episode.delivered + (deliveringAdvisory ? 1 : 0), ts: episodeSignals.now },
+    baselineSessionId
+  );
   let intentRepeatCount = 0;
   const priorPendingFingerprints = memorySession ? (() => {
     try {
@@ -19861,6 +20425,11 @@ async function reconcile(run) {
         decision,
         branch: getCurrentBranch(),
         watermarkSha: watermarkIsPartial ? null : watermarkHash,
+        // The byte witness — the same "only honest definition of reviewed" the
+        // coverage column uses. A finding on a path outside this set records no
+        // statement (plan-mode prose anchored to unsent files must not become
+        // "STILL OPEN … the tree is not clean").
+        sentPaths,
         findings: response.findings?.map((f) => ({
           file: f.file,
           line: f.line,
@@ -19927,6 +20496,39 @@ ${YELLOW2}${note}${NC2}
   return exit(0);
 }
 
+// src/lib/may-block.ts
+var HARD_BLOCK_CEILING = 5;
+function mayBlock(input) {
+  const ceiling = input.ceiling ?? HARD_BLOCK_CEILING;
+  if (input.reviewedFileCount === 0 && input.staticFindingCount === 0) {
+    return { block: false, release: "no-code-reviewed" };
+  }
+  if (input.cycleCutFired) {
+    return { block: false, release: "nothing-moved" };
+  }
+  if (input.attempts > input.maxIterations) {
+    return { block: false, release: "same-problem-cap" };
+  }
+  if (input.blocks > ceiling) {
+    return { block: false, release: "block-ceiling" };
+  }
+  return { block: true, release: null };
+}
+function describeRelease(release, input) {
+  const ceiling = input.ceiling ?? HARD_BLOCK_CEILING;
+  const open = input.findingCount > 0 ? `${input.findingCount} finding(s) remain OPEN and were NOT fixed. Human review required before deploying.` : "Human review required before deploying.";
+  switch (release) {
+    case "no-code-reviewed":
+      return `Verity: WARN \u2014 NOT BLOCKING: no code was reviewed on this turn, so there is nothing here to fix. Reported as advice instead. ${open}`;
+    case "nothing-moved":
+      return `Verity: WARN \u2014 NOT BLOCKING: nothing has changed since the last verdict, so re-raising it cannot move anything forward. ${open}`;
+    case "same-problem-cap":
+      return `Verity: WARN \u2014 self-healing limit (${input.maxIterations}) reached on the same finding. NO LONGER BLOCKING, but ${open}`;
+    case "block-ceiling":
+      return `Verity: WARN \u2014 ${ceiling} consecutive blocking verdicts reached; releasing the block so this cannot loop. ${open}`;
+  }
+}
+
 // src/lib/remediation-guard.ts
 var TOOL_CONFIG_PATTERNS = [
   /(^|\/)\.codacy\//,
@@ -19969,19 +20571,7 @@ function screenRemediation(fix, findingFile) {
 
 // src/commands/analyze/phases/14-render.ts
 function agentContextFor(response, intentRepeat = 0, priorPendingFingerprints = []) {
-  const metadata = response.metadata ?? {};
-  const intent = response.intent_alignment ?? {};
-  return buildAgentContext({
-    intentRepeat,
-    priorPendingFingerprints,
-    gateDecision: String(response.gate_decision ?? ""),
-    findings: response.findings ?? [],
-    pendingItems: response.pending_items ?? [],
-    reviewStatus: metadata.review_status,
-    coverage: metadata.coverage,
-    intentVerdict: intent.verdict,
-    intentGaps: intent.gaps
-  });
+  return buildAgentContext(channelInputFrom(response, intentRepeat, priorPendingFingerprints));
 }
 async function render(run) {
   const { opts, globals } = run;
@@ -20075,38 +20665,63 @@ async function render(run) {
     reverify_by: response.reverify_by
   });
   const grantNudge = grantWarning ? ` \u26A0\uFE0F ${grantWarning}` : "";
-  let capReleased = false;
+  let release = null;
   let effectiveDecision = decision;
   if (decision === "FAIL") {
-    const blocking = (response.findings ?? []).filter((f) => {
+    const findings = response.findings ?? [];
+    const blocking = findings.filter((f) => {
       const sev = String(f.severity ?? "").toLowerCase();
       return sev === "critical" || sev === "high";
     });
     const fingerprint = findingsFingerprint(blocking);
-    const prior = readIterationState(currentCommit);
+    const prior = readBlockState(currentCommit, {
+      newUserPrompt: (conversation?.prompts?.length ?? 0) > 0
+    });
     const sameProblem = isSameProblem(prior.fingerprint, fingerprint);
-    const nextIteration = sameProblem ? prior.iteration + 1 : 1;
     const maxIterations = parseInt(opts.maxIterations, 10);
-    writeIteration(nextIteration, currentCommit, contentHash ?? void 0, fingerprint);
-    iteration = nextIteration;
-    if (nextIteration > maxIterations) {
-      capReleased = true;
+    const attempts = sameProblem ? prior.attempts + 1 : 1;
+    const blocks = prior.blocks + 1;
+    const decisionNow = mayBlock({
+      reviewedFileCount: codeDelta.files.length,
+      staticFindingCount: run.staticResults?.findings?.length ?? 0,
+      cycleCutFired: silenced !== null,
+      attempts,
+      blocks,
+      maxIterations
+    });
+    if (decisionNow.block) {
+      writeBlockState(currentCommit, { attempts, blocks, fingerprint });
+      iteration = attempts;
+    } else {
+      release = decisionNow.release;
       effectiveDecision = "WARN";
-      logEvent("iteration_cap_released", { iteration: nextIteration, fingerprint });
+      logEvent("block_released", {
+        reason: release,
+        attempts,
+        blocks,
+        reviewed_files: codeDelta.files.length,
+        cycle_cut: silenced,
+        fingerprint
+      });
     }
   }
-  if (capReleased) {
+  if (release) {
     const findings = response.findings ?? [];
     const lines = findings.slice(0, 5).map((f) => `  [${String(f.severity ?? "?").toUpperCase()}] ${String(f.title ?? f.message ?? "")} (${String(f.file ?? "?")}:${String(f.line ?? "?")})`);
+    const summary = describeRelease(release, {
+      findingCount: findings.length,
+      maxIterations: parseInt(opts.maxIterations, 10)
+    });
     emitVerdict({
       proposed: "WARN",
       changed: run.changedUniverse,
       coverage: reviewCoverage,
-      userSummary: `Verity: WARN \u2014 self-healing limit (${opts.maxIterations}) reached on the same finding. NO LONGER BLOCKING, but ${findings.length} finding(s) remain OPEN and were NOT fixed. Human review required before deploying.
-${lines.join("\n")}`,
+      userSummary: lines.length > 0 ? `${summary}
+${lines.join("\n")}` : summary,
       agentContext: null,
       silenced: true
     });
+    return;
   }
   switch (effectiveDecision) {
     case "FAIL": {
@@ -20205,7 +20820,7 @@ ${YELLOW}${grantNudge.trim()}${NC}
       break;
     }
     case "PASS": {
-      writeIteration(1, currentCommit, contentHash ?? void 0);
+      resetBlockState(currentCommit);
       if (watermarkHash) recordPassHash(watermarkHash, baselineSessionId);
       if (!watermarkIsPartial && currentCommit && currentCommit !== "no-git") writeBaselineSha(currentCommit);
       let userSummary = response.user_summary ?? "Verity: PASS";
@@ -20226,6 +20841,7 @@ ${YELLOW}${grantNudge.trim()}${NC}
       break;
     }
     case "WARN": {
+      if (decision !== "FAIL") resetBlockState(currentCommit);
       if (watermarkHash) recordPassHash(watermarkHash, baselineSessionId);
       if (!watermarkIsPartial && currentCommit && currentCommit !== "no-git") writeBaselineSha(currentCommit);
       let userSummary = response.user_summary ?? "Verity: WARN";
@@ -20324,7 +20940,7 @@ async function runAnalyze(opts, globals) {
 }
 
 // src/commands/baseline.ts
-var import_node_fs30 = require("node:fs");
+var import_node_fs33 = 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) => {
@@ -20333,7 +20949,7 @@ function registerBaselineCommands(program2) {
         process.chdir(repoRoot());
       } catch {
       }
-      if (!(0, import_node_fs30.existsSync)(VERITY_DIR)) {
+      if (!(0, import_node_fs33.existsSync)(VERITY_DIR)) {
         process.exit(0);
       }
       let sessionId = opts.sessionId;
@@ -20373,7 +20989,7 @@ async function readStdin() {
 }
 
 // src/commands/review.ts
-var import_node_fs31 = require("node:fs");
+var import_node_fs34 = 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();
@@ -20392,7 +21008,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_fs31.existsSync)(f) || resolveFile(f) !== null);
+    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).filter((f) => (0, import_node_fs34.existsSync)(f) || resolveFile(f) !== null);
     staticResults = runCodacyAnalysis(scannable);
   } else {
     staticResults = {
@@ -20418,10 +21034,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_fs31.existsSync)(p)) continue;
+      if (!(0, import_node_fs34.existsSync)(p)) continue;
       try {
-        const { readFileSync: readFileSync18 } = await import("node:fs");
-        const content = readFileSync18(p, "utf-8");
+        const { readFileSync: readFileSync20 } = await import("node:fs");
+        const content = readFileSync20(p, "utf-8");
         specs.push({ path: p, content: content.slice(0, 10240) });
       } catch {
       }
@@ -20478,15 +21094,15 @@ async function runReview(opts, globals) {
 }
 
 // src/commands/guard.ts
-var import_node_fs32 = require("node:fs");
-var import_node_path24 = require("node:path");
+var import_node_fs35 = require("node:fs");
+var import_node_path27 = require("node:path");
 var GUARD_BLOCK_CAP = 2;
-var GUARD_ITER_FILE = (0, import_node_path24.join)(VERITY_DIR, ".guard-iteration");
+var GUARD_ITER_FILE = (0, import_node_path27.join)(VERITY_DIR, ".guard-iteration");
 function readPreToolUseStdin() {
   const empty = { command: "", cwd: null, sessionId: null };
-  return new Promise((resolve2) => {
+  return new Promise((resolve4) => {
     try {
-      if (process.stdin.isTTY) return resolve2(empty);
+      if (process.stdin.isTTY) return resolve4(empty);
       const chunks = [];
       let timer;
       let settled = false;
@@ -20499,7 +21115,7 @@ function readPreToolUseStdin() {
         process.stdin.removeListener("end", onEnd);
         process.stdin.removeListener("error", onError);
         process.stdin.pause();
-        resolve2(value);
+        resolve4(value);
       };
       const onEnd = () => {
         try {
@@ -20520,32 +21136,13 @@ function readPreToolUseStdin() {
       process.stdin.on("error", onError);
       process.stdin.resume();
     } catch {
-      resolve2(empty);
+      resolve4(empty);
     }
   });
 }
-function buildCommandRe(head) {
-  return new RegExp(`(?:^|[\\s;&|(])${head}|(?:^|[;&|(])\\s*[^\\s;&|()'"]*\\/${head}`);
-}
-var GIT_GLOBAL_OPTS = "(?:\\s+(?:-[Cc]\\s+\\S+|--?[\\w-]+(?:=\\S+)?))*";
-var COMMIT_RE = buildCommandRe(`git${GIT_GLOBAL_OPTS}\\s+commit(?![\\w-])`);
-var PUSH_RE = buildCommandRe(`git${GIT_GLOBAL_OPTS}\\s+push\\b`);
-var GH_PR_RE = buildCommandRe(`gh${GIT_GLOBAL_OPTS}\\s+pr\\s+create\\b`);
-function classifyCommand2(command, on) {
-  let commit = false;
-  let push = false;
-  for (const seg of (command ?? "").split(/&&|\|\||;|\n/)) {
-    if (/--dry-run\b/.test(seg)) continue;
-    if (COMMIT_RE.test(seg)) commit = true;
-    if (PUSH_RE.test(seg) || GH_PR_RE.test(seg)) push = true;
-  }
-  if (commit && on.includes("commit")) return "pre-commit";
-  if (push && on.includes("push")) return "pre-push";
-  return null;
-}
 function readIterMap() {
   try {
-    const raw = JSON.parse((0, import_node_fs32.readFileSync)(GUARD_ITER_FILE, "utf-8"));
+    const raw = JSON.parse((0, import_node_fs35.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 };
@@ -20565,10 +21162,10 @@ function readIter(moment) {
 }
 function writeIter(moment, count) {
   try {
-    (0, import_node_fs32.mkdirSync)(VERITY_DIR, { recursive: true });
+    (0, import_node_fs35.mkdirSync)(VERITY_DIR, { recursive: true });
     const map = readIterMap();
     map[moment] = count;
-    (0, import_node_fs32.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
+    (0, import_node_fs35.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
   } catch {
   }
 }
@@ -20578,10 +21175,10 @@ function resetIter(moment) {
     if (!(moment in map)) return;
     delete map[moment];
     if (Object.keys(map).length === 0) {
-      if ((0, import_node_fs32.existsSync)(GUARD_ITER_FILE)) (0, import_node_fs32.unlinkSync)(GUARD_ITER_FILE);
+      if ((0, import_node_fs35.existsSync)(GUARD_ITER_FILE)) (0, import_node_fs35.unlinkSync)(GUARD_ITER_FILE);
     } else {
-      (0, import_node_fs32.mkdirSync)(VERITY_DIR, { recursive: true });
-      (0, import_node_fs32.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
+      (0, import_node_fs35.mkdirSync)(VERITY_DIR, { recursive: true });
+      (0, import_node_fs35.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
     }
   } catch {
   }
@@ -20596,8 +21193,14 @@ function registerGuardCommand(program2) {
     }
   });
 }
-function getMomentFiles(moment) {
-  return moment === "pre-commit" ? getStagedFiles() : getPushRangeFiles().files;
+function resolveMomentRange(moment, frame, command, on) {
+  return moment === "pre-commit" ? stagedRange() : resolvePushRange(frame, command, on);
+}
+function describeRange(range) {
+  if (range.kind === "staged") return "staged";
+  if (range.kind === "nothing" || !range.base) return null;
+  const base = /^[0-9a-f]{40}$/.test(range.base) ? range.base.slice(0, 7) : range.base;
+  return `${base}..${range.head} via ${range.via}`;
 }
 function matchFlagValue(command, flags) {
   const re = new RegExp(`(?<![\\w-])(?:${flags})(?:=|\\s+)('((?:[^'\\\\]|\\\\.)*)'|"((?:[^"\\\\]|\\\\.)*)"|([^\\s'"-][^\\s]*))`);
@@ -20632,26 +21235,24 @@ function isSubstantiveIntent(text) {
   if (SHELL_PLUMBING.test(t)) return false;
   return true;
 }
-function extractStatedIntent(moment, command) {
-  const text = moment === "pre-commit" ? parseCommitMessage(command) : parsePrIntent(command) ?? (getPushRangeMessages() || null);
+function extractStatedIntent(moment, command, pushedMessages = null) {
+  const text = moment === "pre-commit" ? parseCommitMessage(command) : parsePrIntent(command) ?? pushedMessages;
   return isSubstantiveIntent(text) ? text : null;
 }
 function hasBlockingFinding(response) {
   const findings = response.findings ?? [];
   return findings.some((f) => f.scope !== "pre-existing" && ["critical", "high"].includes((f.severity ?? "").toLowerCase()));
 }
-function buildGuardRequest(moment, files, iter, sessionId, command) {
+function buildGuardRequest(moment, files, codeDelta, iter, sessionId, statedIntent, coverageTelemetry) {
   const analyzable = filterAnalyzable(files);
   const securityFiles = filterSecurity(files);
   let staticResults;
   if (isCodacyAvailable()) {
-    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).map((f) => (0, import_node_fs32.existsSync)(f) ? f : resolveFile(f)).filter((f) => f !== null);
+    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).map((f) => (0, import_node_fs35.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: [] } };
   }
-  const codeDelta = collectCodeDelta(files);
-  if (codeDelta.total_files === 0) return null;
   const trigger = moment === "pre-commit" ? "hook:pre-commit" : "hook:pre-push";
   const requestBody = {
     static_results: staticResults,
@@ -20668,9 +21269,9 @@ function buildGuardRequest(moment, files, iter, sessionId, command) {
       iteration: iter + 1
     }
   };
+  if (coverageTelemetry) requestBody.coverage_telemetry = coverageTelemetry;
   const specs = discoverSpecs();
   const plans = discoverPlans();
-  const statedIntent = extractStatedIntent(moment, command);
   if (specs.length > 0 || plans.length > 0 || statedIntent) {
     const intentContext = {};
     if (statedIntent) intentContext.user_prompt = statedIntent;
@@ -20680,6 +21281,39 @@ function buildGuardRequest(moment, files, iter, sessionId, command) {
   }
   return requestBody;
 }
+function buildGuardCoverage(files, codeDelta, frame, frameRange) {
+  const byReason = {};
+  for (const e of codeDelta.excluded) byReason[e.reason] = (byReason[e.reason] ?? 0) + 1;
+  return {
+    changed_all: files.length,
+    analyzable: filterAnalyzable(files).length,
+    reviewable: filterReviewable(files).length,
+    security: filterSecurity(files).length,
+    for_review: files.length,
+    sent: codeDelta.total_files,
+    capped_out: codeDelta.truncated?.dropped ?? 0,
+    excluded: codeDelta.excluded.length,
+    excluded_by_reason: byReason,
+    transcript_windowed: null,
+    guard_frame: frameTelemetry(frame, frameRange)
+  };
+}
+function coverageSummary(c) {
+  const range = c.range ? ` @ ${c.range}` : "";
+  return `reviewed ${c.sent.length} file(s)${range}`;
+}
+function coverageBlock(c) {
+  const lines = [];
+  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}`);
+  for (const f of c.sent) lines.push(`  - ${f}`);
+  if (c.excluded.length > 0) {
+    lines.push(`  Excluded (${c.excluded.length}):`);
+    for (const e of c.excluded) lines.push(`  - ${e.path} (${e.reason})`);
+  }
+  return lines.join("\n");
+}
 function emitAllowNotice(userMsg, agentMsg) {
   process.stdout.write(JSON.stringify({
     systemMessage: userMsg,
@@ -20690,15 +21324,24 @@ function emitAllowNotice(userMsg, agentMsg) {
 async function runGuard(opts, globals) {
   const on = opts.on.split(",").map((s) => s.trim()).filter((s) => s === "commit" || s === "push");
   const { command, cwd, sessionId } = await readPreToolUseStdin();
-  if (cwd && (0, import_node_fs32.existsSync)(cwd)) {
-    try {
-      process.chdir(cwd);
-    } catch {
-    }
-  }
-  const moment = classifyCommand2(command, on);
+  const moment = classifyCommand(command, on);
   if (!moment) process.exit(0);
   const verb = moment === "pre-commit" ? "commit" : "push";
+  const { frame } = resolveFrame({ command, on, hookCwd: cwd });
+  if (frame.refusal || !frame.worktreeRoot) {
+    logEvent("guard_frame", { moment, ...frameTelemetry(frame, null) });
+    if ((frame.refusal ?? "").startsWith("anchor:")) process.exit(0);
+    emitAllowNotice(
+      `\u26A0 Verity ${moment}: could not resolve the tree this ${verb} targets \u2014 ${verb}ed WITHOUT review`,
+      `Verity ${moment}: the target tree could not be resolved (${frame.refusal}); the ${verb} was allowed WITHOUT a Verity review.`
+    );
+  }
+  try {
+    process.chdir(frame.worktreeRoot);
+  } catch {
+    process.exit(0);
+  }
+  _resetRepoRoot();
   const iter = readIter(moment);
   if (iter >= GUARD_BLOCK_CAP) {
     resetIter(moment);
@@ -20707,13 +21350,39 @@ async function runGuard(opts, globals) {
       `Verity ${moment}: review-cycle cap (${GUARD_BLOCK_CAP}) reached; the ${verb} was allowed without a further block.`
     );
   }
-  const files = getMomentFiles(moment);
+  const range = resolveMomentRange(moment, frame, command, on);
+  const files = rangeFiles(frame, range);
   if (files.length === 0) process.exit(0);
   const tokenResult = await resolveToken(globals.token);
   const urlResult = await resolveServiceUrl(globals.serviceUrl);
   if (!tokenResult.ok || !urlResult.ok) process.exit(0);
-  const requestBody = buildGuardRequest(moment, files, iter, sessionId, command);
-  if (!requestBody) process.exit(0);
+  logEvent("guard_frame", { moment, ...frameTelemetry(frame, range) });
+  const codeDelta = collectCodeDelta(files);
+  if (codeDelta.total_files === 0) process.exit(0);
+  const statedIntent = extractStatedIntent(
+    moment,
+    command,
+    moment === "pre-push" ? rangeMessages(frame, range) || null : null
+  );
+  const requestBody = buildGuardRequest(
+    moment,
+    files,
+    codeDelta,
+    iter,
+    sessionId,
+    statedIntent,
+    buildGuardCoverage(files, codeDelta, frame, range)
+  );
+  const coverage = {
+    moment,
+    root: frame.worktreeRoot,
+    branch: frame.branch,
+    linked: frame.isLinkedWorktree,
+    range: describeRange(range),
+    sent: codeDelta.files.map((f) => f.path),
+    excluded: codeDelta.excluded.map((e) => ({ path: e.path, reason: e.reason }))
+  };
+  logToFileOnly(coverageBlock(coverage));
   const result = await analyzeRequest({
     serviceUrl: urlResult.data,
     token: tokenResult.data.token,
@@ -20734,31 +21403,39 @@ async function runGuard(opts, globals) {
   const decision = response.gate_decision ?? "(unrecognised)";
   const viewUrl = response.view_url ?? "";
   const link = viewUrl ? ` \u2014 ${viewUrl}` : "";
+  const covLine = coverageSummary(coverage);
+  const covDetail = coverageBlock(coverage);
   if (decision === "FAIL" && hasBlockingFinding(response)) {
     writeIter(moment, iter + 1);
-    writeBlockMessage(moment, response);
+    writeBlockMessage(moment, response, covDetail);
     process.exit(2);
   }
   resetIter(moment);
   if (decision === "FAIL") {
     const narrative = response.assessment?.narrative ?? "";
     emitAllowNotice(
-      `\u26A0 Verity ${moment}: the ${verb} may not match its stated purpose \u2014 proceeding${link}`,
-      `Verity ${moment}: intent-alignment WARNING (not blocked).${narrative ? " " + narrative : ""}${viewUrl ? ` Report: ${viewUrl}` : ""}`
+      `\u26A0 Verity ${moment}: the ${verb} may not match its stated purpose \u2014 proceeding (${covLine})${link}`,
+      `Verity ${moment}: intent-alignment WARNING (not blocked).${narrative ? " " + narrative : ""}
+${covDetail}${viewUrl ? `
+Report: ${viewUrl}` : ""}`
     );
   }
   if (decision === "WARN") {
     emitAllowNotice(
-      `\u26A0 Verity ${moment}: WARN \u2014 proceeding${link}`,
-      `Verity ${moment} review: WARN (proceeding).${viewUrl ? ` Report: ${viewUrl}` : ""}`
+      `\u26A0 Verity ${moment}: WARN \u2014 proceeding (${covLine})${link}`,
+      `Verity ${moment} review: WARN (proceeding).
+${covDetail}${viewUrl ? `
+Report: ${viewUrl}` : ""}`
     );
   }
   emitAllowNotice(
-    `\u2713 Verity ${moment}: PASS${link}`,
-    `Verity ${moment} review: PASS.${viewUrl ? ` Report: ${viewUrl}` : ""}`
+    `\u2713 Verity ${moment}: PASS (${covLine})${link}`,
+    `Verity ${moment} review: PASS.
+${covDetail}${viewUrl ? `
+Report: ${viewUrl}` : ""}`
   );
 }
-function writeBlockMessage(moment, response) {
+function writeBlockMessage(moment, response, covDetail) {
   const label2 = moment === "pre-commit" ? "pre-commit" : "pre-push";
   const verb = moment === "pre-commit" ? "commit" : "push";
   const assessment = response.assessment;
@@ -20788,6 +21465,9 @@ function writeBlockMessage(moment, response) {
 `);
     }
   }
+  process.stderr.write(`${DIM}${covDetail}${NC}
+
+`);
   if (viewUrl) process.stderr.write(`${CYAN}Full report: ${viewUrl}${NC}
 
 `);
@@ -20796,16 +21476,16 @@ function writeBlockMessage(moment, response) {
 }
 
 // src/commands/init.ts
-var import_node_fs34 = require("node:fs");
+var import_node_fs37 = require("node:fs");
 var import_promises13 = require("node:fs/promises");
-var import_node_path26 = require("node:path");
-var import_node_child_process10 = require("node:child_process");
+var import_node_path29 = require("node:path");
+var import_node_child_process11 = require("node:child_process");
 var readline2 = __toESM(require("node:readline/promises"));
 
 // src/commands/migrate.ts
-var import_node_fs33 = require("node:fs");
-var import_node_path25 = require("node:path");
-var import_node_child_process9 = require("node:child_process");
+var import_node_fs36 = require("node:fs");
+var import_node_path28 = require("node:path");
+var import_node_child_process10 = require("node:child_process");
 
 // src/lib/telemetry.ts
 var import_promises12 = require("node:fs/promises");
@@ -20900,11 +21580,11 @@ async function uninstallTelemetry() {
 // src/commands/migrate.ts
 var LEGACY_NPM_PACKAGE = "@codacy/gate-cli";
 function defaultNpmRemover(pkg) {
-  (0, import_node_child_process9.execSync)(`npm rm -g ${pkg}`, { stdio: "pipe", timeout: 12e4 });
+  (0, import_node_child_process10.execSync)(`npm rm -g ${pkg}`, { stdio: "pipe", timeout: 12e4 });
 }
 function isGitTracked(cwd, relPath) {
   try {
-    (0, import_node_child_process9.execSync)(`git ls-files --error-unmatch ${relPath}`, { cwd, stdio: "pipe" });
+    (0, import_node_child_process10.execSync)(`git ls-files --error-unmatch ${relPath}`, { cwd, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -20912,7 +21592,7 @@ function isGitTracked(cwd, relPath) {
 }
 function isGitRepo(cwd) {
   try {
-    (0, import_node_child_process9.execSync)("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
+    (0, import_node_child_process10.execSync)("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -20933,12 +21613,12 @@ async function runMigration(opts = {}) {
   return { actions, migrated: actions.length > 0 };
 }
 function migrateProjectDir(root, actions) {
-  const gateDir = (0, import_node_path25.join)(root, ".gate");
-  const verityDir = (0, import_node_path25.join)(root, ".verity");
-  if ((0, import_node_fs33.existsSync)(gateDir) && !(0, import_node_fs33.existsSync)(verityDir)) {
+  const gateDir = (0, import_node_path28.join)(root, ".gate");
+  const verityDir = (0, import_node_path28.join)(root, ".verity");
+  if ((0, import_node_fs36.existsSync)(gateDir) && !(0, import_node_fs36.existsSync)(verityDir)) {
     return migrateProjectDirRename(root, gateDir, verityDir, actions);
   }
-  if ((0, import_node_fs33.existsSync)(gateDir) && (0, import_node_fs33.existsSync)(verityDir)) {
+  if ((0, import_node_fs36.existsSync)(gateDir) && (0, import_node_fs36.existsSync)(verityDir)) {
     return migrateProjectDirCarry(gateDir, verityDir, actions);
   }
   return false;
@@ -20952,20 +21632,20 @@ function migrateProjectDirRename(root, gateDir, verityDir, actions) {
       );
     }
     try {
-      (0, import_node_child_process9.execSync)("git mv .gate .verity", { cwd: root, stdio: "pipe" });
+      (0, import_node_child_process10.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_fs33.existsSync)(gateDir)) {
+    if ((0, import_node_fs36.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_fs33.rmSync)(gateDir, { recursive: true, force: true });
+        (0, import_node_fs36.rmSync)(gateDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -20981,18 +21661,18 @@ function migrateProjectDirCarry(gateDir, verityDir, actions) {
     actions.push(`Carried ${carried} legacy file(s) from .gate/ into .verity/`);
   }
   try {
-    (0, import_node_fs33.rmSync)(gateDir, { recursive: true, force: true });
+    (0, import_node_fs36.rmSync)(gateDir, { recursive: true, force: true });
   } catch {
   }
   return carried > 0;
 }
 function migrateGlobalCredentials(home, actions) {
   if (!home) return;
-  const gateCreds = (0, import_node_path25.join)(home, ".gate", "credentials");
-  const verityCreds = (0, import_node_path25.join)(home, ".verity", "credentials");
-  if (!(0, import_node_fs33.existsSync)(gateCreds)) return;
-  if (!(0, import_node_fs33.existsSync)(verityCreds)) {
-    (0, import_node_fs33.mkdirSync)((0, import_node_path25.join)(home, ".verity"), { recursive: true });
+  const gateCreds = (0, import_node_path28.join)(home, ".gate", "credentials");
+  const verityCreds = (0, import_node_path28.join)(home, ".verity", "credentials");
+  if (!(0, import_node_fs36.existsSync)(gateCreds)) return;
+  if (!(0, import_node_fs36.existsSync)(verityCreds)) {
+    (0, import_node_fs36.mkdirSync)((0, import_node_path28.join)(home, ".verity"), { recursive: true });
     moveFile(gateCreds, verityCreds);
     actions.push("Moved ~/.gate/credentials \u2192 ~/.verity/credentials");
     return;
@@ -21014,8 +21694,8 @@ async function migrateLegacyHooks(root, actions) {
   }
 }
 async function migrateClaudeMd(root, actions) {
-  const claudeMd = (0, import_node_path25.join)(root, "CLAUDE.md");
-  const hadLegacyBlock = (0, import_node_fs33.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
+  const claudeMd = (0, import_node_path28.join)(root, "CLAUDE.md");
+  const hadLegacyBlock = (0, import_node_fs36.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
   if (!hadLegacyBlock) return;
   try {
     await ensureClaudeMdPointer(root);
@@ -21025,13 +21705,13 @@ async function migrateClaudeMd(root, actions) {
   }
 }
 function migrateStandardFile(root, actions) {
-  const gateMd = (0, import_node_path25.join)(root, "GATE.md");
-  const verityMd = (0, import_node_path25.join)(root, "VERITY.md");
-  if (!(0, import_node_fs33.existsSync)(gateMd) || (0, import_node_fs33.existsSync)(verityMd)) return;
+  const gateMd = (0, import_node_path28.join)(root, "GATE.md");
+  const verityMd = (0, import_node_path28.join)(root, "VERITY.md");
+  if (!(0, import_node_fs36.existsSync)(gateMd) || (0, import_node_fs36.existsSync)(verityMd)) return;
   let moved = false;
   if (isGitRepo(root) && isGitTracked(root, "GATE.md")) {
     try {
-      (0, import_node_child_process9.execSync)("git mv GATE.md VERITY.md", { cwd: root, stdio: "pipe" });
+      (0, import_node_child_process10.execSync)("git mv GATE.md VERITY.md", { cwd: root, stdio: "pipe" });
       moved = true;
     } catch {
     }
@@ -21039,12 +21719,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_fs33.writeFileSync)(verityMd, refreshed);
+  if (refreshed !== content) (0, import_node_fs36.writeFileSync)(verityMd, refreshed);
   actions.push("Renamed GATE.md \u2192 VERITY.md");
 }
 async function migrateTelemetryHeaders(root, actions) {
-  const file = (0, import_node_path25.join)(root, ".claude", "settings.local.json");
-  if (!(0, import_node_fs33.existsSync)(file)) return;
+  const file = (0, import_node_path28.join)(root, ".claude", "settings.local.json");
+  if (!(0, import_node_fs36.existsSync)(file)) return;
   let settings;
   try {
     settings = JSON.parse(readFileSyncSafe(file) || "{}");
@@ -21091,22 +21771,22 @@ function mergeGlobalCredentials(gateCreds, verityCreds) {
     toAppend.push(line.replace(/\r$/, ""));
   }
   if (toAppend.length > 0) {
-    const sep = verityContent.endsWith("\n") || verityContent === "" ? "" : "\n";
-    (0, import_node_fs33.writeFileSync)(verityCreds, verityContent + sep + toAppend.join("\n") + "\n");
+    const sep2 = verityContent.endsWith("\n") || verityContent === "" ? "" : "\n";
+    (0, import_node_fs36.writeFileSync)(verityCreds, verityContent + sep2 + toAppend.join("\n") + "\n");
   }
-  (0, import_node_fs33.rmSync)(gateCreds, { force: true });
+  (0, import_node_fs36.rmSync)(gateCreds, { force: true });
   return toAppend.length;
 }
 function readFileSyncSafe(path) {
   try {
-    return (0, import_node_fs33.readFileSync)(path, "utf-8");
+    return (0, import_node_fs36.readFileSync)(path, "utf-8");
   } catch {
     return "";
   }
 }
 function hasStagedChanges(root) {
   try {
-    (0, import_node_child_process9.execSync)("git diff --cached --quiet", { cwd: root, stdio: "pipe" });
+    (0, import_node_child_process10.execSync)("git diff --cached --quiet", { cwd: root, stdio: "pipe" });
     return false;
   } catch {
     return true;
@@ -21114,35 +21794,35 @@ function hasStagedChanges(root) {
 }
 function moveDir(from, to) {
   try {
-    (0, import_node_fs33.renameSync)(from, to);
+    (0, import_node_fs36.renameSync)(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
-    (0, import_node_fs33.cpSync)(from, to, { recursive: true });
-    (0, import_node_fs33.rmSync)(from, { recursive: true, force: true });
+    (0, import_node_fs36.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs36.rmSync)(from, { recursive: true, force: true });
   }
 }
 function moveFile(from, to) {
   try {
-    (0, import_node_fs33.renameSync)(from, to);
+    (0, import_node_fs36.renameSync)(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
-    (0, import_node_fs33.cpSync)(from, to);
-    (0, import_node_fs33.rmSync)(from, { force: true });
+    (0, import_node_fs36.cpSync)(from, to);
+    (0, import_node_fs36.rmSync)(from, { force: true });
   }
 }
 function carryLegacyContents(gateDir, verityDir) {
   let copied = 0;
   const walk = (relDir) => {
-    const srcDir = (0, import_node_path25.join)(gateDir, relDir);
-    for (const entry of (0, import_node_fs33.readdirSync)(srcDir)) {
-      const rel = relDir ? (0, import_node_path25.join)(relDir, entry) : entry;
-      const src = (0, import_node_path25.join)(gateDir, rel);
-      const dest = (0, import_node_path25.join)(verityDir, rel);
-      if ((0, import_node_fs33.statSync)(src).isDirectory()) {
+    const srcDir = (0, import_node_path28.join)(gateDir, relDir);
+    for (const entry of (0, import_node_fs36.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_fs36.statSync)(src).isDirectory()) {
         walk(rel);
-      } else if (!(0, import_node_fs33.existsSync)(dest)) {
-        (0, import_node_fs33.mkdirSync)((0, import_node_path25.dirname)(dest), { recursive: true });
-        (0, import_node_fs33.cpSync)(src, dest);
+      } else if (!(0, import_node_fs36.existsSync)(dest)) {
+        (0, import_node_fs36.mkdirSync)((0, import_node_path28.dirname)(dest), { recursive: true });
+        (0, import_node_fs36.cpSync)(src, dest);
         copied++;
       }
     }
@@ -21151,22 +21831,22 @@ function carryLegacyContents(gateDir, verityDir) {
   return copied;
 }
 async function needsMigration(root = repoRoot()) {
-  const gateDir = (0, import_node_path25.join)(root, ".gate");
-  const verityDir = (0, import_node_path25.join)(root, ".verity");
-  if ((0, import_node_fs33.existsSync)(gateDir) && !(0, import_node_fs33.existsSync)(verityDir)) return true;
-  if ((0, import_node_fs33.existsSync)(gateDir) && (0, import_node_fs33.existsSync)(verityDir)) {
-    if ((0, import_node_fs33.existsSync)((0, import_node_path25.join)(gateDir, "credentials")) && !(0, import_node_fs33.existsSync)((0, import_node_path25.join)(verityDir, "credentials"))) {
+  const gateDir = (0, import_node_path28.join)(root, ".gate");
+  const verityDir = (0, import_node_path28.join)(root, ".verity");
+  if ((0, import_node_fs36.existsSync)(gateDir) && !(0, import_node_fs36.existsSync)(verityDir)) return true;
+  if ((0, import_node_fs36.existsSync)(gateDir) && (0, import_node_fs36.existsSync)(verityDir)) {
+    if ((0, import_node_fs36.existsSync)((0, import_node_path28.join)(gateDir, "credentials")) && !(0, import_node_fs36.existsSync)((0, import_node_path28.join)(verityDir, "credentials"))) {
       return true;
     }
-    if ((0, import_node_fs33.existsSync)((0, import_node_path25.join)(gateDir, "memory")) && !(0, import_node_fs33.existsSync)((0, import_node_path25.join)(verityDir, "memory"))) {
+    if ((0, import_node_fs36.existsSync)((0, import_node_path28.join)(gateDir, "memory")) && !(0, import_node_fs36.existsSync)((0, import_node_path28.join)(verityDir, "memory"))) {
       return true;
     }
   }
-  const claudeMd = (0, import_node_path25.join)(root, "CLAUDE.md");
-  if ((0, import_node_fs33.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd))) {
+  const claudeMd = (0, import_node_path28.join)(root, "CLAUDE.md");
+  if ((0, import_node_fs36.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd))) {
     return true;
   }
-  if ((0, import_node_fs33.existsSync)((0, import_node_path25.join)(root, "GATE.md")) && !(0, import_node_fs33.existsSync)((0, import_node_path25.join)(root, "VERITY.md"))) {
+  if ((0, import_node_fs36.existsSync)((0, import_node_path28.join)(root, "GATE.md")) && !(0, import_node_fs36.existsSync)((0, import_node_path28.join)(root, "VERITY.md"))) {
     return true;
   }
   if (await hasLegacyHooksAt(root)) return true;
@@ -21248,6 +21928,8 @@ async function confirmExistingLogin(serviceUrl, remote, opts) {
 async function runOptionalAuth(resolution, opts = {}) {
   if (resolution.source === "default") {
     printInfo(`No Verity service configured on this machine \u2014 using the default: ${resolution.url}`);
+  } else {
+    printInfo(`Authenticating against ${resolution.url} (source: ${resolution.source}).`);
   }
   const heal = await maybeHealServiceUrl(resolution, opts.verbose);
   const serviceUrl = heal.serviceUrl;
@@ -21257,7 +21939,7 @@ async function runOptionalAuth(resolution, opts = {}) {
   }
   let remote = "";
   try {
-    remote = (0, import_node_child_process10.execSync)("git remote get-url origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    remote = (0, import_node_child_process11.execSync)("git remote get-url origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
   }
   if (!healed) {
@@ -21300,15 +21982,15 @@ async function runOptionalAuth(resolution, opts = {}) {
 }
 function resolveDataDir() {
   const candidates = [
-    (0, import_node_path26.join)(__dirname, "..", "data"),
+    (0, import_node_path29.join)(__dirname, "..", "data"),
     // installed: node_modules/@codacy/verity-cli/data
-    (0, import_node_path26.join)(__dirname, "..", "..", "data"),
+    (0, import_node_path29.join)(__dirname, "..", "..", "data"),
     // edge case: nested resolution
-    (0, import_node_path26.join)(process.cwd(), "cli", "data")
+    (0, import_node_path29.join)(process.cwd(), "cli", "data")
     // local dev: running from repo root
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs34.existsSync)((0, import_node_path26.join)(candidate, "skills"))) {
+    if ((0, import_node_fs37.existsSync)((0, import_node_path29.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -21324,7 +22006,7 @@ function registerInitCommand(program2) {
   program2.command("init").description("Initialize Verity in the current project").option("--force", "Overwrite existing skills and hooks").action(async (opts) => {
     const force = opts.force ?? false;
     const projectMarkers = [".git", "package.json", "pyproject.toml", "go.mod", "Cargo.toml", "Gemfile", "pom.xml", "build.gradle"];
-    const isProject = projectMarkers.some((m) => (0, import_node_fs34.existsSync)(m));
+    const isProject = projectMarkers.some((m) => (0, import_node_fs37.existsSync)(m));
     if (!isProject) {
       printError("No project detected in the current directory.");
       printInfo('Run "verity init" from your project root.');
@@ -21352,30 +22034,30 @@ function registerInitCommand(program2) {
     }
     printInfo(`  Node.js ${nodeVersion} \u2713`);
     try {
-      const gitVersion = (0, import_node_child_process10.execSync)("git --version", { encoding: "utf-8" }).trim();
+      const gitVersion = (0, import_node_child_process11.execSync)("git --version", { encoding: "utf-8" }).trim();
       printInfo(`  ${gitVersion} \u2713`);
     } catch {
       printError("git is required but not installed. Install from https://git-scm.com");
       process.exit(1);
     }
     try {
-      (0, import_node_child_process10.execSync)("which claude", { encoding: "utf-8" });
+      (0, import_node_child_process11.execSync)("which claude", { encoding: "utf-8" });
       printInfo("  Claude Code \u2713");
     } catch {
       printWarn("  Claude Code not found \u2014 hooks will be configured but need Claude Code to run.");
     }
     try {
-      (0, import_node_child_process10.execSync)("which codacy-analysis", { encoding: "utf-8", stdio: "pipe" });
+      (0, import_node_child_process11.execSync)("which codacy-analysis", { encoding: "utf-8", stdio: "pipe" });
       printInfo("  @codacy/analysis-cli \u2713");
     } catch {
       printInfo("  Installing @codacy/analysis-cli...");
       try {
-        (0, import_node_child_process10.execSync)("npm install -g @codacy/analysis-cli", { encoding: "utf-8", stdio: "pipe", timeout: 12e4 });
+        (0, import_node_child_process11.execSync)("npm install -g @codacy/analysis-cli", { encoding: "utf-8", stdio: "pipe", timeout: 12e4 });
         printInfo("  @codacy/analysis-cli installed \u2713");
       } catch {
         try {
           printWarn("  Retrying with sudo...");
-          (0, import_node_child_process10.execSync)("sudo npm install -g @codacy/analysis-cli", { encoding: "utf-8", stdio: "inherit", timeout: 12e4 });
+          (0, import_node_child_process11.execSync)("sudo npm install -g @codacy/analysis-cli", { encoding: "utf-8", stdio: "inherit", timeout: 12e4 });
           printInfo("  @codacy/analysis-cli installed \u2713");
         } catch {
           printWarn("  Could not install @codacy/analysis-cli automatically.");
@@ -21387,21 +22069,21 @@ function registerInitCommand(program2) {
     console.log("");
     printInfo("Installing skills...");
     const dataDir = resolveDataDir();
-    const skillsSource = (0, import_node_path26.join)(dataDir, "skills");
+    const skillsSource = (0, import_node_path29.join)(dataDir, "skills");
     const skillsDest = ".claude/skills";
     const skills = ["verity-setup", "verity-analyze", "verity-status", "verity-feedback", "verity-learn", "verity-memory", "verity-insights", "verity-reflect"];
     let skillsInstalled = 0;
     for (const skill of skills) {
-      const src = (0, import_node_path26.join)(skillsSource, skill);
-      const dest = (0, import_node_path26.join)(skillsDest, skill);
-      if (!(0, import_node_fs34.existsSync)(src)) {
+      const src = (0, import_node_path29.join)(skillsSource, skill);
+      const dest = (0, import_node_path29.join)(skillsDest, skill);
+      if (!(0, import_node_fs37.existsSync)(src)) {
         printWarn(`  Skill data not found: ${skill}`);
         continue;
       }
-      if ((0, import_node_fs34.existsSync)(dest) && !force) {
-        const srcSkill = (0, import_node_path26.join)(src, "SKILL.md");
-        const destSkill = (0, import_node_path26.join)(dest, "SKILL.md");
-        if ((0, import_node_fs34.existsSync)(destSkill)) {
+      if ((0, import_node_fs37.existsSync)(dest) && !force) {
+        const srcSkill = (0, import_node_path29.join)(src, "SKILL.md");
+        const destSkill = (0, import_node_path29.join)(dest, "SKILL.md");
+        if ((0, import_node_fs37.existsSync)(destSkill)) {
           try {
             const srcContent = await (0, import_promises13.readFile)(srcSkill, "utf-8");
             const destContent = await (0, import_promises13.readFile)(destSkill, "utf-8");
@@ -21432,13 +22114,19 @@ function registerInitCommand(program2) {
     }
     await (0, import_promises13.mkdir)(VERITY_DIR, { recursive: true });
     await ensureMemoryDir();
+    const ignoreResult = ensureSnapshotGitignored();
+    if (ignoreResult === "failed") {
+      printWarn("  .gitignore: could not add .verity/.snapshot/ \u2014 add it manually (it holds copies of analyzed files)");
+    } else {
+      printInfo(`  .gitignore: .verity/.snapshot/ ${ignoreResult === "added" ? "added" : "already covered"} \u2713`);
+    }
     try {
       await ensureClaudeMdPointer();
       printInfo("  CLAUDE.md memory pointer \u2713");
     } catch (err) {
       printWarn(`  Could not update CLAUDE.md: ${err.message}`);
     }
-    const globalVerityDir = (0, import_node_path26.join)(process.env.HOME ?? "", ".verity");
+    const globalVerityDir = (0, import_node_path29.join)(process.env.HOME ?? "", ".verity");
     await (0, import_promises13.mkdir)(globalVerityDir, { recursive: true });
     console.log("");
     try {
@@ -21473,8 +22161,8 @@ function registerInitCommand(program2) {
 }
 
 // src/commands/uninstall.ts
-var import_node_fs35 = require("node:fs");
-var import_node_path27 = require("node:path");
+var import_node_fs38 = require("node:fs");
+var import_node_path30 = require("node:path");
 var SKILL_NAMES = [
   "verity-setup",
   "verity-analyze",
@@ -21493,11 +22181,11 @@ function registerUninstallCommand(program2) {
     const actions = [];
     const skillsRoot = projectPath(".claude/skills");
     for (const name of SKILL_NAMES) {
-      const dir = (0, import_node_path27.join)(skillsRoot, name);
-      if ((0, import_node_fs35.existsSync)(dir)) {
+      const dir = (0, import_node_path30.join)(skillsRoot, name);
+      if ((0, import_node_fs38.existsSync)(dir)) {
         actions.push({
           label: `Remove .claude/skills/${name}/`,
-          apply: () => (0, import_node_fs35.rmSync)(dir, { recursive: true, force: true })
+          apply: () => (0, import_node_fs38.rmSync)(dir, { recursive: true, force: true })
         });
       }
     }
@@ -21511,24 +22199,24 @@ function registerUninstallCommand(program2) {
       });
     }
     const verityDir = projectPath(VERITY_DIR);
-    if ((0, import_node_fs35.existsSync)(verityDir)) {
+    if ((0, import_node_fs38.existsSync)(verityDir)) {
       actions.push({
         label: `Remove ${VERITY_DIR}/`,
-        apply: () => (0, import_node_fs35.rmSync)(verityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs38.rmSync)(verityDir, { recursive: true, force: true })
       });
     }
     if (!keepVerityMd) {
       const verityMd = projectPath(VERITY_MD_FILE);
-      if ((0, import_node_fs35.existsSync)(verityMd)) {
+      if ((0, import_node_fs38.existsSync)(verityMd)) {
         actions.push({
           label: `Remove ${VERITY_MD_FILE}`,
-          apply: () => (0, import_node_fs35.rmSync)(verityMd, { force: true })
+          apply: () => (0, import_node_fs38.rmSync)(verityMd, { force: true })
         });
       }
     }
     const cleanupEmptyDir = (path) => {
-      if ((0, import_node_fs35.existsSync)(path) && (0, import_node_fs35.statSync)(path).isDirectory() && (0, import_node_fs35.readdirSync)(path).length === 0) {
-        (0, import_node_fs35.rmdirSync)(path);
+      if ((0, import_node_fs38.existsSync)(path) && (0, import_node_fs38.statSync)(path).isDirectory() && (0, import_node_fs38.readdirSync)(path).length === 0) {
+        (0, import_node_fs38.rmdirSync)(path);
       }
     };
     actions.push({
@@ -21539,11 +22227,11 @@ function registerUninstallCommand(program2) {
       }
     });
     const home = process.env.HOME ?? "";
-    const globalVerityDir = (0, import_node_path27.join)(home, ".verity");
-    if (purgeGlobal && (0, import_node_fs35.existsSync)(globalVerityDir)) {
+    const globalVerityDir = (0, import_node_path30.join)(home, ".verity");
+    if (purgeGlobal && (0, import_node_fs38.existsSync)(globalVerityDir)) {
       actions.push({
         label: `Remove ~/.verity/ (global credentials \u2014 reconnect requires re-registration)`,
-        apply: () => (0, import_node_fs35.rmSync)(globalVerityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs38.rmSync)(globalVerityDir, { recursive: true, force: true })
       });
     }
     if (actions.length === 0) {
@@ -21737,8 +22425,8 @@ function registerTaskCommands(program2) {
 }
 
 // src/commands/reset.ts
-var import_node_fs36 = require("node:fs");
-var import_node_path28 = require("node:path");
+var import_node_fs39 = 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) => {
     const globals = program2.opts();
@@ -21775,11 +22463,11 @@ function registerResetCommand(program2) {
     }
     const cacheDir = projectPath(CACHE_DIR);
     let purged = 0;
-    if ((0, import_node_fs36.existsSync)(cacheDir)) {
-      for (const entry of (0, import_node_fs36.readdirSync)(cacheDir)) {
+    if ((0, import_node_fs39.existsSync)(cacheDir)) {
+      for (const entry of (0, import_node_fs39.readdirSync)(cacheDir)) {
         if (entry.startsWith("pending-")) {
           try {
-            (0, import_node_fs36.unlinkSync)((0, import_node_path28.join)(cacheDir, entry));
+            (0, import_node_fs39.unlinkSync)((0, import_node_path31.join)(cacheDir, entry));
             purged++;
           } catch {
           }
@@ -21794,19 +22482,19 @@ function registerResetCommand(program2) {
       projectPath(`${VERITY_DIR}/.last-analysis`)
     ];
     for (const file of filesToClear) {
-      if ((0, import_node_fs36.existsSync)(file)) {
+      if ((0, import_node_fs39.existsSync)(file)) {
         try {
-          (0, import_node_fs36.writeFileSync)(file, "");
+          (0, import_node_fs39.writeFileSync)(file, "");
         } catch {
         }
       }
     }
     if (opts.all) {
       const logsDir = projectPath(`${VERITY_DIR}/.logs`);
-      if ((0, import_node_fs36.existsSync)(logsDir)) {
-        for (const entry of (0, import_node_fs36.readdirSync)(logsDir)) {
+      if ((0, import_node_fs39.existsSync)(logsDir)) {
+        for (const entry of (0, import_node_fs39.readdirSync)(logsDir)) {
           try {
-            (0, import_node_fs36.unlinkSync)((0, import_node_path28.join)(logsDir, entry));
+            (0, import_node_fs39.unlinkSync)((0, import_node_path31.join)(logsDir, entry));
           } catch {
           }
         }
@@ -22114,8 +22802,8 @@ function registerTelemetryCommands(program2) {
 }
 
 // src/cli.ts
-program.name("verity").description("CLI for Verity quality gate service").version("0.29.4-experimental.f2e812c").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.29.4-experimental.f2e812c");
+program.name("verity").description("CLI for Verity quality gate service").version("0.30.0-experimental.43e7755").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.30.0-experimental.43e7755");
   setUserNamedServiceUrl(program.opts().serviceUrl);
   try {
     await foldLegacyLocalCredential();