@akasecurity/cli 0.9.14 → 0.9.15

package/dist/cli.js

@@ -33,9 +33,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../node_modules/.pnpm/ignore@7.0.9/node_modules/ignore/index.js
+// ../node_modules/.pnpm/ignore@7.0.10/node_modules/ignore/index.js
 var require_ignore = __commonJS({
-  "../node_modules/.pnpm/ignore@7.0.9/node_modules/ignore/index.js"(exports, module) {
+  "../node_modules/.pnpm/ignore@7.0.10/node_modules/ignore/index.js"(exports, module) {
     "use strict";
     function makeArray(subject) {
       return Array.isArray(subject) ? subject : [subject];
@@ -430,6 +430,13 @@ var require_ignore = __commonJS({
       }
     };
     var WILDCARD = "[^\\/]*";
+    var separatorAfter = (run2, at) => {
+      let separator = EMPTY;
+      for (let index = at + 1; index < run2.length && !run2[index].wildcard; index++) {
+        separator += run2[index].single;
+      }
+      return separator;
+    };
     var pinWildcards = (source) => {
       if (source.indexOf(WILDCARD) < 0) {
         return source;
@@ -499,7 +506,7 @@ var require_ignore = __commonJS({
             out += token.single;
             return;
           }
-          out += at === lastWildcard ? WILDCARD : `(?:(?!${run2[at + 1].single})[^\\/])*`;
+          out += at === lastWildcard ? WILDCARD : `(?:(?!${separatorAfter(run2, at)})[^\\/])*`;
         });
         run2 = [];
       };
@@ -676,13 +683,13 @@ var require_ignore = __commonJS({
         const rules = this._rules;
         const { length } = rules;
         const shortcut = this._basenameCount * 2 >= length;
-        const basename9 = shortcut ? basenameOf(path) : path;
+        const basename10 = shortcut ? basenameOf(path) : path;
         for (let index = 0; index < length; index++) {
           const rule = rules[index];
           const { negative } = rule;
           const skip = unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored;
           if (!skip && rule[mode].test(
-            shortcut && rule._basenameOnly ? basename9 : path
+            shortcut && rule._basenameOnly ? basename10 : path
           )) {
             ignored = !negative;
             unignored = negative;
@@ -990,6 +997,10 @@ var SQLITE_MIGRATIONS = [
   {
     tag: "0035_share_destination_provider_id",
     sql: "ALTER TABLE `share_destination` ADD `provider_id` text;"
+  },
+  {
+    tag: "0036_secret_vault_identity_fingerprint",
+    sql: "ALTER TABLE `secret_vault` ADD `value_identity_fingerprint` text DEFAULT '' NOT NULL;--> statement-breakpoint\nUPDATE `secret_vault` SET `value_identity_fingerprint` = `value_fingerprint`;\n"
   }
 ];
 
@@ -1056,6 +1067,12 @@ function scopeFromAnswer(answer, now = Date.now()) {
 var PRODUCT_NAME = "AKA Security";
 var PRODUCT_TAGLINE = "We secure agent harnesses at the source.";
 
+// ../packages/schema/src/invisible-padding.ts
+var INVISIBLE_PADDING = /[\u00AD\u200B\u2060-\u2064\u202A-\u202E\u2066-\u2069\uFEFF\u{E0001}\u{E0020}-\u{E007F}]/gu;
+function stripInvisiblePadding(text) {
+  return text.replace(INVISIBLE_PADDING, "");
+}
+
 // ../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -6082,7 +6099,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve8) {
+function isRecursive(inst, stack, resolve9) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -6092,7 +6109,7 @@ function isRecursive(inst, stack, resolve8) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve8);
+      const answer = isRecursive(child, stack, resolve9);
       if (answer > result)
         result = answer;
     }
@@ -6103,7 +6120,7 @@ function isRecursive(inst, stack, resolve8) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve8) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve9) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -6167,7 +6184,7 @@ function isRecursive(inst, stack, resolve8) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve8 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve9 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -23608,7 +23625,29 @@ var StorePosturePlugin = external_exports.object({
    */
   policyBundleVersion: external_exports.string().max(200).nullable(),
   /** Epoch millis, on the CLIENT clock, of that fetch. */
-  policyFetchedAt: external_exports.number().int().min(0).max(MAX_DATE_MS).nullable()
+  policyFetchedAt: external_exports.number().int().min(0).max(MAX_DATE_MS).nullable(),
+  /**
+   * The newest version the host's own install record holds for this plugin —
+   * what is on disk. After an update it leads `version` (the running copy) by
+   * one launch. Null when no usable version can be read: no install record
+   * (a plugin run from a checkout), no entry with a valid version, or every
+   * such entry names an `installPath` that no longer exists; OPTIONAL, not
+   * required, so a build that predates the member keeps getting its 200.
+   * Bounded like `version`.
+   */
+  installedVersion: external_exports.string().max(64).nullable().optional(),
+  /**
+   * The local-store schema version this running build migrates a store to:
+   * the number of store migrations it carries, the count it stamps into
+   * `PRAGMA user_version`. A snapshot whose `schemaVersion` is above it
+   * usually describes a store a newer build migrated. It is a hint, not a
+   * verdict: the stamp is write-only, so a store whose count ran past this
+   * build's while this build knows every migration in its ledger reads above
+   * it too, which is why describeStoreSkew decides skew on ledger tags and
+   * never on the count. OPTIONAL for the same reason as `installedVersion`;
+   * bounded like `schemaVersion`.
+   */
+  buildSchemaVersion: external_exports.number().int().min(0).max(MAX_INT4).optional()
 }).meta({ id: "StorePosturePlugin" });
 var StorePostureSnapshot = external_exports.object({
   deviceId: external_exports.guid(),
@@ -25184,10 +25223,15 @@ var ParsedPointer = external_exports.object({
 });
 var VaultEntry = external_exports.object({
   pointerId: external_exports.string(),
-  // The keyed HMAC of the raw value under `exception.key`, and the epoch it was
-  // derived under. This is what a reveal-to-model grant matches on, and it rotates
-  // independently of the vault encryption key below.
+  // The keyed HMAC of the EXACT raw bytes under `exception.key`, and the epoch it
+  // was derived under. The vault's own dedupe key: a value and its invisibly
+  // padded twin are two rows. It rotates independently of the vault encryption
+  // key below. Never matched against an exception or grant.
   valueFingerprint: external_exports.string().regex(/^[0-9a-f]{64}$/),
+  // The same HMAC over the raw with invisible padding removed: the identity a
+  // reveal-to-model grant and every exception match on. Shared by a value and
+  // its padded twin.
+  valueIdentityFingerprint: external_exports.string().regex(/^[0-9a-f]{64}$/),
   fingerprintKeyVersion: external_exports.number().int().positive(),
   // The vault-key epoch this row's ciphertext was sealed under.
   keyVersion: external_exports.number().int().positive(),
@@ -25816,10 +25860,18 @@ var SeveritySummaryItem = external_exports.object({
   count: external_exports.number().int().nonnegative(),
   // Resolution-aware breakdown (optional, additive). Populated once findings
   // carry lifecycle state: `caught` = handled in-flight (enforced); `openAtRest`
-  // = still open with no in-flight enforcement (needs remediation). Absent on the
-  // legacy count-only response until the resolution feature lands.
+  // = still open with no in-flight enforcement (needs remediation); `dismissed`
+  // = closed by a human judgement rather than a fix — visible, but not counted as
+  // needing remediation. The three are disjoint. Absent on the legacy count-only
+  // response until the resolution feature lands.
   caught: external_exports.number().int().nonnegative().optional(),
-  openAtRest: external_exports.number().int().nonnegative().optional()
+  openAtRest: external_exports.number().int().nonnegative().optional(),
+  dismissed: external_exports.number().int().nonnegative().optional(),
+  // The two halves of `caught`, for a reader that wants them apart: `handled` =
+  // in-flight findings an enforcement action already contained; `resolved` =
+  // at-rest findings closed out by fixing them. `handled + resolved === caught`.
+  handled: external_exports.number().int().nonnegative().optional(),
+  resolved: external_exports.number().int().nonnegative().optional()
 }).meta({ id: "SeveritySummaryItem" });
 var SeveritySummaryResponse = external_exports.object({
   // Sum of bySeverity[].count.
@@ -25827,6 +25879,9 @@ var SeveritySummaryResponse = external_exports.object({
   // Findings still open at rest (sum of bySeverity[].openAtRest). Optional and
   // additive — absent on the legacy response until the resolution feature lands.
   needsRemediation: external_exports.number().int().nonnegative().optional(),
+  // Findings a user dismissed (sum of bySeverity[].dismissed). Excluded from
+  // needsRemediation, and kept visible here so an accepted risk is not erased.
+  dismissed: external_exports.number().int().nonnegative().optional(),
   // All four severity levels are always present (count may be 0).
   bySeverity: external_exports.array(SeveritySummaryItem)
 }).meta({ id: "SeveritySummaryResponse" });
@@ -26203,6 +26258,15 @@ var RELEASE_TAG_SOURCE = {
   /** The lookup produced no tag map at all; the version is null. */
   Unknown: "unknown"
 };
+function managedPluginNoteParts(s) {
+  const managed = s.managedInstall;
+  if (managed === void 0) return { ref: "", lead: "" };
+  return {
+    ref: managed.ref !== void 0 ? ` (marketplace ref ${managed.ref})` : "",
+    lead: managed.pending && s.latest !== null ? `v${s.latest} is on its way. ` : ""
+  };
+}
+var MANAGED_PLUGIN_ADVICE = "Your organization's managed settings install it and pin its version. Updates arrive through Claude Code's own plugin autoupdate when a new session starts, or /plugin \u2192 update inside a session.";
 
 // ../packages/schema/src/zod/web-capture.ts
 var WebUsageSource = external_exports.enum(["site", "estimated", "none"]);
@@ -26462,9 +26526,9 @@ var HOST_VERBS = {
     // Stated rather than defaulted, and stated whenever the ledger names one —
     // including `user`. An implicit agreement between the two halves is exactly
     // what broke, so the reading the comparison used is the one spelled here.
-    // Whether a given scope may be updated at all is the host's call: `managed`
-    // is an administrator's install, and a refusal from `claude` naming that is
-    // a true answer, unlike the one this replaces.
+    // A `managed` install never reaches this verb: it is an organization's
+    // install, pinned by its marketplace declaration, and `applyPluginUpdate`
+    // refuses it before anything runs. Every other scope is spelled here.
     update: (ref, scope) => [["plugin", "update", ref, ...scope ? ["--scope", scope] : []]],
     register: (source) => [["plugin", "marketplace", "add", source]],
     refresh: (marketplace) => [["plugin", "marketplace", "update", marketplace]]
@@ -26574,11 +26638,24 @@ function readJson(path) {
   }
 }
 function marketplaceRoot(claudeHome, marketplace) {
+  const entry = knownMarketplace(claudeHome, marketplace);
+  if (entry === null) return null;
+  return typeof entry.installLocation === "string" ? entry.installLocation : null;
+}
+function knownMarketplace(claudeHome, marketplace) {
   const known = readJson(knownMarketplacesPath(claudeHome));
   if (!isRecord(known)) return null;
   const entry = known[marketplace];
-  if (!isRecord(entry)) return null;
-  return typeof entry.installLocation === "string" ? entry.installLocation : null;
+  return isRecord(entry) ? entry : null;
+}
+var MAX_REF_LENGTH = 200;
+var printableRef = printable(MAX_REF_LENGTH);
+function marketplaceSourceRef(claudeHome, marketplace) {
+  const entry = knownMarketplace(claudeHome, marketplace);
+  if (entry === null || !isRecord(entry.source)) return void 0;
+  const ref = entry.source.ref;
+  if (typeof ref !== "string" || ref.trim() === "") return void 0;
+  return printableRef.safeParse(ref).success ? ref : void 0;
 }
 var NO_PIN = { version: null };
 function marketplacePinnedVersion(agent, claudeHome = join(homedir2(), ".claude")) {
@@ -26715,6 +26792,19 @@ function installedPluginsPath(claudeHome) {
   return join2(claudeHome, "plugins", "installed_plugins.json");
 }
 function installedPlugins(claudeHome = join2(homedir3(), ".claude")) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [ref, records] of ledgerRecords(claudeHome)) {
+    const record2 = records.find((r) => isRecord2(r) && r.scope === "user") ?? records.find((r) => isRecord2(r));
+    if (record2 && typeof record2.version === "string") {
+      out.set(ref, {
+        version: record2.version,
+        ...typeof record2.scope === "string" ? { scope: record2.scope } : {}
+      });
+    }
+  }
+  return out;
+}
+function ledgerRecords(claudeHome) {
   const out = /* @__PURE__ */ new Map();
   const path = installedPluginsPath(claudeHome);
   if (!existsSync2(path)) return out;
@@ -26726,20 +26816,24 @@ function installedPlugins(claudeHome = join2(homedir3(), ".claude")) {
   }
   if (!isRecord2(raw) || !isRecord2(raw.plugins)) return out;
   for (const [ref, records] of Object.entries(raw.plugins)) {
-    if (!Array.isArray(records) || records.length === 0) continue;
-    const record2 = records.find((r) => isRecord2(r) && r.scope === "user") ?? records.find((r) => isRecord2(r));
-    if (record2 && typeof record2.version === "string") {
-      out.set(ref, {
-        version: record2.version,
-        ...typeof record2.scope === "string" ? { scope: record2.scope } : {}
-      });
-    }
+    if (Array.isArray(records) && records.length > 0) out.set(ref, records);
   }
   return out;
 }
 function installedPluginScope(ref, claudeHome) {
   return installedPlugins(claudeHome).get(ref)?.scope;
 }
+var MANAGED_SCOPE = "managed";
+function managedPluginInstall(agent, claudeHome = join2(homedir3(), ".claude")) {
+  if (agent.cliBin !== "claude") return null;
+  const ref = pluginRef(agent);
+  if (ref === void 0) return null;
+  const record2 = ledgerRecords(claudeHome).get(ref)?.find((r) => isRecord2(r) && r.scope === MANAGED_SCOPE);
+  if (record2 === void 0) return null;
+  const version2 = typeof record2.version === "string" && record2.version.trim() !== "" ? record2.version : null;
+  const sourceRef = agent.marketplace === void 0 ? void 0 : marketplaceSourceRef(claudeHome, agent.marketplace);
+  return { version: version2, ...sourceRef !== void 0 ? { ref: sourceRef } : {} };
+}
 function installedPluginVersions(claudeHome) {
   return new Map([...installedPlugins(claudeHome)].map(([ref, { version: version2 }]) => [ref, version2]));
 }
@@ -26830,7 +26924,8 @@ function gatherReport(deps) {
   for (const agent of AGENT_PLUGINS) {
     const ref = pluginRef(agent);
     if (!ref || !agent.npmPackage) continue;
-    const installed = deps.installed.get(ref) ?? null;
+    const managed = deps.managedInstall(agent);
+    const installed = managed !== null ? managed.version : deps.installed.get(ref) ?? null;
     const channel = channelOfVersion(installed);
     const npm = resolveChannel(deps.viewDistTags(agent.npmPackage), channel);
     const npmLatest = npm.version;
@@ -26845,6 +26940,23 @@ function gatherReport(deps) {
         ...pin.range !== void 0 ? { range: pin.range } : {}
       }
     } : {};
+    if (managed !== null) {
+      statuses.push({
+        id: agent.id,
+        name: agent.name,
+        kind: "plugin",
+        installed,
+        latest: pin.version,
+        updateAvailable: false,
+        channel,
+        ...pinned,
+        managedInstall: {
+          ...managed.ref !== void 0 ? { ref: managed.ref } : {},
+          pending: pin.version !== null && installed !== null && isNewer(pin.version, installed)
+        }
+      });
+      continue;
+    }
     if (installed === null) {
       availablePlugins.push({ id: agent.id, name: agent.name, latest });
       continue;
@@ -26879,7 +26991,8 @@ function gatherReportLive(cliChannel) {
     // the HOST check, because a guard written at the call site admits Codex —
     // its registry entry carries a marketplace and a plugin name like any
     // other — into a reader that only understands Claude Code's layout.
-    marketplacePin: (agent) => marketplacePinnedVersion(agent)
+    marketplacePin: (agent) => marketplacePinnedVersion(agent),
+    managedInstall: (agent) => managedPluginInstall(agent)
   });
 }
 
@@ -27184,6 +27297,118 @@ function describeChannel(channel) {
   }
 }
 
+// ../packages/local-ops/src/update-render.ts
+function pinNotes(report) {
+  const notes = [];
+  for (const s of report.statuses) {
+    const pin = s.marketplacePin;
+    if (!pin || s.managedInstall) continue;
+    if (pin.range !== void 0) {
+      const npmPart = pin.npmLatest !== null ? ` npm has v${pin.npmLatest}.` : "";
+      notes.push(
+        `    ${s.name}: the ${pin.marketplace} marketplace pins ${pin.range}, which the host resolves within \u2014 not a single version this report can compare.${npmPart}`
+      );
+      continue;
+    }
+    if (!pin.npmAhead || s.latest === null || pin.npmLatest === null) continue;
+    notes.push(
+      `    ${s.name}: the ${pin.marketplace} marketplace pins v${s.latest}. npm has v${pin.npmLatest}, which this machine cannot install until that marketplace moves.`
+    );
+  }
+  return notes;
+}
+function managedNotes(report) {
+  const notes = [];
+  for (const s of report.statuses) {
+    if (!s.managedInstall) continue;
+    const { ref, lead } = managedPluginNoteParts(s);
+    notes.push(
+      `    ${s.name}${ref}: ${lead}${MANAGED_PLUGIN_ADVICE} \`aka update\` leaves it alone.`
+    );
+  }
+  return notes;
+}
+function managedState(s) {
+  if (!s.managedInstall) return void 0;
+  if (s.installed === null || s.latest === null) return "unknown";
+  if (!isSemver(s.installed) || !isSemver(s.latest)) return "unknown";
+  return s.managedInstall.pending ? "pending" : "current";
+}
+var MANAGED_STATUS = {
+  unknown: "managed",
+  pending: "managed \u2014 update pending",
+  current: "managed \u2014 up to date"
+};
+function statusLabel(s) {
+  const managed = managedState(s);
+  if (managed !== void 0) return MANAGED_STATUS[managed];
+  if (s.installed === null || s.latest === null) return "unknown";
+  return s.updateAvailable ? "update available" : "up to date";
+}
+function channelCell(s) {
+  return s.channel === void 0 || s.channel === RELEASE_CHANNEL.Stable ? "" : s.channel;
+}
+function renderReport(report) {
+  const rows = report.statuses.map((s) => ({
+    name: s.name,
+    installed: s.installed ?? "\u2014",
+    latest: s.latest ?? "unknown",
+    channel: channelCell(s),
+    status: statusLabel(s)
+  }));
+  const nameW = Math.max(9, ...rows.map((r) => r.name.length));
+  const instW = Math.max(9, ...rows.map((r) => r.installed.length));
+  const latW = Math.max(6, ...rows.map((r) => r.latest.length));
+  const chanW = rows.some((r) => r.channel !== "") ? Math.max(7, ...rows.map((r) => r.channel.length)) : 0;
+  const chanCol = (value) => chanW === 0 ? "" : `${value.padEnd(chanW)}  `;
+  const lines = [];
+  lines.push(
+    `  ${"Component".padEnd(nameW)}  ${"Installed".padEnd(instW)}  ${"Latest".padEnd(latW)}  ${chanCol("Channel")}Status`
+  );
+  for (const r of rows) {
+    lines.push(
+      `  ${r.name.padEnd(nameW)}  ${r.installed.padEnd(instW)}  ${r.latest.padEnd(latW)}  ${chanCol(r.channel)}${r.status}`
+    );
+  }
+  const notes = pinNotes(report);
+  if (notes.length > 0) {
+    lines.push("");
+    lines.push("  Pinned by a marketplace:");
+    lines.push(...notes);
+  }
+  const managed = managedNotes(report);
+  if (managed.length > 0) {
+    lines.push("");
+    lines.push("  Managed by your organization:");
+    lines.push(...managed);
+  }
+  if (report.availablePlugins.length > 0) {
+    lines.push("");
+    lines.push("  Available plugins (not installed):");
+    for (const p of report.availablePlugins) {
+      const version2 = p.latest ? ` v${p.latest}` : "";
+      lines.push(`    ${p.name} (${p.id})${version2} \u2014 install: aka plugins install ${p.id}`);
+    }
+  }
+  return lines.join("\n");
+}
+function outdated(report) {
+  return report.statuses.filter((s) => s.updateAvailable);
+}
+function nothingToApplyLine(report) {
+  const unsettled = report.statuses.some((s) => {
+    const managed = managedState(s);
+    return managed !== void 0 && managed !== "current";
+  });
+  return unsettled ? "Nothing for `aka update` to apply \u2014 updates to the plugin your organization manages arrive through Claude Code itself." : "Everything is up to date.";
+}
+function managedUpdateRefusal(name) {
+  return `${name} is managed by your organization, so nothing was run. ${MANAGED_PLUGIN_ADVICE}`;
+}
+function managedInstallRefusal(name) {
+  return `${name} is managed by your organization and is already installed, so nothing was run. ` + MANAGED_PLUGIN_ADVICE;
+}
+
 // ../packages/local-ops/src/apply.ts
 var APPLY_TIMEOUT_MS = 10 * 6e4;
 var PREP_TIMEOUT_MS = 6e4;
@@ -27255,6 +27480,10 @@ function prepare(resolved, mode) {
   }
 }
 function applyPluginUpdate(agentId, mode = "capture") {
+  const agent = findAgent(agentId);
+  if (agent !== void 0 && managedPluginInstall(agent) !== null) {
+    return { ok: false, output: managedUpdateRefusal(agent.name) };
+  }
   const resolved = resolveRef2(agentId);
   if ("ok" in resolved) return resolved;
   prepare(resolved, mode);
@@ -27262,6 +27491,10 @@ function applyPluginUpdate(agentId, mode = "capture") {
   return runSteps(resolved.cliBin, manager3.updateSteps(resolved.ref), mode);
 }
 function installAgentPlugin(agentId, mode = "capture") {
+  const agent = findAgent(agentId);
+  if (agent !== void 0 && managedPluginInstall(agent) !== null) {
+    return { ok: false, output: managedInstallRefusal(agent.name) };
+  }
   const resolved = resolveRef2(agentId);
   if ("ok" in resolved) return resolved;
   prepare(resolved, mode);
@@ -28484,11 +28717,11 @@ var EXACT_KIND_BY_BASENAME = {
   "composer.json": "composer.json",
   "packages.config": "packages.config"
 };
-function manifestKindOf(basename9) {
-  if (LOCKFILE_BASENAMES.has(basename9)) return null;
-  const exact = Object.hasOwn(EXACT_KIND_BY_BASENAME, basename9) ? EXACT_KIND_BY_BASENAME[basename9] : void 0;
+function manifestKindOf(basename10) {
+  if (LOCKFILE_BASENAMES.has(basename10)) return null;
+  const exact = Object.hasOwn(EXACT_KIND_BY_BASENAME, basename10) ? EXACT_KIND_BY_BASENAME[basename10] : void 0;
   if (exact !== void 0) return exact;
-  if (basename9.endsWith(".csproj")) return "csproj";
+  if (basename10.endsWith(".csproj")) return "csproj";
   return null;
 }
 function extractManifestSdks(text, kind) {
@@ -28966,6 +29199,82 @@ function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// ../packages/detections/src/format-chars.ts
+var HAS_FORMAT_CHAR = new RegExp("\\p{Cf}", "u");
+var FORMAT_CHAR_GLOBAL = new RegExp("\\p{Cf}", "gu");
+function normalizeFormatChars(text) {
+  if (!HAS_FORMAT_CHAR.test(text)) return void 0;
+  const normalizedParts = [];
+  const segments2 = [];
+  let cursor = 0;
+  let normLength = 0;
+  for (const match of text.matchAll(FORMAT_CHAR_GLOBAL)) {
+    const matchStart = match.index;
+    if (matchStart > cursor) {
+      const length = matchStart - cursor;
+      normalizedParts.push(text.slice(cursor, matchStart));
+      segments2.push({ normStart: normLength, origStart: cursor, length });
+      normLength += length;
+    }
+    cursor = matchStart + match[0].length;
+  }
+  if (cursor < text.length) {
+    const length = text.length - cursor;
+    normalizedParts.push(text.slice(cursor));
+    segments2.push({ normStart: normLength, origStart: cursor, length });
+  }
+  return { normalized: normalizedParts.join(""), segments: segments2 };
+}
+function segmentAt(segments2, normPos) {
+  let lo = 0;
+  let hi = segments2.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    const segment = segments2[mid];
+    if (segment !== void 0 && normPos >= segment.normStart + segment.length) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  const found = segments2[lo];
+  if (found === void 0) {
+    throw new Error(`normPos ${String(normPos)} has no covering segment`);
+  }
+  return found;
+}
+function mapSpanToOriginal(span, normalization) {
+  const { segments: segments2 } = normalization;
+  const startSegment = segmentAt(segments2, span.start);
+  const start = startSegment.origStart + (span.start - startSegment.normStart);
+  const endSegment = segmentAt(segments2, span.end - 1);
+  const end = endSegment.origStart + (span.end - 1 - endSegment.normStart) + 1;
+  return { start, end };
+}
+function normalizedOffset(origPos, segments2) {
+  let lo = 0;
+  let hi = segments2.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    const segment = segments2[mid];
+    if (segment !== void 0 && segment.origStart + segment.length <= origPos) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  const found = segments2[Math.min(lo, segments2.length - 1)];
+  if (found === void 0) return 0;
+  return found.normStart + Math.min(Math.max(0, origPos - found.origStart), found.length);
+}
+function mapSpanToNormalized(span, normalization) {
+  const { segments: segments2 } = normalization;
+  return {
+    start: normalizedOffset(span.start, segments2),
+    end: normalizedOffset(span.end, segments2)
+  };
+}
+
 // ../packages/detections/src/regex-cache.ts
 var singles = /* @__PURE__ */ new WeakMap();
 var keywordLists = /* @__PURE__ */ new WeakMap();
@@ -29127,29 +29436,35 @@ function registerPack(pack) {
 function getLoadedRules() {
   return [...packs.values()].flatMap((p) => p.rules);
 }
-function isCorroborated(candidate, candidates, text) {
+function spansOverlap(a, b) {
+  return a.start < b.end && a.end > b.start;
+}
+function isCorroborated(candidate, candidates, text, normalization) {
   const req = candidate.rule.requiresNearby;
   if (!req) return true;
   const halfWindow = req.windowChars;
-  const { start, end } = candidate.match.span;
-  const winStart = start - halfWindow;
-  const winEnd = end + halfWindow;
+  const ns = candidate.normSpan;
+  const winStart = ns.start - halfWindow;
+  const winEnd = ns.end + halfWindow;
   const categories = req.categories;
   const ruleIds = req.ruleIds;
   if (categories?.length || ruleIds?.length) {
     for (const other of candidates) {
       if (other === candidate) continue;
-      const os = other.match.span;
-      if (os.end < winStart || os.start > winEnd) continue;
-      if (other.match.ruleId !== candidate.match.ruleId && categories?.includes(other.match.category)) {
-        return true;
+      if (other.normSpan.end < winStart || other.normSpan.start > winEnd) continue;
+      const relevant = other.match.ruleId !== candidate.match.ruleId && categories?.includes(other.match.category) === true || ruleIds?.includes(other.match.ruleId) === true;
+      if (!relevant) continue;
+      if (other.match.ruleId === candidate.match.ruleId && spansOverlap(other.match.span, candidate.match.span)) {
+        continue;
       }
-      if (ruleIds?.includes(other.match.ruleId)) return true;
+      return true;
     }
   }
   const labels = req.labels;
   if (labels && labels.length > 0) {
-    const haystack = text.slice(Math.max(0, winStart), winEnd);
+    const { start, end } = candidate.match.span;
+    const haystack = text.slice(Math.max(0, start - halfWindow), end + halfWindow);
+    const normalizedHaystack = normalization === void 0 ? void 0 : normalization.normalized.slice(Math.max(0, winStart), winEnd);
     for (const re of memoizedRegExpList(
       "label",
       req,
@@ -29158,29 +29473,20 @@ function isCorroborated(candidate, candidates, text) {
         return trimmed.length === 0 ? void 0 : new RegExp(`(?<![A-Za-z0-9])${escapeRegExp2(trimmed)}(?![A-Za-z0-9])`, "i");
       })
     )) {
-      if (re?.test(haystack)) return true;
+      if (!re) continue;
+      if (re.test(haystack)) return true;
+      if (normalizedHaystack !== void 0 && re.test(normalizedHaystack)) return true;
     }
   }
   return false;
 }
-function extensionOf(filePath) {
-  const base = filePath.slice(Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\")) + 1);
-  const dot = base.lastIndexOf(".");
-  return dot > 0 ? base.slice(dot).toLowerCase() : void 0;
-}
-function ruleApplies(rule, extension) {
-  if (!rule.appliesTo || extension === void 0) return true;
-  return rule.appliesTo.extensions.some((e) => e.toLowerCase() === extension);
-}
-function scan(text, rules, context) {
-  const ruleset = rules ?? getLoadedRules();
-  const extension = context?.filePath ? extensionOf(context.filePath) : void 0;
+function buildCandidates(matchText, ruleset, extension) {
   const candidates = [];
   for (const rule of ruleset) {
     if (!ruleApplies(rule, extension)) continue;
-    const spans = MATCHERS[rule.matcher.type](text, rule);
+    const spans = MATCHERS[rule.matcher.type](matchText, rule);
     for (const span of spans) {
-      const rawMatch = text.slice(span.start, span.end);
+      const rawMatch = matchText.slice(span.start, span.end);
       if (!passesPostValidators(rule, rawMatch)) continue;
       candidates.push({
         rule,
@@ -29191,10 +29497,31 @@ function scan(text, rules, context) {
           span,
           rawMatch,
           confidence: 0.9
-        }
+        },
+        // In `matchText`'s own coordinates, which is the normalized text for
+        // a normalized-pass candidate and so already right; an original-pass
+        // candidate on the slow path is re-derived by withNormalizedSpan.
+        normSpan: span
       });
     }
   }
+  return candidates;
+}
+function mapCandidateToOriginal(candidate, normalization, text) {
+  const span = mapSpanToOriginal(candidate.match.span, normalization);
+  return {
+    rule: candidate.rule,
+    match: { ...candidate.match, span, rawMatch: text.slice(span.start, span.end) },
+    // Deliberately NOT remapped: `normSpan` is the span the primitive match
+    // was found at in the normalized text, which is exactly the coordinate
+    // space windows are measured in. See the `Candidate` comment.
+    normSpan: candidate.normSpan
+  };
+}
+function withNormalizedSpan(candidate, normalization) {
+  return { ...candidate, normSpan: mapSpanToNormalized(candidate.match.span, normalization) };
+}
+function gate(candidates, text, normalization) {
   const findings = [];
   for (const candidate of candidates) {
     const req = candidate.rule.requiresNearby;
@@ -29202,7 +29529,7 @@ function scan(text, rules, context) {
       findings.push(candidate.match);
       continue;
     }
-    if (!isCorroborated(candidate, candidates, text)) continue;
+    if (!isCorroborated(candidate, candidates, text, normalization)) continue;
     const boost = req.confidenceBoost;
     findings.push(
       boost ? { ...candidate.match, confidence: Math.min(0.99, candidate.match.confidence + boost) } : candidate.match
@@ -29210,6 +29537,81 @@ function scan(text, rules, context) {
   }
   return findings;
 }
+function closeRegion(open3, text) {
+  const span = { start: open3.start, end: open3.end };
+  return {
+    ruleId: open3.ruleId,
+    category: open3.category,
+    severity: open3.severity,
+    span,
+    rawMatch: text.slice(span.start, span.end),
+    confidence: open3.confidence
+  };
+}
+function mergeOverlappingSameRule(findings, text) {
+  if (findings.length === 0) return findings;
+  const groups = /* @__PURE__ */ new Map();
+  const ruleOrder = [];
+  for (const finding of findings) {
+    const group = groups.get(finding.ruleId);
+    if (group) {
+      group.push(finding);
+    } else {
+      groups.set(finding.ruleId, [finding]);
+      ruleOrder.push(finding.ruleId);
+    }
+  }
+  const merged = [];
+  for (const ruleId of ruleOrder) {
+    const group = groups.get(ruleId) ?? [];
+    const sorted = [...group].sort(
+      (a, b) => a.span.start - b.span.start || a.span.end - b.span.end
+    );
+    let open3;
+    for (const finding of sorted) {
+      if (open3 && finding.span.start < open3.end) {
+        open3.end = Math.max(open3.end, finding.span.end);
+        open3.confidence = Math.max(open3.confidence, finding.confidence);
+        continue;
+      }
+      if (open3) merged.push(closeRegion(open3, text));
+      open3 = {
+        start: finding.span.start,
+        end: finding.span.end,
+        confidence: finding.confidence,
+        ruleId: finding.ruleId,
+        category: finding.category,
+        severity: finding.severity
+      };
+    }
+    if (open3) merged.push(closeRegion(open3, text));
+  }
+  return merged;
+}
+function extensionOf(filePath) {
+  const base = filePath.slice(Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\")) + 1);
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(dot).toLowerCase() : void 0;
+}
+function ruleApplies(rule, extension) {
+  if (!rule.appliesTo || extension === void 0) return true;
+  return rule.appliesTo.extensions.some((e) => e.toLowerCase() === extension);
+}
+function scan(text, rules, context) {
+  const ruleset = rules ?? getLoadedRules();
+  const extension = context?.filePath ? extensionOf(context.filePath) : void 0;
+  const normalization = normalizeFormatChars(text);
+  const originalCandidates = buildCandidates(text, ruleset, extension);
+  if (!normalization) return gate(originalCandidates, text, void 0);
+  const pooledOriginal = originalCandidates.map(
+    (candidate) => withNormalizedSpan(candidate, normalization)
+  );
+  const normalizedCandidates = buildCandidates(normalization.normalized, ruleset, extension).map(
+    (candidate) => mapCandidateToOriginal(candidate, normalization, text)
+  );
+  const findings = gate([...pooledOriginal, ...normalizedCandidates], text, normalization);
+  return mergeOverlappingSameRule(findings, text);
+}
 var SEVERITY_RANK2 = {
   critical: 3,
   high: 2,
@@ -29632,11 +30034,11 @@ function repairOrRefuseMode(file2) {
   const link = lstatSync2(file2, { throwIfNoEntry: false });
   if (link === void 0) return "absent";
   if (link.isSymbolicLink()) return "untrusted";
-  const stat = statSync(file2, { throwIfNoEntry: false });
-  if (stat === void 0) return "absent";
+  const stat2 = statSync(file2, { throwIfNoEntry: false });
+  if (stat2 === void 0) return "absent";
   const uid = process.getuid?.();
-  if (uid !== void 0 && stat.uid !== uid) return "untrusted";
-  if (process.platform !== "win32" && (stat.mode & 511) !== DATA_FILE_MODE) {
+  if (uid !== void 0 && stat2.uid !== uid) return "untrusted";
+  if (process.platform !== "win32" && (stat2.mode & 511) !== DATA_FILE_MODE) {
     try {
       chmodSync2(file2, DATA_FILE_MODE);
     } catch {
@@ -29652,9 +30054,9 @@ function readControlPlaneCredentialState(settingsDir2, connection) {
 function readControlPlaneCredentialFile(settingsDir2, connection) {
   const file2 = controlPlaneCredentialPath(settingsDir2);
   let raw;
-  const gate = repairOrRefuseMode(file2);
-  if (gate === "absent") return { usable: false, reason: "absent" };
-  if (gate === "untrusted") return { usable: false, reason: "untrusted-file" };
+  const gate2 = repairOrRefuseMode(file2);
+  if (gate2 === "absent") return { usable: false, reason: "absent" };
+  if (gate2 === "untrusted") return { usable: false, reason: "untrusted-file" };
   try {
     raw = readFileSync5(file2, "utf8");
   } catch (err) {
@@ -36134,7 +36536,10 @@ var SqliteResolutionsRepository = class {
    * Insert many dispositions as ONE transaction — all of them or none.
    *
    * A dashboard dismissal closes every open finding of a rule, which is one
-   * write per key; run loose, a fault partway leaves half a rule closed with
+   * write per key. It reaches this through
+   * `LocalDatabase.dismissOpenFindingsForRule`, which calls it inside the
+   * transaction that selected the keys, so there it runs as a SAVEPOINT of
+   * that transaction. Run loose, a fault partway leaves half a rule closed with
    * nothing recording that the other half was meant to be. The caller then has
    * no way to tell a partial run from a complete one, because the card it
    * refreshes into just shows a smaller number either way.
@@ -36354,6 +36759,7 @@ function toSighting(row) {
 var SELECT_COLUMNS = `
   pointer_id AS pointerId,
   value_fingerprint AS valueFingerprint,
+  value_identity_fingerprint AS valueIdentityFingerprint,
   fingerprint_key_version AS fingerprintKeyVersion,
   key_version AS keyVersion,
   format_version AS formatVersion,
@@ -36378,13 +36784,13 @@ var SqliteSecretVaultRepository = class {
     this.db = db;
     this.insertStmt = db.prepare(
       `INSERT INTO secret_vault (
-         pointer_id, value_fingerprint, fingerprint_key_version, key_version,
-         format_version, category, rule_id, masked_match, provider,
+         pointer_id, value_fingerprint, value_identity_fingerprint,
+         fingerprint_key_version, key_version, format_version, category, rule_id, masked_match, provider,
          ciphertext, nonce, auth_tag,
          user_authorized, occurrence_count, first_seen, last_seen
        ) VALUES (
-         :pointerId, :valueFingerprint, :fingerprintKeyVersion, :keyVersion,
-         :formatVersion, :category, :ruleId, :maskedMatch, :provider,
+         :pointerId, :valueFingerprint, :valueIdentityFingerprint,
+         :fingerprintKeyVersion, :keyVersion, :formatVersion, :category, :ruleId, :maskedMatch, :provider,
          :ciphertext, :nonce, :authTag,
          :userAuthorized, 1, :now, :now
        )`
@@ -36409,7 +36815,13 @@ var SqliteSecretVaultRepository = class {
     );
     this.refreshFingerprintStmt = db.prepare(
       `UPDATE secret_vault
-       SET value_fingerprint = :valueFingerprint, fingerprint_key_version = :fingerprintKeyVersion
+       SET value_fingerprint = :valueFingerprint,
+           value_identity_fingerprint = :valueIdentityFingerprint,
+           fingerprint_key_version = :fingerprintKeyVersion
+       WHERE pointer_id = :pointerId`
+    );
+    this.setIdentityStmt = db.prepare(
+      `UPDATE secret_vault SET value_identity_fingerprint = :valueIdentityFingerprint
        WHERE pointer_id = :pointerId`
     );
     this.deleteByPointerStmt = db.prepare(`DELETE FROM secret_vault WHERE pointer_id = :pointerId`);
@@ -36426,6 +36838,7 @@ var SqliteSecretVaultRepository = class {
   listStmt;
   replaceCiphertextStmt;
   refreshFingerprintStmt;
+  setIdentityStmt;
   deleteByPointerStmt;
   derefStmt;
   /**
@@ -36456,6 +36869,7 @@ var SqliteSecretVaultRepository = class {
             bindParams({
               pointerId: input2.pointerId,
               valueFingerprint: input2.valueFingerprint,
+              valueIdentityFingerprint: input2.valueIdentityFingerprint,
               fingerprintKeyVersion: input2.fingerprintKeyVersion,
               keyVersion: input2.keyVersion,
               formatVersion: input2.formatVersion ?? POINTER_FORMAT_VERSION,
@@ -36517,7 +36931,15 @@ var SqliteSecretVaultRepository = class {
   replaceCiphertext(pointerId, next) {
     this.replaceCiphertextStmt.run({ pointerId, ...next });
   }
-  /** Re-derive an entry's fingerprint under a new fingerprint-key epoch. */
+  /**
+   * Correct an entry's identity fingerprint in place, leaving its exact
+   * fingerprint and key epoch alone. For a row whose identity column still holds
+   * the exact value copied in by the migration that added it.
+   */
+  setIdentityFingerprint(pointerId, valueIdentityFingerprint) {
+    this.setIdentityStmt.run({ pointerId, valueIdentityFingerprint });
+  }
+  /** Re-derive an entry's fingerprints under a new fingerprint-key epoch. */
   refreshFingerprint(pointerId, next) {
     this.refreshFingerprintStmt.run({ pointerId, ...next });
   }
@@ -36648,7 +37070,7 @@ var SqliteSecretVaultRepository = class {
         `SELECT ${INVENTORY_COLUMNS},
                 (SELECT e.id FROM exceptions e
                   WHERE e.rule_id = v.rule_id
-                    AND e.value_fingerprint = v.value_fingerprint
+                    AND e.value_fingerprint = v.value_identity_fingerprint
                     AND e.key_version = v.fingerprint_key_version
                     AND ${ACTIVE_REVEAL_GRANT_PREDICATE}
                   LIMIT 1) AS grant_id
@@ -36691,7 +37113,7 @@ var SqliteSecretVaultRepository = class {
         `SELECT ${INVENTORY_COLUMNS},
                 (SELECT e.id FROM exceptions e
                   WHERE e.rule_id = v.rule_id
-                    AND e.value_fingerprint = v.value_fingerprint
+                    AND e.value_fingerprint = v.value_identity_fingerprint
                     AND e.key_version = v.fingerprint_key_version
                     AND ${ACTIVE_REVEAL_GRANT_PREDICATE}
                   LIMIT 1) AS grant_id
@@ -36795,6 +37217,18 @@ var OPEN_AT_REST_FINDINGS_SQL = `FROM inspection_findings f
              OR latest.status IS NULL
              OR latest.status NOT IN ('resolved', 'dismissed')
            )`;
+function selectOpenFindingKeysForRule(db, ruleId) {
+  const rows = allRows(
+    db.prepare(
+      `SELECT DISTINCT f.finding_key AS finding_key
+       ${OPEN_AT_REST_FINDINGS_SQL}
+         AND d.rule_id = :ruleId
+         AND f.finding_key IS NOT NULL`
+    ),
+    { ruleId }
+  );
+  return rows.map((r) => r.finding_key);
+}
 var SEVERITIES = ["critical", "high", "medium", "low"];
 var ACTION_TO_KIND = {
   block: "blocked",
@@ -36851,16 +37285,16 @@ var SqliteSecurityRepository = class {
   // findings are caught only once their latest disposition is resolved,
   // otherwise they are open-at-rest.
   //
-  // NOTE for future manual-resolution writers: only latest status
-  // 'resolved' counts as caught above. When acknowledged/dismissed/
-  // false-positive manual dispositions land, this must keep filtering by
-  // status/method — 'acknowledged' is accepted risk, not a fix, and must NOT
-  // be bucketed as caught alongside 'resolved'.
+  // Only latest status 'resolved' counts as caught above. 'dismissed' is its
+  // own bucket: a judgement rather than a fix, so it is neither caught nor
+  // needing remediation, and stays countable. A further manual disposition
+  // (acknowledged, false-positive) must be placed deliberately — 'acknowledged'
+  // is accepted risk, not a fix, and must NOT be bucketed as caught.
   //
   // Legacy at-rest findings from pre-branch scans carry finding_key = NULL —
   // the resolution lifecycle is keyed by finding_key, so it can never attach a
   // disposition to (or clear) one of these on re-scan. They are excluded from
-  // both caught and openAtRest (untracked, not "needs remediation forever"),
+  // all three buckets (untracked, not "needs remediation forever"),
   // but still counted in total/count below — this keeps this predicate
   // consistent with SqliteResolutionsRepository.openAtRestKeysForPath, which
   // already filters `finding_key IS NOT NULL`.
@@ -36883,12 +37317,25 @@ var SqliteSecurityRepository = class {
                       WHEN latest.status = 'resolved' THEN 1
                       ELSE 0
                     END) AS caught,
+                SUM(CASE WHEN e.event_type != 'code_change' THEN 1 ELSE 0 END) AS handled,
+                SUM(CASE
+                      WHEN e.event_type = 'code_change'
+                       AND f.finding_key IS NOT NULL
+                       AND latest.status = 'resolved' THEN 1
+                      ELSE 0
+                    END) AS resolved,
                 SUM(CASE
                       WHEN e.event_type = 'code_change'
                        AND f.finding_key IS NOT NULL
-                       AND (latest.status IS NULL OR latest.status != 'resolved') THEN 1
+                       AND (latest.status IS NULL
+                            OR latest.status NOT IN ('resolved', 'dismissed')) THEN 1
+                      ELSE 0
+                    END) AS open_at_rest,
+                SUM(CASE
+                      WHEN e.event_type = 'code_change'
+                       AND latest.status = 'dismissed' THEN 1
                       ELSE 0
-                    END) AS open_at_rest
+                    END) AS dismissed
          FROM inspection_findings f
          JOIN audit_events e INDEXED BY idx_audit_capture_rollup ON e.id = f.audit_event_id
          JOIN inspection_definitions d ON d.id = f.inspection_definition_id
@@ -36903,11 +37350,15 @@ var SqliteSecurityRepository = class {
       severity,
       count: byRow.get(severity)?.count ?? 0,
       caught: byRow.get(severity)?.caught ?? 0,
-      openAtRest: byRow.get(severity)?.open_at_rest ?? 0
+      handled: byRow.get(severity)?.handled ?? 0,
+      resolved: byRow.get(severity)?.resolved ?? 0,
+      openAtRest: byRow.get(severity)?.open_at_rest ?? 0,
+      dismissed: byRow.get(severity)?.dismissed ?? 0
     }));
     const total = bySeverity.reduce((sum, s) => sum + s.count, 0);
     const needsRemediation = bySeverity.reduce((sum, s) => sum + s.openAtRest, 0);
-    return Promise.resolve({ total, needsRemediation, bySeverity });
+    const dismissed = bySeverity.reduce((sum, s) => sum + s.dismissed, 0);
+    return Promise.resolve({ total, needsRemediation, dismissed, bySeverity });
   }
   // Range is echoed but does not change the result today — coverage is a constant
   // business fact (see SCAN_COVERAGE), not a measured per-window metric. Order
@@ -37224,10 +37675,10 @@ var SqliteSecurityRepository = class {
    * machine, and the second reported "no recommendations" over live exposure.
    *
    * `open` mirrors `deriveFindingStatus` — at-rest, minus resolved and dismissed —
-   * so a row's count is exactly what `?status=open&type=<rule>` returns. Note that
-   * is NOT `severitySummary`'s `openAtRest`, which keeps dismissed findings (a
-   * dismissal is a judgement, not a remediation) and drops untracked legacy rows.
-   * The two answer different questions and only this one has to match a link.
+   * so a row's count is exactly what `?status=open&type=<rule>` returns. It
+   * differs from `severitySummary`'s `openAtRest` only in including untracked
+   * legacy rows, which that bucket leaves out; dismissed is excluded from both.
+   * Only this one has to match a link.
    *
    * Aggregated in SQL: the result is O(distinct rule × category × severity), so a
    * whole-store scope costs a grouped scan rather than a row per finding.
@@ -37255,6 +37706,8 @@ var SqliteSecurityRepository = class {
   /**
    * The distinct `finding_key`s behind ONE rule's {@link recommendationInputs}
    * tally — what a dashboard dismissal of that row writes a disposition for.
+   * The dismissal itself does not call this: it reads the same set through
+   * {@link selectOpenFindingKeysForRule}, inside its own write transaction.
    *
    * It shares {@link OPEN_AT_REST_FINDINGS_SQL} with the count rather than
    * restating the predicate, because a dismissal has to act on exactly the set
@@ -37271,16 +37724,7 @@ var SqliteSecurityRepository = class {
    * this set SMALLER than the tally, never larger.
    */
   openFindingKeysForRule(ruleId) {
-    const rows = allRows(
-      this.db.prepare(
-        `SELECT DISTINCT f.finding_key AS finding_key
-         ${OPEN_AT_REST_FINDINGS_SQL}
-           AND d.rule_id = :ruleId
-           AND f.finding_key IS NOT NULL`
-      ),
-      { ruleId }
-    );
-    return Promise.resolve(rows.map((r) => r.finding_key));
+    return Promise.resolve(selectOpenFindingKeysForRule(this.db, ruleId));
   }
   // Findings whose parent event occurred in [fromMs, toMs), with the parent's
   // epoch-millis timestamp. started_at is an INTEGER column, so the bounds stay
@@ -38326,6 +38770,31 @@ function openLocalDatabase(dir, options = {}) {
       );
     });
   }
+  function dismissOpenFindingsForRule(ruleId, disposition) {
+    let dismissed = 0;
+    withTransaction(
+      db,
+      () => {
+        const keys = selectOpenFindingKeysForRule(db, ruleId);
+        resolutions.insertResolutions(
+          keys.map((findingKey) => ({
+            findingKey,
+            status: "dismissed",
+            method: disposition.method,
+            resolvedAt: disposition.resolvedAt,
+            evidence: disposition.evidence
+          }))
+        );
+        dismissed = keys.length;
+      },
+      // IMMEDIATE takes the write lock at BEGIN, before the select, which is
+      // what keeps a concurrent resolve out of the gap. It also makes waiting
+      // on a busy writer an ordinary busy_timeout wait rather than a
+      // read-to-write upgrade SQLite refuses to retry.
+      "IMMEDIATE"
+    );
+    return dismissed;
+  }
   function recordCapture(event, detected) {
     failOpenTransaction(db, () => {
       const sessionId = event.metadata?.sessionId;
@@ -38509,6 +38978,7 @@ function openLocalDatabase(dir, options = {}) {
     inspectionDefinitions,
     inspectionFindings,
     recordCapture,
+    dismissOpenFindingsForRule,
     markCaptureDelivered,
     markCaptureOwed,
     markAuditEventsDelivered,
@@ -38738,6 +39208,9 @@ function rotateFingerprintKey(dataDir2) {
   });
 }
 function fingerprintValue(key, raw) {
+  return exactFingerprintValue(key, stripInvisiblePadding(raw));
+}
+function exactFingerprintValue(key, raw) {
   return createHmac("sha256", key.material).update(raw, "utf8").digest("hex");
 }
 function isCurrentKeyVersion(key, keyVersion) {
@@ -39581,10 +40054,14 @@ var SecretVault = class {
   async tokenize(raw, meta4, fingerprintKey) {
     if (!this.#isConsented()) return CONSENT_ABSENT;
     const fpKey = fingerprintKey();
-    const valueFingerprint = fingerprintValue(fpKey, raw);
+    const valueFingerprint = exactFingerprintValue(fpKey, raw);
+    const valueIdentityFingerprint = fingerprintValue(fpKey, raw);
     const existing = this.#repo.byValueFingerprint(valueFingerprint);
     const now = this.#now();
     if (existing) {
+      if (existing.valueIdentityFingerprint !== valueIdentityFingerprint) {
+        this.#repo.setIdentityFingerprint(existing.pointerId, valueIdentityFingerprint);
+      }
       this.#repo.upsert(
         {
           ...existing,
@@ -39604,6 +40081,7 @@ var SecretVault = class {
       {
         pointerId: base32Encode(pointerId),
         valueFingerprint,
+        valueIdentityFingerprint,
         fingerprintKeyVersion: fpKey.version,
         keyVersion: version2,
         // Recorded so the row stays OPENABLE if the wire-format constant ever
@@ -39658,7 +40136,7 @@ var SecretVault = class {
       try {
         covered = await verify(grantId, {
           ruleId: row.ruleId,
-          valueFingerprint: row.valueFingerprint,
+          valueFingerprint: row.valueIdentityFingerprint,
           fingerprintKeyVersion: row.fingerprintKeyVersion
         });
       } catch {
@@ -39736,16 +40214,36 @@ var SecretVault = class {
    * The raw-free row identity a reveal grant matches on. Deliberately not fed to
    * view surfaces: the keyed fingerprint is a correlation key and must not reach
    * a presentation layer.
+   *
+   * Its `valueFingerprint` is the row's IDENTITY fingerprint (invisible padding
+   * removed) — the space every exception, grant and ledger entry lives in — not
+   * the exact-bytes key the vault dedupes on. A padded value and its clean twin
+   * are two rows with one identity, so one grant covers both.
+   *
+   * Residual: a row written before the identity column existed holds its exact
+   * fingerprint there until the value is next detected or the fingerprint key
+   * rotates. That is the same value for every secret without an invisible
+   * padding character; for a padded one a grant minted from that stale identity
+   * does not match until the row is corrected.
    */
   async resolvePointerIdentity(token) {
     const row = await this.#rowFor(token);
     if (!row) return null;
     return {
       ruleId: row.ruleId,
-      valueFingerprint: row.valueFingerprint,
+      valueFingerprint: row.valueIdentityFingerprint,
       fingerprintKeyVersion: row.fingerprintKeyVersion
     };
   }
+  /**
+   * The id of the vault row a pointer verifies against, or null when the vault
+   * cannot identify it. Audit-free like `resolvePointerIdentity`. For callers
+   * that must tell two rows apart even when they share an identity fingerprint.
+   */
+  async resolvePointerRowId(token) {
+    const row = await this.#rowFor(token);
+    return row ? row.pointerId : null;
+  }
   /**
    * Mint the next vault key epoch and re-encrypt every entry under it. Pointers
    * already emitted keep verifying: their tag is checked against the historical
@@ -39809,6 +40307,9 @@ var SecretVault = class {
    * because the raw values are gone — the vault still holds the values, so
    * determinism, dedup, and every outstanding pointer survive the rotation.
    *
+   * Re-derives BOTH fingerprints (the exact dedupe key and the identity), which
+   * also corrects an identity column still holding a pre-migration exact value.
+   *
    * Every fingerprint-key rotation must run this: a row left at the old epoch
    * still resolves, but the same value detected again fingerprints under the
    * NEW key, misses the dedup lookup, and mints a second row and a second
@@ -39826,7 +40327,8 @@ var SecretVault = class {
         const raw = await this.#openRow(row);
         if (raw === null) continue;
         this.#repo.refreshFingerprint(row.pointerId, {
-          valueFingerprint: fingerprintValue(next, raw),
+          valueFingerprint: exactFingerprintValue(next, raw),
+          valueIdentityFingerprint: fingerprintValue(next, raw),
           fingerprintKeyVersion: next.version
         });
         refreshed += 1;
@@ -42901,75 +43403,6 @@ ${lines.join("\n")}
   if (!cache || isStale(cache)) triggerBackgroundRefresh(home);
 }
 
-// ../packages/local-ops/src/update-render.ts
-function pinNotes(report) {
-  const notes = [];
-  for (const s of report.statuses) {
-    const pin = s.marketplacePin;
-    if (!pin) continue;
-    if (pin.range !== void 0) {
-      const npmPart = pin.npmLatest !== null ? ` npm has v${pin.npmLatest}.` : "";
-      notes.push(
-        `    ${s.name}: the ${pin.marketplace} marketplace pins ${pin.range}, which the host resolves within \u2014 not a single version this report can compare.${npmPart}`
-      );
-      continue;
-    }
-    if (!pin.npmAhead || s.latest === null || pin.npmLatest === null) continue;
-    notes.push(
-      `    ${s.name}: the ${pin.marketplace} marketplace pins v${s.latest}. npm has v${pin.npmLatest}, which this machine cannot install until that marketplace moves.`
-    );
-  }
-  return notes;
-}
-function statusLabel(s) {
-  if (s.installed === null || s.latest === null) return "unknown";
-  return s.updateAvailable ? "update available" : "up to date";
-}
-function channelCell(s) {
-  return s.channel === void 0 || s.channel === RELEASE_CHANNEL.Stable ? "" : s.channel;
-}
-function renderReport(report) {
-  const rows = report.statuses.map((s) => ({
-    name: s.name,
-    installed: s.installed ?? "\u2014",
-    latest: s.latest ?? "unknown",
-    channel: channelCell(s),
-    status: statusLabel(s)
-  }));
-  const nameW = Math.max(9, ...rows.map((r) => r.name.length));
-  const instW = Math.max(9, ...rows.map((r) => r.installed.length));
-  const latW = Math.max(6, ...rows.map((r) => r.latest.length));
-  const chanW = rows.some((r) => r.channel !== "") ? Math.max(7, ...rows.map((r) => r.channel.length)) : 0;
-  const chanCol = (value) => chanW === 0 ? "" : `${value.padEnd(chanW)}  `;
-  const lines = [];
-  lines.push(
-    `  ${"Component".padEnd(nameW)}  ${"Installed".padEnd(instW)}  ${"Latest".padEnd(latW)}  ${chanCol("Channel")}Status`
-  );
-  for (const r of rows) {
-    lines.push(
-      `  ${r.name.padEnd(nameW)}  ${r.installed.padEnd(instW)}  ${r.latest.padEnd(latW)}  ${chanCol(r.channel)}${r.status}`
-    );
-  }
-  const notes = pinNotes(report);
-  if (notes.length > 0) {
-    lines.push("");
-    lines.push("  Pinned by a marketplace:");
-    lines.push(...notes);
-  }
-  if (report.availablePlugins.length > 0) {
-    lines.push("");
-    lines.push("  Available plugins (not installed):");
-    for (const p of report.availablePlugins) {
-      const version2 = p.latest ? ` v${p.latest}` : "";
-      lines.push(`    ${p.name} (${p.id})${version2} \u2014 install: aka plugins install ${p.id}`);
-    }
-  }
-  return lines.join("\n");
-}
-function outdated(report) {
-  return report.statuses.filter((s) => s.updateAvailable);
-}
-
 // src/command-manifest.ts
 var COMMAND_SPECS = [
   { name: "init", summary: "Scaffold ~/.aka (settings + local database)" },
@@ -43166,7 +43599,7 @@ async function send(options) {
       }
     }
   };
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     let settled = false;
     const fail = (reason, status) => {
       if (settled) return;
@@ -43192,7 +43625,7 @@ async function send(options) {
       res.on("end", () => {
         if (settled) return;
         settled = true;
-        resolve8({
+        resolve9({
           status: res.statusCode ?? 0,
           headers: res.headers,
           body: Buffer.concat(chunks).toString("utf8")
@@ -43462,6 +43895,9 @@ function createSharesSender(timeoutMs = SHARES_FORWARD_TIMEOUT_MS) {
   };
 }
 
+// ../packages/plugin-runtime/src/attached/with-timeout.ts
+var REQUEST_TIMEOUT_MS = 2e3;
+
 // ../packages/plugin-runtime/src/attached/forward-drops.ts
 import { readFileSync as readFileSync23 } from "fs";
 import { join as join31 } from "path";
@@ -44162,13 +44598,18 @@ import { spawn as spawn3 } from "child_process";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var HISTORY_SYNC_THROTTLE_MS = 5 * 60 * 1e3;
 
+// ../packages/plugin-runtime/src/attached/install-record.ts
+import { readFile as readFile2, stat } from "fs/promises";
+import { basename as basename7, dirname as dirname9, join as join33, resolve as resolve5 } from "path";
+
 // ../packages/plugin-runtime/src/attached/plugin-block.ts
 import { readFileSync as readFileSync24 } from "fs";
+var INSTALL_RECORD_READ_TIMEOUT_MS = REQUEST_TIMEOUT_MS / 2;
 
 // ../packages/plugin-runtime/src/attached/policy-store.ts
 import { randomUUID as randomUUID17 } from "crypto";
-import { readFile as readFile2, rm, writeFile as writeFile2 } from "fs/promises";
-import { join as join33 } from "path";
+import { readFile as readFile3, rm, writeFile as writeFile2 } from "fs/promises";
+import { join as join34 } from "path";
 
 // ../packages/plugin-runtime/src/attached/atomic-publish.ts
 import { rename as rename2 } from "fs/promises";
@@ -44176,11 +44617,11 @@ var RETRYABLE = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
 var IMMEDIATE_RETRIES = 8;
 var TIMED_RETRIES = 4;
 var ATTEMPTS = 1 + IMMEDIATE_RETRIES + TIMED_RETRIES;
-var delay = (ms) => new Promise((resolve8) => {
-  setTimeout(resolve8, ms);
+var delay = (ms) => new Promise((resolve9) => {
+  setTimeout(resolve9, ms);
 });
-var yieldToLoop = () => new Promise((resolve8) => {
-  setImmediate(resolve8);
+var yieldToLoop = () => new Promise((resolve9) => {
+  setImmediate(resolve9);
 });
 async function publishByRename(tmp, file2, move = rename2) {
   for (let attempt = 1; ; attempt += 1) {
@@ -44197,10 +44638,10 @@ async function publishByRename(tmp, file2, move = rename2) {
 
 // ../packages/plugin-runtime/src/attached/policy-store.ts
 function createPolicyStore(dir = dataDir()) {
-  const file2 = join33(dir, "policy-cache.json");
+  const file2 = join34(dir, "policy-cache.json");
   async function read() {
     try {
-      const raw = await readFile2(file2, "utf8");
+      const raw = await readFile3(file2, "utf8");
       const parsed2 = JSON.parse(raw);
       if (typeof parsed2 !== "object" || parsed2 === null) return null;
       const record2 = parsed2;
@@ -44222,7 +44663,7 @@ function createPolicyStore(dir = dataDir()) {
   }
   async function priorRecord() {
     try {
-      const parsed2 = JSON.parse(await readFile2(file2, "utf8"));
+      const parsed2 = JSON.parse(await readFile3(file2, "utf8"));
       return typeof parsed2 === "object" && parsed2 !== null ? parsed2 : null;
     } catch {
       return null;
@@ -44268,7 +44709,7 @@ function createPolicyStore(dir = dataDir()) {
 
 // ../packages/plugin-runtime/src/attached/posture-report-state.ts
 import { readFileSync as readFileSync25 } from "fs";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 var POSTURE_REPORT_STATE_FILENAME = ATTACHED_POSTURE_REPORT_FILENAME;
 var OUTCOME_KEYS = {
   ok: true,
@@ -44282,7 +44723,7 @@ var OUTCOME_KEYS = {
 };
 var OUTCOMES2 = new Set(Object.keys(OUTCOME_KEYS));
 function postureReportStatePath(dataDir2) {
-  return join34(dataDir2, POSTURE_REPORT_STATE_FILENAME);
+  return join35(dataDir2, POSTURE_REPORT_STATE_FILENAME);
 }
 function readPostureReportState(dataDir2) {
   try {
@@ -44306,12 +44747,12 @@ import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
 
 // ../packages/plugin-runtime/src/attached/posture-store.ts
 import { randomUUID as randomUUID18 } from "crypto";
-import { readFile as readFile3, rm as rm2, writeFile as writeFile3 } from "fs/promises";
-import { join as join35 } from "path";
+import { readFile as readFile4, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { join as join36 } from "path";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 function createPostureStore(dir = settingsDir(), legacyDir) {
-  const file2 = join35(dir, "posture-state.json");
-  const legacyFile = legacyDir === void 0 ? null : join35(legacyDir, "posture-state.json");
+  const file2 = join36(dir, "posture-state.json");
+  const legacyFile = legacyDir === void 0 ? null : join36(legacyDir, "posture-state.json");
   async function persist(state) {
     await ensureDataDir(dir);
     const tmp = `${file2}.${randomUUID18()}.tmp`;
@@ -44326,7 +44767,7 @@ function createPostureStore(dir = settingsDir(), legacyDir) {
   async function readFrom(path) {
     let raw;
     try {
-      raw = await readFile3(path, "utf8");
+      raw = await readFile4(path, "utf8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT" || code === "ENOTDIR") return null;
@@ -44384,7 +44825,7 @@ async function readDeviceIdentity(dir) {
 
 // ../packages/plugin-runtime/src/attached/sync-state.ts
 import { readFileSync as readFileSync26 } from "fs";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 var SYNC_STATE_FILENAME = ATTACHED_SYNC_STATE_FILENAME;
 var OUTCOMES3 = /* @__PURE__ */ new Set([
   "ok",
@@ -44395,7 +44836,7 @@ var OUTCOMES3 = /* @__PURE__ */ new Set([
   "invalid-bundle"
 ]);
 function syncStatePath(dataDir2) {
-  return join36(dataDir2, SYNC_STATE_FILENAME);
+  return join37(dataDir2, SYNC_STATE_FILENAME);
 }
 function readSyncState(dataDir2) {
   try {
@@ -44630,10 +45071,10 @@ import { randomUUID as randomUUID20 } from "crypto";
 var EXCEPTION_RETENTION_MS = 90 * 24 * 60 * 60 * 1e3;
 
 // src/lib/args.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 var HOME_OPTION = { home: { type: "string" } };
 function homeBase(home) {
-  return home === void 0 ? defaultDataDir() : resolve5(home);
+  return home === void 0 ? defaultDataDir() : resolve6(home);
 }
 
 // src/lib/open-url.ts
@@ -44701,11 +45142,11 @@ function terminalPrompter(io = processIo()) {
     },
     isInteractive: io.input.isTTY && io.output.isTTY,
     ask(question) {
-      return new Promise((resolve8) => {
+      return new Promise((resolve9) => {
         const rl = createInterface({ input: io.input, output: io.output });
         rl.question(question, (answer) => {
           rl.close();
-          resolve8(answer);
+          resolve9(answer);
         });
       });
     },
@@ -44716,7 +45157,7 @@ function terminalPrompter(io = processIo()) {
     // fatal signals: a security tool must never brick the terminal it was
     // invoked from.
     askHidden(question) {
-      return new Promise((resolve8, reject) => {
+      return new Promise((resolve9, reject) => {
         const stdin = io.input;
         io.output.write(question);
         stdin.setRawMode(true);
@@ -44739,7 +45180,7 @@ function terminalPrompter(io = processIo()) {
           restore();
           io.output.write("\n");
           if (err) reject(err);
-          else resolve8(state.value);
+          else resolve9(state.value);
         };
         const onError = (err) => {
           finish(err);
@@ -45350,7 +45791,8 @@ function runCheckUpdates(argv) {
       'Could not reach the npm registry, so "Latest" is unknown. Check your\nnetwork connection and try again.\n'
     );
   } else if (ups.length === 0 && report.availablePlugins.length === 0) {
-    out.write("Everything is up to date.\n");
+    out.write(`${nothingToApplyLine(report)}
+`);
   } else if (ups.length > 0) {
     out.write(`${String(ups.length)} update(s) available \u2014 run \`aka update\` to apply.
 `);
@@ -45529,24 +45971,24 @@ import { spawn as spawn7 } from "child_process";
 import { existsSync as existsSync17 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { createServer } from "net";
-import { dirname as dirname9, join as join37 } from "path";
+import { dirname as dirname10, join as join38 } from "path";
 import { fileURLToPath as fileURLToPath6, pathToFileURL } from "url";
 import { parseArgs as parseArgs2 } from "util";
 var require3 = createRequire2(import.meta.url);
-var here = dirname9(fileURLToPath6(import.meta.url));
+var here = dirname10(fileURLToPath6(import.meta.url));
 var BIND_HOST = "127.0.0.1";
 function pkgBase() {
-  return isSea() ? dirname9(process.execPath) : join37(here, "..");
+  return isSea() ? dirname10(process.execPath) : join38(here, "..");
 }
 function isPortFree(port) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const probe = createServer();
     probe.once("error", () => {
-      resolve8(false);
+      resolve9(false);
     });
     probe.once("listening", () => {
       probe.close(() => {
-        resolve8(true);
+        resolve9(true);
       });
     });
     probe.listen(port, BIND_HOST);
@@ -45590,14 +46032,14 @@ async function runDashboard(argv) {
   refreshUpdateMirror(dataDir());
   const base = pkgBase();
   const bundledServer = [
-    join37(base, "web-ui", "server.js"),
-    join37(base, "web-ui", "web-ui", "server.js")
+    join38(base, "web-ui", "server.js"),
+    join38(base, "web-ui", "web-ui", "server.js")
   ].find((p) => existsSync17(p));
   if (bundledServer) {
     launchStandalone(bundledServer, port, shouldOpen, url2);
     return;
   }
-  const webUiDir = dirname9(require3.resolve("@akasecurity/web-ui/package.json"));
+  const webUiDir = dirname10(require3.resolve("@akasecurity/web-ui/package.json"));
   const nextBin = require3.resolve("next/dist/bin/next", { paths: [webUiDir] });
   const startNext = () => {
     const child = spawn7(
@@ -45611,7 +46053,7 @@ async function runDashboard(argv) {
     onReadyOpen(child, shouldOpen, url2, `Starting the AKA dashboard at ${url2}
 `);
   };
-  if (existsSync17(join37(webUiDir, ".next", "BUILD_ID"))) {
+  if (existsSync17(join38(webUiDir, ".next", "BUILD_ID"))) {
     startNext();
     return;
   }
@@ -45634,7 +46076,7 @@ function launchStandalone(serverJs, port, shouldOpen, url2) {
     return;
   }
   const child = spawn7(reinvoke.command, reinvoke.args, {
-    cwd: dirname9(serverJs),
+    cwd: dirname10(serverJs),
     stdio: ["inherit", "pipe", "inherit"],
     // Inherit the parent env so the child server sees PATH etc.; PORT/HOSTNAME tell
     // Next's standalone server where to bind (its only port input).
@@ -46321,7 +46763,9 @@ async function fingerprintForRule(ruleId, useStdin, dir, io) {
     );
   }
   if (first !== raw) {
-    io.out("Note: the grant binds to the exact detected span, not the whole input.\n");
+    io.out(
+      "Note: the grant binds to the detected span (invisible padding ignored), not the whole input.\n"
+    );
   }
   const key = loadOrCreateFingerprintKey(dir);
   const result = {
@@ -46659,7 +47103,7 @@ import { execFileSync as execFileSync3 } from "child_process";
 import { existsSync as existsSync18, mkdirSync as mkdirSync6, readFileSync as readFileSync27, renameSync as renameSync5, writeFileSync as writeFileSync9 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname11, isAbsolute as isAbsolute2, join as join39, resolve as resolve6 } from "path";
+import { dirname as dirname12, isAbsolute as isAbsolute2, join as join40, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL2 } from "url";
 import { parseArgs as parseArgs5 } from "util";
 
@@ -46740,7 +47184,7 @@ function parseLauncher(script) {
 
 // src/lib/stable-path.ts
 import { realpathSync as realpathSync6 } from "fs";
-import { basename as basename7, dirname as dirname10, join as join38, relative as relative2 } from "path";
+import { basename as basename8, dirname as dirname11, join as join39, relative as relative2 } from "path";
 var realpathOrNull = (path) => {
   try {
     return realpathSync6(path);
@@ -46753,23 +47197,23 @@ var INSTALLER_BINROOT = /^aka-(?:darwin|linux|win32)-(?:arm64|x64)$/;
 var INSTALLER_VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
 function layoutLinks(realPath) {
   const links = [];
-  let versionDir = dirname10(realPath);
+  let versionDir = dirname11(realPath);
   for (let reach = 1; ; reach++) {
-    const parent = dirname10(versionDir);
+    const parent = dirname11(versionDir);
     if (parent === versionDir) break;
-    const grandparent = dirname10(parent);
+    const grandparent = dirname11(parent);
     const rest = relative2(versionDir, realPath);
     const add = (link) => {
-      links.push({ link, path: join38(link, rest) });
+      links.push({ link, path: join39(link, rest) });
     };
     if (reach <= CURRENT_LINK_REACH) {
-      if (INSTALLER_BINROOT.test(basename7(versionDir)) && INSTALLER_VERSION.test(basename7(parent)) && grandparent !== parent) {
-        add(join38(grandparent, "current"));
+      if (INSTALLER_BINROOT.test(basename8(versionDir)) && INSTALLER_VERSION.test(basename8(parent)) && grandparent !== parent) {
+        add(join39(grandparent, "current"));
       }
-      if (basename7(grandparent) === "apps") add(join38(parent, "current"));
+      if (basename8(grandparent) === "apps") add(join39(parent, "current"));
     }
-    if (basename7(grandparent) === "Cellar") {
-      add(join38(dirname10(grandparent), "opt", basename7(parent)));
+    if (basename8(grandparent) === "Cellar") {
+      add(join39(dirname11(grandparent), "opt", basename8(parent)));
     }
     versionDir = parent;
   }
@@ -46800,9 +47244,9 @@ function versionPin(path, realpath = realpathOrNull) {
 
 // src/commands/extension.ts
 var require4 = createRequire3(import.meta.url);
-var here2 = dirname11(fileURLToPath7(import.meta.url));
+var here2 = dirname12(fileURLToPath7(import.meta.url));
 function cliRoot() {
-  return isSea() ? dirname11(process.execPath) : join39(here2, "..");
+  return isSea() ? dirname12(process.execPath) : join40(here2, "..");
 }
 var EXTENSION_IDS = [
   // Derived from the "key" in plugins/browser-extension/manifest.json.
@@ -46819,22 +47263,22 @@ function nativeHostManifest(hostPath) {
   };
 }
 function resolveHostScript(root = cliRoot()) {
-  const bundled = join39(root, "native-host", "host.js");
+  const bundled = join40(root, "native-host", "host.js");
   if (existsSync18(bundled)) return bundled;
   try {
     const pkgJson = require4.resolve("@akasecurity/plugin-browser-extension/package.json");
-    const devBuilt = join39(dirname11(pkgJson), "native-host", "host.js");
+    const devBuilt = join40(dirname12(pkgJson), "native-host", "host.js");
     if (existsSync18(devBuilt)) return devBuilt;
   } catch {
   }
   return null;
 }
 function resolveExtensionDist(root = cliRoot()) {
-  const bundled = join39(root, "extension");
+  const bundled = join40(root, "extension");
   if (existsSync18(bundled)) return bundled;
   try {
     const pkgJson = require4.resolve("@akasecurity/plugin-browser-extension/package.json");
-    const devDist = join39(dirname11(pkgJson), "dist");
+    const devDist = join40(dirname12(pkgJson), "dist");
     if (existsSync18(devDist)) return devDist;
   } catch {
   }
@@ -46842,7 +47286,7 @@ function resolveExtensionDist(root = cliRoot()) {
 }
 function chromeManifestDir(platform3 = process.platform) {
   if (platform3 === "darwin") {
-    return join39(
+    return join40(
       homedir8(),
       "Library",
       "Application Support",
@@ -46852,9 +47296,9 @@ function chromeManifestDir(platform3 = process.platform) {
     );
   }
   if (platform3 === "win32") {
-    return join39(homedir8(), ".aka", "native-messaging");
+    return join40(homedir8(), ".aka", "native-messaging");
   }
-  return join39(homedir8(), ".config", "google-chrome", "NativeMessagingHosts");
+  return join40(homedir8(), ".config", "google-chrome", "NativeMessagingHosts");
 }
 var NATIVE_HOST_COMMAND = "__native-host";
 function currentRuntime() {
@@ -46866,7 +47310,7 @@ function launcherCommand(hostScript, runtime = currentRuntime()) {
   return [executable, stablePath(hostScript, runtime.realpath)];
 }
 function launcherPath(manifestDir, platform3) {
-  return join39(
+  return join40(
     manifestDir,
     platform3 === "win32" ? `${NATIVE_HOST_NAME}.cmd` : `${NATIVE_HOST_NAME}.sh`
   );
@@ -46894,7 +47338,7 @@ async function runNativeHost(hostScript = resolveHostScript()) {
 }
 function hostChildScript(command, sea = isSea(), root = cliRoot()) {
   if (!sea || !isAbsolute2(command) || !command.endsWith(".js")) return null;
-  if (resolve6(dirname11(command)) !== resolve6(root, "native-host")) return null;
+  if (resolve7(dirname12(command)) !== resolve7(root, "native-host")) return null;
   return existsSync18(command) ? command : null;
 }
 function windowsRegistryKey() {
@@ -46945,7 +47389,7 @@ function runInstall(manifestDir, hostScript = resolveHostScript(), extensionDist
   const argv = command ?? launcherCommand(hostScript);
   mkdirSync6(manifestDir, { recursive: true });
   const launcher = writeLauncher(manifestDir, argv, process.platform);
-  const manifestPath = join39(manifestDir, `${NATIVE_HOST_NAME}.json`);
+  const manifestPath = join40(manifestDir, `${NATIVE_HOST_NAME}.json`);
   const tmp = `${manifestPath}.tmp`;
   writeFileSync9(tmp, `${JSON.stringify(nativeHostManifest(launcher), null, 2)}
 `, {
@@ -47076,7 +47520,7 @@ function registrationFaults(manifestPath) {
   return lines;
 }
 function runStatus2(manifestDir, home) {
-  const manifestPath = join39(manifestDir, `${NATIVE_HOST_NAME}.json`);
+  const manifestPath = join40(manifestDir, `${NATIVE_HOST_NAME}.json`);
   if (!existsSync18(manifestPath)) {
     process.stdout.write(
       `native-messaging host: not installed
@@ -47101,7 +47545,7 @@ function runStatus2(manifestDir, home) {
 
 // src/commands/init.ts
 import { existsSync as existsSync20, lstatSync as lstatSync4, readdirSync as readdirSync7, statSync as statSync13 } from "fs";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 import * as readline from "readline/promises";
 import { parseArgs as parseArgs7 } from "util";
 
@@ -47132,10 +47576,13 @@ async function listPlugins(argv) {
   const installed = installedAgentPluginVersions();
   const out = process.stdout;
   out.write("Agent plugins (the CLI is an optional hub \u2014 plugins also self-install):\n\n");
+  let anyManaged = false;
   for (const a of AGENT_PLUGINS) {
     const ref = pluginRef(a);
+    const managed = managedPluginInstall(a);
+    if (managed !== null) anyManaged = true;
     const version2 = ref ? installed.get(ref) : void 0;
-    const state = version2 ? `installed v${version2}` : active.has(a.sourceTool) ? "active" : "available";
+    const state = managed !== null ? managedState2(managed.version) : version2 ? `installed v${version2}` : active.has(a.sourceTool) ? "active" : "available";
     out.write(`  ${a.id.padEnd(16)} ${state.padEnd(16)} ${a.name}
 `);
     out.write(`  ${" ".padEnd(16)} ${" ".padEnd(16)} ${a.description}
@@ -47143,6 +47590,15 @@ async function listPlugins(argv) {
   }
   out.write("\nInstall:  aka plugins install <agent>\n");
   out.write("Update:   aka update            (or: aka check-updates)\n");
+  if (anyManaged) {
+    out.write(
+      `Managed:  \`aka plugins install\` and \`aka update\` leave a managed plugin alone. ${MANAGED_PLUGIN_ADVICE}
+`
+    );
+  }
+}
+function managedState2(version2) {
+  return version2 !== null ? `managed v${version2}` : "managed";
 }
 async function installPlugin(argv, deps) {
   const { positionals } = parseArgs6({ args: argv, options: HOME_OPTION, allowPositionals: true });
@@ -47159,6 +47615,7 @@ async function installPlugin(argv, deps) {
     process.exitCode = 1;
     return;
   }
+  if (refuseManaged(agent, deps)) return;
   const ref = pluginRef(agent);
   const cliBin = agent.cliBin;
   if (!ref || !cliBin) {
@@ -47205,13 +47662,14 @@ Those protections will be inactive until you update Claude Code to ${required2}
       }
     }
   }
+  if (refuseManaged(agent, deps)) return;
   const plan = manager3.installSpawnPlan(ref, agent.marketplaceSource, agent.marketplace);
   process.stdout.write(
     `Installing ${agent.name} via ${cliBin}, running:
 ` + plan.map((command) => `  ${command}
 `).join("")
   );
-  const { ok } = installAgentPlugin(agent.id, "inherit");
+  const { ok, output: output2 } = installAgentPlugin(agent.id, "inherit");
   if (ok) {
     process.stdout.write(
       `
@@ -47220,14 +47678,29 @@ Those protections will be inactive until you update Claude Code to ${required2}
   Run \`aka init\` to scaffold your local store (if you haven't already).
 `
     );
-  } else {
-    process.stderr.write(
-      `
-\u2717 Install failed \u2014 see the output above, or add it in ${agent.name} with \`${recipe.join(" && ")}\`.
-`
-    );
+    return;
+  }
+  if (refuseManaged(agent, deps)) return;
+  if (output2 !== "") {
+    process.stderr.write(`
+\u2717 ${output2}
+`);
     process.exitCode = 1;
+    return;
   }
+  process.stderr.write(
+    `
+\u2717 Install failed \u2014 see the output above, or add it in ${agent.name} with \`${recipe.join(" && ")}\`.
+`
+  );
+  process.exitCode = 1;
+}
+function refuseManaged(agent, deps) {
+  if (managedPluginInstall(agent) === null) return false;
+  process.stderr.write(`aka plugins install: ${managedInstallRefusal(agent.name)}
+`);
+  if (deps.declineIsFailure !== false) process.exitCode = 1;
+  return true;
 }
 
 // src/commands/init.ts
@@ -47238,7 +47711,7 @@ function storeModeTargets(home) {
     try {
       for (const entry of readdirSync7(dir, { withFileTypes: true })) {
         if (entry.name.endsWith(".partial") && !entry.isDirectory()) continue;
-        targets.add(join40(dir, entry.name));
+        targets.add(join41(dir, entry.name));
       }
     } catch {
     }
@@ -47320,7 +47793,7 @@ async function runInit(argv) {
   ensureLayoutDirSync(home);
   const settings = settingsDir(home);
   ensureLayoutDirSync(settings);
-  const settingsFile = join40(settings, "settings.json");
+  const settingsFile = join41(settings, "settings.json");
   let settingsCreated = false;
   if (!existsSync20(settingsFile)) {
     try {
@@ -47368,6 +47841,7 @@ async function offerPluginInstall(autoYes) {
   const ref = agent ? pluginRef(agent) : void 0;
   if (!agent || !ref) return;
   if (installedPluginVersions().has(ref)) return;
+  if (managedPluginInstall(agent) !== null) return;
   const out = process.stdout;
   if (!autoYes) {
     if (!process.stdin.isTTY) {
@@ -47749,10 +48223,12 @@ Latest findings:
 function renderFindingsSummary(severity) {
   const caught = severity.bySeverity.reduce((sum, s) => sum + (s.caught ?? 0), 0);
   const needsRemediation = severity.needsRemediation ?? 0;
+  const dismissed = severity.dismissed ?? 0;
   const labelWidth = Math.max(
     9,
     ...severity.bySeverity.map((s) => s.severity.length),
-    "Needs remediation".length
+    "Needs remediation".length,
+    "Dismissed".length
   );
   const lines = [`Findings: ${String(severity.total)} total`];
   for (const s of severity.bySeverity) {
@@ -47760,6 +48236,7 @@ function renderFindingsSummary(severity) {
   }
   lines.push(`  ${"Caught".padEnd(labelWidth)} ${String(caught)}`);
   lines.push(`  ${"Needs remediation".padEnd(labelWidth)} ${String(needsRemediation)}`);
+  lines.push(`  ${"Dismissed".padEnd(labelWidth)} ${String(dismissed)}`);
   return lines.join("\n");
 }
 var TOP_MODELS = 6;
@@ -48494,11 +48971,11 @@ import * as readline2 from "readline/promises";
 import { parseArgs as parseArgs13 } from "util";
 
 // src/lib/install-origin.ts
-import { dirname as dirname12 } from "path";
+import { dirname as dirname13 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 function cliInstallOrigin() {
   try {
-    return { moduleDir: dirname12(fileURLToPath8(import.meta.url)) };
+    return { moduleDir: dirname13(fileURLToPath8(import.meta.url)) };
   } catch {
     return { moduleDir: void 0 };
   }
@@ -48565,6 +49042,13 @@ async function runUpdate(argv) {
     process.exitCode = 1;
     return;
   }
+  const targetRow = target && target !== "all" ? report.statuses.find((s) => s.id === target) : void 0;
+  if (targetRow?.managedInstall) {
+    process.stderr.write(`aka update: ${managedUpdateRefusal(targetRow.name)}
+`);
+    process.exitCode = 1;
+    return;
+  }
   let candidates = outdated(report);
   if (target && target !== "all") candidates = candidates.filter((s) => s.id === target);
   if (candidates.length === 0) {
@@ -48580,7 +49064,8 @@ async function runUpdate(argv) {
     } else {
       out.write(
         target && target !== "all" ? `${target} is already up to date.
-` : "Everything is up to date.\n"
+` : `${nothingToApplyLine(report)}
+`
       );
     }
     return;
@@ -48632,6 +49117,10 @@ function pluginChannelRefusal(target, channel) {
 `;
   if (!agent || !ref || !agent.cliBin) {
     return `${head}  Update ${target} through its host, then re-run \`aka check-updates\`.
+`;
+  }
+  if (managedPluginInstall(agent) !== null) {
+    return `${head}  ${agent.name} is managed by your organization. ${MANAGED_PLUGIN_ADVICE}
 `;
   }
   const recipe = createCliPluginManager(agent.cliBin).updateRecipe(ref, agent.marketplaceSource);
@@ -48673,6 +49162,11 @@ function applyPluginUpdate2(status) {
   const cliBin = agent?.cliBin;
   if (!agent || !ref || !cliBin) {
     process.stderr.write(`\u2717 ${status.name}: no update coordinates in the registry.
+`);
+    return false;
+  }
+  if (managedPluginInstall(agent) !== null) {
+    process.stderr.write(`\u2717 ${managedUpdateRefusal(status.name)}
 `);
     return false;
   }
@@ -48691,9 +49185,11 @@ function applyPluginUpdate2(status) {
 ` + plan.map((command) => `  ${command}
 `).join("")
   );
-  const { ok } = applyPluginUpdate(status.id, "inherit");
+  const { ok, output: output2 } = applyPluginUpdate(status.id, "inherit");
   process.stdout.write(ok ? `\u2713 ${status.name} updated.
 ` : `\u2717 ${status.name} update failed.
+`);
+  if (!ok && output2 !== "") process.stderr.write(`  ${output2}
 `);
   return ok;
 }
@@ -48717,10 +49213,10 @@ import {
   writeFileSync as writeFileSync10
 } from "fs";
 import { homedir as homedir9 } from "os";
-import { basename as basename8, dirname as dirname13, isAbsolute as isAbsolute3, join as join41, relative as relative3, resolve as resolve7 } from "path";
+import { basename as basename9, dirname as dirname14, isAbsolute as isAbsolute3, join as join42, relative as relative3, resolve as resolve8 } from "path";
 var DEFAULT_MAX_REWRITE_BYTES = 32 * 1024 * 1024;
 function transcriptRoots(userHome) {
-  return [join41(userHome ?? homedir9(), ".claude", "projects")];
+  return [join42(userHome ?? homedir9(), ".claude", "projects")];
 }
 function readContainedFile(realPath, maxBytes = DEFAULT_MAX_REWRITE_BYTES) {
   try {
@@ -48744,7 +49240,7 @@ function isWithinRoot(realTarget, root) {
   return rel !== "" && !rel.startsWith("..") && !isAbsolute3(rel);
 }
 function containedRealPath(filePath, roots) {
-  const realTarget = realPathOrNull(resolve7(filePath));
+  const realTarget = realPathOrNull(resolve8(filePath));
   if (realTarget === null) return null;
   return roots.some((root) => isWithinRoot(realTarget, root)) ? realTarget : null;
 }
@@ -48761,8 +49257,8 @@ function isProcessAlive(pid) {
   }
 }
 function sweepStrandedTemps(realPath) {
-  const dir = dirname13(realPath);
-  const prefix = `${basename8(realPath)}.`;
+  const dir = dirname14(realPath);
+  const prefix = `${basename9(realPath)}.`;
   let names;
   try {
     names = readdirSync8(dir);
@@ -48776,7 +49272,7 @@ function sweepStrandedTemps(realPath) {
     const pid = Number(pidPart);
     if (pid !== process.pid && isProcessAlive(pid)) continue;
     try {
-      const stranded = join41(dir, name);
+      const stranded = join42(dir, name);
       if (!lstatSync5(stranded).isFile()) continue;
       rmSync9(stranded, { force: true });
     } catch {
@@ -48870,7 +49366,6 @@ function selectOutOfPolicy(rows, ruleActions) {
     }
     selection.outOfPolicy.push({
       pointerId: row.pointerId,
-      valueFingerprint: row.valueFingerprint,
       ruleId: row.ruleId,
       action
     });
@@ -48907,12 +49402,12 @@ async function analyseText(text, deps) {
   const tokens = new Set(found);
   let unattributable = 0;
   for (const token of tokens) {
-    const identity = await deps.identify(token);
-    if (identity === null) {
+    const pointerId = await deps.identify(token);
+    if (pointerId === null) {
       unattributable += 1;
       continue;
     }
-    const entry = deps.entryFor(identity.valueFingerprint);
+    const entry = deps.entryFor(pointerId);
     if (entry === void 0) continue;
     hits.set(token, entry);
   }
@@ -49011,7 +49506,7 @@ async function runPrune2(argv, io) {
 `);
       return;
     }
-    const byFingerprint = new Map(selection.outOfPolicy.map((e) => [e.valueFingerprint, e]));
+    const byPointerId = new Map(selection.outOfPolicy.map((e) => [e.pointerId, e]));
     const ledger = sightingLedger(db);
     const locations = /* @__PURE__ */ new Set();
     let surfaceSighted = 0;
@@ -49031,8 +49526,8 @@ async function runPrune2(argv, io) {
       isConsented: () => isVaultConsentValid(readWorkspaceSettings(base).vaultConsent)
     });
     const analyse = async (text) => analyseText(text, {
-      entryFor: (fingerprint) => byFingerprint.get(fingerprint),
-      identify: (token) => vault.resolvePointerIdentity(token)
+      entryFor: (pointerId) => byPointerId.get(pointerId),
+      identify: (token) => vault.resolvePointerRowId(token)
     });
     const reports = [];
     const clearedLocations = /* @__PURE__ */ new Set();