@akasecurity/ai-tc-claude-code 0.9.1 → 0.9.3

package/scripts/apply-suppressions.js

@@ -492,14 +492,14 @@ var require_ignore = __commonJS({
 });
 
 // src/apply-suppressions.ts
-import { existsSync as existsSync5, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync9 } from "fs";
 import { userInfo } from "os";
-import { dirname as dirname5, join as join13 } from "path";
+import { dirname as dirname5, join as join14 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // ../../packages/persistence/src/database.ts
 import { randomUUID as randomUUID8 } from "crypto";
-import { existsSync, renameSync, rmSync } from "fs";
+import { existsSync, renameSync as renameSync2, rmSync as rmSync2 } from "fs";
 import { join, sep } from "path";
 import { DatabaseSync } from "node:sqlite";
 
@@ -552,6 +552,18 @@ var SQLITE_MIGRATIONS = [
   {
     tag: "0011_egress_writer",
     sql: '-- Stable per-project reconcile key for egress call sites, plus a host-keyed\n-- egress decision override that survives destination pruning.\n--\n-- DROP INDEX IF EXISTS, not a bare DROP: the applier replays a pending\n-- migration\'s non-index statements verbatim, so a store that lost\n-- uq_share_call_site out of band would throw here \u2014 and on the plugin hook path\n-- that throw is swallowed fail-open, silently stopping capture.\n--\n-- Existing rows carry the old key\'s discriminator into project_key\n-- (\'legacy:\' || project), so the new unique index is a re-encoding of the old\n-- one and cannot collide on rows the old one allowed. Leaving them on the\n-- column default would collapse two projects\' identical file/line hits onto\n-- one key and abort the whole migration. Writer keys are \'git:\'/\'path:\'-\n-- prefixed, so a backfilled row never collides with a captured one either.\n--\n-- egress_decision_override.destination_id becomes nullable with ON DELETE SET\n-- NULL, which SQLite can only do by rebuilding the table. `host` is ADDed\n-- before the rebuild so the copy has a column to read and so the migration\n-- still presents two probeable columns to the applier\'s evidence check.\nALTER TABLE `share_call_site` ADD `project_key` text DEFAULT \'\' NOT NULL;--> statement-breakpoint\nUPDATE `share_call_site` SET `project_key` = \'legacy:\' || `project`;--> statement-breakpoint\nDROP INDEX IF EXISTS `uq_share_call_site`;--> statement-breakpoint\nCREATE UNIQUE INDEX `uq_share_call_site` ON `share_call_site` (`endpoint_id`,`project_key`,`file`,`line`);--> statement-breakpoint\nCREATE INDEX `idx_share_call_site_project` ON `share_call_site` (`project_key`,`endpoint_id`);--> statement-breakpoint\nALTER TABLE `egress_decision_override` ADD `host` text;--> statement-breakpoint\nPRAGMA foreign_keys=OFF;--> statement-breakpoint\nCREATE TABLE `__new_egress_decision_override` (\n	`id` text PRIMARY KEY NOT NULL,\n	`destination_id` text,\n	`host` text,\n	`decision` text NOT NULL,\n	`created_at` integer NOT NULL,\n	`updated_at` integer NOT NULL,\n	FOREIGN KEY (`destination_id`) REFERENCES `share_destination`(`id`) ON UPDATE no action ON DELETE set null\n);\n--> statement-breakpoint\nINSERT INTO `__new_egress_decision_override`("id", "destination_id", "host", "decision", "created_at", "updated_at") SELECT "id", "destination_id", "host", "decision", "created_at", "updated_at" FROM `egress_decision_override`;--> statement-breakpoint\nDROP TABLE `egress_decision_override`;--> statement-breakpoint\nALTER TABLE `__new_egress_decision_override` RENAME TO `egress_decision_override`;--> statement-breakpoint\nPRAGMA foreign_keys=ON;--> statement-breakpoint\nCREATE UNIQUE INDEX `uq_egress_decision_override` ON `egress_decision_override` (`destination_id`);--> statement-breakpoint\nCREATE UNIQUE INDEX `uq_egress_decision_override_host` ON `egress_decision_override` (`host`) WHERE `host` IS NOT NULL;\n'
+  },
+  {
+    tag: "0012_handy_the_captain",
+    sql: "ALTER TABLE `inspection_findings` ADD `finding_key` text;--> statement-breakpoint\nALTER TABLE `inspection_findings` ADD `first_detected_at` integer;--> statement-breakpoint\nCREATE UNIQUE INDEX `uq_inspection_findings_key` ON `inspection_findings` (`finding_key`);"
+  },
+  {
+    tag: "0013_legacy_history_backfill_support",
+    sql: "-- Legacy-to-generalized backfill support: the schema the resumable\n-- events/findings -> audit_events/inspection_findings copy needs (the row\n-- copy itself runs as a batched post-migration installer, not here \u2014 see\n-- @akasecurity/persistence's migrations.ts), plus the audit_events read-path\n-- indexes replacing the ones the legacy events table carried (0009/0010).\n\n-- Tracks how far the batched, resumable copy has advanced through each legacy\n-- table, by rowid, so a copy interrupted mid-run resumes instead of\n-- restarting, and a completed copy is a cheap no-op on every later open.\nCREATE TABLE `legacy_copy_watermark` (\n	`source` text PRIMARY KEY NOT NULL,\n	`last_rowid` integer DEFAULT 0 NOT NULL\n);\n--> statement-breakpoint\n-- Serves the time-range read family that scans a single event_type across a\n-- start/end window (e.g. the Activity timeline) without a full-table scan.\nCREATE INDEX `idx_audit_type_t` ON `audit_events` (`event_type`,`started_at`);\n--> statement-breakpoint\n-- Partial expression index mirroring `idx_events_code_change_path` (0009) for\n-- the generalized audit_events/attributes pair: file-path reads filter\n-- `event_type = 'code_change' AND json_extract(attributes, '$.file_path') = :path`.\nCREATE INDEX `idx_audit_code_change_path` ON `audit_events` (json_extract(`attributes`, '$.file_path')) WHERE `event_type` = 'code_change';\n--> statement-breakpoint\n-- Synthesizes a stub session root (event_type = 'session', no attributes) for\n-- every legacy `events.metadata.sessionId` that has no audit_events row yet.\n-- audit_events.root_session_id is a self-FK, enforced with foreign-key\n-- checking on, and INSERT OR IGNORE does not suppress a foreign-key violation\n-- (only UNIQUE/PK/NOT NULL/CHECK) \u2014 so this must run before the events copy\n-- resolves root_session_id, or every session-scoped row's insert fails.\n-- started_at takes the earliest legacy occurred_at recorded under that\n-- session, so the stub root's own timeline position is never later than\n-- anything it will end up parenting.\nINSERT INTO audit_events (id, event_type, root_session_id, started_at)\nSELECT\n	json_extract(metadata, '$.sessionId'),\n	'session',\n	NULL,\n	min(occurred_at)\nFROM events\nWHERE json_valid(metadata)\n	AND json_extract(metadata, '$.sessionId') IS NOT NULL\n	AND json_extract(metadata, '$.sessionId') NOT IN (SELECT id FROM audit_events)\nGROUP BY json_extract(metadata, '$.sessionId');\n"
+  },
+  {
+    tag: "0014_drop_legacy_events_findings",
+    sql: "-- Custom migration: drops the frozen legacy `events`/`findings` tables\n-- (superseded by audit_events/inspection_definitions/inspection_findings) and\n-- replaces them with read-only views of the same name.\n--\n-- persistence's migrations.ts applies this migration ONLY once the batched\n-- history backfill (see runLegacyHistoryBackfill) has fully drained both\n-- tables, and only after copying the live file aside \u2014 see\n-- backupBeforeLegacyDrop in packages/persistence/src/migrations.ts. A store\n-- still mid-copy keeps its real tables and this migration stays pending.\n--\n-- The views exist for skew: the `aka` CLI and the Claude Code plugin update\n-- independently against one shared store, so an older, already-installed\n-- binary can open a store a newer binary already dropped these tables on.\n-- Every already-shipped repository constructor prepares its SQL eagerly at\n-- open time, so a bare \"table not found\" would fail the WHOLE open, not just\n-- a findings-specific read \u2014 these views keep `prepare()` succeeding so an\n-- old binary's unrelated features keep working; its own reads stay truthful,\n-- and its rare (already fail-open) writes fail at run time instead.\n--\n-- The 0009/0010 expression indexes existed only over the legacy `events`\n-- table; DROP TABLE below would remove them implicitly, but they are\n-- dropped explicitly first so the intent reads clearly. IF EXISTS so a store\n-- that reached here with an index missing out of band (an adopted-tag store\n-- whose physical index was never built) does not throw a deterministic \"no\n-- such index\" out of the fail-open drop path.\nDROP INDEX IF EXISTS `idx_events_code_change_path`;\n--> statement-breakpoint\nDROP INDEX IF EXISTS `idx_events_session_id`;\n--> statement-breakpoint\n-- `findings.event_id` references `events.id` \u2014 drop the child first.\nDROP TABLE `findings`;\n--> statement-breakpoint\nDROP TABLE `events`;\n--> statement-breakpoint\n-- Legacy `events` shape, projected from audit_events: `kind`/`occurred_at`/\n-- `source_tool` become real columns again (source_tool round-trips through\n-- the attributes bag, the only place a capture-typed audit row keeps it);\n-- `metadata` is reconstructed as the old camelCase JSON object from the new\n-- snake_case attributes bag, with `root_session_id` folded back in as\n-- `sessionId` (the one legacy metadata key that became a column, never an\n-- attribute, on the new table). Constrained to the four capture kinds so\n-- structural rows (session/run/tool_call/llm_call/source_lookup/config_scan)\n-- never leak into a legacy reader's result set \u2014 the old `events` table\n-- never held them either.\nCREATE VIEW `events` AS\nSELECT\n  id,\n  json_extract(attributes, '$.source_tool') AS source_tool,\n  event_type AS kind,\n  started_at AS occurred_at,\n  content_hash,\n  content,\n  -- Plugin-local bookkeeping column that `ensureSyncedAtColumn` adds to the\n  -- real `events` table at open time. A pre-cutover binary runs that probe on\n  -- EVERY open; without this projection its `columnNames('events')` check\n  -- misses `synced_at` and issues `ALTER TABLE events ADD COLUMN` against this\n  -- view, which SQLite rejects (\"Cannot add a column to a view\") \u2014 a hard,\n  -- non-fail-open crash of the whole open, the exact skew failure these views\n  -- exist to prevent. Projecting it (always NULL; no reader consumes it)\n  -- short-circuits that ALTER.\n  NULL AS synced_at,\n  json_object(\n    'sessionId', root_session_id,\n    'repo', json_extract(attributes, '$.repo'),\n    'filePath', json_extract(attributes, '$.file_path'),\n    'toolName', json_extract(attributes, '$.tool_name'),\n    'gitignored', json_extract(attributes, '$.gitignored'),\n    'wholeFile', json_extract(attributes, '$.whole_file'),\n    'model', json_extract(attributes, '$.model'),\n    'turnIndex', json_extract(attributes, '$.turn_index'),\n    'correlationId', json_extract(attributes, '$.correlation_id'),\n    'traceId', json_extract(attributes, '$.trace_id'),\n    'exceptionIds', json_extract(attributes, '$.exception_ids')\n  ) AS metadata\nFROM audit_events\nWHERE event_type IN ('prompt', 'response', 'code_change', 'tool_use');\n--> statement-breakpoint\n-- A plain single-row INSERT (the old writer's shape \u2014 no ON CONFLICT) is\n-- accepted by prepare() against a view once an INSTEAD OF INSERT trigger\n-- exists, so it fails at run time instead of at open \u2014 landing in the same\n-- fail-open path the caller already wraps its write in.\nCREATE TRIGGER `trg_events_ro`\nINSTEAD OF INSERT ON `events`\nBEGIN SELECT RAISE(ABORT, 'events is read-only; write to audit_events instead'); END;\n--> statement-breakpoint\n-- Legacy `findings` shape: rule_id/category/severity come from the joined\n-- inspection_definitions row (the legacy table inlined them per-row; the\n-- generalized schema normalizes them out into the shared definition). A view\n-- has no rowid of its own, so the underlying table's rowid is re-exposed\n-- explicitly under that name \u2014 a legacy reader ordering by `f.rowid` would\n-- otherwise fail to resolve the column at all. Joined to audit_events for the\n-- same four-capture-kind constraint as the events view above (a finding\n-- attached to a tool_call/config_scan row never existed in the legacy table\n-- either \u2014 see the persistence findings repository's identical predicate).\nCREATE VIEW `findings` AS\nSELECT\n  f.id AS id,\n  f.rowid AS rowid,\n  f.audit_event_id AS event_id,\n  d.rule_id AS rule_id,\n  d.category AS category,\n  d.severity AS severity,\n  f.span_start AS span_start,\n  f.span_end AS span_end,\n  f.masked_match AS masked_match,\n  f.action_taken AS action_taken,\n  f.confidence AS confidence,\n  f.finding_key AS finding_key,\n  f.first_detected_at AS first_detected_at\nFROM inspection_findings f\nJOIN audit_events e ON e.id = f.audit_event_id\nJOIN inspection_definitions d ON d.id = f.inspection_definition_id\nWHERE e.event_type IN ('prompt', 'response', 'code_change', 'tool_use');\n--> statement-breakpoint\n-- Defense in depth only: SQLite refuses to plan ANY upsert against a view\n-- (\"cannot UPSERT a view\") no matter what trigger exists, so this can never\n-- rescue the real legacy writer, which always used\n-- `ON CONFLICT (finding_key) DO UPDATE` \u2014 that statement still fails at\n-- prepare() on an old binary, same as it would with no trigger at all. This\n-- only covers a plain-INSERT shape, should one ever exist.\nCREATE TRIGGER `trg_findings_ro`\nINSTEAD OF INSERT ON `findings`\nBEGIN SELECT RAISE(ABORT, 'findings is read-only; write to inspection_findings instead'); END;\n"
   }
 ];
 
@@ -15382,7 +15394,12 @@ var FindingFacets = external_exports.object({
   severity: external_exports.array(FindingFacetItem),
   subtype: external_exports.array(FindingFacetItem),
   provider: external_exports.array(FindingFacetItem),
-  action: external_exports.array(FindingFacetItem)
+  action: external_exports.array(FindingFacetItem),
+  // Counts by the group's derived status. The SQLite store derives a status
+  // for every instance, so every group lands in a bucket; a status-less
+  // group (possible only for callers whose rows carry no statuses) is
+  // counted under no value.
+  status: external_exports.array(FindingFacetItem)
 }).meta({ id: "FindingFacets" });
 var DEFAULT_GROUPED_FINDINGS_LIMIT = 50;
 var ListGroupedFindingsQuery = external_exports.object({
@@ -15392,6 +15409,10 @@ var ListGroupedFindingsQuery = external_exports.object({
   subtype: external_exports.array(external_exports.string()).optional(),
   provider: external_exports.array(FindingProvider).optional(),
   action: external_exports.array(FindingAction).optional(),
+  // Matches a group's DERIVED status (see FindingGroup.status), not its
+  // individual instances' — so a filtered group's Status column always reads
+  // one of the requested values.
+  status: external_exports.array(FindingStatus).optional(),
   q: external_exports.string().optional(),
   // Scope to findings whose event carries this session id (the Activity page's
   // session → findings drilldown). Findings without a session never match.
@@ -15579,6 +15600,33 @@ var ToolCallAttributes = external_exports.object({
   parent_uuid: external_exports.string().optional(),
   run_key: external_exports.string().optional()
 }).catchall(external_exports.unknown());
+var CaptureAttributes = external_exports.object({
+  // The harness/tool that produced the capture (`claude-code`, `cli`, …). A
+  // column on the legacy `events` table; here it rides the bag because a
+  // capture-typed audit row has no equivalent column of its own.
+  source_tool: external_exports.string().optional(),
+  file_path: external_exports.string().optional(),
+  repo: external_exports.string().optional(),
+  // The host tool whose input/output was scanned (e.g. 'Bash', 'WebFetch') —
+  // gives a non-file capture a display location ("via Bash") when file_path
+  // is absent. The tool NAME only, never its arguments/output.
+  tool_name: external_exports.string().optional(),
+  // Presence-only provenance flag: set when the file is excluded by the
+  // repo's .gitignore. Omitted (not false) for tracked files.
+  gitignored: external_exports.boolean().optional(),
+  // Set ONLY when the capture is a COMPLETE file snapshot (a worktree scan
+  // reading from disk), never a partial fragment (a hook-captured edit).
+  whole_file: external_exports.boolean().optional(),
+  // Distributed-tracing correlation: `correlation_id` ties the capture back to
+  // the request that produced it; `trace_id` is the originating span's W3C
+  // trace id when telemetry is enabled.
+  correlation_id: external_exports.uuid().optional(),
+  trace_id: external_exports.string().regex(/^[0-9a-f]{32}$/).optional(),
+  // Ids of the detection exceptions that downgraded findings in this capture
+  // to 'allow' — the enforcement audit trail's link back to the grant that
+  // authorized the bypass.
+  exception_ids: external_exports.array(external_exports.guid()).optional()
+}).catchall(external_exports.unknown());
 var ToolCallInspection = external_exports.object({
   ruleId: external_exports.string().min(1),
   ruleName: external_exports.string(),
@@ -15665,7 +15713,18 @@ var InspectionFindingInput = external_exports.object({
   span: Span,
   maskedMatch: external_exports.string(),
   actionTaken: ActionTaken,
-  confidence: external_exports.number().min(0).max(1)
+  confidence: external_exports.number().min(0).max(1),
+  // Stable, content-addressed key correlating this finding across re-detections
+  // — mirrors the legacy `findings.finding_key` (uq_inspection_findings_key is
+  // its unique index). Optional: only an at-rest/re-scannable finding carries
+  // one; an in-flight capture (prompt/response) has nothing to re-detect
+  // against and leaves it unset, so every insert is a fresh row.
+  findingKey: external_exports.string().optional(),
+  // The ORIGINAL detection time, preserved across a later re-detection of the
+  // same findingKey — mirrors the legacy `findings.first_detected_at`.
+  // Optional: when omitted, the writer derives it from the referenced audit
+  // event's startedAt on first insert (see SqliteInspectionFindingsRepository).
+  firstDetectedAt: external_exports.iso.datetime().optional()
 });
 var InventoryContext = external_exports.object({
   host: InventoryInput.optional(),
@@ -15867,6 +15926,7 @@ var ActivityOverviewResponse = external_exports.object({
 
 // ../../packages/schema/src/zod/event.ts
 var EventKind = external_exports.enum(["prompt", "response", "code_change", "tool_use"]).meta({ id: "EventKind" });
+var CAPTURE_EVENT_TYPES_SQL = EventKind.options.map((k) => `'${k}'`).join(",");
 var SourceTool = external_exports.enum(["claude-code", "claude-desktop", "cursor", "chatgpt", "github-copilot", "cli", "unknown"]).meta({ id: "SourceTool" });
 var EventMetadata = external_exports.object({
   sessionId: external_exports.string().optional(),
@@ -16356,6 +16416,12 @@ var PolicyBundle = external_exports.object({
   // on-disk caches — that omit the field still parse; consumers read
   // `bundle.exceptions ?? []`.
   exceptions: external_exports.array(ExceptionBundleEntry).optional(),
+  // Installed pack version, keyed by ruleId, for rules in `rules` that came
+  // from a versioned installed pack. Optional so older backends — and older
+  // on-disk caches — that omit the field still parse; consumers fall back to
+  // the rule's own spec version. NOT the bundle version above — see
+  // installedRuleset's ruleVersions for the source of truth.
+  ruleVersions: external_exports.record(external_exports.string(), external_exports.string()).optional(),
   customKeywords: external_exports.array(external_exports.string()),
   fetchedAt: external_exports.iso.datetime()
 }).meta({ id: "PolicyBundle" });
@@ -17160,6 +17226,15 @@ function groupActions(g) {
   actionsCache.set(g, actions);
   return actions;
 }
+function countInstancesByStatus(statusInputs, statuses) {
+  const statusSet = new Set(statuses);
+  let sum = 0;
+  for (const input of statusInputs) {
+    if (input.count === void 0) return null;
+    if (statusSet.has(deriveFindingStatus(input))) sum += input.count;
+  }
+  return sum;
+}
 function applyFindingFilters(groups, opts) {
   let filtered = groups;
   if (opts.severity && opts.severity.length > 0) {
@@ -17178,6 +17253,10 @@ function applyFindingFilters(groups, opts) {
     const subtypeSet = new Set(opts.subtype);
     filtered = filtered.filter((g) => subtypeSet.has(g.subtype));
   }
+  if (opts.statuses && opts.statuses.length > 0) {
+    const statusSet = new Set(opts.statuses);
+    filtered = filtered.filter((g) => g.status !== void 0 && statusSet.has(g.status));
+  }
   if (opts.q) {
     const q = opts.q.toLowerCase();
     filtered = filtered.filter((g) => groupHaystack(g).includes(q));
@@ -17199,6 +17278,7 @@ function computeFindingFacets(allGroups, opts) {
   const forSeverity = applyFindingFilters(allGroups, {
     providers: opts.providers,
     actions: opts.actions,
+    statuses: opts.statuses,
     q: opts.q,
     subtype: opts.subtype
   });
@@ -17208,6 +17288,7 @@ function computeFindingFacets(allGroups, opts) {
   }
   const forProvider = applyFindingFilters(allGroups, {
     actions: opts.actions,
+    statuses: opts.statuses,
     q: opts.q,
     subtype: opts.subtype,
     severity: opts.severity
@@ -17218,6 +17299,7 @@ function computeFindingFacets(allGroups, opts) {
   }
   const forAction = applyFindingFilters(allGroups, {
     providers: opts.providers,
+    statuses: opts.statuses,
     q: opts.q,
     subtype: opts.subtype,
     severity: opts.severity
@@ -17229,17 +17311,30 @@ function computeFindingFacets(allGroups, opts) {
   const forSubtype = applyFindingFilters(allGroups, {
     providers: opts.providers,
     actions: opts.actions,
+    statuses: opts.statuses,
     q: opts.q,
     severity: opts.severity
   });
   const subtypeMap = /* @__PURE__ */ new Map();
   for (const g of forSubtype) subtypeMap.set(g.subtype, (subtypeMap.get(g.subtype) ?? 0) + 1);
+  const forStatus = applyFindingFilters(allGroups, {
+    providers: opts.providers,
+    actions: opts.actions,
+    q: opts.q,
+    subtype: opts.subtype,
+    severity: opts.severity
+  });
+  const statusMap = /* @__PURE__ */ new Map();
+  for (const g of forStatus) {
+    if (g.status !== void 0) statusMap.set(g.status, (statusMap.get(g.status) ?? 0) + 1);
+  }
   const toItems = (m) => [...m.entries()].map(([value, count]) => ({ value, count }));
   return {
     severity: toItems(severityMap),
     provider: toItems(providerMap),
     action: toItems(actionMap),
-    subtype: toItems(subtypeMap)
+    subtype: toItems(subtypeMap),
+    status: toItems(statusMap)
   };
 }
 
@@ -17274,10 +17369,18 @@ var PatchInstalledPackRequest = external_exports.object({
 }).meta({ id: "PatchInstalledPackRequest" });
 
 // ../../packages/schema/src/zod/local.ts
-var WORKSPACE_SETTINGS_SPEC_VERSION = 3;
+var WORKSPACE_SETTINGS_SPEC_VERSION = 4;
+var MODEL_JUDGE_PAYLOAD_VERSION = 1;
 var RunMode = external_exports.enum(["standalone"]);
 var SimpleDetectionPolicy = external_exports.enum(["redact", "warn"]);
 var HistoricalAccess = external_exports.enum(["full", "session-only"]);
+var ModelJudgeConsent = external_exports.object({
+  acknowledgedAt: external_exports.iso.datetime(),
+  payloadVersion: external_exports.number().int().positive()
+});
+function isModelJudgeConsentValid(consent) {
+  return consent?.payloadVersion === MODEL_JUDGE_PAYLOAD_VERSION;
+}
 var WorkspaceSettings = external_exports.object({
   specVersion: external_exports.number().int().positive().default(WORKSPACE_SETTINGS_SPEC_VERSION),
   // Settings files written by earlier releases may carry the retired 'attached'
@@ -17293,37 +17396,16 @@ var WorkspaceSettings = external_exports.object({
   // Shares writes.
   dataSharesInPlace: external_exports.boolean().default(true),
   // Absent until /aka:setup completes; its presence is what "onboarded" means.
-  onboardedAt: external_exports.iso.datetime().optional()
+  onboardedAt: external_exports.iso.datetime().optional(),
+  // Records that the user consented to sending findings to the model API for
+  // the /aka:setup judge, along with the payload-shape version they agreed to.
+  // Absent until granted; a stale payloadVersion means the consent no longer
+  // covers the current payload and must be re-granted.
+  modelJudgeConsent: ModelJudgeConsent.optional()
 });
 function defaultWorkspaceSettings() {
   return WorkspaceSettings.parse({});
 }
-function toEventRow(event) {
-  return {
-    id: event.id,
-    sourceTool: event.sourceTool,
-    kind: event.kind,
-    occurredAt: isoToEpochMillis(event.occurredAt),
-    contentHash: event.contentHash,
-    content: event.content,
-    metadata: event.metadata ? JSON.stringify(event.metadata) : null
-  };
-}
-function toFindingRow(finding) {
-  return {
-    id: finding.id,
-    eventId: finding.eventId,
-    ruleId: finding.ruleId,
-    category: finding.category,
-    severity: finding.severity,
-    spanStart: finding.span.start,
-    spanEnd: finding.span.end,
-    maskedMatch: finding.maskedMatch,
-    actionTaken: finding.actionTaken,
-    confidence: finding.confidence,
-    findingKey: finding.findingKey ?? null
-  };
-}
 function toInventoryRow(input, id, now) {
   return {
     id,
@@ -17393,7 +17475,42 @@ function toInspectionFindingRow(input) {
     spanEnd: input.span.end,
     maskedMatch: input.maskedMatch,
     actionTaken: input.actionTaken,
-    confidence: input.confidence
+    confidence: input.confidence,
+    findingKey: input.findingKey ?? null,
+    firstDetectedAt: input.firstDetectedAt ? isoToEpochMillis(input.firstDetectedAt) : null
+  };
+}
+function toCaptureAttributes(event) {
+  const metadata = event.metadata;
+  return {
+    source_tool: event.sourceTool,
+    ...metadata?.repo !== void 0 ? { repo: metadata.repo } : {},
+    ...metadata?.filePath !== void 0 ? { file_path: metadata.filePath } : {},
+    ...metadata?.toolName !== void 0 ? { tool_name: metadata.toolName } : {},
+    ...metadata?.gitignored !== void 0 ? { gitignored: metadata.gitignored } : {},
+    ...metadata?.wholeFile !== void 0 ? { whole_file: metadata.wholeFile } : {},
+    ...metadata?.correlationId !== void 0 ? { correlation_id: metadata.correlationId } : {},
+    ...metadata?.traceId !== void 0 ? { trace_id: metadata.traceId } : {},
+    ...metadata?.exceptionIds !== void 0 ? { exception_ids: metadata.exceptionIds } : {},
+    // `model`/`turnIndex` have no dedicated CaptureAttributes field (no writer
+    // has ever populated either), but every legacy metadata key still rides
+    // the bag rather than being silently dropped — CaptureAttributes'
+    // `.catchall(z.unknown())` carries the long tail.
+    ...metadata?.model !== void 0 ? { model: metadata.model } : {},
+    ...metadata?.turnIndex !== void 0 ? { turn_index: metadata.turnIndex } : {}
+  };
+}
+function captureDefinitionVersion(finding) {
+  return `capture/${finding.category}/${finding.severity}`;
+}
+function toCaptureDefinitionInput(finding) {
+  return {
+    ruleId: finding.ruleId,
+    version: captureDefinitionVersion(finding),
+    name: finding.ruleId,
+    category: finding.category,
+    severity: finding.severity,
+    definition: JSON.stringify({ ruleId: finding.ruleId })
   };
 }
 
@@ -17821,6 +17938,37 @@ function reviewSeverityRank(reasons) {
   return Math.min(...reasons.map((r) => REVIEW_SEVERITY_RANK[r]));
 }
 
+// ../../packages/persistence/src/ids.ts
+import { createHash } from "crypto";
+function sha256Hex(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function inventoryId(objectType, identityKey) {
+  return sha256Hex(canonicalIdentity(["inventory", objectType, identityKey]));
+}
+function sourceProjectId(url2) {
+  return sha256Hex(canonicalIdentity(["source_project", url2]));
+}
+function classifiedDataId(cls) {
+  return sha256Hex(canonicalIdentity(["classified_data", cls]));
+}
+function inspectionDefinitionId(ruleId, version2) {
+  return sha256Hex(canonicalIdentity(["inspection_definition", ruleId, version2]));
+}
+function llmCallId(sessionId, messageId) {
+  return sha256Hex(canonicalIdentity(["audit_event_llm_call", sessionId, messageId]));
+}
+function toolCallId(sessionId, toolUseId) {
+  return sha256Hex(canonicalIdentity(["audit_event_tool_call", sessionId, toolUseId]));
+}
+var NO_SESSION = "no_session";
+var NO_PATH = "no_path";
+function captureId(sessionId, contentHash, filePath = null) {
+  return sha256Hex(
+    canonicalIdentity(["capture", sessionId ?? NO_SESSION, contentHash, filePath ?? NO_PATH])
+  );
+}
+
 // ../../packages/persistence/src/internal/sql-text.ts
 function escapeLikePattern(s) {
   return s.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
@@ -17917,28 +18065,81 @@ function evidenceExists(db, object2) {
   return schemaObjectExists(db, "table", object2.name);
 }
 
-// ../../packages/persistence/src/ids.ts
-import { createHash } from "crypto";
-function sha256Hex(input) {
-  return createHash("sha256").update(input).digest("hex");
+// ../../packages/persistence/src/internal/rows.ts
+function allRows(stmt, params) {
+  if (params === void 0) return stmt.all();
+  if (Array.isArray(params)) return stmt.all(...params);
+  return stmt.all(params);
 }
-function inventoryId(objectType, identityKey) {
-  return sha256Hex(canonicalIdentity(["inventory", objectType, identityKey]));
+function getRow(stmt, params) {
+  if (params === void 0) return stmt.get();
+  if (Array.isArray(params)) return stmt.get(...params);
+  return stmt.get(params);
 }
-function sourceProjectId(url2) {
-  return sha256Hex(canonicalIdentity(["source_project", url2]));
+function intToBool(raw) {
+  return raw === 1 || raw === true;
 }
-function classifiedDataId(cls) {
-  return sha256Hex(canonicalIdentity(["classified_data", cls]));
+function boolToInt(b) {
+  return b ? 1 : 0;
 }
-function inspectionDefinitionId(ruleId, version2) {
-  return sha256Hex(canonicalIdentity(["inspection_definition", ruleId, version2]));
+function bindParams(row) {
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    out[key] = value === void 0 ? null : value;
+  }
+  return out;
 }
-function llmCallId(sessionId, messageId) {
-  return sha256Hex(canonicalIdentity(["audit_event_llm_call", sessionId, messageId]));
+function countScalar(db, sql, params) {
+  return getRow(db.prepare(sql), params)?.n ?? 0;
 }
-function toolCallId(sessionId, toolUseId) {
-  return sha256Hex(canonicalIdentity(["audit_event_tool_call", sessionId, toolUseId]));
+function countBy(db, sql, params) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const row of allRows(db.prepare(sql), params)) {
+    map2.set(row.k, row.n);
+  }
+  return map2;
+}
+function mapRowsTolerant(rows, map2) {
+  const out = [];
+  for (const row of rows) {
+    try {
+      out.push(map2(row));
+    } catch {
+    }
+  }
+  return out;
+}
+
+// ../../packages/persistence/src/paths.ts
+import { chmodSync, lstatSync, mkdirSync, renameSync, rmSync, writeFileSync } from "fs";
+var DATA_DIR_MODE = 448;
+var DATA_FILE_MODE = 384;
+var DB_FILENAME = "aka.db";
+function chmodBestEffort(path, mode) {
+  try {
+    chmodSync(path, mode);
+  } catch {
+  }
+}
+function tightenDir(dir) {
+  chmodBestEffort(dir, DATA_DIR_MODE);
+}
+function ensureDataDirSync(dir) {
+  mkdirSync(dir, { recursive: true, mode: DATA_DIR_MODE });
+  tightenDir(dir);
+}
+function dbSidecars(file2) {
+  return [`${file2}-wal`, `${file2}-shm`, `${file2}-journal`];
+}
+function tightenFile(file2) {
+  try {
+    if (lstatSync(file2).isSymbolicLink()) return;
+  } catch {
+  }
+  chmodBestEffort(file2, DATA_FILE_MODE);
+}
+function tightenPerms(file2) {
+  for (const path of [file2, ...dbSidecars(file2)]) chmodBestEffort(path, DATA_FILE_MODE);
 }
 
 // ../../packages/persistence/src/migrations.ts
@@ -17952,7 +18153,8 @@ function createdIndexName(statement) {
   const body = statement.replace(/^(?:\s*--[^\n]*\n?)+/, "").trimStart();
   return /^CREATE (?:UNIQUE )?INDEX (?:IF NOT EXISTS )?`([^`]+)`/.exec(body)?.[1];
 }
-function applyMigrations(db) {
+var LEGACY_DROP_MIGRATION_TAG = "0014_drop_legacy_events_findings";
+function applyMigrations(db, file2) {
   const legacyCount = db.prepare("PRAGMA user_version").get().user_version;
   db.exec(
     "CREATE TABLE IF NOT EXISTS migration_ledger (tag TEXT PRIMARY KEY, applied_at INTEGER NOT NULL)"
@@ -17966,6 +18168,7 @@ function applyMigrations(db) {
   );
   for (const [index, migration] of SQLITE_MIGRATIONS.entries()) {
     if (applied.has(migration.tag)) continue;
+    if (migration.tag === LEGACY_DROP_MIGRATION_TAG) continue;
     const evidence = evidenceObjects(migration.sql);
     const present = evidence.filter((o) => evidenceExists(db, o));
     if (present.length > 0 && present.length < evidence.length) {
@@ -18010,7 +18213,6 @@ function applyMigrations(db) {
   if (legacyCount < SQLITE_MIGRATIONS.length) {
     db.exec(`PRAGMA user_version = ${String(SQLITE_MIGRATIONS.length)}`);
   }
-  ensureSyncedAtColumn(db, "events");
   ensureSyncedAtColumn(db, "audit_events");
   ensureScanLedgerTable(db);
   ensureBlockedDetectionsTable(db);
@@ -18018,6 +18220,47 @@ function applyMigrations(db) {
   ensureWriteGateTrigger(db);
   ensureTokenUsageColumns(db);
   reconcileSourceProjectIds(db);
+  if (!applied.has(LEGACY_DROP_MIGRATION_TAG)) {
+    const drained = runLegacyHistoryBackfill(db);
+    if (drained) applyLegacyDropMigration(db, file2);
+  }
+}
+function applyLegacyDropMigration(db, file2) {
+  const migration = SQLITE_MIGRATIONS.find((m) => m.tag === LEGACY_DROP_MIGRATION_TAG);
+  if (!migration) return;
+  if (file2) {
+    try {
+      backupBeforeLegacyDrop(db, file2);
+    } catch (error51) {
+      akaWarn(`legacy events/findings backup failed; deferring the drop: ${String(error51)}`);
+      return;
+    }
+  }
+  try {
+    withTransaction(
+      db,
+      () => {
+        const alreadyDropped = db.prepare("SELECT 1 FROM migration_ledger WHERE tag = ?").get(migration.tag);
+        if (alreadyDropped) return;
+        for (const statement of splitStatements(migration.sql)) {
+          db.exec(statement);
+        }
+        db.prepare("INSERT OR IGNORE INTO migration_ledger (tag, applied_at) VALUES (?, ?)").run(
+          migration.tag,
+          Date.now()
+        );
+      },
+      "IMMEDIATE"
+    );
+  } catch (error51) {
+    akaWarn(`legacy events/findings drop failed; deferring: ${String(error51)}`);
+  }
+}
+function backupBeforeLegacyDrop(db, file2) {
+  const backup = `${file2}.pre-drop.${String(Date.now())}.bak`;
+  db.prepare("VACUUM INTO ?").run(backup);
+  tightenFile(backup);
+  return backup;
 }
 var TOKEN_USAGE_COLUMNS = [
   {
@@ -18046,6 +18289,7 @@ var TOKEN_USAGE_COLUMNS = [
   }
 ];
 function ensureTokenUsageColumns(db) {
+  if (!schemaObjectExists(db, "table", "audit_events")) return;
   const existing = new Set(columnNames(db, "audit_events", { includeGenerated: true }));
   for (const column of TOKEN_USAGE_COLUMNS) {
     if (!existing.has(column.name)) {
@@ -18111,11 +18355,187 @@ function reconcileSourceProjectIds(db) {
     akaWarn(`source_project id reconcile failed: ${String(error51)}`);
   }
 }
+var LEGACY_BACKFILL_BATCH_SIZE = 200;
+var LEGACY_BACKFILL_MAX_ROWS_PER_CALL = 1e3;
+function getLegacyCopyWatermark(db, source) {
+  const row = db.prepare("SELECT last_rowid AS lastRowid FROM legacy_copy_watermark WHERE source = ?").get(source);
+  return row?.lastRowid ?? 0;
+}
+function setLegacyCopyWatermark(db, source, lastRowid) {
+  db.prepare(
+    `INSERT INTO legacy_copy_watermark (source, last_rowid) VALUES (?, ?)
+     ON CONFLICT(source) DO UPDATE SET last_rowid = excluded.last_rowid`
+  ).run(source, lastRowid);
+}
+function drainLegacyTable(db, source, selectStmt, handleRows) {
+  let watermark = getLegacyCopyWatermark(db, source);
+  let processed = 0;
+  while (processed < LEGACY_BACKFILL_MAX_ROWS_PER_CALL) {
+    const rows = selectStmt.all(watermark, LEGACY_BACKFILL_BATCH_SIZE);
+    if (rows.length === 0) return true;
+    withTransaction(
+      db,
+      () => {
+        handleRows(rows);
+        watermark = rows[rows.length - 1]?.rowid ?? watermark;
+        setLegacyCopyWatermark(db, source, watermark);
+      },
+      "IMMEDIATE"
+    );
+    processed += rows.length;
+    if (rows.length < LEGACY_BACKFILL_BATCH_SIZE) return true;
+  }
+  return false;
+}
+function parseLegacyEventMetadata(raw) {
+  if (raw === null) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function toLegacyAuditAttributesJson(row) {
+  return JSON.stringify(
+    toCaptureAttributes({
+      id: row.id,
+      sourceTool: row.sourceTool,
+      kind: row.kind,
+      occurredAt: new Date(row.occurredAt).toISOString(),
+      contentHash: row.contentHash,
+      content: row.content,
+      metadata: row.metadata
+    })
+  );
+}
+function copyLegacyEvents(db) {
+  const selectStmt = db.prepare(
+    `SELECT rowid AS rowid, id, source_tool AS sourceTool, kind, occurred_at AS occurredAt,
+            content_hash AS contentHash, content, metadata
+     FROM events WHERE rowid > ? ORDER BY rowid LIMIT ?`
+  );
+  const insertStmt = db.prepare(
+    `INSERT OR IGNORE INTO audit_events
+       (id, parent_id, root_session_id, event_type, started_at, content, content_hash, attributes)
+     VALUES (:id, :parentId, :rootSessionId, :eventType, :startedAt, :content, :contentHash, :attributes)`
+  );
+  const stubRootStmt = db.prepare(
+    `INSERT OR IGNORE INTO audit_events (id, event_type, started_at) VALUES (?, 'session', ?)`
+  );
+  return drainLegacyTable(
+    db,
+    "events",
+    selectStmt,
+    (rows) => {
+      for (const row of rows) {
+        const metadata = parseLegacyEventMetadata(row.metadata);
+        const sessionId = metadata?.sessionId ?? null;
+        if (sessionId !== null) stubRootStmt.run(sessionId, row.occurredAt);
+        insertStmt.run(
+          bindParams({
+            id: row.id,
+            parentId: sessionId,
+            rootSessionId: sessionId,
+            eventType: row.kind,
+            startedAt: row.occurredAt,
+            content: row.content,
+            contentHash: row.contentHash,
+            attributes: toLegacyAuditAttributesJson({ ...row, metadata })
+          })
+        );
+      }
+    }
+  );
+}
+function copyLegacyFindings(db) {
+  const selectStmt = db.prepare(
+    `SELECT rowid AS rowid, id, event_id AS eventId, rule_id AS ruleId, category, severity,
+            span_start AS spanStart, span_end AS spanEnd, masked_match AS maskedMatch,
+            action_taken AS actionTaken, confidence, finding_key AS findingKey,
+            first_detected_at AS firstDetectedAt
+     FROM findings WHERE rowid > ? ORDER BY rowid LIMIT ?`
+  );
+  const definitionStmt = db.prepare(
+    `INSERT OR IGNORE INTO inspection_definitions
+       (id, rule_id, name, category, severity, definition, version)
+     VALUES (:id, :ruleId, :name, :category, :severity, :definition, :version)`
+  );
+  const findingStmt = db.prepare(
+    `INSERT INTO inspection_findings
+       (id, audit_event_id, inspection_definition_id, classified_data_id,
+        span_start, span_end, masked_match, action_taken, confidence,
+        finding_key, first_detected_at)
+     VALUES
+       (:id, :auditEventId, :inspectionDefinitionId, NULL,
+        :spanStart, :spanEnd, :maskedMatch, :actionTaken, :confidence,
+        :findingKey, :firstDetectedAt)
+     ON CONFLICT(id) DO NOTHING
+     ON CONFLICT (finding_key) DO UPDATE SET
+       first_detected_at = CASE
+         WHEN first_detected_at IS NULL THEN excluded.first_detected_at
+         WHEN excluded.first_detected_at IS NULL THEN first_detected_at
+         ELSE min(first_detected_at, excluded.first_detected_at)
+       END`
+  );
+  return drainLegacyTable(
+    db,
+    "findings",
+    selectStmt,
+    (rows) => {
+      const definitionIds = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const tupleKey = JSON.stringify([row.ruleId, row.category, row.severity]);
+        let definitionId = definitionIds.get(tupleKey);
+        if (definitionId === void 0) {
+          const version2 = `unmigrated/${row.category}/${row.severity}`;
+          definitionId = inspectionDefinitionId(row.ruleId, version2);
+          definitionStmt.run(
+            bindParams({
+              id: definitionId,
+              ruleId: row.ruleId,
+              name: row.ruleId,
+              category: row.category,
+              severity: row.severity,
+              definition: "",
+              version: version2
+            })
+          );
+          definitionIds.set(tupleKey, definitionId);
+        }
+        findingStmt.run(
+          bindParams({
+            id: row.id,
+            auditEventId: row.eventId,
+            inspectionDefinitionId: definitionId,
+            spanStart: row.spanStart,
+            spanEnd: row.spanEnd,
+            maskedMatch: row.maskedMatch,
+            actionTaken: row.actionTaken,
+            confidence: row.confidence,
+            findingKey: row.findingKey,
+            firstDetectedAt: row.firstDetectedAt
+          })
+        );
+      }
+    }
+  );
+}
+function runLegacyHistoryBackfill(db) {
+  try {
+    const eventsCaughtUp = copyLegacyEvents(db);
+    if (!eventsCaughtUp) return false;
+    return copyLegacyFindings(db);
+  } catch (error51) {
+    akaWarn(`legacy history backfill failed: ${String(error51)}`);
+    return false;
+  }
+}
 function isForeignSqliteLineage(db) {
   if (schemaObjectExists(db, "table", "tenants")) return true;
   return columnNames(db, "events").includes("tenant_id");
 }
 function ensureSyncedAtColumn(db, table2) {
+  if (!schemaObjectExists(db, "table", table2)) return;
   if (!columnNames(db, table2).includes("synced_at")) {
     db.exec(`ALTER TABLE ${table2} ADD COLUMN synced_at integer`);
   }
@@ -18136,6 +18556,7 @@ function ensureWriteGateTrigger(db) {
 	CONSTRAINT "ck_pack_write_gate_single_row" CHECK("_pack_write_gate"."id" = 1)
 )`);
   db.exec("INSERT OR IGNORE INTO _pack_write_gate (id, open) VALUES (1, 0)");
+  if (!schemaObjectExists(db, "table", "installed_packs")) return;
   db.exec(`CREATE TRIGGER IF NOT EXISTS trg_installed_packs_write_gate
 BEFORE UPDATE OF version, name, rules_json ON installed_packs
 WHEN (SELECT open FROM _pack_write_gate WHERE id = 1) IS NOT 1
@@ -18163,30 +18584,6 @@ function ensureRuleProbeCacheTable(db) {
   )`);
 }
 
-// ../../packages/persistence/src/paths.ts
-import { chmodSync, mkdirSync } from "fs";
-var DATA_DIR_MODE = 448;
-var DATA_FILE_MODE = 384;
-var DB_FILENAME = "aka.db";
-function ensureDataDirSync(dir) {
-  mkdirSync(dir, { recursive: true, mode: DATA_DIR_MODE });
-  try {
-    chmodSync(dir, DATA_DIR_MODE);
-  } catch {
-  }
-}
-function walSidecars(file2) {
-  return [`${file2}-wal`, `${file2}-shm`];
-}
-function tightenPerms(file2) {
-  for (const path of [file2, ...walSidecars(file2)]) {
-    try {
-      chmodSync(path, DATA_FILE_MODE);
-    } catch {
-    }
-  }
-}
-
 // ../../packages/persistence/src/internal/json.ts
 function safeJson(s, fallback) {
   if (s == null) return fallback;
@@ -18206,60 +18603,15 @@ function parseJsonObject(s) {
   return void 0;
 }
 
-// ../../packages/persistence/src/internal/rows.ts
-function allRows(stmt, params) {
-  if (params === void 0) return stmt.all();
-  if (Array.isArray(params)) return stmt.all(...params);
-  return stmt.all(params);
-}
-function getRow(stmt, params) {
-  if (params === void 0) return stmt.get();
-  if (Array.isArray(params)) return stmt.get(...params);
-  return stmt.get(params);
-}
-function intToBool(raw) {
-  return raw === 1 || raw === true;
-}
-function boolToInt(b) {
-  return b ? 1 : 0;
-}
-function bindParams(row) {
-  const out = {};
-  for (const [key, value] of Object.entries(row)) {
-    out[key] = value === void 0 ? null : value;
-  }
-  return out;
-}
-function countScalar(db, sql, params) {
-  return getRow(db.prepare(sql), params)?.n ?? 0;
-}
-function countBy(db, sql, params) {
-  const map2 = /* @__PURE__ */ new Map();
-  for (const row of allRows(db.prepare(sql), params)) {
-    map2.set(row.k, row.n);
-  }
-  return map2;
-}
-function mapRowsTolerant(rows, map2) {
-  const out = [];
-  for (const row of rows) {
-    try {
-      out.push(map2(row));
-    } catch {
-    }
-  }
-  return out;
-}
-
-// ../../packages/persistence/src/repositories/activity.ts
-var DAY_MS = 864e5;
-var LIVE_ACTIVITY_WINDOW_MS = 30 * 6e4;
-var LAST_ACTIVITY_EXPR = `max(started_at, coalesce(ended_at, started_at))`;
-function defaultTimeZone() {
-  try {
-    return Intl.DateTimeFormat().resolvedOptions().timeZone;
-  } catch {
-    return "UTC";
+// ../../packages/persistence/src/repositories/activity.ts
+var DAY_MS = 864e5;
+var LIVE_ACTIVITY_WINDOW_MS = 30 * 6e4;
+var LAST_ACTIVITY_EXPR = `max(started_at, coalesce(ended_at, started_at))`;
+function defaultTimeZone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    return "UTC";
   }
 }
 function todayWindow(timeZone, nowMs) {
@@ -18867,6 +19219,21 @@ var SqliteAuditEventsRepository = class {
       })
     );
   }
+  // Idempotent stub of a session's structural root. Session-scoped leaves
+  // (captures, llm_call, tool_call) FK parent_id/root_session_id onto this row;
+  // INSERT OR IGNORE does NOT suppress a foreign-key violation (only
+  // UNIQUE/PK/NOT NULL/CHECK), so a session-scoped insert with no root row
+  // raises SQLITE_CONSTRAINT and rolls its whole transaction back — silently
+  // dropping the write under failOpenTransaction. SessionStart's own root write
+  // is itself fail-open and marks "attempted", not "succeeded", so a session
+  // with no root row yet is a real, permanent condition, not a transient race.
+  // The stub carries no dimensions/attributes; an authoritative root
+  // (SessionStart / the reconciler's buildSessionRoot) wins by first-write-wins
+  // on the id PK, so the stub never shadows real data. This is the single named
+  // home for that FK invariant — call it before writing any session-scoped row.
+  ensureSessionRoot(sessionId, startedAt) {
+    this.insertAuditEvent({ id: sessionId, eventType: "session", startedAt });
+  }
   // Insert one transcript-derived `llm_call` leaf. Unlike `insertAuditEvent`
   // (which takes a caller-supplied random id), the id here is MINTED internally
   // from the natural key — `llmCallId(sessionId, messageId)` — tenant-free like the
@@ -19328,8 +19695,14 @@ var SqliteDetectionsRepository = class {
       )
     );
   }
-  // Findings whose parent event occurred in the last 30 days and whose rule_id is
-  // in the given set. Mirrors the security repo's findings⋈events window join.
+  // Findings whose parent audit event occurred in the last 30 days, is one of
+  // the four capture kinds, and whose definition's rule_id is in the given set.
+  // Mirrors the security repo's inspection_findings⋈audit_events window join.
+  // rule_id lives on inspection_definitions, not the finding row, so the join
+  // chains through it. audit_events also holds structural rows (session, run,
+  // tool_call, llm_call, source_lookup, config_scan) that never had a legacy
+  // events counterpart, so the event_type predicate keeps this count identical
+  // to the old findings⋈events one.
   countFindingsLast30d(ruleIds) {
     if (ruleIds.length === 0) return 0;
     const since = this.now() - 30 * DAY_MS2;
@@ -19337,8 +19710,12 @@ var SqliteDetectionsRepository = class {
     return countScalar(
       this.db,
       `SELECT count(*) AS n
-         FROM findings f JOIN events e ON e.id = f.event_id
-         WHERE e.occurred_at >= ? AND f.rule_id IN (${inClause})`,
+         FROM inspection_findings f
+         JOIN audit_events e ON e.id = f.audit_event_id
+         JOIN inspection_definitions d ON d.id = f.inspection_definition_id
+         WHERE e.started_at >= ?
+           AND e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})
+           AND d.rule_id IN (${inClause})`,
       [since, ...ruleIds]
     );
   }
@@ -19348,35 +19725,24 @@ var SqliteDetectionsRepository = class {
 var SqliteEventsRepository = class {
   constructor(db) {
     this.db = db;
-    this.insertStmt = db.prepare(
-      `INSERT INTO events (id, source_tool, kind, occurred_at, content_hash, content, metadata)
-       VALUES (:id, :sourceTool, :kind, :occurredAt, :contentHash, :content, :metadata)`
-    );
   }
   db;
-  insertStmt;
-  insertEvent(event) {
-    const row = toEventRow(event);
-    this.insertStmt.run(
-      bindParams({
-        id: row.id,
-        sourceTool: row.sourceTool,
-        kind: row.kind,
-        occurredAt: row.occurredAt,
-        contentHash: row.contentHash,
-        content: row.content,
-        metadata: row.metadata
-      })
-    );
-  }
-  // Every recorded event's content hash — the historical backfill loads this once
-  // to skip transcript messages it has already stored, so re-running the scan
-  // never duplicates findings.
+  // Every recorded capture's content hash — the historical backfill loads this
+  // once to skip transcript messages it has already stored, so re-running the
+  // scan never duplicates findings.
   // Async (Promise.resolve over synchronous node:sqlite) so it satisfies the
   // async EventsReadPort contract.
+  //
+  // audit_events also holds structural rows (session, run, tool_call, llm_call,
+  // source_lookup, config_scan) with a NULL content_hash, so the capture-kind
+  // predicate isn't load-bearing here — it documents intent and keeps the scan
+  // index-friendly rather than walking rows that can never match.
   contentHashes() {
     const rows = allRows(
-      this.db.prepare("SELECT content_hash FROM events")
+      this.db.prepare(
+        `SELECT content_hash FROM audit_events
+         WHERE event_type IN (${CAPTURE_EVENT_TYPES_SQL})`
+      )
     );
     return Promise.resolve(new Set(rows.map((r) => r.content_hash)));
   }
@@ -19712,17 +20078,20 @@ function parseExceptionRow(row) {
 }
 
 // ../../packages/persistence/src/repositories/resolution-sql.ts
-function latestResolutionStatusSql(findingsAlias) {
+function latestResolutionColumnSql(column, findingsAlias) {
   return `(
-    SELECT fr.status FROM finding_resolution fr
+    SELECT fr.${column} FROM finding_resolution fr
      WHERE fr.finding_key = ${findingsAlias}.finding_key
      ORDER BY fr.created_at DESC, fr.rowid DESC
      LIMIT 1
   )`;
 }
+function latestResolutionStatusSql(findingsAlias) {
+  return latestResolutionColumnSql("status", findingsAlias);
+}
 var LATEST_RESOLUTION_BY_KEY_SQL = `(
-  SELECT finding_key, status FROM (
-    SELECT fr.finding_key, fr.status,
+  SELECT finding_key, status, method, resolved_at FROM (
+    SELECT fr.finding_key, fr.status, fr.method, fr.resolved_at,
            ROW_NUMBER() OVER (
              PARTITION BY fr.finding_key
              ORDER BY fr.created_at DESC, fr.rowid DESC
@@ -19749,68 +20118,21 @@ var DAY_MS3 = 864e5;
 var SqliteFindingsRepository = class {
   constructor(db) {
     this.db = db;
-    this.insertStmt = db.prepare(
-      `INSERT INTO findings (id, event_id, rule_id, category, severity, span_start, span_end, masked_match, action_taken, confidence, finding_key, first_detected_at)
-       VALUES (:id, :eventId, :ruleId, :category, :severity, :spanStart, :spanEnd, :maskedMatch, :actionTaken, :confidence, :findingKey,
-               (SELECT occurred_at FROM events WHERE id = :eventId))
-       ON CONFLICT (finding_key) DO UPDATE SET
-         event_id = excluded.event_id,
-         category = excluded.category,
-         severity = excluded.severity,
-         span_start = excluded.span_start,
-         span_end = excluded.span_end,
-         masked_match = excluded.masked_match,
-         action_taken = excluded.action_taken,
-         confidence = excluded.confidence`
-    );
-    this.sessionDupStmt = db.prepare(
-      `SELECT 1 FROM findings f JOIN events e ON e.id = f.event_id
-       WHERE f.rule_id = :ruleId AND f.masked_match = :maskedMatch
-         AND json_extract(e.metadata, '$.sessionId') = :sessionId
-       LIMIT 1`
-    );
   }
   db;
-  insertStmt;
-  sessionDupStmt;
-  insertFindings(findings, scope = {}) {
-    for (const finding of findings) {
-      if (scope.sessionId && this.isSessionDuplicate(finding, scope.sessionId)) continue;
-      const row = toFindingRow(finding);
-      this.insertStmt.run({
-        id: row.id,
-        eventId: row.eventId,
-        ruleId: row.ruleId,
-        category: row.category,
-        severity: row.severity,
-        spanStart: row.spanStart,
-        spanEnd: row.spanEnd,
-        maskedMatch: row.maskedMatch,
-        actionTaken: row.actionTaken,
-        confidence: row.confidence,
-        findingKey: row.findingKey ?? null
-      });
-    }
-  }
-  // True when an earlier event in the same session already recorded a finding
-  // with the same rule and masked value. The current event is inserted before
-  // its findings, but carries no findings yet, so this never self-matches.
-  isSessionDuplicate(finding, sessionId) {
-    const hit = this.sessionDupStmt.get({
-      ruleId: finding.ruleId,
-      maskedMatch: finding.maskedMatch,
-      sessionId
-    });
-    return hit !== void 0;
-  }
   recentFindings(opts) {
     const limit = opts?.limit ?? 50;
     const rows = allRows(
       this.db.prepare(
-        `SELECT f.id, f.event_id, f.rule_id, f.category, f.severity, f.masked_match,
-                f.action_taken, f.confidence, e.occurred_at, e.source_tool, e.kind
-         FROM findings f JOIN events e ON e.id = f.event_id
-         ORDER BY e.occurred_at DESC, f.rowid DESC
+        `SELECT f.id, f.audit_event_id AS event_id, d.rule_id, d.category, d.severity,
+                f.masked_match, f.action_taken, f.confidence, e.started_at AS occurred_at,
+                json_extract(e.attributes, '$.source_tool') AS source_tool,
+                e.event_type AS kind
+         FROM inspection_findings f
+         JOIN audit_events e ON e.id = f.audit_event_id
+         JOIN inspection_definitions d ON d.id = f.inspection_definition_id
+         WHERE e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})
+         ORDER BY e.started_at DESC, f.rowid DESC
          LIMIT :limit`
       ),
       { limit }
@@ -19832,25 +20154,34 @@ var SqliteFindingsRepository = class {
     );
   }
   /** Live-enforced findings recorded for one session — a bare COUNT over the
-   * session-stamped events (served by idx_events_session_id), so the Activity
+   * session-stamped audit_events (served by idx_audit_session), so the Activity
    * page can label its findings link without the grouped pipeline. */
   sessionFindingsCount(sessionId) {
     if (!sessionId) return Promise.resolve(0);
     return Promise.resolve(
       countScalar(
         this.db,
-        `SELECT count(*) AS n FROM findings f
-           JOIN events e ON e.id = f.event_id
-          WHERE json_extract(e.metadata, '$.sessionId') = :sessionId`,
+        `SELECT count(*) AS n FROM inspection_findings f
+           JOIN audit_events e ON e.id = f.audit_event_id
+          WHERE e.root_session_id = :sessionId
+            AND e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})`,
         { sessionId }
       )
     );
   }
-  /** Per-rule transcript firing tally for one session — reads the OTHER finding
-   * store (inspection_findings, keyed to audit_events): every detection the
-   * transcript pass recorded, counted per firing rather than per unique value.
-   * Rides on session-scoped grouped responses so the findings view can
-   * reconcile the Activity page's tally with the deduped groups it lists. */
+  /** Per-rule transcript firing tally for one session — every detection the
+   * transcript-reconciler pass recorded against the session's `tool_call` rows,
+   * counted per firing rather than per unique value. Rides on session-scoped
+   * grouped responses so the findings view can reconcile the Activity page's
+   * tally with the deduped groups it lists.
+   *
+   * `inspection_findings`/`audit_events` are now the SAME physical tables the
+   * rest of this class reads for the live-capture list above (they used to be
+   * a separate store), so this excludes the four capture kinds those rows
+   * already carry — without that exclusion, every live-capture finding in the
+   * session would be tallied here too, double-counting against the grouped
+   * list this response rides alongside. The reconciler attaches its findings
+   * only to `tool_call` rows, which the exclusion leaves untouched. */
   sessionFirings(sessionId) {
     return Object.fromEntries(
       countBy(
@@ -19860,18 +20191,25 @@ var SqliteFindingsRepository = class {
            JOIN audit_events e ON e.id = f.audit_event_id
            JOIN inspection_definitions d ON d.id = f.inspection_definition_id
           WHERE e.root_session_id = :sessionId
+            AND e.event_type NOT IN (${CAPTURE_EVENT_TYPES_SQL})
           GROUP BY d.rule_id`,
         { sessionId }
       )
     );
   }
   /**
-   * Grouped findings for the dashboard — joins findings⋈events (repo/file/
-   * toolName from event metadata), groups by ruleId, computes per-filter-excluded facets,
-   * applies the requested filters, and sorts by severity then recency. Filtering
+   * Grouped findings for the dashboard — joins inspection_findings⋈audit_events
+   * ⋈inspection_definitions (repo/file/toolName from the audit event's
+   * attributes bag, rule_id/category/severity from the definition), scoped to
+   * the four capture kinds (audit_events also holds structural/reconciler/scan
+   * rows this list must never surface), groups by ruleId, computes
+   * per-filter-excluded facets, applies the requested filters, and sorts by
+   * severity then recency. Filtering
    * and faceting run in JS via the shared @akasecurity/schema helpers. `totals`
    * reflect the full filtered set; `items` is the requested
-   * page (default 50); no cursor (nextCursor is always null).
+   * page (default 50); no cursor (nextCursor is always null). Under a `status`
+   * filter, `totals.findings` counts only instances whose derived status was
+   * requested, and each item's instance preview is narrowed the same way.
    *
    * Two reads, neither of which materializes a row per finding:
    *   1. one aggregate row per rule_id, folding EVERY instance into the numbers
@@ -19884,10 +20222,11 @@ var SqliteFindingsRepository = class {
    * rule is ever restated in SQL.
    */
   listGroupedFindings(query) {
-    const sessionPredicate = query.sessionId ? `WHERE json_extract(e.metadata, '$.sessionId') = :sessionId` : "";
+    const sessionPredicate = query.sessionId ? ` AND e.root_session_id = :sessionId` : "";
+    const predicate = `WHERE e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})${sessionPredicate}`;
     const sessionParams = query.sessionId ? { sessionId: query.sessionId } : {};
     const aggregates = this.groupAggregates(query.q !== void 0 && query.q !== "", {
-      predicate: sessionPredicate,
+      predicate,
       params: sessionParams
     });
     const rows = allRows(
@@ -19895,24 +20234,26 @@ var SqliteFindingsRepository = class {
         `SELECT id, rule_id, category, severity, masked_match, action_taken, confidence,
                 occurred_at, source_tool, repo, file, tool_name, kind, finding_key, latest_status
          FROM (
-           SELECT f.id AS id, f.rule_id AS rule_id, f.category AS category,
-                  f.severity AS severity, f.masked_match AS masked_match,
+           SELECT f.id AS id, d.rule_id AS rule_id, d.category AS category,
+                  d.severity AS severity, f.masked_match AS masked_match,
                   f.action_taken AS action_taken, f.confidence AS confidence,
-                  e.occurred_at AS occurred_at, e.source_tool AS source_tool,
-                  json_extract(e.metadata, '$.repo') AS repo,
-                  json_extract(e.metadata, '$.filePath') AS file,
-                  json_extract(e.metadata, '$.toolName') AS tool_name,
-                  e.kind AS kind, f.finding_key AS finding_key,
+                  e.started_at AS occurred_at,
+                  json_extract(e.attributes, '$.source_tool') AS source_tool,
+                  json_extract(e.attributes, '$.repo') AS repo,
+                  json_extract(e.attributes, '$.file_path') AS file,
+                  json_extract(e.attributes, '$.tool_name') AS tool_name,
+                  e.event_type AS kind, f.finding_key AS finding_key,
                   latest.status AS latest_status,
                   ROW_NUMBER() OVER (
-                    PARTITION BY f.rule_id
-                    ORDER BY e.occurred_at DESC, f.id DESC
+                    PARTITION BY d.rule_id
+                    ORDER BY e.started_at DESC, f.id DESC
                   ) AS rn
-             FROM findings f
-             JOIN events e ON e.id = f.event_id
+             FROM inspection_findings f
+             JOIN audit_events e ON e.id = f.audit_event_id
+             JOIN inspection_definitions d ON d.id = f.inspection_definition_id
              LEFT JOIN ${LATEST_RESOLUTION_BY_KEY_SQL} latest
                ON latest.finding_key = f.finding_key
-             ${sessionPredicate}
+             ${predicate}
          )
          WHERE rn <= :cap
          ORDER BY occurred_at DESC, id DESC`
@@ -19939,17 +20280,29 @@ var SqliteFindingsRepository = class {
       severity: query.severity,
       providers: query.provider,
       actions: query.action,
+      statuses: query.status,
       subtype: query.subtype,
       q: query.q
     };
     const facets = computeFindingFacets(allGroups, filterOpts);
     const sorted = sortFindingGroups(applyFindingFilters(allGroups, filterOpts));
+    const statusFilter = query.status ?? [];
     const totals = {
-      findings: sorted.reduce((acc, g) => acc + g.instanceCount, 0),
+      findings: sorted.reduce((acc, g) => {
+        if (statusFilter.length === 0) return acc + g.instanceCount;
+        const agg = aggregates.get(g.id);
+        return acc + (agg ? countInstancesByStatus(agg.statusInputs, statusFilter) ?? g.instanceCount : g.instanceCount);
+      }, 0),
       groups: sorted.length
     };
     const limit = query.limit ?? DEFAULT_GROUPED_FINDINGS_LIMIT;
-    const items = sorted.slice(0, limit);
+    const statusSet = statusFilter.length > 0 ? new Set(statusFilter) : null;
+    const items = sorted.slice(0, limit).map(
+      (g) => statusSet ? {
+        ...g,
+        instances: g.instances.filter((i) => i.status !== void 0 && statusSet.has(i.status))
+      } : g
+    );
     return Promise.resolve({
       totals,
       facets,
@@ -19963,45 +20316,62 @@ var SqliteFindingsRepository = class {
    * buildFindingGroups cannot recover from a preview. Bounded by the number of
    * distinct rule_ids (the installed packs' rules), not by the store's size.
    *
-   * The per-instance sets ride back as group_concat lists of RAW DB values —
-   * source_tool, action_taken, and the (kind, has-key, latest-status) triples
-   * deriveFindingStatus consumes. Aggregating the status INPUTS rather than a
-   * status keeps the classifier itself in @akasecurity/schema, where
-   * severitySummary's SQL and this query can't drift apart on what 'resolved'
-   * means (see resolution-sql.ts). Each of those sets is bounded by an enum, so
+   * A single scan, folded in two levels: the inner SELECT groups by
+   * (rule_id, status tuple) so each (kind, has-key, latest-status) combination
+   * carries its instance count — countInstancesByStatus needs those counts for
+   * status-scoped totals — and the outer SELECT folds the tuples back to one
+   * row per rule. The per-instance sets ride back as group_concat lists of RAW
+   * DB values — source_tool, action_taken, and the tuples deriveFindingStatus
+   * consumes. Aggregating the status INPUTS rather than a status keeps the
+   * classifier itself in @akasecurity/schema, where severitySummary's SQL and
+   * this query can't drift apart on what 'resolved' means (see
+   * resolution-sql.ts). The concat-of-concats can repeat a value across
+   * tuples; the schema mappers dedupe, and each set is bounded by an enum, so
    * a group's row stays small however many findings it holds.
    *
    * `withSearchText` is the exception, and the one column here that does NOT
-   * stay small: the group's distinct repos/filePaths, whose size tracks how many
-   * distinct paths a rule fired across — for a rule hitting mostly-unique paths
-   * that is a string proportional to the store (~8MB over 200k distinct paths,
-   * and buildHaystack lowercases a second copy). It buys `q` the ability to
-   * match an instance outside the preview, which searching the preview alone
-   * would silently lose, so it is fetched only when the request actually
-   * carries a `q`.
+   * stay small: the group's per-tuple-distinct repos/filePaths, whose size
+   * tracks how many distinct paths a rule fired across — for a rule hitting
+   * mostly-unique paths that is a string proportional to the store (~8MB over
+   * 200k distinct paths, and buildHaystack lowercases a second copy). It buys
+   * `q` the ability to match an instance outside the preview, which searching
+   * the preview alone would silently lose, so it is fetched only when the
+   * request actually carries a `q`. (Substring matching is unaffected by a
+   * path repeating across tuples.)
    */
   groupAggregates(withSearchText, scope) {
-    const searchTextColumns = withSearchText ? `, group_concat(DISTINCT json_extract(e.metadata, '$.repo')) AS repos,
-           group_concat(DISTINCT json_extract(e.metadata, '$.filePath')) AS files,
-           group_concat(DISTINCT 'via ' || json_extract(e.metadata, '$.toolName')) AS tool_names` : `, NULL AS repos, NULL AS files, NULL AS tool_names`;
+    const innerSearchColumns = withSearchText ? `, group_concat(DISTINCT json_extract(e.attributes, '$.repo')) AS repos,
+           group_concat(DISTINCT json_extract(e.attributes, '$.file_path')) AS files,
+           group_concat(DISTINCT 'via ' || json_extract(e.attributes, '$.tool_name')) AS tool_names` : `, NULL AS repos, NULL AS files, NULL AS tool_names`;
     const rows = this.db.prepare(
-      `SELECT f.rule_id AS rule_id,
-                count(*) AS instance_count,
-                max(e.occurred_at) AS latest_at,
-                group_concat(DISTINCT e.source_tool) AS source_tools,
-                group_concat(DISTINCT f.action_taken) AS actions_taken,
-                group_concat(DISTINCT (
-                  e.kind || '${TUPLE_SEP}' ||
-                  (CASE WHEN f.finding_key IS NULL THEN '' ELSE 'k' END) || '${TUPLE_SEP}' ||
-                  coalesce(latest.status, '')
-                )) AS status_inputs
-                ${searchTextColumns}
-           FROM findings f
-           JOIN events e ON e.id = f.event_id
-           LEFT JOIN ${LATEST_RESOLUTION_BY_KEY_SQL} latest
-             ON latest.finding_key = f.finding_key
-          ${scope.predicate}
-          GROUP BY f.rule_id`
+      `SELECT rule_id,
+                sum(tuple_count) AS instance_count,
+                max(latest_at) AS latest_at,
+                group_concat(source_tools) AS source_tools,
+                group_concat(actions_taken) AS actions_taken,
+                group_concat(status_tuple || '${TUPLE_SEP}' || tuple_count) AS status_inputs,
+                group_concat(repos) AS repos,
+                group_concat(files) AS files,
+                group_concat(tool_names) AS tool_names
+           FROM (
+             SELECT d.rule_id AS rule_id,
+                    e.event_type || '${TUPLE_SEP}' ||
+                      (CASE WHEN f.finding_key IS NULL THEN '' ELSE 'k' END) || '${TUPLE_SEP}' ||
+                      coalesce(latest.status, '') AS status_tuple,
+                    count(*) AS tuple_count,
+                    max(e.started_at) AS latest_at,
+                    group_concat(DISTINCT json_extract(e.attributes, '$.source_tool')) AS source_tools,
+                    group_concat(DISTINCT f.action_taken) AS actions_taken
+                    ${innerSearchColumns}
+               FROM inspection_findings f
+               JOIN audit_events e ON e.id = f.audit_event_id
+               JOIN inspection_definitions d ON d.id = f.inspection_definition_id
+               LEFT JOIN ${LATEST_RESOLUTION_BY_KEY_SQL} latest
+                 ON latest.finding_key = f.finding_key
+              ${scope.predicate}
+              GROUP BY d.rule_id, status_tuple
+           )
+          GROUP BY rule_id`
     ).all(scope.params);
     return new Map(
       rows.map((r) => [
@@ -20011,13 +20381,14 @@ var SqliteFindingsRepository = class {
           sourceTools: splitConcat(r.source_tools),
           actionsTaken: splitConcat(r.actions_taken),
           statusInputs: splitConcat(r.status_inputs).map((tuple2) => {
-            const [kind = "", keyMarker = "", latestStatus = ""] = tuple2.split(TUPLE_SEP);
+            const [kind = "", keyMarker = "", latestStatus = "", count = ""] = tuple2.split(TUPLE_SEP);
             return {
               // deriveFindingStatus only distinguishes null from non-null here,
               // so the marker stands in for the key itself (never rendered).
               kind,
               findingKey: keyMarker === "" ? null : keyMarker,
-              latestResolutionStatus: latestStatus === "" ? null : latestStatus
+              latestResolutionStatus: latestStatus === "" ? null : latestStatus,
+              count: Number(count)
             };
           }),
           latestDetectedAt: epochMillisToIso(r.latest_at),
@@ -20034,10 +20405,21 @@ var SqliteFindingsRepository = class {
     );
   }
   healthSummary() {
-    const total = countScalar(this.db, "SELECT count(*) AS n FROM findings");
+    const total = countScalar(
+      this.db,
+      `SELECT count(*) AS n FROM inspection_findings f
+         JOIN audit_events e ON e.id = f.audit_event_id
+        WHERE e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})`
+    );
     const byAction = Object.fromEntries(ACTION_TAKEN_KEYS.map((a) => [a, 0]));
     const grouped = allRows(
-      this.db.prepare("SELECT action_taken, count(*) AS c FROM findings GROUP BY action_taken")
+      this.db.prepare(
+        `SELECT f.action_taken AS action_taken, count(*) AS c
+           FROM inspection_findings f
+           JOIN audit_events e ON e.id = f.audit_event_id
+          WHERE e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})
+          GROUP BY f.action_taken`
+      )
     );
     for (const row of grouped) {
       if (row.action_taken in byAction) byAction[row.action_taken] = row.c;
@@ -20045,12 +20427,15 @@ var SqliteFindingsRepository = class {
     const bySeverity = { critical: 0, high: 0, medium: 0, low: 0 };
     const sevRows = allRows(
       this.db.prepare(
-        `SELECT f.severity AS severity, count(*) AS c
-         FROM findings f
+        `SELECT d.severity AS severity, count(*) AS c
+         FROM inspection_findings f
+         JOIN audit_events e ON e.id = f.audit_event_id
+         JOIN inspection_definitions d ON d.id = f.inspection_definition_id
          LEFT JOIN ${LATEST_RESOLUTION_BY_KEY_SQL} latest
            ON latest.finding_key = f.finding_key
-         WHERE latest.status IS NULL OR latest.status != 'resolved'
-         GROUP BY f.severity`
+         WHERE e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})
+           AND (latest.status IS NULL OR latest.status != 'resolved')
+         GROUP BY d.severity`
       )
     );
     for (const row of sevRows) {
@@ -20071,9 +20456,11 @@ var SqliteFindingsRepository = class {
     const since = startOfUtcDay(Date.now()) - (days - 1) * DAY_MS3;
     const rows = allRows(
       this.db.prepare(
-        `SELECT date(e.occurred_at / 1000, 'unixepoch') AS day, f.action_taken AS action, count(*) AS c
-         FROM findings f JOIN events e ON e.id = f.event_id
-         WHERE e.occurred_at >= :since
+        `SELECT date(e.started_at / 1000, 'unixepoch') AS day, f.action_taken AS action, count(*) AS c
+         FROM inspection_findings f
+         JOIN audit_events e ON e.id = f.audit_event_id
+         WHERE e.started_at >= :since
+           AND e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})
          GROUP BY day, f.action_taken`
       ),
       { since }
@@ -20138,15 +20525,59 @@ var SqliteInspectionFindingsRepository = class {
     this.insertStmt = db.prepare(
       `INSERT INTO inspection_findings
          (id, audit_event_id, inspection_definition_id, classified_data_id,
-          span_start, span_end, masked_match, action_taken, confidence)
+          span_start, span_end, masked_match, action_taken, confidence,
+          finding_key, first_detected_at)
        VALUES
          (:id, :auditEventId, :inspectionDefinitionId, :classifiedDataId,
-          :spanStart, :spanEnd, :maskedMatch, :actionTaken, :confidence)
-       ON CONFLICT(id) DO NOTHING`
+          :spanStart, :spanEnd, :maskedMatch, :actionTaken, :confidence,
+          :findingKey,
+          COALESCE(:firstDetectedAt, (SELECT started_at FROM audit_events WHERE id = :auditEventId)))
+       ON CONFLICT(id) DO UPDATE SET
+         inspection_definition_id = excluded.inspection_definition_id
+       ON CONFLICT (finding_key) DO UPDATE SET
+         audit_event_id = excluded.audit_event_id,
+         inspection_definition_id = excluded.inspection_definition_id,
+         classified_data_id = excluded.classified_data_id,
+         span_start = excluded.span_start,
+         span_end = excluded.span_end,
+         masked_match = excluded.masked_match,
+         action_taken = excluded.action_taken,
+         confidence = excluded.confidence`
+    );
+    this.sessionDupStmt = db.prepare(
+      `SELECT 1 FROM inspection_findings f
+         JOIN audit_events e ON e.id = f.audit_event_id
+         JOIN inspection_definitions d ON d.id = f.inspection_definition_id
+        WHERE d.rule_id = :ruleId AND f.masked_match = :maskedMatch
+          AND e.root_session_id = :sessionId
+          AND e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})
+        LIMIT 1`
+    );
+    this.eventDupStmt = db.prepare(
+      `SELECT 1 FROM inspection_findings f
+         JOIN inspection_definitions d ON d.id = f.inspection_definition_id
+        WHERE f.audit_event_id = :auditEventId AND d.rule_id = :ruleId
+          AND f.masked_match = :maskedMatch
+          AND f.span_start = :spanStart AND f.span_end = :spanEnd
+        LIMIT 1`
     );
   }
   db;
   insertStmt;
+  sessionDupStmt;
+  eventDupStmt;
+  // True when an earlier event in the same session already recorded a finding
+  // with the same rule and masked value. The current event's own findings are
+  // inserted one at a time in caller order, so an earlier finding in the SAME
+  // recordCapture call is visible to a later duplicate check within it too.
+  isSessionDuplicate(ruleId, maskedMatch, sessionId) {
+    return this.sessionDupStmt.get({ ruleId, maskedMatch, sessionId }) !== void 0;
+  }
+  // True when this exact detection (rule + masked value + span) is already
+  // recorded against the given audit event.
+  isEventDuplicate(auditEventId, ruleId, maskedMatch, spanStart, spanEnd) {
+    return this.eventDupStmt.get({ auditEventId, ruleId, maskedMatch, spanStart, spanEnd }) !== void 0;
+  }
   insertFinding(input) {
     const row = toInspectionFindingRow(input);
     this.insertStmt.run(
@@ -20159,7 +20590,9 @@ var SqliteInspectionFindingsRepository = class {
         spanEnd: row.spanEnd,
         maskedMatch: row.maskedMatch,
         actionTaken: row.actionTaken,
-        confidence: row.confidence
+        confidence: row.confidence,
+        findingKey: row.findingKey,
+        firstDetectedAt: row.firstDetectedAt
       })
     );
   }
@@ -20212,8 +20645,8 @@ function isParseableBinaryVersion(version2) {
 
 // ../../packages/persistence/src/repositories/installed-packs.ts
 var DEFAULT_POLICY_ID = DEFAULT_PACK_POLICY_ID;
-function inventorySignature(packs) {
-  return packs.map((p) => `${p.namespace}/${p.packId}@${p.version}#${hashRules(p.rulesJson)}`).sort().join(",");
+function inventorySignature(packs2) {
+  return packs2.map((p) => `${p.namespace}/${p.packId}@${p.version}#${hashRules(p.rulesJson)}`).sort().join(",");
 }
 function hashRules(rulesJson) {
   return createHash2("sha1").update(rulesJson).digest("hex");
@@ -20297,10 +20730,10 @@ var SqliteInstalledPacksRepository = class {
    * Optional — callers that can't know their version (old writers, most plugin
    * hooks) simply leave it null.
    */
-  recordInventory(packs, meta3) {
-    if (packs.length === 0) return;
+  recordInventory(packs2, meta3) {
+    if (packs2.length === 0) return;
     try {
-      const rows = packs.map((pack) => ({
+      const rows = packs2.map((pack) => ({
         namespace: pack.namespace,
         packId: pack.packId,
         version: pack.version,
@@ -20431,7 +20864,7 @@ var SqliteInstalledPacksRepository = class {
   installedRuleset() {
     const rows = allRows(
       this.db.prepare(
-        `SELECT enabled, policy_id AS policyId, rules_json AS rulesJson FROM installed_packs`
+        `SELECT enabled, policy_id AS policyId, rules_json AS rulesJson, version FROM installed_packs`
       )
     );
     const out = {
@@ -20439,7 +20872,8 @@ var SqliteInstalledPacksRepository = class {
       enabledPacks: 0,
       rules: [],
       invalidRules: 0,
-      ruleActions: /* @__PURE__ */ new Map()
+      ruleActions: /* @__PURE__ */ new Map(),
+      ruleVersions: /* @__PURE__ */ new Map()
     };
     for (const row of rows) {
       if (!intToBool(row.enabled)) continue;
@@ -20461,6 +20895,7 @@ var SqliteInstalledPacksRepository = class {
         if (parsed.success) {
           out.rules.push(parsed.data);
           out.ruleActions.set(parsed.data.id, action);
+          out.ruleVersions.set(parsed.data.id, row.version);
         } else out.invalidRules += 1;
       }
     }
@@ -21529,8 +21964,8 @@ var SqlitePoliciesRepository = class {
 
 // ../../packages/persistence/src/repositories/policy-catalog.ts
 var SqlitePolicyCatalogRepository = class {
-  constructor(packs) {
-    this.packs = packs;
+  constructor(packs2) {
+    this.packs = packs2;
   }
   packs;
   getPolicyList(kind) {
@@ -21635,19 +22070,19 @@ var SqliteResolutionsRepository = class {
     );
     this.openAtRestStmt = db.prepare(
       `SELECT DISTINCT f.finding_key AS finding_key
-         FROM findings f
-         JOIN events e ON e.id = f.event_id
-        WHERE e.kind = 'code_change'
-          AND json_extract(e.metadata, '$.filePath') = :path
+         FROM inspection_findings f
+         JOIN audit_events e ON e.id = f.audit_event_id
+        WHERE e.event_type = 'code_change'
+          AND json_extract(e.attributes, '$.file_path') = :path
           AND f.finding_key IS NOT NULL
           AND ${latestResolutionStatusSql("f")} IS NOT 'resolved'`
     );
     this.resolvedAtRestStmt = db.prepare(
       `SELECT DISTINCT f.finding_key AS finding_key
-         FROM findings f
-         JOIN events e ON e.id = f.event_id
-        WHERE e.kind = 'code_change'
-          AND json_extract(e.metadata, '$.filePath') = :path
+         FROM inspection_findings f
+         JOIN audit_events e ON e.id = f.audit_event_id
+        WHERE e.event_type = 'code_change'
+          AND json_extract(e.attributes, '$.file_path') = :path
           AND f.finding_key IS NOT NULL
           AND ${latestResolutionStatusSql("f")} = 'resolved'`
     );
@@ -21870,25 +22305,27 @@ var SqliteSecurityRepository = class {
   severitySummary() {
     const rows = allRows(
       this.db.prepare(
-        `SELECT f.severity AS severity,
+        `SELECT d.severity AS severity,
                 COUNT(*) AS count,
                 SUM(CASE
-                      WHEN e.kind != 'code_change' THEN 1
+                      WHEN e.event_type != 'code_change' THEN 1
                       WHEN f.finding_key IS NULL THEN 0
                       WHEN latest.status = 'resolved' THEN 1
                       ELSE 0
                     END) AS caught,
                 SUM(CASE
-                      WHEN e.kind = 'code_change'
+                      WHEN e.event_type = 'code_change'
                        AND f.finding_key IS NOT NULL
                        AND (latest.status IS NULL OR latest.status != 'resolved') THEN 1
                       ELSE 0
                     END) AS open_at_rest
-         FROM findings f
-         JOIN events e ON e.id = f.event_id
+         FROM inspection_findings f
+         JOIN audit_events e ON e.id = f.audit_event_id
+         JOIN inspection_definitions d ON d.id = f.inspection_definition_id
          LEFT JOIN ${LATEST_RESOLUTION_BY_KEY_SQL} latest
            ON latest.finding_key = f.finding_key
-         GROUP BY f.severity`
+         WHERE e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})
+         GROUP BY d.severity`
       )
     );
     const byRow = new Map(rows.map((r) => [r.severity, r]));
@@ -21954,7 +22391,7 @@ var SqliteSecurityRepository = class {
   // Mean time-to-remediate per bucket, split by severity — a sibling of
   // findingsTimeseries that reuses the same window/bucket/UTC math, but buckets
   // on a different timestamp: findingsTimeseries buckets by first-detection
-  // (events.occurred_at), this buckets by resolution time (the latest
+  // (audit_events.started_at), this buckets by resolution time (the latest
   // finding_resolution row's resolved_at) — it's a "resolved in this bucket"
   // trend, not a "detected in this bucket" one. Only findings whose LATEST
   // resolution row (latest-resolution-wins, same correlated subquery as
@@ -21979,30 +22416,20 @@ var SqliteSecurityRepository = class {
         // first_detected_at is the PRESERVED first-detection time (set once on a
         // finding's INSERT, never overwritten on the re-detection upsert), so MTTR
         // measures from first sighting — not the latest re-scan's event, whose
-        // occurred_at the upsert overwrites onto findings.event_id. COALESCE onto
-        // the parent event's occurred_at defends against any legacy/edge row the
-        // backfill left null.
-        `SELECT COALESCE(f.first_detected_at, e.occurred_at) AS first_detected_at, f.severity AS severity,
-                (
-                  SELECT fr.status FROM finding_resolution fr
-                   WHERE fr.finding_key = f.finding_key
-                   ORDER BY fr.created_at DESC, fr.rowid DESC
-                   LIMIT 1
-                ) AS latest_status,
-                (
-                  SELECT fr.method FROM finding_resolution fr
-                   WHERE fr.finding_key = f.finding_key
-                   ORDER BY fr.created_at DESC, fr.rowid DESC
-                   LIMIT 1
-                ) AS latest_method,
-                (
-                  SELECT fr.resolved_at FROM finding_resolution fr
-                   WHERE fr.finding_key = f.finding_key
-                   ORDER BY fr.created_at DESC, fr.rowid DESC
-                   LIMIT 1
-                ) AS latest_resolved_at
-         FROM findings f JOIN events e ON e.id = f.event_id
+        // started_at the upsert overwrites onto inspection_findings.audit_event_id.
+        // COALESCE onto the parent event's started_at defends against any
+        // legacy/edge row the backfill left null.
+        `SELECT COALESCE(f.first_detected_at, e.started_at) AS first_detected_at, d.severity AS severity,
+                latest.status AS latest_status,
+                latest.method AS latest_method,
+                latest.resolved_at AS latest_resolved_at
+         FROM inspection_findings f
+         JOIN audit_events e ON e.id = f.audit_event_id
+         JOIN inspection_definitions d ON d.id = f.inspection_definition_id
+         LEFT JOIN ${LATEST_RESOLUTION_BY_KEY_SQL} latest
+           ON latest.finding_key = f.finding_key
          WHERE f.finding_key IS NOT NULL
+           AND e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})
            AND EXISTS (
              SELECT 1 FROM finding_resolution fr
               WHERE fr.finding_key = f.finding_key
@@ -22049,11 +22476,13 @@ var SqliteSecurityRepository = class {
     const from = now - RANGE_DAYS[range] * DAY_MS4;
     const rows = allRows(
       this.db.prepare(
-        `SELECT json_extract(e.metadata, '$.repo') AS repo, count(*) AS c
-         FROM findings f JOIN events e ON e.id = f.event_id
-         WHERE e.occurred_at >= :from AND e.occurred_at < :to
-           AND json_extract(e.metadata, '$.repo') IS NOT NULL
-           AND json_extract(e.metadata, '$.repo') != ''
+        `SELECT json_extract(e.attributes, '$.repo') AS repo, count(*) AS c
+         FROM inspection_findings f
+         JOIN audit_events e ON e.id = f.audit_event_id
+         WHERE e.started_at >= :from AND e.started_at < :to
+           AND e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})
+           AND json_extract(e.attributes, '$.repo') IS NOT NULL
+           AND json_extract(e.attributes, '$.repo') != ''
          GROUP BY repo
          ORDER BY c DESC, repo
          LIMIT :limit`
@@ -22077,44 +22506,28 @@ var SqliteSecurityRepository = class {
   // secret came back) is excluded — it is not currently resolved. Legacy
   // at-rest findings with finding_key IS NULL are excluded outright (the
   // resolution lifecycle can never attach to them). Path comes from the
-  // finding's parent event (kind 'code_change', metadata.filePath) — mirrors
-  // resolutions.ts's openAtRestStmt accessor. Ordered by resolved_at DESC,
-  // capped at `limit`.
+  // finding's parent event (event_type 'code_change', attributes.file_path) —
+  // mirrors resolutions.ts's openAtRestStmt accessor. Ordered by resolved_at
+  // DESC, capped at `limit`.
   recentlyResolved(limit = 20) {
     const rows = allRows(
       this.db.prepare(
         `SELECT f.finding_key AS finding_key,
-                f.rule_id AS rule_id,
-                f.severity AS severity,
-                json_extract(e.metadata, '$.filePath') AS path,
-                COALESCE(f.first_detected_at, e.occurred_at) AS first_detected_at,
-                (
-                  SELECT fr.resolved_at FROM finding_resolution fr
-                   WHERE fr.finding_key = f.finding_key
-                   ORDER BY fr.created_at DESC, fr.rowid DESC
-                   LIMIT 1
-                ) AS latest_resolved_at
-         FROM findings f JOIN events e ON e.id = f.event_id
-         WHERE e.kind = 'code_change'
+                d.rule_id AS rule_id,
+                d.severity AS severity,
+                json_extract(e.attributes, '$.file_path') AS path,
+                COALESCE(f.first_detected_at, e.started_at) AS first_detected_at,
+                latest.resolved_at AS latest_resolved_at
+         FROM inspection_findings f
+         JOIN audit_events e ON e.id = f.audit_event_id
+         JOIN inspection_definitions d ON d.id = f.inspection_definition_id
+         LEFT JOIN ${LATEST_RESOLUTION_BY_KEY_SQL} latest
+           ON latest.finding_key = f.finding_key
+         WHERE e.event_type = 'code_change'
            AND f.finding_key IS NOT NULL
-           AND (
-             SELECT fr.status FROM finding_resolution fr
-              WHERE fr.finding_key = f.finding_key
-              ORDER BY fr.created_at DESC, fr.rowid DESC
-              LIMIT 1
-           ) = 'resolved'
-           AND (
-             SELECT fr.method FROM finding_resolution fr
-              WHERE fr.finding_key = f.finding_key
-              ORDER BY fr.created_at DESC, fr.rowid DESC
-              LIMIT 1
-           ) = 'fixed-at-source'
-           AND (
-             SELECT fr.resolved_at FROM finding_resolution fr
-              WHERE fr.finding_key = f.finding_key
-              ORDER BY fr.created_at DESC, fr.rowid DESC
-              LIMIT 1
-           ) IS NOT NULL
+           AND latest.status = 'resolved'
+           AND latest.method = 'fixed-at-source'
+           AND latest.resolved_at IS NOT NULL
          ORDER BY latest_resolved_at DESC
          LIMIT :limit`
       ),
@@ -22133,15 +22546,18 @@ var SqliteSecurityRepository = class {
     return Promise.resolve({ items });
   }
   // Findings whose parent event occurred in [fromMs, toMs), with the parent's
-  // epoch-millis timestamp. occurred_at is an INTEGER column, so the bounds stay
+  // epoch-millis timestamp. started_at is an INTEGER column, so the bounds stay
   // numeric and the JS aggregations bucket/split on ms directly.
   findingsInRange(fromMs, toMs) {
     const rows = allRows(
       this.db.prepare(
-        `SELECT e.occurred_at AS occurred_at, f.severity AS severity, f.action_taken AS action_taken
-         FROM findings f JOIN events e ON e.id = f.event_id
-         WHERE e.occurred_at >= :from AND e.occurred_at < :to
-         ORDER BY e.occurred_at`
+        `SELECT e.started_at AS occurred_at, d.severity AS severity, f.action_taken AS action_taken
+         FROM inspection_findings f
+         JOIN audit_events e ON e.id = f.audit_event_id
+         JOIN inspection_definitions d ON d.id = f.inspection_definition_id
+         WHERE e.started_at >= :from AND e.started_at < :to
+           AND e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})
+         ORDER BY e.started_at`
       ),
       { from: fromMs, to: toMs }
     );
@@ -22956,63 +23372,159 @@ function purgeSampleData(db) {
 function linkHost(input, hostId) {
   return hostId ? { ...input, hostId } : input;
 }
+function closeQuietly(db) {
+  try {
+    db.close();
+  } catch {
+  }
+}
 function openWithPragmas(file2) {
   const db = new DatabaseSync(file2);
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA busy_timeout = 2000");
-  db.exec("PRAGMA foreign_keys = ON");
+  try {
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA busy_timeout = 2000");
+    db.exec("PRAGMA foreign_keys = ON");
+  } catch (err) {
+    closeQuietly(db);
+    throw err;
+  }
   return db;
 }
 function backupLegacyStore(file2) {
   const backup = `${file2}.legacy.${String(Date.now())}.bak`;
-  renameSync(file2, backup);
-  for (const sidecar of walSidecars(file2)) {
-    if (existsSync(sidecar)) rmSync(sidecar);
+  renameSync2(file2, backup);
+  tightenFile(backup);
+  for (const sidecar of dbSidecars(file2)) {
+    if (existsSync(sidecar)) rmSync2(sidecar);
   }
   return backup;
 }
+function openAndInitialize(file2) {
+  let db = openWithPragmas(file2);
+  try {
+    if (isForeignSqliteLineage(db)) {
+      db.close();
+      const backup = backupLegacyStore(file2);
+      db = openWithPragmas(file2);
+      akaWarn(
+        `Detected an older, incompatible (tenant-bearing) ${DB_FILENAME}; backed it up to ${backup} and created a fresh store.`
+      );
+    }
+    applyMigrations(db, file2);
+    tightenPerms(file2);
+    const policies = new SqlitePoliciesRepository(db);
+    const installedPacks = new SqliteInstalledPacksRepository(db);
+    const repositories = {
+      events: new SqliteEventsRepository(db),
+      findings: new SqliteFindingsRepository(db),
+      policies,
+      installedPacks,
+      scanLedger: new SqliteScanLedgerRepository(db),
+      exceptions: new SqliteExceptionsRepository(db),
+      resolutions: new SqliteResolutionsRepository(db),
+      ruleProbeCache: new SqliteRuleProbeCacheRepository(db),
+      security: new SqliteSecurityRepository(db),
+      detections: new SqliteDetectionsRepository(db),
+      shares: new SqliteSharesRepository(db),
+      policyCatalog: new SqlitePolicyCatalogRepository(installedPacks),
+      inventory: new SqliteInventoryRepository(db),
+      inventoryAssets: new SqliteInventoryAssetsRepository(db),
+      projectFiles: new SqliteProjectFilesRepository(db),
+      activity: new SqliteActivityRepository(db),
+      sourceProject: new SqliteSourceProjectRepository(db),
+      auditEvents: new SqliteAuditEventsRepository(db),
+      classifiedData: new SqliteClassifiedDataRepository(db),
+      inspectionDefinitions: new SqliteInspectionDefinitionsRepository(db),
+      inspectionFindings: new SqliteInspectionFindingsRepository(db),
+      configInventory: new SqliteConfigInventoryRepository(db)
+    };
+    policies.seedDefaults();
+    return { db, ...repositories };
+  } catch (err) {
+    closeQuietly(db);
+    throw err;
+  }
+}
 function openLocalDatabase(dir) {
   ensureDataDirSync(dir);
   const file2 = join(dir, DB_FILENAME);
-  let db = openWithPragmas(file2);
-  if (isForeignSqliteLineage(db)) {
-    db.close();
-    const backup = backupLegacyStore(file2);
-    db = openWithPragmas(file2);
-    akaWarn(
-      `Detected an older, incompatible (tenant-bearing) ${DB_FILENAME}; backed it up to ${backup} and created a fresh store.`
-    );
-  }
-  applyMigrations(db);
-  tightenPerms(file2);
-  const events = new SqliteEventsRepository(db);
-  const findings = new SqliteFindingsRepository(db);
-  const policies = new SqlitePoliciesRepository(db);
-  const installedPacks = new SqliteInstalledPacksRepository(db);
-  const scanLedger = new SqliteScanLedgerRepository(db);
-  const exceptions = new SqliteExceptionsRepository(db);
-  const resolutions = new SqliteResolutionsRepository(db);
-  const ruleProbeCache = new SqliteRuleProbeCacheRepository(db);
-  const security = new SqliteSecurityRepository(db);
-  const detections = new SqliteDetectionsRepository(db);
-  const shares = new SqliteSharesRepository(db);
-  const policyCatalog = new SqlitePolicyCatalogRepository(installedPacks);
-  const inventory = new SqliteInventoryRepository(db);
-  const inventoryAssets = new SqliteInventoryAssetsRepository(db);
-  const projectFiles = new SqliteProjectFilesRepository(db);
-  const activity = new SqliteActivityRepository(db);
-  const sourceProject = new SqliteSourceProjectRepository(db);
-  const auditEvents = new SqliteAuditEventsRepository(db);
-  const classifiedData = new SqliteClassifiedDataRepository(db);
-  const inspectionDefinitions = new SqliteInspectionDefinitionsRepository(db);
-  const inspectionFindings = new SqliteInspectionFindingsRepository(db);
-  const configInventory = new SqliteConfigInventoryRepository(db);
-  policies.seedDefaults();
+  const {
+    db,
+    events,
+    findings,
+    policies,
+    installedPacks,
+    scanLedger,
+    exceptions,
+    resolutions,
+    ruleProbeCache,
+    security,
+    detections,
+    shares,
+    policyCatalog,
+    inventory,
+    inventoryAssets,
+    projectFiles,
+    activity,
+    sourceProject,
+    auditEvents,
+    classifiedData,
+    inspectionDefinitions,
+    inspectionFindings,
+    configInventory
+  } = openAndInitialize(file2);
   function recordCapture(event, detected) {
     failOpenTransaction(db, () => {
-      events.insertEvent(event);
       const sessionId = event.metadata?.sessionId;
-      findings.insertFindings(detected, sessionId ? { sessionId } : {});
+      if (sessionId) {
+        auditEvents.ensureSessionRoot(sessionId, event.occurredAt);
+      }
+      const auditEventId = captureId(
+        sessionId ?? null,
+        event.contentHash,
+        event.metadata?.filePath ?? null
+      );
+      auditEvents.insertAuditEvent({
+        id: auditEventId,
+        eventType: event.kind,
+        startedAt: event.occurredAt,
+        parentId: sessionId,
+        rootSessionId: sessionId,
+        content: event.content,
+        contentHash: event.contentHash,
+        attributes: toCaptureAttributes(event)
+      });
+      const definitionIds = /* @__PURE__ */ new Map();
+      for (const finding of detected) {
+        if (sessionId && inspectionFindings.isSessionDuplicate(finding.ruleId, finding.maskedMatch, sessionId)) {
+          continue;
+        }
+        if (inspectionFindings.isEventDuplicate(
+          auditEventId,
+          finding.ruleId,
+          finding.maskedMatch,
+          finding.span.start,
+          finding.span.end
+        )) {
+          continue;
+        }
+        const key = `${finding.ruleId}@${captureDefinitionVersion(finding)}`;
+        let definitionId = definitionIds.get(key);
+        if (!definitionId) {
+          definitionId = inspectionDefinitions.upsert(toCaptureDefinitionInput(finding));
+          definitionIds.set(key, definitionId);
+        }
+        inspectionFindings.insertFinding({
+          id: finding.id,
+          auditEventId,
+          inspectionDefinitionId: definitionId,
+          span: finding.span,
+          maskedMatch: finding.maskedMatch,
+          actionTaken: finding.actionTaken,
+          confidence: finding.confidence,
+          findingKey: finding.findingKey ?? void 0
+        });
+      }
     });
   }
   function ensureInventory(ctx) {
@@ -23160,14 +23672,18 @@ function openLocalDatabase(dir) {
   };
 }
 
+// ../../packages/persistence/src/finding-key.ts
+import { createHash as createHash3 } from "crypto";
+
 // ../../packages/persistence/src/fingerprint.ts
 import { createHmac, randomBytes } from "crypto";
-import { chmodSync as chmodSync2, readFileSync, renameSync as renameSync2, writeFileSync } from "fs";
+import { existsSync as existsSync2, readFileSync } from "fs";
 import { join as join2 } from "path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 
 // ../../packages/persistence/src/local-layout.ts
-import { chmodSync as chmodSync3, mkdirSync as mkdirSync2, renameSync as renameSync3 } from "fs";
-import { chmod, mkdir } from "fs/promises";
+import { renameSync as renameSync3 } from "fs";
+import { mkdir } from "fs/promises";
 import { homedir } from "os";
 import { join as join3 } from "path";
 function defaultDataDir() {
@@ -23182,6 +23698,9 @@ function dataDir(base = defaultDataDir()) {
 function dbPath(base = defaultDataDir()) {
   return join3(dataDir(base), "aka.db");
 }
+function ensureLayoutDirSync(dir = defaultDataDir()) {
+  ensureDataDirSync(dir);
+}
 function migrateLegacyLayout(base = defaultDataDir()) {
   const moves = [
     { name: "config.json", dest: settingsDir(base) },
@@ -23189,19 +23708,17 @@ function migrateLegacyLayout(base = defaultDataDir()) {
   ];
   for (const { name, dest } of moves) {
     try {
-      mkdirSync2(dest, { recursive: true, mode: DATA_DIR_MODE });
-      try {
-        chmodSync3(dest, DATA_DIR_MODE);
-      } catch {
-      }
-      renameSync3(join3(base, name), join3(dest, name));
+      ensureDataDirSync(dest);
+      const moved = join3(dest, name);
+      renameSync3(join3(base, name), moved);
+      tightenFile(moved);
     } catch {
     }
   }
 }
 
 // ../../packages/persistence/src/settings.ts
-import { readFileSync as readFileSync2, renameSync as renameSync4, writeFileSync as writeFileSync2 } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { join as join4 } from "path";
 function readWorkspaceSettings(base = defaultDataDir()) {
   const record2 = readJson(join4(settingsDir(base), "settings.json"));
@@ -23223,9 +23740,13 @@ function readJson(file2) {
 }
 
 // ../../packages/persistence/src/warn-era-cap.ts
-import { existsSync as existsSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync3, writeFileSync as writeFileSync2 } from "fs";
 import { join as join5 } from "path";
 
+// ../../packages/plugin-sdk/src/config.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join6 } from "path";
+
 // ../../packages/plugin-sdk/src/provider-env.ts
 var DEFAULT_ANTHROPIC_HOST = "api.anthropic.com";
 var booleanish = external_exports.string().optional().transform((v) => {
@@ -23276,6 +23797,12 @@ function resolveProvider() {
 
 // ../../packages/plugin-sdk/src/config.ts
 function loadConfig(base = defaultDataDir()) {
+  try {
+    ensureLayoutDirSync(base);
+    const settingsFile = join6(settingsDir(base), "settings.json");
+    if (existsSync4(settingsFile)) tightenFile(settingsFile);
+  } catch {
+  }
   migrateLegacyLayout(base);
   const settings = readWorkspaceSettings(base);
   return {
@@ -23298,7 +23825,7 @@ function resolveProviderSafe() {
 // ../../packages/plugin-sdk/src/config-inventory.ts
 import { readdirSync, readFileSync as readFileSync4, realpathSync, statSync as statSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename as basename2, join as join7 } from "path";
+import { basename as basename2, join as join8 } from "path";
 
 // ../../packages/detections/src/egress/registry.ts
 var EXTRACTOR_VERSION = "1";
@@ -23922,9 +24449,156 @@ var RegexMatcher2 = class {
   }
 };
 
+// ../../packages/detections/src/validators/entropy.ts
+function shannonEntropy(str2) {
+  const freq = {};
+  for (const ch of str2) {
+    freq[ch] = (freq[ch] ?? 0) + 1;
+  }
+  let entropy = 0;
+  for (const count of Object.values(freq)) {
+    const p = count / str2.length;
+    entropy -= p * Math.log2(p);
+  }
+  return entropy;
+}
+function isHighEntropy(value, threshold = 3.5, minLength = 20) {
+  return value.length >= minLength && shannonEntropy(value) >= threshold;
+}
+
+// ../../packages/detections/src/validators/luhn.ts
+function luhnCheck(digits) {
+  const nums = digits.replace(/\D/g, "");
+  if (nums.length < 13) return false;
+  let sum = 0;
+  let isOdd = true;
+  for (let i = nums.length - 1; i >= 0; i--) {
+    let digit = parseInt(nums[i] ?? "0", 10);
+    if (!isOdd) {
+      digit *= 2;
+      if (digit > 9) digit -= 9;
+    }
+    sum += digit;
+    isOdd = !isOdd;
+  }
+  return sum % 10 === 0;
+}
+
 // ../../packages/detections/src/engine.ts
 var keywordMatcher = new KeywordMatcher2();
 var regexMatcher = new RegexMatcher2();
+var packs = /* @__PURE__ */ new Map();
+var POST_VALIDATORS = {
+  entropy: (value, config2) => isHighEntropy(value, numberOption(config2, "threshold"), numberOption(config2, "minLength")),
+  luhn: (value) => luhnCheck(value)
+};
+function numberOption(config2, key) {
+  const value = config2?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function passesPostValidators(rule, value) {
+  const validators = rule.postValidators;
+  if (!validators || validators.length === 0) return true;
+  for (const ref of validators) {
+    const name = typeof ref === "string" ? ref : ref.name;
+    const config2 = typeof ref === "string" ? void 0 : ref.config;
+    const validate = POST_VALIDATORS[name];
+    if (validate && !validate(value, config2)) return false;
+  }
+  return true;
+}
+function registerPack(pack) {
+  packs.set(pack.id, pack);
+}
+function getLoadedRules() {
+  return [...packs.values()].flatMap((p) => p.rules);
+}
+function isCorroborated(candidate, candidates, text) {
+  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 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 (ruleIds?.includes(other.match.ruleId)) return true;
+    }
+  }
+  const labels = req.labels;
+  if (labels && labels.length > 0) {
+    const haystack = text.slice(Math.max(0, winStart), winEnd);
+    for (const label of labels) {
+      const trimmed = label.trim();
+      if (trimmed.length === 0) continue;
+      const re = new RegExp(`(?<![A-Za-z0-9])${escapeRegExp2(trimmed)}(?![A-Za-z0-9])`, "i");
+      if (re.test(haystack)) 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;
+  const candidates = [];
+  for (const rule of ruleset) {
+    if (!ruleApplies(rule, extension)) continue;
+    let spans;
+    if (rule.matcher.type === "keyword") {
+      spans = keywordMatcher.match(text, rule);
+    } else if (rule.matcher.type === "regex") {
+      spans = regexMatcher.match(text, rule);
+    } else {
+      continue;
+    }
+    for (const span of spans) {
+      const rawMatch = text.slice(span.start, span.end);
+      if (!passesPostValidators(rule, rawMatch)) continue;
+      candidates.push({
+        rule,
+        match: {
+          ruleId: rule.id,
+          category: rule.category,
+          severity: rule.severity,
+          span,
+          rawMatch,
+          confidence: 0.9
+        }
+      });
+    }
+  }
+  const findings = [];
+  for (const candidate of candidates) {
+    const req = candidate.rule.requiresNearby;
+    if (!req) {
+      findings.push(candidate.match);
+      continue;
+    }
+    if (!isCorroborated(candidate, candidates, text)) continue;
+    const boost = req.confidenceBoost;
+    findings.push(
+      boost ? { ...candidate.match, confidence: Math.min(0.99, candidate.match.confidence + boost) } : candidate.match
+    );
+  }
+  return findings;
+}
 var SEVERITY_RANK2 = {
   critical: 3,
   high: 2,
@@ -24055,41 +24729,2102 @@ var POLYNOMIAL_PROBES = ["abc-", "a.", "a ", "a=", "x", "0", "a@", "a/", "ab"].m
   (unit) => unit.repeat(1e4).slice(0, 4e4) + "!"
 );
 
-// ../../packages/plugin-sdk/src/repo.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, statSync } from "fs";
-import { basename, dirname, isAbsolute, join as join6, sep as sep2 } from "path";
-
-// ../../packages/plugin-sdk/src/events.ts
-import { createHash as createHash3, randomUUID as randomUUID9 } from "crypto";
-
-// ../../packages/plugin-sdk/src/finding-key.ts
-import { createHash as createHash4 } from "crypto";
+// ../../rules/code-flaws/auth-jwt-no-verify.json
+var auth_jwt_no_verify_default = {
+  specVersion: 1,
+  id: "code-flaws/auth-jwt-no-verify",
+  name: "JWT decoded without signature verification",
+  category: "code_flaw",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "(verify\\s*=\\s*false|verify_signature.*false|algorithms\\s*=\\s*\\[\\])",
+    flags: "gi"
+  },
+  requiresNearby: {
+    labels: ["jwt", "decode", "token"],
+    windowChars: 160
+  },
+  examples: [
+    'jwt.decode(token, options={"verify_signature": False})',
+    "jwt.decode(token, algorithms=[])"
+  ]
+};
 
-// ../../packages/plugin-sdk/src/inventory-resolver.ts
-import { arch, hostname as hostname3, platform, release } from "os";
+// ../../rules/code-flaws/auth-ssl-verify-false.json
+var auth_ssl_verify_false_default = {
+  specVersion: 1,
+  id: "code-flaws/auth-ssl-verify-false",
+  name: "SSL certificate verification disabled",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\brequests\\.(get|post|put|delete|patch|request)\\s*\\([^)]*verify\\s*=\\s*False",
+    flags: "gi"
+  },
+  examples: [
+    "requests.get(url, verify=False)",
+    "requests.post(endpoint, data=payload, verify=False)"
+  ],
+  appliesTo: {
+    extensions: [".py"]
+  }
+};
 
-// ../../packages/plugin-sdk/src/nudge.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join8 } from "path";
+// ../../rules/code-flaws/cmd-inject-exec.json
+var cmd_inject_exec_default = {
+  specVersion: 1,
+  id: "code-flaws/cmd-inject-exec",
+  name: "Command injection via Java Runtime.exec",
+  category: "code_flaw",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "Runtime\\.getRuntime\\(\\)\\.exec\\(",
+    flags: "g"
+  },
+  requiresNearby: {
+    labels: ["input", "request", "param", "user"],
+    windowChars: 200
+  },
+  examples: ["Runtime.getRuntime().exec(userInput)"],
+  appliesTo: {
+    extensions: [".java"]
+  }
+};
 
-// ../../packages/plugin-sdk/src/paths.ts
-import { readdirSync as readdirSync2, realpathSync as realpathSync2 } from "fs";
-import { basename as basename3, dirname as dirname2, sep as sep3 } from "path";
+// ../../rules/code-flaws/cmd-inject-node-exec.json
+var cmd_inject_node_exec_default = {
+  specVersion: 1,
+  id: "code-flaws/cmd-inject-node-exec",
+  name: "Command injection via Node.js exec with variable argument",
+  category: "code_flaw",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\bexec(?:Sync)?\\s*\\(\\s*(?!['\"`])",
+    flags: "g"
+  },
+  requiresNearby: {
+    labels: ["input", "request", "param", "argv", "user", "query", "body"],
+    windowChars: 200
+  },
+  examples: ["exec(req.query.cmd)", "execSync(userInput)"],
+  appliesTo: {
+    extensions: [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"]
+  }
+};
 
-// ../../packages/plugin-sdk/src/posture.ts
-function applyCategoryPosture(posture, repo, mode = "fill-gaps") {
-  for (const category of Object.keys(posture)) {
-    const policyId = posture[category];
-    if (!policyId) continue;
-    if (mode === "fill-gaps" && repo.getCategoryAction(category) !== void 0) continue;
-    repo.upsertCategoryAction(category, builtinPolicyToAction(policyId));
+// ../../rules/code-flaws/cmd-inject-shell.json
+var cmd_inject_shell_default = {
+  specVersion: 1,
+  id: "code-flaws/cmd-inject-shell",
+  name: "Command injection via subprocess shell=True",
+  category: "code_flaw",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "subprocess\\.(run|Popen|call|check_output)\\s*\\([^)]*shell\\s*=\\s*True",
+    flags: "gi"
+  },
+  requiresNearby: {
+    labels: ["input", "request", "param", "argv", "user"],
+    windowChars: 300
+  },
+  examples: ["subprocess.run(user_input, shell=True)"],
+  appliesTo: {
+    extensions: [".py"]
   }
-}
+};
+
+// ../../rules/code-flaws/crypto-insecure-random.json
+var crypto_insecure_random_default = {
+  specVersion: 1,
+  id: "code-flaws/crypto-insecure-random",
+  name: "Insecure random number generator used for security-sensitive value",
+  category: "code_flaw",
+  severity: "medium",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(Math\\.random\\(\\)|random\\.random\\(\\)|random\\.randint\\()",
+    flags: "gi"
+  },
+  requiresNearby: {
+    labels: ["token", "session", "key", "password", "secret", "nonce", "salt"],
+    windowChars: 160
+  },
+  examples: ["const token = Math.random().toString(36)", "session_key = str(random.random())"],
+  appliesTo: {
+    extensions: [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".py"]
+  }
+};
+
+// ../../rules/code-flaws/crypto-weak-hash-md5.json
+var crypto_weak_hash_md5_default = {
+  specVersion: 1,
+  id: "code-flaws/crypto-weak-hash-md5",
+  name: "Weak cryptographic hash: MD5",
+  category: "code_flaw",
+  severity: "medium",
+  matcher: {
+    type: "regex",
+    pattern: `(hashlib\\.md5\\s*\\(|MD5\\.(?:digest|hash)\\b|Digest::MD5|MessageDigest\\.getInstance\\s*\\(\\s*["']MD5["'])`,
+    flags: "gi"
+  },
+  examples: ["hashlib.md5(password.encode())", 'MessageDigest.getInstance("MD5")'],
+  appliesTo: {
+    extensions: [".py", ".rb", ".java"]
+  }
+};
+
+// ../../rules/code-flaws/crypto-weak-hash-sha1.json
+var crypto_weak_hash_sha1_default = {
+  specVersion: 1,
+  id: "code-flaws/crypto-weak-hash-sha1",
+  name: "Weak cryptographic hash: SHA-1 in security context",
+  category: "code_flaw",
+  severity: "medium",
+  matcher: {
+    type: "regex",
+    pattern: `(hashlib\\.sha1\\s*\\(|SHA1\\.(?:digest|hash)\\b|Digest::SHA1|MessageDigest\\.getInstance\\s*\\(\\s*["']SHA-?1["'])`,
+    flags: "gi"
+  },
+  requiresNearby: {
+    labels: ["password", "credential", "hash", "token", "secret"],
+    windowChars: 160
+  },
+  examples: [
+    "password_hash = hashlib.sha1(password.encode()).hexdigest()",
+    'MessageDigest.getInstance("SHA1")'
+  ],
+  appliesTo: {
+    extensions: [".py", ".rb", ".java"]
+  }
+};
+
+// ../../rules/code-flaws/deser-java-ois.json
+var deser_java_ois_default = {
+  specVersion: 1,
+  id: "code-flaws/deser-java-ois",
+  name: "Insecure deserialization via Java ObjectInputStream",
+  category: "code_flaw",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\bObjectInputStream\\b",
+    flags: "g"
+  },
+  requiresNearby: {
+    labels: ["readObject"],
+    windowChars: 200
+  },
+  examples: [
+    "ObjectInputStream ois = new ObjectInputStream(inputStream); Object obj = ois.readObject();"
+  ],
+  appliesTo: {
+    extensions: [".java"]
+  }
+};
+
+// ../../rules/code-flaws/deser-pickle.json
+var deser_pickle_default = {
+  specVersion: 1,
+  id: "code-flaws/deser-pickle",
+  name: "Insecure deserialization via Python pickle",
+  category: "code_flaw",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\bpickle\\.loads?\\s*\\(",
+    flags: "gi"
+  },
+  examples: ["data = pickle.loads(user_data)", "obj = pickle.load(request.stream)"],
+  appliesTo: {
+    extensions: [".py"]
+  }
+};
+
+// ../../rules/code-flaws/deser-yaml-unsafe.json
+var deser_yaml_unsafe_default = {
+  specVersion: 1,
+  id: "code-flaws/deser-yaml-unsafe",
+  name: "Insecure deserialization via yaml.load without SafeLoader",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\byaml\\.load\\s*\\((?![^)]*SafeLoader|[^)]*safe_load)",
+    flags: "gi"
+  },
+  examples: ["data = yaml.load(user_input)", "config = yaml.load(f)"],
+  appliesTo: {
+    extensions: [".py"]
+  }
+};
+
+// ../../rules/code-flaws/dev-debug-enabled.json
+var dev_debug_enabled_default = {
+  specVersion: 1,
+  id: "code-flaws/dev-debug-enabled",
+  name: "Debug mode enabled in configuration",
+  category: "code_flaw",
+  severity: "medium",
+  matcher: {
+    type: "regex",
+    pattern: "\\bdebug\\s*[=:]\\s*(true|1|yes)",
+    flags: "gi"
+  },
+  examples: ["DEBUG = True", "debug: true", "app.debug = True"]
+};
+
+// ../../rules/code-flaws/dev-placeholder-secret.json
+var dev_placeholder_secret_default = {
+  specVersion: 1,
+  id: "code-flaws/dev-placeholder-secret",
+  name: "Placeholder or default secret left in code",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "keyword",
+    keywords: [
+      "changeme",
+      "placeholder",
+      "your-secret",
+      "dev-secret",
+      "replace-me",
+      "todo-secret"
+    ],
+    caseSensitive: false
+  },
+  requiresNearby: {
+    labels: ["key", "secret", "password", "token"],
+    windowChars: 80
+  },
+  examples: ["SECRET_KEY = 'changeme'", "api_token = 'your-secret'"]
+};
+
+// ../../rules/code-flaws/dev-wildcard-cors.json
+var dev_wildcard_cors_default = {
+  specVersion: 1,
+  id: "code-flaws/dev-wildcard-cors",
+  name: "CORS wildcard allowing all origins",
+  category: "code_flaw",
+  severity: "medium",
+  matcher: {
+    type: "regex",
+    pattern: `(Access-Control-Allow-Origin:\\s*\\*|origin:\\s*["']\\*["']|allow_all_origins\\s*=\\s*True|CORS_ALLOW_ALL_ORIGINS\\s*=\\s*True)`,
+    flags: "gi"
+  },
+  examples: [
+    "Access-Control-Allow-Origin: *",
+    "cors({ origin: '*' })",
+    "CORS_ALLOW_ALL_ORIGINS = True"
+  ]
+};
+
+// ../../rules/code-flaws/eval-dynamic-exec.json
+var eval_dynamic_exec_default = {
+  specVersion: 1,
+  id: "code-flaws/eval-dynamic-exec",
+  name: "Dynamic code execution with user-controlled input",
+  category: "code_flaw",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(eval|exec)\\s*\\(\\s*(?!['\"`])",
+    flags: "g"
+  },
+  requiresNearby: {
+    labels: ["input", "request", "param", "user", "query", "body"],
+    windowChars: 200
+  },
+  examples: ["eval(request.body.code)", "exec(user_input)"]
+};
+
+// ../../rules/code-flaws/hardcoded-password.json
+var hardcoded_password_default = {
+  specVersion: 1,
+  id: "code-flaws/hardcoded-password",
+  name: "Hardcoded password in source code",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: `(?:password|passwd|pwd)\\s*=\\s*["']([^"']{3,})["']`,
+    flags: "gi",
+    captureGroup: 1
+  },
+  postValidators: [
+    {
+      name: "entropy",
+      config: {
+        minLength: 8,
+        threshold: 3
+      }
+    }
+  ],
+  examples: ['password = "Tr0ub4dor&3"', "DB_PASSWORD = 'c0rr3ctH0rseBatt3ry'"]
+};
+
+// ../../rules/code-flaws/hardcoded-secret-key.json
+var hardcoded_secret_key_default = {
+  specVersion: 1,
+  id: "code-flaws/hardcoded-secret-key",
+  name: "Hardcoded API key or secret key in source code",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: `\\b(secret[_-]?key|api[_-]?key|auth[_-]?token)\\s*=\\s*["'][^"']{8,}["']`,
+    flags: "gi"
+  },
+  postValidators: ["entropy"],
+  examples: [
+    'SECRET_KEY = "a9f2c8e1b4d7f3a6c9e2b5d8f1a4c7e0"',
+    "api_key = 'sk-proj-abc123XYZ789def456'"
+  ]
+};
+
+// ../../rules/code-flaws/path-traversal-join.json
+var path_traversal_join_default = {
+  specVersion: 1,
+  id: "code-flaws/path-traversal-join",
+  name: "Path traversal via os.path.join with user-controlled component",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "os\\.path\\.join\\s*\\([^,)]+,\\s*(request|req|params|user)",
+    flags: "gi"
+  },
+  examples: [
+    "os.path.join(base_dir, request.args['file'])",
+    "os.path.join(upload_dir, user_filename)"
+  ],
+  appliesTo: {
+    extensions: [".py"]
+  }
+};
+
+// ../../rules/code-flaws/path-traversal-open.json
+var path_traversal_open_default = {
+  specVersion: 1,
+  id: "code-flaws/path-traversal-open",
+  name: "Path traversal via open() with user-controlled path",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\bopen\\s*\\(\\s*(request|req|params|argv|input)",
+    flags: "gi"
+  },
+  requiresNearby: {
+    labels: ["request", "param", "input", "argv", "user"],
+    windowChars: 200
+  },
+  examples: ["open(request.args['filename'])", "open(params['path'])"],
+  appliesTo: {
+    extensions: [".py", ".rb"]
+  }
+};
+
+// ../../rules/code-flaws/prototype-pollution-merge.json
+var prototype_pollution_merge_default = {
+  specVersion: 1,
+  id: "code-flaws/prototype-pollution-merge",
+  name: "Prototype pollution via merge with user-controlled input",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "(Object\\.assign\\s*\\(\\s*\\w+\\s*,\\s*(req|request|body|params|query)|_\\.merge\\s*\\(\\s*\\w+\\s*,\\s*(req|request))",
+    flags: "gi"
+  },
+  examples: ["Object.assign(config, req.body)", "_.merge(target, request.body)"],
+  appliesTo: {
+    extensions: [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"]
+  }
+};
+
+// ../../rules/code-flaws/regex-redos-backtrack.json
+var regex_redos_backtrack_default = {
+  specVersion: 1,
+  id: "code-flaws/regex-redos-backtrack",
+  name: "ReDoS via catastrophic backtracking pattern",
+  category: "code_flaw",
+  severity: "medium",
+  matcher: {
+    type: "regex",
+    pattern: "\\((?:\\?:)?(?:\\\\.|\\[[^\\]]*\\]|[^\\\\()\\[\\]+*?|])[+*](?:(?:\\\\.|\\[[^\\]]*\\]|[^\\\\()\\[\\]+*?|])\\*)?\\)[+*]|\\((?:\\?:)?([^()|]+)\\|\\1\\)[+*]",
+    flags: "g"
+  },
+  examples: ["/(a+)+/", "/(\\w+\\s*)+/"]
+};
+
+// ../../rules/code-flaws/sql-inject-concat-dot.json
+var sql_inject_concat_dot_default = {
+  specVersion: 1,
+  id: "code-flaws/sql-inject-concat-dot",
+  name: "SQL injection via string concatenation (PHP dot operator)",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: `["'][^\\n]*?(select|insert|update|delete|drop|where)[^\\n]*?["']\\s*\\.`,
+    flags: "gi"
+  },
+  appliesTo: {
+    extensions: [".php"]
+  },
+  examples: ['$query = "SELECT * FROM orders WHERE user = " . $username;']
+};
+
+// ../../rules/code-flaws/sql-inject-concat.json
+var sql_inject_concat_default = {
+  specVersion: 1,
+  id: "code-flaws/sql-inject-concat",
+  name: "SQL injection via string concatenation",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: `["']\\s*(?:select\\b[^\\n]*?\\bfrom\\b|insert\\s+into\\b|update\\s+\\S+\\s+set\\b|delete\\s+from\\b|drop\\s+(?:table|database)\\b|where\\b[^\\n]*?=)[^\\n]*?["']\\s*\\+`,
+    flags: "gi"
+  },
+  examples: ['"SELECT * FROM users WHERE id = " + userId']
+};
+
+// ../../rules/code-flaws/sql-inject-format.json
+var sql_inject_format_default = {
+  specVersion: 1,
+  id: "code-flaws/sql-inject-format",
+  name: "SQL injection via format string or f-string",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:select\\b[^\\n]*?\\bfrom\\b|insert\\s+into\\b|update\\s+\\S+\\s+set\\b|delete\\s+from\\b|drop\\s+(?:table|database)\\b|where\\b[^\\n]*?=)[^\\n]*?(?:[%][sd]|\\{[^}]+\\})",
+    flags: "gi"
+  },
+  examples: [
+    'f"SELECT * FROM users WHERE id = {user_id}"',
+    `"SELECT * FROM users WHERE name = '%s'" % name`
+  ]
+};
+
+// ../../rules/code-flaws/sql-inject-interp.json
+var sql_inject_interp_default = {
+  specVersion: 1,
+  id: "code-flaws/sql-inject-interp",
+  name: "SQL injection via Ruby string interpolation or PHP variable",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "(select|insert|update|delete|where)[^\\n]*?(#\\{|\\$[a-z_])",
+    flags: "gi"
+  },
+  examples: [
+    '"SELECT * FROM users WHERE id = #{params[:id]}"',
+    '"SELECT * FROM users WHERE id = $userId"'
+  ],
+  appliesTo: {
+    extensions: [".rb", ".php"]
+  }
+};
+
+// ../../rules/code-flaws/ssrf-user-url.json
+var ssrf_user_url_default = {
+  specVersion: 1,
+  id: "code-flaws/ssrf-user-url",
+  name: "Server-side request forgery via user-controlled URL",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "(fetch|axios\\.\\w+|requests\\.get|urllib\\.request\\.urlopen)\\s*\\(\\s*(req|request|params|query|body)",
+    flags: "gi"
+  },
+  examples: ["fetch(req.query.url)", "requests.get(request.form['url'])"],
+  appliesTo: {
+    extensions: [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".py"]
+  }
+};
+
+// ../../rules/code-flaws/xss-dangerously-set.json
+var xss_dangerously_set_default = {
+  specVersion: 1,
+  id: "code-flaws/xss-dangerously-set",
+  name: "XSS via React dangerouslySetInnerHTML",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "keyword",
+    keywords: ["dangerouslySetInnerHTML"],
+    caseSensitive: true
+  },
+  examples: ["<div dangerouslySetInnerHTML={{ __html: userContent }} />"],
+  appliesTo: {
+    extensions: [".js", ".jsx", ".ts", ".tsx"]
+  }
+};
+
+// ../../rules/code-flaws/xss-inner-html.json
+var xss_inner_html_default = {
+  specVersion: 1,
+  id: "code-flaws/xss-inner-html",
+  name: "XSS via innerHTML assignment",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "keyword",
+    keywords: ["innerHTML =", "innerHTML="],
+    caseSensitive: true
+  },
+  examples: ["element.innerHTML = userInput"],
+  appliesTo: {
+    extensions: [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"]
+  }
+};
+
+// ../../rules/code-flaws/xss-unescaped-render.json
+var xss_unescaped_render_default = {
+  specVersion: 1,
+  id: "code-flaws/xss-unescaped-render",
+  name: "XSS via unescaped template rendering",
+  category: "code_flaw",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "(\\braw\\s*\\(|\\bhtml_safe\\b|\\|\\s*safe\\b|\\bmark_safe\\s*\\()",
+    flags: "gi"
+  },
+  examples: ["<%= raw(user_comment) %>", "{{ user_input | safe }}", "mark_safe(user_html)"],
+  appliesTo: {
+    extensions: [".rb", ".py"]
+  }
+};
+
+// ../../rules/core-code-context/db-table-name.json
+var db_table_name_default = {
+  specVersion: 1,
+  id: "core-code-context/db-table-name",
+  name: "Internal database table/column name",
+  category: "code_context",
+  severity: "low",
+  matcher: {
+    type: "keyword",
+    keywords: [
+      "SELECT * FROM ",
+      "SELECT COUNT(*) FROM ",
+      "INSERT INTO ",
+      "DELETE FROM ",
+      "CREATE TABLE ",
+      "ALTER TABLE ",
+      "DROP TABLE ",
+      "FROM users",
+      "FROM orders",
+      "FROM employees",
+      "FROM customers",
+      "FROM accounts",
+      "FROM transactions",
+      "FROM products",
+      "FROM payments"
+    ],
+    caseSensitive: false
+  },
+  examples: ["SELECT * FROM users WHERE id = 1"]
+};
+
+// ../../rules/core-code-context/feature-flag.json
+var feature_flag_default = {
+  specVersion: 1,
+  id: "core-code-context/feature-flag",
+  name: "Feature flag / toggle name",
+  category: "code_context",
+  severity: "low",
+  matcher: {
+    type: "keyword",
+    keywords: [
+      "feature_flag:",
+      "feature_toggle:",
+      "feature-flag:",
+      "feature-toggle:",
+      "FF_",
+      "FEATURE_FLAG_",
+      "FEATURE_TOGGLE_",
+      "unleash:",
+      "launchdarkly:",
+      "split.io:"
+    ],
+    caseSensitive: false
+  },
+  examples: ["feature_flag: new-checkout-flow", "FF_ENABLE_DARK_MODE"]
+};
+
+// ../../rules/core-code-context/file-path.json
+var file_path_default = {
+  specVersion: 1,
+  id: "core-code-context/file-path",
+  name: "User home / identity-bearing file path",
+  category: "code_context",
+  severity: "low",
+  matcher: {
+    type: "regex",
+    pattern: "(?:/home|/Users)/[A-Za-z0-9_.@-]+(?:/[A-Za-z0-9_.@+-]+)*|/root(?:/[A-Za-z0-9_.@+-]+)+|[A-Za-z]:\\\\[Uu]sers\\\\[A-Za-z0-9_.-]+(?:\\\\[A-Za-z0-9_.-]+)*",
+    flags: "g"
+  },
+  examples: [
+    "/home/user/.ssh/id_rsa",
+    "/Users/jane/projects/acme/secrets.env",
+    "C:\\Users\\admin\\config.yml"
+  ]
+};
+
+// ../../rules/core-code-context/internal-domain.json
+var internal_domain_default = {
+  specVersion: 1,
+  id: "core-code-context/internal-domain",
+  name: "Internal domain / hostname",
+  category: "code_context",
+  severity: "low",
+  matcher: {
+    type: "regex",
+    pattern: "(?<![A-Za-z0-9.-])[A-Za-z0-9][A-Za-z0-9.-]{0,251}\\.(?:internal|corp|local|lan|intranet|private|dev|staging|test|qa)(?:\\.(?:com|net|org|io|co|app))?\\b",
+    flags: "gi"
+  },
+  examples: ["db.internal.com", "app.corp.local", "api.staging.example.com"]
+};
+
+// ../../rules/core-code-context/internal-ip.json
+var internal_ip_default = {
+  specVersion: 1,
+  id: "core-code-context/internal-ip",
+  name: "Internal (RFC 1918) IP address",
+  category: "code_context",
+  severity: "low",
+  matcher: {
+    type: "regex",
+    pattern: "(?<![\\d.])(?:10\\.(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)|172\\.(?:1[6-9]|2\\d|3[01])\\.(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)|192\\.168\\.(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?))(?![\\d])",
+    flags: "g"
+  },
+  examples: ["10.0.0.1", "192.168.1.1", "172.16.0.1"]
+};
+
+// ../../rules/core-code-context/internal-url.json
+var internal_url_default = {
+  specVersion: 1,
+  id: "core-code-context/internal-url",
+  name: "Internal environment URL",
+  category: "code_context",
+  severity: "low",
+  matcher: {
+    type: "keyword",
+    keywords: [
+      "https://staging.",
+      "https://dev.",
+      "https://qa.",
+      "https://test.",
+      "http://staging.",
+      "http://dev.",
+      "http://qa.",
+      "http://test.",
+      ".staging.com",
+      ".dev.com",
+      ".qa.com",
+      "staging.internal",
+      "dev.internal"
+    ],
+    caseSensitive: false
+  },
+  examples: ["https://staging.example.com"]
+};
+
+// ../../rules/core-code-context/localhost-ref.json
+var localhost_ref_default = {
+  specVersion: 1,
+  id: "core-code-context/localhost-ref",
+  name: "Localhost reference",
+  category: "code_context",
+  severity: "low",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:localhost|127\\.0\\.0\\.1|0\\.0\\.0\\.0|::1)\\b",
+    flags: "g"
+  },
+  examples: ["localhost", "127.0.0.1"]
+};
+
+// ../../rules/core-code-context/stack-trace.json
+var stack_trace_default = {
+  specVersion: 1,
+  id: "core-code-context/stack-trace",
+  name: "Stack trace (internal code structure)",
+  category: "code_context",
+  severity: "low",
+  matcher: {
+    type: "regex",
+    pattern: "(?:^|\\s+)at\\s+[A-Za-z0-9._$<>]+\\.[A-Za-z0-9_$]+\\s*\\([A-Za-z0-9._\\-/:]+:\\d+:\\d+\\)",
+    flags: "g"
+  },
+  examples: ["at com.example.service.UserService.findUser(UserService.java:42:13)"]
+};
+
+// ../../rules/core-financial/credit-card.json
+var credit_card_default = {
+  specVersion: 1,
+  id: "core-financial/credit-card",
+  name: "Credit/debit card number",
+  category: "financial",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|6(?:011|5[0-9]{2})[0-9]{12})\\b",
+    flags: "g"
+  },
+  postValidators: ["luhn"],
+  examples: ["4111111111111111", "5500000000000004"]
+};
+
+// ../../rules/core-financial/cusip.json
+var cusip_default = {
+  specVersion: 1,
+  id: "core-financial/cusip",
+  name: "CUSIP security identifier",
+  category: "financial",
+  severity: "medium",
+  matcher: {
+    type: "regex",
+    pattern: "\\bcusip\\b[\\s#:=-]{0,8}(\\d{3}[A-Z0-9]{2}[A-Z0-9*#@]\\d{2}[0-9])\\b",
+    flags: "gi",
+    captureGroup: 1
+  },
+  examples: ["CUSIP: 037833100", "CUSIP 931142103"]
+};
+
+// ../../rules/core-financial/cvv.json
+var cvv_default = {
+  specVersion: 1,
+  id: "core-financial/cvv",
+  name: "Card security code (CVV/CVC)",
+  category: "financial",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:CVV|CVC|CID|security\\s+code|card\\s+code)[:\\s]*\\d{3,4}\\b",
+    flags: "gi"
+  },
+  examples: ["CVV: 123", "CVC: 456"]
+};
+
+// ../../rules/core-financial/iban.json
+var iban_default = {
+  specVersion: 1,
+  id: "core-financial/iban",
+  name: "International Bank Account Number",
+  category: "financial",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\b[A-Z]{2}\\d{2}[A-Z0-9 ]{10,30}\\b",
+    flags: "g"
+  },
+  requiresNearby: {
+    labels: ["iban", "bank", "account", "bic", "swift"],
+    windowChars: 160
+  },
+  examples: ["IBAN: GB82 WEST 1234 5698 7654 32", "IBAN: DE89 3704 0044 0532 0130 00"]
+};
+
+// ../../rules/core-financial/paypal.json
+var paypal_default = {
+  specVersion: 1,
+  id: "core-financial/paypal",
+  name: "PayPal transaction/merchant ID",
+  category: "financial",
+  severity: "medium",
+  matcher: {
+    type: "regex",
+    pattern: "paypal.{0,30}?\\b([A-Z0-9]{17})\\b",
+    flags: "gi",
+    captureGroup: 1
+  },
+  examples: ["PayPal transaction ID: 9HW7382910ABCDEF1"]
+};
+
+// ../../rules/core-financial/routing-number.json
+var routing_number_default = {
+  specVersion: 1,
+  id: "core-financial/routing-number",
+  name: "US bank routing number (ABA)",
+  category: "financial",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:routing|aba|rtn)\\b[\\s#:=-]{0,8}(\\d{9})\\b",
+    flags: "gi",
+    captureGroup: 1
+  },
+  examples: ["Routing: 021000021", "ABA 111000025"]
+};
+
+// ../../rules/core-financial/salary.json
+var salary_default = {
+  specVersion: 1,
+  id: "core-financial/salary",
+  name: "Salary/compensation (contextual)",
+  category: "financial",
+  severity: "low",
+  matcher: {
+    type: "keyword",
+    keywords: [
+      "my salary is",
+      "my base salary",
+      "annual compensation",
+      "total comp",
+      "my tc is",
+      "my package is",
+      "i make $",
+      "i earn $",
+      "offered $"
+    ],
+    caseSensitive: false
+  },
+  examples: ["My salary is $150,000"]
+};
+
+// ../../rules/core-financial/swift.json
+var swift_default = {
+  specVersion: 1,
+  id: "core-financial/swift",
+  name: "SWIFT/BIC code",
+  category: "financial",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:swift|bic)\\b[\\s#:=-]{0,8}([A-Z]{6}[A-Z0-9]{2}(?:[A-Z0-9]{3})?)\\b",
+    flags: "gi",
+    captureGroup: 1
+  },
+  examples: ["SWIFT: BOFAUS3N", "BIC: CHASGB2LXXX"]
+};
+
+// ../../rules/core-phi/biometric-ref.json
+var biometric_ref_default = {
+  specVersion: 1,
+  id: "core-phi/biometric-ref",
+  name: "Biometric data reference",
+  category: "phi",
+  severity: "high",
+  matcher: {
+    type: "keyword",
+    keywords: [
+      "fingerprint data",
+      "fingerprint scan",
+      "my iris scan",
+      "my retina scan",
+      "my biometric",
+      "my facial recognition",
+      "my voiceprint",
+      "my palm print",
+      "my hand geometry"
+    ],
+    caseSensitive: false
+  },
+  examples: ["My fingerprint data is stored in the biometric database"]
+};
+
+// ../../rules/core-phi/genetic-data.json
+var genetic_data_default = {
+  specVersion: 1,
+  id: "core-phi/genetic-data",
+  name: "Genetic/DNA sequence reference",
+  category: "phi",
+  severity: "high",
+  matcher: {
+    type: "keyword",
+    keywords: [
+      "my dna sequence",
+      "my genome",
+      "my genetic",
+      "dna test results",
+      "genetic test results",
+      "my 23andme",
+      "my ancestrydna",
+      "gene variant",
+      "my genotype",
+      "my haplogroup"
+    ],
+    caseSensitive: false
+  },
+  examples: ["My DNA sequence shows a variant in the BRCA1 gene"]
+};
+
+// ../../rules/core-phi/group-id.json
+var group_id_default = {
+  specVersion: 1,
+  id: "core-phi/group-id",
+  name: "Health plan group ID",
+  category: "phi",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\bgroup\\s*(?:id|number|no|#)\\s*[:#]?\\s*[A-Za-z0-9]{6,20}\\b",
+    flags: "gi"
+  },
+  requiresNearby: {
+    ruleIds: ["core-phi/member-id"],
+    labels: ["member id", "subscriber", "health plan"],
+    windowChars: 200,
+    confidenceBoost: 0.05
+  },
+  examples: ["Member ID: ABC987654321, Group ID: GRP12345678"]
+};
+
+// ../../rules/core-phi/hipaa-identifier.json
+var hipaa_identifier_default = {
+  specVersion: 1,
+  id: "core-phi/hipaa-identifier",
+  name: "HIPAA standard identifier (health plan / beneficiary / claim number)",
+  category: "phi",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:health\\s+plan|beneficiary|claim\\s+number|subscriber)[:\\s]*[A-Za-z0-9]{8,20}\\b",
+    flags: "gi"
+  },
+  examples: ["Health Plan: XYZ123456789", "Beneficiary: ABC987654321"]
+};
+
+// ../../rules/core-phi/icd10-code.json
+var icd10_code_default = {
+  specVersion: 1,
+  id: "core-phi/icd10-code",
+  name: "ICD-10 diagnosis code",
+  category: "phi",
+  severity: "medium",
+  matcher: {
+    type: "regex",
+    pattern: "(?:icd[- ]?10|diagnosis|\\bdx\\b).{0,12}?([A-Z][0-9]{2}(?:\\.[0-9]{1,4})?)\\b",
+    flags: "gi",
+    captureGroup: 1
+  },
+  examples: ["ICD-10: I10", "Diagnosis code E11.9", "dx: J45.909"]
+};
+
+// ../../rules/core-phi/member-id.json
+var member_id_default = {
+  specVersion: 1,
+  id: "core-phi/member-id",
+  name: "Health plan member ID",
+  category: "phi",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\bmember\\s*(?:id|number|no|#)\\s*[:#]?\\s*[A-Za-z0-9]{6,20}\\b",
+    flags: "gi"
+  },
+  examples: ["Member ID: ABC987654321"]
+};
+
+// ../../rules/core-phi/mrn.json
+var mrn_default = {
+  specVersion: 1,
+  id: "core-phi/mrn",
+  name: "Medical Record Number",
+  category: "phi",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:MRN|MR#|medical\\s+record)[:\\s]*[A-Za-z0-9]{6,16}\\b",
+    flags: "gi"
+  },
+  examples: ["MRN: 1234567890", "Medical Record: ABCD1234"]
+};
+
+// ../../rules/core-phi/ndc-code.json
+var ndc_code_default = {
+  specVersion: 1,
+  id: "core-phi/ndc-code",
+  name: "National Drug Code (NDC)",
+  category: "phi",
+  severity: "medium",
+  matcher: {
+    type: "regex",
+    pattern: "\\b\\d{4,5}-\\d{3,4}-\\d{1,2}\\b",
+    flags: "g"
+  },
+  examples: ["0002-1427-01", "68788-6965-1"]
+};
+
+// ../../rules/core-pii/dob.json
+var dob_default = {
+  specVersion: 1,
+  id: "core-pii/dob",
+  name: "Date of birth",
+  category: "pii",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:(?:19[4-9]\\d|20[0-1]\\d)[/-]\\d{1,2}[/-]\\d{1,2}|\\d{1,2}[/-]\\d{1,2}[/-](?:19[4-9]\\d|20[0-1]\\d))\\b",
+    flags: "g"
+  },
+  requiresNearby: {
+    categories: ["pii"],
+    labels: ["dob", "date of birth", "birth", "d.o.b"],
+    windowChars: 160
+  },
+  examples: ["DOB: 1985-03-22", "Date of birth: 03/22/1985"]
+};
+
+// ../../rules/core-pii/drivers-license-us.json
+var drivers_license_us_default = {
+  specVersion: 1,
+  id: "core-pii/drivers-license-us",
+  name: "US driver's license number",
+  category: "pii",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "(?:driver'?s?\\s*licen[sc]e|licen[sc]e|\\bDL\\b).{0,10}?([A-Z]\\d{6,8}|\\d{8,9})\\b",
+    flags: "gi",
+    captureGroup: 1
+  },
+  examples: ["Driver's License: D1234567", "DL: 123456789"]
+};
+
+// ../../rules/core-pii/email.json
+var email_default = {
+  specVersion: 1,
+  id: "core-pii/email",
+  name: "Email address",
+  category: "pii",
+  severity: "medium",
+  matcher: {
+    type: "regex",
+    pattern: "(?<![A-Za-z0-9._%+-])[A-Za-z0-9._%+-]{1,64}@[A-Za-z0-9.-]{1,255}\\.[A-Za-z]{2,24}\\b",
+    flags: "g"
+  },
+  examples: ["user@example.com"]
+};
+
+// ../../rules/core-pii/home-address.json
+var home_address_default = {
+  specVersion: 1,
+  id: "core-pii/home-address",
+  name: "Home address (contextual)",
+  category: "pii",
+  severity: "medium",
+  matcher: {
+    type: "keyword",
+    keywords: [
+      "my address is",
+      "home address",
+      "shipping address",
+      "billing address",
+      "mailing address",
+      "my home is at",
+      "i reside at"
+    ],
+    caseSensitive: false
+  },
+  examples: ["My address is 123 Main St, Springfield, IL 62701"]
+};
+
+// ../../rules/core-pii/ip-address.json
+var ip_address_default = {
+  specVersion: 1,
+  id: "core-pii/ip-address",
+  name: "IP address",
+  category: "pii",
+  severity: "low",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\b",
+    flags: "g"
+  },
+  examples: ["192.168.1.1", "10.0.0.1"]
+};
+
+// ../../rules/core-pii/mac-address.json
+var mac_address_default = {
+  specVersion: 1,
+  id: "core-pii/mac-address",
+  name: "MAC address",
+  category: "pii",
+  severity: "low",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:[0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}\\b",
+    flags: "g"
+  },
+  examples: ["AA:BB:CC:DD:EE:FF"]
+};
+
+// ../../rules/core-pii/name.json
+var name_default = {
+  specVersion: 1,
+  id: "core-pii/name",
+  name: "Personal name (contextual)",
+  category: "pii",
+  severity: "medium",
+  matcher: {
+    type: "keyword",
+    keywords: [
+      "my name is",
+      "my full name",
+      "i am called",
+      "please call me",
+      "name:\n",
+      '"full_name": "',
+      '"fullName": "'
+    ],
+    caseSensitive: false
+  },
+  examples: ["My name is John Doe"]
+};
+
+// ../../rules/core-pii/national-id.json
+var national_id_default = {
+  specVersion: 1,
+  id: "core-pii/national-id",
+  name: "National ID number (multi-country)",
+  category: "pii",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\b[A-Z]{2}\\d{6}[A-D]\\b|\\b[2-9]\\d{11}\\b|(?:national\\s*id|aadhaar|\\bSIN\\b).{0,10}?\\d{3}[\\s-]?\\d{3}[\\s-]?\\d{3}\\b",
+    flags: "gi"
+  },
+  requiresNearby: {
+    labels: [
+      "national id",
+      "national identity",
+      "national insurance",
+      "nino",
+      "ni",
+      "aadhaar",
+      "sin",
+      "identity number",
+      "id number"
+    ],
+    windowChars: 160
+  },
+  examples: ["Aadhaar: 234567890123", "NI: AB123456C", "SIN: 123-456-789"]
+};
+
+// ../../rules/core-pii/passport-us.json
+var passport_us_default = {
+  specVersion: 1,
+  id: "core-pii/passport-us",
+  name: "US passport number",
+  category: "pii",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\b[A-Z]\\d{8}\\b",
+    flags: "g"
+  },
+  requiresNearby: {
+    labels: ["passport"],
+    windowChars: 160
+  },
+  examples: ["Passport: A12345678"]
+};
+
+// ../../rules/core-pii/phone-intl.json
+var phone_intl_default = {
+  specVersion: 1,
+  id: "core-pii/phone-intl",
+  name: "International phone number",
+  category: "pii",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\+\\d{1,3}(?:[-.\\s]\\d{1,14}){1,5}\\b",
+    flags: "g"
+  },
+  examples: ["+44 20 7946 0958", "+86 138 0013 8000"]
+};
+
+// ../../rules/core-pii/phone-us.json
+var phone_us_default = {
+  specVersion: 1,
+  id: "core-pii/phone-us",
+  name: "US phone number",
+  category: "pii",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "(?<!\\d)(?:\\+?1[-.\\s]?)?(?:\\([2-9]\\d{2}\\)[-.\\s]?|[2-9]\\d{2}[-.\\s])\\d{3}[-.\\s]\\d{4}(?!\\d)",
+    flags: "g"
+  },
+  requiresNearby: {
+    labels: ["phone", "call", "mobile", "cell", "tel", "telephone", "contact", "fax", "dial"],
+    windowChars: 160
+  },
+  examples: ["(555) 123-4567", "+1-555-123-4567"]
+};
+
+// ../../rules/core-pii/ssn.json
+var ssn_default = {
+  specVersion: 1,
+  id: "core-pii/ssn",
+  name: "US Social Security Number",
+  category: "pii",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?!000|666|9\\d{2})\\d{3}[\\s\\-](?!00)\\d{2}[\\s\\-](?!0000)\\d{4}\\b",
+    flags: "g"
+  },
+  examples: ["123-45-6789"]
+};
+
+// ../../rules/core-pii/vin.json
+var vin_default = {
+  specVersion: 1,
+  id: "core-pii/vin",
+  name: "Vehicle Identification Number",
+  category: "pii",
+  severity: "medium",
+  matcher: {
+    type: "regex",
+    pattern: "\\b[A-HJ-NPR-Z0-9]{17}\\b",
+    flags: "g"
+  },
+  examples: ["1HGCM82633A004352"]
+};
+
+// ../../rules/core-pii/zip.json
+var zip_default = {
+  specVersion: 1,
+  id: "core-pii/zip",
+  name: "US ZIP / ZIP+4 postal code",
+  category: "pii",
+  severity: "low",
+  matcher: {
+    type: "regex",
+    pattern: "\\b\\d{5}(?:-\\d{4})?\\b",
+    flags: "g"
+  },
+  requiresNearby: {
+    ruleIds: ["core-pii/home-address"],
+    labels: [
+      "address",
+      "street",
+      "avenue",
+      "boulevard",
+      "mailing",
+      "shipping",
+      "billing",
+      "suite",
+      "p.o. box",
+      "po box",
+      "postal"
+    ],
+    windowChars: 120
+  },
+  examples: ["Shipping address: 123 Main Street, Springfield, IL 94107-1234"]
+};
+
+// ../../rules/secrets-infra/api-key-header.json
+var api_key_header_default = {
+  specVersion: 1,
+  id: "secrets-infra/api-key-header",
+  name: "API key in a custom HTTP header",
+  category: "secret",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: `["']?\\bapi-?key\\b["']?\\s*:\\s*["']?([A-Za-z0-9+/_\\-.]{16,500})["']?`,
+    flags: "gi",
+    captureGroup: 1
+  },
+  postValidators: ["entropy"],
+  examples: ["X-Api-Key: aBc123XyZ789kLmNoPqRsTuVwXyZ1234567890"]
+};
+
+// ../../rules/secrets-infra/basic-auth-header.json
+var basic_auth_header_default = {
+  specVersion: 1,
+  id: "secrets-infra/basic-auth-header",
+  name: "HTTP Basic auth Authorization header",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "authorization\\s*:\\s*basic\\s+[A-Za-z0-9+/=]{16,}",
+    flags: "gi"
+  },
+  examples: ["Authorization: Basic dXNlcjpwYXNzd29yZDEyMzQ="]
+};
+
+// ../../rules/secrets-infra/basic-auth-url.json
+var basic_auth_url_default = {
+  specVersion: 1,
+  id: "secrets-infra/basic-auth-url",
+  name: "URL with embedded basic auth credentials",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "https?://[A-Za-z0-9_%\\-]+:[A-Za-z0-9_%\\-]+@[A-Za-z0-9.\\-]+",
+    flags: "g"
+  },
+  examples: ["https://user:password@example.com/path"]
+};
+
+// ../../rules/secrets-infra/bearer-token.json
+var bearer_token_default = {
+  specVersion: 1,
+  id: "secrets-infra/bearer-token",
+  name: "Generic Authorization Bearer token",
+  category: "secret",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:Bearer|bearer)\\s+([A-Za-z0-9_\\-.]{20,500})",
+    flags: "g",
+    captureGroup: 1
+  },
+  postValidators: ["entropy"],
+  examples: [
+    "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U"
+  ]
+};
+
+// ../../rules/secrets-infra/db-connection-string.json
+var db_connection_string_default = {
+  specVersion: 1,
+  id: "secrets-infra/db-connection-string",
+  name: "Database connection string with credentials",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:postgres(?:ql)?|mysql|mongodb(?:\\+srv)?|redis|rediss)://[A-Za-z0-9_%\\-]+:[A-Za-z0-9_%\\-]+@[A-Za-z0-9.\\-]+(?:\\:\\d+)?",
+    flags: "g"
+  },
+  examples: ["postgresql://user:password@localhost:5432/mydb"]
+};
+
+// ../../rules/secrets-infra/docker-config-auth.json
+var docker_config_auth_default = {
+  specVersion: 1,
+  id: "secrets-infra/docker-config-auth",
+  name: "Docker config.json auth (base64-encoded)",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: '"auth"\\s*:\\s*"[A-Za-z0-9+/]{12,}={0,2}"',
+    flags: "g"
+  },
+  examples: ['"auths": {"https://index.docker.io/v1/": {"auth": "dXNlcjpwYXNzd29yZA=="}}']
+};
+
+// ../../rules/secrets-infra/env-key-value.json
+var env_key_value_default = {
+  specVersion: 1,
+  id: "secrets-infra/env-key-value",
+  name: "Environment variable assignment with sensitive key",
+  category: "secret",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: `\\b[A-Za-z0-9_]*(?:API_KEY|API_SECRET|SECRET_KEY|SECRET|TOKEN|PASSWORD|PASS|CREDENTIALS|PRIVATE_KEY|ENCRYPTION_KEY|SIGNING_KEY)\\s*=\\s*["']?([^\\s"']{4,})`,
+    flags: "gi",
+    captureGroup: 1
+  },
+  examples: ["API_KEY=aBcDeFgHiJkLmNoPqRsTuVwXyZ1234567890"]
+};
+
+// ../../rules/secrets-infra/generic-high-entropy-secret.json
+var generic_high_entropy_secret_default = {
+  specVersion: 1,
+  id: "secrets-infra/generic-high-entropy-secret",
+  name: "Generic high-entropy secret assigned to a credential-shaped field",
+  category: "secret",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: `(?<![A-Za-z0-9_-])[A-Za-z0-9_]{0,34}(?:(?:secret|token|passw(?:or)?d|credentials?|(?<!api[_-]?)key)(?:["']?\\s*:|\\s+=)|(?:passwd|credential|(?<!api[_-]?)(?<!secret_)(?<!private_)(?<!encryption_)(?<!signing_)key)=)\\s*["']?((?!eyJ)[A-Za-z0-9+/_\\-]{20,200})`,
+    flags: "gi",
+    captureGroup: 1
+  },
+  postValidators: ["entropy"],
+  examples: [
+    'authToken: "aBc123XyZ789kLmNoPqRsTuVwXyZ1234567890"',
+    "MASTER_KEY=aBc123XyZ789kLmNoPqRsTuVwXyZ1234567890"
+  ]
+};
+
+// ../../rules/secrets-infra/jwt-token.json
+var jwt_token_default = {
+  specVersion: 1,
+  id: "secrets-infra/jwt-token",
+  name: "JSON Web Token (JWT)",
+  category: "secret",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: "\\beyJ[A-Za-z0-9_\\-+/]+\\.[A-Za-z0-9_\\-+/]+\\.[A-Za-z0-9_\\-+/]+\\b",
+    flags: "g"
+  },
+  postValidators: ["entropy"],
+  examples: [
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U"
+  ]
+};
+
+// ../../rules/secrets-infra/kubeconfig-token.json
+var kubeconfig_token_default = {
+  specVersion: 1,
+  id: "secrets-infra/kubeconfig-token",
+  name: "Kubernetes kubeconfig embedded token",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:client-(?:certificate|key)-data|token):\\s+([A-Za-z0-9+/=_.-]{20,})",
+    flags: "g",
+    captureGroup: 1
+  },
+  examples: ["token: eyJhbGciOiJSUzI1NiIsImtpZCI6IiJ9..."]
+};
+
+// ../../rules/secrets-infra/password-field.json
+var password_field_default = {
+  specVersion: 1,
+  id: "secrets-infra/password-field",
+  name: "JSON/YAML field with password value",
+  category: "secret",
+  severity: "high",
+  matcher: {
+    type: "regex",
+    pattern: `["']?\\b(?:password|passwd|pwd|pass|secret|token|api[_-]?key|apikey)\\b["']?\\s*:\\s*["']([^"'\\n]{4,})["']`,
+    flags: "gi",
+    captureGroup: 1
+  },
+  examples: ['"password": "supersecret123"']
+};
+
+// ../../rules/secrets-infra/pgp-private-key.json
+var pgp_private_key_default = {
+  specVersion: 1,
+  id: "secrets-infra/pgp-private-key",
+  name: "PGP private key block",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "-----BEGIN PGP PRIVATE KEY BLOCK-----",
+    flags: "g"
+  },
+  examples: [
+    "-----BEGIN PGP PRIVATE KEY BLOCK-----\nVersion: Keybase Go 1.0.0\n...\n-----END PGP PRIVATE KEY BLOCK-----"
+  ]
+};
+
+// ../../rules/secrets-infra/ssh-private-key.json
+var ssh_private_key_default = {
+  specVersion: 1,
+  id: "secrets-infra/ssh-private-key",
+  name: "SSH private key",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "-----BEGIN (?:RSA |DSA |EC |OPENSSH |SSH2 )?PRIVATE KEY-----",
+    flags: "g"
+  },
+  examples: [
+    "-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEA...\n-----END RSA PRIVATE KEY-----"
+  ]
+};
+
+// ../../rules/secrets/anthropic-api-key.json
+var anthropic_api_key_default = {
+  specVersion: 1,
+  id: "secrets/anthropic-api-key",
+  name: "Anthropic API key",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\bsk-ant-[A-Za-z0-9_-]{40,}",
+    flags: "g"
+  },
+  postValidators: ["entropy"],
+  examples: ["sk-ant-AbCdEfGhIjKlMnOpQrStUvWxYzAbCdEfGhIjKlMnOpQrStUvWxYz"]
+};
+
+// ../../rules/secrets/aws-access-key.json
+var aws_access_key_default = {
+  specVersion: 1,
+  id: "secrets/aws-access-key",
+  name: "AWS Access Key ID",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(AKIA|ASIA|AROA|AIDA|ANPA|ANVA|APKA)[A-Z0-9]{16}\\b",
+    flags: "g"
+  },
+  postValidators: ["entropy"],
+  examples: ["AKIAIOSFODNN7EXAMPLE"]
+};
+
+// ../../rules/secrets/aws-secret-key.json
+var aws_secret_key_default = {
+  specVersion: 1,
+  id: "secrets/aws-secret-key",
+  name: "AWS Secret Access Key",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: `aws[_.-]?secret[_.-]?(?:access[_.-]?)?key["'\\s:=]{1,5}([A-Za-z0-9/+]{40})`,
+    flags: "gi",
+    captureGroup: 1
+  },
+  postValidators: ["entropy"],
+  examples: ["AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"]
+};
+
+// ../../rules/secrets/azure-connection-string.json
+var azure_connection_string_default = {
+  specVersion: 1,
+  id: "secrets/azure-connection-string",
+  name: "Azure connection string",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "(?<![A-Za-z0-9])(?:DefaultEndpointsProtocol|AccountEndpoint|AccountName|AccountKey|SharedAccessSignature|SharedAccessKeyName|SharedAccessKey|EndpointSuffix|BlobEndpoint|QueueEndpoint|TableEndpoint|FileEndpoint|HostName|Endpoint)=(?![{<($])[^\\x3B\\r\\n]{1,400}\\x3B(?:[A-Za-z][A-Za-z0-9_]{0,39}=[^\\x3B\\r\\n]{1,400}\\x3B){0,10}(?:DefaultEndpointsProtocol|AccountEndpoint|AccountName|AccountKey|SharedAccessSignature|SharedAccessKeyName|SharedAccessKey|EndpointSuffix|BlobEndpoint|QueueEndpoint|TableEndpoint|FileEndpoint|HostName|Endpoint)=(?![{<($])[^\\x3B\\r\\n]{1,400}(?:\\x3B[A-Za-z][A-Za-z0-9_]{0,39}=[^\\x3B\\r\\n]{1,400}){0,10}",
+    flags: "g"
+  },
+  examples: ["AccountName=mystorage;AccountKey=abc123=="]
+};
+
+// ../../rules/secrets/cloudflare-api-key.json
+var cloudflare_api_key_default = {
+  specVersion: 1,
+  id: "secrets/cloudflare-api-key",
+  name: "Cloudflare API token",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: `cloudflare.{0,40}?["'\\s:=]([A-Za-z0-9_-]{40})`,
+    flags: "gi",
+    captureGroup: 1
+  },
+  postValidators: ["entropy"],
+  examples: ["CLOUDFLARE_API_TOKEN=kQ9fL2mP7xR4tY6wB1nC8vD3jH5sZ0aG2eU4iO7p"]
+};
+
+// ../../rules/secrets/datadog-key.json
+var datadog_key_default = {
+  specVersion: 1,
+  id: "secrets/datadog-key",
+  name: "Datadog API/Application key",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:DD_API_KEY|DD_APP_KEY|DATADOG_API_KEY|DATADOG_APP_KEY)[\\s:=]+([A-Za-z0-9]{32,40})\\b",
+    flags: "gi",
+    captureGroup: 1
+  },
+  postValidators: ["entropy"],
+  examples: ["DD_API_KEY=a3F5g8H1j4K7m2N0p9Q6r1S4t7U0v3W8"]
+};
+
+// ../../rules/secrets/digitalocean-token.json
+var digitalocean_token_default = {
+  specVersion: 1,
+  id: "secrets/digitalocean-token",
+  name: "DigitalOcean Personal Access Token",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\bdop_v1_[A-Za-z0-9]{64}\\b",
+    flags: "g"
+  },
+  examples: ["dop_v1_1234567890123456789012345678901234567890123456789012345678901234"]
+};
+
+// ../../rules/secrets/discord-token.json
+var discord_token_default = {
+  specVersion: 1,
+  id: "secrets/discord-token",
+  name: "Discord bot token",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\b[A-Za-z0-9]{24}\\.[A-Za-z0-9]{6}\\.[A-Za-z0-9_\\-]{27}\\b",
+    flags: "g"
+  },
+  postValidators: ["entropy"],
+  examples: ["AbCdEfGhIjKlMnOpQrStUvWx.YzAbCd.ABCdEfGhIjKlMnOpQrStUvWxYzAbCdEf"]
+};
+
+// ../../rules/secrets/gcp-service-account.json
+var gcp_service_account_default = {
+  specVersion: 1,
+  id: "secrets/gcp-service-account",
+  name: "GCP service account key",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\b[a-z0-9][a-z0-9-]{2,60}@[a-z0-9][a-z0-9-]{2,60}\\.iam\\.gserviceaccount\\.com\\b",
+    flags: "g"
+  },
+  examples: [
+    "deploy-bot@sample-project.iam.gserviceaccount.com",
+    "12345678-1234-1234-1234-123456789012@my-project.iam.gserviceaccount.com"
+  ]
+};
+
+// ../../rules/secrets/github-pat.json
+var github_pat_default = {
+  specVersion: 1,
+  id: "secrets/github-pat",
+  name: "GitHub Personal Access Token (classic and fine-grained)",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:gh[psou]_[A-Za-z0-9]{36}|github_pat_[0-9A-Za-z_]{82})\\b",
+    flags: "g"
+  },
+  examples: [
+    "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",
+    "ghp_aBcDeFgHiJkLmNoPqRsTuVwXyZ1234567890"
+  ]
+};
+
+// ../../rules/secrets/gitlab-token.json
+var gitlab_token_default = {
+  specVersion: 1,
+  id: "secrets/gitlab-token",
+  name: "GitLab Personal/Project Access Token",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\bglpat-[A-Za-z0-9\\-_]{20,40}\\b",
+    flags: "g"
+  },
+  postValidators: ["entropy"],
+  examples: ["glpat-ABCdEfGhIjKlMnOpQrStUvWxYz1234567890"]
+};
+
+// ../../rules/secrets/heroku-api-key.json
+var heroku_api_key_default = {
+  specVersion: 1,
+  id: "secrets/heroku-api-key",
+  name: "Heroku API key",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "heroku.{0,40}?([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})",
+    flags: "gi",
+    captureGroup: 1
+  },
+  examples: ["HEROKU_API_KEY=3f8a1c2e-9b4d-4e6f-a1b2-c3d4e5f6a7b8"]
+};
+
+// ../../rules/secrets/npm-token.json
+var npm_token_default = {
+  specVersion: 1,
+  id: "secrets/npm-token",
+  name: "npm access token",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\bnpm_[A-Za-z0-9]{36,60}\\b",
+    flags: "g"
+  },
+  postValidators: ["entropy"],
+  examples: ["npm_AbCdEfGhIjKlMnOpQrStUvWxYz1234567890AbCdEfGhIjKlMnO"]
+};
+
+// ../../rules/secrets/openai-api-key.json
+var openai_api_key_default = {
+  specVersion: 1,
+  id: "secrets/openai-api-key",
+  name: "OpenAI API key",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\bsk-proj-[A-Za-z0-9]{20,60}\\b|\\bsk-[A-Za-z0-9]{40,55}\\b",
+    flags: "g"
+  },
+  postValidators: ["entropy"],
+  examples: ["sk-proj-AbCdEfGhIjKlMnOpQrStUvWxYz1234567890AbCdEfGhIjK"]
+};
+
+// ../../rules/secrets/pulumi-access-token.json
+var pulumi_access_token_default = {
+  specVersion: 1,
+  id: "secrets/pulumi-access-token",
+  name: "Pulumi access token",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\bpul-[A-Za-z0-9]{20,60}\\b",
+    flags: "g"
+  },
+  postValidators: ["entropy"],
+  examples: ["pul-ABCdEfGhIjKlMnOpQrStUvWxYz1234567890"]
+};
+
+// ../../rules/secrets/sendgrid-key.json
+var sendgrid_key_default = {
+  specVersion: 1,
+  id: "secrets/sendgrid-key",
+  name: "SendGrid API key",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\bSG\\.[A-Za-z0-9_\\-]{20,60}\\b",
+    flags: "g"
+  },
+  postValidators: ["entropy"],
+  examples: ["SG.AbCdEfGhIjKlMnOpQrStUvWxYzAbCdEfGhIjKlMnOpQrStUvWxYz"]
+};
+
+// ../../rules/secrets/slack-token.json
+var slack_token_default = {
+  specVersion: 1,
+  id: "secrets/slack-token",
+  name: "Slack API token",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:xox[baprs]-[A-Za-z0-9]{10,60}|xapp-[A-Za-z0-9-]{10,60})\\b",
+    flags: "g"
+  },
+  examples: ["xoxb-123456789012-123456789012-ABCdEfGhIjKlMnOpQrStUvWx"]
+};
+
+// ../../rules/secrets/stripe-live-key.json
+var stripe_live_key_default = {
+  specVersion: 1,
+  id: "secrets/stripe-live-key",
+  name: "Stripe live API key",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:sk|pk|rk)_live_[A-Za-z0-9]{24,40}\\b",
+    flags: "g"
+  },
+  postValidators: ["entropy"],
+  examples: ["sk_live_aBcDeFgHiJkLmNoPqRsTuVwXyZ"]
+};
+
+// ../../rules/secrets/terraform-cloud-token.json
+var terraform_cloud_token_default = {
+  specVersion: 1,
+  id: "secrets/terraform-cloud-token",
+  name: "Terraform Cloud / TFE user token",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\b[A-Za-z0-9]{14}\\.atlasv1\\.[A-Za-z0-9_\\-]{60,80}\\b",
+    flags: "g"
+  },
+  postValidators: ["entropy"],
+  examples: [
+    "AbCdEfGhIjKlMnOp.atlasv1.XyZ1234567890123456789012345678901234567890123456789012345678901234567890"
+  ]
+};
+
+// ../../rules/secrets/twilio-key.json
+var twilio_key_default = {
+  specVersion: 1,
+  id: "secrets/twilio-key",
+  name: "Twilio Account SID",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\bAC[A-Za-z0-9]{32}\\b",
+    flags: "g"
+  },
+  examples: ["AC12345678901234567890123456789012"]
+};
+
+// ../../rules/secrets/vault-token.json
+var vault_token_default = {
+  specVersion: 1,
+  id: "secrets/vault-token",
+  name: "HashiCorp Vault token",
+  category: "secret",
+  severity: "critical",
+  matcher: {
+    type: "regex",
+    pattern: "\\b(?:hvs\\.[A-Za-z0-9\\-_]{20,50}|s\\.[A-Za-z0-9\\-_]{20,50})\\b",
+    flags: "g"
+  },
+  postValidators: ["entropy"],
+  examples: ["hvs.AbCdEfGhIjKlMnOpQrStUvWxYz1234567890"]
+};
+
+// ../../packages/plugin-sdk/src/bundled-packs.generated.ts
+var BUNDLED_PACKS = [
+  {
+    packId: "code-flaws",
+    name: "Code Security Flaws",
+    version: "0.1.0",
+    rawRules: [
+      sql_inject_concat_default,
+      sql_inject_concat_dot_default,
+      sql_inject_format_default,
+      sql_inject_interp_default,
+      cmd_inject_shell_default,
+      cmd_inject_exec_default,
+      cmd_inject_node_exec_default,
+      xss_inner_html_default,
+      xss_dangerously_set_default,
+      xss_unescaped_render_default,
+      deser_pickle_default,
+      deser_yaml_unsafe_default,
+      deser_java_ois_default,
+      hardcoded_password_default,
+      hardcoded_secret_key_default,
+      dev_debug_enabled_default,
+      dev_placeholder_secret_default,
+      dev_wildcard_cors_default,
+      auth_ssl_verify_false_default,
+      auth_jwt_no_verify_default,
+      path_traversal_open_default,
+      path_traversal_join_default,
+      crypto_weak_hash_md5_default,
+      crypto_weak_hash_sha1_default,
+      crypto_insecure_random_default,
+      prototype_pollution_merge_default,
+      eval_dynamic_exec_default,
+      ssrf_user_url_default,
+      regex_redos_backtrack_default
+    ]
+  },
+  {
+    packId: "core-code-context",
+    name: "Code Context",
+    version: "0.1.0",
+    rawRules: [
+      internal_ip_default,
+      localhost_ref_default,
+      internal_domain_default,
+      file_path_default,
+      stack_trace_default,
+      internal_url_default,
+      feature_flag_default,
+      db_table_name_default
+    ]
+  },
+  {
+    packId: "core-financial",
+    name: "Financial Information",
+    version: "0.1.0",
+    rawRules: [
+      credit_card_default,
+      iban_default,
+      routing_number_default,
+      swift_default,
+      cvv_default,
+      cusip_default,
+      paypal_default,
+      salary_default
+    ]
+  },
+  {
+    packId: "core-phi",
+    name: "Protected Health Information",
+    version: "0.1.0",
+    rawRules: [
+      mrn_default,
+      hipaa_identifier_default,
+      member_id_default,
+      group_id_default,
+      icd10_code_default,
+      ndc_code_default,
+      genetic_data_default,
+      biometric_ref_default
+    ]
+  },
+  {
+    packId: "core-pii",
+    name: "Core PII",
+    version: "0.2.0",
+    rawRules: [
+      email_default,
+      ssn_default,
+      phone_us_default,
+      phone_intl_default,
+      ip_address_default,
+      dob_default,
+      drivers_license_us_default,
+      passport_us_default,
+      home_address_default,
+      name_default,
+      vin_default,
+      mac_address_default,
+      national_id_default,
+      zip_default
+    ]
+  },
+  {
+    packId: "secrets",
+    name: "Secrets & Credentials",
+    version: "0.1.0",
+    rawRules: [
+      aws_access_key_default,
+      aws_secret_key_default,
+      gcp_service_account_default,
+      azure_connection_string_default,
+      openai_api_key_default,
+      anthropic_api_key_default,
+      stripe_live_key_default,
+      slack_token_default,
+      discord_token_default,
+      sendgrid_key_default,
+      twilio_key_default,
+      gitlab_token_default,
+      digitalocean_token_default,
+      datadog_key_default,
+      npm_token_default,
+      heroku_api_key_default,
+      cloudflare_api_key_default,
+      pulumi_access_token_default,
+      terraform_cloud_token_default,
+      vault_token_default,
+      github_pat_default
+    ]
+  },
+  {
+    packId: "secrets-infra",
+    name: "Infrastructure Secrets",
+    version: "0.1.0",
+    rawRules: [
+      ssh_private_key_default,
+      db_connection_string_default,
+      jwt_token_default,
+      basic_auth_url_default,
+      basic_auth_header_default,
+      pgp_private_key_default,
+      bearer_token_default,
+      env_key_value_default,
+      password_field_default,
+      docker_config_auth_default,
+      kubeconfig_token_default,
+      api_key_header_default,
+      generic_high_entropy_secret_default
+    ]
+  }
+];
+
+// ../../packages/plugin-sdk/src/rule-packs.ts
+function registerRulePack(packId, rawRules) {
+  const rules = rawRules.map((raw) => Rule.parse(raw));
+  registerPack({ id: packId, rules });
+}
+function registerBundledPacks() {
+  for (const pack of BUNDLED_PACKS) registerRulePack(pack.packId, pack.rawRules);
+}
+
+// ../../packages/plugin-sdk/src/mask.ts
+var packsReady = false;
+var packsFailed = false;
+function ensureBundledPacks() {
+  if (packsReady) return true;
+  if (packsFailed) return false;
+  try {
+    registerBundledPacks();
+    packsReady = true;
+    return true;
+  } catch {
+    packsFailed = true;
+    return false;
+  }
+}
+function scanText(text, ruleVersions) {
+  if (!ensureBundledPacks()) return { masked: "[REDACTED]", findings: [] };
+  try {
+    const rules = getLoadedRules();
+    const matches = scan(text, rules);
+    if (matches.length === 0) return { masked: text, findings: [] };
+    const byId = new Map(rules.map((r) => [r.id, r]));
+    const findings = matches.map((m) => {
+      const rule = byId.get(m.ruleId);
+      return {
+        ruleId: m.ruleId,
+        ruleName: rule?.name ?? m.ruleId,
+        ruleVersion: ruleVersions?.[m.ruleId] ?? String(rule?.specVersion ?? 1),
+        category: m.category,
+        severity: m.severity,
+        span: m.span,
+        maskedMatch: maskMatch(m.rawMatch),
+        confidence: m.confidence
+      };
+    });
+    return { masked: redact(text, matches), findings };
+  } catch {
+    return { masked: "[REDACTED]", findings: [] };
+  }
+}
+function maskText(text) {
+  return scanText(text).masked;
+}
+
+// ../../packages/plugin-sdk/src/repo.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, statSync } from "fs";
+import { basename, dirname, isAbsolute, join as join7, sep as sep2 } from "path";
+
+// ../../packages/plugin-sdk/src/events.ts
+import { createHash as createHash4, randomUUID as randomUUID9 } from "crypto";
+
+// ../../packages/plugin-sdk/src/inventory-resolver.ts
+import { arch, hostname as hostname3, platform, release } from "os";
+
+// ../../packages/plugin-sdk/src/nudge.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join9 } from "path";
+
+// ../../packages/plugin-sdk/src/paths.ts
+import { readdirSync as readdirSync2, realpathSync as realpathSync2 } from "fs";
+import { basename as basename3, dirname as dirname2, sep as sep3 } from "path";
+
+// ../../packages/plugin-sdk/src/posture.ts
+function applyCategoryPosture(posture, repo, mode = "fill-gaps") {
+  for (const category of Object.keys(posture)) {
+    const policyId = posture[category];
+    if (!policyId) continue;
+    if (mode === "fill-gaps" && repo.getCategoryAction(category) !== void 0) continue;
+    repo.upsertCategoryAction(category, builtinPolicyToAction(policyId));
+  }
+}
 
 // ../../packages/plugin-sdk/src/project-files.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "fs";
