@codacy/verity-cli 0.28.1-experimental.dbd87b1 → 0.28.1-experimental.e79117b

package/bin/verity.js

@@ -10386,10 +10386,9 @@ function projectPath(relativePath) {
   return (0, import_node_path.join)(repoRoot(), relativePath);
 }
 var MAX_DELTA_BYTES = 194560;
-var MAX_FILES = 20;
+var MAX_FILES = 40;
 var MAX_FILE_BYTES = 51200;
 var DEBOUNCE_SECONDS = 30;
-var MAX_ITERATIONS = 2;
 var MAX_SPEC_FILES = 10;
 var MAX_SPEC_FILE_BYTES = 10240;
 var MAX_TOTAL_SPEC_BYTES = 30720;
@@ -10636,14 +10635,14 @@ async function readGlobalCredential(remote) {
       const parsed = parseCredentialLine(line);
       if (parsed && parsed.remote === key) last = parsed.rec;
     }
-    if (last) return last;
+    if (last) return { ...last, keyed: true };
   }
   let plain = null;
   for (const line of lines) {
     const parsed = parseCredentialLine(line);
     if (parsed && parsed.remote === "") plain = parsed.rec;
   }
-  return plain;
+  return plain ? { ...plain, keyed: false } : null;
 }
 async function upsertGlobalCredential(remote, rec) {
   const path = globalCredentialsPath();
@@ -10707,6 +10706,36 @@ async function removeSupersededUserCredentials(loginServiceUrl, loginUserId) {
   }
   return removed;
 }
+async function removeGlobalCredential(remote) {
+  const path = globalCredentialsPath();
+  let content;
+  try {
+    content = await (0, import_promises.readFile)(path, "utf-8");
+  } catch {
+    return false;
+  }
+  const key = encodeRemoteKey(remote);
+  const kept = [];
+  let removed = false;
+  for (const line of content.split("\n")) {
+    const parsed = parseCredentialLine(line);
+    if (parsed && parsed.remote === key) {
+      removed = true;
+      continue;
+    }
+    kept.push(line);
+  }
+  if (!removed) return false;
+  while (kept.length && kept[kept.length - 1].trim() === "") kept.pop();
+  try {
+    await (0, import_promises.writeFile)(path, kept.length ? kept.join("\n") + "\n" : "", { mode: 384 });
+    await (0, import_promises.chmod)(path, 384).catch(() => {
+    });
+  } catch {
+    return false;
+  }
+  return true;
+}
 function parseLocalCredentialFile(content) {
   const tokenMatch = content.match(/token:\s*((?:gate_|verity_)[a-f0-9]+)/);
   if (!tokenMatch) return null;
@@ -10894,8 +10923,8 @@ function filterReviewable(files) {
     const ext = (0, import_node_path3.extname)(f).slice(1);
     if (ANALYZABLE_EXTENSIONS.has(ext)) return false;
     if (REVIEWABLE_EXTENSIONS.has(ext)) return true;
-    const basename4 = f.split("/").pop() ?? "";
-    if (REVIEWABLE_FILENAMES.has(basename4)) return true;
+    const basename3 = f.split("/").pop() ?? "";
+    if (REVIEWABLE_FILENAMES.has(basename3)) return true;
     if (REVIEWABLE_PATH_PATTERNS.some((p) => p.test(f))) return true;
     return false;
   });
@@ -10986,7 +11015,54 @@ function listTrackedFiles() {
   return Array.from(set);
 }
 function sanitizeRemote(remote) {
-  return remote.replace(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)[^/]*@/, "$1");
+  const withoutUserinfo = remote.replace(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)[^/]*@/, "$1");
+  return /[\u0000-\u001f\u007f]/.test(withoutUserinfo) ? "" : withoutUserinfo;
+}
+
+// src/lib/token-pin.ts
+var cached;
+var warned = false;
+function warnOnce(message, warn) {
+  if (!warned) {
+    warned = true;
+    warn(message);
+  }
+  return message;
+}
+async function storedCredential() {
+  if (cached !== void 0) return cached;
+  const rec = await readGlobalCredential(currentRemote());
+  cached = rec ? { token: rec.token, serviceUrl: rec.serviceUrl } : null;
+  return cached;
+}
+var userNamedUrl = null;
+function setUserNamedServiceUrl(url) {
+  userNamedUrl = url?.trim() || null;
+}
+async function checkTokenPin(token, targetUrl) {
+  if (process.env.VERITY_TOKEN && token === process.env.VERITY_TOKEN) return { attach: true };
+  const envUrl = process.env.VERITY_SERVICE_URL?.trim();
+  if (envUrl && normalizeUrl(envUrl) === normalizeUrl(targetUrl)) return { attach: true };
+  if (userNamedUrl && normalizeUrl(userNamedUrl) === normalizeUrl(targetUrl)) return { attach: true };
+  const stored = await storedCredential();
+  if (!stored || stored.token !== token) return { attach: true };
+  if (!stored.serviceUrl) return { attach: false, reason: "unpinnable" };
+  return normalizeUrl(stored.serviceUrl) === normalizeUrl(targetUrl) ? { attach: true } : { attach: false, reason: "mismatch", mintedFor: stored.serviceUrl };
+}
+function normalizeUrl(raw) {
+  const trimmed = raw.trim().replace(/\/+$/, "");
+  try {
+    const u = new URL(trimmed);
+    return `${u.protocol}//${u.host.toLowerCase()}${u.pathname.replace(/\/+$/, "")}`;
+  } catch {
+    return trimmed.toLowerCase();
+  }
+}
+function pinRefusalMessage(verdict, targetUrl) {
+  if (verdict.reason === "unpinnable") {
+    return `Refusing to send your Verity login to ${targetUrl}: this machine's credential does not record which service issued it, so it cannot be verified. Run "verity login" to re-issue it.`;
+  }
+  return `Refusing to send your Verity login to ${targetUrl}: it was issued by ${verdict.mintedFor}. A repository cannot redirect your credential to another service. If this service is genuinely yours, log in against it explicitly: VERITY_SERVICE_URL=${targetUrl} verity login`;
 }
 
 // src/lib/api-client.ts
@@ -11023,6 +11099,24 @@ async function apiRequest(options) {
     "Content-Type": "application/json"
   };
   if (token) {
+    const pin = await checkTokenPin(token, serviceUrl);
+    if (!pin.attach) {
+      const message = warnOnce(pinRefusalMessage(pin, serviceUrl), printWarn);
+      logHttpCall({
+        cmd,
+        method,
+        url,
+        duration_ms: 0,
+        http_status: null,
+        // 'network' rather than a new category on purpose: no request left the
+        // machine, and every caller's offline path is exactly the handling a
+        // refusal wants (fall back to local, never fabricate a verdict).
+        category: "network",
+        error: "token_pin_refused",
+        retry
+      });
+      return { ok: false, error: `TOKEN_PIN_REFUSED: ${message}`, category: "network" };
+    }
     headers["Authorization"] = `Bearer ${token}`;
   }
   const remote = requestRemote();
