@akasecurity/cli 0.9.14 → 0.9.15

package/native-host/host.js

@@ -32,9 +32,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];
@@ -429,6 +429,13 @@ var require_ignore = __commonJS({
       }
     };
     var WILDCARD = "[^\\/]*";
+    var separatorAfter = (run, at) => {
+      let separator = EMPTY;
+      for (let index = at + 1; index < run.length && !run[index].wildcard; index++) {
+        separator += run[index].single;
+      }
+      return separator;
+    };
     var pinWildcards = (source) => {
       if (source.indexOf(WILDCARD) < 0) {
         return source;
@@ -498,7 +505,7 @@ var require_ignore = __commonJS({
             out += token.single;
             return;
           }
-          out += at === lastWildcard ? WILDCARD : `(?:(?!${run[at + 1].single})[^\\/])*`;
+          out += at === lastWildcard ? WILDCARD : `(?:(?!${separatorAfter(run, at)})[^\\/])*`;
         });
         run = [];
       };
@@ -675,13 +682,13 @@ var require_ignore = __commonJS({
         const rules = this._rules;
         const { length } = rules;
         const shortcut = this._basenameCount * 2 >= length;
-        const basename7 = shortcut ? basenameOf(path) : path;
+        const basename8 = 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 ? basename7 : path
+            shortcut && rule._basenameOnly ? basename8 : path
           )) {
             ignored = !negative;
             unignored = negative;
@@ -1002,6 +1009,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"
   }
 ];
 
@@ -1011,6 +1022,12 @@ var HOUR_MS = 60 * MINUTE_MS;
 var MAX_TEMPORARY_MS = 24 * HOUR_MS;
 var ONCE_BACKSTOP_MS = 30 * MINUTE_MS;
 
+// ../../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, {
@@ -6037,7 +6054,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve2) {
+function isRecursive(inst, stack, resolve3) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -6047,7 +6064,7 @@ function isRecursive(inst, stack, resolve2) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve2);
+      const answer = isRecursive(child, stack, resolve3);
       if (answer > result)
         result = answer;
     }