-import { basename as basename4, join as join9, relative, sep as sep4 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "fs";
+import { basename as basename4, join as join10, relative, sep as sep4 } from "path";
 
 // ../../packages/plugin-sdk/src/raw-egress.ts
 var RawEgressError = class extends Error {
@@ -24180,8 +26915,8 @@ async function applySetupTriageSuppressions(entries, writer, opts) {
 }
 
 // ../../packages/plugin-sdk/src/throttle.ts
-import { mkdirSync as mkdirSync4, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
-import { join as join10 } from "path";
+import { mkdirSync as mkdirSync3, statSync as statSync3, writeFileSync as writeFileSync4 } from "fs";
+import { join as join11 } from "path";
 
 // src/command-registry.ts
 import { readdirSync as readdirSync4 } from "fs";
@@ -24296,12 +27031,12 @@ function show(body) {
 }
 
 // src/triage/gate-display.ts
-function findContext(entry, join14) {
-  const byFingerprint = join14.find(
+function findContext(entry, join15) {
+  const byFingerprint = join15.find(
     (j) => j.valueFingerprint !== void 0 && j.valueFingerprint === entry.valueFingerprint
   );
   if (byFingerprint) return byFingerprint.maskedContext;
-  const byRuleAndMask = join14.find(
+  const byRuleAndMask = join15.find(
     (j) => j.ruleId === entry.ruleId && j.maskedMatch === entry.maskedValue
   );
   return byRuleAndMask?.maskedContext;
@@ -24372,13 +27107,13 @@ function renderShowcase(showcase) {
 
 ${blocks.join("\n\n")}`;
 }
-function renderSuppressionGate(entries, join14) {
+function renderSuppressionGate(entries, join15) {
   if (entries.length === 0) {
     return "No false-positive suppressions to confirm \u2014 nothing will be written.";
   }
   const header = entries.length === 1 ? "This looks like a false positive \u2014 take a look before I suppress it:" : `These ${String(entries.length)} look like false positives \u2014 take a look before I suppress them:`;
   const blocks = entries.map((entry, i) => {
-    const context = findContext(entry, join14);
+    const context = findContext(entry, join15);
     const lines = [
       `${String(i + 1)}. ${entry.ruleId} [${entry.category}]`,
       `   value:   ${entry.maskedValue}`,
@@ -24415,10 +27150,10 @@ function renderRecommendedPosture(posture) {
 }
 var GRID_MARK = "\u25CF";
 function renderPostureGrid(posture) {
-  const packs = Object.keys(posture).sort(
+  const packs2 = Object.keys(posture).sort(
     (a, b) => categoryRank(a) - categoryRank(b)
   );
-  const rows = packs.map((category) => [
+  const rows = packs2.map((category) => [
     category,
     ...BUILTIN_ORDER.map((level) => posture[category] === level ? GRID_MARK : "")
   ]);
@@ -24469,14 +27204,17 @@ function frameCalibration(preview, maskedFindings = [], falsePositivePatterns =
 }
 var SCAN_CLEAN_HEADLINE = "I looked over Claude's recent work \u2014 nothing needs your attention right now. You're starting clean; here's what I'd recommend:";
 var NO_HISTORY_HEADLINE = "Nothing to learn from yet \u2014 Claude hasn't left any work on this machine. I'll start each detection category at a careful default:";
-function frameEmptyState(cause, posture) {
-  const frame = {
+function zeroCountFrame(posture) {
+  return {
     counts: { total: 0, important: 0, routine: 0 },
     routineCategories: [],
     surfacedCategories: [],
     findingKinds: [],
     posture
   };
+}
+function frameEmptyState(cause, posture) {
+  const frame = zeroCountFrame(posture);
   const copy = cause === "scan-clean" ? `${SCAN_CLEAN_HEADLINE}
 ${renderRecommendedPosture(posture)}` : `${NO_HISTORY_HEADLINE}
 ${renderPostureGrid(posture)}`;
@@ -24605,9 +27343,9 @@ function mergeRecommendations(verdicts) {
 }
 
 // src/triage/plan-file.ts
-import { mkdtempSync, readFileSync as readFileSync7, rmdirSync, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { mkdtempSync, readFileSync as readFileSync7, rmdirSync, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
 import { tmpdir } from "os";
-import { basename as basename5, dirname as dirname3, join as join11 } from "path";
+import { basename as basename5, dirname as dirname3, join as join12 } from "path";
 var SuppressionEntrySchema = external_exports.object({
   ruleId: external_exports.string(),
   category: DetectionCategory,
@@ -24662,9 +27400,9 @@ function serializePlan(plan, current) {
 function writePlanFile(plan, current, rawValues, deps = {}) {
   const serialized = serializePlan(plan, current);
   assertRawFree(serialized, rawValues);
-  const dir = (deps.mkTempDir ?? (() => mkdtempSync(join11(tmpdir(), "aka-plan-"))))();
-  const path = join11(dir, "setup-plan.json");
-  writeFileSync6(path, serialized, { encoding: "utf8", mode: 384 });
+  const dir = (deps.mkTempDir ?? (() => mkdtempSync(join12(tmpdir(), "aka-plan-"))))();
+  const path = join12(dir, "setup-plan.json");
+  writeFileSync5(path, serialized, { encoding: "utf8", mode: 384 });
   return path;
 }
 function readPlanFile(path) {
@@ -24673,7 +27411,7 @@ function readPlanFile(path) {
   return PersistedPlanSchema.parse(json2);
 }
 function deletePlanFile(path) {
-  rmSync2(path, { force: true });
+  rmSync3(path, { force: true });
   const dir = dirname3(path);
   if (!basename5(dir).startsWith("aka-plan-")) return;
   try {
@@ -24742,8 +27480,8 @@ function buildJoinEntries(hits) {
 }
 
 // src/triage/resolve.ts
-function resolveSuppressions(rec, join14) {
-  const byId = new Map(join14.map((e) => [e.id, e]));
+function resolveSuppressions(rec, join15) {
+  const byId = new Map(join15.map((e) => [e.id, e]));
   const entries = [];
   const skipped = [];
   for (const cat of rec.perCategory) {
@@ -24845,7 +27583,7 @@ function parseTriageStream(text) {
   return { hits, status: "complete" };
 }
 function planTriageWriteback(hits, rec) {
-  const join14 = buildJoinEntries(hits);
+  const join15 = buildJoinEntries(hits);
   const rawValues = hits.map((h) => h.rawMatch);
   const skipped = [];
   const posture = {};
@@ -24885,7 +27623,7 @@ function planTriageWriteback(hits, rec) {
   }
   const { entries, skipped: resolveSkips } = resolveSuppressions(
     { perCategory: safeCategories, notes: rec.notes },
-    join14
+    join15
   );
   skipped.push(...resolveSkips);
   let notes = rec.notes;
@@ -24895,7 +27633,7 @@ function planTriageWriteback(hits, rec) {
     if (err instanceof RawEgressError) notes = SCRUBBED_NOTES;
     else throw err;
   }
-  return { entries, posture, showcase, join: join14, notes, skipped };
+  return { entries, posture, showcase, join: join15, notes, skipped };
 }
 function recommendedPosture(evidence) {
   return { ...severityFloorPosture(), ...evidence };
@@ -24960,6 +27698,11 @@ function runPreview(deps, planIO) {
     deps.stdout(show("I didn't review anything \u2014 historical access wasn't granted."));
     return 0;
   }
+  if (!deps.modelJudgeConsent()) {
+    deps.stdout(show("I didn't send anything to the model \u2014 model-judge consent wasn't granted."));
+    deps.stdout(frameJsonBlock(zeroCountFrame(severityFloorPosture())));
+    return 0;
+  }
   const rawValues = hits.map((h) => h.rawMatch);
   try {
     const reps = dedupeForJudge(hits);
@@ -25147,9 +27890,9 @@ async function runConfirm(deps, planIO) {
 
 // src/triage/judge.ts
 import { execFileSync } from "child_process";
-import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync8, rmSync as rmSync3 } from "fs";
+import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync8, rmSync as rmSync4 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname4, join as join12 } from "path";
+import { dirname as dirname4, join as join13 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/triage/parse-verdict.ts
@@ -25163,7 +27906,7 @@ function parseRecommendation(text) {
 
 // src/triage/judge.ts
 var TRIAGE_DIR = dirname4(fileURLToPath2(import.meta.url));
-var DEFAULT_RUBRIC_PATH = join12(TRIAGE_DIR, "..", "..", "eval", "prompt.md");
+var DEFAULT_RUBRIC_PATH = join13(TRIAGE_DIR, "..", "..", "eval", "prompt.md");
 function parseVerdict(stdout) {
   let envelope;
   try {
@@ -25190,7 +27933,7 @@ function judgeEnv() {
     CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1"
   };
   if (process.platform === "darwin") {
-    env.CLAUDE_CONFIG_DIR = mkdtempSync2(join12(tmpdir2(), "aka-judge-cfg-"));
+    env.CLAUDE_CONFIG_DIR = mkdtempSync2(join13(tmpdir2(), "aka-judge-cfg-"));
   }
   return env;
 }
@@ -25211,9 +27954,16 @@ function spawnFailureMeta(err) {
   if (typeof e.code === "string" && e.code) parts.push(e.code);
   return parts.length > 0 ? parts.join(", ") : "unknown error";
 }
+function toJudgePayload(hit) {
+  const payload = { ...hit, context: maskText(hit.context) };
+  delete payload.filePath;
+  delete payload.valueFingerprint;
+  delete payload.keyVersion;
+  return payload;
+}
 function runJudge(hits, deps) {
   const rubric = deps.loadRubric?.() ?? readFileSync8(DEFAULT_RUBRIC_PATH, "utf8");
-  const hitsJsonl = hits.map((h) => JSON.stringify(h)).join("\n");
+  const hitsJsonl = hits.map((h) => JSON.stringify(toJudgePayload(h))).join("\n");
   const fullPrompt = `${rubric}
 
 ## Hits
@@ -25234,7 +27984,7 @@ ${hitsJsonl}
     return parseVerdict(stdout);
   } finally {
     if (process.platform === "darwin" && env.CLAUDE_CONFIG_DIR) {
-      rmSync3(env.CLAUDE_CONFIG_DIR, { recursive: true, force: true });
+      rmSync4(env.CLAUDE_CONFIG_DIR, { recursive: true, force: true });
     }
   }
 }
@@ -25254,9 +28004,9 @@ function resolveCreatedBy() {
 }
 function loadRubric() {
   const here = dirname5(fileURLToPath3(import.meta.url));
-  const shipped = join13(here, "triage-rubric.md");
-  if (existsSync5(shipped)) return readFileSync9(shipped, "utf8");
-  return readFileSync9(join13(here, "..", "eval", "prompt.md"), "utf8");
+  const shipped = join14(here, "triage-rubric.md");
+  if (existsSync7(shipped)) return readFileSync9(shipped, "utf8");
+  return readFileSync9(join14(here, "..", "eval", "prompt.md"), "utf8");
 }
 async function main() {
   const argv = process.argv.slice(2);
@@ -25266,6 +28016,10 @@ async function main() {
     // Called only on the preview path — the confirm path never reads a stream.
     readStream: (streamPath) => streamPath !== void 0 ? readFileSync9(streamPath, "utf8") : readFileSync9(0, "utf8"),
     runJudge: (hits) => runJudge(hits, { spawn: spawnClaude, loadRubric }),
+    // The distinct model-judge egress consent, read from settings.json. When it
+    // is absent or stale the preview skips the judge instead of sending findings
+    // to the model API.
+    modelJudgeConsent: () => isModelJudgeConsentValid(loadConfig().settings.modelJudgeConsent),
     openDb: () => {
       const db = openLocalDatabase(loadConfig().dataDir);
       return {