@@ -11135,14 +11229,9 @@ async function serviceUrlFromCredentials() {
 async function serviceUrlFromVerityMd() {
   try {
     const content = await (0, import_promises2.readFile)(projectPath(VERITY_MD_FILE), "utf-8");
-    const boldLine = content.split("\n").find((l) => /\*\*url\*\*/i.test(l));
-    if (boldLine) {
-      const urlMatch = boldLine.match(/https:\/\/[^\s]+/);
-      if (urlMatch) return urlMatch[0];
-    }
-    const plainLine = content.split("\n").find((l) => /(?:url|service)\s*:/i.test(l));
-    if (plainLine) {
-      const urlMatch = plainLine.match(/https:\/\/[^\s]+/);
+    const line = content.split("\n").find((l) => /\*{0,2}(?:url|service)\*{0,2}\s*:/i.test(l));
+    if (line) {
+      const urlMatch = line.match(/https:\/\/[^\s]+/);
       if (urlMatch) return urlMatch[0];
     }
   } catch {
@@ -11165,7 +11254,15 @@ async function resolveServiceUrlDetailed(flagUrl) {
   if (mdUrl) {
     return { ok: true, data: { url: mdUrl, source: "verity_md" } };
   }
-  return { ok: false, error: "No Verity service URL found. Run /verity-setup to configure." };
+  return {
+    ok: false,
+    error: 'No Verity service URL found. Run "verity login" to get started, or /verity-setup to configure this project.'
+  };
+}
+async function resolveServiceUrlForAuth(flagUrl) {
+  const strict = await resolveServiceUrlDetailed(flagUrl);
+  if (strict.ok) return strict.data;
+  return { url: DEFAULT_SERVICE_URL, source: "default" };
 }
 async function resolveServiceUrl(flagUrl) {
   const result = await resolveServiceUrlDetailed(flagUrl);
@@ -11188,7 +11285,13 @@ async function resolveToken(flagToken) {
   if (rec) {
     return {
       ok: true,
-      data: { token: rec.token, source: "global", userId: rec.userId, email: rec.email }
+      data: {
+        token: rec.token,
+        source: "global",
+        userId: rec.userId,
+        email: rec.email,
+        keyed: rec.keyed
+      }
     };
   }
   const local = await readLegacyLocalCredential();
@@ -11198,7 +11301,10 @@ async function resolveToken(flagToken) {
       data: { token: local.token, source: "local", userId: local.userId, email: local.email }
     };
   }
-  return { ok: false, error: "No Verity token found. Run /verity-setup to configure." };
+  return {
+    ok: false,
+    error: 'No Verity token found. Run "verity login" to sign in, or /verity-setup to set up this project.'
+  };
 }
 async function whoami(token, serviceUrl, verbose) {
   return apiRequest({
@@ -11220,6 +11326,16 @@ function reverifyNudge(who) {
   }
   return null;
 }
+function isLegacyPerRepoCredential(auth2) {
+  return auth2.source === "local" || auth2.source === "global" && auth2.keyed === true;
+}
+async function shouldUpgradeOnLogin(auth2) {
+  if (!isLegacyPerRepoCredential(auth2)) return false;
+  if (auth2.userId == null) return true;
+  const bare = await readGlobalCredential("");
+  if (bare?.userId == null) return true;
+  return bare.userId === auth2.userId;
+}
 function authDenialRemedy(error) {
   if (error.startsWith("STALE_VERIFICATION")) {
     return {
@@ -11233,6 +11349,12 @@ function authDenialRemedy(error) {
       remedy: 'No access grant for this repository \u2014 run "verity login" to refresh your grants (a repo granted after your last login needs one), or get write access to it.'
     };
   }
+  if (error.startsWith("INVALID_TOKEN")) {
+    return {
+      code: "INVALID_TOKEN",
+      remedy: 'Your Verity login has expired or was revoked \u2014 run "verity login" to sign in again.'
+    };
+  }
   return null;
 }
 async function probeService(serviceUrl, verbose) {
@@ -11273,6 +11395,7 @@ async function maybeHealServiceUrl(resolution, verbose) {
 
 // src/lib/register.ts
 var readline = __toESM(require("node:readline/promises"));
+var import_node_os = require("node:os");
 
 // src/lib/provider-auth.ts
 var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
@@ -11460,6 +11583,15 @@ async function registerProject(opts) {
   }
   return { ok: true, data: { projectId: project_id, serviceUrl: service_url, email, userId } };
 }
+function deviceLabel() {
+  const override = process.env.VERITY_DEVICE_LABEL?.trim();
+  if (override) return override;
+  try {
+    return (0, import_node_os.hostname)() || void 0;
+  } catch {
+    return void 0;
+  }
+}
 async function loginOnce(opts) {
   const usingTokenOverride = Boolean(process.env.VERITY_PROVIDER_TOKEN);
   const providerAuth = await githubDeviceFlow();
@@ -11480,13 +11612,19 @@ async function loginOnce(opts) {
     path: "/auth/login",
     serviceUrl: opts.serviceUrl,
     extraHeaders: { "X-Provider-Token": providerToken },
+    // Label the session so its owner can tell their machines apart in
+    // `verity sessions list` — a list of identical "login" rows is unusable when
+    // the question is "which of these is the laptop I lost?". The hostname is the
+    // useful default; VERITY_DEVICE_LABEL overrides it for anyone who would
+    // rather not send it. Server-side it is sanitized and capped.
+    body: { device: deviceLabel() },
     verbose: opts.verbose,
     cmd: "login"
   });
   if (!result.ok) {
     return { ok: false, error: result.error };
   }
-  const { token, service_url, user_id, user, repo_count } = result.data;
+  const { token, service_url, user_id, user, repo_count, expires_at } = result.data;
   const loginUserId = user_id ?? user?.id ?? void 0;
   try {
     await upsertGlobalCredential("", {
@@ -11510,15 +11648,16 @@ async function loginOnce(opts) {
       email: user?.email,
       userId: loginUserId,
       repoCount: repo_count ?? 0,
-      prunedCredentials: pruned
+      prunedCredentials: pruned,
+      expiresAt: expires_at
     }
   };
 }
 
 // src/commands/auth.ts
 function registerAuthCommands(program2) {
-  const auth = program2.command("auth").description("Manage project authentication");
-  auth.command("register").description("Register a project with Verity").requiredOption("--project <name>", "Project name").option("--remote <url>", "Git remote URL (auto-detected if omitted)").action(async (opts) => {
+  const auth2 = program2.command("auth").description("Manage project authentication");
+  auth2.command("register").description("Register a project with Verity").requiredOption("--project <name>", "Project name").option("--remote <url>", "Git remote URL (auto-detected if omitted)").action(async (opts) => {
     const globals = program2.opts();
     const serviceUrl = globals.serviceUrl ?? DEFAULT_SERVICE_URL;
     let remote = opts.remote;
@@ -11545,7 +11684,7 @@ function registerAuthCommands(program2) {
     if (email) printInfo(`Authenticated as: ${email}`);
     printJson({ project_id: projectId, service_url: resolvedUrl });
   });
-  auth.command("verify").description("Verify the current token is valid").action(async () => {
+  auth2.command("verify").description("Verify the current token is valid").action(async () => {
     const globals = program2.opts();
     const tokenResult = await resolveToken(globals.token);
     if (!tokenResult.ok) {
@@ -11571,7 +11710,7 @@ function registerAuthCommands(program2) {
     printInfo(`Token valid. Project: ${result.data.project_name}`);
     printJson(result.data);
   });
-  auth.command("discover").description("Check if a project is registered").option("--remote <url>", "Git remote URL (auto-detected if omitted)").action(async (opts) => {
+  auth2.command("discover").description("Check if a project is registered").option("--remote <url>", "Git remote URL (auto-detected if omitted)").action(async (opts) => {
     const globals = program2.opts();
     let remote = opts.remote;
     if (!remote) {
@@ -11602,16 +11741,81 @@ function registerAuthCommands(program2) {
   });
 }
 
+// src/lib/login-report.ts
+async function reportLoginOutcome(out, opts = {}) {
+  const identity = out.email ?? (out.userId != null ? `user #${out.userId}` : "your account");
+  printInfo(`Logged in as ${identity}. \u2713`);
+  printInfo(`  Access granted to ${out.repoCount} ${out.repoCount === 1 ? "repository" : "repositories"}.`);
+  if (out.expiresAt) {
+    printInfo(`  This login expires on ${out.expiresAt.slice(0, 10)} \u2014 "verity login" again to renew.`);
+    printInfo('  See your machines with "verity sessions list"; sign out with "verity logout".');
+  }
+  if (out.repoCount > 0) {
+    printInfo("  Runs, history, and cloud memory now sync to Verity everywhere you have write access.");
+  }
+  if (out.prunedCredentials > 0) {
+    printVerbose(`Pruned ${out.prunedCredentials} superseded per-repository credential line(s).`, opts.verbose);
+  } else if (out.prunedCredentials < 0) {
+    printWarn("  Could not rewrite ~/.verity/credentials: superseded per-repository tokens remain and");
+    printWarn("  will keep taking precedence over this login in their own repositories.");
+    printInfo(`  Check the file's permissions; the next successful "verity login" retries the cleanup.`);
+  }
+  if (out.repoCount === 0) {
+    printWarn("The Verity GitHub App is not installed on any account you can access.");
+    printInfo("  Install it (and grant your repositories), then re-run verity login:");
+    printInfo(`  ${githubAppInstallUrl(null)}`);
+    return;
+  }
+  const remote = opts.remote;
+  if (!remote) return;
+  const who = await whoami(out.token, out.serviceUrl, opts.verbose);
+  if (who.ok && who.data.grant_status != null) {
+    printInfo("  \u2713 This repository is covered.");
+  } else if (!who.ok) {
+    printWarn(`  Could not confirm this repository's coverage (${who.error}) \u2014 verity status will show it.`);
+  } else {
+    const parsed = parseRemote(remote);
+    const installUrl = githubAppInstallUrl(parsed ? await githubAccountId(parsed.owner) : null);
+    printWarn(`  This repository (${parsed ? `${parsed.owner}/${parsed.repo}` : remote}) is NOT covered by your grants.`);
+    printInfo("  Grant the Verity GitHub App access to it, then re-run verity login:");
+    printInfo(`  ${installUrl}`);
+  }
+  const rec = await readGlobalCredential(remote);
+  if (rec && rec.token !== out.token) {
+    const otherBackend = rec.serviceUrl != null && rec.serviceUrl !== out.serviceUrl;
+    const otherIdentity = rec.userId != null && out.userId != null && rec.userId !== out.userId;
+    if (otherBackend) {
+      printWarn(`  Note: this repository is pinned to a different Verity service (${rec.serviceUrl})`);
+      printWarn("  by its own credential line, which takes precedence here \u2014 this login does not");
+      printWarn("  change that. To move the repository, remove its line from ~/.verity/credentials.");
+      printWarn('  Until that line is removed, "verity login" here cannot fast-path and will run');
+      printWarn("  the full GitHub flow every time.");
+    } else if (otherIdentity) {
+      printWarn("  Note: this repository uses a different account's credential, which takes");
+      printWarn('  precedence here \u2014 this login leaves it in place, and "verity login" in this');
+      printWarn("  repository will report that account. Remove its line from ~/.verity/credentials");
+      printWarn("  only if you want this repository on the login you just completed.");
+    } else {
+      const kind = rec.userId != null ? "superseded per-repository" : "anonymous project-specific";
+      printWarn(`  Note: this repository has a ${kind} credential that takes`);
+      printWarn("  precedence here. Remove its line from ~/.verity/credentials to use your login.");
+      printWarn('  Until then, "verity login" in this repository re-runs the full GitHub flow');
+      printWarn("  every time.");
+    }
+  }
+}
+
 // src/commands/login.ts
 function registerLoginCommand(program2) {
   program2.command("login").description("Log in to Verity (one GitHub login grants access to all your repositories)").option("--force", "Re-authenticate even if already logged in").action(async (opts) => {
     const globals = program2.opts();
-    const urlResult = await resolveServiceUrlDetailed(globals.serviceUrl);
-    if (!urlResult.ok) {
-      printError(urlResult.error);
-      process.exit(1);
+    const resolution = await resolveServiceUrlForAuth(globals.serviceUrl);
+    if (resolution.source === "default") {
+      printInfo(`No Verity service configured on this machine \u2014 using the default: ${resolution.url}`);
+    } else {
+      printVerbose(`Service URL from ${resolution.source}: ${resolution.url}`, globals.verbose);
     }
-    const heal = await maybeHealServiceUrl(urlResult.data, globals.verbose);
+    const heal = await maybeHealServiceUrl(resolution, globals.verbose);
     const serviceUrl = heal.serviceUrl;
     if (heal.healed) {
       printInfo("  Completing login updates ~/.verity/credentials against the live service.");
@@ -11627,13 +11831,19 @@ function registerLoginCommand(program2) {
       const who = await whoami(existing.data.token, serviceUrl, globals.verbose);
       if (who.ok && who.data.logged_in) {
         const nudge = reverifyNudge(who.data);
-        if (!nudge) {
+        const upgrade = await shouldUpgradeOnLogin(existing.data);
+        if (!nudge && !upgrade) {
           printInfo(`Already logged in as ${who.data.email ?? `user #${who.data.user_id}`}. \u2713`);
           printInfo("  Re-authenticate with: verity login --force");
           return;
         }
-        printWarn(nudge);
-        printInfo("Re-verifying your repository access\u2026");
+        if (nudge) {
+          printWarn(nudge);
+          printInfo("Re-verifying your repository access\u2026");
+        } else {
+          printInfo("You are signed in with a per-repository token (the old format).");
+          printInfo("  Upgrading to a single login that covers every repository you can write to\u2026");
+        }
       } else if (who.ok && who.data.anonymous) {
         printInfo("You have an anonymous token (the gate runs, but nothing is saved). Logging you in\u2026");
       } else if (!who.ok) {
@@ -11646,51 +11856,7 @@ function registerLoginCommand(program2) {
       printError(`Login failed: ${result.error}`);
       process.exit(1);
     }
-    const out = result.data;
-    const identity = out.email ?? (out.userId != null ? `user #${out.userId}` : "your account");
-    printInfo(`Logged in as ${identity}. \u2713`);
-    printInfo(`  Access granted to ${out.repoCount} ${out.repoCount === 1 ? "repository" : "repositories"}.`);
-    printInfo("  Runs, history, and cloud memory now sync to Verity everywhere you have write access.");
-    if (out.prunedCredentials > 0) {
-      printVerbose(`Pruned ${out.prunedCredentials} superseded per-repository credential line(s).`, globals.verbose);
-    } else if (out.prunedCredentials < 0) {
-      printWarn("  Could not rewrite ~/.verity/credentials: superseded per-repository tokens remain and");
-      printWarn("  will keep taking precedence over this login in their own repositories.");
-      printInfo(`  Check the file's permissions; the next successful "verity login" retries the cleanup.`);
-    }
-    if (out.repoCount === 0) {
-      printWarn("The Verity GitHub App is not installed on any account you can access.");
-      printInfo(`  Install it (and grant your repositories), then re-run verity login:`);
-      printInfo(`  ${githubAppInstallUrl(null)}`);
-      return;
-    }
-    if (remote) {
-      const who = await whoami(out.token, out.serviceUrl, globals.verbose);
-      if (who.ok && who.data.grant_status != null) {
-        printInfo("  \u2713 This repository is covered.");
-      } else if (!who.ok) {
-        printWarn(`  Could not confirm this repository's coverage (${who.error}) \u2014 verity status will show it.`);
-      } else {
-        const parsed = parseRemote(remote);
-        const installUrl = githubAppInstallUrl(parsed ? await githubAccountId(parsed.owner) : null);
-        printWarn(`  This repository (${parsed ? `${parsed.owner}/${parsed.repo}` : remote}) is NOT covered by your grants.`);
-        printInfo("  Grant the Verity GitHub App access to it, then re-run verity login:");
-        printInfo(`  ${installUrl}`);
-      }
-      const rec = await readGlobalCredential(remote);
-      if (rec && rec.token !== out.token) {
-        const otherBackend = rec.serviceUrl != null && rec.serviceUrl !== out.serviceUrl;
-        if (otherBackend) {
-          printWarn(`  Note: this repository is pinned to a different Verity service (${rec.serviceUrl})`);
-          printWarn("  by its own credential line, which takes precedence here \u2014 this login does not");
-          printWarn("  change that. To move the repository, remove its line from ~/.verity/credentials.");
-        } else {
-          const kind = rec.userId != null ? "superseded per-repository" : "anonymous project-specific";
-          printWarn(`  Note: this repository has a ${kind} credential that takes`);
-          printWarn("  precedence here. Remove its line from ~/.verity/credentials to use your login.");
-        }
-      }
-    }
+    await reportLoginOutcome(result.data, { remote: remote || void 0, verbose: globals.verbose });
   });
 }
 
@@ -11809,6 +11975,205 @@ function registerTokenCommand(program2) {
   });
 }
 
+// src/commands/sessions.ts
+function shortDate(iso) {
+  return iso ? iso.slice(0, 10) : "\u2014";
+}
+function daysUntil(iso) {
+  if (!iso) return null;
+  const ms = Date.parse(iso);
+  if (Number.isNaN(ms)) return null;
+  return Math.round((ms - Date.now()) / 864e5);
+}
+async function auth(globals) {
+  const tokenResult = await resolveToken(globals.token);
+  if (!tokenResult.ok) {
+    printError(tokenResult.error);
+    process.exit(1);
+  }
+  const resolution = await resolveServiceUrlForAuth(globals.serviceUrl);
+  return {
+    token: tokenResult.data.token,
+    serviceUrl: resolution.url,
+    keyed: tokenResult.data.keyed === true
+  };
+}
+function explain(error) {
+  if (error.startsWith("FORBIDDEN")) {
+    printInfo('  Sessions belong to a logged-in account \u2014 run "verity login" first.');
+  } else if (error.startsWith("INVALID_TOKEN")) {
+    printInfo('  This login has expired or was revoked \u2014 run "verity login" to sign in again.');
+  }
+}
+async function logoutLocallyOnly(keyed) {
+  printWarn("Could not reach the Verity service to revoke this login (see above).");
+  const cleared = await removeGlobalCredential(keyed ? currentRemote() : "");
+  if (cleared) {
+    printInfo(keyed ? "This repository\u2019s Verity credential cleared \u2014 it is signed out. \u2713" : "Local login credential cleared \u2014 this machine is signed out. \u2713");
+    printInfo("  The session may still exist server-side; revoke it from another machine with");
+    printInfo('  "verity sessions revoke <session-id>" if that matters.');
+  } else {
+    printInfo("No local credential to clear \u2014 already signed out here.");
+  }
+}
+function isPinRefusal(error) {
+  return error.startsWith("TOKEN_PIN_REFUSED");
+}
+function registerSessionsCommands(program2) {
+  const sessions = program2.command("sessions").description("List and revoke your Verity logins (one per machine)");
+  sessions.command("list").description("List your active logins \u2014 device, last use, and expiry").option("--json", "Output raw JSON").action(async (opts) => {
+    const globals = program2.opts();
+    const { token, serviceUrl } = await auth(globals);
+    const result = await apiRequest({
+      method: "GET",
+      path: "/auth/sessions",
+      serviceUrl,
+      token,
+      verbose: globals.verbose,
+      cmd: "sessions"
+    });
+    if (!result.ok) {
+      printError(result.error);
+      explain(result.error);
+      process.exit(1);
+    }
+    if (opts.json) {
+      printJson(result.data);
+      return;
+    }
+    const list = result.data.sessions;
+    if (list.length === 0) {
+      printInfo('No active logins. (Run "verity login".)');
+      return;
+    }
+    printInfo(`${list.length} active login${list.length === 1 ? "" : "s"}:`);
+    printInfo("");
+    printInfo(`${"SESSION ID".padEnd(38)}${"DEVICE".padEnd(24)}${"CREATED".padEnd(12)}${"LAST USED".padEnd(12)}EXPIRES`);
+    for (const s of list) {
+      const days = daysUntil(s.expires_at);
+      const expiry = s.expires_at ? `${shortDate(s.expires_at)}${days != null ? ` (${days}d)` : ""}` : "never";
+      const device = (s.device ?? "login").slice(0, 22);
+      printInfo(
+        `${s.id.padEnd(38)}${device.padEnd(24)}${shortDate(s.created_at).padEnd(12)}${shortDate(s.last_used_at).padEnd(12)}${expiry}${s.current ? "   \u2190 this machine" : ""}`
+      );
+    }
+    printInfo("");
+    printInfo("Revoke one:  verity sessions revoke <session-id>");
+    printInfo("Sign out everywhere else:  verity logout --others");
+  });
+  sessions.command("revoke <session-id>").description("Revoke one login. Revoking this machine's also clears the local credential").action(async (sessionId) => {
+    const globals = program2.opts();
+    const { token, serviceUrl, keyed } = await auth(globals);
+    const result = await apiRequest({
+      method: "DELETE",
+      path: `/auth/sessions/${encodeURIComponent(sessionId)}`,
+      serviceUrl,
+      token,
+      verbose: globals.verbose,
+      cmd: "sessions-revoke"
+    });
+    if (!result.ok) {
+      printError(result.error);
+      if (result.http_status === 404) {
+        printInfo('  No session with that id on your account \u2014 check "verity sessions list".');
+      }
+      explain(result.error);
+      process.exit(1);
+    }
+    printInfo(`Session ${sessionId} revoked. \u2713`);
+    if (result.data.was_current) {
+      const cleared = await removeGlobalCredential(keyed ? currentRemote() : "");
+      printInfo(cleared ? '  That was this machine \u2014 local credential cleared. Run "verity login" to sign back in.' : '  That was this machine. Run "verity login" to sign back in.');
+    }
+  });
+}
+function registerLogoutCommand(program2) {
+  program2.command("logout").description("Sign out of Verity on this machine (--all / --others for every machine)").option("--all", "Revoke every login on every machine, including this one").option("--others", "Revoke every login EXCEPT this machine (e.g. a lost laptop)").action(async (opts) => {
+    const globals = program2.opts();
+    if (opts.all && opts.others) {
+      printError("Use either --all or --others, not both.");
+      process.exit(1);
+    }
+    const { token, serviceUrl, keyed } = await auth(globals);
+    if (opts.all || opts.others) {
+      const result = await apiRequest({
+        method: "DELETE",
+        path: opts.others ? "/auth/sessions?others=true" : "/auth/sessions",
+        serviceUrl,
+        token,
+        verbose: globals.verbose,
+        cmd: "logout"
+      });
+      if (!result.ok) {
+        if (isPinRefusal(result.error) && !opts.others) {
+          await logoutLocallyOnly(keyed);
+          return;
+        }
+        printError(result.error);
+        explain(result.error);
+        process.exit(1);
+      }
+      const n = result.data.revoked;
+      printInfo(`Revoked ${n} login${n === 1 ? "" : "s"}. \u2713`);
+      if (opts.others) {
+        printInfo("  This machine is still signed in.");
+        return;
+      }
+      const cleared2 = await removeGlobalCredential("");
+      if (cleared2) printInfo("  Local credential cleared.");
+      printInfo('  Run "verity login" to sign back in.');
+      return;
+    }
+    const list = await apiRequest({
+      method: "GET",
+      path: "/auth/sessions",
+      serviceUrl,
+      token,
+      verbose: globals.verbose,
+      cmd: "logout"
+    });
+    if (!list.ok) {
+      if (isPinRefusal(list.error)) {
+        await logoutLocallyOnly(keyed);
+        return;
+      }
+      printError(list.error);
+      explain(list.error);
+      process.exit(1);
+    }
+    const current = list.data.sessions.find((s) => s.current);
+    if (!current) {
+      printWarn(keyed ? "This repository uses its own Verity credential, not a machine login." : "This machine is not signed in with a Verity login.");
+      const cleared2 = await removeGlobalCredential(keyed ? currentRemote() : "");
+      if (cleared2) {
+        printInfo(keyed ? "  Cleared this repository\u2019s credential; your machine login is untouched." : "  Cleared the local login credential anyway.");
+      }
+      return;
+    }
+    const revoked = await apiRequest({
+      method: "DELETE",
+      path: `/auth/sessions/${current.id}`,
+      serviceUrl,
+      token,
+      verbose: globals.verbose,
+      cmd: "logout"
+    });
+    if (!revoked.ok) {
+      if (isPinRefusal(revoked.error)) {
+        await logoutLocallyOnly(keyed);
+        return;
+      }
+      printError(revoked.error);
+      explain(revoked.error);
+      process.exit(1);
+    }
+    const cleared = await removeGlobalCredential("");
+    printInfo("Signed out on this machine. \u2713");
+    if (cleared) printInfo("  Local credential cleared.");
+    printInfo('  Your other machines are unaffected \u2014 use "verity logout --all" for all of them.');
+  });
+}
+
 // src/lib/hooks.ts
 var import_promises4 = require("node:fs/promises");
 var import_node_path5 = require("node:path");
@@ -12430,7 +12795,7 @@ function getRecentCommitMessages() {
 // src/lib/context-identity.ts
 var import_node_crypto2 = require("node:crypto");
 var import_node_fs5 = require("node:fs");
-var import_node_os = require("node:os");
+var import_node_os2 = require("node:os");
 var import_node_path6 = require("node:path");
 var SHARED_SENTINELS = /* @__PURE__ */ new Set([
   "",
@@ -12485,7 +12850,7 @@ function contextIdentity(input) {
 }
 function verityHome() {
   const override = process.env.VERITY_HOME;
-  return override && override.trim() ? (0, import_node_path6.resolve)(override) : (0, import_node_path6.join)((0, import_node_os.homedir)(), ".verity");
+  return override && override.trim() ? (0, import_node_path6.resolve)(override) : (0, import_node_path6.join)((0, import_node_os2.homedir)(), ".verity");
 }
 function dossierDir(identity) {
   return (0, import_node_path6.join)(verityHome(), "sessions", identity.userKey, identity.treeKey, identity.sessionKey);
@@ -13331,6 +13696,143 @@ var import_node_fs10 = require("node:fs");
 var import_node_crypto5 = require("node:crypto");
 var import_node_path11 = require("node:path");
 
+// src/lib/skip-detection.ts
+function isBareAckPrompt(prompt) {
+  if (typeof prompt !== "string") return false;
+  const trimmed = prompt.trim();
+  if (trimmed.length === 0) return false;
+  if (trimmed.length > 20) return false;
+  const bareAckPattern = /^(\d{1,2}|y|n|yes|no|yep|nope|ok(ay)?|sure|skip|cancel|stop|done|noted|got\s+it|sounds\s+good|thanks|thank\s+you|thx)[.!?]*$/i;
+  return bareAckPattern.test(trimmed);
+}
+function isContinuationPrompt(prompt) {
+  if (typeof prompt !== "string") return false;
+  const trimmed = prompt.trim();
+  if (trimmed.length === 0) return false;
+  if (trimmed.length > 24) return false;
+  const continuation = /^(let['’]?s\s+(go|do\s+it|start|continue)|go|go\s+ahead|go\s+on|proceed|continue|carry\s+on|keep\s+going|do\s+it|make\s+it\s+so|next|start|begin|ship\s+it|yes\s+please|please\s+continue|perfect|great|nice|excellent|agreed)[.!]*$/i;
+  return continuation.test(trimmed) || isBareAckPrompt(trimmed);
+}
+function resolveGoalPrompt(prompts) {
+  if (prompts.length === 0) return null;
+  const latest = prompts[prompts.length - 1];
+  if (!isContinuationPrompt(latest.prompt)) return { entry: latest, turnsBack: 0 };
+  for (let i = prompts.length - 2; i >= 0; i--) {
+    if (!isContinuationPrompt(prompts[i].prompt)) {
+      return { entry: prompts[i], turnsBack: prompts.length - 1 - i };
+    }
+  }
+  return { entry: latest, turnsBack: 0 };
+}
+function isReflectionQuestion(response) {
+  if (!response || typeof response !== "string") return false;
+  const markers = [
+    /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,
+    // 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));
+}
+function isMetaTaskLabel(label2) {
+  if (label2 === null || label2 === void 0) return false;
+  if (typeof label2 !== "string") return false;
+  const trimmed = label2.trim();
+  if (trimmed.length === 0) return true;
+  const metaPatterns = [
+    /^verity\s+[\w-]+\s+response$/i,
+    // "Verity reflect response"
+    /^simple user response$/i,
+    /^verity\s+command$/i,
+    // "Verity command"
+    /^user\s+(question|reply|response|ack)$/i
+  ];
+  return metaPatterns.some((p) => p.test(trimmed));
+}
+function shouldSkipForBareAck(input) {
+  if (!isBareAckPrompt(input.prompt)) return false;
+  if (input.turnAuthoredCode) return false;
+  return input.canSeeTurnAuthorship;
+}
+
+// src/lib/pending-repeat.ts
+var STOP = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "that",
+  "this",
+  "with",
+  "from",
+  "have",
+  "been",
+  "were",
+  "what",
+  "when",
+  "which",
+  "their",
+  "there",
+  "these",
+  "those",
+  "would",
+  "could",
+  "should",
+  "must",
+  "will",
+  "also",
+  "just",
+  "only",
+  "into",
+  "over",
+  "than",
+  "then",
+  "them",
+  "some",
+  "such",
+  "more",
+  "most",
+  "other",
+  "about",
+  "after",
+  "before",
+  "since",
+  "because",
+  "while",
+  "where",
+  "whether",
+  "ensure",
+  "confirm",
+  "verify",
+  "check"
+]);
+function pendingTokens(text) {
+  if (!text || typeof text !== "string") return [];
+  const out = /* @__PURE__ */ new Set();
+  for (const raw of text.toLowerCase().split(/[^a-z0-9]+/)) {
+    if (raw.length <= 3) continue;
+    if (STOP.has(raw)) continue;
+    out.add(raw);
+  }
+  return [...out].sort();
+}
+var REPEAT_THRESHOLD = 0.3;
+function overlapCoefficient(a, b) {
+  if (a.length === 0 || b.length === 0) return 0;
+  const setB = new Set(b);
+  let shared = 0;
+  for (const t of a) if (setB.has(t)) shared++;
+  return shared / Math.min(a.length, b.length);
+}
+function isRepeatOfAny(text, priorFingerprints, threshold = REPEAT_THRESHOLD) {
+  const tokens = pendingTokens(text);
+  if (tokens.length === 0) return false;
+  return priorFingerprints.some((prior) => overlapCoefficient(tokens, prior) >= threshold);
+}
+
 // src/lib/dossier.ts
 var import_node_fs9 = require("node:fs");
 var import_node_crypto4 = require("node:crypto");
@@ -13339,6 +13841,7 @@ var MAX_LINE_BYTES = 4096;
 var MAX_GOAL_CHARS = 2e3;
 var GOAL_KEEP = 8;
 var GOAL_TOTAL_CAP = 32;
+var RECENT_PENDING_CAP = 20;
 var HASH_WIDTH = 16;
 var AUTHORED_CAP = 300;
 var NOT_MINE_CAP = 300;
@@ -13579,6 +14082,13 @@ function reduce(state, events, now) {
         });
         break;
       }
+      case "goal_delivered": {
+        const g = state.goal.find((x) => x.status === "active");
+        if (!g) break;
+        if (g.delivered) break;
+        g.delivered = { at: ev.at, seq: ev.seq, summary: ev.summary };
+        break;
+      }
       case "authored": {
         authoredEvents++;
         const e = byPath.get(ev.path) ?? {
@@ -13693,6 +14203,22 @@ function reduce(state, events, now) {
       }
       case "verdict": {
         state.meta.last_verdict_seq = ev.seq;
+        state.meta.channel = {
+          emittedLast: ev.emitted === true,
+          // Reset by ANY movement, so the counter measures a standstill rather
+          // than session length.
+          consecutiveIdle: ev.idle === false ? 0 : (state.meta.channel?.consecutiveIdle ?? 0) + 1
+        };
+        state.meta.last_adjudication = ev.intent_verdict ? { verdict: ev.intent_verdict, score: ev.intent_score ?? null, at: ev.at, decision: ev.decision } : void 0;
+        if (Array.isArray(ev.pending_sigs) && ev.pending_sigs.length > 0) {
+          const prior = state.meta.recent_pending_sigs ?? [];
+          state.meta.recent_pending_sigs = [...prior, ...ev.pending_sigs].slice(-RECENT_PENDING_CAP);
+        }
+        if (ev.intent_sig) {
+          state.meta.intent_repeat = state.meta.intent_repeat && state.meta.intent_repeat.sig === ev.intent_sig ? { sig: ev.intent_sig, consecutive: state.meta.intent_repeat.consecutive + 1 } : { sig: ev.intent_sig, consecutive: 1 };
+        } else {
+          state.meta.intent_repeat = void 0;
+        }
         state.meta.watermark = {
           sha: ev.head_sha,
           reviewed_hash: ev.watermark_sha,
@@ -13778,7 +14304,12 @@ function compactState(s) {
   const ms = (iso) => Date.parse(iso) || 0;
   return {
     v: 1,
-    g: s.goal.map((g) => [g.seq, ms(g.at), g.hash, g.superseded_by, g.text ?? 0, g.text_len ?? 0, g.source ?? 0, g.status ?? 0, g.repeats ?? 0, g.truncated ? 1 : 0, g.collapsed ? 1 : 0]),
+    // ⚠ APPEND-ONLY POSITIONALLY. Indices 11-13 carry `delivered`; a cache row
+    // written before it existed has length 11 and expands with `delivered`
+    // absent, which is the correct reading of "nothing had been delivered yet".
+    // Inserting rather than appending would silently re-interpret every existing
+    // cached row.
+    g: s.goal.map((g) => [g.seq, ms(g.at), g.hash, g.superseded_by, g.text ?? 0, g.text_len ?? 0, g.source ?? 0, g.status ?? 0, g.repeats ?? 0, g.truncated ? 1 : 0, g.collapsed ? 1 : 0, g.delivered ? ms(g.delivered.at) : 0, g.delivered?.seq ?? 0, g.delivered?.summary ?? 0]),
     a: s.authored?.map((a) => [a.path, a.origin, a.edits, a.hunks, a.adds, a.dels, a.hash_now, a.hash_at_last_verdict, a.first_seq, a.last_seq]) ?? null,
     n: s.not_mine?.map((n) => [n.path, n.reason, ms(n.at), n.head_sha]) ?? null,
     t: s.statements.map((x) => [x.anchor_key, x.file, x.line, x.pattern_id, x.title_hash, x.register, x.line_sha, x.said_at_seq, ms(x.said_at), x.outcome, x.outcome_at ? ms(x.outcome_at) : 0, x.repeats, x.carried ? 1 : 0]),
@@ -13824,7 +14355,14 @@ function expandState(raw) {
         ...x[7] ? { status: x[7] } : {},
         ...x[8] ? { repeats: x[8] } : {},
         ...x[9] ? { truncated: true } : {},
-        ...x[10] ? { collapsed: true } : {}
+        ...x[10] ? { collapsed: true } : {},
+        ...x[11] ? {
+          delivered: {
+            at: iso(x[11]),
+            seq: x[12] ?? 0,
+            summary: x[13] || ""
+          }
+        } : {}
       })),
       authored: decodedAuthored,
       // The cache stores the BOUNDED list, so this is the bounded list too. That
@@ -13900,12 +14438,12 @@ function readFoldCache(d) {
     if (!(0, import_node_fs9.existsSync)(d.foldPath)) return null;
     const raw = JSON.parse((0, import_node_fs9.readFileSync)(d.foldPath, "utf8"));
     if (raw?.v !== 1) return null;
-    const cached = expandState(raw);
-    if (!cached?.meta) return null;
+    const cached2 = expandState(raw);
+    if (!cached2?.meta) return null;
     const size = (0, import_node_fs9.existsSync)(d.eventsPath) ? (0, import_node_fs9.statSync)(d.eventsPath).size : 0;
     const rotations = (0, import_node_fs9.existsSync)(d.rotatedDir) ? (0, import_node_fs9.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).length : 0;
-    if (cached.meta.upto_offset !== size || cached.meta.rotations !== rotations) return null;
-    return cached;
+    if (cached2.meta.upto_offset !== size || cached2.meta.rotations !== rotations) return null;
+    return cached2;
   } catch {
     return null;
   }
@@ -14038,9 +14576,18 @@ function projectMemory(state, opts) {
       seq: active.seq,
       superseded,
       truncated: active.truncated === true,
-      collapsed: state.meta.collapsed.goal ?? 0
+      collapsed: state.meta.collapsed.goal ?? 0,
+      ...active.delivered && { delivered: active.delivered }
     };
   }
+  if (opts.capture) {
+    const missed = Math.max(0, opts.capture.seen - opts.capture.captured);
+    p.capture = { seen: opts.capture.seen, captured: opts.capture.captured, missed };
+  }
+  if (state.meta.last_adjudication) {
+    const a = state.meta.last_adjudication;
+    p.last_adjudication = { verdict: a.verdict, score: a.score, at: a.at };
+  }
   const ageOf = (seq, carried) => carried ? "carried" : seq > lastVerdictSeq ? "this_turn" : "this_session";
   if (opts.spoken.length > 0) {
     p.statements = opts.spoken.map((s) => ({
@@ -14283,7 +14830,8 @@ function recall(d, input) {
     continuity,
     spoken: reanchored.spoken,
     refused: reanchored.dropped.length,
-    lastVerdictSeq
+    lastVerdictSeq,
+    ...input.capture && { capture: input.capture }
   });
   return {
     state: effective,
@@ -14394,7 +14942,19 @@ function sessionDossier(token, sessionId) {
   const d = openDossier(identity);
   return d ? { d, identity } : null;
 }
+function hasActiveGoal(d) {
+  try {
+    if (!(0, import_node_fs10.existsSync)(d.eventsPath)) return false;
+    return (0, import_node_fs10.readFileSync)(d.eventsPath, "utf8").includes('"k":"goal"');
+  } catch {
+    return false;
+  }
+}
 function recordGoal(d, prompt, source = "prompt") {
+  if (source === "prompt" && isContinuationPrompt(prompt) && hasActiveGoal(d)) {
+    appendEvent(d, { k: "goal_continue", text: prompt.slice(0, 64) });
+    return;
+  }
   const text = prompt.slice(0, MAX_GOAL_CHARS);
   appendEvent(d, {
     k: "goal",
@@ -14466,6 +15026,10 @@ function toStatus(n) {
 }
 function recordVerdict(d, v) {
   const root = repoRoot();
+  if (v.intent?.verdict === "aligned") {
+    const summary = (v.intent.implemented ?? "").trim().slice(0, 400);
+    if (summary) appendEvent(d, { k: "goal_delivered", summary });
+  }
   const lines = /* @__PURE__ */ new Map();
   for (const f of v.findings) {
     if (!f.file || typeof f.line !== "number" || !f.pattern_id) continue;
@@ -14493,15 +15057,39 @@ function recordVerdict(d, v) {
       line_sha: at !== void 0 ? lineSha(at) : null
     });
   }
+  const foldedNow = foldDossier(d);
+  const sig = intentSignature(v.intent, {
+    goalSeq: foldedNow.goal.find((g) => g.status === "active")?.seq ?? 0,
+    idle: v.idle !== false
+  });
   appendEvent(d, {
     k: "verdict",
     run_id: v.runId,
     head_sha: getCurrentCommit(),
     watermark_sha: v.watermarkSha,
     branch: v.branch,
-    decision: v.decision
+    decision: v.decision,
+    ...sig && { intent_sig: sig },
+    // Fingerprints of the pending items this verdict delivered, so the NEXT turn
+    // can tell a repeat from a new requirement. Only recorded when the channel
+    // actually spoke — a silenced turn delivered nothing, so nothing was "said
+    // before" and labelling the next turn's items as repeats would be a lie.
+    ...v.emitted === true && v.pendingTexts && v.pendingTexts.length > 0 && {
+      pending_sigs: v.pendingTexts.slice(0, 8).map((t) => pendingTokens(t).slice(0, 16))
+    },
+    emitted: v.emitted === true,
+    idle: v.idle !== false,
+    ...v.intent?.verdict && { intent_verdict: v.intent.verdict },
+    ...typeof v.intent?.score === "number" && { intent_score: v.intent.score }
   });
 }
+function intentSignature(intent, ctx) {
+  if (!intent?.verdict) return null;
+  if (intent.verdict !== "misaligned" && intent.verdict !== "partial") return null;
+  const goal = ctx ? `g${ctx.goalSeq}` : "g?";
+  const moved = ctx?.idle === false ? "active" : "idle";
+  return `${intent.verdict}:${goal}:${moved}`;
+}
 function toRegister(severity) {
   switch (severity) {
     case "critical":
@@ -14537,7 +15125,9 @@ function recallMemory(d, identity, opts) {
     const state = foldDossier(d);
     const watermark = state.meta.watermark?.sha ?? null;
     const watermarkPaths = (state.authored ?? []).map((a) => a.path);
+    const captureCmp = typeof opts.userMessagesSeen === "number" ? { seen: opts.userMessagesSeen, captured: state.meta.goal_chain } : void 0;
     const r = recall(d, {
+      ...captureCmp && { capture: captureCmp },
       identity,
       currentSessionKey: opts.currentSessionKey,
       branchNow: getCurrentBranch(),
@@ -14794,6 +15384,8 @@ function collectCodeDelta(files, opts) {
   let totalSize = 0;
   let truncationReason = null;
   const droppedPaths = [];
+  const excluded = [];
+  const exclude = (path, reason) => excluded.push({ path, reason, stage: "collectCodeDelta", kind: "capacity" });
   for (const filepath of sorted) {
     if (result.length >= maxFiles) {
       truncationReason ??= "max_files";
@@ -14801,14 +15393,21 @@ function collectCodeDelta(files, opts) {
       continue;
     }
     const resolved = resolveFile(filepath);
-    if (!resolved) continue;
+    if (!resolved) {
+      exclude(filepath, "path-not-resolvable");
+      continue;
+    }
     let size;
     try {
       size = (0, import_node_fs11.statSync)(resolved).size;
     } catch {
+      exclude(filepath, "not-stattable");
+      continue;
+    }
+    if (size > maxFileBytes) {
+      exclude(filepath, `over-file-size-limit-${maxFileBytes}b`);
       continue;
     }
-    if (size > maxFileBytes) continue;
     if (totalSize + size > maxTotalBytes) {
       truncationReason ??= "max_total_bytes";
       const idx = sorted.indexOf(filepath);
@@ -14819,6 +15418,7 @@ function collectCodeDelta(files, opts) {
     try {
       content = (0, import_node_fs11.readFileSync)(resolved, "utf-8");
     } catch {
+      exclude(filepath, "not-readable");
       continue;
     }
     totalSize += size;
@@ -14832,10 +15432,14 @@ function collectCodeDelta(files, opts) {
     (sum, f) => sum + f.content.split("\n").length,
     0
   );
+  for (const path of droppedPaths) {
+    exclude(path, truncationReason === "max_files" ? "max-files-cap" : "max-total-bytes-cap");
+  }
   return {
     files: result,
     total_lines: totalLines,
     total_files: result.length,
+    excluded,
     ...truncationReason && {
       truncated: {
         reason: truncationReason,
@@ -15084,8 +15688,8 @@ function preImage(repoRelPath, baseline) {
     perBaseline = /* @__PURE__ */ new Map();
     preImageCache.set(baseline, perBaseline);
   }
-  const cached = perBaseline.get(repoRelPath);
-  if (cached) return cached;
+  const cached2 = perBaseline.get(repoRelPath);
+  if (cached2) return cached2;
   const resolved = resolvePreImage(repoRelPath, baseline);
   perBaseline.set(repoRelPath, resolved);
   return resolved;
@@ -15129,6 +15733,34 @@ ${addedLines}`,
   }
   return { diffs, has_baseline: true };
 }
+function absorbIntoBaseline(paths, sessionId) {
+  const baseline = readBaseline(sessionId);
+  if (!baseline || paths.length === 0) return 0;
+  const dir = sessionDir(sessionKey(baseline.session_id));
+  let adopted = 0;
+  const dirty = new Set(baseline.dirty_paths);
+  for (const p of paths) {
+    try {
+      const content = safeReadForMirror(projectPath(p));
+      if (content === null) continue;
+      const dest = mirrorPath(dir, p);
+      (0, import_node_fs13.mkdirSync)((0, import_node_path14.dirname)(dest), { recursive: true });
+      (0, import_node_fs13.writeFileSync)(dest, content);
+      dirty.add(p);
+      adopted++;
+    } catch {
+    }
+  }
+  if (adopted === 0) return 0;
+  try {
+    const updated = { ...baseline, dirty_paths: [...dirty] };
+    (0, import_node_fs13.writeFileSync)(manifestPath(dir), JSON.stringify(updated));
+    preImageCache.delete(baseline);
+  } catch {
+    return 0;
+  }
+  return adopted;
+}
 function changedSinceBaseline(repoRelPath, baseline) {
   const pre = preImage(repoRelPath, baseline);
   let current;
@@ -16005,40 +16637,40 @@ function narrowToRecent(files, sessionId) {
   });
   return recent.length > 0 ? recent : files;
 }
-function readIteration(currentCommit, _contentHash) {
-  if (!(0, import_node_fs15.existsSync)(ITERATION_FILE)) return 1;
+function readIterationState(currentCommit) {
+  if (!(0, import_node_fs15.existsSync)(ITERATION_FILE)) return { iteration: 1, fingerprint: null };
   try {
     const stored = (0, import_node_fs15.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);
-    if (isNaN(iter)) return 1;
-    if (storedCommit !== currentCommit) return 1;
+    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 1;
+      if (elapsed > 600) return { iteration: 1, fingerprint: null };
     }
-    return iter;
+    return { iteration: iter, fingerprint };
   } catch {
-    return 1;
+    return { iteration: 1, fingerprint: null };
   }
 }
-function checkMaxIterations(currentCommit, maxIterations = MAX_ITERATIONS, contentHash) {
-  const iteration = readIteration(currentCommit, contentHash);
-  if (iteration > maxIterations) {
-    writeIteration(1, currentCommit, contentHash);
-    return {
-      skip: `Max Verity iterations (${maxIterations}) reached \u2014 accepting to prevent infinite loop. Human review required before deploying.`,
-      iteration
-    };
-  }
-  return { skip: null, iteration };
+function findingsFingerprint(findings) {
+  const keys = findings.map((f) => `${String(f.pattern_id ?? "?")}|${String(f.file ?? "?")}`).filter((k) => k !== "?|?");
+  return [...new Set(keys)].sort().join(",");
 }
-function writeIteration(iteration, commit, _contentHash) {
+function isSameProblem(previous, current) {
+  if (!previous || !current) return false;
+  const prev = new Set(previous.split(","));
+  return current.split(",").some((k) => prev.has(k));
+}
+function writeIteration(iteration, commit, _contentHash, fingerprint) {
   (0, import_node_fs15.mkdirSync)(VERITY_DIR, { recursive: true });
   const ts = Math.floor(Date.now() / 1e3);
-  (0, import_node_fs15.writeFileSync)(ITERATION_FILE, `${iteration}:${commit}:${ts}`);
+  const fp = fingerprint ? `:${fingerprint}` : "";
+  (0, import_node_fs15.writeFileSync)(ITERATION_FILE, `${iteration}:${commit}:${ts}${fp}`);
 }
 
 // src/lib/static-analysis.ts
@@ -16287,7 +16919,7 @@ function resolveTaskContext(opts) {
 // src/lib/cli-version.ts
 function cliVersion() {
   try {
-    return true ? "0.28.1-experimental.dbd87b1" : "dev";
+    return true ? "0.28.1-experimental.e79117b" : "dev";
   } catch {
     return "dev";
   }
@@ -16381,10 +17013,26 @@ function cacheRequest(body) {
     (0, import_node_fs18.mkdirSync)(CACHE_DIR, { recursive: true });
     const suffix = (0, import_node_crypto9.randomBytes)(4).toString("hex");
     const filename = `pending-${Math.floor(Date.now() / 1e3)}-${suffix}.json`;
-    (0, import_node_fs18.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(body));
+    (0, import_node_fs18.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(redactRequest(body)));
   } catch {
   }
 }
+function redactRequest(body) {
+  const b = body ?? {};
+  const delta = b.code_delta ?? {};
+  const files = Array.isArray(delta.files) ? delta.files : [];
+  return {
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    undelivered: true,
+    total_files: files.length,
+    total_bytes: files.reduce(
+      (n, f) => n + (typeof f.content === "string" ? f.content.length : 0),
+      0
+    ),
+    // Paths only. A path is already visible in the repository; the content is not.
+    files: files.map((f) => typeof f.path === "string" ? f.path : "<unknown>").slice(0, 100)
+  };
+}
 function buildOfflineFallback(reason, staticResults) {
   return {
     // G12 / INV-18 — WARN, not PASS.
@@ -16512,6 +17160,16 @@ var KNOWN_RECORD_TYPES = /* @__PURE__ */ new Set([
   "subagent"
 ]);
 var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "NotebookEdit", "MultiEdit"]);
+var DISPATCH_TOOLS = /* @__PURE__ */ new Set(["Task", "Workflow"]);
+function hasUserText(record) {
+  const message = record.message;
+  const content = message?.content ?? record.content;
+  if (typeof content === "string") return content.trim().length > 0;
+  if (!Array.isArray(content)) return false;
+  return content.some(
+    (b) => b?.type === "text" && typeof b.text === "string" && b.text.trim().length > 0
+  );
+}
 var COMMAND_CLASSES = [
   [/\b(npm|yarn|pnpm|bun)\s+(run\s+)?test\b|\bvitest\b|\bjest\b|\bpytest\b|\bgo test\b/, "test"],
   [/\b(npm|yarn|pnpm|bun)\s+(run\s+)?build\b|\btsc\b|\bwebpack\b|\bcargo build\b/, "build"],
@@ -16601,8 +17259,8 @@ function commandShape(cmd) {
 var COMMAND_HEAD_CHARS = 80;
 var rootCandidateCache = /* @__PURE__ */ new Map();
 function candidateRoots(repoRoot2) {
-  const cached = rootCandidateCache.get(repoRoot2);
-  if (cached) return cached;
+  const cached2 = rootCandidateCache.get(repoRoot2);
+  if (cached2) return cached2;
   const norm = repoRoot2.replace(/\\/g, "/").replace(/\/+$/, "");
   const out = [norm];
   try {
@@ -16638,6 +17296,8 @@ function fold(transcriptPath, opts = {}) {
       totalRecords: 0,
       malformed: 0,
       subagentFiles: 0,
+      dispatched: 0,
+      userMessages: 0,
       subagentSkipped: 0,
       compactions: 0,
       complete: false
@@ -16664,7 +17324,8 @@ function fold(transcriptPath, opts = {}) {
       if (type === "system" && record.subtype === "compact_boundary") {
         result.coverage.compactions++;
       }
-      collectFromRecord(record, owner, byPath, commandStats, pendingByToolUse, opts.repoRoot);
+      if (type === "user" && hasUserText(record)) result.coverage.userMessages++;
+      collectFromRecord(record, owner, byPath, commandStats, pendingByToolUse, opts.repoRoot, result.coverage);
     }
   };
   try {
@@ -16736,7 +17397,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, repoRoot2) {
+function collectFromRecord(record, owner, byPath, commandStats, pendingByToolUse, repoRoot2, tally) {
   const message = record.message;
   const content = message?.content ?? record.content;
   const blocks = Array.isArray(content) ? content : content && typeof content === "object" ? [content] : [];
@@ -16758,6 +17419,9 @@ function collectFromRecord(record, owner, byPath, commandStats, pendingByToolUse
           byPath.set(path, entry);
         }
       }
+      if (DISPATCH_TOOLS.has(name) && tally) {
+        tally.dispatched += 1;
+      }
       if (name === "Bash") {
         const cmd = typeof input.command === "string" ? input.command : "";
         if (cmd) {
@@ -16816,6 +17480,86 @@ function checkConservation(changedFiles, result, repoRoot2) {
   };
 }
 
+// src/lib/verdict.ts
+function reconcileCoverage(changed, coverage) {
+  const changedSet = new Set(changed);
+  const reviewed = coverage.reviewed.filter((p) => changedSet.has(p));
+  const claimed = /* @__PURE__ */ new Set([...reviewed, ...coverage.notReviewed.map((n) => n.path)]);
+  const unaccounted = [...changedSet].filter((p) => !claimed.has(p)).sort();
+  const notReviewed = [
+    ...coverage.notReviewed.filter((n) => changedSet.has(n.path)),
+    ...unaccounted.map((path) => ({
+      path,
+      reason: "unaccounted",
+      // Named so the eventual bug report writes itself: some stage removed this
+      // path and did not say so.
+      stage: "unknown-stage",
+      // An undeclared drop is CAPACITY by default. A stage that cannot be
+      // bothered to say why it dropped a file does not get the benefit of the
+      // doubt — that default is what makes forgetting expensive.
+      kind: "capacity"
+    }))
+  ];
+  return {
+    coverage: { reviewed: [...new Set(reviewed)].sort(), notReviewed },
+    unaccounted,
+    balances: unaccounted.length === 0
+  };
+}
+function resolveVerdict(proposed, coverage) {
+  if (proposed === "FAIL") return "FAIL";
+  const blocking = coverage.notReviewed.filter((n) => (n.kind ?? "capacity") !== "policy");
+  if (blocking.length === 0) return proposed;
+  return "WARN";
+}
+function describeCoverage(coverage, maxPaths = 5) {
+  const relevant = coverage.notReviewed.filter((n) => (n.kind ?? "capacity") !== "policy");
+  if (relevant.length === 0) return null;
+  const byReason = /* @__PURE__ */ new Map();
+  for (const n of relevant) {
+    const key = `${n.reason}`;
+    const list = byReason.get(key) ?? [];
+    list.push(n.path);
+    byReason.set(key, list);
+  }
+  const lines = [];
+  for (const [reason, paths] of [...byReason.entries()].sort()) {
+    const shown = paths.slice(0, maxPaths).join(", ");
+    const more = paths.length > maxPaths ? ` (+${paths.length - maxPaths} more)` : "";
+    lines.push(`  ${paths.length} not reviewed \u2014 ${reason}: ${shown}${more}`);
+  }
+  return `NOT A CLEAN REVIEW. ${relevant.length} changed file(s) never reached the reviewer, so this verdict does not cover them:
+${lines.join("\n")}
+Treat those files as UNCHECKED, not as approved.`;
+}
+function openBlockingElsewhere(statements, reviewedNow, lineShaAt) {
+  const reviewed = new Set(reviewedNow);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const s of statements) {
+    if (s.outcome !== "open") continue;
+    if (s.register !== "BLOCK") continue;
+    if (s.carried) continue;
+    if (reviewed.has(s.file)) continue;
+    if (!s.line_sha) continue;
+    if (lineShaAt(s.file, s.line) !== s.line_sha) continue;
+    const key = `${s.file}::${s.pattern_id}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ file: s.file, line: s.line, pattern_id: s.pattern_id });
+  }
+  return out;
+}
+function describeOpenElsewhere(open) {
+  if (open.length === 0) return null;
+  const lines = open.slice(0, 5).map((o) => `  ${o.file}:${o.line} [${o.pattern_id}]`);
+  const more = open.length > 5 ? `
+  (+${open.length - 5} more)` : "";
+  return `STILL OPEN ELSEWHERE. ${open.length} blocking finding(s) Verity raised earlier are still present in files this run did not review:
+${lines.join("\n")}${more}
+This verdict covers the current change only. The tree is not clean.`;
+}
+
 // src/lib/channel.ts
 var MAX_AGENT_CONTEXT_CHARS = 1500;
 var MAX_AGENT_ITEMS = 5;
@@ -16838,9 +17582,16 @@ function buildAgentContext(input) {
   }
   if (input.intentVerdict === "misaligned" || input.intentVerdict === "partial") {
     const gap = input.intentGaps?.[0];
-    lines.push(
-      `- This does not look like the change that was asked for` + (gap ? `: ${gap}` : ".") + " Not blocking \u2014 but check it against what you were asked to do."
-    );
+    const repeat = input.intentRepeat ?? 0;
+    if (repeat > 0) {
+      lines.push(
+        `- Same intent flag as the last ${repeat === 1 ? "turn" : `${repeat} turns`}, on a goal that has not changed. Nothing new here \u2014 do not relay or re-explain it again; either act on it or carry on.`
+      );
+    } else {
+      lines.push(
+        `- This does not look like the change that was asked for` + (gap ? `: ${gap}` : ".") + " Not blocking \u2014 but check it against what you were asked to do."
+      );
+    }
   }
   const agentFindings = (input.findings ?? []).filter((f) => f.scope !== "pre-existing");
   for (const f of agentFindings) {
@@ -16858,9 +17609,13 @@ function buildAgentContext(input) {
   }
   for (const p of input.pendingItems ?? []) {
     if (lines.length >= MAX_AGENT_ITEMS) break;
+    if (p.pattern_id === "intent-misalignment") continue;
     const text = p.description ?? p.title ?? p.reason;
     if (!text) continue;
-    lines.push(renderItem("", text, p.pattern_id, p.file, p.line));
+    const seenBefore = isRepeatOfAny(text, input.priorPendingFingerprints ?? []);
+    lines.push(
+      renderItem("", text, p.pattern_id, p.file, p.line) + (seenBefore ? "\n    (raised earlier this session and still open \u2014 do not re-explain it; act on it or carry on)" : "")
+    );
   }
   if (lines.length === 0) return null;
   const body = `${REPORT_PREFIX}
@@ -16887,6 +17642,47 @@ function buildHookOutput(gateDecision, systemMessage, agentContext) {
     } : {}
   };
 }
+var IDLE_EPISODE_CAP = 3;
+function channelSilence(input) {
+  const movedSomething = input.newUserPrompt || input.newAuthorship;
+  if (movedSomething) return null;
+  if (input.consecutiveIdle >= IDLE_EPISODE_CAP) return "idle-episode-cap";
+  if (input.emittedLast) return "caused-by-our-own-emission";
+  return null;
+}
+
+// src/lib/emit.ts
+var YELLOW2 = "\x1B[33m";
+var NC2 = "\x1B[0m";
+function emitVerdict(input) {
+  const exit = input.exit ?? ((code) => process.exit(code));
+  const { coverage, unaccounted } = reconcileCoverage(input.changed, input.coverage);
+  let verdict = resolveVerdict(input.proposed, coverage);
+  const openElsewhere = input.openElsewhere ?? [];
+  if (verdict === "PASS" && openElsewhere.length > 0) verdict = "WARN";
+  const note = [describeCoverage(coverage), describeOpenElsewhere(openElsewhere)].filter(Boolean).join("\n\n") || null;
+  if (unaccounted.length > 0) {
+    process.stderr.write(
+      `${YELLOW2}Verity: ${unaccounted.length} changed file(s) could not be attributed to any review stage \u2014 counted as unreviewed.${NC2}
+`
+    );
+  }
+  if (verdict === "FAIL") {
+    input.renderBlocking?.();
+    if (input.agentContext) {
+      process.stderr.write(`
+${input.agentContext}
+`);
+    }
+    if (note && !input.silenced) process.stderr.write(`
+${YELLOW2}${note}${NC2}
+`);
+    return exit(2);
+  }
+  const agentBlock = input.silenced ? null : [input.agentContext, note].filter(Boolean).join("\n\n") || null;
+  printJsonCompact(buildHookOutput(verdict, input.userSummary, agentBlock));
+  return exit(0);
+}
 
 // src/lib/cache-cleanup.ts
 var import_node_fs21 = require("node:fs");
@@ -16969,6 +17765,13 @@ function isGitOnlyPrompt(prompt) {
   return true;
 }
 function reconcileAnalysisMode(predictedMode, signals) {
+  const mode = resolveAnalysisMode(predictedMode, signals);
+  if (mode !== "skip") return mode;
+  const windowIsOrphaned = signals.actionSummary?.transcript_windowed === "orphaned";
+  if (windowIsOrphaned && !signals.sessionAuthoredCode) return "standard";
+  return mode;
+}
+function resolveAnalysisMode(predictedMode, signals) {
   if (!predictedMode || !isValidMode(predictedMode)) {
     return detectAnalysisMode(
       signals.noFilesChanged,
@@ -17067,46 +17870,6 @@ function shouldWarmRetryAnalyze(result) {
   return false;
 }
 
-// src/lib/skip-detection.ts
-function isBareAckPrompt(prompt) {
-  if (typeof prompt !== "string") return false;
-  const trimmed = prompt.trim();
-  if (trimmed.length === 0) return false;
-  if (trimmed.length > 20) return false;
-  const bareAckPattern = /^(\d{1,2}|y|n|yes|no|yep|nope|ok(ay)?|sure|skip|cancel|stop|done|noted|got\s+it|sounds\s+good|thanks|thank\s+you|thx)[.!?]*$/i;
-  return bareAckPattern.test(trimmed);
-}
-function isReflectionQuestion(response) {
-  if (!response || typeof response !== "string") return false;
-  const markers = [
-    /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,
-    // 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));
-}
-function isMetaTaskLabel(label2) {
-  if (label2 === null || label2 === void 0) return false;
-  if (typeof label2 !== "string") return false;
-  const trimmed = label2.trim();
-  if (trimmed.length === 0) return true;
-  const metaPatterns = [
-    /^verity\s+[\w-]+\s+response$/i,
-    // "Verity reflect response"
-    /^simple user response$/i,
-    /^verity\s+command$/i,
-    // "Verity command"
-    /^user\s+(question|reply|response|ack)$/i
-  ];
-  return metaPatterns.some((p) => p.test(trimmed));
-}
-
 // src/lib/transcript.ts
 var import_node_fs22 = require("node:fs");
 var MAX_READ_BYTES = 256 * 1024;
@@ -17120,9 +17883,11 @@ var MAX_SUMMARY_BYTES = 4096;
 var HOME = process.env.HOME ?? "";
 async function extractActionSummary(transcriptPath) {
   try {
-    const lines = readTurnLines(transcriptPath);
-    if (!lines || lines.length === 0) return null;
-    return buildSummary(lines);
+    const read = readTurnLines(transcriptPath);
+    if (!read || read.lines.length === 0) return null;
+    const summary = buildSummary(read.lines);
+    if (summary) summary.transcript_windowed = read.window;
+    return summary;
   } catch {
     return null;
   }
@@ -17136,9 +17901,11 @@ function readTurnLines(transcriptPath) {
   }
   if (size === 0) return null;
   let raw;
+  let windowed = false;
   if (size <= SMALL_FILE_BYTES) {
     raw = (0, import_node_fs22.readFileSync)(transcriptPath, "utf-8");
   } else {
+    windowed = true;
     const buf = Buffer.alloc(Math.min(MAX_READ_BYTES, size));
     const fd = require("node:fs").openSync(transcriptPath, "r");
     try {
@@ -17156,17 +17923,22 @@ function readTurnLines(transcriptPath) {
   const allLines = raw.split("\n").filter((l) => l.trim().length > 0);
   if (allLines.length === 0) return null;
   let turnStart = 0;
+  let boundaryFound = false;
   for (let i = allLines.length - 1; i >= 0; i--) {
     try {
       const parsed = JSON.parse(allLines[i]);
       if (parsed.type === "user" && isRealUserMessage(parsed)) {
         turnStart = i;
+        boundaryFound = true;
         break;
       }
     } catch {
     }
   }
-  return allLines.slice(turnStart);
+  return {
+    lines: allLines.slice(turnStart),
+    window: !windowed ? "whole" : boundaryFound ? "windowed" : "orphaned"
+  };
 }
 function isRealUserMessage(parsed) {
   const message = parsed.message;
@@ -17270,6 +18042,13 @@ function buildSummary(lines) {
     files_read: capArray(filesRead, MAX_FILES_LIST),
     files_edited: capArray(filesEdited, MAX_FILES_LIST),
     files_created: capArray(filesCreated, MAX_CREATED_LIST),
+    // The complement of the two caps that affect SCOPE. `files_read` is excluded
+    // deliberately: reading a file is not authoring it, so a capped read list
+    // narrows nothing.
+    capped_out: [
+      ...cappedOut(filesEdited, MAX_FILES_LIST),
+      ...cappedOut(filesCreated, MAX_CREATED_LIST)
+    ],
     searches,
     commands,
     subagents,
@@ -17320,6 +18099,9 @@ function sanitizeCommand(rawCmd) {
 function capArray(set, max) {
   return Array.from(set).slice(0, max);
 }
+function cappedOut(set, max) {
+  return Array.from(set).slice(max);
+}
 
 // src/lib/run-mode.ts
 function parseAutonomousEnv(raw) {
@@ -17714,10 +18496,12 @@ async function readStopHookStdin() {
     return empty;
   }
 }
-function agentContextFor(response) {
+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 ?? [],
@@ -17728,12 +18512,45 @@ function agentContextFor(response) {
   });
 }
 var beaconCtx = null;
-async function passAndExit(reason, skip) {
+async function passAndExit(reason, skip, kindOverride) {
   const sent = await sendSkipBeacon(beaconCtx, skip);
   logEvent("skip", { reason: skip, beacon: sent });
-  printJsonCompact({ gate_decision: "PASS", systemMessage: `Verity: ${reason}` });
+  const POLICY_SKIPS = /* @__PURE__ */ new Set([
+    "no-analyzable-files",
+    "verity-command",
+    "bare-acknowledgment",
+    "reflection-prompt",
+    "skip-mode",
+    "zero-increment",
+    "debounce",
+    "no-delta-since-last-review"
+  ]);
+  const skipKind = kindOverride ?? (POLICY_SKIPS.has(skip) ? "policy" : "capacity");
+  const changed = skipCoverageChanged;
+  const { coverage, unaccounted } = reconcileCoverage(changed, {
+    reviewed: [],
+    notReviewed: changed.map((path) => ({ path, reason: skip, stage: "pre-flight", kind: skipKind }))
+  });
+  const verdict = resolveVerdict("PASS", coverage);
+  const note = describeCoverage(coverage);
+  if (unaccounted.length > 0) {
+    logEvent("coverage_unaccounted", { where: "passAndExit", skip, count: unaccounted.length });
+  }
+  const AGENT_SILENT_SKIPS = /* @__PURE__ */ new Set([]);
+  const agentNote = AGENT_SILENT_SKIPS.has(skip) ? null : note;
+  printJsonCompact(
+    buildHookOutput(
+      verdict,
+      `Verity: ${reason}`,
+      // The agent's ONLY input is additionalContext. Sixteen of the nineteen
+      // terminating paths wrote `systemMessage` — the human's field — and told
+      // the agent nothing at all.
+      agentNote
+    )
+  );
   process.exit(0);
 }
+var skipCoverageChanged = [];
 var EMPTY_STATIC = {
   tool: "@codacy/analysis-cli",
   findings: [],
@@ -17748,7 +18565,7 @@ function runLocalStatic(analyzable, securityFiles, baseline, skipStatic) {
 }
 function localOnlyAndExit(staticResults) {
   printJsonCompact({
-    gate_decision: "PASS",
+    gate_decision: "WARN",
     systemMessage: "Verity: not authenticated \u2014 ran a local static-only check (no deep review, no upload). Run `verity init` to authenticate and enable the full quality gate.",
     unauthenticated: true,
     static_results: staticResults
@@ -17808,6 +18625,7 @@ async function runAnalyze(opts, globals) {
     });
   }
   const { files: allChanged, hasRecentCommitFiles } = getChangedFiles();
+  skipCoverageChanged = allChanged;
   const analyzable = filterAnalyzable(allChanged);
   const reviewable = filterReviewable(allChanged);
   const securityFiles = filterSecurity(allChanged);
@@ -17819,15 +18637,27 @@ async function runAnalyze(opts, globals) {
   const conversation = await readAndClearConversationBuffer(baselineSessionId);
   const specs = discoverSpecs();
   const plans = discoverPlans();
+  const agentAuthoredCodeThisTurn = !!(actionSummary && (actionSummary.files_edited.length > 0 || actionSummary.files_created.length > 0));
+  const turnAuthoredCode = agentAuthoredCodeThisTurn || !!baseline && allForReview.some((f) => changedSinceBaseline(f, baseline));
+  const authorshipIsObservable = !!actionSummary && actionSummary.transcript_windowed !== "orphaned" || !!baseline;
+  const canSeeTurnAuthorship = authorshipIsObservable;
+  let earlyFold = null;
   const latestPrompt = conversation?.prompts?.[conversation.prompts.length - 1]?.prompt ?? "";
   if (/^\s*\/verity-/i.test(latestPrompt)) {
+    const setupAuthored = [
+      ...actionSummary?.files_edited ?? [],
+      ...actionSummary?.files_created ?? []
+    ];
+    if (setupAuthored.length > 0) {
+      const adopted = absorbIntoBaseline(setupAuthored, baselineSessionId);
+      logEvent("baseline_absorbed", { skip: "verity-command", offered: setupAuthored.length, adopted });
+    }
     await passAndExit("Verity command \u2014 skipping analysis", "verity-command");
   }
-  if (isBareAckPrompt(latestPrompt)) {
+  if (shouldSkipForBareAck({ prompt: latestPrompt, turnAuthoredCode, canSeeTurnAuthorship })) {
     await passAndExit("Bare acknowledgment \u2014 skipping analysis", "bare-acknowledgment");
   }
-  const agentAuthoredCodeThisTurn = !!(actionSummary && (actionSummary.files_edited.length > 0 || actionSummary.files_created.length > 0));
-  if (isReflectionQuestion(assistantResponse) && !agentAuthoredCodeThisTurn) {
+  if (isReflectionQuestion(assistantResponse) && !turnAuthoredCode && canSeeTurnAuthorship) {
     await passAndExit("Reflection-prompt turn \u2014 skipping analysis", "reflection-prompt");
   }
   const urlResult = await resolveServiceUrl(globals.serviceUrl);
@@ -17873,7 +18703,11 @@ async function runAnalyze(opts, globals) {
     );
   }
   if (analysisMode === "skip") {
-    await passAndExit("Skip mode \u2014 no code work to analyze", "skip-mode");
+    await passAndExit(
+      "Skip mode \u2014 no code work to analyze",
+      "skip-mode",
+      turnAuthoredCode ? "capacity" : void 0
+    );
   }
   let staticResults = {
     tool: "@codacy/analysis-cli",
@@ -17883,7 +18717,8 @@ async function runAnalyze(opts, globals) {
   let codeDelta = {
     files: [],
     total_lines: 0,
-    total_files: 0
+    total_files: 0,
+    excluded: []
   };
   let snapshotResult = { has_snapshots: false, diffs: [] };
   let contentHash = null;
@@ -17924,10 +18759,43 @@ async function runAnalyze(opts, globals) {
       contentHash = hashResult.hash;
       if (analysisMode !== "plan") {
         const scoped = scopeToAuthored(allForReview, actionSummary);
-        if (scoped.signal === "none-authored" && !hasNonEditAuthorship(actionSummary, sessionAuthoredCode)) {
+        const canTrustNoneAuthored = scoped.signal === "none-authored" && authorshipIsObservable;
+        if (canTrustNoneAuthored && !hasNonEditAuthorship(actionSummary, sessionAuthoredCode)) {
           await passAndExit("No agent-authored code this turn \u2014 working-tree changes were not authored by this session", "zero-increment");
         }
-        const baseForReview = scoped.signal === "authored" && scoped.files.length > 0 ? scoped.files : allForReview;
+        if (scoped.signal === "none-authored" && !authorshipIsObservable) {
+          logEvent("none_authored_unverifiable", {
+            reason: "orphaned_window_no_baseline",
+            would_have_skipped: allForReview.length
+          });
+        }
+        const narrowingIsTrustworthy = scoped.signal === "authored" && scoped.files.length > 0 && actionSummary?.transcript_windowed !== "orphaned";
+        let recoveredScope = [];
+        if (!narrowingIsTrustworthy && transcriptPath) {
+          try {
+            earlyFold = fold(transcriptPath, { changedFiles: allForReview, repoRoot: repoRoot() });
+            const authoredWhole = new Set(earlyFold.authored.map((a) => a.p));
+            if (authoredWhole.size > 0) {
+              const root = repoRoot();
+              recoveredScope = allForReview.filter((f) => authoredWhole.has(toRepoRelative(f, root)));
+            }
+            logEvent("scope_recovered_from_fold", {
+              window_saw: scoped.files.length,
+              fold_saw: authoredWhole.size,
+              recovered: recoveredScope.length,
+              would_have_widened_to: allForReview.length
+            });
+          } catch {
+            earlyFold = null;
+          }
+        }
+        if (!narrowingIsTrustworthy && scoped.signal === "authored" && recoveredScope.length === 0) {
+          logEvent("scope_widened_orphaned_window", {
+            would_have_sent: scoped.files.length,
+            widened_to: allForReview.length
+          });
+        }
+        const baseForReview = narrowingIsTrustworthy ? scoped.files : recoveredScope.length > 0 ? recoveredScope : allForReview;
         const recentForReview = narrowToRecent(baseForReview, baselineSessionId);
         if (!opts.skipStatic && isCodacyAvailable()) {
           let allScannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles]));
@@ -17948,7 +18816,11 @@ async function runAnalyze(opts, globals) {
           if (assistantResponse) {
             analysisMode = "plan";
           } else {
-            await passAndExit("No files within size limits to analyze", "size-limit");
+            await passAndExit(
+              "No files within size limits to analyze",
+              "size-limit",
+              codeDelta.excluded.length > 0 ? "capacity" : "policy"
+            );
           }
         }
       }
@@ -17961,19 +18833,13 @@ async function runAnalyze(opts, globals) {
         snapshotResult = generateSnapshotDiffs(codeDelta.files);
       }
       currentCommit = getCurrentCommit();
-      const maxIterations = parseInt(opts.maxIterations, 10);
-      const iterResult = checkMaxIterations(currentCommit, maxIterations, contentHash ?? void 0);
-      if (iterResult.skip) await passAndExit(iterResult.skip, "iteration-cap");
-      iteration = iterResult.iteration;
+      iteration = readIterationState(currentCommit).iteration;
     }
   }
   if (analysisMode === "plan") {
     recordAnalysisStart();
     currentCommit = getCurrentCommit();
-    const maxIterations = parseInt(opts.maxIterations, 10);
-    const iterResult = checkMaxIterations(currentCommit, maxIterations);
-    if (iterResult.skip) await passAndExit(iterResult.skip, "iteration-cap");
-    iteration = iterResult.iteration;
+    iteration = readIterationState(currentCommit).iteration;
   }
   const contextFiles = gatherContextFiles(contextFilePaths, codeDelta.files);
   for (const f of codeDelta.files) {
@@ -18040,7 +18906,7 @@ async function runAnalyze(opts, globals) {
   let foldConservation = null;
   if (transcriptPath) {
     try {
-      foldResult = fold(transcriptPath, { changedFiles: allForReview, repoRoot: repoRoot() });
+      foldResult = earlyFold ?? fold(transcriptPath, { changedFiles: allForReview, repoRoot: repoRoot() });
       foldConservation = checkConservation(allForReview, foldResult, repoRoot());
       if (!foldConservation.holds) {
         process.stderr.write(
@@ -18122,7 +18988,10 @@ async function runAnalyze(opts, globals) {
       priorState.capabilities
     );
     memory = recallMemory(memorySession.d, memorySession.identity, {
-      currentSessionKey: memorySession.identity.sessionKey
+      currentSessionKey: memorySession.identity.sessionKey,
+      // The independent witness. Only meaningful when a transcript was folded —
+      // otherwise it stays undefined and capture coverage reads as UNKNOWN.
+      ...foldResult && { userMessagesSeen: foldResult.coverage.userMessages }
     });
     if (memory && !memory.provenanceHolds) {
       process.stderr.write("Verity: working-memory provenance check failed \u2014 recall suppressed.\n");
@@ -18143,7 +19012,30 @@ async function runAnalyze(opts, globals) {
     hasUserPrompt: (conversation?.prompts?.length ?? 0) > 0,
     isTTY: process.stdout.isTTY === true
   });
+  const excludedByReason = {};
+  for (const e of codeDelta.excluded ?? []) {
+    excludedByReason[e.reason] = (excludedByReason[e.reason] ?? 0) + 1;
+  }
+  const coverageTelemetry = {
+    // git's whole answer, before ANY narrowing. The number that has never been sent.
+    changed_all: allChanged.length,
+    analyzable: analyzable.length,
+    reviewable: reviewable.length,
+    security: securityFiles.length,
+    // after the allowlist, before authorship scoping and the caps
+    for_review: allForReview.length,
+    // what actually reaches the reviewer
+    sent: codeDelta.files.length,
+    // the two silent narrowings, counted separately so they can be told apart
+    capped_out: actionSummary?.capped_out?.length ?? 0,
+    excluded: (codeDelta.excluded ?? []).length,
+    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
+  };
   const requestBody = {
+    coverage_telemetry: coverageTelemetry,
     static_results: staticResults,
     code_delta: codeDelta,
     changed_files: allForReview,
@@ -18201,6 +19093,25 @@ async function runAnalyze(opts, globals) {
       projection: {
         v: 1,
         authored: foldResult?.authored ?? [],
+        // ⚠ AUTHORED *SINCE THE LAST VERDICT* — a different question from `authored`.
+        //
+        // `authored` above is the fold of the session TRANSCRIPT, which is
+        // cumulative: on turn 3 it still lists the files turn 2 edited. The
+        // account's close-out reads it as "was this file edited since the
+        // statement was raised", and those are not the same set.
+        //
+        // Measured 2026-08-03 (shirt-seller): four real vulnerabilities were
+        // raised on the turn that wrote them, then marked `fixed` 36 seconds
+        // later by a SUMMARY turn that edited nothing — `authored` still said 2,
+        // the turn carried 0 findings, so "gone + file authored" resolved to
+        // fixed. The vulnerabilities were still on disk. A silent false `fixed`
+        // is worse than a false `open`: it retires the statement the Account
+        // exists to keep.
+        //
+        // `hash_at_last_verdict` is frozen at each verdict and `hash_now` tracks
+        // disk, so their inequality IS "changed since we last spoke" — already
+        // computed, already maintained by the divergence machinery.
+        authored_since_verdict: memorySession ? foldDossier(memorySession.d).authored_all.filter((a) => a.hash_now !== a.hash_at_last_verdict).map((a) => a.path) : [],
         unobserved: foldResult?.unobserved ?? [],
         commands: foldResult?.commands ?? [],
         unknown_types: foldResult?.unknownTypes ?? [],
@@ -18210,6 +19121,54 @@ async function runAnalyze(opts, globals) {
         // replaced a population floor with ≈35% power that was sub-integer for
         // three-quarters of the fleet.
         conservation: foldConservation,
+        // ⚠ VRT-52 — RECORDED, NOT APPLIED. The number nobody has.
+        //
+        // The whole "task-scoped delta" design space rests on an assumption that
+        // has been observed exactly ONCE: that delta files routinely belong to
+        // earlier work. Three designs were built on it and all three were killed
+        // adversarially — two by measurement — so before another is attempted,
+        // measure the base rate.
+        //
+        // `authored_under_earlier_goal` counts delta paths whose LAST authorship
+        // event precedes the seq of the goal now in force. Both numbers come from
+        // the same append-only counter (`nextSeq`), so the comparison is exact.
+        //
+        // Keyed on the GOAL, deliberately, not on the task id. The task classifier
+        // reported `is_new_task` on two consecutive turns of one task 25 seconds
+        // apart, so a task-keyed number would measure its unreliability rather
+        // than the phenomenon. And this only became meaningful once `recordGoal`
+        // stopped letting a bare "ok" supersede the goal — before that the seq
+        // advanced every turn and this would have degenerated to "not edited this
+        // turn", which is the exact mistake that sank one of the three designs.
+        //
+        // Changes no payload the reviewer sees, no narrowing, no verdict.
+        vrt52: (() => {
+          const goalSeq = memory?.projection.goal?.seq;
+          if (goalSeq === void 0 || !memorySession) return { known: false };
+          const lastSeq2 = new Map(
+            foldDossier(memorySession.d).authored_all.map((a) => [a.path, a.last_seq])
+          );
+          let earlier = 0;
+          let unknown = 0;
+          for (const f of codeDelta.files) {
+            const seen = lastSeq2.get(f.path);
+            if (seen === void 0) unknown++;
+            else if (seen < goalSeq) earlier++;
+          }
+          return {
+            known: true,
+            goal_seq: goalSeq,
+            delta: codeDelta.files.length,
+            // Files this delta carries that were last written under an EARLIER
+            // instruction. If this stays near zero, VRT-52's code half is
+            // unnecessary and should be closed saying so.
+            authored_under_earlier_goal: earlier,
+            // Delta files the dossier has no authorship record for at all —
+            // pre-existing tree state, or an authorship channel the fold cannot
+            // see. Reported separately so a blind spot is never counted as a zero.
+            no_authorship_record: unknown
+          };
+        })(),
         // P2 — RECORDED, NOT APPLIED. What this run WOULD have reviewed if it
         // narrowed to the within-session increment: what changed since the last
         // VERDICT rather than since task start.
@@ -18242,7 +19201,20 @@ async function runAnalyze(opts, globals) {
     const intentContext = {};
     if (conversation && conversation.prompts.length > 0) {
       const latest = conversation.prompts[conversation.prompts.length - 1];
-      intentContext.user_prompt = latest.prompt;
+      const goalPrompt = resolveGoalPrompt(conversation.prompts) ?? { entry: latest, turnsBack: 0 };
+      intentContext.user_prompt = goalPrompt.entry.prompt;
+      if (isContinuationPrompt(intentContext.user_prompt)) {
+        const carried = memory?.projection.goal?.text;
+        if (carried && !isContinuationPrompt(carried)) {
+          intentContext.continuation_prompt = latest.prompt;
+          intentContext.user_prompt = carried;
+          logEvent("goal_from_dossier", { chars: carried.length });
+        }
+      }
+      if (goalPrompt.turnsBack > 0) {
+        intentContext.continuation_prompt = latest.prompt;
+        logEvent("goal_walked_back", { turns_back: goalPrompt.turnsBack });
+      }
       intentContext.session_id = latest.session_id || void 0;
       intentContext.prompt_captured_at = latest.captured_at || void 0;
       if (conversation.prompts.length > 1) {
@@ -18318,6 +19290,8 @@ async function runAnalyze(opts, globals) {
       message = "Verity: your GitHub verification expired \u2014 run `verity login` to re-verify (local analysis this run)";
     } else if (result.error.startsWith("FORBIDDEN")) {
       message = "Verity: no access grant for this repository \u2014 run `verity login` to refresh your grants (local analysis this run)";
+    } else if (result.error.startsWith("INVALID_TOKEN")) {
+      message = "Verity: your login expired or was revoked \u2014 run `verity login` to sign in again (local analysis this run)";
     } else if (result.http_status && result.http_status >= 400 && result.http_status < 500) {
       message = `Verity: request rejected (HTTP ${result.http_status}) \u2014 ${result.error}`;
     } else if (result.http_status && result.http_status >= 500) {
@@ -18332,8 +19306,122 @@ async function runAnalyze(opts, globals) {
   const response = result.data;
   const decision = response.gate_decision ?? "(unrecognised)";
   const sentPaths = codeDelta.files.map((f) => f.path);
+  let openElsewhere = [];
+  if (memorySession) {
+    try {
+      const st = foldDossier(memorySession.d);
+      openElsewhere = openBlockingElsewhere(st.statements, sentPaths, (file, line) => {
+        try {
+          const src = (0, import_node_fs24.readFileSync)((0, import_node_path20.join)(repoRoot(), file), "utf8").split("\n");
+          const at = src[line - 1];
+          return at === void 0 ? null : lineSha(at);
+        } catch {
+          return null;
+        }
+      });
+    } catch {
+    }
+  }
+  const reviewCoverage = {
+    reviewed: sentPaths,
+    // Declared drops from the stages that DO report themselves today. The other
+    // stages surface via `unaccounted`, which is the tripwire, not the design.
+    notReviewed: [
+      // Every exit from the collection loop, each named. Six reasons where there
+      // used to be two recorded and four silent — the silent ones including the
+      // per-file size cap, which could drop a whole source file without leaving a
+      // trace anywhere in the payload or the run row.
+      ...codeDelta.excluded,
+      // The server-side 300-line middle-out truncation. It only bites on the
+      // full-file branch (a first analysis, before snapshots exist) because
+      // analyze normally sends diffs — but on that branch the reviewer sees the
+      // first and last 100 lines and nothing between, and until now said so to
+      // nobody. CAPACITY: a partial look is not a look.
+      ...(response.metadata?.truncated_files ?? []).map((path) => ({
+        path,
+        reason: "file-middle-truncated-300-lines",
+        stage: "prompt-builder",
+        kind: "capacity"
+      })),
+      // The 20-entry edit cap. CAPACITY, and the sharpest of the lot: it narrows
+      // what is REVIEWED, not merely what is summarised — a session editing 25
+      // files had five silently excluded from the reviewed set.
+      ...(actionSummary?.capped_out ?? []).map((path) => ({
+        path,
+        reason: "edit-list-cap-20",
+        stage: "extractActionSummary",
+        kind: "capacity"
+      })),
+      // ⚠ BASELINE SCOPING — the biggest source of false NOT A CLEAN REVIEW.
+      //
+      // The universe is `allChanged`, git's whole dirty tree. The reviewed set is
+      // scoped to what THIS SESSION authored (the VRT-26 contamination cure), so
+      // every pre-existing dirty file is in the universe, absent from `reviewed`,
+      // and — until now — declared by nobody. It fell through to `unaccounted`,
+      // became capacity, and produced "NOT A CLEAN REVIEW: admin.js" over a file
+      // that was never this session's to review.
+      //
+      // Measured 2026-08-04: three consecutive runs over an untouched tree gave
+      // three different answers — .claude/settings.json, then admin.js, then six
+      // files — because each run took a different path and each path had a
+      // different idea of the universe. POLICY: not this session's work is not a
+      // coverage gap, it is the cure working.
+      ...allChanged.filter((p) => !sentPaths.includes(p) && !codeDelta.excluded.some((e) => e.path === p)).filter((p) => analyzable.includes(p) || reviewable.includes(p) || securityFiles.includes(p)).map((path) => ({
+        path,
+        reason: "not-authored-this-session",
+        stage: "baseline-scoping",
+        kind: "policy"
+      })),
+      // The extension allowlist, and it is POLICY rather than capacity: a changed
+      // README was never going to be reviewed, and treating that as 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 — but it never touches the verdict.
+      ...allChanged.filter((p) => !analyzable.includes(p) && !reviewable.includes(p) && !securityFiles.includes(p)).map((path) => ({
+        path,
+        reason: "not-a-reviewed-file-type",
+        stage: "extension-allowlist",
+        kind: "policy"
+      }))
+    ]
+  };
   const watermarkHash = sentPaths.length > 0 ? computeContentHash(sentPaths) : contentHash;
   const watermarkIsPartial = !!codeDelta.truncated;
+  let silenced = null;
+  let turnIsIdleForChannel = true;
+  if (memorySession) {
+    try {
+      const st = foldDossier(memorySession.d);
+      turnIsIdleForChannel = st.authored_all.every((a) => a.hash_now === a.hash_at_last_verdict);
+      silenced = channelSilence({
+        // The BUFFER, not intentContext.user_prompt: the latter falls back to a
+        // linked issue (VRT-53 W4) when no human spoke, and a fallback goal is
+        // not a user utterance. Treating it as one would keep the loop alive on
+        // exactly the autonomous cohort.
+        newUserPrompt: (conversation?.prompts?.length ?? 0) > 0,
+        newAuthorship: !turnIsIdleForChannel,
+        emittedLast: st.meta.channel?.emittedLast === true,
+        consecutiveIdle: st.meta.channel?.consecutiveIdle ?? 0
+      });
+    } catch {
+      silenced = null;
+    }
+  }
+  if (silenced) {
+    logEvent("channel_silenced", {
+      reason: silenced,
+      run_id: response.run_id ?? turnId,
+      decision
+    });
+  }
+  let intentRepeatCount = 0;
+  const priorPendingFingerprints = memorySession ? (() => {
+    try {
+      return foldDossier(memorySession.d).meta.recent_pending_sigs ?? [];
+    } catch {
+      return [];
+    }
+  })() : [];
   if (memorySession) {
     try {
       recordVerdict(memorySession.d, {
@@ -18347,8 +19435,21 @@ async function runAnalyze(opts, globals) {
           pattern_id: f.pattern_id ?? f.rule_id,
           title: f.title,
           severity: f.severity
-        })) ?? []
+        })) ?? [],
+        intent: response.intent_alignment ?? null,
+        // The same signal F1 introduced: bytes differing from the hash frozen at
+        // the last verdict. A turn that moved nothing is the only kind that can
+        // accumulate a repeat.
+        idle: turnIsIdleForChannel,
+        // What next turn reads as `emittedLast`. A suppressed turn did not
+        // speak, so it cannot be the cause of the turn after it — which is what
+        // keeps this from becoming a permanent gag.
+        emitted: !silenced,
+        // Fingerprinted for the NEXT turn's repeat check. Reviewer pending items
+        // carry no `pattern_id`, so their content is the only available key.
+        pendingTexts: (response.pending_items ?? []).map((p) => String(p.description ?? p.title ?? p.reason ?? "")).filter(Boolean)
       });
+      intentRepeatCount = Math.max(0, (foldDossier(memorySession.d).meta.intent_repeat?.consecutive ?? 1) - 1);
     } catch {
     }
   }
@@ -18446,9 +19547,41 @@ async function runAnalyze(opts, globals) {
     reverify_by: response.reverify_by
   });
   const grantNudge = grantWarning ? ` \u26A0\uFE0F ${grantWarning}` : "";
-  switch (decision) {
+  let capReleased = false;
+  let effectiveDecision = decision;
+  if (decision === "FAIL") {
+    const blocking = (response.findings ?? []).filter((f) => {
+      const sev = String(f.severity ?? "").toLowerCase();
+      return sev === "critical" || sev === "high";
+    });
+    const fingerprint = findingsFingerprint(blocking);
+    const prior = readIterationState(currentCommit);
+    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;
+      effectiveDecision = "WARN";
+      logEvent("iteration_cap_released", { iteration: nextIteration, fingerprint });
+    }
+  }
+  if (capReleased) {
+    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 ?? "?")})`);
+    emitVerdict({
+      proposed: "WARN",
+      changed: skipCoverageChanged,
+      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")}`,
+      agentContext: null,
+      silenced: true
+    });
+  }
+  switch (effectiveDecision) {
     case "FAIL": {
-      writeIteration(iteration + 1, currentCommit, contentHash ?? void 0);
       const assessment = response.assessment;
       const narrative = assessment?.narrative ?? "";
       const findings = response.findings ?? [];
@@ -18525,7 +19658,19 @@ ${YELLOW}${loginNudge.trim()}${NC}
       if (grantNudge) process.stderr.write(`
 ${YELLOW}${grantNudge.trim()}${NC}
 `);
-      process.exit(2);
+      emitVerdict({
+        proposed: "FAIL",
+        changed: skipCoverageChanged,
+        coverage: reviewCoverage,
+        userSummary: "",
+        // Subject to the SAME cycle cut as PASS/WARN. Suppressing here is safe:
+        // the findings themselves are rendered above by the blocking renderer,
+        // so what the cut removes is the repeated commentary, never the defect.
+        agentContext: silenced ? null : agentContextFor(response, intentRepeatCount, priorPendingFingerprints),
+        // The coverage note is silenced with it — half a channel is still a channel.
+        silenced: !!silenced,
+        openElsewhere
+      });
       break;
     }
     case "PASS": {
@@ -18537,10 +19682,16 @@ ${YELLOW}${grantNudge.trim()}${NC}
       if (viewUrl) userSummary += ` Report: ${viewUrl}`;
       if (autoSeedNotice) userSummary = `${autoSeedNotice} ${userSummary}`;
       userSummary += loginNudge + grantNudge;
-      printJsonCompact(
-        buildHookOutput("PASS", userSummary, agentContextFor(response))
-      );
-      process.exit(0);
+      emitVerdict({
+        proposed: "PASS",
+        changed: skipCoverageChanged,
+        coverage: reviewCoverage,
+        userSummary,
+        agentContext: silenced ? null : agentContextFor(response, intentRepeatCount, priorPendingFingerprints),
+        // The coverage note is silenced with it — half a channel is still a channel.
+        silenced: !!silenced,
+        openElsewhere
+      });
       break;
     }
     case "WARN": {
@@ -18551,10 +19702,16 @@ ${YELLOW}${grantNudge.trim()}${NC}
       if (viewUrl) userSummary += ` Report: ${viewUrl}`;
       if (autoSeedNotice) userSummary = `${autoSeedNotice} ${userSummary}`;
       userSummary += loginNudge + grantNudge;
-      printJsonCompact(
-        buildHookOutput("WARN", userSummary, agentContextFor(response))
-      );
-      process.exit(0);
+      emitVerdict({
+        proposed: "WARN",
+        changed: skipCoverageChanged,
+        coverage: reviewCoverage,
+        userSummary,
+        agentContext: silenced ? null : agentContextFor(response, intentRepeatCount, priorPendingFingerprints),
+        // The coverage note is silenced with it — half a channel is still a channel.
+        silenced: !!silenced,
+        openElsewhere
+      });
       break;
     }
     default: {
@@ -18667,8 +19824,8 @@ async function runReview(opts, globals) {
     for (const p of specPaths) {
       if (!(0, import_node_fs26.existsSync)(p)) continue;
       try {
-        const { readFileSync: readFileSync15 } = await import("node:fs");
-        const content = readFileSync15(p, "utf-8");
+        const { readFileSync: readFileSync16 } = await import("node:fs");
+        const content = readFileSync16(p, "utf-8");
         specs.push({ path: p, content: content.slice(0, 10240) });
       } catch {
       }
@@ -18970,7 +20127,7 @@ async function runGuard(opts, globals) {
     cmd: "guard"
   });
   if (!result.ok) {
-    const authRemedy = result.error.startsWith("STALE_VERIFICATION") ? " Your GitHub verification expired \u2014 run `verity login` to re-verify." : result.error.startsWith("FORBIDDEN") ? " No access grant for this repository \u2014 run `verity login` to refresh your grants." : "";
+    const authRemedy = result.error.startsWith("STALE_VERIFICATION") ? " Your GitHub verification expired \u2014 run `verity login` to re-verify." : result.error.startsWith("FORBIDDEN") ? " No access grant for this repository \u2014 run `verity login` to refresh your grants." : result.error.startsWith("INVALID_TOKEN") ? " Your Verity login expired or was revoked \u2014 run `verity login` to sign in again." : "";
     emitAllowNotice(
       `\u26A0 Verity ${moment}: ${authRemedy ? "not authorized" : "service offline"} \u2014 ${verb}ed WITHOUT review${authRemedy}`,
       `Verity ${moment}: ${authRemedy ? "not authorized" : "service unavailable"} (${result.error}); the ${verb} was allowed WITHOUT a Verity review.${authRemedy}`
@@ -19471,6 +20628,13 @@ async function confirmExistingLogin(serviceUrl, remote, opts) {
     return "handled";
   }
   if (!who.ok) {
+    const denial = authDenialRemedy(who.error);
+    if (denial) {
+      console.log("");
+      printWarn(`Your existing Verity credential was rejected (${denial.code}).`);
+      printInfo(`  ${denial.remedy}`);
+      return "drive-login";
+    }
     if (existing.data.userId != null) {
       printInfo(`Logged in as ${existing.data.email ?? `user #${existing.data.userId}`} (cached \u2014 could not reach the Verity service). \u2713`);
     } else {
@@ -19486,15 +20650,14 @@ async function confirmExistingLogin(serviceUrl, remote, opts) {
   return "drive-login";
 }
 async function runOptionalAuth(resolution, opts = {}) {
-  let serviceUrl = resolution?.url ?? DEFAULT_SERVICE_URL;
-  let healed = false;
-  if (resolution) {
-    const heal = await maybeHealServiceUrl(resolution, opts.verbose);
-    serviceUrl = heal.serviceUrl;
-    healed = heal.healed;
-    if (healed) {
-      printInfo("  Log in below to re-register this project and repair ~/.verity/credentials.");
-    }
+  if (resolution.source === "default") {
+    printInfo(`No Verity service configured on this machine \u2014 using the default: ${resolution.url}`);
+  }
+  const heal = await maybeHealServiceUrl(resolution, opts.verbose);
+  const serviceUrl = heal.serviceUrl;
+  const healed = heal.healed;
+  if (healed) {
+    printInfo("  Log in below to re-register this project and repair ~/.verity/credentials.");
   }
   let remote = "";
   try {
@@ -19512,8 +20675,10 @@ async function runOptionalAuth(resolution, opts = {}) {
   if (process.stdin.isTTY && process.stdout.isTTY) {
     console.log("");
     console.log("  Signing in is optional. What it does:");
-    console.log("    - Confirms you have write access to this repository. The GitHub token");
-    console.log("      is used once to verify that, then discarded \u2014 Verity never stores it.");
+    console.log("    - Confirms which repositories you can write to. The GitHub token is");
+    console.log("      used once for that check, then discarded \u2014 Verity never stores it.");
+    console.log("    - One login covers every repository you can write to \u2014 other repos");
+    console.log("      need no further sign-in on this machine.");
     console.log("    - It does NOT give Verity access to your code. Code checked by the gate");
     console.log("      is analyzed in memory and discarded \u2014 we never store your code.");
     console.log("    - It is required to store and access run history for this repo");
@@ -19528,17 +20693,10 @@ async function runOptionalAuth(resolution, opts = {}) {
     localOnlyNote();
     return;
   }
-  if (!remote) {
-    printWarn("No git remote found \u2014 cannot authenticate yet.");
-    localOnlyNote();
-    return;
-  }
-  const projectName = parseRemote(remote)?.repo ?? (0, import_node_path23.basename)(process.cwd());
   printInfo("Authenticating with GitHub\u2026");
-  const result = await registerProject({ projectName, remote, serviceUrl, verbose: opts.verbose });
+  const result = await loginOnce({ serviceUrl, remote: remote || void 0, verbose: opts.verbose });
   if (result.ok) {
-    const who = result.data.email ?? (result.data.userId != null ? `user #${result.data.userId}` : null);
-    printInfo(`Logged in${who ? ` as ${who}` : ""} \u2713 \u2014 runs, history, and cloud memory now sync to Verity.`);
+    await reportLoginOutcome(result.data, { remote: remote || void 0, verbose: opts.verbose });
   } else {
     printWarn(`Authentication did not complete: ${result.error}`);
     localOnlyNote();
@@ -19689,8 +20847,8 @@ function registerInitCommand(program2) {
     console.log("");
     try {
       const globals = program2.opts();
-      const urlResult = await resolveServiceUrlDetailed(globals.serviceUrl);
-      await runOptionalAuth(urlResult.ok ? urlResult.data : null, {
+      const resolution = await resolveServiceUrlForAuth(globals.serviceUrl);
+      await runOptionalAuth(resolution, {
         token: globals.token,
         verbose: globals.verbose
       });
@@ -20306,6 +21464,12 @@ function registerTelemetryCommands(program2) {
       printError(urlResult.error);
       process.exit(1);
     }
+    const pin = await checkTokenPin(tokenResult.data.token, urlResult.data);
+    if (!pin.attach && pin.reason === "unpinnable") {
+      printWarn("Your Verity credential does not record which service issued it, so this endpoint");
+      printWarn("  cannot be verified \u2014 a repository could point your telemetry elsewhere.");
+      printWarn('  Run "verity login" to re-issue the credential; Verity can check it after that.');
+    }
     const result = await installTelemetry(urlResult.data);
     if (!result.ok) {
       printError(result.error);
@@ -20354,7 +21518,8 @@ function registerTelemetryCommands(program2) {
 }
 
 // src/cli.ts
-program.name("verity").description("CLI for Verity quality gate service").version("0.28.1-experimental.dbd87b1").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr").hook("preAction", async () => {
+program.name("verity").description("CLI for Verity quality gate service").version("0.28.1-experimental.e79117b").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr").hook("preAction", async () => {
+  setUserNamedServiceUrl(program.opts().serviceUrl);
   try {
     await foldLegacyLocalCredential();
   } catch {
@@ -20363,6 +21528,8 @@ program.name("verity").description("CLI for Verity quality gate service").versio
 registerAuthCommands(program);
 registerLoginCommand(program);
 registerTokenCommand(program);
+registerSessionsCommands(program);
+registerLogoutCommand(program);
 registerHooksCommands(program);
 registerIntentCommands(program);
 registerLifecycleCommands(program);