@akasecurity/ai-tc-codex 0.9.10 → 0.9.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -492,8 +492,8 @@ var require_ignore = __commonJS({
492
492
  });
493
493
 
494
494
  // ../../packages/plugin-sdk/src/config.ts
495
- import { existsSync as existsSync7 } from "fs";
496
- import { join as join13 } from "path";
495
+ import { existsSync as existsSync8 } from "fs";
496
+ import { join as join14 } from "path";
497
497
 
498
498
  // ../../packages/persistence/src/attached-derived.ts
499
499
  import { rmSync } from "fs";
@@ -20743,13 +20743,11 @@ var FindingGroup = external_exports.object({
20743
20743
  latestDetectedAt: external_exports.iso.datetime(),
20744
20744
  instances: external_exports.array(FindingInstance),
20745
20745
  // Derived from instances' statuses with open-dominates precedence (see
20746
- // buildFindingGroups). Undefined only when no instance carries a status.
20746
+ // foldGroupStatus). Undefined only when no instance carries a status.
20747
20747
  status: FindingStatus.optional(),
20748
- // The distinct people across the WHOLE group, not just the `instances`
20749
- // preview — from the store's whole-group aggregate when it supplies one,
20750
- // else folded from the rows (see buildFindingGroups). Undefined when no
20751
- // instance carries a user, or when the store supplied whole-group folds
20752
- // without one.
20748
+ // The distinct people across the WHOLE group, not just the instances
20749
+ // carried here. Undefined when no instance carries a user, or when the
20750
+ // store supplied whole-group folds without one.
20753
20751
  users: external_exports.array(FindingUser).optional()
20754
20752
  }).meta({ id: "FindingGroup" });
