@codacy/verity-cli 0.29.4-experimental.e387745 → 0.29.4-experimental.e818a8a

package/bin/verity.js

@@ -10502,6 +10502,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";
@@ -15060,8 +15061,10 @@ 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);
@@ -15513,6 +15516,33 @@ ${addedLines}`,
   }
   return { diffs, has_snapshots: true };
 }
+function ensureSnapshotGitignored() {
+  let content = "";
+  try {
+    content = (0, import_node_fs15.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_fs15.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) {
@@ -15557,7 +15587,7 @@ function cleanStaleSnapshots(dir, keepSet) {
   try {
     const entries = (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
-      if (entry.name.startsWith(".")) continue;
+      if (dir === SNAPSHOT_DIR && (entry.name === ".diff-old.tmp" || entry.name === ".diff-new.tmp")) continue;
       const fullPath = (0, import_node_path14.join)(dir, entry.name);
       if (entry.isDirectory()) {
         cleanStaleSnapshots(fullPath, keepSet);
@@ -16717,7 +16747,7 @@ function formatRunEvidence(run, startedAt) {
   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)`);
   }
@@ -17146,6 +17176,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 +17218,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 +17326,7 @@ function channelSilence(input) {
 // src/lib/cli-version.ts
 function cliVersion() {
   try {
-    return true ? "0.29.4-experimental.e387745" : "dev";
+    return true ? "0.29.4-experimental.e818a8a" : "dev";
   } catch {
     return "dev";
   }
@@ -17562,9 +17648,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");
@@ -18057,26 +18144,50 @@ function narrowToRecent(files, sessionId) {
   });
   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_fs22.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 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,11 +18197,22 @@ function isSameProblem(previous, current) {
   const prev = new Set(previous.split(","));
   return current.split(",").some((k) => prev.has(k));
 }
-function writeIteration(iteration, commit, _contentHash, fingerprint) {
+function writeBlockState(commit, state) {
   (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}`);
+  (0, import_node_fs22.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
@@ -18282,8 +18404,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,8 +18433,12 @@ 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 {
@@ -18382,6 +18510,10 @@ 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) {
@@ -18394,7 +18526,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] : [];
@@ -18478,6 +18610,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 +18674,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 +18700,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 +18711,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 +18724,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 +18788,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,13 +18810,13 @@ 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 });
 }
@@ -18764,7 +18912,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";
   }
@@ -19334,6 +19483,54 @@ async function workingMemory(run) {
   Object.assign(run, { incrementReport, memory, memorySession, reachability });
 }
 
+// src/lib/note-budget.ts
+var import_node_fs28 = 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_fs28.existsSync)(file)) return null;
+  try {
+    const o = JSON.parse((0, import_node_fs28.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_fs28.mkdirSync)(VERITY_DIR, { recursive: true });
+    (0, import_node_fs28.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;
@@ -19427,7 +19624,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 +19769,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 +19802,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 +19825,14 @@ async function buildRequest(run) {
 }
 
 // src/lib/offline.ts
-var import_node_fs28 = require("node:fs");
+var import_node_fs29 = 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_fs29.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_fs29.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(redactRequest(body)));
   } catch {
   }
 }
@@ -19743,10 +19951,10 @@ async function transmit(run) {
 }
 
 // src/commands/analyze/phases/13-reconcile.ts
-var import_node_fs29 = require("node:fs");
+var import_node_fs30 = require("node:fs");
 var import_node_path23 = 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 +19962,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_fs30.readFileSync)((0, import_node_path23.join)(repoRoot(), file), "utf8").split("\n");
           const at = src[line - 1];
           return at === void 0 ? null : lineSha(at);
         } catch {
@@ -19764,6 +19972,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 +20014,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 +20064,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 +20102,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 +20173,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 +20248,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 +20342,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 +20497,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 +20518,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 +20617,7 @@ async function runAnalyze(opts, globals) {
 }
 
 // src/commands/baseline.ts
-var import_node_fs30 = require("node:fs");
+var import_node_fs31 = 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 +20626,7 @@ function registerBaselineCommands(program2) {
         process.chdir(repoRoot());
       } catch {
       }
-      if (!(0, import_node_fs30.existsSync)(VERITY_DIR)) {
+      if (!(0, import_node_fs31.existsSync)(VERITY_DIR)) {
         process.exit(0);
       }
       let sessionId = opts.sessionId;
@@ -20373,7 +20666,7 @@ async function readStdin() {
 }
 
 // src/commands/review.ts
-var import_node_fs31 = require("node:fs");
+var import_node_fs32 = 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 +20685,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_fs32.existsSync)(f) || resolveFile(f) !== null);
     staticResults = runCodacyAnalysis(scannable);
   } else {
     staticResults = {
@@ -20418,10 +20711,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_fs32.existsSync)(p)) continue;
       try {
-        const { readFileSync: readFileSync18 } = await import("node:fs");
-        const content = readFileSync18(p, "utf-8");
+        const { readFileSync: readFileSync19 } = await import("node:fs");
+        const content = readFileSync19(p, "utf-8");
         specs.push({ path: p, content: content.slice(0, 10240) });
       } catch {
       }
@@ -20478,7 +20771,7 @@ async function runReview(opts, globals) {
 }
 
 // src/commands/guard.ts
-var import_node_fs32 = require("node:fs");
+var import_node_fs33 = require("node:fs");
 var import_node_path24 = require("node:path");
 var GUARD_BLOCK_CAP = 2;
 var GUARD_ITER_FILE = (0, import_node_path24.join)(VERITY_DIR, ".guard-iteration");
@@ -20545,7 +20838,7 @@ function classifyCommand2(command, on) {
 }
 function readIterMap() {
   try {
-    const raw = JSON.parse((0, import_node_fs32.readFileSync)(GUARD_ITER_FILE, "utf-8"));
+    const raw = JSON.parse((0, import_node_fs33.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 +20858,10 @@ function readIter(moment) {
 }
 function writeIter(moment, count) {
   try {
-    (0, import_node_fs32.mkdirSync)(VERITY_DIR, { recursive: true });
+    (0, import_node_fs33.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_fs33.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
   } catch {
   }
 }
@@ -20578,10 +20871,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_fs33.existsSync)(GUARD_ITER_FILE)) (0, import_node_fs33.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_fs33.mkdirSync)(VERITY_DIR, { recursive: true });
+      (0, import_node_fs33.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
     }
   } catch {
   }
@@ -20645,7 +20938,7 @@ function buildGuardRequest(moment, files, iter, sessionId, command) {
   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_fs33.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: [] } };
@@ -20690,7 +20983,7 @@ 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)) {
+  if (cwd && (0, import_node_fs33.existsSync)(cwd)) {
     try {
       process.chdir(cwd);
     } catch {
@@ -20796,14 +21089,14 @@ function writeBlockMessage(moment, response) {
 }
 
 // src/commands/init.ts
-var import_node_fs34 = require("node:fs");
+var import_node_fs35 = 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 readline2 = __toESM(require("node:readline/promises"));
 
 // src/commands/migrate.ts
-var import_node_fs33 = require("node:fs");
+var import_node_fs34 = require("node:fs");
 var import_node_path25 = require("node:path");
 var import_node_child_process9 = require("node:child_process");
 
@@ -20935,10 +21228,10 @@ async function runMigration(opts = {}) {
 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)) {
+  if ((0, import_node_fs34.existsSync)(gateDir) && !(0, import_node_fs34.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_fs34.existsSync)(gateDir) && (0, import_node_fs34.existsSync)(verityDir)) {
     return migrateProjectDirCarry(gateDir, verityDir, actions);
   }
   return false;
@@ -20959,13 +21252,13 @@ function migrateProjectDirRename(root, gateDir, verityDir, actions) {
     }
   }
   if (moved) {
-    if ((0, import_node_fs33.existsSync)(gateDir)) {
+    if ((0, import_node_fs34.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_fs34.rmSync)(gateDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -20981,7 +21274,7 @@ 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_fs34.rmSync)(gateDir, { recursive: true, force: true });
   } catch {
   }
   return carried > 0;
@@ -20990,9 +21283,9 @@ 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 });
+  if (!(0, import_node_fs34.existsSync)(gateCreds)) return;
+  if (!(0, import_node_fs34.existsSync)(verityCreds)) {
+    (0, import_node_fs34.mkdirSync)((0, import_node_path25.join)(home, ".verity"), { recursive: true });
     moveFile(gateCreds, verityCreds);
     actions.push("Moved ~/.gate/credentials \u2192 ~/.verity/credentials");
     return;
@@ -21015,7 +21308,7 @@ 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 hadLegacyBlock = (0, import_node_fs34.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
   if (!hadLegacyBlock) return;
   try {
     await ensureClaudeMdPointer(root);
@@ -21027,7 +21320,7 @@ 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;
+  if (!(0, import_node_fs34.existsSync)(gateMd) || (0, import_node_fs34.existsSync)(verityMd)) return;
   let moved = false;
   if (isGitRepo(root) && isGitTracked(root, "GATE.md")) {
     try {
@@ -21039,12 +21332,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_fs34.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;
+  if (!(0, import_node_fs34.existsSync)(file)) return;
   let settings;
   try {
     settings = JSON.parse(readFileSyncSafe(file) || "{}");
@@ -21092,14 +21385,14 @@ function mergeGlobalCredentials(gateCreds, verityCreds) {
   }
   if (toAppend.length > 0) {
     const sep = verityContent.endsWith("\n") || verityContent === "" ? "" : "\n";
-    (0, import_node_fs33.writeFileSync)(verityCreds, verityContent + sep + toAppend.join("\n") + "\n");
+    (0, import_node_fs34.writeFileSync)(verityCreds, verityContent + sep + toAppend.join("\n") + "\n");
   }
-  (0, import_node_fs33.rmSync)(gateCreds, { force: true });
+  (0, import_node_fs34.rmSync)(gateCreds, { force: true });
   return toAppend.length;
 }
 function readFileSyncSafe(path) {
   try {
-    return (0, import_node_fs33.readFileSync)(path, "utf-8");
+    return (0, import_node_fs34.readFileSync)(path, "utf-8");
   } catch {
     return "";
   }
@@ -21114,35 +21407,35 @@ function hasStagedChanges(root) {
 }
 function moveDir(from, to) {
   try {
-    (0, import_node_fs33.renameSync)(from, to);
+    (0, import_node_fs34.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_fs34.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs34.rmSync)(from, { recursive: true, force: true });
   }
 }
 function moveFile(from, to) {
   try {
-    (0, import_node_fs33.renameSync)(from, to);
+    (0, import_node_fs34.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_fs34.cpSync)(from, to);
+    (0, import_node_fs34.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)) {
+    for (const entry of (0, import_node_fs34.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()) {
+      if ((0, import_node_fs34.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_fs34.existsSync)(dest)) {
+        (0, import_node_fs34.mkdirSync)((0, import_node_path25.dirname)(dest), { recursive: true });
+        (0, import_node_fs34.cpSync)(src, dest);
         copied++;
       }
     }
@@ -21153,20 +21446,20 @@ function carryLegacyContents(gateDir, verityDir) {
 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"))) {
+  if ((0, import_node_fs34.existsSync)(gateDir) && !(0, import_node_fs34.existsSync)(verityDir)) return true;
+  if ((0, import_node_fs34.existsSync)(gateDir) && (0, import_node_fs34.existsSync)(verityDir)) {
+    if ((0, import_node_fs34.existsSync)((0, import_node_path25.join)(gateDir, "credentials")) && !(0, import_node_fs34.existsSync)((0, import_node_path25.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_fs34.existsSync)((0, import_node_path25.join)(gateDir, "memory")) && !(0, import_node_fs34.existsSync)((0, import_node_path25.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))) {
+  if ((0, import_node_fs34.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_fs34.existsSync)((0, import_node_path25.join)(root, "GATE.md")) && !(0, import_node_fs34.existsSync)((0, import_node_path25.join)(root, "VERITY.md"))) {
     return true;
   }
   if (await hasLegacyHooksAt(root)) return true;
@@ -21308,7 +21601,7 @@ function resolveDataDir() {
     // 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_fs35.existsSync)((0, import_node_path26.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -21324,7 +21617,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_fs35.existsSync)(m));
     if (!isProject) {
       printError("No project detected in the current directory.");
       printInfo('Run "verity init" from your project root.');
@@ -21394,14 +21687,14 @@ function registerInitCommand(program2) {
     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)) {
+      if (!(0, import_node_fs35.existsSync)(src)) {
         printWarn(`  Skill data not found: ${skill}`);
         continue;
       }
-      if ((0, import_node_fs34.existsSync)(dest) && !force) {
+      if ((0, import_node_fs35.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_fs35.existsSync)(destSkill)) {
           try {
             const srcContent = await (0, import_promises13.readFile)(srcSkill, "utf-8");
             const destContent = await (0, import_promises13.readFile)(destSkill, "utf-8");
@@ -21432,6 +21725,12 @@ 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");
@@ -21473,7 +21772,7 @@ function registerInitCommand(program2) {
 }
 
 // src/commands/uninstall.ts
-var import_node_fs35 = require("node:fs");
+var import_node_fs36 = require("node:fs");
 var import_node_path27 = require("node:path");
 var SKILL_NAMES = [
   "verity-setup",
@@ -21494,10 +21793,10 @@ function registerUninstallCommand(program2) {
     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)) {
+      if ((0, import_node_fs36.existsSync)(dir)) {
         actions.push({
           label: `Remove .claude/skills/${name}/`,
-          apply: () => (0, import_node_fs35.rmSync)(dir, { recursive: true, force: true })
+          apply: () => (0, import_node_fs36.rmSync)(dir, { recursive: true, force: true })
         });
       }
     }
@@ -21511,24 +21810,24 @@ function registerUninstallCommand(program2) {
       });
     }
     const verityDir = projectPath(VERITY_DIR);
-    if ((0, import_node_fs35.existsSync)(verityDir)) {
+    if ((0, import_node_fs36.existsSync)(verityDir)) {
       actions.push({
         label: `Remove ${VERITY_DIR}/`,
-        apply: () => (0, import_node_fs35.rmSync)(verityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs36.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_fs36.existsSync)(verityMd)) {
         actions.push({
           label: `Remove ${VERITY_MD_FILE}`,
-          apply: () => (0, import_node_fs35.rmSync)(verityMd, { force: true })
+          apply: () => (0, import_node_fs36.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_fs36.existsSync)(path) && (0, import_node_fs36.statSync)(path).isDirectory() && (0, import_node_fs36.readdirSync)(path).length === 0) {
+        (0, import_node_fs36.rmdirSync)(path);
       }
     };
     actions.push({
@@ -21540,10 +21839,10 @@ 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)) {
+    if (purgeGlobal && (0, import_node_fs36.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_fs36.rmSync)(globalVerityDir, { recursive: true, force: true })
       });
     }
     if (actions.length === 0) {
@@ -21737,7 +22036,7 @@ function registerTaskCommands(program2) {
 }
 
 // src/commands/reset.ts
-var import_node_fs36 = require("node:fs");
+var import_node_fs37 = require("node:fs");
 var import_node_path28 = 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) => {
@@ -21775,11 +22074,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_fs37.existsSync)(cacheDir)) {
+      for (const entry of (0, import_node_fs37.readdirSync)(cacheDir)) {
         if (entry.startsWith("pending-")) {
           try {
-            (0, import_node_fs36.unlinkSync)((0, import_node_path28.join)(cacheDir, entry));
+            (0, import_node_fs37.unlinkSync)((0, import_node_path28.join)(cacheDir, entry));
             purged++;
           } catch {
           }
@@ -21794,19 +22093,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_fs37.existsSync)(file)) {
         try {
-          (0, import_node_fs36.writeFileSync)(file, "");
+          (0, import_node_fs37.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_fs37.existsSync)(logsDir)) {
+        for (const entry of (0, import_node_fs37.readdirSync)(logsDir)) {
           try {
-            (0, import_node_fs36.unlinkSync)((0, import_node_path28.join)(logsDir, entry));
+            (0, import_node_fs37.unlinkSync)((0, import_node_path28.join)(logsDir, entry));
           } catch {
           }
         }
@@ -22114,8 +22413,8 @@ function registerTelemetryCommands(program2) {
 }
 
 // src/cli.ts
-program.name("verity").description("CLI for Verity quality gate service").version("0.29.4-experimental.e387745").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.e387745");
+program.name("verity").description("CLI for Verity quality gate service").version("0.29.4-experimental.e818a8a").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.e818a8a");
   setUserNamedServiceUrl(program.opts().serviceUrl);
   try {
     await foldLegacyLocalCredential();

package/data/skills/verity-setup/SKILL.md

@@ -711,18 +711,31 @@ to-be-pushed diff before it lands.
 Add these entries to `.gitignore` (create it if it doesn't exist, append if it does):
 
 ```
-# Verity
-.verity/.cache/
-.verity/.logs/
-.verity/.last-analysis
-.verity/.iteration-count
-.verity/.last-pass-hash
-.verity/.last-intent
-.verity/.memory-sync-state.json
+# Verity — machine-local state. Everything in .verity/ is ignored EXCEPT the
+# shared standard and the knowledge graph, which are meant to be committed.
+.verity/*
+!.verity/standard.yaml
+!.verity/memory/
 .verity/memory/log.md
 .claude/settings.local.json
 ```
 
+This is a whitelist on purpose: `.verity/` accumulates state files over time
+(`.snapshot/` holds byte-for-byte copies of analyzed files — including any
+secret the gate just flagged — plus `.cache/`, `.logs/`, `.baseline`,
+`.task-context`, session-suffixed `.last-analysis.*` files, and whatever comes
+next). Enumerating them one by one is how `.snapshot/` ended up committed in a
+real repo; ignoring everything and re-including the two shared artifacts means
+a future state file can never repeat that.
+
+**If the repo previously committed Verity state** (check with
+`git ls-files .verity`), untrack everything except the shared artifacts once:
+
+```bash
+git rm -r --cached .verity
+git add .verity/standard.yaml .verity/memory
+```
+
 `.claude/settings.local.json` is machine-local Claude Code config (telemetry endpoint + an
 `otelHeadersHelper` reference — no token). `verity telemetry install` adds this entry
 automatically.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codacy/verity-cli",
-  "version": "0.29.4-experimental.e387745",
+  "version": "0.29.4-experimental.e818a8a",
   "description": "CLI for Verity quality gate service",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://verity.md",