@@ -6058,7 +6075,7 @@ function isRecursive(inst, stack, resolve2) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve2) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve3) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -6122,7 +6139,7 @@ function isRecursive(inst, stack, resolve2) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve2 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve3 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -23520,7 +23537,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(),
@@ -25163,10 +25202,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(),
@@ -25751,10 +25795,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.
@@ -25762,6 +25814,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" });
@@ -26395,11 +26450,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 {
@@ -26415,9 +26470,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 = readFileSync(file2, "utf8");
   } catch (err) {
@@ -32562,7 +32617,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.
@@ -32782,6 +32840,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,
@@ -32806,13 +32865,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
        )`
@@ -32837,7 +32896,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`);
@@ -32854,6 +32919,7 @@ var SqliteSecretVaultRepository = class {
   listStmt;
   replaceCiphertextStmt;
   refreshFingerprintStmt;
+  setIdentityStmt;
   deleteByPointerStmt;
   derefStmt;
   /**
@@ -32884,6 +32950,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,
@@ -32945,7 +33012,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 });
   }
@@ -33076,7 +33151,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
@@ -33119,7 +33194,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
@@ -33223,6 +33298,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",
@@ -33279,16 +33366,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`.
@@ -33311,12 +33398,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
@@ -33331,11 +33431,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
@@ -33652,10 +33756,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.
@@ -33683,6 +33787,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
@@ -33699,16 +33805,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
@@ -34754,6 +34851,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;
@@ -34937,6 +35059,7 @@ function openLocalDatabase(dir, options = {}) {
     inspectionDefinitions,
     inspectionFindings,
     recordCapture,
+    dismissOpenFindingsForRule,
     markCaptureDelivered,
     markCaptureOwed,
     markAuditEventsDelivered,
@@ -35153,6 +35276,9 @@ function loadOrCreateFingerprintKey(dataDir2) {
   });
 }
 function fingerprintValue(key, raw) {
+  return exactFingerprintValue(key, stripInvisiblePadding(raw));
+}
+function exactFingerprintValue(key, raw) {
   return createHmac("sha256", key.material).update(raw, "utf8").digest("hex");
 }
 
@@ -35323,7 +35449,7 @@ async function send(options) {
       }
     }
   };
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let settled = false;
     const fail = (reason, status) => {
       if (settled) return;
@@ -35349,7 +35475,7 @@ async function send(options) {
       res.on("end", () => {
         if (settled) return;
         settled = true;
-        resolve2({
+        resolve3({
           status: res.statusCode ?? 0,
           headers: res.headers,
           body: Buffer.concat(chunks).toString("utf8")
@@ -36328,6 +36454,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 segments = [];
+  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));
+      segments.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));
+    segments.push({ normStart: normLength, origStart: cursor, length });
+  }
+  return { normalized: normalizedParts.join(""), segments };
+}
+function segmentAt(segments, normPos) {
+  let lo = 0;
+  let hi = segments.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    const segment = segments[mid];
+    if (segment !== void 0 && normPos >= segment.normStart + segment.length) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  const found = segments[lo];
+  if (found === void 0) {
+    throw new Error(`normPos ${String(normPos)} has no covering segment`);
+  }
+  return found;
+}
+function mapSpanToOriginal(span, normalization) {
+  const { segments } = normalization;
+  const startSegment = segmentAt(segments, span.start);
+  const start = startSegment.origStart + (span.start - startSegment.normStart);
+  const endSegment = segmentAt(segments, span.end - 1);
+  const end = endSegment.origStart + (span.end - 1 - endSegment.normStart) + 1;
+  return { start, end };
+}
+function normalizedOffset(origPos, segments) {
+  let lo = 0;
+  let hi = segments.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    const segment = segments[mid];
+    if (segment !== void 0 && segment.origStart + segment.length <= origPos) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  const found = segments[Math.min(lo, segments.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 } = normalization;
+  return {
+    start: normalizedOffset(span.start, segments),
+    end: normalizedOffset(span.end, segments)
+  };
+}
+
 // ../../packages/detections/src/regex-cache.ts
 var singles = /* @__PURE__ */ new WeakMap();
 var keywordLists = /* @__PURE__ */ new WeakMap();
@@ -36489,29 +36691,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,
@@ -36520,29 +36728,20 @@ function isCorroborated(candidate, candidates, text) {
         return trimmed2.length === 0 ? void 0 : new RegExp(`(?<![A-Za-z0-9])${escapeRegExp2(trimmed2)}(?![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,
@@ -36553,10 +36752,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;
@@ -36564,7 +36784,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
@@ -36572,6 +36792,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 finding2 of findings) {
+    const group = groups.get(finding2.ruleId);
+    if (group) {
+      group.push(finding2);
+    } else {
+      groups.set(finding2.ruleId, [finding2]);
+      ruleOrder.push(finding2.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 finding2 of sorted) {
+      if (open3 && finding2.span.start < open3.end) {
+        open3.end = Math.max(open3.end, finding2.span.end);
+        open3.confidence = Math.max(open3.confidence, finding2.confidence);
+        continue;
+      }
+      if (open3) merged.push(closeRegion(open3, text));
+      open3 = {
+        start: finding2.span.start,
+        end: finding2.span.end,
+        confidence: finding2.confidence,
+        ruleId: finding2.ruleId,
+        category: finding2.category,
+        severity: finding2.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,
@@ -39414,8 +39709,8 @@ function collectConfigFiles(scan2, claudeDir, cwd) {
 }
 function configFileEntry(path, scope, kind) {
   try {
-    const stat = statSync7(path);
-    return { name: basename4(path), path, scope, kind, updatedAt: stat.mtime.toISOString() };
+    const stat2 = statSync7(path);
+    return { name: basename4(path), path, scope, kind, updatedAt: stat2.mtime.toISOString() };
   } catch {
     return void 0;
   }
@@ -39918,8 +40213,8 @@ function createIsolatedScanner(data, opts = {}) {
   }
   function enqueue(spec) {
     const next = chain.then(
-      () => new Promise((resolve2) => {
-        spec(resolve2);
+      () => new Promise((resolve3) => {
+        spec(resolve3);
       })
     );
     chain = next.then(
@@ -39930,7 +40225,7 @@ function createIsolatedScanner(data, opts = {}) {
   }
   return {
     scan(text, context, scanOpts) {
-      return enqueue((resolve2) => {
+      return enqueue((resolve3) => {
         runOne(
           {
             budgetMs,
@@ -39943,23 +40238,23 @@ function createIsolatedScanner(data, opts = {}) {
             }),
             reply: (message2) => {
               if (message2.kind !== "result") return false;
-              resolve2({ status: "ok", findings: message2.findings });
+              resolve3({ status: "ok", findings: message2.findings });
               return true;
             }
           },
-          resolve2
+          resolve3
         );
       });
     },
     probe(rule) {
-      return enqueue((resolve2) => {
+      return enqueue((resolve3) => {
         runOne(
           {
             budgetMs: probeBudgetMs,
             build: (id) => ({ kind: "probe", id, rule }),
             reply: (message2) => {
               if (message2.kind !== "probed") return false;
-              resolve2({
+              resolve3({
                 status: "ok",
                 verdict: message2.verdict,
                 worstMs: message2.worstMs,
@@ -39968,7 +40263,7 @@ function createIsolatedScanner(data, opts = {}) {
               return true;
             }
           },
-          resolve2
+          resolve3
         );
       });
     },
@@ -41653,10 +41948,55 @@ function spawnDetached(scriptPath) {
   child.unref();
 }
 
+// ../../packages/plugin-runtime/src/attached/install-record.ts
+import { readFile as readFile2, stat } from "fs/promises";
+import { basename as basename7, dirname as dirname6, join as join28, resolve as resolve2 } from "path";
+async function readInstalledVersion(installRoot) {
+  try {
+    const versionDir = resolve2(installRoot);
+    const pluginDir = dirname6(versionDir);
+    const marketplaceDir = dirname6(pluginDir);
+    const cacheDir = dirname6(marketplaceDir);
+    if (basename7(cacheDir) !== "cache") return null;
+    const key = `${basename7(pluginDir)}@${basename7(marketplaceDir)}`;
+    const record2 = JSON.parse(
+      await readFile2(join28(dirname6(cacheDir), "installed_plugins.json"), "utf8")
+    );
+    const plugins = record2?.plugins;
+    if (typeof plugins !== "object" || plugins === null || !Object.hasOwn(plugins, key)) {
+      return null;
+    }
+    const entries = plugins[key];
+    if (!Array.isArray(entries)) return null;
+    let newest = null;
+    for (const entry of entries) {
+      const { version: version3, installPath } = entry ?? {};
+      if (typeof version3 !== "string" || !isParseableBinaryVersion(version3)) continue;
+      if (!StorePosturePlugin.shape.installedVersion.safeParse(version3).success) continue;
+      if (newest !== null && compareBinaryVersions(version3, newest) <= 0) continue;
+      if (typeof installPath === "string" && !await exists(installPath)) continue;
+      newest = version3;
+    }
+    return newest;
+  } catch {
+    return null;
+  }
+}
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // ../../packages/plugin-runtime/src/attached/plugin-block.ts
 import { readFileSync as readFileSync18 } from "fs";
+var INSTALL_RECORD_READ_TIMEOUT_MS = REQUEST_TIMEOUT_MS / 2;
 function createPluginBlock(build, policyStore) {
   return async () => {
+    const installed = build.installRoot === void 0 ? void 0 : readInstalledVersionBounded(build.installRoot);
     const cached2 = await policyStore.read();
     const fetchedAtMs = cached2?.fetchedAtMs;
     const block = {
@@ -41664,16 +42004,25 @@ function createPluginBlock(build, policyStore) {
       version: build.version,
       ossVersion: build.ossVersion ?? null,
       policyBundleVersion: cached2 !== null && StorePosturePlugin.shape.policyBundleVersion.safeParse(cached2.bundle.version).success ? cached2.bundle.version : null,
-      policyFetchedAt: fetchedAtMs !== void 0 && fetchedAtMs > 0 && StorePosturePlugin.shape.policyFetchedAt.safeParse(fetchedAtMs).success ? fetchedAtMs : null
+      policyFetchedAt: fetchedAtMs !== void 0 && fetchedAtMs > 0 && StorePosturePlugin.shape.policyFetchedAt.safeParse(fetchedAtMs).success ? fetchedAtMs : null,
+      ...installed === void 0 ? {} : { installedVersion: await installed },
+      buildSchemaVersion: SQLITE_MIGRATIONS.length
     };
     return StorePosturePlugin.safeParse(block).success ? block : void 0;
   };
 }
+async function readInstalledVersionBounded(installRoot) {
+  try {
+    return await withTimeout(readInstalledVersion(installRoot), INSTALL_RECORD_READ_TIMEOUT_MS);
+  } catch {
+    return null;
+  }
+}
 
 // ../../packages/plugin-runtime/src/attached/policy-store.ts
 import { randomUUID as randomUUID16 } from "crypto";
-import { readFile as readFile2, rm, writeFile as writeFile2 } from "fs/promises";
-import { join as join28 } from "path";
+import { readFile as readFile3, rm, writeFile as writeFile2 } from "fs/promises";
+import { join as join29 } from "path";
 
 // ../../packages/plugin-runtime/src/attached/atomic-publish.ts
 import { rename as rename2 } from "fs/promises";
@@ -41681,11 +42030,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((resolve2) => {
-  setTimeout(resolve2, ms);
+var delay = (ms) => new Promise((resolve3) => {
+  setTimeout(resolve3, ms);
 });
-var yieldToLoop = () => new Promise((resolve2) => {
-  setImmediate(resolve2);
+var yieldToLoop = () => new Promise((resolve3) => {
+  setImmediate(resolve3);
 });
 async function publishByRename(tmp, file2, move = rename2) {
   for (let attempt = 1; ; attempt += 1) {
@@ -41702,10 +42051,10 @@ async function publishByRename(tmp, file2, move = rename2) {
 
 // ../../packages/plugin-runtime/src/attached/policy-store.ts
 function createPolicyStore(dir = dataDir()) {
-  const file2 = join28(dir, "policy-cache.json");
+  const file2 = join29(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;
@@ -41727,7 +42076,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;
@@ -41773,7 +42122,7 @@ function createPolicyStore(dir = dataDir()) {
 
 // ../../packages/plugin-runtime/src/attached/posture-report-state.ts
 import { readFileSync as readFileSync19 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var POSTURE_REPORT_STATE_FILENAME = ATTACHED_POSTURE_REPORT_FILENAME;
 var OUTCOME_KEYS = {
   ok: true,
@@ -41787,7 +42136,7 @@ var OUTCOME_KEYS = {
 };
 var OUTCOMES = new Set(Object.keys(OUTCOME_KEYS));
 function postureReportStatePath(dataDir2) {
-  return join29(dataDir2, POSTURE_REPORT_STATE_FILENAME);
+  return join30(dataDir2, POSTURE_REPORT_STATE_FILENAME);
 }
 function writePostureReportState(dataDir2, state) {
   try {
@@ -41966,12 +42315,12 @@ function readStorePosture(dbPath2) {
 
 // ../../packages/plugin-runtime/src/attached/posture-store.ts
 import { randomUUID as randomUUID17 } from "crypto";
-import { readFile as readFile3, rm as rm2, writeFile as writeFile3 } from "fs/promises";
-import { join as join30 } from "path";
+import { readFile as readFile4, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { join as join31 } 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 = join30(dir, "posture-state.json");
-  const legacyFile = legacyDir === void 0 ? null : join30(legacyDir, "posture-state.json");
+  const file2 = join31(dir, "posture-state.json");
+  const legacyFile = legacyDir === void 0 ? null : join31(legacyDir, "posture-state.json");
   async function persist(state) {
     await ensureDataDir(dir);
     const tmp = `${file2}.${randomUUID17()}.tmp`;
@@ -41986,7 +42335,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;
@@ -42040,7 +42389,7 @@ function createPostureStore(dir = settingsDir(), legacyDir) {
 
 // ../../packages/plugin-runtime/src/attached/sync-state.ts
 import { readFileSync as readFileSync20 } from "fs";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 
 // ../../packages/plugin-runtime/src/attached/status.ts
 var REFUSAL_LINES = {
@@ -42161,12 +42510,12 @@ var StandaloneDataGateway = class {
   // reconciler drops the whole pass and recovers it idempotently on the next read.
   recordLlmCalls(inputs) {
     if (inputs.length === 0) return Promise.resolve();
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       try {
         this.db.auditEvents.runInTransaction(() => {
           for (const input2 of inputs) this.db.auditEvents.insertLlmCall(input2);
         });
-        resolve2();
+        resolve3();
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -42178,12 +42527,12 @@ var StandaloneDataGateway = class {
   // drops the whole pass and recovers it idempotently next time.
   recordToolCalls(inputs) {
     if (inputs.length === 0) return Promise.resolve();
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       try {
         this.db.auditEvents.runInTransaction(() => {
           for (const input2 of inputs) this.writeToolCall(input2);
         });
-        resolve2();
+        resolve3();
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -42734,7 +43083,7 @@ function buildSessionRoot(sessionId, input2, ctx, resolved, provider, branch) {
 
 // package.json
 var name = "@akasecurity/plugin-browser-extension";
-var version2 = "0.9.14";
+var version2 = "0.9.15";
 
 // src/native-host/exchange.ts
 var MAX_TARGET_LEN = 500;
@@ -42908,10 +43257,10 @@ function writeMessage(stdout, message2) {
   const body = Buffer.from(JSON.stringify(message2), "utf8");
   const header = Buffer.alloc(4);
   header.writeUInt32LE(body.length, 0);
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     stdout.write(Buffer.concat([header, body]), (err) => {
       if (err) reject(err);
-      else resolve2();
+      else resolve3();
     });
   });
 }