20755
20753
  var FindingStats = external_exports.object({
@@ -20778,21 +20776,31 @@ var FindingFacets = external_exports.object({
20778
20776
  // counted under no value.
20779
20777
  status: external_exports.array(FindingFacetItem),
20780
20778
  // Host tool (attributes.tool_name). Present only on the instance-level
20781
- // reads, which can filter by it; the grouped read omits the dimension
20779
+ // reads, which can filter by it; the type-level read omits the dimension
20782
20780
  // because a group spans tools.
20783
20781
  tool: external_exports.array(FindingFacetItem).optional()
20784
20782
  }).meta({ id: "FindingFacets" });
20785
- var DEFAULT_GROUPED_FINDINGS_LIMIT = 50;
20786
- var ListGroupedFindingsQuery = external_exports.object({
20783
+ var FindingTypeSummary = FindingGroup.omit({ instances: true, match: true }).meta({
20784
+ id: "FindingTypeSummary"
20785
+ });
20786
+ var DEFAULT_FINDING_TYPES_LIMIT = 50;
20787
+ var MAX_FINDING_TYPES_LIMIT = 100;
20788
+ var ListFindingTypesQuery = external_exports.object({
20787
20789
  // NOTE: severity filters by Severity (critical/high/medium/low), not by
20788
- // FindingAction.
20790
+ // FindingAction. It narrows TYPES: a type's severity is the one its newest
20791
+ // firing version carries, and this list pages types.
20792
+ //
20793
+ // That is NOT a claim the findings of a type share it. A rule can hold several
20794
+ // definition versions at different severities, so a type kept by this filter
20795
+ // can hold findings that individually do not match — see totals.findings on
20796
+ // ListFindingTypesResponse, which counts them all.
20789
20797
  severity: external_exports.array(Severity).optional(),
20790
20798
  subtype: external_exports.array(external_exports.string()).optional(),
20791
20799
  provider: external_exports.array(FindingProvider).optional(),
20792
20800
  action: external_exports.array(FindingAction).optional(),
20793
- // Matches a group's DERIVED status (see FindingGroup.status), not its
20794
- // individual instances' — so a filtered group's Status column always reads
20795
- // one of the requested values.
20801
+ // Matches a type's DERIVED status (see FindingGroup.status), not its
20802
+ // individual findings' — so a filtered row's status always reads one of the
20803
+ // requested values.
20796
20804
  status: external_exports.array(FindingStatus).optional(),
20797
20805
  q: external_exports.string().optional(),
20798
20806
  // Scope to findings whose event carries this session id (the Activity page's
@@ -20802,23 +20810,37 @@ var ListGroupedFindingsQuery = external_exports.object({
20802
20810
  // from a time-scoped page (Activity's range) can carry that scope. Absent
20803
20811
  // means all time — this list has no default window.
20804
20812
  from: external_exports.iso.datetime().optional(),
20805
- // A group or instance id that must appear in the page even when the cursor
20806
- // has already advanced past its sort position. This is what keeps the
20807
- // Findings page's one-shot ?finding= deep link resolving once the list
20808
- // paginates: the target group is appended out of sort order rather than
20809
- // scanning forward for it. Never affects totals, facets or the cursor.
20813
+ // A RULE id that must appear in the page even when the cursor has already
20814
+ // advanced past its sort position. This is what keeps the selected type
20815
+ // visible in the list once it paginates: the target is appended out of sort
20816
+ // order rather than scanned forward for. Never affects totals, facets or the
20817
+ // cursor. Unlike the grouped read this replaces, it names a rule only — an
20818
+ // instance id is resolved by `findingInstance`, which is a primary-key seek
20819
+ // and so is not bounded by what any page happens to hold.
20810
20820
  includeId: external_exports.string().optional(),
20811
- groupBy: external_exports.literal("type").optional(),
20812
- limit: external_exports.coerce.number().int().min(1).max(100).optional(),
20821
+ limit: external_exports.coerce.number().int().min(1).max(MAX_FINDING_TYPES_LIMIT).optional(),
20813
20822
  cursor: external_exports.string().optional()
20814
20823
  });
20815
- var ListGroupedFindingsResponse = external_exports.object({
20824
+ var ListFindingTypesResponse = external_exports.object({
20816
20825
  totals: external_exports.object({
20826
+ // Findings belonging to the matching TYPES — not findings that each match
20827
+ // the filters. The filters here select types, so a type that survives
20828
+ // contributes its whole instanceCount.
20829
+ //
20830
+ // `status` is the one exception, narrowed per finding via
20831
+ // countInstancesByStatus. `severity`, `provider` and `action` are not, so
20832
+ // this can exceed what the instance read reports for the same filters: a
20833
+ // rule whose severity moved between versions is kept on its newest and
20834
+ // still counts its older findings. Narrowing the other three needs
20835
+ // per-dimension counts the aggregate does not carry today.
20817
20836
  findings: external_exports.number().int().nonnegative(),
20818
- groups: external_exports.number().int().nonnegative()
20837
+ // Counts TYPES, which is the unit this read pages. The instance read's
20838
+ // own totals count findings; the two deliberately answer different
20839
+ // questions and are never summed.
20840
+ types: external_exports.number().int().nonnegative()
20819
20841
  }),
20820
20842
  facets: FindingFacets,
20821
- items: external_exports.array(FindingGroup),
20843
+ items: external_exports.array(FindingTypeSummary),
20822
20844
  nextCursor: external_exports.string().nullable(),
20823
20845
  // Present only on session-scoped queries (`sessionId` set): per ruleId, how
20824
20846
  // many times that rule fired in the session's persisted transcript. Findings
@@ -20826,7 +20848,7 @@ var ListGroupedFindingsResponse = external_exports.object({
20826
20848
  // every firing, so the two numbers legitimately differ — this map lets a
20827
20849
  // session-scoped view show both.
20828
20850
  sessionFirings: external_exports.record(external_exports.string(), external_exports.number().int().nonnegative()).optional()
20829
- }).meta({ id: "ListGroupedFindingsResponse" });
20851
+ }).meta({ id: "ListFindingTypesResponse" });
20830
20852
  var ApplyFindingActionRequest = external_exports.object({
20831
20853
  // 'quarantined' is system-assigned (see FindingAction) — clients may not set
20832
20854
  // it, so it is excluded from the request contract. The mapping helper
@@ -20856,12 +20878,13 @@ var DEFAULT_FLAT_FINDINGS_LIMIT = 50;
20856
20878
  var MAX_FLAT_FINDINGS_LIMIT = 200;
20857
20879
  var ListFindingInstancesQuery = external_exports.object({
20858
20880
  severity: external_exports.array(Severity).optional(),
20859
- // Rule ids, the same vocabulary the grouped list's `subtype` carries.
20881
+ // Rule ids, the same vocabulary the types list's `subtype` carries. Pinning
20882
+ // ONE of them is how the master/detail view scopes its right-hand panel.
20860
20883
  subtype: external_exports.array(external_exports.string()).optional(),
20861
20884
  provider: external_exports.array(FindingProvider).optional(),
20862
20885
  action: external_exports.array(FindingAction).optional(),
20863
20886
  // Matches each instance's OWN derived status (deriveFindingStatus), unlike
20864
- // the grouped query's group-level fold.
20887
+ // the types query's type-level fold.
20865
20888
  status: external_exports.array(FindingStatus).optional(),
20866
20889
  // Exact host-tool names (attributes.tool_name, e.g. 'Bash'). A real filter,
20867
20890
  // where the free-text `q` can only match the rendered "via Bash" label.
@@ -20878,37 +20901,47 @@ var ListFindingInstancesQuery = external_exports.object({
20878
20901
  });
20879
20902
  var ListFindingInstancesResponse = external_exports.object({
20880
20903
  // Instances matching the filters across the whole scope, not just this
20881
- // page — cursor-independent, like the grouped list's totals.
20904
+ // page — cursor-independent, like the types list's totals.
20882
20905
  totals: external_exports.object({ findings: external_exports.number().int().nonnegative() }),
20883
- // Counts in INSTANCES here, where the grouped response counts groups. Each
20906
+ // Counts in INSTANCES here, where the types response counts types. Each
20884
20907
  // dimension still excludes its own filter.
20885
20908
  facets: FindingFacets,
20886
20909
  items: external_exports.array(FindingInstanceDetail),
20887
20910
  nextCursor: external_exports.string().nullable()
20888
20911
  }).meta({ id: "ListFindingInstancesResponse" });
20889
- var FindingLocationFile = external_exports.object({
20890
- // Empty when the instances carried no file path (a prompt or a tool call
20891
- // with no file attribution).
20892
- file: external_exports.string(),
20893
- instanceCount: external_exports.number().int().nonnegative(),
20894
- maxSeverity: Severity,
20895
- latestDetectedAt: external_exports.iso.datetime(),
20896
- // Folded from the instances' derived statuses with the same
20897
- // open-dominates precedence a group uses.
20898
- status: FindingStatus.optional(),
20899
- // Distinct rules seen at this location, capped — the row shows them as
20900
- // chips, and the count is what conveys scale.
20901
- ruleIds: external_exports.array(external_exports.string())
20902
- }).meta({ id: "FindingLocationFile" });
20903
- var FindingLocationRepo = external_exports.object({
20912
+ var FindingLocationSummary = external_exports.object({
20913
+ // Opaque, stable, minted from the pair by encodeLocationId. It exists
20914
+ // because a location's identity is two values and a URL param carries one:
20915
+ // `?loc=` names a location the way `?rule=` names a type. Only ever compared
20916
+ // for EQUALITY — the page's selection check, this read's `includeId`, the
20917
+ // client's page dedupe — never decoded, and never a sort key.
20918
+ id: external_exports.string(),
20904
20919
  /** Empty when the instances carried no repo attribute. */
20905
20920
  repo: external_exports.string(),
20921
+ // Empty when the instances carried no file path (a prompt, or a tool call
20922
+ // with no file attribution). Both halves empty is a real location — usually
20923
+ // the largest one in a store — and is selectable like any other.
20924
+ file: external_exports.string(),
20906
20925
  instanceCount: external_exports.number().int().nonnegative(),
20926
+ // The WORST severity present, not the first row's. It is this list's primary
20927
+ // sort key, so it is also what explains why a row is where it is, and it is
20928
+ // how a reader decides what to open without opening everything.
20907
20929
  maxSeverity: Severity,
20908
20930
  latestDetectedAt: external_exports.iso.datetime(),
20931
+ // Folded from the instances' derived statuses with the same open-dominates
20932
+ // precedence a group uses, so it answers "is anything left to do here" and
20933
+ // not much more: a location holding 1 open among 40 resolved reads like one
20934
+ // holding 40 open. That loss is accepted — the panel beside this list
20935
+ // carries each finding's own status, and instanceCount sits next to the
20936
+ // badge.
20909
20937
  status: FindingStatus.optional(),
20910
- files: external_exports.array(FindingLocationFile)
20911
- }).meta({ id: "FindingLocationRepo" });
20938
+ // Every distinct rule seen at this location, UNCAPPED — so the length is a
20939
+ // tally rather than a sample and a row can say how many there are. Bounded
20940
+ // by the ruleset, not by the store. The view bounds what it DISPLAYS.
20941
+ ruleIds: external_exports.array(external_exports.string())
20942
+ }).meta({ id: "FindingLocationSummary" });
20943
+ var DEFAULT_FINDING_LOCATIONS_LIMIT = 50;
20944
+ var MAX_FINDING_LOCATIONS_LIMIT = 100;
20912
20945
  var ListFindingLocationsQuery = external_exports.object({
20913
20946
  severity: external_exports.array(Severity).optional(),
20914
20947
  subtype: external_exports.array(external_exports.string()).optional(),
@@ -20921,18 +20954,42 @@ var ListFindingLocationsQuery = external_exports.object({
20921
20954
  q: external_exports.string().optional(),
20922
20955
  sessionId: external_exports.string().optional(),
20923
20956
  from: external_exports.iso.datetime().optional(),
20924
- limit: external_exports.coerce.number().int().min(1).max(500).optional()
20957
+ // A LOCATION id (see FindingLocationSummary.id) that must appear in the page
20958
+ // even when the cursor has already advanced past its sort position — the
20959
+ // counterpart of ListFindingTypesQuery.includeId, and needed far more often
20960
+ // here. Selecting a row pushes the URL, which re-renders the server and resets
20961
+ // the client's page cache to page 0; with distinct (repo, file) pairs running
20962
+ // into the thousands, a selection sitting off page 0 is the ordinary case
20963
+ // rather than a deep-link corner. Never affects totals, facets or the cursor.
20964
+ includeId: external_exports.string().optional(),
20965
+ limit: external_exports.coerce.number().int().min(1).max(MAX_FINDING_LOCATIONS_LIMIT).optional(),
20966
+ cursor: external_exports.string().optional()
20925
20967
  });
20926
20968
  var ListFindingLocationsResponse = external_exports.object({
20927
20969
  totals: external_exports.object({
20970
+ // Findings matching the filters across the whole scope. Unlike the types
20971
+ // read's same-named field this needs no caveat: the filters here narrow
20972
+ // per finding, so this is the sum of every row's instanceCount.
20928
20973
  findings: external_exports.number().int().nonnegative(),
20929
- repos: external_exports.number().int().nonnegative(),
20930
- files: external_exports.number().int().nonnegative()
20974
+ // Counts LOCATIONS, the unit this read pages — the number the paginator
20975
+ // states. The facets beside it count FINDINGS (see below); a surface
20976
+ // showing both says which is which.
20977
+ locations: external_exports.number().int().nonnegative()
20931
20978
  }),
20932
- /** Sorted by max severity, then most recent. */
20933
- items: external_exports.array(FindingLocationRepo),
20934
- /** Whether `limit` truncated the repo list. */
20935
- hasMore: external_exports.boolean()
20979
+ // Counts in FINDINGS, where the types response counts types, each dimension
20980
+ // still excluding its own filter. Deliberately not locations: counting those
20981
+ // needs a set of location keys per dimension per value — memory tracking the
20982
+ // store times the vocabulary, in a read whose scan promises flat memory —
20983
+ // and the cheap per-location version is not an approximation but WRONG. A
20984
+ // location holding {claudecode, block} and {codex, warn} would survive
20985
+ // provider=claudecode AND action=warn, under which no single finding
20986
+ // matches, so the facet would contradict the instanceCount this whole view
20987
+ // rests on. Findings also keep the toolbar in the same unit as the page
20988
+ // tally and the panel it sits above.
20989
+ facets: FindingFacets,
20990
+ /** Sorted by max severity, then most recent, then (repo, file). */
20991
+ items: external_exports.array(FindingLocationSummary),
20992
+ nextCursor: external_exports.string().nullable()
20936
20993
  }).meta({ id: "ListFindingLocationsResponse" });
20937
20994
 
20938
20995
  // ../../packages/schema/src/zod/meta.ts
@@ -22101,6 +22158,14 @@ var ControlPlaneErrorBody = external_exports.object({
22101
22158
  message: external_exports.string().optional()
22102
22159
  }).optional()
22103
22160
  });
22161
+ var RemoteFailureKind = external_exports.enum([
22162
+ "unauthorized",
22163
+ "forbidden",
22164
+ "route-absent",
22165
+ "invalid-request",
22166
+ "rejected",
22167
+ "unreachable"
22168
+ ]);
22104
22169
  var AttachDeviceRequest = external_exports.object({
22105
22170
  // This machine's own continuity id, so re-attaching ROTATES the credential
22106
22171
  // on one machine record instead of producing a second one. Client-minted
@@ -22794,139 +22859,62 @@ function deriveFindingStatus(row) {
22794
22859
  if (row.latestResolutionStatus === "dismissed") return "dismissed";
22795
22860
  return "open";
22796
22861
  }
22797
- function distinctUsers(instances) {
22798
- const seen = /* @__PURE__ */ new Set();
22799
- const users = [];
22800
- for (const i of instances) {
22801
- if (i.user === void 0 || seen.has(i.user.id)) continue;
22802
- seen.add(i.user.id);
22803
- users.push(i.user);
22804
- }
22805
- return users;
22806
- }
22807
22862
  function sortUsers(users) {
22808
22863
  return [...users].sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
22809
22864
  }
22810
- function buildFindingGroups(rows, opts = {}) {
22811
- const overrides = opts.overrides;
22865
+ function buildFindingTypes(aggregates, opts = {}) {
22812
22866
  const packNames = opts.packNames;
22813
- const aggregates = opts.aggregates;
22814
- const byRuleId = /* @__PURE__ */ new Map();
22815
- for (const row of rows) {
22816
- const existing = byRuleId.get(row.ruleId);
22817
- if (existing) existing.push(row);
22818
- else byRuleId.set(row.ruleId, [row]);
22819
- }
22820
- const groups = [];
22821
- for (const [ruleId, ruleRows] of byRuleId) {
22822
- const instances = ruleRows.map((r) => {
22823
- const effectiveDbAction = overrides?.get(r.id) ?? r.actionTaken;
22824
- return {
22825
- id: r.id,
22826
- provider: toApiProvider(r.sourceTool),
22827
- repo: r.repo,
22828
- file: r.file,
22829
- ...r.toolName === void 0 ? {} : { toolName: r.toolName },
22830
- ...r.eventId === void 0 ? {} : { eventId: r.eventId },
22831
- ...r.sessionId === void 0 ? {} : { sessionId: r.sessionId },
22832
- ...r.user === void 0 ? {} : { user: r.user },
22833
- action: toApiAction(effectiveDbAction),
22834
- detectedAt: r.occurredAt,
22835
- confidence: r.confidence,
22836
- status: r.status
22837
- };
22838
- });
22839
- const agg = aggregates?.get(ruleId);
22840
- const users = agg ? sortUsers(agg.users ?? []) : distinctUsers(instances);
22841
- const latestDetectedAt = agg?.latestDetectedAt ?? ruleRows.reduce(
22842
- (max, r) => r.occurredAt > max ? r.occurredAt : max,
22843
- ruleRows[0]?.occurredAt ?? (/* @__PURE__ */ new Date(0)).toISOString()
22844
- );
22845
- const seenProviders = /* @__PURE__ */ new Set();
22846
- const providers = (agg ? [...new Set(agg.sourceTools.map(toApiProvider))].sort() : instances.map((i) => i.provider)).filter((p) => {
22847
- if (seenProviders.has(p)) return false;
22848
- seenProviders.add(p);
22849
- return true;
22850
- });
22851
- const actionSet = new Set(
22852
- agg ? agg.actionsTaken.map(toApiAction) : instances.map((i) => i.action)
22853
- );
22867
+ const types = [];
22868
+ for (const [ruleId, agg] of aggregates) {
22869
+ const users = sortUsers(agg.users ?? []);
22870
+ const providers = [...new Set(agg.sourceTools.map(toApiProvider))].sort();
22871
+ const actionSet = new Set(agg.actionsTaken.map(toApiAction));
22854
22872
  const aggregateAction = actionSet.size === 1 ? [...actionSet][0] ?? null : null;
22855
- const severity = ruleRows[0]?.severity ?? "low";
22856
- const detection = {
22857
- id: ruleId,
22858
- name: packNames?.get(ruleId) ?? null
22859
- };
22860
- const apiCategory = toApiCategory(ruleRows[0]?.category ?? "custom");
22861
- const policy = { id: `category:${apiCategory}`, name: apiCategory };
22862
- const match = {
22863
- maskedValue: ruleRows[0]?.maskedMatch ?? "",
22864
- contextPrefix: ""
22865
- // empty (pending privacy review)
22866
- };
22867
- const status = foldGroupStatus(
22868
- agg ? agg.statusInputs.map(deriveFindingStatus) : instances.map((i) => i.status)
22869
- );
22870
- const group = {
22873
+ const apiCategory = toApiCategory(agg.category ?? "custom");
22874
+ const type = {
22871
22875
  id: ruleId,
22872
22876
  category: apiCategory,
22873
22877
  subtype: ruleId,
22874
22878
  // human label comes with pack metadata later
22875
- severity,
22876
- match,
22877
- detection,
22878
- policy,
22879
- instanceCount: agg?.instanceCount ?? instances.length,
22879
+ severity: agg.severity ?? "low",
22880
+ detection: { id: ruleId, name: packNames?.get(ruleId) ?? null },
22881
+ policy: { id: `category:${apiCategory}`, name: apiCategory },
22882
+ instanceCount: agg.instanceCount,
22880
22883
  providers,
22881
22884
  aggregateAction,
22882
- latestDetectedAt,
22883
- instances,
22884
- status,
22885
+ latestDetectedAt: agg.latestDetectedAt,
22886
+ status: foldGroupStatus(agg.statusInputs.map(deriveFindingStatus)),
22885
22887
  ...users.length > 0 ? { users } : {}
22886
22888
  };
22887
- if (agg) {
22888
- actionsCache.set(group, [...actionSet]);
22889
- if (agg.searchText !== void 0) {
22890
- haystackCache.set(group, buildHaystack(group, agg.searchText));
22891
- }
22889
+ actionsCache.set(type, [...actionSet]);
22890
+ if (agg.searchText !== void 0) {
22891
+ haystackCache.set(type, buildHaystack(type, agg.searchText));
22892
22892
  }
22893
- groups.push(group);
22893
+ types.push(type);
22894
22894
  }
22895
- return groups;
22895
+ return types;
22896
22896
  }
22897
22897
  var haystackCache = /* @__PURE__ */ new WeakMap();
22898
- function buildHaystack(g, extra) {
22898
+ function buildHaystack(t, extra) {
22899
22899
  return [
22900
- g.subtype,
22901
- g.category,
22902
- g.match.maskedValue,
22903
- g.policy.name,
22904
- g.id,
22905
- ...g.instances.map((i) => i.repo),
22906
- ...g.instances.map((i) => i.file),
22907
- ...g.instances.map((i) => i.toolName ? `via ${i.toolName}` : ""),
22908
- ...g.instances.map((i) => i.id),
22909
- // The people: the whole group's list when the store folded one, plus the
22910
- // preview's own — the two overlap, and a haystack does not mind.
22911
- ...(g.users ?? []).map((u) => u.name),
22912
- ...g.instances.map((i) => i.user?.name ?? ""),
22900
+ t.subtype,
22901
+ t.category,
22902
+ t.policy.name,
22903
+ t.id,
22904
+ ...(t.users ?? []).map((u) => u.name),
22913
22905
  ...extra === void 0 ? [] : [extra]
22914
22906
  ].join(" ").toLowerCase();
22915
22907
  }
22916
- function groupHaystack(g) {
22917
- const cached2 = haystackCache.get(g);
22908
+ function typeHaystack(t) {
22909
+ const cached2 = haystackCache.get(t);
22918
22910
  if (cached2 !== void 0) return cached2;
22919
- const haystack = buildHaystack(g);
22920
- haystackCache.set(g, haystack);
22911
+ const haystack = buildHaystack(t);
22912
+ haystackCache.set(t, haystack);
22921
22913
  return haystack;
22922
22914
  }
22923
22915
  var actionsCache = /* @__PURE__ */ new WeakMap();
22924
- function groupActions(g) {
22925
- const cached2 = actionsCache.get(g);
22926
- if (cached2 !== void 0) return cached2;
22927
- const actions = [...new Set(g.instances.map((i) => i.action))];
22928
- actionsCache.set(g, actions);
22929
- return actions;
22916
+ function typeActions(t) {
22917
+ return actionsCache.get(t) ?? [];
22930
22918
  }
22931
22919
  function countInstancesByStatus(statusInputs, statuses) {
22932
22920
  const statusSet = new Set(statuses);
@@ -22937,8 +22925,8 @@ function countInstancesByStatus(statusInputs, statuses) {
22937
22925
  }
22938
22926
  return sum;
22939
22927
  }
22940
- function applyFindingFilters(groups, opts) {
22941
- let filtered = groups;
22928
+ function applyFindingFilters(types, opts) {
22929
+ let filtered = types;
22942
22930
  if (opts.severity && opts.severity.length > 0) {
22943
22931
  const sevSet = new Set(opts.severity);
22944
22932
  filtered = filtered.filter((g) => sevSet.has(g.severity));
@@ -22949,7 +22937,7 @@ function applyFindingFilters(groups, opts) {
22949
22937
  }
22950
22938
  if (opts.actions && opts.actions.length > 0) {
22951
22939
  const actionSet = new Set(opts.actions);
22952
- filtered = filtered.filter((g) => groupActions(g).some((a) => actionSet.has(a)));
22940
+ filtered = filtered.filter((t) => typeActions(t).some((a) => actionSet.has(a)));
22953
22941
  }
22954
22942
  if (opts.subtype && opts.subtype.length > 0) {
22955
22943
  const subtypeSet = new Set(opts.subtype);
@@ -22961,7 +22949,7 @@ function applyFindingFilters(groups, opts) {
22961
22949
  }
22962
22950
  if (opts.q) {
22963
22951
  const q = opts.q.toLowerCase();
22964
- filtered = filtered.filter((g) => groupHaystack(g).includes(q));
22952
+ filtered = filtered.filter((t) => typeHaystack(t).includes(q));
22965
22953
  }
22966
22954
  return filtered;
22967
22955
  }
@@ -22976,11 +22964,11 @@ function compareFindingGroupOrder(a, b) {
22976
22964
  if (recencyDiff !== 0) return recencyDiff;
22977
22965
  return a.id.localeCompare(b.id);
22978
22966
  }
22979
- function sortFindingGroups(groups) {
22980
- return [...groups].sort(compareFindingGroupOrder);
22967
+ function sortFindingTypes(types) {
22968
+ return [...types].sort(compareFindingGroupOrder);
22981
22969
  }
22982
- function computeFindingFacets(allGroups, opts) {
22983
- const forSeverity = applyFindingFilters(allGroups, {
22970
+ function computeFindingFacets(allTypes, opts) {
22971
+ const forSeverity = applyFindingFilters(allTypes, {
22984
22972
  providers: opts.providers,
22985
22973
  actions: opts.actions,
22986
22974
  statuses: opts.statuses,
@@ -22991,7 +22979,7 @@ function computeFindingFacets(allGroups, opts) {
22991
22979
  for (const g of forSeverity) {
22992
22980
  severityMap.set(g.severity, (severityMap.get(g.severity) ?? 0) + 1);
22993
22981
  }
22994
- const forProvider = applyFindingFilters(allGroups, {
22982
+ const forProvider = applyFindingFilters(allTypes, {
22995
22983
  actions: opts.actions,
22996
22984
  statuses: opts.statuses,
22997
22985
  q: opts.q,
@@ -23002,7 +22990,7 @@ function computeFindingFacets(allGroups, opts) {
23002
22990
  for (const g of forProvider) {
23003
22991
  for (const p of g.providers) providerMap.set(p, (providerMap.get(p) ?? 0) + 1);
23004
22992
  }
23005
- const forAction = applyFindingFilters(allGroups, {
22993
+ const forAction = applyFindingFilters(allTypes, {
23006
22994
  providers: opts.providers,
23007
22995
  statuses: opts.statuses,
23008
22996
  q: opts.q,
@@ -23011,9 +22999,9 @@ function computeFindingFacets(allGroups, opts) {
23011
22999
  });
23012
23000
  const actionMap = /* @__PURE__ */ new Map();
23013
23001
  for (const g of forAction) {
23014
- for (const a of groupActions(g)) actionMap.set(a, (actionMap.get(a) ?? 0) + 1);
23002
+ for (const a of typeActions(g)) actionMap.set(a, (actionMap.get(a) ?? 0) + 1);
23015
23003
  }
23016
- const forSubtype = applyFindingFilters(allGroups, {
23004
+ const forSubtype = applyFindingFilters(allTypes, {
23017
23005
  providers: opts.providers,
23018
23006
  actions: opts.actions,
23019
23007
  statuses: opts.statuses,
@@ -23022,7 +23010,7 @@ function computeFindingFacets(allGroups, opts) {
23022
23010
  });
23023
23011
  const subtypeMap = /* @__PURE__ */ new Map();
23024
23012
  for (const g of forSubtype) subtypeMap.set(g.subtype, (subtypeMap.get(g.subtype) ?? 0) + 1);
23025
- const forStatus = applyFindingFilters(allGroups, {
23013
+ const forStatus = applyFindingFilters(allTypes, {
23026
23014
  providers: opts.providers,
23027
23015
  actions: opts.actions,
23028
23016
  q: opts.q,
@@ -23070,10 +23058,20 @@ function matchesDimension(row, opts, dimension) {
23070
23058
  return !opts.statuses?.length || row.status !== void 0 && opts.statuses.includes(row.status);
23071
23059
  case "tools":
23072
23060
  return !opts.tools?.length || row.toolName !== void 0 && opts.tools.includes(row.toolName);
23061
+ // An EMPTY value is a real filter here, not an absent one. The location
23062
+ // list buckets a finding whose event recorded no repo — or no file — under
23063
+ // the empty string, and selecting that bucket has to narrow the panel to
23064
+ // exactly it. Only `undefined` means "no filter"; a caller that wants every
23065
+ // row omits the key, which every call site already does.
23066
+ //
23067
+ // Reading '' as unset is what this replaced, and it failed in the one place
23068
+ // it mattered: the no-repo/no-file bucket is often the largest in a real
23069
+ // store, and its panel dropped both predicates and returned the WHOLE scope
23070
+ // — a row reading 3 findings beside a panel listing every finding there is.
23073
23071
  case "repo":
23074
- return opts.repo === void 0 || opts.repo === "" || row.repo === opts.repo;
23072
+ return opts.repo === void 0 || row.repo === opts.repo;
23075
23073
  case "file":
23076
- return opts.file === void 0 || opts.file === "" || row.file === opts.file;
23074
+ return opts.file === void 0 || row.file === opts.file;
23077
23075
  case "q":
23078
23076
  return !opts.q || rowHaystack(row).includes(opts.q.toLowerCase());
23079
23077
  }
@@ -23187,6 +23185,23 @@ function addToLocation(acc, row) {
23187
23185
  acc.statuses.push(row.status);
23188
23186
  acc.ruleIds.add(row.ruleId);
23189
23187
  }
23188
+ function compareLocationOrder(a, b) {
23189
+ const rankA = SEVERITY_ORDER2[a.maxSeverity] ?? -1;
23190
+ const rankB = SEVERITY_ORDER2[b.maxSeverity] ?? -1;
23191
+ if (rankA !== rankB) return rankA - rankB;
23192
+ if (a.latestDetectedAt !== b.latestDetectedAt) {
23193
+ return a.latestDetectedAt < b.latestDetectedAt ? 1 : -1;
23194
+ }
23195
+ if (a.repo !== b.repo) return a.repo < b.repo ? -1 : 1;
23196
+ if (a.file !== b.file) return a.file < b.file ? -1 : 1;
23197
+ return 0;
23198
+ }
23199
+ function encodeLocationId(repo, file2) {
23200
+ return `${encodePart(repo)}/${encodePart(file2)}`;
23201
+ }
23202
+ function encodePart(value) {
23203
+ return encodeURIComponent(value.replace(/[\uD800-\uDFFF]/gu, "\uFFFD"));
23204
+ }
23190
23205
 
23191
23206
  // ../../packages/schema/src/zod/installed-pack.ts
23192
23207
  var InstalledPack = external_exports.object({
@@ -23693,11 +23708,11 @@ var WorkspaceSettings = external_exports.object({
23693
23708
  // covers the current payload and must be re-granted.
23694
23709
  modelJudgeConsent: ModelJudgeConsent.optional(),
23695
23710
  // Records that the user consented to the DEFERRED send — the outbox — along
23696
- // with the payload shape and the endpoint they agreed to. Since payload v2
23697
- // that covers both the pre-attach backlog and undelivered captures (which
23698
- // carry prompt/reply text in `content`); the key name predates the widening.
23699
- // Absent until granted, and a grant for a different endpoint or an older
23700
- // payload no longer counts.
23711
+ // with the payload shape and the endpoint they agreed to. Since payload v3
23712
+ // that covers the pre-attach backlog AND undelivered captures alike, and both
23713
+ // carry prompt/reply/tool-output text in `content`; the key name predates
23714
+ // both widenings. Absent until granted, and a grant for a different endpoint
23715
+ // or an older payload no longer counts.
23701
23716
  historySyncConsent: HistorySyncConsent.optional()
23702
23717
  });
23703
23718
  function defaultWorkspaceSettings() {
@@ -23828,6 +23843,9 @@ var ManagedSettingKey = external_exports.enum([
23828
23843
  "dataSharesInPlace",
23829
23844
  "redactFallback"
23830
23845
  ]).meta({ id: "ManagedSettingKey" });
23846
+ function isManagedSettingKey(value) {
23847
+ return ManagedSettingKey.safeParse(value).success;
23848
+ }
23831
23849
  var ManagedSettingsValues = external_exports.object({
23832
23850
  runMode: external_exports.enum(["standalone", "attached"]).optional(),
23833
23851
  controlPlane: external_exports.object({
@@ -23852,7 +23870,27 @@ var ManagedSettings = external_exports.object({
23852
23870
  // Which of those the user may not change. A key here with no matching value
23853
23871
  // freezes whatever the user last chose; a value with no lock is a DEFAULT
23854
23872
  // the user may still override. The two are separable on purpose.
23855
- lockedFields: external_exports.array(ManagedSettingKey).default([])
23873
+ //
23874
+ // Parsed as NAMES rather than as the enum, and split below: a name this
23875
+ // build does not know is dropped from the locked set and reported, never a
23876
+ // reason to refuse the file. The same shape reaches an older build whenever
23877
+ // an administrator locks a key a newer build added, and refusing it there
23878
+ // ran that build entirely unmanaged — every pin and lock gone — on exactly
23879
+ // the fleets most likely to carry a version skew. A name outside the enum
23880
+ // is still never HONOURED: the lockable set stays explicit above.
23881
+ lockedFields: external_exports.array(external_exports.string()).default([])
23882
+ }).transform(({ lockedFields, ...rest }) => {
23883
+ const known = [];
23884
+ const unknown2 = [];
23885
+ for (const name of lockedFields) {
23886
+ if (isManagedSettingKey(name)) known.push(name);
23887
+ else unknown2.push(name);
23888
+ }
23889
+ return {
23890
+ ...rest,
23891
+ lockedFields: known,
23892
+ ...unknown2.length > 0 ? { unknownLockedFields: unknown2 } : {}
23893
+ };
23856
23894
  }).meta({ id: "ManagedSettings" });
23857
23895
 
23858
23896
  // ../../packages/schema/src/zod/project-files.ts
@@ -23976,7 +24014,11 @@ var FindingsTimeseriesPoint = external_exports.object({
23976
24014
  timestamp: external_exports.iso.date(),
23977
24015
  critical: external_exports.number().int().nonnegative(),
23978
24016
  high: external_exports.number().int().nonnegative(),
23979
- medium: external_exports.number().int().nonnegative()
24017
+ medium: external_exports.number().int().nonnegative(),
24018
+ // Optional and additive, so a producer written against the earlier
24019
+ // three-series contract keeps validating. A consumer plotting it resolves the
24020
+ // absent case itself — the chart point requires a number.
24021
+ low: external_exports.number().int().nonnegative().optional()
23980
24022
  }).meta({ id: "FindingsTimeseriesPoint" });
23981
24023
  var FindingsTimeseriesResponse = external_exports.object({
23982
24024
  range: TimeRange,
@@ -24002,6 +24044,10 @@ var ResolvedFeedItem = external_exports.object({
24002
24044
  findingKey: external_exports.string(),
24003
24045
  ruleId: external_exports.string(),
24004
24046
  severity: Severity,
24047
+ // Repository slug, and the file path RELATIVE to it. The pair is what
24048
+ // identifies the file: a bare path matches the same name in every repo.
24049
+ // Optional and additive; empty when the event carried no repo.
24050
+ repo: external_exports.string().optional(),
24005
24051
  path: external_exports.string(),
24006
24052
  // ISO-8601 datetime (matches FindingInstance.detectedAt / the rest of the
24007
24053
  // findings domain). The reader `.toISOString()`s the DB epoch-ms values.
@@ -25575,7 +25621,8 @@ var SqliteActivityRepository = class {
25575
25621
  SELECT 1 FROM audit_events d
25576
25622
  WHERE d.root_session_id = audit_events.id
25577
25623
  AND (d.content LIKE ? ESCAPE '\\'
25578
- OR json_extract(d.attributes, '$.detail') LIKE ? ESCAPE '\\')))`
25624
+ OR coalesce(json_extract(d.attributes, '$.detail'),
25625
+ json_extract(d.attributes, '$.target')) LIKE ? ESCAPE '\\')))`
25579
25626
  );
25580
25627
  params.push(pattern, pattern, pattern, pattern, pattern, pattern);
25581
25628
  }
@@ -26913,23 +26960,6 @@ var LATEST_RESOLUTION_BY_KEY_SQL = `(
26913
26960
  )`;
26914
26961
 
26915
26962
  // ../../packages/persistence/src/repositories/findings.ts
26916
- var PREVIEW_INSTANCES_PER_GROUP = 200;
26917
- var DEFAULT_LOCATIONS_LIMIT = 100;
26918
- var LOCATION_RULE_IDS_CAP = 20;
26919
- function compareLocationOrder(a, b) {
26920
- return compareFindingGroupOrder(
26921
- {
26922
- severity: a.maxSeverity,
26923
- latestDetectedAt: a.latestDetectedAt,
26924
- id: ""
26925
- },
26926
- {
26927
- severity: b.maxSeverity,
26928
- latestDetectedAt: b.latestDetectedAt,
26929
- id: ""
26930
- }
26931
- );
26932
- }
26933
26963
  var CONCAT_SEP = ",";
26934
26964
  var TUPLE_SEP = "|";
26935
26965
  function splitConcat(value) {
@@ -26981,13 +27011,48 @@ function decodeGroupCursor(cursor) {
26981
27011
  return null;
26982
27012
  }
26983
27013
  function firstAfter(sorted, cursor) {
26984
- const index = sorted.findIndex((g) => compareFindingGroupOrder(g, cursor) > 0);
27014
+ const index = sorted.findIndex((t) => compareFindingGroupOrder(t, cursor) > 0);
26985
27015
  return index === -1 ? sorted.length : index;
26986
27016
  }
26987
27017
  function findDeepLinked(sorted, page, id) {
26988
- if (page.some((g) => g.id === id || g.instances.some((i) => i.id === id))) return void 0;
26989
- return sorted.find((g) => g.id === id || g.instances.some((i) => i.id === id));
27018
+ if (page.some((t) => t.id === id)) return void 0;
27019
+ return sorted.find((t) => t.id === id);
27020
+ }
27021
+ function encodeLocationCursor(location) {
27022
+ const payload = {
27023
+ sev: location.maxSeverity,
27024
+ t: location.latestDetectedAt,
27025
+ r: location.repo,
27026
+ f: location.file
27027
+ };
27028
+ return Buffer.from(JSON.stringify(payload)).toString("base64url");
26990
27029
  }
27030
+ function decodeLocationCursor(cursor) {
27031
+ const parsed2 = parseJsonObject(Buffer.from(cursor, "base64url").toString("utf8"));
27032
+ if (parsed2 !== void 0 && typeof parsed2.sev === "string" && typeof parsed2.t === "string" && typeof parsed2.r === "string" && typeof parsed2.f === "string") {
27033
+ return { maxSeverity: parsed2.sev, latestDetectedAt: parsed2.t, repo: parsed2.r, file: parsed2.f };
27034
+ }
27035
+ return null;
27036
+ }
27037
+ function firstLocationAfter(sorted, cursor) {
27038
+ const index = sorted.findIndex((l) => compareLocationOrder(l, cursor) > 0);
27039
+ return index === -1 ? sorted.length : index;
27040
+ }
27041
+ function findDeepLinkedLocation(sorted, page, id) {
27042
+ if (page.some((l) => l.id === id)) return void 0;
27043
+ return sorted.find((l) => l.id === id);
27044
+ }
27045
+ var FINDING_ROW_COLUMNS_SQL = `f.id AS id, d.rule_id AS rule_id, d.category AS category,
27046
+ d.severity AS severity, f.masked_match AS masked_match,
27047
+ f.action_taken AS action_taken, f.confidence AS confidence,
27048
+ e.started_at AS occurred_at,
27049
+ e.source_tool AS source_tool,
27050
+ e.repo AS repo,
27051
+ e.file_path AS file,
27052
+ e.tool_name AS tool_name,
27053
+ f.audit_event_id AS event_id, e.root_session_id AS session_id,
27054
+ e.event_type AS kind, f.finding_key AS finding_key,
27055
+ ${latestResolutionStatusSql("f")} AS latest_status`;
26991
27056
  var DAY_MS3 = 864e5;
26992
27057
  var SqliteFindingsRepository = class {
26993
27058
  constructor(db) {
@@ -27108,30 +27173,26 @@ var SqliteFindingsRepository = class {
27108
27173
  );
27109
27174
  }
27110
27175
  /**
27111
- * Grouped findings for the dashboard — joins inspection_findings⋈audit_events
27112
- * ⋈inspection_definitions (repo/file/toolName from the audit event's
27113
- * attributes bag, rule_id/category/severity from the definition), scoped to
27114
- * the four capture kinds (audit_events also holds structural/reconciler/scan
27115
- * rows this list must never surface), groups by ruleId, computes
27116
- * per-filter-excluded facets, applies the requested filters, and sorts by
27117
- * severity then recency. Filtering
27118
- * and faceting run in JS via the shared @akasecurity/schema helpers. `totals`
27119
- * reflect the full filtered set; `items` is the requested
27120
- * page (default 50); no cursor (nextCursor is always null). Under a `status`
27121
- * filter, `totals.findings` counts only instances whose derived status was
27122
- * requested, and each item's instance preview is narrowed the same way.
27176
+ * Finding TYPES for the dashboard — one row per rule, scoped to the four
27177
+ * capture kinds (audit_events also holds structural/reconciler/scan rows this
27178
+ * list must never surface), with per-filter-excluded facets, the requested
27179
+ * filters applied, and sorted by severity then recency. Filtering and faceting
27180
+ * run in JS via the shared @akasecurity/schema helpers. `totals` reflect the
27181
+ * full filtered set; `items` is the requested page (default 50), keyset-paged.
27182
+ * Under a `status` filter, `totals.findings` counts only findings whose
27183
+ * derived status was requested.
27184
+ *
27185
+ * ONE read, which materializes no findings: a single aggregate per rule_id,
27186
+ * folding EVERY finding into the numbers a type row and the filters need
27187
+ * (count, severity, category, providers, actions, statuses, latest, search
27188
+ * text). The findings OF a type come from listFindingInstances scoped to
27189
+ * `subtype`, so neither list bounds the other and no per-type cap exists.
27123
27190
  *
27124
- * Two reads, neither of which materializes a row per finding:
27125
- * 1. one aggregate row per rule_id, folding EVERY instance into the numbers
27126
- * the group and the filters need (count, providers, actions, statuses,
27127
- * latest, search text);
27128
- * 2. each group's newest PREVIEW_INSTANCES_PER_GROUP instances, which
27129
- * populate `instances` for the table's expanded rows.
27130
27191
  * The aggregates carry raw DB values and are translated by the same
27131
- * @akasecurity/schema mappers the row path uses, so no enum mapping or status
27132
- * rule is ever restated in SQL.
27192
+ * @akasecurity/schema mappers every other path uses, so no enum mapping or
27193
+ * status rule is ever restated in SQL.
27133
27194
  */
27134
- listGroupedFindings(query) {
27195
+ listFindingTypes(query) {
27135
27196
  const sessionPredicate = query.sessionId ? ` AND e.root_session_id = :sessionId` : "";
27136
27197
  const fromMs = query.from === void 0 ? void 0 : isoToEpochMillis(query.from);
27137
27198
  const fromPredicate = fromMs === void 0 ? "" : ` AND e.started_at >= :fromMs`;
@@ -27144,12 +27205,7 @@ var SqliteFindingsRepository = class {
27144
27205
  predicate,
27145
27206
  params: sessionParams
27146
27207
  });
27147
- const rows = this.previewRows(aggregates, {
27148
- sessionId: query.sessionId,
27149
- from: query.from
27150
- });
27151
- const groupable = rows.map(toFlatFindingRow);
27152
- const allGroups = buildFindingGroups(groupable, { aggregates });
27208
+ const allTypes = buildFindingTypes(aggregates);
27153
27209
  const filterOpts = {
27154
27210
  severity: query.severity,
27155
27211
  providers: query.provider,
@@ -27158,30 +27214,25 @@ var SqliteFindingsRepository = class {
27158
27214
  subtype: query.subtype,
27159
27215
  q: query.q
27160
27216
  };
27161
- const facets = computeFindingFacets(allGroups, filterOpts);
27162
- const sorted = sortFindingGroups(applyFindingFilters(allGroups, filterOpts));
27217
+ const facets = computeFindingFacets(allTypes, filterOpts);
27218
+ const sorted = sortFindingTypes(applyFindingFilters(allTypes, filterOpts));
27163
27219
  const statusFilter = query.status ?? [];
27164
27220
  const totals = {
27165
- findings: sorted.reduce((acc, g) => {
27166
- if (statusFilter.length === 0) return acc + g.instanceCount;
27167
- const agg = aggregates.get(g.id);
27168
- return acc + (agg ? countInstancesByStatus(agg.statusInputs, statusFilter) ?? g.instanceCount : g.instanceCount);
27221
+ findings: sorted.reduce((acc, t) => {
27222
+ if (statusFilter.length === 0) return acc + t.instanceCount;
27223
+ const agg = aggregates.get(t.id);
27224
+ return acc + (agg ? countInstancesByStatus(agg.statusInputs, statusFilter) ?? t.instanceCount : t.instanceCount);
27169
27225
  }, 0),
27170
- groups: sorted.length
27226
+ types: sorted.length
27171
27227
  };
27172
- const limit = query.limit ?? DEFAULT_GROUPED_FINDINGS_LIMIT;
27228
+ const limit = query.limit ?? DEFAULT_FINDING_TYPES_LIMIT;
27173
27229
  const cursor = query.cursor === void 0 ? null : decodeGroupCursor(query.cursor);
27174
27230
  const start = cursor === null ? 0 : firstAfter(sorted, cursor);
27175
27231
  const page = sorted.slice(start, start + limit);
27176
27232
  const lastOnPage = page.at(-1);
27177
27233
  const nextCursor = start + limit < sorted.length && lastOnPage ? encodeGroupCursor(lastOnPage) : null;
27178
27234
  const deepLinked = query.includeId === void 0 || query.includeId === "" ? void 0 : findDeepLinked(sorted, page, query.includeId);
27179
- const statusSet = statusFilter.length > 0 ? new Set(statusFilter) : null;
27180
- const narrow = (g) => statusSet ? {
27181
- ...g,
27182
- instances: g.instances.filter((i) => i.status !== void 0 && statusSet.has(i.status))
27183
- } : g;
27184
- const items = [...page, ...deepLinked ? [deepLinked] : []].map(narrow);
27235
+ const items = [...page, ...deepLinked ? [deepLinked] : []];
27185
27236
  return Promise.resolve({
27186
27237
  totals,
27187
27238
  facets,
@@ -27192,7 +27243,7 @@ var SqliteFindingsRepository = class {
27192
27243
  }
27193
27244
  /**
27194
27245
  * One row per rule_id, folding EVERY instance of the group into the values
27195
- * buildFindingGroups cannot recover from a preview. Bounded by the number of
27246
+ * buildFindingTypes cannot recover from an aggregate. Bounded by the number of
27196
27247
  * distinct rule_ids (the installed packs' rules), not by the store's size.
27197
27248
  *
27198
27249
  * A single scan, folded in two levels: the inner SELECT groups by
@@ -27286,13 +27337,25 @@ var SqliteFindingsRepository = class {
27286
27337
  });
27287
27338
  }
27288
27339
  /**
27289
- * The same findings folded by location: repository, then file within it.
27340
+ * The same findings folded by WHERE they live — one row per (repo, file) pair.
27290
27341
  *
27291
27342
  * The grouping keys come from the capturing event's attributes, which is what
27292
- * the local store relates a finding to — there is no finding↔asset row to
27293
- * group by instead. A repo or file the event did not record folds into the
27294
- * empty-string bucket, which the view renders but does not link, since no
27295
- * filter can name it.
27343
+ * the local store relates a finding to; there is no finding↔asset row to group
27344
+ * by instead. A repo or file the event did not record folds into the
27345
+ * empty-string bucket, which is a real location like any other: it is listed,
27346
+ * it is selectable, and its `?loc=` token is as good as any other row's.
27347
+ *
27348
+ * ONE flat list rather than repos nesting files. A rollup can only be paged by
27349
+ * repo, which leaves the file list inside it unbounded — the shape the by-type
27350
+ * list was rebuilt to remove — and two-level pagination inside an
27351
+ * expand/collapse table is what pushed that view to master/detail in the first
27352
+ * place.
27353
+ *
27354
+ * Every filter narrows the FINDINGS and the locations fall out of what
27355
+ * survives, so each row's `instanceCount` is exactly what listFindingInstances
27356
+ * reports for the same filters scoped to that pair. The view depends on it:
27357
+ * one toolbar sits over both panels precisely because a location owns none of
27358
+ * its fields.
27296
27359
  */
27297
27360
  listFindingLocations(query) {
27298
27361
  const opts = {
@@ -27304,13 +27367,16 @@ var SqliteFindingsRepository = class {
27304
27367
  tools: query.tool,
27305
27368
  q: query.q
27306
27369
  };
27307
- const limit = query.limit ?? DEFAULT_LOCATIONS_LIMIT;
27370
+ const limit = query.limit ?? DEFAULT_FINDING_LOCATIONS_LIMIT;
27371
+ const cursor = query.cursor === void 0 ? null : decodeLocationCursor(query.cursor);
27308
27372
  const byRepo = /* @__PURE__ */ new Map();
27373
+ const accumulator = createInstanceFacetAccumulator(opts);
27309
27374
  let total = 0;
27310
27375
  for (const row of this.scanFindingRows({
27311
27376
  sessionId: query.sessionId,
27312
27377
  from: query.from
27313
27378
  })) {
27379
+ accumulator.add(row);
27314
27380
  if (!matchesInstanceFilters(row, opts)) continue;
27315
27381
  total += 1;
27316
27382
  let files = byRepo.get(row.repo);
@@ -27325,103 +27391,35 @@ var SqliteFindingsRepository = class {
27325
27391
  }
27326
27392
  addToLocation(acc, row);
27327
27393
  }
27328
- let fileCount = 0;
27329
- const repos = [...byRepo.entries()].map(([repo, files]) => {
27330
- fileCount += files.size;
27331
- const fileRows = [...files.entries()].map(([file2, acc]) => ({
27332
- file: file2,
27333
- instanceCount: acc.instanceCount,
27334
- maxSeverity: acc.maxSeverity,
27335
- latestDetectedAt: acc.latestDetectedAt,
27336
- ...foldGroupStatus(acc.statuses) === void 0 ? {} : { status: foldGroupStatus(acc.statuses) },
27337
- ruleIds: [...acc.ruleIds].slice(0, LOCATION_RULE_IDS_CAP)
27338
- })).sort(compareLocationOrder);
27339
- const rollup = fileRows.reduce(
27340
- (a, f) => ({
27341
- instanceCount: a.instanceCount + f.instanceCount,
27342
- maxSeverity: compareLocationOrder(f, a) < 0 ? f.maxSeverity : a.maxSeverity,
27343
- latestDetectedAt: f.latestDetectedAt > a.latestDetectedAt ? f.latestDetectedAt : a.latestDetectedAt
27344
- }),
27345
- {
27346
- instanceCount: 0,
27347
- maxSeverity: fileRows[0]?.maxSeverity ?? "low",
27348
- latestDetectedAt: ""
27349
- }
27350
- );
27351
- const statuses = fileRows.map((f) => f.status);
27352
- const folded = foldGroupStatus(statuses);
27353
- return {
27354
- repo,
27355
- instanceCount: rollup.instanceCount,
27356
- maxSeverity: rollup.maxSeverity,
27357
- latestDetectedAt: rollup.latestDetectedAt,
27358
- ...folded === void 0 ? {} : { status: folded },
27359
- files: fileRows
27360
- };
27361
- });
27362
- repos.sort(compareLocationOrder);
27394
+ const sorted = [];
27395
+ for (const [repo, files] of byRepo) {
27396
+ for (const [file2, acc] of files) {
27397
+ const status = foldGroupStatus(acc.statuses);
27398
+ sorted.push({
27399
+ id: encodeLocationId(repo, file2),
27400
+ repo,
27401
+ file: file2,
27402
+ instanceCount: acc.instanceCount,
27403
+ maxSeverity: acc.maxSeverity,
27404
+ latestDetectedAt: acc.latestDetectedAt,
27405
+ ...status === void 0 ? {} : { status },
27406
+ ruleIds: [...acc.ruleIds]
27407
+ });
27408
+ }
27409
+ }
27410
+ sorted.sort(compareLocationOrder);
27411
+ const start = cursor === null ? 0 : firstLocationAfter(sorted, cursor);
27412
+ const page = sorted.slice(start, start + limit);
27413
+ const lastOnPage = page.at(-1);
27414
+ const nextCursor = start + limit < sorted.length && lastOnPage ? encodeLocationCursor(lastOnPage) : null;
27415
+ const deepLinked = query.includeId === void 0 || query.includeId === "" ? void 0 : findDeepLinkedLocation(sorted, page, query.includeId);
27363
27416
  return Promise.resolve({
27364
- totals: { findings: total, repos: repos.length, files: fileCount },
27365
- items: repos.slice(0, limit),
27366
- hasMore: repos.length > limit
27417
+ totals: { findings: total, locations: sorted.length },
27418
+ facets: accumulator.facets(),
27419
+ items: [...page, ...deepLinked ? [deepLinked] : []],
27420
+ nextCursor
27367
27421
  });
27368
27422
  }
27369
- /**
27370
- * Each group's newest instances, for the table's expanded rows.
27371
- *
27372
- * ONE index-ordered scan with early termination, and the shape is the point.
27373
- * The natural spelling — `ROW_NUMBER() OVER (PARTITION BY rule_id ORDER BY
27374
- * started_at DESC)` then `WHERE rn <= cap` — sorts EVERY finding in scope
27375
- * through a temp B-tree to keep a bounded preview of each group, and then
27376
- * sorts the survivors again for the page order. Both sorts grow with the
27377
- * store while the answer does not.
27378
- *
27379
- * Instead the scan walks `audit_events` newest-first off `idx_audit_started_at`
27380
- * (or the session or window index the scope names — see `findingScanSql`),
27381
- * which is already the order the page wants, and keeps rows per rule until
27382
- * each rule has as many as it can show. The aggregate the caller already holds
27383
- * says how many that is: `min(instanceCount, PREVIEW_INSTANCES_PER_GROUP)`
27384
- * per rule, summed, is the number of rows this scan has to find, and it stops
27385
- * on the last one. That sum is bounded by `rules * PREVIEW_INSTANCES_PER_GROUP`
27386
- * (8,000 at this repo's 40-rule bench corpus), not by a fixed row count — a
27387
- * store with many firing rules widens it. The bound that DOES hold
27388
- * unconditionally is the sorted form's floor: this scan visits at most as
27389
- * many rows as `ROW_NUMBER() OVER (PARTITION BY rule_id …)` would have
27390
- * sorted, and stops the moment every rule has its cap, where the sorted form
27391
- * sorts the whole scope regardless. The true worst case — the rarest rule's
27392
- * wanted instances sitting at the tail of the scope — is one pass over
27393
- * everything in scope with a block sort of the id tie-break only, never a
27394
- * sort of the scope, which is still that floor.
27395
- *
27396
- * A row whose rule the aggregate did not see is skipped: the two statements
27397
- * run without a shared snapshot, so a capture landing between them can add a
27398
- * rule here that has no counts there, and the counts are what the group is
27399
- * built from.
27400
- */
27401
- previewRows(aggregates, scope) {
27402
- const wanted = /* @__PURE__ */ new Map();
27403
- let remaining = 0;
27404
- for (const [ruleId, agg] of aggregates) {
27405
- const n = Math.min(agg.instanceCount, PREVIEW_INSTANCES_PER_GROUP);
27406
- wanted.set(ruleId, n);
27407
- remaining += n;
27408
- }
27409
- const rows = [];
27410
- if (remaining === 0) return rows;
27411
- const { sql, params } = this.findingScanSql(scope);
27412
- const taken = /* @__PURE__ */ new Map();
27413
- for (const r of iterateRows(this.db.prepare(sql), params)) {
27414
- const want = wanted.get(r.rule_id);
27415
- if (want === void 0) continue;
27416
- const have = taken.get(r.rule_id) ?? 0;
27417
- if (have >= want) continue;
27418
- taken.set(r.rule_id, have + 1);
27419
- rows.push(r);
27420
- remaining -= 1;
27421
- if (remaining === 0) break;
27422
- }
27423
- return rows;
27424
- }
27425
27423
  /**
27426
27424
  * Every finding in scope as a FlatFindingRow, newest first, streamed.
27427
27425
  *
@@ -27448,6 +27446,33 @@ var SqliteFindingsRepository = class {
27448
27446
  yield toFlatFindingRow(r);
27449
27447
  }
27450
27448
  }
27449
+ /**
27450
+ * One finding by its own id, or null when no such row exists.
27451
+ *
27452
+ * A primary-key seek on `inspection_findings`, so its cost does not grow with
27453
+ * the store — and, unlike anything derived from a list page, it resolves a
27454
+ * finding of ANY age. That is what the Findings page's one-shot `?finding=`
27455
+ * deep link needs: the id it carries may name a finding thousands of rows
27456
+ * older than anything a first page holds.
27457
+ *
27458
+ * Deliberately UNFILTERED — no capture-kind, session or time predicate. It
27459
+ * RESOLVES an id; whether that row would survive the list's current filters is
27460
+ * a different question, and hiding the target because a filter excludes it is
27461
+ * worse than showing it.
27462
+ *
27463
+ * `groupId` on the result IS the rule id, so this one read answers both "which
27464
+ * type should the list select?" and "what does the drawer show?".
27465
+ */
27466
+ findingInstance(id) {
27467
+ const row = this.db.prepare(
27468
+ `SELECT ${FINDING_ROW_COLUMNS_SQL}
27469
+ FROM inspection_findings f
27470
+ JOIN audit_events e ON e.id = f.audit_event_id
27471
+ JOIN inspection_definitions d ON d.id = f.inspection_definition_id
27472
+ WHERE f.id = ?`
27473
+ ).get(id);
27474
+ return Promise.resolve(row === void 0 ? null : toInstanceDetail(toFlatFindingRow(row)));
27475
+ }
27451
27476
  /**
27452
27477
  * The one statement both instance-level scans run: every finding in scope,
27453
27478
  * joined to its event and definition, newest first.
@@ -27481,17 +27506,7 @@ var SqliteFindingsRepository = class {
27481
27506
  conditions.push("e.started_at >= ?");
27482
27507
  params.push(isoToEpochMillis(scope.from));
27483
27508
  }
27484
- const sql = `SELECT f.id AS id, d.rule_id AS rule_id, d.category AS category,
27485
- d.severity AS severity, f.masked_match AS masked_match,
27486
- f.action_taken AS action_taken, f.confidence AS confidence,
27487
- e.started_at AS occurred_at,
27488
- e.source_tool AS source_tool,
27489
- e.repo AS repo,
27490
- e.file_path AS file,
27491
- e.tool_name AS tool_name,
27492
- f.audit_event_id AS event_id, e.root_session_id AS session_id,
27493
- e.event_type AS kind, f.finding_key AS finding_key,
27494
- ${latestResolutionStatusSql("f")} AS latest_status
27509
+ const sql = `SELECT ${FINDING_ROW_COLUMNS_SQL}
27495
27510
  FROM audit_events e
27496
27511
  CROSS JOIN inspection_findings f ON f.audit_event_id = e.id
27497
27512
  CROSS JOIN inspection_definitions d ON d.id = f.inspection_definition_id
@@ -27505,6 +27520,26 @@ var SqliteFindingsRepository = class {
27505
27520
  group_concat(DISTINCT 'via ' || e.tool_name) AS tool_names` : `, NULL AS repos, NULL AS files, NULL AS tool_names`;
27506
27521
  const rows = this.db.prepare(
27507
27522
  `SELECT rule_id,
27523
+ -- BARE columns beside max(latest_at), which is deliberate and
27524
+ -- is SQLite's documented behaviour: with a single min()/max()
27525
+ -- in an aggregate query, every bare column takes its value from
27526
+ -- the row that produced the extremum. So these are the severity
27527
+ -- and category of the definition whose finding is NEWEST, which
27528
+ -- is what the row-based build they replaced read off its first
27529
+ -- (newest-first) row.
27530
+ --
27531
+ -- min() is WRONG here and was the defect: inspection_definitions
27532
+ -- holds one row per rule VERSION (see its writer \u2014 a version bump
27533
+ -- mints a new row), so a rule whose severity moved between
27534
+ -- versions has several, and min() picks the ALPHABETICALLY
27535
+ -- smallest \u2014 'low' over 'medium', but 'critical' over 'high'.
27536
+ -- That is arbitrary in direction, and it feeds the badge, the
27537
+ -- filter, the facet counts and the primary sort key.
27538
+ --
27539
+ -- Adding a second min()/max() aggregate here would make these
27540
+ -- bare columns ambiguous again; keep max(latest_at) the only one.
27541
+ severity,
27542
+ category,
27508
27543
  sum(tuple_count) AS instance_count,
27509
27544
  max(latest_at) AS latest_at,
27510
27545
  group_concat(source_tools) AS source_tools,
@@ -27515,6 +27550,14 @@ var SqliteFindingsRepository = class {
27515
27550
  group_concat(tool_names) AS tool_names
27516
27551
  FROM (
27517
27552
  SELECT d.rule_id AS rule_id,
27553
+ -- Severity and category are columns of the DEFINITION, and
27554
+ -- a rule can have SEVERAL definitions (one per version), so
27555
+ -- these are grouped on below and resolved to the newest
27556
+ -- firing version by the outer query's bare-column select.
27557
+ -- They ride the aggregate because the type build has no rows
27558
+ -- to read them off \u2014 see buildFindingTypes.
27559
+ d.severity AS severity,
27560
+ d.category AS category,
27518
27561
  e.event_type || '${TUPLE_SEP}' ||
27519
27562
  (CASE WHEN f.finding_key IS NULL THEN '' ELSE 'k' END) || '${TUPLE_SEP}' ||
27520
27563
  coalesce(latest.status, '') AS status_tuple,
@@ -27529,7 +27572,7 @@ var SqliteFindingsRepository = class {
27529
27572
  LEFT JOIN ${LATEST_RESOLUTION_BY_KEY_SQL} latest
27530
27573
  ON latest.finding_key = f.finding_key
27531
27574
  ${scope.predicate}
27532
- GROUP BY d.rule_id, status_tuple
27575
+ GROUP BY d.rule_id, d.severity, d.category, status_tuple
27533
27576
  )
27534
27577
  GROUP BY rule_id`
27535
27578
  ).all(scope.params);
@@ -27538,6 +27581,8 @@ var SqliteFindingsRepository = class {
27538
27581
  r.rule_id,
27539
27582
  {
27540
27583
  instanceCount: r.instance_count,
27584
+ severity: r.severity,
27585
+ category: r.category,
27541
27586
  sourceTools: splitConcat(r.source_tools),
27542
27587
  actionsTaken: splitConcat(r.actions_taken),
27543
27588
  statusInputs: splitConcat(r.status_inputs).map((tuple2) => {
@@ -27554,7 +27599,7 @@ var SqliteFindingsRepository = class {
27554
27599
  latestDetectedAt: epochMillisToIso(r.latest_at),
27555
27600
  // Free text only — joined and substring-matched, so group_concat's
27556
27601
  // commas need no unpicking (a repo/path containing one still matches).
27557
- // Left undefined (not '') when unfetched, so buildFindingGroups can
27602
+ // Left undefined (not '') when unfetched, so buildFindingTypes can
27558
27603
  // tell "no q this request" from "a group with no repo/file at all"
27559
27604
  // and skip priming a haystack nothing will read.
27560
27605
  ...withSearchText ? {
@@ -27706,6 +27751,12 @@ var SqliteHistorySyncRepository = class {
27706
27751
  this.markOwedStmt = db.prepare(
27707
27752
  `UPDATE audit_events SET outbox_owed = 1 WHERE id = :id AND synced_at IS NULL`
27708
27753
  );
27754
+ this.markCaptureBacklogOwedStmt = db.prepare(
27755
+ `UPDATE audit_events SET outbox_owed = 1
27756
+ WHERE synced_at IS NULL
27757
+ AND event_type IN (${CAPTURE_TYPE_LIST})
27758
+ AND started_at < :before`
27759
+ );
27709
27760
  this.stampStmt = db.prepare(
27710
27761
  `UPDATE audit_events SET synced_at = :at, sync_claimed_at = NULL WHERE id = :id`
27711
27762
  );
@@ -27754,7 +27805,9 @@ var SqliteHistorySyncRepository = class {
27754
27805
  );
27755
27806
  this.disownCapturesStmt = db.prepare(
27756
27807
  `UPDATE audit_events SET outbox_owed = NULL
27757
- WHERE outbox_owed IS NOT NULL AND event_type IN (${CAPTURE_TYPE_LIST})`
27808
+ WHERE outbox_owed IS NOT NULL
27809
+ AND event_type IN (${CAPTURE_TYPE_LIST})
27810
+ AND started_at < :attachedAt`
27758
27811
  );
27759
27812
  this.rearmStmt = db.prepare(
27760
27813
  `UPDATE audit_events SET synced_at = NULL
@@ -27830,6 +27883,7 @@ var SqliteHistorySyncRepository = class {
27830
27883
  freezeBoundaryStmt;
27831
27884
  captureRowsStmt;
27832
27885
  markOwedStmt;
27886
+ markCaptureBacklogOwedStmt;
27833
27887
  captureSkipCountStmt;
27834
27888
  disownCapturesStmt;
27835
27889
  partitionStmt;
@@ -27893,6 +27947,23 @@ var SqliteHistorySyncRepository = class {
27893
27947
  markCaptureOwed(id) {
27894
27948
  this.markOwedStmt.run({ id });
27895
27949
  }
27950
+ /**
27951
+ * Mark every capture already on disk as owed, as of `before`.
27952
+ *
27953
+ * The consent-time backfill, called once from `aka attach` when a human
27954
+ * grants existing-history consent — never from an ongoing drain pass, and
27955
+ * never inferred from a boundary that could later move. `before` is the
27956
+ * caller's own "now" at the moment consent was granted, so what this marks
27957
+ * is exactly the backlog the consent prompt already counted, not whatever a
27958
+ * later re-attach or key rotation might widen it to.
27959
+ *
27960
+ * Returns how many rows matched, for the caller to log or test against. Not a
27961
+ * count of NEWLY marked rows — a row still unsynced from an earlier call
27962
+ * matches again and is counted again, the same as `UPDATE`'s own `changes`.
27963
+ */
27964
+ markCaptureBacklogOwed(before) {
27965
+ return Number(this.markCaptureBacklogOwedStmt.run({ before }).changes);
27966
+ }
27896
27967
  /** Record delivery. Called only AFTER the far side has accepted the rows. */
27897
27968
  markSynced(ids, atMs) {
27898
27969
  this.stampAll(ids, atMs);
@@ -28009,15 +28080,42 @@ var SqliteHistorySyncRepository = class {
28009
28080
  *
28010
28081
  * Delivery is a fact about ONE recipient: rows sent to the deployment a
28011
28082
  * machine has just left are undelivered as far as the new one is concerned.
28012
- * All three in one transaction, so a crash between them cannot leave stamps
28013
- * attributed to the wrong deployment, or a boundary that belongs to another.
28083
+ * All four in one transaction, so a crash between them cannot leave stamps
28084
+ * attributed to the wrong deployment, a boundary that belongs to another, or
28085
+ * a disown with no re-mark to follow it.
28014
28086
  *
28015
28087
  * The boundary is written HERE and only here, which is what freezes it: a
28016
28088
  * re-attach to the SAME deployment (a key rotation) leaves the fingerprint
28017
28089
  * unchanged, so this never runs and the backlog does not widen back over rows
28018
28090
  * the live path has since delivered.
28091
+ *
28092
+ * `backfillCapturesBefore` is the caller's OWN "now" at the instant a human
28093
+ * granted existing-history consent for the deployment this call is arming —
28094
+ * a DIFFERENT instant from `backlogBefore`: the re-mark boundary is the GRANT
28095
+ * instant, `backlogBefore` is the ATTACH instant, and the two can be far
28096
+ * apart. Passed only when that grant is valid, since this method has no way
28097
+ * to check consent itself and must not mark a row owed for a machine that
28098
+ * never agreed to it. Applied AFTER the disown above, in the SAME
28099
+ * transaction: what the disown clears is every marker below `backlogBefore`,
28100
+ * which includes this deployment's OWN pre-attach rows — `aka attach` calls
28101
+ * `seedCaptureBacklogOwed` at the attach instant, so every row it marks sits
28102
+ * on the cleared side of that bound — and the re-mark in the same
28103
+ * transaction is what puts those rows back. A crash between the two cannot
28104
+ * strand the ledger disowned with nothing re-marked — the transaction either
28105
+ * lands whole or not at all, and a fingerprint mismatch that has not yet
28106
+ * committed re-enters this method on the very next pass. Omit it (the
28107
+ * structural-only tests do) to exercise the disown in isolation.
28108
+ *
28109
+ * The disown is bounded by `backlogBefore`, which is what keeps it from
28110
+ * touching a marker the NEW deployment's OWN live path has already set: B's
28111
+ * live path can mark a capture owed from the moment `aka attach` writes the
28112
+ * descriptor, before the drain's first pass ever reaches this method, and
28113
+ * such a row sits at or after the bound rather than below it. What keeps the
28114
+ * disown from eating THIS SAME CALL's own re-mark is the order, not the
28115
+ * bound — disown runs first, re-mark second, both inside the one
28116
+ * transaction above.
28019
28117
  */
28020
- rearmFor(fingerprint, backlogBefore) {
28118
+ rearmFor(fingerprint, backlogBefore, backfillCapturesBefore) {
28021
28119
  this.ensureRowStmt.run();
28022
28120
  withTransaction(
28023
28121
  this.db,
@@ -28025,7 +28123,10 @@ var SqliteHistorySyncRepository = class {
28025
28123
  const previous = getRow(this.fingerprintStmt)?.fingerprint;
28026
28124
  this.rearmStmt.run();
28027
28125
  if (previous !== null && previous !== void 0 && previous !== fingerprint) {
28028
- this.disownCapturesStmt.run();
28126
+ this.disownCapturesStmt.run({ attachedAt: backlogBefore });
28127
+ }
28128
+ if (backfillCapturesBefore !== void 0) {
28129
+ this.markCaptureBacklogOwedStmt.run({ before: backfillCapturesBefore });
28029
28130
  }
28030
28131
  this.setFingerprintStmt.run({ fingerprint, backlogBefore });
28031
28132
  },
@@ -28305,7 +28406,8 @@ function managedSettingsPaths(platform2 = process.platform) {
28305
28406
  }
28306
28407
  return [posix.join("/etc", "aka", MANAGED_SETTINGS_FILENAME)];
28307
28408
  }
28308
- function readManagedSettings(paths = managedSettingsPaths()) {
28409
+ var testOnlyManagedPaths = null;
28410
+ function readManagedSettings(paths = testOnlyManagedPaths ?? managedSettingsPaths()) {
28309
28411
  for (const path of paths) {
28310
28412
  let text;
28311
28413
  try {
@@ -30785,7 +30887,7 @@ function toUtcDateString(ms) {
30785
30887
  return new Date(ms).toISOString().slice(0, 10);
30786
30888
  }
30787
30889
  function isTimeseriesSeverity(s) {
30788
- return s === "critical" || s === "high" || s === "medium";
30890
+ return s === "critical" || s === "high" || s === "medium" || s === "low";
30789
30891
  }
30790
30892
  var SqliteSecurityRepository = class {
30791
30893
  constructor(db, now = () => Date.now()) {
@@ -30914,12 +31016,16 @@ var SqliteSecurityRepository = class {
30914
31016
  const now = this.now();
30915
31017
  const windowStart = startOfUtcDay2(now) - (lenDays - 1) * DAY_MS4;
30916
31018
  const rows = this.findingsInRange(windowStart, now);
30917
- const points = Array.from({ length: numBuckets }, (_, i) => ({
30918
- timestamp: toUtcDateString(windowStart + i * bucketMs),
30919
- critical: 0,
30920
- high: 0,
30921
- medium: 0
30922
- }));
31019
+ const points = Array.from(
31020
+ { length: numBuckets },
31021
+ (_, i) => ({
31022
+ timestamp: toUtcDateString(windowStart + i * bucketMs),
31023
+ critical: 0,
31024
+ high: 0,
31025
+ medium: 0,
31026
+ low: 0
31027
+ })
31028
+ );
30923
31029
  for (const r of rows) {
30924
31030
  const idx = Math.floor((r.occurredAt - windowStart) / bucketMs);
30925
31031
  const bucket = points[idx];
@@ -31137,6 +31243,7 @@ var SqliteSecurityRepository = class {
31137
31243
  `SELECT f.finding_key AS finding_key,
31138
31244
  d.rule_id AS rule_id,
31139
31245
  d.severity AS severity,
31246
+ e.repo AS repo,
31140
31247
  e.file_path AS path,
31141
31248
  COALESCE(f.first_detected_at, e.started_at) AS first_detected_at,
31142
31249
  latest.resolved_at AS latest_resolved_at
@@ -31156,6 +31263,7 @@ var SqliteSecurityRepository = class {
31156
31263
  const items = rows.map((r) => ({
31157
31264
  findingKey: r.finding_key,
31158
31265
  ruleId: r.rule_id,
31266
+ repo: r.repo ?? "",
31159
31267
  severity: r.severity,
31160
31268
  path: r.path ?? "",
31161
31269
  resolvedAt: new Date(r.latest_resolved_at).toISOString(),
@@ -31165,13 +31273,66 @@ var SqliteSecurityRepository = class {
31165
31273
  }));
31166
31274
  return Promise.resolve({ items });
31167
31275
  }
31276
+ /**
31277
+ * Per-rule tallies of the findings that are still OPEN, whole-store.
31278
+ *
31279
+ * Scoped by status rather than by time, because the card this feeds is a to-do
31280
+ * list: a secret committed three weeks ago and never rotated is still the most
31281
+ * important thing to fix, and any window hides it. It carried a "newest N
31282
+ * findings" cap and then a range; the first meant a different span on every
31283
+ * machine, and the second reported "no recommendations" over live exposure.
31284
+ *
31285
+ * `open` mirrors `deriveFindingStatus` — at-rest, minus resolved and dismissed —
31286
+ * so a row's count is exactly what `?status=open&type=<rule>` returns. Note that
31287
+ * is NOT `severitySummary`'s `openAtRest`, which keeps dismissed findings (a
31288
+ * dismissal is a judgement, not a remediation) and drops untracked legacy rows.
31289
+ * The two answer different questions and only this one has to match a link.
31290
+ *
31291
+ * Aggregated in SQL: the result is O(distinct rule × category × severity), so a
31292
+ * whole-store scope costs a grouped scan rather than a row per finding.
31293
+ */
31294
+ recommendationInputs() {
31295
+ const rows = allRows(
31296
+ this.db.prepare(
31297
+ `SELECT d.rule_id AS rule_id,
31298
+ d.category AS category,
31299
+ d.severity AS severity,
31300
+ COUNT(*) AS count
31301
+ FROM inspection_findings f
31302
+ JOIN audit_events e ON e.id = f.audit_event_id
31303
+ JOIN inspection_definitions d ON d.id = f.inspection_definition_id
31304
+ LEFT JOIN ${LATEST_RESOLUTION_BY_KEY_SQL} latest
31305
+ ON latest.finding_key = f.finding_key
31306
+ WHERE e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})
31307
+ AND e.event_type = 'code_change'
31308
+ AND (
31309
+ f.finding_key IS NULL
31310
+ OR latest.status IS NULL
31311
+ OR latest.status NOT IN ('resolved', 'dismissed')
31312
+ )
31313
+ GROUP BY d.rule_id, d.category, d.severity`
31314
+ )
31315
+ );
31316
+ return Promise.resolve(
31317
+ rows.map((r) => ({
31318
+ ruleId: r.rule_id,
31319
+ category: r.category,
31320
+ severity: r.severity,
31321
+ count: r.count
31322
+ }))
31323
+ );
31324
+ }
31168
31325
  // Findings whose parent event occurred in [fromMs, toMs), with the parent's
31169
31326
  // epoch-millis timestamp. started_at is an INTEGER column, so the bounds stay
31170
31327
  // numeric and the JS aggregations bucket/split on ms directly.
31171
31328
  findingsInRange(fromMs, toMs) {
31172
31329
  const rows = allRows(
31173
31330
  this.db.prepare(
31174
- `SELECT e.started_at AS occurred_at, d.severity AS severity, f.action_taken AS action_taken
31331
+ // `rule_id`/`category` cost nothing extra: inspection_definitions is already
31332
+ // joined for `severity`, so they are two more columns off a row this read
31333
+ // already fetches. They feed the recommended-actions rollup.
31334
+ `SELECT e.started_at AS occurred_at, d.severity AS severity, f.action_taken AS action_taken,
31335
+ d.rule_id AS rule_id, d.category AS category
31175
31336
  FROM inspection_findings f
31176
31337
  JOIN audit_events e ON e.id = f.audit_event_id
31177
31338
  JOIN inspection_definitions d ON d.id = f.inspection_definition_id
@@ -31184,7 +31345,9 @@ var SqliteSecurityRepository = class {
31184
31345
  return rows.map((r) => ({
31185
31346
  occurredAt: r.occurred_at,
31186
31347
  severity: r.severity,
31187
- actionTaken: r.action_taken
31348
+ actionTaken: r.action_taken,
31349
+ ruleId: r.rule_id,
31350
+ category: r.category
31188
31351
  }));
31189
31352
  }
31190
31353
  };
@@ -32354,14 +32517,51 @@ function openLocalDatabase(dir) {
32354
32517
  };
32355
32518
  }
32356
32519
 
32357
- // ../../packages/persistence/src/finding-key.ts
32520
+ // ../../packages/persistence/src/egress-wire.ts
32358
32521
  import { createHash as createHash3 } from "crypto";
32522
+ function hashProjectKey(projectKey) {
32523
+ return createHash3("sha256").update(projectKey, "utf8").digest("hex");
32524
+ }
32525
+ function toIngestHit(hit) {
32526
+ return {
32527
+ host: hit.host,
32528
+ kind: hit.kind,
32529
+ name: hit.name,
32530
+ category: hit.category,
32531
+ trust: hit.trust,
32532
+ network: hit.network,
32533
+ method: hit.method,
32534
+ transport: hit.transport,
32535
+ url: hit.url,
32536
+ template: hit.template,
32537
+ dataClass: hit.dataClass,
32538
+ site: {
32539
+ file: hit.site.file,
32540
+ line: hit.site.line,
32541
+ dynamic: hit.site.dynamic,
32542
+ vendored: hit.site.vendored
32543
+ }
32544
+ };
32545
+ }
32546
+ function toEgressIngestRequest(input2) {
32547
+ const { hits, droppedFiles } = capHits(input2.hits, input2.reconcile.mode);
32548
+ const reconcile = withoutDroppedFiles(input2.reconcile, droppedFiles);
32549
+ return {
32550
+ projectKey: hashProjectKey(input2.projectKey),
32551
+ project: input2.project,
32552
+ reconcile,
32553
+ hits: hits.map(toIngestHit)
32554
+ };
32555
+ }
32556
+
32557
+ // ../../packages/persistence/src/finding-key.ts
32558
+ import { createHash as createHash4 } from "crypto";
32359
32559
  function normalizeFilePath(filePath) {
32360
32560
  return filePath.replaceAll("\\", "/");
32361
32561
  }
32362
32562
  function computeFindingKey(input2) {
32363
32563
  const normalizedPath = normalizeFilePath(input2.filePath);
32364
- return createHash3("sha256").update(`${input2.ruleId}\0${normalizedPath}\0${input2.valueFingerprint}`).digest("hex");
32564
+ return createHash4("sha256").update(`${input2.ruleId}\0${normalizedPath}\0${input2.valueFingerprint}`).digest("hex");
32365
32565
  }
32366
32566
 
32367
32567
  // ../../packages/persistence/src/fingerprint.ts
@@ -32487,14 +32687,18 @@ function fingerprintValue(key, raw) {
32487
32687
  return createHmac("sha256", key.material).update(raw, "utf8").digest("hex");
32488
32688
  }
32489
32689
 
32490
- // ../../packages/persistence/src/history-preview.ts
32690
+ // ../../packages/persistence/src/history-backfill.ts
32491
32691
  import { existsSync as existsSync4 } from "fs";
32492
32692
  import { join as join9 } from "path";
32693
+
32694
+ // ../../packages/persistence/src/history-preview.ts
32695
+ import { existsSync as existsSync5 } from "fs";
32696
+ import { join as join10 } from "path";
32493
32697
  import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
32494
32698
 
32495
32699
  // ../../packages/persistence/src/store-symlinks.ts
32496
- import { existsSync as existsSync5, lstatSync as lstatSync3, readlinkSync, realpathSync, statSync as statSync4 } from "fs";
32497
- import { dirname as dirname3, join as join10, resolve } from "path";
32700
+ import { existsSync as existsSync6, lstatSync as lstatSync3, readlinkSync, realpathSync, statSync as statSync4 } from "fs";
32701
+ import { dirname as dirname3, join as join11, resolve } from "path";
32498
32702
  var STORE_DB = "the store database (including the prompt corpus)";
32499
32703
  var STORE_SETTINGS = "your settings file";
32500
32704
  function storeContents(home) {
@@ -32503,7 +32707,7 @@ function storeContents(home) {
32503
32707
  [settingsDir(home), STORE_SETTINGS],
32504
32708
  [dataDir(home), STORE_DB],
32505
32709
  [keysDir(home), "the vault key"],
32506
- [join10(settingsDir(home), "settings.json"), STORE_SETTINGS],
32710
+ [join11(settingsDir(home), "settings.json"), STORE_SETTINGS],
32507
32711
  [dbPath(home), STORE_DB]
32508
32712
  ]);
32509
32713
  }
@@ -32518,7 +32722,7 @@ function symlinkedStorePaths(home, platform2 = process.platform) {
32518
32722
  holds,
32519
32723
  // existsSync follows the link, so a target that is gone reads as
32520
32724
  // absent here while lstat above still sees the link itself.
32521
- missing: !existsSync5(path),
32725
+ missing: !existsSync6(path),
32522
32726
  mode: targetMode(path, platform2)
32523
32727
  }
32524
32728
  ];
@@ -32556,19 +32760,19 @@ import {
32556
32760
  import { execFileSync } from "child_process";
32557
32761
  import { randomBytes as randomBytes2 } from "crypto";
32558
32762
  import { chmodSync as chmodSync3, readFileSync as readFileSync7, renameSync as renameSync4, rmSync as rmSync6, statSync as statSync5, writeFileSync as writeFileSync3 } from "fs";
32559
- import { join as join11 } from "path";
32763
+ import { join as join12 } from "path";
32560
32764
 
32561
32765
  // ../../packages/persistence/src/vault/vault.ts
32562
32766
  import { randomBytes as randomBytes3, randomUUID as randomUUID12 } from "crypto";
32563
32767
 
32564
32768
  // ../../packages/persistence/src/warn-era-cap.ts
32565
- import { existsSync as existsSync6, writeFileSync as writeFileSync4 } from "fs";
32566
- import { join as join12 } from "path";
32769
+ import { existsSync as existsSync7, writeFileSync as writeFileSync4 } from "fs";
32770
+ import { join as join13 } from "path";
32567
32771
  var MARKER = "warn-era-capped";
32568
32772
  function capWarnEraEnforcementOnce(db, policyMode, dataDir2) {
32569
32773
  if (policyMode !== "warn") return { capped: 0, skipped: "not-warn" };
32570
- const marker = join12(dataDir2, MARKER);
32571
- if (existsSync6(marker)) return { capped: 0, skipped: "already-run" };
32774
+ const marker = join13(dataDir2, MARKER);
32775
+ if (existsSync7(marker)) return { capped: 0, skipped: "already-run" };
32572
32776
  const capped = db.policies.capCategoryActions();
32573
32777
  writeFileSync4(marker, `${new Date(Date.now()).toISOString()}
32574
32778
  `, { mode: DATA_FILE_MODE });
@@ -32627,8 +32831,8 @@ function resolveProvider() {
32627
32831
  function loadConfig(base = defaultDataDir(), resolveProviderFn = resolveProvider) {
32628
32832
  try {
32629
32833
  ensureLayoutDirSync(base);
32630
- const settingsFile = join13(settingsDir(base), "settings.json");
32631
- if (existsSync7(settingsFile)) tightenFile(settingsFile);
32834
+ const settingsFile = join14(settingsDir(base), "settings.json");
32835
+ if (existsSync8(settingsFile)) tightenFile(settingsFile);
32632
32836
  } catch {
32633
32837
  }
32634
32838
  migrateLegacyLayout(base);
@@ -32653,7 +32857,7 @@ function resolveProviderSafe(resolveProviderFn) {
32653
32857
  // ../../packages/plugin-sdk/src/config-inventory.ts
32654
32858
  import { readdirSync as readdirSync2, readFileSync as readFileSync9, realpathSync as realpathSync2, statSync as statSync7 } from "fs";
32655
32859
  import { homedir as homedir2 } from "os";
32656
- import { basename as basename3, join as join15 } from "path";
32860
+ import { basename as basename3, join as join16 } from "path";
32657
32861
 
32658
32862
  // ../../packages/detections/src/egress/registry.ts
32659
32863
  var EXTRACTOR_VERSION = "1";
@@ -35745,8 +35949,8 @@ function uniqueRuleIds(findings) {
35745
35949
  }
35746
35950
 
35747
35951
  // ../../packages/plugin-sdk/src/repo.ts
35748
- import { existsSync as existsSync8, readFileSync as readFileSync8, statSync as statSync6 } from "fs";
35749
- import { basename as basename2, dirname as dirname4, isAbsolute, join as join14, sep as sep2 } from "path";
35952
+ import { existsSync as existsSync9, readFileSync as readFileSync8, statSync as statSync6 } from "fs";
35953
+ import { basename as basename2, dirname as dirname4, isAbsolute, join as join15, sep as sep2 } from "path";
35750
35954
  function resolveRepo(cwd) {
35751
35955
  try {
35752
35956
  const root = findGitRoot(cwd);
@@ -35761,32 +35965,32 @@ function resolveRepo(cwd) {
35761
35965
  function findGitRoot(start) {
35762
35966
  let dir = start;
35763
35967
  for (; ; ) {
35764
- if (existsSync8(join14(dir, ".git"))) return dir;
35968
+ if (existsSync9(join15(dir, ".git"))) return dir;
35765
35969
  const parent = dirname4(dir);
35766
35970
  if (parent === dir) return void 0;
35767
35971
  dir = parent;
35768
35972
  }
35769
35973
  }
35770
35974
  function resolveGitContext(root) {
35771
- const dotGit = join14(root, ".git");
35975
+ const dotGit = join15(root, ".git");
35772
35976
  try {
35773
35977
  if (statSync6(dotGit).isDirectory()) {
35774
- return { configPath: join14(dotGit, "config"), headRoot: root };
35978
+ return { configPath: join15(dotGit, "config"), headRoot: root };
35775
35979
  }
35776
35980
  } catch {
35777
35981
  return void 0;
35778
35982
  }
35779
35983
  const target = /^gitdir:\s*(.+?)\s*$/m.exec(safeRead(dotGit) ?? "")?.[1];
35780
35984
  if (!target) return void 0;
35781
- const gitdir = isAbsolute(target) ? target : join14(root, target);
35782
- if (existsSync8(join14(gitdir, "config"))) {
35783
- return { configPath: join14(gitdir, "config"), headRoot: root };
35985
+ const gitdir = isAbsolute(target) ? target : join15(root, target);
35986
+ if (existsSync9(join15(gitdir, "config"))) {
35987
+ return { configPath: join15(gitdir, "config"), headRoot: root };
35784
35988
  }
35785
- const commonRaw = safeRead(join14(gitdir, "commondir"))?.trim();
35989
+ const commonRaw = safeRead(join15(gitdir, "commondir"))?.trim();
35786
35990
  if (!commonRaw) return void 0;
35787
- const commonGitDir = isAbsolute(commonRaw) ? commonRaw : join14(gitdir, commonRaw);
35991
+ const commonGitDir = isAbsolute(commonRaw) ? commonRaw : join15(gitdir, commonRaw);
35788
35992
  const headRoot = basename2(commonGitDir) === ".git" ? dirname4(commonGitDir) : root;
35789
- return { configPath: join14(commonGitDir, "config"), headRoot };
35993
+ return { configPath: join15(commonGitDir, "config"), headRoot };
35790
35994
  }
35791
35995
  function safeRead(path) {
35792
35996
  try {
@@ -35828,9 +36032,9 @@ function slugFromUrl(url2) {
35828
36032
  }
35829
36033
 
35830
36034
  // ../../packages/plugin-sdk/src/events.ts
35831
- import { createHash as createHash4, randomUUID as randomUUID13 } from "crypto";
36035
+ import { createHash as createHash5, randomUUID as randomUUID13 } from "crypto";
35832
36036
  function contentHashOf(text) {
35833
- return createHash4("sha256").update(text).digest("hex");
36037
+ return createHash5("sha256").update(text).digest("hex");
35834
36038
  }
35835
36039
  function buildIngestEvent(input2) {
35836
36040
  const contentHash = input2.contentHash ?? contentHashOf(input2.content);
@@ -35856,7 +36060,7 @@ function buildIngestEvent(input2) {
35856
36060
  }
35857
36061
 
35858
36062
  // ../../packages/plugin-sdk/src/isolated-scan.ts
35859
- import { existsSync as existsSync9 } from "fs";
36063
+ import { existsSync as existsSync10 } from "fs";
35860
36064
  import { fileURLToPath } from "url";
35861
36065
  import { Worker } from "worker_threads";
35862
36066
  var ISOLATED_SCAN_BUDGET_MS = 2e3;
@@ -35870,7 +36074,7 @@ function resolveWorkerUrl() {
35870
36074
  for (const name of ["scan-worker.js", "scan-worker.ts"]) {
35871
36075
  const candidate = new URL(name, import.meta.url);
35872
36076
  try {
35873
- if (existsSync9(fileURLToPath(candidate))) {
36077
+ if (existsSync10(fileURLToPath(candidate))) {
35874
36078
  resolvedWorkerUrl = candidate;
35875
36079
  return candidate;
35876
36080
  }
@@ -36333,13 +36537,9 @@ function createGuardedScanner(partition, gateway, opts) {
36333
36537
  };
36334
36538
  }
36335
36539
 
36336
- // ../../packages/plugin-sdk/src/ignore-layers.ts
36337
- var import_ignore = __toESM(require_ignore(), 1);
36338
- import { readFileSync as readFileSync10 } from "fs";
36339
- import { join as join16 } from "path";
36340
-
36341
- // ../../packages/plugin-sdk/src/inventory-resolver.ts
36342
- import { arch, hostname as hostname4, platform, release } from "os";
36540
+ // ../../packages/plugin-sdk/src/host-floor.ts
36541
+ import { readFileSync as readFileSync11 } from "fs";
36542
+ import { join as join18 } from "path";
36343
36543
 
36344
36544
  // ../../packages/plugin-sdk/src/model-governance.ts
36345
36545
  import {
@@ -36347,7 +36547,7 @@ import {
36347
36547
  fstatSync,
36348
36548
  mkdirSync as mkdirSync2,
36349
36549
  openSync as openSync2,
36350
- readFileSync as readFileSync11,
36550
+ readFileSync as readFileSync10,
36351
36551
  readSync,
36352
36552
  writeFileSync as writeFileSync5
36353
36553
  } from "fs";
@@ -36367,7 +36567,7 @@ function isModelProhibited(model, prohibited) {
36367
36567
  function readSessionModel(dataDir2, sessionId) {
36368
36568
  if (sessionId === void 0 || sessionId === "") return void 0;
36369
36569
  try {
36370
- const parsed2 = JSON.parse(readFileSync11(join17(dataDir2, SESSION_MODEL_MARKER), "utf8"));
36570
+ const parsed2 = JSON.parse(readFileSync10(join17(dataDir2, SESSION_MODEL_MARKER), "utf8"));
36371
36571
  if (typeof parsed2 !== "object" || parsed2 === null) return void 0;
36372
36572
  const record2 = parsed2;
36373
36573
  if (record2.sessionId !== sessionId) return void 0;
@@ -36381,7 +36581,7 @@ function readTail(path) {
36381
36581
  const fd = openSync2(path, "r");
36382
36582
  try {
36383
36583
  const { size } = fstatSync(fd);
36384
- if (size <= TAIL_BYTES) return { text: readFileSync11(fd, "utf8"), truncated: false };
36584
+ if (size <= TAIL_BYTES) return { text: readFileSync10(fd, "utf8"), truncated: false };
36385
36585
  const buffer = Buffer.allocUnsafe(TAIL_BYTES);
36386
36586
  let filled = 0;
36387
36587
  while (filled < TAIL_BYTES) {
@@ -36456,18 +36656,44 @@ function buildModelRefusalEvent(input2) {
36456
36656
  };
36457
36657
  }
36458
36658
 
36659
+ // ../../packages/plugin-sdk/src/host-floor.ts
36660
+ var HOST_FEATURE = {
36661
+ ModelSwitch: "model-switch",
36662
+ VaultPointerDisplay: "vault-pointer-display"
36663
+ };
36664
+ var HOST_FLOORS = {
36665
+ [HOST_FEATURE.ModelSwitch]: {
36666
+ label: "model-switch protection",
36667
+ hookEvents: ["PreModelSwitch", "PostModelSwitch"],
36668
+ since: "2.1.251"
36669
+ },
36670
+ [HOST_FEATURE.VaultPointerDisplay]: {
36671
+ label: "vault pointer display",
36672
+ hookEvents: ["MessageDisplay"],
36673
+ since: "2.1.152"
36674
+ }
36675
+ };
36676
+
36677
+ // ../../packages/plugin-sdk/src/ignore-layers.ts
36678
+ var import_ignore = __toESM(require_ignore(), 1);
36679
+ import { readFileSync as readFileSync12 } from "fs";
36680
+ import { join as join19 } from "path";
36681
+
36682
+ // ../../packages/plugin-sdk/src/inventory-resolver.ts
36683
+ import { arch, hostname as hostname4, platform, release } from "os";
36684
+
36459
36685
  // ../../packages/plugin-sdk/src/nudge.ts
36460
- import { mkdirSync as mkdirSync3, readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "fs";
36461
- import { join as join18 } from "path";
36686
+ import { mkdirSync as mkdirSync3, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
36687
+ import { join as join20 } from "path";
36462
36688
  var NUDGE_MARKER = "nudge-last-session";
36463
36689
  function claimOnboardingNudge(dataDir2, sessionId) {
36464
36690
  return claimOncePerSession(dataDir2, NUDGE_MARKER, sessionId);
36465
36691
  }
36466
36692
  function claimOncePerSession(dataDir2, marker, sessionId) {
36467
36693
  if (!sessionId) return true;
36468
- const path = join18(dataDir2, marker);
36694
+ const path = join20(dataDir2, marker);
36469
36695
  try {
36470
- if (readFileSync12(path, "utf8") === sessionId) return false;
36696
+ if (readFileSync13(path, "utf8") === sessionId) return false;
36471
36697
  } catch {
36472
36698
  }
36473
36699
  try {
@@ -36518,8 +36744,8 @@ function createPolicyResolver(bundle) {
36518
36744
  }
36519
36745
 
36520
36746
  // ../../packages/plugin-sdk/src/project-files.ts
36521
- import { existsSync as existsSync10, readdirSync as readdirSync4 } from "fs";
36522
- import { basename as basename5, join as join19 } from "path";
36747
+ import { existsSync as existsSync11, readdirSync as readdirSync4 } from "fs";
36748
+ import { basename as basename5, join as join21 } from "path";
36523
36749
 
36524
36750
  // ../../packages/plugin-sdk/src/provider-env-antigravity.ts
36525
36751
  var optionalBaseUrl2 = external_exports.preprocess((v) => {
@@ -36550,6 +36776,14 @@ var CodexProviderEnvSchema = external_exports.object(codexProviderEnvShape);
36550
36776
  // ../../packages/plugin-sdk/src/runtime.ts
36551
36777
  import { randomUUID as randomUUID14 } from "crypto";
36552
36778
  var ENFORCEMENT_CEILING_ENABLED = false;
36779
+ function applyEnforcementCeiling(action, policyMode, enabled) {
36780
+ if (!enabled || policyMode !== "warn") return action;
36781
+ return action === "block" || action === "redact" ? "warn" : action;
36782
+ }
36783
+ function resolveEnforcedAction(action, opts) {
36784
+ const degraded = !opts.rewritable && action === "redact" ? builtinPolicyToAction(opts.redactFallback) : action;
36785
+ return applyEnforcementCeiling(degraded, opts.policyMode, opts.ceilingEnabled);
36786
+ }
36553
36787
  function startTiming() {
36554
36788
  try {
36555
36789
  return performance.now();
@@ -36658,12 +36892,12 @@ function createPluginRuntime(gateway, settings, opts) {
36658
36892
  }
36659
36893
  function actionForFinding(finding, excepted, rewritable = true) {
36660
36894
  if (excepted?.has(finding)) return "allow";
36661
- const action = resolveAction(finding.ruleId, finding.category);
36662
- if (!rewritable && action === "redact") return builtinPolicyToAction(redactFallback);
36663
- if (ENFORCEMENT_CEILING_ENABLED && policyMode === "warn" && (action === "block" || action === "redact")) {
36664
- return "warn";
36665
- }
36666
- return action;
36895
+ return resolveEnforcedAction(resolveAction(finding.ruleId, finding.category), {
36896
+ policyMode,
36897
+ redactFallback,
36898
+ rewritable,
36899
+ ceilingEnabled: ENFORCEMENT_CEILING_ENABLED
36900
+ });
36667
36901
  }
36668
36902
  function decide(findings, text, excepted, rewritable = true) {
36669
36903
  if (findings.length === 0) return { action: "log", text, findings: [] };
@@ -36912,7 +37146,7 @@ var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
36912
37146
 
36913
37147
  // ../../packages/plugin-sdk/src/throttle.ts
36914
37148
  import { mkdirSync as mkdirSync4, statSync as statSync8, writeFileSync as writeFileSync7 } from "fs";
36915
- import { join as join20 } from "path";
37149
+ import { join as join22 } from "path";
36916
37150
 
36917
37151
  // src/present.ts
36918
37152
  var fg = (hex3) => (text) => {
@@ -37055,45 +37289,8 @@ function baseMetadata(input2) {
37055
37289
  }
37056
37290
 
37057
37291
  // src/hooks/store-health.ts
37058
- import { mkdirSync as mkdirSync5, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "fs";
37059
- import { dirname as dirname6, join as join27 } from "path";
37060
-
37061
- // ../../packages/plugin-runtime/src/attached/egress-wire.ts
37062
- import { createHash as createHash5 } from "crypto";
37063
- function hashProjectKey(projectKey) {
37064
- return createHash5("sha256").update(projectKey, "utf8").digest("hex");
37065
- }
37066
- function toIngestHit(hit) {
37067
- return {
37068
- host: hit.host,
37069
- kind: hit.kind,
37070
- name: hit.name,
37071
- category: hit.category,
37072
- trust: hit.trust,
37073
- network: hit.network,
37074
- method: hit.method,
37075
- transport: hit.transport,
37076
- url: hit.url,
37077
- template: hit.template,
37078
- dataClass: hit.dataClass,
37079
- site: {
37080
- file: hit.site.file,
37081
- line: hit.site.line,
37082
- dynamic: hit.site.dynamic,
37083
- vendored: hit.site.vendored
37084
- }
37085
- };
37086
- }
37087
- function toEgressIngestRequest(input2) {
37088
- const { hits, droppedFiles } = capHits(input2.hits, input2.reconcile.mode);
37089
- const reconcile = withoutDroppedFiles(input2.reconcile, droppedFiles);
37090
- return {
37091
- projectKey: hashProjectKey(input2.projectKey),
37092
- project: input2.project,
37093
- reconcile,
37094
- hits: hits.map(toIngestHit)
37095
- };
37096
- }
37292
+ import { mkdirSync as mkdirSync5, readFileSync as readFileSync19, writeFileSync as writeFileSync8 } from "fs";
37293
+ import { dirname as dirname6, join as join29 } from "path";
37097
37294
 
37098
37295
  // ../../packages/remote/src/http.ts
37099
37296
  import { request as httpRequest } from "http";
@@ -37374,6 +37571,7 @@ function createRemoteClient(options) {
37374
37571
  url: url2(ROUTES.shares),
37375
37572
  body: JSON.stringify(validated.data)
37376
37573
  });
37574
+ if (response.status === 404) throw new RemoteRouteAbsent(ROUTES.shares);
37377
37575
  okBody(response);
37378
37576
  },
37379
37577
  async pollCommand() {
@@ -37396,19 +37594,51 @@ function createRemoteClient(options) {
37396
37594
  };
37397
37595
  }
37398
37596
 
37399
- // ../../packages/plugin-runtime/src/attached/failure.ts
37597
+ // ../../packages/remote/src/failure-kind.ts
37400
37598
  function statusOf(err) {
37401
37599
  if (typeof err !== "object" || err === null || !("status" in err)) return null;
37402
37600
  const { status } = err;
37403
37601
  if (typeof status !== "number" || !Number.isInteger(status)) return null;
37404
37602
  return status >= 100 && status <= 599 ? status : null;
37405
37603
  }
37406
- function classifyFailure(err) {
37407
- switch (statusOf(err)) {
37604
+ function nameOf(err) {
37605
+ if (typeof err !== "object" || err === null || !("name" in err)) return null;
37606
+ return typeof err.name === "string" ? err.name : null;
37607
+ }
37608
+ function classifyRemoteFailure(err) {
37609
+ switch (nameOf(err)) {
37610
+ case "RemoteRouteAbsent":
37611
+ return "route-absent";
37612
+ case "RemoteRequestInvalid":
37613
+ return "invalid-request";
37614
+ case "RemoteResponseInvalid":
37615
+ return "rejected";
37616
+ default:
37617
+ break;
37618
+ }
37619
+ const status = statusOf(err);
37620
+ if (status === null) return "unreachable";
37621
+ switch (status) {
37408
37622
  case 401:
37409
37623
  return "unauthorized";
37410
37624
  case 403:
37411
37625
  return "forbidden";
37626
+ case 429:
37627
+ return "unreachable";
37628
+ case 404:
37629
+ return "unreachable";
37630
+ default:
37631
+ return status >= 400 && status <= 499 ? "rejected" : "unreachable";
37632
+ }
37633
+ }
37634
+
37635
+ // ../../packages/plugin-runtime/src/attached/failure.ts
37636
+ function classifyFailure(err) {
37637
+ switch (classifyRemoteFailure(err)) {
37638
+ case "unauthorized":
37639
+ return "unauthorized";
37640
+ case "forbidden":
37641
+ return "forbidden";
37412
37642
  default:
37413
37643
  return "unreachable";
37414
37644
  }
@@ -37430,11 +37660,11 @@ function withTimeout(promise2, ms) {
37430
37660
  }
37431
37661
 
37432
37662
  // ../../packages/plugin-runtime/src/attached/forward-drops.ts
37433
- import { readFileSync as readFileSync13 } from "fs";
37434
- import { join as join21 } from "path";
37663
+ import { readFileSync as readFileSync14 } from "fs";
37664
+ import { join as join23 } from "path";
37435
37665
  var FORWARD_DROPS_FILENAME = ATTACHED_FORWARD_DROPS_FILENAME;
37436
37666
  function forwardDropsPath(dataDir2) {
37437
- return join21(dataDir2, FORWARD_DROPS_FILENAME);
37667
+ return join23(dataDir2, FORWARD_DROPS_FILENAME);
37438
37668
  }
37439
37669
  function recordForwardDrops(dataDir2, count, nowMs) {
37440
37670
  if (count <= 0) return;
@@ -37452,7 +37682,7 @@ function recordForwardDrops(dataDir2, count, nowMs) {
37452
37682
  }
37453
37683
  function readForwardDrops(dataDir2) {
37454
37684
  try {
37455
- const parsed2 = JSON.parse(readFileSync13(forwardDropsPath(dataDir2), "utf8"));
37685
+ const parsed2 = JSON.parse(readFileSync14(forwardDropsPath(dataDir2), "utf8"));
37456
37686
  if (typeof parsed2 !== "object" || parsed2 === null) return null;
37457
37687
  const record2 = parsed2;
37458
37688
  if (typeof record2.droppedForwards !== "number" || !Number.isFinite(record2.droppedForwards)) {
@@ -37470,9 +37700,9 @@ function readForwardDrops(dataDir2) {
37470
37700
 
37471
37701
  // ../../packages/plugin-runtime/src/attached/forward-policy.ts
37472
37702
  import { randomUUID as randomUUID16 } from "crypto";
37473
- import { readFileSync as readFileSync14 } from "fs";
37703
+ import { readFileSync as readFileSync15 } from "fs";
37474
37704
  import { readFile, rename, writeFile } from "fs/promises";
37475
- import { join as join22 } from "path";
37705
+ import { join as join24 } from "path";
37476
37706
  function isInvalidRequest(err) {
37477
37707
  return typeof err === "object" && err !== null && err.name === "RemoteRequestInvalid";
37478
37708
  }
@@ -37510,7 +37740,7 @@ function parseBreakerState(raw, nowMs) {
37510
37740
  }
37511
37741
  function createForwardPolicy(deps) {
37512
37742
  const now = deps.now ?? (() => Date.now());
37513
- const file2 = join22(deps.dir, STATE_FILENAME);
37743
+ const file2 = join24(deps.dir, STATE_FILENAME);
37514
37744
  let state = null;
37515
37745
  let loading = null;
37516
37746
  async function readState() {
@@ -38232,8 +38462,8 @@ function toolAuditEvent(input2) {
38232
38462
  }
38233
38463
 
38234
38464
  // ../../packages/plugin-runtime/src/attached/history-state.ts
38235
- import { readFileSync as readFileSync15 } from "fs";
38236
- import { join as join23 } from "path";
38465
+ import { readFileSync as readFileSync16 } from "fs";
38466
+ import { join as join25 } from "path";
38237
38467
 
38238
38468
  // ../../packages/plugin-runtime/src/attached/history-sync.ts
38239
38469
  import { createHash as createHash6 } from "crypto";
@@ -38250,7 +38480,7 @@ import { fileURLToPath as fileURLToPath2 } from "url";
38250
38480
  var HISTORY_SYNC_THROTTLE_MS = 5 * 60 * 1e3;
38251
38481
 
38252
38482
  // ../../packages/plugin-runtime/src/attached/plugin-block.ts
38253
- import { readFileSync as readFileSync16 } from "fs";
38483
+ import { readFileSync as readFileSync17 } from "fs";
38254
38484
  function createPluginBlock(build, policyStore) {
38255
38485
  return async () => {
38256
38486
  const cached2 = await policyStore.read();
@@ -38269,7 +38499,7 @@ function createPluginBlock(build, policyStore) {
38269
38499
  // ../../packages/plugin-runtime/src/attached/policy-store.ts
38270
38500
  import { randomUUID as randomUUID17 } from "crypto";
38271
38501
  import { readFile as readFile2, rm, writeFile as writeFile2 } from "fs/promises";
38272
- import { join as join24 } from "path";
38502
+ import { join as join26 } from "path";
38273
38503
 
38274
38504
  // ../../packages/plugin-runtime/src/attached/atomic-publish.ts
38275
38505
  import { rename as rename2 } from "fs/promises";
@@ -38293,7 +38523,7 @@ async function publishByRename(tmp, file2, move = rename2) {
38293
38523
 
38294
38524
  // ../../packages/plugin-runtime/src/attached/policy-store.ts
38295
38525
  function createPolicyStore(dir = dataDir()) {
38296
- const file2 = join24(dir, "policy-cache.json");
38526
+ const file2 = join26(dir, "policy-cache.json");
38297
38527
  async function read() {
38298
38528
  try {
38299
38529
  const raw = await readFile2(file2, "utf8");
@@ -38524,11 +38754,11 @@ function readStorePosture(dbPath2) {
38524
38754
  // ../../packages/plugin-runtime/src/attached/posture-store.ts
38525
38755
  import { randomUUID as randomUUID18 } from "crypto";
38526
38756
  import { readFile as readFile3, rm as rm2, writeFile as writeFile3 } from "fs/promises";
38527
- import { join as join25 } from "path";
38757
+ import { join as join27 } from "path";
38528
38758
  var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
38529
38759
  function createPostureStore(dir = settingsDir(), legacyDir) {
38530
- const file2 = join25(dir, "posture-state.json");
38531
- const legacyFile = legacyDir === void 0 ? null : join25(legacyDir, "posture-state.json");
38760
+ const file2 = join27(dir, "posture-state.json");
38761
+ const legacyFile = legacyDir === void 0 ? null : join27(legacyDir, "posture-state.json");
38532
38762
  async function persist(state) {
38533
38763
  await ensureDataDir(dir);
38534
38764
  const tmp = `${file2}.${randomUUID18()}.tmp`;
@@ -38596,8 +38826,8 @@ function createPostureStore(dir = settingsDir(), legacyDir) {
38596
38826
  }
38597
38827
 
38598
38828
  // ../../packages/plugin-runtime/src/attached/sync-state.ts
38599
- import { readFileSync as readFileSync17 } from "fs";
38600
- import { join as join26 } from "path";
38829
+ import { readFileSync as readFileSync18 } from "fs";
38830
+ import { join as join28 } from "path";
38601
38831
 
38602
38832
  // ../../packages/plugin-runtime/src/attached/status.ts
38603
38833
  var REFUSAL_LINES = {
@@ -39093,7 +39323,7 @@ function markerDirs(dataDir2) {
39093
39323
  function alreadyClaimed(dirs, marker, sessionId) {
39094
39324
  return dirs.some((dir) => {
39095
39325
  try {
39096
- return readFileSync18(join27(dir, marker), "utf8") === sessionId;
39326
+ return readFileSync19(join29(dir, marker), "utf8") === sessionId;
39097
39327
  } catch {
39098
39328
  return false;
39099
39329
  }
@@ -39103,7 +39333,7 @@ function recordClaim(dirs, marker, sessionId) {
39103
39333
  for (const dir of dirs) {
39104
39334
  try {
39105
39335
  mkdirSync5(dir, { recursive: true, mode: DATA_DIR_MODE });
39106
- writeFileSync8(join27(dir, marker), sessionId, { mode: DATA_FILE_MODE });
39336
+ writeFileSync8(join29(dir, marker), sessionId, { mode: DATA_FILE_MODE });
39107
39337
  return;
39108
39338
  } catch {
39109
39339
  }