@akasecurity/cli 0.9.14 → 0.9.15

package/native-host/history-sync.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 basename6 = shortcut ? basenameOf(path) : path;
+        const basename7 = 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 ? basename6 : path
+            shortcut && rule._basenameOnly ? basename7 : path
           )) {
             ignored = !negative;
             unignored = negative;
@@ -997,6 +1004,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"
   }
 ];
 
@@ -6032,7 +6043,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;
@@ -6042,7 +6053,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;
     }
@@ -6053,7 +6064,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;
     }
@@ -6117,7 +6128,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;
     }
@@ -23398,7 +23409,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(),
@@ -24954,10 +24987,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(),
@@ -25535,10 +25573,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.
@@ -25546,6 +25592,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" });
@@ -26106,11 +26155,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 {
@@ -32230,7 +32279,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.
@@ -32450,6 +32502,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,
@@ -32474,13 +32527,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
        )`
@@ -32505,7 +32558,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`);
@@ -32522,6 +32581,7 @@ var SqliteSecretVaultRepository = class {
   listStmt;
   replaceCiphertextStmt;
   refreshFingerprintStmt;
+  setIdentityStmt;
   deleteByPointerStmt;
   derefStmt;
   /**
@@ -32552,6 +32612,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,
@@ -32613,7 +32674,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 });
   }
@@ -32744,7 +32813,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
@@ -32787,7 +32856,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
@@ -32891,6 +32960,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",
@@ -32947,16 +33028,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`.
@@ -32979,12 +33060,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 IS NULL OR latest.status != 'resolved') THEN 1
+                       AND latest.status = 'resolved' THEN 1
                       ELSE 0
-                    END) AS open_at_rest
+                    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 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 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
@@ -32999,11 +33093,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
@@ -33320,10 +33418,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.
@@ -33351,6 +33449,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
@@ -33367,16 +33467,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
@@ -34422,6 +34513,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;
@@ -34605,6 +34721,7 @@ function openLocalDatabase(dir, options = {}) {
     inspectionDefinitions,
     inspectionFindings,
     recordCapture,
+    dismissOpenFindingsForRule,
     markCaptureDelivered,
     markCaptureOwed,
     markAuditEventsDelivered,
@@ -34859,7 +34976,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;
@@ -34885,7 +35002,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")
@@ -35074,6 +35191,9 @@ function createRemoteClient(options) {
   };
 }
 
+// ../../packages/plugin-runtime/src/attached/with-timeout.ts
+var REQUEST_TIMEOUT_MS = 2e3;
+
 // ../../packages/plugin-runtime/src/attached/forward-drops.ts
 import { readFileSync as readFileSync10 } from "fs";
 import { join as join16 } from "path";
@@ -35706,6 +35826,10 @@ 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");
+
 // ../../packages/detections/src/regex-cache.ts
 var singles = /* @__PURE__ */ new WeakMap();
 var keywordLists = /* @__PURE__ */ new WeakMap();
@@ -36726,13 +36850,18 @@ import { spawn } from "child_process";
 import { fileURLToPath as fileURLToPath2 } 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 basename6, dirname as dirname6, join as join28, resolve as resolve2 } from "path";
+
 // ../../packages/plugin-runtime/src/attached/plugin-block.ts
 import { readFileSync as readFileSync18 } from "fs";
+var INSTALL_RECORD_READ_TIMEOUT_MS = REQUEST_TIMEOUT_MS / 2;
 
 // ../../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";
@@ -36742,7 +36871,7 @@ var ATTEMPTS = 1 + IMMEDIATE_RETRIES + TIMED_RETRIES;
 
 // ../../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 OUTCOME_KEYS = {
   ok: true,
   unauthorized: true,
@@ -36764,12 +36893,12 @@ import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
 
 // ../../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";
 
 // ../../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 = {