@akasecurity/cli 0.9.14 → 0.9.15

package/native-host/scan-worker.js

@@ -603,6 +603,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();
@@ -761,29 +837,35 @@ function passesPostValidators(rule, value) {
 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,
@@ -792,29 +874,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 ruleset2 = rules ?? getLoadedRules();
-  const extension = context?.filePath ? extensionOf(context.filePath) : void 0;
+function buildCandidates(matchText, ruleset2, extension) {
   const candidates = [];
   for (const rule of ruleset2) {
     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,
@@ -825,10 +898,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;
@@ -836,7 +930,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
@@ -844,6 +938,81 @@ function scan(text, rules, context) {
   }
   return findings;
 }
+function closeRegion(open2, text) {
+  const span = { start: open2.start, end: open2.end };
+  return {
+    ruleId: open2.ruleId,
+    category: open2.category,
+    severity: open2.severity,
+    span,
+    rawMatch: text.slice(span.start, span.end),
+    confidence: open2.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 open2;
+    for (const finding of sorted) {
+      if (open2 && finding.span.start < open2.end) {
+        open2.end = Math.max(open2.end, finding.span.end);
+        open2.confidence = Math.max(open2.confidence, finding.confidence);
+        continue;
+      }
+      if (open2) merged.push(closeRegion(open2, text));
+      open2 = {
+        start: finding.span.start,
+        end: finding.span.end,
+        confidence: finding.confidence,
+        ruleId: finding.ruleId,
+        category: finding.category,
+        severity: finding.severity
+      };
+    }
+    if (open2) merged.push(closeRegion(open2, 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 ruleset2 = rules ?? getLoadedRules();
+  const extension = context?.filePath ? extensionOf(context.filePath) : void 0;
+  const normalization = normalizeFormatChars(text);
+  const originalCandidates = buildCandidates(text, ruleset2, extension);
+  if (!normalization) return gate(originalCandidates, text, void 0);
+  const pooledOriginal = originalCandidates.map(
+    (candidate) => withNormalizedSpan(candidate, normalization)
+  );
+  const normalizedCandidates = buildCandidates(normalization.normalized, ruleset2, extension).map(
+    (candidate) => mapCandidateToOriginal(candidate, normalization, text)
+  );
+  const findings = gate([...pooledOriginal, ...normalizedCandidates], text, normalization);
+  return mergeOverlappingSameRule(findings, text);
+}
 
 // ../../packages/schema/src/exception-scope.ts
 var MINUTE_MS = 6e4;
@@ -22977,7 +23146,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(),
@@ -23956,10 +24147,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(),
@@ -24401,10 +24597,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.
@@ -24412,6 +24616,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" });

package/native-host/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;
@@ -5882,7 +5889,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;
@@ -5892,7 +5899,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;
     }
@@ -5903,7 +5910,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;
     }
@@ -5967,7 +5974,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;
     }
@@ -23007,7 +23014,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(),
@@ -23986,10 +24015,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(),
@@ -24440,10 +24474,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.
@@ -24451,6 +24493,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" });
@@ -24931,11 +24976,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 {
@@ -25451,7 +25496,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;
@@ -25477,7 +25522,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")
@@ -25718,6 +25763,7 @@ function classifyFailure(err) {
 }
 
 // ../../packages/plugin-runtime/src/attached/with-timeout.ts
+var REQUEST_TIMEOUT_MS = 2e3;
 function withTimeout(promise2, ms) {
   let timer;
   const timeout = new Promise((_, reject) => {
@@ -26422,6 +26468,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();
@@ -26790,13 +26840,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";
@@ -26804,11 +26859,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) {
@@ -26825,10 +26880,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;
@@ -26850,7 +26905,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;
@@ -26945,7 +27000,7 @@ async function runPolicySync(deps) {
 
 // ../../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,
@@ -26967,15 +27022,15 @@ 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";
 var SYNC_STATE_FILENAME = ATTACHED_SYNC_STATE_FILENAME;
 function syncStatePath(dataDir2) {
-  return join31(dataDir2, SYNC_STATE_FILENAME);
+  return join32(dataDir2, SYNC_STATE_FILENAME);
 }
 function writeSyncState(dataDir2, result) {
   try {