@codacy/verity-cli 0.23.2 → 0.24.0-experimental.6a390ac

package/bin/verity.js

@@ -10379,6 +10379,7 @@ var MAX_PLAN_FILES = 3;
 var MAX_PLAN_FILE_BYTES = 10240;
 var MAX_INTENT_CHARS = 2e3;
 var SNAPSHOT_DIR = `${VERITY_DIR}/.snapshot`;
+var BASELINE_DIR = `${VERITY_DIR}/.baseline`;
 var CONVERSATION_BUFFER_FILE = `${VERITY_DIR}/.conversation-buffer`;
 var CONVERSATION_MAX_ENTRIES = 10;
 var CONVERSATION_WINDOW_MINUTES = 15;
@@ -10473,7 +10474,8 @@ var SECURITY_PATTERNS = [
   /Cargo\.lock$/,
   /Dockerfile/
 ];
-var DEFAULT_SERVICE_URL = "https://ofcamwrjwrkazqvdchko.supabase.co/functions/v1";
+var PROD_SERVICE_URL = "https://ofcamwrjwrkazqvdchko.supabase.co/functions/v1";
+var DEFAULT_SERVICE_URL = "https://yykkfdexzljmmkklpgyz.supabase.co/functions/v1".length > 0 ? "https://yykkfdexzljmmkklpgyz.supabase.co/functions/v1" : PROD_SERVICE_URL;
 
 // src/lib/auth.ts
 async function resolveToken(flagToken) {
@@ -10848,6 +10850,10 @@ var VERITY_INTENT_HOOK = {
   type: "command",
   command: "verity intent capture"
 };
+var VERITY_BASELINE_HOOK = {
+  type: "command",
+  command: "verity baseline capture"
+};
 var GUARD_TIMEOUT = 300;
 function buildGuardHook(on) {
   return {
@@ -10860,9 +10866,13 @@ function buildGuardHook(on) {
 var VERITY_STOP_RE = /(?:^|[\/\s"'])verity\s+analyze\b/;
 var VERITY_INTENT_RE = /(?:^|[\/\s"'])verity\s+intent\s+capture\b/;
 var VERITY_GUARD_RE = /(?:^|[\/\s"'])verity\s+guard\b/;
+var VERITY_BASELINE_RE = /(?:^|[\/\s"'])verity\s+baseline\s+capture\b/;
 function isVerityGuardHook(entry) {
   return VERITY_GUARD_RE.test(entry.command ?? "");
 }
+function isVerityBaselineHook(entry) {
+  return VERITY_BASELINE_RE.test(entry.command ?? "");
+}
 var LEGACY_STOP_RE = /(?:^|[\/\s"'])gate\s+analyze\b/;
 var LEGACY_INTENT_RE = /(?:^|[\/\s"'])gate\s+intent\s+capture\b/;
 function isVerityStopHook(entry) {
@@ -10874,7 +10884,7 @@ function isVerityIntentHook(entry) {
   return VERITY_INTENT_RE.test(c) || LEGACY_INTENT_RE.test(c) || c.includes(".verity/hooks/capture-intent.sh") || c.includes(".gate/hooks/capture-intent.sh");
 }
 function isVerityHook(entry) {
-  return isVerityStopHook(entry) || isVerityIntentHook(entry) || isVerityGuardHook(entry);
+  return isVerityStopHook(entry) || isVerityIntentHook(entry) || isVerityGuardHook(entry) || isVerityBaselineHook(entry);
 }
 function isCurrentVerityStopHook(entry) {
   const c = entry.command ?? "";
@@ -10885,7 +10895,7 @@ function isCurrentVerityIntentHook(entry) {
   return VERITY_INTENT_RE.test(c) || c.includes(".verity/hooks/capture-intent.sh");
 }
 function isCurrentVerityHook(entry) {
-  return isCurrentVerityStopHook(entry) || isCurrentVerityIntentHook(entry) || isVerityGuardHook(entry);
+  return isCurrentVerityStopHook(entry) || isCurrentVerityIntentHook(entry) || isVerityGuardHook(entry) || isVerityBaselineHook(entry);
 }
 function settingsHasLegacyHook(settings) {
   for (const groups of Object.values(settings.hooks ?? {})) {
@@ -10927,16 +10937,18 @@ async function readAllSettings() {
 async function checkAllVerityHooks() {
   let stop = false;
   let intent = false;
+  let baseline = false;
   let guard = false;
   let guardOn = [];
   for (const settings of await readAllSettings()) {
     const r = checkVerityHooks(settings);
     stop = stop || r.stop;
     intent = intent || r.intent;
+    baseline = baseline || r.baseline;
     guard = guard || r.guard;
     if (r.guardOn.length > guardOn.length) guardOn = r.guardOn;
   }
-  return { stop, intent, guard, guardOn };
+  return { stop, intent, baseline, guard, guardOn };
 }
 async function checkExternalVerityHooks() {
   let stop = false;
@@ -10959,12 +10971,14 @@ async function checkExternalVerityHooks() {
 async function checkAllVerityHooksDetailed() {
   let stop = false;
   let intent = false;
+  let baseline = false;
   let hasCurrent = false;
   let hasLegacy = false;
   for (const settings of await readAllSettings()) {
     const r = checkVerityHooks(settings);
     stop = stop || r.stop;
     intent = intent || r.intent;
+    baseline = baseline || r.baseline;
     for (const groups of Object.values(settings.hooks ?? {})) {
       for (const g of groups ?? []) {
         for (const h of g.hooks ?? []) {
@@ -10974,7 +10988,7 @@ async function checkAllVerityHooksDetailed() {
       }
     }
   }
-  return { stop, intent, current: hasCurrent, legacyOnly: hasLegacy && !hasCurrent };
+  return { stop, intent, baseline, current: hasCurrent, legacyOnly: hasLegacy && !hasCurrent };
 }
 async function writeSettings(settings) {
   await (0, import_promises4.mkdir)((0, import_node_path3.dirname)(CLAUDE_SETTINGS_FILE), { recursive: true });
@@ -11017,6 +11031,10 @@ function checkVerityHooks(settings) {
   const hasIntent = intentGroups.some(
     (g) => g.hooks?.some((h) => isCurrentVerityIntentHook(h))
   );
+  const sessionStartGroups = hooks["SessionStart"] ?? [];
+  const hasBaseline = sessionStartGroups.some(
+    (g) => g.hooks?.some((h) => isVerityBaselineHook(h))
+  );
   let guard = false;
   let guardOn = [];
   for (const g of hooks["PreToolUse"] ?? []) {
@@ -11029,16 +11047,17 @@ function checkVerityHooks(settings) {
       }
     }
   }
-  return { stop: hasStop, intent: hasIntent, guard, guardOn };
+  return { stop: hasStop, intent: hasIntent, baseline: hasBaseline, guard, guardOn };
 }
-function installVerityHooks(settings, force, externalPresent = { stop: false, intent: false }) {
+function installVerityHooks(settings, force, externalPresent = { stop: false, intent: false, baseline: false }) {
   const local = checkVerityHooks(settings);
   const existing = {
     stop: local.stop || externalPresent.stop,
-    intent: local.intent || externalPresent.intent
+    intent: local.intent || externalPresent.intent,
+    baseline: local.baseline || (externalPresent.baseline ?? false)
   };
   const hasLocalLegacy = settingsHasLegacyHook(settings);
-  if (existing.stop && existing.intent && !force && !hasLocalLegacy) {
+  if (existing.stop && existing.intent && existing.baseline && !force && !hasLocalLegacy) {
     return { ok: false, error: "Verity hooks already installed. Use --force to overwrite." };
   }
   const newSettings = { ...settings };
@@ -11046,7 +11065,7 @@ function installVerityHooks(settings, force, externalPresent = { stop: false, in
     newSettings.hooks = {};
   }
   const shouldStrip = force ? isVerityHook : isLegacyHook;
-  for (const key of ["Stop", "UserPromptSubmit"]) {
+  for (const key of ["Stop", "UserPromptSubmit", "SessionStart"]) {
     const groups = newSettings.hooks[key];
     if (groups) {
       newSettings.hooks[key] = groups.map((g) => ({
@@ -11073,6 +11092,15 @@ function installVerityHooks(settings, force, externalPresent = { stop: false, in
     if (!newSettings.hooks["UserPromptSubmit"]) newSettings.hooks["UserPromptSubmit"] = [];
     newSettings.hooks["UserPromptSubmit"].push({ hooks: [VERITY_INTENT_HOOK] });
   }
+  if (!existing.baseline) {
+    if (!newSettings.hooks["SessionStart"]) {
+      newSettings.hooks["SessionStart"] = [];
+    }
+    newSettings.hooks["SessionStart"].push({ hooks: [VERITY_BASELINE_HOOK] });
+  } else if (force && local.baseline) {
+    if (!newSettings.hooks["SessionStart"]) newSettings.hooks["SessionStart"] = [];
+    newSettings.hooks["SessionStart"].push({ hooks: [VERITY_BASELINE_HOOK] });
+  }
   return { ok: true, data: newSettings };
 }
 function removeVerityHooks(settings) {
@@ -11106,6 +11134,7 @@ function reconcileMomentHooks(settings, moments, externalPresent = {
     (s.hooks[event] ??= []).push(group);
   };
   if (!externalPresent.intent) push("UserPromptSubmit", { hooks: [VERITY_INTENT_HOOK] });
+  push("SessionStart", { hooks: [VERITY_BASELINE_HOOK] });
   if (moments.includes("stop") && !externalPresent.stop) {
     push("Stop", { hooks: [VERITY_STOP_HOOK] });
   }
@@ -11154,7 +11183,7 @@ function registerHooksCommands(program2) {
       return;
     }
     const detail = await checkAllVerityHooksDetailed();
-    const present = { stop: detail.stop, intent: detail.intent };
+    const present = { stop: detail.stop, intent: detail.intent, baseline: detail.baseline };
     if (detail.legacyOnly) {
       printInfo("Found a legacy GATE.md hook \u2014 upgrading it to Verity...");
       const settings2 = removeVerityHooks(await readSettings());
@@ -11167,11 +11196,12 @@ function registerHooksCommands(program2) {
       printInfo("Verity hooks installed in .claude/settings.json (legacy hook removed)");
       printInfo("  Stop hook: verity analyze");
       printInfo("  UserPromptSubmit hook: verity intent capture");
+      printInfo("  SessionStart hook: verity baseline capture");
       return;
     }
     const settings = await readSettings();
     const hasLocalLegacy = settingsHasLegacyHook(settings);
-    if (!force && present.stop && present.intent && !hasLocalLegacy) {
+    if (!force && present.stop && present.intent && present.baseline && !hasLocalLegacy) {
       printInfo("Verity hooks already installed (found in .claude/settings.json, settings.local.json, or your global settings).");
       printInfo("Use --force to rewrite the project settings.json copy.");
       return;
@@ -11185,11 +11215,13 @@ function registerHooksCommands(program2) {
     printInfo("Verity hooks installed in .claude/settings.json");
     printInfo("  Stop hook: verity analyze");
     printInfo("  UserPromptSubmit hook: verity intent capture");
+    printInfo("  SessionStart hook: verity baseline capture");
   });
   hooks.command("check").description("Check if Verity hooks are installed").action(async () => {
     const status = await checkAllVerityHooks();
     printInfo(`Stop hook (verity analyze): ${status.stop ? "installed" : "not installed"}`);
     printInfo(`Intent hook (verity intent capture): ${status.intent ? "installed" : "not installed"}`);
+    printInfo(`Baseline hook (verity baseline capture): ${status.baseline ? "installed" : "not installed"}`);
     const gates = status.guard ? status.guardOn.join(", ") : "none";
     printInfo(`Git-moment gate (verity guard): ${status.guard ? `installed [${gates}]` : "not installed"}`);
     if (!status.stop && !status.guard) {
@@ -11242,15 +11274,28 @@ async function appendToConversationBuffer(prompt, sessionId) {
   } catch {
   }
 }
-async function readAndClearConversationBuffer() {
+async function readAndClearConversationBuffer(currentSessionId) {
   try {
     if ((0, import_node_fs2.existsSync)(CONVERSATION_BUFFER_FILE)) {
       const entries = await readBufferEntries();
-      await (0, import_promises5.unlink)(CONVERSATION_BUFFER_FILE).catch(() => {
-      });
-      if (entries.length > 0) {
+      let mine = entries;
+      let others = [];
+      if (currentSessionId) {
+        mine = entries.filter((e) => e.session_id === currentSessionId || !e.session_id);
+        others = entries.filter((e) => e.session_id && e.session_id !== currentSessionId);
+      }
+      if (others.length > 0) {
+        const remaining = others.map((e) => JSON.stringify(e)).join("\n") + "\n";
+        const tmpFile = `${CONVERSATION_BUFFER_FILE}.tmp`;
+        await (0, import_promises5.writeFile)(tmpFile, remaining);
+        await (0, import_promises5.rename)(tmpFile, CONVERSATION_BUFFER_FILE);
+      } else {
+        await (0, import_promises5.unlink)(CONVERSATION_BUFFER_FILE).catch(() => {
+        });
+      }
+      if (mine.length > 0) {
         return {
-          prompts: entries,
+          prompts: mine,
           recent_commits: getRecentCommitMessages()
         };
       }
@@ -12718,8 +12763,8 @@ async function sendGeneralFeedback(message, opts, globals) {
 }
 
 // src/commands/analyze.ts
-var import_node_fs18 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_fs19 = require("node:fs");
+var import_node_path14 = require("node:path");
 
 // src/lib/git.ts
 var import_node_child_process5 = require("node:child_process");
@@ -12811,6 +12856,26 @@ function getChangedFiles() {
 function getStagedFiles() {
   return splitLines(execGit("git diff --cached --name-only")).filter((f) => !f.startsWith(".verity/") && !f.startsWith(".verity\\"));
 }
+function getDirtyFiles() {
+  const set = /* @__PURE__ */ new Set();
+  for (const f of splitLines(execGit("git diff --name-only HEAD"))) set.add(f);
+  for (const f of splitLines(execGit("git diff --name-only --cached"))) set.add(f);
+  for (const f of splitLines(execGit("git ls-files --others --exclude-standard"))) set.add(f);
+  return Array.from(set).filter((f) => !f.startsWith(".verity/") && !f.startsWith(".verity\\"));
+}
+function showContentAtRef(ref, repoRelPath) {
+  if (!ref || ref === "no-git") return null;
+  const normalizedPath = repoRelPath.replace(/\\/g, "/");
+  try {
+    return (0, import_node_child_process5.execFileSync)("git", ["show", `${ref}:${normalizedPath}`], {
+      encoding: "utf-8",
+      maxBuffer: 64 * 1024 * 1024,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    return null;
+  }
+}
 function getPushRangeFiles() {
   const diff = (range) => splitLines(execGit(`git diff --name-only ${range}`)).filter((f) => !f.startsWith(".verity/") && !f.startsWith(".verity\\"));
   const resolvers = [
@@ -12833,6 +12898,11 @@ function getPushRangeFiles() {
   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 getWorktreeFiles() {
   const result = [];
   const worktreeDir = ".claude/worktrees";
@@ -13458,15 +13528,207 @@ function cleanStaleSnapshots(dir, keepSet) {
   }
 }
 
-// src/lib/offline.ts
+// src/lib/baseline.ts
 var import_node_fs13 = require("node:fs");
+var import_node_path11 = require("node:path");
 var import_node_crypto4 = require("node:crypto");
+var BASELINE_VERSION = 1;
+var BASELINE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var MIRROR_MAX_BYTES = 2 * 1024 * 1024;
+var DEFAULT_SESSION_KEY = "_default";
+function sessionKey(sessionId) {
+  if (!sessionId) return DEFAULT_SESSION_KEY;
+  return (0, import_node_crypto4.createHash)("sha256").update(sessionId).digest("hex").slice(0, 16);
+}
+function sessionDir(key) {
+  return (0, import_node_path11.join)(projectPath(BASELINE_DIR), key);
+}
+function manifestPath(dir) {
+  return (0, import_node_path11.join)(dir, "manifest.json");
+}
+function mirrorPath(dir, repoRelPath) {
+  return (0, import_node_path11.join)(dir, "files", repoRelPath);
+}
+function captureBaseline(opts = {}) {
+  const key = sessionKey(opts.sessionId);
+  const dir = sessionDir(key);
+  const existing = readManifest(dir);
+  const freshStart = opts.source === "startup" || opts.source === "clear";
+  if (existing && !freshStart) {
+    return { baseline: existing, created: false };
+  }
+  const head_sha = getCurrentCommit();
+  const dirty = getDirtyFiles();
+  try {
+    (0, import_node_fs13.rmSync)(dir, { recursive: true, force: true });
+  } catch {
+  }
+  const filesDir = (0, import_node_path11.join)(dir, "files");
+  const mirrored = [];
+  try {
+    (0, import_node_fs13.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_fs13.mkdirSync)((0, import_node_path11.dirname)(dest), { recursive: true });
+        (0, import_node_fs13.writeFileSync)(dest, content);
+        mirrored.push(p);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const baseline = {
+    session_id: opts.sessionId ?? "",
+    head_sha,
+    captured_at: Date.now(),
+    dirty_paths: mirrored,
+    version: BASELINE_VERSION
+  };
+  try {
+    (0, import_node_fs13.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs13.writeFileSync)(manifestPath(dir), JSON.stringify(baseline));
+  } catch {
+  }
+  pruneOldBaselines();
+  return { baseline, created: true };
+}
+function readBaseline(sessionId) {
+  return readManifest(sessionDir(sessionKey(sessionId)));
+}
+function readManifest(dir) {
+  const mp = manifestPath(dir);
+  if (!(0, import_node_fs13.existsSync)(mp)) return null;
+  try {
+    const parsed = JSON.parse((0, import_node_fs13.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;
+    }
+    return {
+      session_id: typeof parsed.session_id === "string" ? parsed.session_id : "",
+      head_sha: parsed.head_sha,
+      captured_at: parsed.captured_at,
+      dirty_paths: parsed.dirty_paths.filter((p) => typeof p === "string"),
+      version: parsed.version
+    };
+  } catch {
+    return null;
+  }
+}
+var preImageCache = /* @__PURE__ */ new WeakMap();
+function preImage(repoRelPath, baseline) {
+  let perBaseline = preImageCache.get(baseline);
+  if (!perBaseline) {
+    perBaseline = /* @__PURE__ */ new Map();
+    preImageCache.set(baseline, perBaseline);
+  }
+  const cached = perBaseline.get(repoRelPath);
+  if (cached) return cached;
+  const resolved = resolvePreImage(repoRelPath, baseline);
+  perBaseline.set(repoRelPath, resolved);
+  return resolved;
+}
+function resolvePreImage(repoRelPath, baseline) {
+  if (baseline.dirty_paths.includes(repoRelPath)) {
+    const mp = mirrorPath(sessionDir(sessionKey(baseline.session_id)), repoRelPath);
+    if ((0, import_node_fs13.existsSync)(mp)) {
+      try {
+        return { content: (0, import_node_fs13.readFileSync)(mp, "utf-8"), existed: true };
+      } catch {
+      }
+    }
+  }
+  const atHead = showContentAtRef(baseline.head_sha, repoRelPath);
+  if (atHead !== null) return { content: atHead, existed: true };
+  return { content: "", existed: false };
+}
+function generateBaselineDiffs(files, baseline) {
+  if (!baseline) return { diffs: [], has_baseline: false };
+  const diffs = [];
+  for (const file of files) {
+    const language = file.language ?? detectLanguage(file.path);
+    const pre = preImage(file.path, baseline);
+    if (pre.existed) {
+      if (pre.content === file.content) continue;
+      const diff = computeDiff(pre.content, file.content, file.path);
+      if (diff) diffs.push({ path: file.path, language, diff, status: "modified" });
+    } else {
+      const addedLines = file.content.split("\n").map((l) => `+${l}`).join("\n");
+      diffs.push({
+        path: file.path,
+        language,
+        diff: `--- /dev/null
++++ b/${file.path}
+@@ -0,0 +1,${file.content.split("\n").length} @@
+${addedLines}`,
+        status: "added"
+      });
+    }
+  }
+  return { diffs, has_baseline: true };
+}
+function changedSinceBaseline(repoRelPath, baseline) {
+  const pre = preImage(repoRelPath, baseline);
+  let current;
+  try {
+    current = (0, import_node_fs13.readFileSync)(projectPath(repoRelPath), "utf-8");
+  } catch {
+    return pre.existed;
+  }
+  if (!pre.existed) return true;
+  return current !== pre.content;
+}
+function safeReadForMirror(absPath) {
+  try {
+    if ((0, import_node_fs13.statSync)(absPath).size > MIRROR_MAX_BYTES) return null;
+    const buf = (0, import_node_fs13.readFileSync)(absPath);
+    if (buf.includes(0)) return null;
+    return buf.toString("utf-8");
+  } catch {
+    return null;
+  }
+}
+function pruneOldBaselines() {
+  const root = projectPath(BASELINE_DIR);
+  let entries;
+  try {
+    entries = (0, import_node_fs13.readdirSync)(root);
+  } catch {
+    return;
+  }
+  const now = Date.now();
+  for (const name of entries) {
+    const dir = (0, import_node_path11.join)(root, name);
+    const manifest = readManifest(dir);
+    if (!manifest) {
+      try {
+        if (now - (0, import_node_fs13.statSync)(dir).mtimeMs > BASELINE_TTL_MS) {
+          (0, import_node_fs13.rmSync)(dir, { recursive: true, force: true });
+        }
+      } catch {
+      }
+      continue;
+    }
+    if (now - manifest.captured_at <= BASELINE_TTL_MS) continue;
+    try {
+      (0, import_node_fs13.rmSync)(dir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
+// src/lib/offline.ts
+var import_node_fs14 = require("node:fs");
+var import_node_crypto5 = require("node:crypto");
 function cacheRequest(body) {
   try {
-    (0, import_node_fs13.mkdirSync)(CACHE_DIR, { recursive: true });
-    const suffix = (0, import_node_crypto4.randomBytes)(4).toString("hex");
+    (0, import_node_fs14.mkdirSync)(CACHE_DIR, { recursive: true });
+    const suffix = (0, import_node_crypto5.randomBytes)(4).toString("hex");
     const filename = `pending-${Math.floor(Date.now() / 1e3)}-${suffix}.json`;
-    (0, import_node_fs13.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(body));
+    (0, import_node_fs14.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(body));
   } catch {
   }
 }
@@ -13480,7 +13742,7 @@ function buildOfflineFallback(reason, staticResults) {
 }
 
 // src/lib/context-files.ts
-var import_node_fs14 = require("node:fs");
+var import_node_fs15 = require("node:fs");
 var MAX_CONTEXT_FILES = 10;
 var MAX_CONTEXT_FILE_BYTES = 10240;
 var MAX_CONTEXT_TOTAL_BYTES = 51200;
@@ -13492,7 +13754,7 @@ function gatherContextFiles(contextPaths, deltaFiles) {
     if (result.length >= MAX_CONTEXT_FILES) break;
     if (deltaPaths.has(filePath)) continue;
     try {
-      const content = (0, import_node_fs14.readFileSync)(filePath, "utf8");
+      const content = (0, import_node_fs15.readFileSync)(filePath, "utf8");
       const bytes = Buffer.byteLength(content);
       if (bytes > MAX_CONTEXT_FILE_BYTES) {
         logEvent("context_file_skipped", { path: filePath, reason: "too_large", bytes });
@@ -13537,20 +13799,20 @@ function gatherContextFiles(contextPaths, deltaFiles) {
 }
 
 // src/lib/cache-cleanup.ts
-var import_node_fs15 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_fs16 = require("node:fs");
+var import_node_path12 = 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_fs15.readdirSync)(dir)) {
+    for (const entry of (0, import_node_fs16.readdirSync)(dir)) {
       if (!entry.startsWith("pending-")) continue;
-      const path = (0, import_node_path11.join)(dir, entry);
+      const path = (0, import_node_path12.join)(dir, entry);
       try {
-        const stat3 = (0, import_node_fs15.statSync)(path);
+        const stat3 = (0, import_node_fs16.statSync)(path);
         if (stat3.mtimeMs < cutoff) {
-          (0, import_node_fs15.unlinkSync)(path);
+          (0, import_node_fs16.unlinkSync)(path);
           logEvent("cache_entry_pruned", {
             path: entry,
             age_days: Math.round((Date.now() - stat3.mtimeMs) / 864e5)
@@ -13622,10 +13884,11 @@ function reconcileAnalysisMode(predictedMode, signals) {
       signals.noFilesChanged,
       signals.assistantResponse,
       signals.conversationPrompts,
-      signals.actionSummary
+      signals.actionSummary,
+      signals.sessionAuthoredCode
     );
   }
-  const agentAuthoredCode = !!(signals.actionSummary && (signals.actionSummary.files_edited.length > 0 || signals.actionSummary.files_created.length > 0));
+  const agentAuthoredCode = !!(signals.actionSummary && (signals.actionSummary.files_edited.length > 0 || signals.actionSummary.files_created.length > 0)) || !!signals.sessionAuthoredCode;
   const agentInvestigated = didAgentInvestigate(signals.actionSummary);
   switch (predictedMode) {
     case "skip":
@@ -13650,8 +13913,8 @@ function didAgentInvestigate(summary) {
 function isValidMode(mode) {
   return mode === "standard" || mode === "plan" || mode === "debug" || mode === "skip";
 }
-function detectAnalysisMode(noFilesChanged, assistantResponse, conversationPrompts, actionSummary) {
-  const agentAuthoredCode = !!(actionSummary && (actionSummary.files_edited.length > 0 || actionSummary.files_created.length > 0));
+function detectAnalysisMode(noFilesChanged, assistantResponse, conversationPrompts, actionSummary, sessionAuthoredCode) {
+  const agentAuthoredCode = !!(actionSummary && (actionSummary.files_edited.length > 0 || actionSummary.files_created.length > 0)) || !!sessionAuthoredCode;
   if (conversationPrompts.length > 0 && conversationPrompts.every(isGitOnlyPrompt)) {
     if (!agentAuthoredCode) return "skip";
   }
@@ -13705,7 +13968,12 @@ function isReflectionQuestion(response) {
     /reflection\s+for\s+future\s+agents/i,
     /what(?:'s|\s+is)\s+one\s+thing\s+you\s+learned/i,
     /say\s+['"]?skip['"]?\s+to\s+skip/i,
-    /quick\s+reflection\s+question/i
+    /quick\s+reflection\s+question/i,
+    // Post-flip (VRT-21): the agent drafts the reflection itself and, when
+    // interactive, asks the user to confirm/correct before recording. That
+    // turn authors no code either, so it's still a reflection turn.
+    /reflection\s+draft/i,
+    /confirm,?\s+correct,?\s+or\s+add/i
   ];
   return markers.some((m) => m.test(response));
 }
@@ -13726,7 +13994,7 @@ function isMetaTaskLabel(label2) {
 }
 
 // src/lib/transcript.ts
-var import_node_fs16 = require("node:fs");
+var import_node_fs17 = require("node:fs");
 var MAX_READ_BYTES = 256 * 1024;
 var SMALL_FILE_BYTES = 64 * 1024;
 var MAX_FILES_LIST = 20;
@@ -13748,14 +14016,14 @@ async function extractActionSummary(transcriptPath) {
 function readTurnLines(transcriptPath) {
   let size;
   try {
-    size = (0, import_node_fs16.statSync)(transcriptPath).size;
+    size = (0, import_node_fs17.statSync)(transcriptPath).size;
   } catch {
     return null;
   }
   if (size === 0) return null;
   let raw;
   if (size <= SMALL_FILE_BYTES) {
-    raw = (0, import_node_fs16.readFileSync)(transcriptPath, "utf-8");
+    raw = (0, import_node_fs17.readFileSync)(transcriptPath, "utf-8");
   } else {
     const buf = Buffer.alloc(Math.min(MAX_READ_BYTES, size));
     const fd = require("node:fs").openSync(transcriptPath, "r");
@@ -13843,6 +14111,12 @@ function buildSummary(lines) {
         case "Edit":
           addPath(filesEdited, input.file_path);
           break;
+        case "MultiEdit":
+          addPath(filesEdited, input.file_path);
+          break;
+        case "NotebookEdit":
+          addPath(filesEdited, input.notebook_path ?? input.file_path);
+          break;
         case "Write":
           addPath(filesCreated, input.file_path);
           addPath(filesEdited, input.file_path);
@@ -13926,8 +14200,8 @@ function capArray(set, max) {
 
 // src/lib/seed-runner.ts
 var import_promises11 = require("node:fs/promises");
-var import_node_fs17 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_fs18 = require("node:fs");
+var import_node_path13 = require("node:path");
 var import_yaml2 = __toESM(require_dist());
 
 // src/lib/seed.ts
@@ -14166,7 +14440,7 @@ function renderNodeMarkdown(candidate, nodeId, createdAt) {
   return fm;
 }
 async function runSeed(opts) {
-  if (!(0, import_node_fs17.existsSync)(STANDARD_FILE)) {
+  if (!(0, import_node_fs18.existsSync)(STANDARD_FILE)) {
     return { created: 0, failed: 0, skipped: "no_standard", candidates: [] };
   }
   let standardDoc;
@@ -14178,7 +14452,7 @@ async function runSeed(opts) {
   }
   const knowledgeSpec = standardDoc.knowledge_spec ?? {};
   let readmeContent;
-  if ((0, import_node_fs17.existsSync)("README.md")) {
+  if ((0, import_node_fs18.existsSync)("README.md")) {
     try {
       readmeContent = await (0, import_promises11.readFile)("README.md", "utf-8");
     } catch {
@@ -14186,7 +14460,7 @@ async function runSeed(opts) {
   }
   let claudeMdContent;
   for (const p of ["CLAUDE.md", ".claude/CLAUDE.md"]) {
-    if ((0, import_node_fs17.existsSync)(p)) {
+    if ((0, import_node_fs18.existsSync)(p)) {
       try {
         claudeMdContent = await (0, import_promises11.readFile)(p, "utf-8");
         break;
@@ -14209,8 +14483,8 @@ async function runSeed(opts) {
   if (candidates.length === 0) {
     return { created: 0, failed: 0, skipped: "no_candidates", candidates: [] };
   }
-  const overviewPath = (0, import_node_path12.join)(MEMORY_DIR, "domain", "project-overview.md");
-  if ((0, import_node_fs17.existsSync)(overviewPath) && !opts.force) {
+  const overviewPath = (0, import_node_path13.join)(MEMORY_DIR, "domain", "project-overview.md");
+  if ((0, import_node_fs18.existsSync)(overviewPath) && !opts.force) {
     return { created: 0, failed: 0, skipped: "already_seeded", candidates };
   }
   if (opts.dryRun) {
@@ -14245,9 +14519,9 @@ async function runSeed(opts) {
     }
     const nodeId = res.data.node_id;
     const filePathRel = res.data.file_path;
-    const targetPath = (0, import_node_path12.join)(MEMORY_DIR, filePathRel);
+    const targetPath = (0, import_node_path13.join)(MEMORY_DIR, filePathRel);
     try {
-      await (0, import_promises11.mkdir)((0, import_node_path12.dirname)(targetPath), { recursive: true });
+      await (0, import_promises11.mkdir)((0, import_node_path13.dirname)(targetPath), { recursive: true });
       await (0, import_promises11.writeFile)(targetPath, renderNodeMarkdown(c, nodeId, createdAt));
       created++;
       opts.onCreated?.(nodeId, filePathRel, c);
@@ -14317,6 +14591,15 @@ async function runAnalyze(opts, globals) {
   }
   const { assistantMessage: assistantResponse, stopReason, transcriptPath, sessionId } = await readStopHookStdin();
   const actionSummary = transcriptPath ? await extractActionSummary(transcriptPath) : null;
+  const baselineSessionId = sessionId || process.env.CLAUDE_SESSION_ID || void 0;
+  const baseline = readBaseline(baselineSessionId);
+  if (baseline) {
+    logEvent("baseline_loaded", {
+      head: baseline.head_sha.slice(0, 12),
+      dirty_count: baseline.dirty_paths.length,
+      age_ms: Date.now() - baseline.captured_at
+    });
+  }
   const { files: allChanged, hasRecentCommitFiles } = getChangedFiles();
   const analyzable = filterAnalyzable(allChanged);
   const reviewable = filterReviewable(allChanged);
@@ -14326,7 +14609,7 @@ async function runAnalyze(opts, globals) {
     passAndExit("No analyzable files changed");
   }
   const allForReview = Array.from(/* @__PURE__ */ new Set([...analyzable, ...reviewable]));
-  const conversation = await readAndClearConversationBuffer();
+  const conversation = await readAndClearConversationBuffer(sessionId ?? void 0);
   const specs = discoverSpecs();
   const plans = discoverPlans();
   const latestPrompt = conversation?.prompts?.[conversation.prompts.length - 1]?.prompt ?? "";
@@ -14376,13 +14659,14 @@ async function runAnalyze(opts, globals) {
   }
   const conversationPrompts = (conversation?.prompts ?? []).map((p) => p.prompt);
   let analysisMode;
+  const sessionAuthoredCode = !!baseline && allForReview.some((f) => changedSinceBaseline(f, baseline));
   const modeOverride = opts.mode;
   if (modeOverride && ["standard", "plan", "debug", "skip"].includes(modeOverride)) {
     analysisMode = modeOverride;
   } else {
     analysisMode = reconcileAnalysisMode(
       predictedMode,
-      { noFilesChanged, assistantResponse, actionSummary, conversationPrompts }
+      { noFilesChanged, assistantResponse, actionSummary, conversationPrompts, sessionAuthoredCode }
     );
   }
   if (analysisMode === "skip") {
@@ -14440,10 +14724,16 @@ async function runAnalyze(opts, globals) {
         const baseForReview = agentNarrowed.length > 0 ? agentNarrowed : allForReview;
         const recentForReview = narrowToRecent(baseForReview);
         if (!opts.skipStatic && isCodacyAvailable()) {
-          const allScannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles]));
-          staticResults = runCodacyAnalysis(allScannable);
+          let allScannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles]));
+          if (baseline) {
+            allScannable = allScannable.filter((f) => changedSinceBaseline(f, baseline));
+          }
+          if (allScannable.length > 0) {
+            staticResults = runCodacyAnalysis(allScannable);
+          }
         }
-        codeDelta = collectCodeDelta(recentForReview, {
+        const deltaSet = baseline ? recentForReview.filter((f) => changedSinceBaseline(f, baseline)) : recentForReview;
+        codeDelta = collectCodeDelta(deltaSet, {
           maxFiles: parseInt(opts.maxFiles, 10),
           maxFileBytes: parseInt(opts.maxFileSize, 10),
           maxTotalBytes: parseInt(opts.maxTotalSize, 10)
@@ -14458,7 +14748,12 @@ async function runAnalyze(opts, globals) {
       }
     }
     if (analysisMode !== "plan") {
-      snapshotResult = generateSnapshotDiffs(codeDelta.files);
+      if (baseline) {
+        const baselineDiffs = generateBaselineDiffs(codeDelta.files, baseline);
+        snapshotResult = { has_snapshots: baselineDiffs.diffs.length > 0, diffs: baselineDiffs.diffs };
+      } else {
+        snapshotResult = generateSnapshotDiffs(codeDelta.files);
+      }
       currentCommit = getCurrentCommit();
       const maxIterations = parseInt(opts.maxIterations, 10);
       const iterResult = checkMaxIterations(currentCommit, maxIterations, contentHash ?? void 0);
@@ -14490,9 +14785,9 @@ async function runAnalyze(opts, globals) {
   let autoSeedNotice = null;
   try {
     await ensureMemoryDir();
-    const seedMarker = (0, import_node_path13.join)(VERITY_DIR, ".seeded");
-    const hasStandard = (0, import_node_fs18.existsSync)(STANDARD_FILE);
-    const alreadyTried = (0, import_node_fs18.existsSync)(seedMarker);
+    const seedMarker = (0, import_node_path14.join)(VERITY_DIR, ".seeded");
+    const hasStandard = (0, import_node_fs19.existsSync)(STANDARD_FILE);
+    const alreadyTried = (0, import_node_fs19.existsSync)(seedMarker);
     if (hasStandard && !alreadyTried) {
       const preManifest = await buildManifest();
       if (preManifest.nodes.length === 0) {
@@ -14505,7 +14800,7 @@ async function runAnalyze(opts, globals) {
             dryRun: false
           });
           if (seedResult.created > 0) {
-            (0, import_node_fs18.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} created=${seedResult.created}
+            (0, import_node_fs19.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", {
@@ -14513,7 +14808,7 @@ async function runAnalyze(opts, globals) {
               failed: seedResult.failed
             });
           } else if (seedResult.skipped === "already_seeded") {
-            (0, import_node_fs18.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} skipped=already_seeded
+            (0, import_node_fs19.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} skipped=already_seeded
 `);
           } else {
             logEvent("auto_seed_noop", {
@@ -14831,8 +15126,54 @@ async function runAnalyze(opts, globals) {
   }
 }
 
+// src/commands/baseline.ts
+var import_node_fs20 = 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) => {
+    try {
+      try {
+        process.chdir(repoRoot());
+      } catch {
+      }
+      if (!(0, import_node_fs20.existsSync)(VERITY_DIR)) {
+        process.exit(0);
+      }
+      let sessionId = opts.sessionId;
+      let source = opts.source;
+      if (!process.stdin.isTTY) {
+        const input = (await readStdin()).trim();
+        if (input) {
+          try {
+            const event = JSON.parse(input);
+            sessionId = sessionId ?? event.session_id;
+            source = source ?? event.source;
+          } catch {
+          }
+        }
+      }
+      const result = captureBaseline({ sessionId, source });
+      logEvent("baseline_capture", {
+        created: result.created,
+        source: source ?? null,
+        dirty_count: result.baseline.dirty_paths.length,
+        head: result.baseline.head_sha.slice(0, 12)
+      });
+    } catch {
+    }
+    process.exit(0);
+  });
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
 // src/commands/review.ts
-var import_node_fs19 = require("node:fs");
+var import_node_fs21 = 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();
@@ -14851,7 +15192,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_fs19.existsSync)(f) || resolveFile(f) !== null);
+    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).filter((f) => (0, import_node_fs21.existsSync)(f) || resolveFile(f) !== null);
     staticResults = runCodacyAnalysis(scannable);
   } else {
     staticResults = {
@@ -14876,10 +15217,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_fs19.existsSync)(p)) continue;
+      if (!(0, import_node_fs21.existsSync)(p)) continue;
       try {
-        const { readFileSync: readFileSync11 } = await import("node:fs");
-        const content = readFileSync11(p, "utf-8");
+        const { readFileSync: readFileSync12 } = await import("node:fs");
+        const content = readFileSync12(p, "utf-8");
         specs.push({ path: p, content: content.slice(0, 10240) });
       } catch {
       }
@@ -14936,10 +15277,10 @@ async function runReview(opts, globals) {
 }
 
 // src/commands/guard.ts
-var import_node_fs20 = require("node:fs");
-var import_node_path14 = require("node:path");
+var import_node_fs22 = require("node:fs");
+var import_node_path15 = require("node:path");
 var GUARD_BLOCK_CAP = 2;
-var GUARD_ITER_FILE = (0, import_node_path14.join)(VERITY_DIR, ".guard-iteration");
+var GUARD_ITER_FILE = (0, import_node_path15.join)(VERITY_DIR, ".guard-iteration");
 function readPreToolUseStdin() {
   const empty = { command: "", cwd: null, sessionId: null };
   return new Promise((resolve) => {
@@ -15003,7 +15344,7 @@ function classifyCommand(command, on) {
 }
 function readIterMap() {
   try {
-    const raw = JSON.parse((0, import_node_fs20.readFileSync)(GUARD_ITER_FILE, "utf-8"));
+    const raw = JSON.parse((0, import_node_fs22.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 };
@@ -15023,10 +15364,10 @@ function readIter(moment) {
 }
 function writeIter(moment, count) {
   try {
-    (0, import_node_fs20.mkdirSync)(VERITY_DIR, { recursive: true });
+    (0, import_node_fs22.mkdirSync)(VERITY_DIR, { recursive: true });
     const map = readIterMap();
     map[moment] = count;
-    (0, import_node_fs20.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
+    (0, import_node_fs22.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
   } catch {
   }
 }
@@ -15036,10 +15377,10 @@ function resetIter(moment) {
     if (!(moment in map)) return;
     delete map[moment];
     if (Object.keys(map).length === 0) {
-      if ((0, import_node_fs20.existsSync)(GUARD_ITER_FILE)) (0, import_node_fs20.unlinkSync)(GUARD_ITER_FILE);
+      if ((0, import_node_fs22.existsSync)(GUARD_ITER_FILE)) (0, import_node_fs22.unlinkSync)(GUARD_ITER_FILE);
     } else {
-      (0, import_node_fs20.mkdirSync)(VERITY_DIR, { recursive: true });
-      (0, import_node_fs20.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
+      (0, import_node_fs22.mkdirSync)(VERITY_DIR, { recursive: true });
+      (0, import_node_fs22.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
     }
   } catch {
   }
@@ -15057,12 +15398,53 @@ function registerGuardCommand(program2) {
 function getMomentFiles(moment) {
   return moment === "pre-commit" ? getStagedFiles() : getPushRangeFiles().files;
 }
-function buildGuardRequest(moment, files, iter, sessionId) {
+function matchFlagValue(command, flags) {
+  const re = new RegExp(`(?<![\\w-])(?:${flags})(?:=|\\s+)('((?:[^'\\\\]|\\\\.)*)'|"((?:[^"\\\\]|\\\\.)*)"|([^\\s'"-][^\\s]*))`);
+  const m = re.exec(command);
+  if (!m) return null;
+  const v = m[2] ?? m[3] ?? m[4];
+  return v != null ? v.replace(/\\(["'])/g, "$1") : null;
+}
+function parseCommitMessage(command) {
+  const parts = [];
+  const re = /(?<![\w-])(?:--message|-am|-m)(?:=|\s+)('((?:[^'\\]|\\.)*)'|"((?:[^"\\]|\\.)*)"|([^\s'"-][^\s]*))/g;
+  let m;
+  while ((m = re.exec(command)) !== null) {
+    const v = m[2] ?? m[3] ?? m[4];
+    if (v != null && v.length) parts.push(v.replace(/\\(["'])/g, "$1"));
+  }
+  return parts.length ? parts.join("\n\n") : null;
+}
+function parsePrIntent(command) {
+  const title = matchFlagValue(command, "--title|-t");
+  const body = matchFlagValue(command, "--body|-b");
+  const parts = [title, body].filter((x) => !!x);
+  return parts.length ? parts.join("\n\n") : null;
+}
+var TRIVIAL_INTENT = /^(wip|tmp|temp|test|fix|chore|amend|\.+|fixup!.*|squash!.*|merge\b.*)$/i;
+var SHELL_PLUMBING = /\$\(|`|<<-?\s*['"]?[A-Za-z_]/;
+function isSubstantiveIntent(text) {
+  if (!text) return false;
+  const t = text.trim();
+  if (t.length < 12) return false;
+  if (TRIVIAL_INTENT.test(t)) return false;
+  if (SHELL_PLUMBING.test(t)) return false;
+  return true;
+}
+function extractStatedIntent(moment, command) {
+  const text = moment === "pre-commit" ? parseCommitMessage(command) : parsePrIntent(command) ?? (getPushRangeMessages() || null);
+  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) {
   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_fs20.existsSync)(f) ? f : resolveFile(f)).filter((f) => f !== null);
+    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).map((f) => (0, import_node_fs22.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: [] } };
@@ -15087,26 +15469,27 @@ function buildGuardRequest(moment, files, iter, sessionId) {
   };
   const specs = discoverSpecs();
   const plans = discoverPlans();
-  if (specs.length > 0 || plans.length > 0) {
+  const statedIntent = extractStatedIntent(moment, command);
+  if (specs.length > 0 || plans.length > 0 || statedIntent) {
     const intentContext = {};
+    if (statedIntent) intentContext.user_prompt = statedIntent;
     if (specs.length > 0) intentContext.specs = specs;
     if (plans.length > 0) intentContext.plans = plans;
     requestBody.intent_context = intentContext;
   }
   return requestBody;
 }
-function allowWithNotice(moment, decision) {
-  resetIter(moment);
-  if (decision === "WARN") {
-    process.stderr.write(`${YELLOW}Verity ${moment}: WARN \u2014 proceeding. See findings in the report.${NC}
-`);
-  }
+function emitAllowNotice(userMsg, agentMsg) {
+  process.stdout.write(JSON.stringify({
+    systemMessage: userMsg,
+    hookSpecificOutput: { hookEventName: "PreToolUse", additionalContext: agentMsg }
+  }) + "\n");
   process.exit(0);
 }
 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_fs20.existsSync)(cwd)) {
+  if (cwd && (0, import_node_fs22.existsSync)(cwd)) {
     try {
       process.chdir(cwd);
     } catch {
@@ -15114,19 +15497,21 @@ async function runGuard(opts, globals) {
   }
   const moment = classifyCommand(command, on);
   if (!moment) process.exit(0);
+  const verb = moment === "pre-commit" ? "commit" : "push";
   const iter = readIter(moment);
   if (iter >= GUARD_BLOCK_CAP) {
-    process.stderr.write(`${DIM}Verity ${moment}: ${GUARD_BLOCK_CAP} review cycles reached \u2014 allowing through.${NC}
-`);
     resetIter(moment);
-    process.exit(0);
+    emitAllowNotice(
+      `Verity ${moment}: ${GUARD_BLOCK_CAP} review cycles reached \u2014 allowing the ${verb} through`,
+      `Verity ${moment}: review-cycle cap (${GUARD_BLOCK_CAP}) reached; the ${verb} was allowed without a further block.`
+    );
   }
   const files = getMomentFiles(moment);
   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);
+  const requestBody = buildGuardRequest(moment, files, iter, sessionId, command);
   if (!requestBody) process.exit(0);
   const result = await analyzeRequest({
     serviceUrl: urlResult.data,
@@ -15137,21 +15522,39 @@ async function runGuard(opts, globals) {
     cmd: "guard"
   });
   if (!result.ok) {
-    process.stderr.write(`${DIM}Verity ${moment}: service unavailable \u2014 allowing commit/push (${result.error}).${NC}
-`);
-    process.exit(0);
-  }
-  if (opts.json) {
-    process.stdout.write(JSON.stringify(result.data) + "\n");
+    emitAllowNotice(
+      `\u26A0 Verity ${moment}: service offline \u2014 ${verb}ed WITHOUT review`,
+      `Verity ${moment}: service unavailable (${result.error}); the ${verb} was allowed WITHOUT a Verity review.`
+    );
   }
+  if (opts.json) process.stderr.write(JSON.stringify(result.data) + "\n");
   const response = result.data;
   const decision = response.gate_decision ?? "PASS";
-  if (decision === "FAIL") {
+  const viewUrl = response.view_url ?? "";
+  const link = viewUrl ? ` \u2014 ${viewUrl}` : "";
+  if (decision === "FAIL" && hasBlockingFinding(response)) {
     writeIter(moment, iter + 1);
     writeBlockMessage(moment, response);
     process.exit(2);
   }
-  allowWithNotice(moment, decision);
+  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}` : ""}`
+    );
+  }
+  if (decision === "WARN") {
+    emitAllowNotice(
+      `\u26A0 Verity ${moment}: WARN \u2014 proceeding${link}`,
+      `Verity ${moment} review: WARN (proceeding).${viewUrl ? ` Report: ${viewUrl}` : ""}`
+    );
+  }
+  emitAllowNotice(
+    `\u2713 Verity ${moment}: PASS${link}`,
+    `Verity ${moment} review: PASS.${viewUrl ? ` Report: ${viewUrl}` : ""}`
+  );
 }
 function writeBlockMessage(moment, response) {
   const label2 = moment === "pre-commit" ? "pre-commit" : "pre-push";
@@ -15191,14 +15594,14 @@ function writeBlockMessage(moment, response) {
 }
 
 // src/commands/init.ts
-var import_node_fs22 = require("node:fs");
+var import_node_fs24 = require("node:fs");
 var import_promises12 = require("node:fs/promises");
-var import_node_path16 = require("node:path");
+var import_node_path17 = require("node:path");
 var import_node_child_process9 = require("node:child_process");
 
 // src/commands/migrate.ts
-var import_node_fs21 = require("node:fs");
-var import_node_path15 = require("node:path");
+var import_node_fs23 = require("node:fs");
+var import_node_path16 = require("node:path");
 var import_node_child_process8 = require("node:child_process");
 var LEGACY_NPM_PACKAGE = "@codacy/gate-cli";
 function defaultNpmRemover(pkg) {
@@ -15234,12 +15637,12 @@ async function runMigration(opts = {}) {
   return { actions, migrated: actions.length > 0 };
 }
 function migrateProjectDir(root, actions) {
-  const gateDir = (0, import_node_path15.join)(root, ".gate");
-  const verityDir = (0, import_node_path15.join)(root, ".verity");
-  if ((0, import_node_fs21.existsSync)(gateDir) && !(0, import_node_fs21.existsSync)(verityDir)) {
+  const gateDir = (0, import_node_path16.join)(root, ".gate");
+  const verityDir = (0, import_node_path16.join)(root, ".verity");
+  if ((0, import_node_fs23.existsSync)(gateDir) && !(0, import_node_fs23.existsSync)(verityDir)) {
     return migrateProjectDirRename(root, gateDir, verityDir, actions);
   }
-  if ((0, import_node_fs21.existsSync)(gateDir) && (0, import_node_fs21.existsSync)(verityDir)) {
+  if ((0, import_node_fs23.existsSync)(gateDir) && (0, import_node_fs23.existsSync)(verityDir)) {
     return migrateProjectDirCarry(gateDir, verityDir, actions);
   }
   return false;
@@ -15260,13 +15663,13 @@ function migrateProjectDirRename(root, gateDir, verityDir, actions) {
     }
   }
   if (moved) {
-    if ((0, import_node_fs21.existsSync)(gateDir)) {
+    if ((0, import_node_fs23.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_fs21.rmSync)(gateDir, { recursive: true, force: true });
+        (0, import_node_fs23.rmSync)(gateDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -15282,18 +15685,18 @@ function migrateProjectDirCarry(gateDir, verityDir, actions) {
     actions.push(`Carried ${carried} legacy file(s) from .gate/ into .verity/`);
   }
   try {
-    (0, import_node_fs21.rmSync)(gateDir, { recursive: true, force: true });
+    (0, import_node_fs23.rmSync)(gateDir, { recursive: true, force: true });
   } catch {
   }
   return carried > 0;
 }
 function migrateGlobalCredentials(home, actions) {
   if (!home) return;
-  const gateCreds = (0, import_node_path15.join)(home, ".gate", "credentials");
-  const verityCreds = (0, import_node_path15.join)(home, ".verity", "credentials");
-  if (!(0, import_node_fs21.existsSync)(gateCreds)) return;
-  if (!(0, import_node_fs21.existsSync)(verityCreds)) {
-    (0, import_node_fs21.mkdirSync)((0, import_node_path15.join)(home, ".verity"), { recursive: true });
+  const gateCreds = (0, import_node_path16.join)(home, ".gate", "credentials");
+  const verityCreds = (0, import_node_path16.join)(home, ".verity", "credentials");
+  if (!(0, import_node_fs23.existsSync)(gateCreds)) return;
+  if (!(0, import_node_fs23.existsSync)(verityCreds)) {
+    (0, import_node_fs23.mkdirSync)((0, import_node_path16.join)(home, ".verity"), { recursive: true });
     moveFile(gateCreds, verityCreds);
     actions.push("Moved ~/.gate/credentials \u2192 ~/.verity/credentials");
     return;
@@ -15315,8 +15718,8 @@ async function migrateLegacyHooks(root, actions) {
   }
 }
 async function migrateClaudeMd(root, actions) {
-  const claudeMd = (0, import_node_path15.join)(root, "CLAUDE.md");
-  const hadLegacyBlock = (0, import_node_fs21.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
+  const claudeMd = (0, import_node_path16.join)(root, "CLAUDE.md");
+  const hadLegacyBlock = (0, import_node_fs23.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
   if (!hadLegacyBlock) return;
   try {
     await ensureClaudeMdPointer(root);
@@ -15326,9 +15729,9 @@ async function migrateClaudeMd(root, actions) {
   }
 }
 function migrateStandardFile(root, actions) {
-  const gateMd = (0, import_node_path15.join)(root, "GATE.md");
-  const verityMd = (0, import_node_path15.join)(root, "VERITY.md");
-  if (!(0, import_node_fs21.existsSync)(gateMd) || (0, import_node_fs21.existsSync)(verityMd)) return;
+  const gateMd = (0, import_node_path16.join)(root, "GATE.md");
+  const verityMd = (0, import_node_path16.join)(root, "VERITY.md");
+  if (!(0, import_node_fs23.existsSync)(gateMd) || (0, import_node_fs23.existsSync)(verityMd)) return;
   let moved = false;
   if (isGitRepo(root) && isGitTracked(root, "GATE.md")) {
     try {
@@ -15340,7 +15743,7 @@ 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_fs21.writeFileSync)(verityMd, refreshed);
+  if (refreshed !== content) (0, import_node_fs23.writeFileSync)(verityMd, refreshed);
   actions.push("Renamed GATE.md \u2192 VERITY.md");
 }
 function removeLegacyPackage(movedProjectDir, npmRemover, actions) {
@@ -15374,14 +15777,14 @@ function mergeGlobalCredentials(gateCreds, verityCreds) {
   }
   if (toAppend.length > 0) {
     const sep = verityContent.endsWith("\n") || verityContent === "" ? "" : "\n";
-    (0, import_node_fs21.writeFileSync)(verityCreds, verityContent + sep + toAppend.join("\n") + "\n");
+    (0, import_node_fs23.writeFileSync)(verityCreds, verityContent + sep + toAppend.join("\n") + "\n");
   }
-  (0, import_node_fs21.rmSync)(gateCreds, { force: true });
+  (0, import_node_fs23.rmSync)(gateCreds, { force: true });
   return toAppend.length;
 }
 function readFileSyncSafe(path) {
   try {
-    return (0, import_node_fs21.readFileSync)(path, "utf-8");
+    return (0, import_node_fs23.readFileSync)(path, "utf-8");
   } catch {
     return "";
   }
@@ -15396,35 +15799,35 @@ function hasStagedChanges(root) {
 }
 function moveDir(from, to) {
   try {
-    (0, import_node_fs21.renameSync)(from, to);
+    (0, import_node_fs23.renameSync)(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
-    (0, import_node_fs21.cpSync)(from, to, { recursive: true });
-    (0, import_node_fs21.rmSync)(from, { recursive: true, force: true });
+    (0, import_node_fs23.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs23.rmSync)(from, { recursive: true, force: true });
   }
 }
 function moveFile(from, to) {
   try {
-    (0, import_node_fs21.renameSync)(from, to);
+    (0, import_node_fs23.renameSync)(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
-    (0, import_node_fs21.cpSync)(from, to);
-    (0, import_node_fs21.rmSync)(from, { force: true });
+    (0, import_node_fs23.cpSync)(from, to);
+    (0, import_node_fs23.rmSync)(from, { force: true });
   }
 }
 function carryLegacyContents(gateDir, verityDir) {
   let copied = 0;
   const walk = (relDir) => {
-    const srcDir = (0, import_node_path15.join)(gateDir, relDir);
-    for (const entry of (0, import_node_fs21.readdirSync)(srcDir)) {
-      const rel = relDir ? (0, import_node_path15.join)(relDir, entry) : entry;
-      const src = (0, import_node_path15.join)(gateDir, rel);
-      const dest = (0, import_node_path15.join)(verityDir, rel);
-      if ((0, import_node_fs21.statSync)(src).isDirectory()) {
+    const srcDir = (0, import_node_path16.join)(gateDir, relDir);
+    for (const entry of (0, import_node_fs23.readdirSync)(srcDir)) {
+      const rel = relDir ? (0, import_node_path16.join)(relDir, entry) : entry;
+      const src = (0, import_node_path16.join)(gateDir, rel);
+      const dest = (0, import_node_path16.join)(verityDir, rel);
+      if ((0, import_node_fs23.statSync)(src).isDirectory()) {
         walk(rel);
-      } else if (!(0, import_node_fs21.existsSync)(dest)) {
-        (0, import_node_fs21.mkdirSync)((0, import_node_path15.dirname)(dest), { recursive: true });
-        (0, import_node_fs21.cpSync)(src, dest);
+      } else if (!(0, import_node_fs23.existsSync)(dest)) {
+        (0, import_node_fs23.mkdirSync)((0, import_node_path16.dirname)(dest), { recursive: true });
+        (0, import_node_fs23.cpSync)(src, dest);
         copied++;
       }
     }
@@ -15433,22 +15836,22 @@ function carryLegacyContents(gateDir, verityDir) {
   return copied;
 }
 async function needsMigration(root = repoRoot()) {
-  const gateDir = (0, import_node_path15.join)(root, ".gate");
-  const verityDir = (0, import_node_path15.join)(root, ".verity");
-  if ((0, import_node_fs21.existsSync)(gateDir) && !(0, import_node_fs21.existsSync)(verityDir)) return true;
-  if ((0, import_node_fs21.existsSync)(gateDir) && (0, import_node_fs21.existsSync)(verityDir)) {
-    if ((0, import_node_fs21.existsSync)((0, import_node_path15.join)(gateDir, "credentials")) && !(0, import_node_fs21.existsSync)((0, import_node_path15.join)(verityDir, "credentials"))) {
+  const gateDir = (0, import_node_path16.join)(root, ".gate");
+  const verityDir = (0, import_node_path16.join)(root, ".verity");
+  if ((0, import_node_fs23.existsSync)(gateDir) && !(0, import_node_fs23.existsSync)(verityDir)) return true;
+  if ((0, import_node_fs23.existsSync)(gateDir) && (0, import_node_fs23.existsSync)(verityDir)) {
+    if ((0, import_node_fs23.existsSync)((0, import_node_path16.join)(gateDir, "credentials")) && !(0, import_node_fs23.existsSync)((0, import_node_path16.join)(verityDir, "credentials"))) {
       return true;
     }
-    if ((0, import_node_fs21.existsSync)((0, import_node_path15.join)(gateDir, "memory")) && !(0, import_node_fs21.existsSync)((0, import_node_path15.join)(verityDir, "memory"))) {
+    if ((0, import_node_fs23.existsSync)((0, import_node_path16.join)(gateDir, "memory")) && !(0, import_node_fs23.existsSync)((0, import_node_path16.join)(verityDir, "memory"))) {
       return true;
     }
   }
-  const claudeMd = (0, import_node_path15.join)(root, "CLAUDE.md");
-  if ((0, import_node_fs21.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd))) {
+  const claudeMd = (0, import_node_path16.join)(root, "CLAUDE.md");
+  if ((0, import_node_fs23.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd))) {
     return true;
   }
-  if ((0, import_node_fs21.existsSync)((0, import_node_path15.join)(root, "GATE.md")) && !(0, import_node_fs21.existsSync)((0, import_node_path15.join)(root, "VERITY.md"))) {
+  if ((0, import_node_fs23.existsSync)((0, import_node_path16.join)(root, "GATE.md")) && !(0, import_node_fs23.existsSync)((0, import_node_path16.join)(root, "VERITY.md"))) {
     return true;
   }
   if (await hasLegacyHooksAt(root)) return true;
@@ -15476,15 +15879,15 @@ function registerMigrateCommand(program2) {
 // src/commands/init.ts
 function resolveDataDir() {
   const candidates = [
-    (0, import_node_path16.join)(__dirname, "..", "data"),
+    (0, import_node_path17.join)(__dirname, "..", "data"),
     // installed: node_modules/@codacy/verity-cli/data
-    (0, import_node_path16.join)(__dirname, "..", "..", "data"),
+    (0, import_node_path17.join)(__dirname, "..", "..", "data"),
     // edge case: nested resolution
-    (0, import_node_path16.join)(process.cwd(), "cli", "data")
+    (0, import_node_path17.join)(process.cwd(), "cli", "data")
     // local dev: running from repo root
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs22.existsSync)((0, import_node_path16.join)(candidate, "skills"))) {
+    if ((0, import_node_fs24.existsSync)((0, import_node_path17.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -15500,7 +15903,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_fs22.existsSync)(m));
+    const isProject = projectMarkers.some((m) => (0, import_node_fs24.existsSync)(m));
     if (!isProject) {
       printError("No project detected in the current directory.");
       printInfo('Run "verity init" from your project root.');
@@ -15563,21 +15966,21 @@ function registerInitCommand(program2) {
     console.log("");
     printInfo("Installing skills...");
     const dataDir = resolveDataDir();
-    const skillsSource = (0, import_node_path16.join)(dataDir, "skills");
+    const skillsSource = (0, import_node_path17.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_path16.join)(skillsSource, skill);
-      const dest = (0, import_node_path16.join)(skillsDest, skill);
-      if (!(0, import_node_fs22.existsSync)(src)) {
+      const src = (0, import_node_path17.join)(skillsSource, skill);
+      const dest = (0, import_node_path17.join)(skillsDest, skill);
+      if (!(0, import_node_fs24.existsSync)(src)) {
         printWarn(`  Skill data not found: ${skill}`);
         continue;
       }
-      if ((0, import_node_fs22.existsSync)(dest) && !force) {
-        const srcSkill = (0, import_node_path16.join)(src, "SKILL.md");
-        const destSkill = (0, import_node_path16.join)(dest, "SKILL.md");
-        if ((0, import_node_fs22.existsSync)(destSkill)) {
+      if ((0, import_node_fs24.existsSync)(dest) && !force) {
+        const srcSkill = (0, import_node_path17.join)(src, "SKILL.md");
+        const destSkill = (0, import_node_path17.join)(dest, "SKILL.md");
+        if ((0, import_node_fs24.existsSync)(destSkill)) {
           try {
             const srcContent = await (0, import_promises12.readFile)(srcSkill, "utf-8");
             const destContent = await (0, import_promises12.readFile)(destSkill, "utf-8");
@@ -15601,6 +16004,7 @@ function registerInitCommand(program2) {
       await writeSettings(hookResult.data);
       printInfo("  Stop hook: verity analyze \u2713");
       printInfo("  Intent hook: verity intent capture \u2713");
+      printInfo("  Baseline hook: verity baseline capture \u2713");
     } else {
       printWarn(`  ${hookResult.error}`);
       printInfo('  Run "verity hooks install --force" to overwrite.');
@@ -15613,7 +16017,7 @@ function registerInitCommand(program2) {
     } catch (err) {
       printWarn(`  Could not update CLAUDE.md: ${err.message}`);
     }
-    const globalVerityDir = (0, import_node_path16.join)(process.env.HOME ?? "", ".verity");
+    const globalVerityDir = (0, import_node_path17.join)(process.env.HOME ?? "", ".verity");
     await (0, import_promises12.mkdir)(globalVerityDir, { recursive: true });
     console.log("");
     printInfo("Verity initialized!");
@@ -15636,8 +16040,8 @@ function registerInitCommand(program2) {
 }
 
 // src/commands/uninstall.ts
-var import_node_fs23 = require("node:fs");
-var import_node_path17 = require("node:path");
+var import_node_fs25 = require("node:fs");
+var import_node_path18 = require("node:path");
 var SKILL_NAMES = [
   "verity-setup",
   "verity-analyze",
@@ -15656,11 +16060,11 @@ function registerUninstallCommand(program2) {
     const actions = [];
     const skillsRoot = projectPath(".claude/skills");
     for (const name of SKILL_NAMES) {
-      const dir = (0, import_node_path17.join)(skillsRoot, name);
-      if ((0, import_node_fs23.existsSync)(dir)) {
+      const dir = (0, import_node_path18.join)(skillsRoot, name);
+      if ((0, import_node_fs25.existsSync)(dir)) {
         actions.push({
           label: `Remove .claude/skills/${name}/`,
-          apply: () => (0, import_node_fs23.rmSync)(dir, { recursive: true, force: true })
+          apply: () => (0, import_node_fs25.rmSync)(dir, { recursive: true, force: true })
         });
       }
     }
@@ -15674,24 +16078,24 @@ function registerUninstallCommand(program2) {
       });
     }
     const verityDir = projectPath(VERITY_DIR);
-    if ((0, import_node_fs23.existsSync)(verityDir)) {
+    if ((0, import_node_fs25.existsSync)(verityDir)) {
       actions.push({
         label: `Remove ${VERITY_DIR}/`,
-        apply: () => (0, import_node_fs23.rmSync)(verityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs25.rmSync)(verityDir, { recursive: true, force: true })
       });
     }
     if (!keepVerityMd) {
       const verityMd = projectPath(VERITY_MD_FILE);
-      if ((0, import_node_fs23.existsSync)(verityMd)) {
+      if ((0, import_node_fs25.existsSync)(verityMd)) {
         actions.push({
           label: `Remove ${VERITY_MD_FILE}`,
-          apply: () => (0, import_node_fs23.rmSync)(verityMd, { force: true })
+          apply: () => (0, import_node_fs25.rmSync)(verityMd, { force: true })
         });
       }
     }
     const cleanupEmptyDir = (path) => {
-      if ((0, import_node_fs23.existsSync)(path) && (0, import_node_fs23.statSync)(path).isDirectory() && (0, import_node_fs23.readdirSync)(path).length === 0) {
-        (0, import_node_fs23.rmdirSync)(path);
+      if ((0, import_node_fs25.existsSync)(path) && (0, import_node_fs25.statSync)(path).isDirectory() && (0, import_node_fs25.readdirSync)(path).length === 0) {
+        (0, import_node_fs25.rmdirSync)(path);
       }
     };
     actions.push({
@@ -15702,11 +16106,11 @@ function registerUninstallCommand(program2) {
       }
     });
     const home = process.env.HOME ?? "";
-    const globalVerityDir = (0, import_node_path17.join)(home, ".verity");
-    if (purgeGlobal && (0, import_node_fs23.existsSync)(globalVerityDir)) {
+    const globalVerityDir = (0, import_node_path18.join)(home, ".verity");
+    if (purgeGlobal && (0, import_node_fs25.existsSync)(globalVerityDir)) {
       actions.push({
         label: `Remove ~/.verity/ (global credentials \u2014 reconnect requires re-registration)`,
-        apply: () => (0, import_node_fs23.rmSync)(globalVerityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs25.rmSync)(globalVerityDir, { recursive: true, force: true })
       });
     }
     if (actions.length === 0) {
@@ -15900,8 +16304,8 @@ function registerTaskCommands(program2) {
 }
 
 // src/commands/reset.ts
-var import_node_fs24 = require("node:fs");
-var import_node_path18 = require("node:path");
+var import_node_fs26 = require("node:fs");
+var import_node_path19 = 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();
@@ -15938,11 +16342,11 @@ function registerResetCommand(program2) {
     }
     const cacheDir = projectPath(CACHE_DIR);
     let purged = 0;
-    if ((0, import_node_fs24.existsSync)(cacheDir)) {
-      for (const entry of (0, import_node_fs24.readdirSync)(cacheDir)) {
+    if ((0, import_node_fs26.existsSync)(cacheDir)) {
+      for (const entry of (0, import_node_fs26.readdirSync)(cacheDir)) {
         if (entry.startsWith("pending-")) {
           try {
-            (0, import_node_fs24.unlinkSync)((0, import_node_path18.join)(cacheDir, entry));
+            (0, import_node_fs26.unlinkSync)((0, import_node_path19.join)(cacheDir, entry));
             purged++;
           } catch {
           }
@@ -15957,19 +16361,19 @@ function registerResetCommand(program2) {
       projectPath(`${VERITY_DIR}/.last-analysis`)
     ];
     for (const file of filesToClear) {
-      if ((0, import_node_fs24.existsSync)(file)) {
+      if ((0, import_node_fs26.existsSync)(file)) {
         try {
-          (0, import_node_fs24.writeFileSync)(file, "");
+          (0, import_node_fs26.writeFileSync)(file, "");
         } catch {
         }
       }
     }
     if (opts.all) {
       const logsDir = projectPath(`${VERITY_DIR}/.logs`);
-      if ((0, import_node_fs24.existsSync)(logsDir)) {
-        for (const entry of (0, import_node_fs24.readdirSync)(logsDir)) {
+      if ((0, import_node_fs26.existsSync)(logsDir)) {
+        for (const entry of (0, import_node_fs26.readdirSync)(logsDir)) {
           try {
-            (0, import_node_fs24.unlinkSync)((0, import_node_path18.join)(logsDir, entry));
+            (0, import_node_fs26.unlinkSync)((0, import_node_path19.join)(logsDir, entry));
           } catch {
           }
         }
@@ -15980,10 +16384,29 @@ function registerResetCommand(program2) {
   });
 }
 
+// src/lib/run-mode.ts
+function parseAutonomousEnv(raw) {
+  if (raw === void 0) return void 0;
+  const v = raw.trim().toLowerCase();
+  if (v === "") return void 0;
+  if (v === "0" || v === "false" || v === "off" || v === "no") return false;
+  return true;
+}
+function resolveRunMode(inputs = {}) {
+  if (inputs.autonomousFlag === true) return "autonomous";
+  if (inputs.autonomousFlag === false) return "interactive";
+  const env = inputs.env ?? process.env;
+  const envDecision = parseAutonomousEnv(env.VERITY_AUTONOMOUS);
+  if (envDecision !== void 0) return envDecision ? "autonomous" : "interactive";
+  const isTTY = inputs.isTTY ?? Boolean(process.stdin?.isTTY);
+  return isTTY ? "interactive" : "autonomous";
+}
+
 // src/commands/reflect.ts
 function registerReflectCommand(program2) {
-  program2.command("reflect").description("Capture learnings \u2014 auto-extract or submit a human reflection").option("--user-input <text>", "Your reflection (becomes a high-confidence knowledge node)").option("--kind <kind>", "Node kind (decision, gotcha, pattern, security, quality, intent, domain, integration)", "gotcha").option("--task-id <id>", "Task to reflect on (defaults to current task)").action(async (opts) => {
+  program2.command("reflect").description("Capture learnings \u2014 auto-extract or submit a human reflection").option("--user-input <text>", "The reflection to record (the agent-drafted or user-confirmed text)").option("--kind <kind>", "Node kind (decision, gotcha, pattern, security, quality, intent, domain, integration)", "gotcha").option("--task-id <id>", "Task to reflect on (defaults to current task)").option("--autonomous", "Record the drafted reflection without a confirm step (auto-detected from TTY / VERITY_AUTONOMOUS when omitted)").action(async (opts) => {
     const globals = program2.opts();
+    const mode = resolveRunMode({ autonomousFlag: opts.autonomous });
     await ensureMemoryDir();
     const tokenResult = await resolveToken(globals.token);
     if (!tokenResult.ok) {
@@ -16074,7 +16497,9 @@ function registerReflectCommand(program2) {
       const nodeId = result.data.node_id;
       const filePath = result.data.file_path;
       printInfo(`Queued: ${nodeId} (will sync to .verity/memory/${filePath} on next analysis).`);
-      printInfo("Your reflection is now part of the project knowledge base (confidence: 100%).");
+      printInfo(
+        mode === "autonomous" ? "Recorded autonomously (no confirm step) into the project knowledge base." : "Recorded your confirmed reflection into the project knowledge base."
+      );
       if (taskResolution === "none") {
         printInfo("(No task context \u2014 reflection lives at the project level.)");
       }
@@ -16207,7 +16632,7 @@ function registerRunCommand(program2) {
 
 // src/lib/telemetry.ts
 var import_promises13 = require("node:fs/promises");
-var import_node_path19 = require("node:path");
+var import_node_path20 = require("node:path");
 var SETTINGS_LOCAL_FILE2 = ".claude/settings.local.json";
 var GITIGNORE_FILE = ".gitignore";
 var GITIGNORE_ENTRY = ".claude/settings.local.json";
@@ -16245,7 +16670,7 @@ async function readSettingsLocal() {
 }
 async function writeSettingsLocal(settings) {
   const file = projectPath(SETTINGS_LOCAL_FILE2);
-  await (0, import_promises13.mkdir)((0, import_node_path19.dirname)(file), { recursive: true });
+  await (0, import_promises13.mkdir)((0, import_node_path20.dirname)(file), { recursive: true });
   await (0, import_promises13.writeFile)(file, JSON.stringify(settings, null, 2) + "\n");
 }
 async function ensureGitignore() {
@@ -16341,7 +16766,7 @@ function registerTelemetryCommands(program2) {
 }
 
 // src/cli.ts
-program.name("verity").description("CLI for Verity quality gate service").version("0.23.2").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr");
+program.name("verity").description("CLI for Verity quality gate service").version("0.24.0-experimental.6a390ac").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr");
 registerAuthCommands(program);
 registerHooksCommands(program);
 registerIntentCommands(program);
@@ -16350,6 +16775,7 @@ registerConfigCommands(program);
 registerStatusCommand(program);
 registerFeedbackCommand(program);
 registerAnalyzeCommand(program);
+registerBaselineCommands(program);
 registerReviewCommand(program);
 registerGuardCommand(program);
 registerInitCommand(program);