@akasecurity/ai-tc-claude-code 0.9.9 → 0.9.10

package/scripts/history-sync.js

@@ -497,6 +497,7 @@ import { createHash as createHash4 } from "crypto";
 // ../../packages/persistence/src/attached-derived.ts
 import { rmSync } from "fs";
 import { join } from "path";
+var POLICY_CACHE_FILENAME = "policy-cache.json";
 var ATTACHED_FORWARD_STATE_FILENAME = "attached-state.json";
 var ATTACHED_HISTORY_SYNC_STATE_FILENAME = "attached-history-sync.json";
 
@@ -597,6 +598,30 @@ var SQLITE_MIGRATIONS = [
   {
     tag: "0022_audit_inspection_ms",
     sql: "ALTER TABLE `audit_events` ADD `inspection_ms` integer GENERATED ALWAYS AS (json_extract(attributes, '$.inspection_ms')) VIRTUAL;"
+  },
+  {
+    tag: "0023_secret_vault_user_authorized",
+    sql: "ALTER TABLE `secret_vault` ADD `user_authorized` integer DEFAULT 0 NOT NULL;"
+  },
+  {
+    tag: "0024_finding_resolution_key_created_index",
+    sql: "DROP INDEX IF EXISTS `idx_finding_resolution_key`;--> statement-breakpoint\nCREATE INDEX `idx_finding_resolution_key_created` ON `finding_resolution` (`finding_key`,`created_at`);"
+  },
+  {
+    tag: "0025_audit_capture_attribute_columns",
+    sql: "ALTER TABLE `audit_events` ADD `source_tool` text GENERATED ALWAYS AS (json_extract(attributes, '$.source_tool')) VIRTUAL;--> statement-breakpoint\nALTER TABLE `audit_events` ADD `repo` text GENERATED ALWAYS AS (json_extract(attributes, '$.repo')) VIRTUAL;--> statement-breakpoint\nALTER TABLE `audit_events` ADD `file_path` text GENERATED ALWAYS AS (json_extract(attributes, '$.file_path')) VIRTUAL;--> statement-breakpoint\nALTER TABLE `audit_events` ADD `tool_name` text GENERATED ALWAYS AS (json_extract(attributes, '$.tool_name')) VIRTUAL;"
+  },
+  {
+    tag: "0026_audit_llm_call_usage_columns",
+    sql: "ALTER TABLE `audit_events` ADD `service_tier` text GENERATED ALWAYS AS (json_extract(attributes, '$.service_tier')) VIRTUAL;--> statement-breakpoint\nALTER TABLE `audit_events` ADD `ephemeral_1h_input_tokens` integer GENERATED ALWAYS AS (json_extract(attributes, '$.ephemeral_1h_input_tokens')) VIRTUAL;--> statement-breakpoint\nALTER TABLE `audit_events` ADD `ephemeral_5m_input_tokens` integer GENERATED ALWAYS AS (json_extract(attributes, '$.ephemeral_5m_input_tokens')) VIRTUAL;--> statement-breakpoint\nALTER TABLE `audit_events` ADD `web_search_requests` integer GENERATED ALWAYS AS (json_extract(attributes, '$.web_search_requests')) VIRTUAL;"
+  },
+  {
+    tag: "0027_audit_llm_usage_index",
+    sql: "CREATE INDEX `idx_audit_llm_usage` ON `audit_events` (`started_at`,`root_session_id`,`provider`,`model`,`service_tier`,`input_tokens`,`output_tokens`,`cache_creation_input_tokens`,`cache_read_input_tokens`,`ephemeral_1h_input_tokens`,`ephemeral_5m_input_tokens`,`web_search_requests`) WHERE event_type = 'llm_call' AND attributes IS NOT NULL;"
+  },
+  {
+    tag: "0028_activity_session_probe_indexes",
+    sql: "CREATE INDEX `idx_audit_session_prompt` ON `audit_events` (`root_session_id`) WHERE event_type = 'prompt';--> statement-breakpoint\nCREATE INDEX `idx_audit_session_share` ON `audit_events` (`root_session_id`) WHERE event_type = 'share';--> statement-breakpoint\nCREATE INDEX `idx_audit_ended_at` ON `audit_events` (`ended_at`,`root_session_id`) WHERE ended_at IS NOT NULL;--> statement-breakpoint\nCREATE INDEX `idx_audit_session_ended` ON `audit_events` (`root_session_id`,`ended_at`) WHERE ended_at IS NOT NULL;--> statement-breakpoint\n-- Expression index for the activity list's turns rollup: a live-captured\n-- session's turns are the DISTINCT `run_key` across its `llm_call` leaves, and\n-- carrying the extracted key in the index answers that count from the index\n-- alone instead of parsing every leaf's attribute bag. Written by hand, as\n-- 0013's `idx_audit_code_change_path` was: drizzle-kit cannot emit an\n-- expression containing a comma, so this index is not declared in sqlite.ts.\nCREATE INDEX `idx_audit_session_run_key` ON `audit_events` (`root_session_id`, json_extract(`attributes`, '$.run_key')) WHERE `event_type` = 'llm_call';\n"
   }
 ];
 
@@ -22136,6 +22161,26 @@ var AttachTokenResponse = external_exports.union([
   AttachTokenExpired,
   external_exports.object({ status: printable(64) })
 ]);
+var DeviceCommandKind = external_exports.enum(["shares_rescan"]);
+var DeviceCommand = external_exports.object({
+  id: printable(128).min(1),
+  kind: DeviceCommandKind,
+  issuedAt: printable(64).min(1),
+  expiresAt: printable(64).min(1)
+}).strict();
+var DeviceCommandPollResponse = external_exports.object({ command: DeviceCommand.nullable() });
+var DeviceCommandFailureReason = external_exports.enum(["scan_failed", "no_projects", "expired"]);
+var DeviceCommandAckBody = external_exports.discriminatedUnion("outcome", [
+  external_exports.object({
+    outcome: external_exports.literal("reported"),
+    projectsScanned: external_exports.number().int().nonnegative()
+  }).strict(),
+  external_exports.object({
+    outcome: external_exports.literal("failed"),
+    reason: DeviceCommandFailureReason,
+    projectsScanned: external_exports.number().int().nonnegative()
+  }).strict()
+]);
 
 // ../../packages/schema/src/zod/registry.ts
 var Namespace = external_exports.string().regex(/^[a-z][a-z0-9-]*$/);
@@ -22302,7 +22347,7 @@ var PackManifest = external_exports.object({
 }).meta({ id: "PackManifest" });
 
 // ../../packages/schema/src/zod/detection.ts
-var OriginEnum = external_exports.enum(["library"]).meta({ id: "OriginEnum" });
+var OriginEnum = external_exports.enum(["library", "custom"]).meta({ id: "OriginEnum" });
 var DetectionFilterEnum = external_exports.enum(["all", "library", "custom", "customized", "updates"]);
 var LibraryStateEnum = external_exports.enum(["new", "imported", "update"]).meta({ id: "LibraryStateEnum" });
 var DetectionCounts = external_exports.object({
@@ -22439,14 +22484,17 @@ function optional2(key, parsed2, raw) {
 function isStringArray(value) {
   return Array.isArray(value) && value.every((entry) => typeof entry === "string");
 }
+var ORIGIN_VALUES = { library: true, custom: true };
+function resolveOrigin(origin) {
+  return origin != null && Object.hasOwn(ORIGIN_VALUES, origin) ? origin : "library";
+}
 function summaryToDetectionListItem(s) {
   return {
     id: `${s.namespace}/${s.packId}`,
     name: s.name,
     version: s.version,
     enabled: s.enabled,
-    origin: "library",
-    // v1: every installed pack is library origin
+    origin: resolveOrigin(s.origin),
     namespace: s.namespace,
     packId: s.packId,
     ruleCount: s.ruleCount,
@@ -22498,7 +22546,7 @@ function rowToDetectionDetail(row, findingsLast30d, update) {
     name: row.name,
     version: row.version,
     enabled: row.enabled,
-    origin: "library",
+    origin: resolveOrigin(row.origin),
     namespace: row.namespace,
     packId: row.packId,
     ruleCount: row.rules.length,
@@ -22518,16 +22566,20 @@ function splitDetectionId(id) {
 }
 function buildDetectionsList(summaries, query) {
   const withUpdate = summaries.filter((s) => s.latestVersion != null);
+  const originOf = (s) => resolveOrigin(s.origin);
   const counts = {
     all: summaries.length,
-    library: summaries.length,
-    // all origin=library in v1
-    custom: 0,
+    library: summaries.filter((s) => originOf(s) === "library").length,
+    custom: summaries.filter((s) => originOf(s) === "custom").length,
+    // No origin member produces this, so it is 0 BY CONSTRUCTION rather than by
+    // omission: `customized` would mean a LIBRARY pack whose rules were edited in
+    // place, and that state does not exist — editing a library pack forks it. See
+    // OriginEnum.
     customized: 0,
     updates: withUpdate.length
   };
   const filter = query.filter;
-  let filtered = filter === "custom" || filter === "customized" ? [] : filter === "updates" ? [...withUpdate] : [...summaries];
+  let filtered = filter === "customized" ? [] : filter === "custom" ? summaries.filter((s) => originOf(s) === "custom") : filter === "library" ? summaries.filter((s) => originOf(s) === "library") : filter === "updates" ? [...withUpdate] : [...summaries];
   if (query.q) {
     const q = query.q.toLowerCase();
     filtered = filtered.filter(
@@ -22607,8 +22659,9 @@ var Event = external_exports.object({
   metadata: EventMetadata.optional()
 }).meta({ id: "Event" });
 var IngestEvent = Event.meta({ id: "IngestEvent" });
+var INGEST_BATCH_MAX = 100;
 var IngestBatch = external_exports.object({
-  events: external_exports.array(IngestEvent).min(1).max(100),
+  events: external_exports.array(IngestEvent).min(1).max(INGEST_BATCH_MAX),
   // Dedup policy for this batch. Id-dedup ALWAYS applies. 'content-hash'
   // additionally rejects any event whose contentHash the store has already
   // recorded — for re-runnable bulk ingest (worktree scan, transcript
@@ -23164,6 +23217,252 @@ var PatchInstalledPackRequest = external_exports.object({
   message: "At least one field must be provided"
 }).meta({ id: "PatchInstalledPackRequest" });
 
+// ../../packages/schema/src/zod/policy.ts
+var PolicyScope = external_exports.enum(["global", "repo", "user"]).meta({ id: "PolicyScope" });
+var PolicyTarget = external_exports.union([external_exports.object({ ruleId: external_exports.string() }), external_exports.object({ category: DetectionCategory })]).meta({ id: "PolicyTarget" });
+var PolicyKind = external_exports.enum(["builtin", "custom"]).meta({ id: "PolicyKind" });
+var PolicyProvenance = external_exports.enum(["builtin", "authored"]).meta({ id: "PolicyProvenance" });
+var Policy = external_exports.object({
+  id: external_exports.guid(),
+  scope: PolicyScope,
+  target: PolicyTarget,
+  action: ActionTaken,
+  enabled: external_exports.boolean().default(true),
+  customKeywords: external_exports.array(external_exports.string()).optional(),
+  // Display name — optional so older policy rows without name still parse.
+  // Added for the findings API (policy.name column migration).
+  name: external_exports.string().optional(),
+  // Whether an AUTHORED policy governs this row's target — not a claim about
+  // which row this is. A producer that collapses several rows onto one target
+  // must carry the marker onto whichever row survives, or the collapse decides
+  // the answer; a survivor may therefore be a built-in expansion still marked
+  // 'authored' because an authored sibling targeted the same thing.
+  // Optional so an older producer — and an older on-disk cache — still parses;
+  // absent reads as 'builtin', which is the behaviour that predates the field.
+  //
+  // Deliberately NOT `kind`/PolicyKind: that name and that enum answer which
+  // built-in archetype catalog entry a policy is, which every catalog surface
+  // reads and which a caller may state. This one is a statement the PRODUCER
+  // of a bundle makes about a row, and only the bundle builder ever stamps it
+  // — the CRUD routes neither accept nor set it.
+  //
+  // A device consumes this in exactly one direction: an 'authored' policy
+  // arriving from a control plane marks the rules it targets as not
+  // locally re-assignable. That can only ever ADD a refusal, never relax one,
+  // which is what makes it safe to honour from an unsigned cache — the same
+  // test `prohibitedModels` passes and `reversibleRuleIds` fails.
+  provenance: PolicyProvenance.optional()
+}).meta({ id: "Policy" });
+var PolicyBundle = external_exports.object({
+  version: external_exports.string(),
+  policies: external_exports.array(Policy),
+  // Rules from the installed marketplace packs (snapshotted by the
+  // control plane). The plugin registers these in addition to its bundled
+  // packs. Optional so older backends — and older on-disk caches — that omit
+  // the field still parse; consumers read `bundle.rules ?? []`.
+  rules: external_exports.array(Rule).optional(),
+  // When true, `rules` IS the complete effective ruleset and the runtime must
+  // NOT merge its compiled-in bundled packs — the standalone gateway sets this
+  // after reading the user's installed snapshot (installed_packs, enabled
+  // packs only), which is how detection updates stay manual: new bundled
+  // rules run only after the user applies the pack update. Absent/false keeps
+  // the historical composition (bundled packs + rules) — older caches.
+  rulesComplete: external_exports.boolean().optional(),
+  // Active detection exceptions, evaluation subset only (see
+  // ExceptionBundleEntry). Optional so older bundle producers — and older
+  // on-disk caches — that omit the field still parse; consumers read
+  // `bundle.exceptions ?? []`.
+  exceptions: external_exports.array(ExceptionBundleEntry).optional(),
+  // Rule ids whose pack is assigned a REVERSIBLE archetype (Redact & Vault).
+  // A second axis over the same `redact` action, carried beside the policies
+  // rather than on them: nothing writes ruleId-targeted policies to disk, so
+  // widening Policy itself would change a persisted shape to express something
+  // only the in-memory bundle needs. Optional so an older producer — or an
+  // older on-disk cache — still parses; consumers read `?? []` and get the
+  // pre-existing one-way behaviour, which is the safe direction to default.
+  reversibleRuleIds: external_exports.array(external_exports.string()).optional(),
+  // Installed pack version, keyed by ruleId, for rules in `rules` that came
+  // from a versioned installed pack. Optional so older backends — and older
+  // on-disk caches — that omit the field still parse; consumers fall back to
+  // the rule's own spec version. NOT the bundle version above — see
+  // installedRuleset's ruleVersions for the source of truth.
+  ruleVersions: external_exports.record(external_exports.string(), external_exports.string()).optional(),
+  // Model ids (the raw `model` string a harness reports, e.g.
+  // `claude-opus-4-1`) the tenant has PROHIBITED. The plugin refuses to switch
+  // a session onto one (PreModelSwitch) and refuses a turn that would run on
+  // one (UserPromptSubmit). Optional so an older backend — and an older
+  // on-disk cache — still parses; consumers read `?? []`, which is the
+  // unenforced behaviour that predates this field and the safe direction to
+  // default.
+  //
+  // Ids, not display names: the governance decision is keyed on the exact
+  // string the harness reports (`model_status_override.versionId` in the
+  // control plane), so no name resolution stands between the decision and the
+  // comparison.
+  prohibitedModels: external_exports.array(external_exports.string()).optional(),
+  customKeywords: external_exports.array(external_exports.string()),
+  fetchedAt: external_exports.iso.datetime()
+}).meta({ id: "PolicyBundle" });
+var POLICY_BUNDLE_SHAPE_ID = [
+  ...Object.keys(PolicyBundle.shape),
+  ...Object.keys(Policy.shape).map((key) => `policies.${key}`),
+  ...PolicyTarget.options.flatMap((member) => "shape" in member ? Object.keys(member.shape) : []).map((key) => `policies.target.${key}`),
+  ...Object.keys(ExceptionBundleEntry.shape).map((key) => `exceptions.${key}`)
+].sort().join(",");
+var OBSERVE_ONLY_CATEGORIES = ["config"];
+var ENFORCEABLE_CATEGORIES = DetectionCategory.options.filter((c) => !OBSERVE_ONLY_CATEGORIES.includes(c));
+var CATEGORY_PEAK_SEVERITY = {
+  secret: "critical",
+  financial: "critical",
+  // core-financial/credit-card
+  code_flaw: "critical",
+  pii: "high",
+  phi: "high",
+  custom: "high",
+  // user-defined; conservative
+  code_context: "low",
+  config: "low"
+  // observe-only; floors to monitor regardless
+};
+function severityFloorPolicy(category) {
+  if (OBSERVE_ONLY_CATEGORIES.includes(category)) return "monitor";
+  const peak = CATEGORY_PEAK_SEVERITY[category];
+  return peak === "critical" || peak === "high" ? "warn" : "monitor";
+}
+var KNOWN_BUILTIN_IDS = ["monitor", "warn", "redact", "vault", "block"];
+var BuiltinPolicyId = external_exports.enum(KNOWN_BUILTIN_IDS).meta({ id: "BuiltinPolicyId" });
+var RedactFallback = BuiltinPolicyId.extract(["monitor", "warn", "block"]).meta({
+  id: "RedactFallback"
+});
+var BUILTIN_ORDER = KNOWN_BUILTIN_IDS;
+var BUILTIN_POLICY_SPECS = {
+  monitor: {
+    name: "Monitor",
+    action: "log",
+    reversible: false,
+    description: "Log every match for audit. The request is allowed through untouched."
+  },
+  warn: {
+    name: "Warn",
+    action: "warn",
+    reversible: false,
+    description: "Allow the request, but warn the user inline before it is sent."
+  },
+  redact: {
+    name: "Redact",
+    action: "redact",
+    reversible: false,
+    description: "Strip the matched value from the request and destroy it, then continue. What was removed cannot be recovered."
+  },
+  vault: {
+    name: "Redact & Vault",
+    action: "redact",
+    reversible: true,
+    description: "Strip the matched value from the request and keep an encrypted, recoverable copy in the local vault, leaving a pointer in its place. Needs the vault consent granted under Settings; without it this behaves as Redact."
+  },
+  block: {
+    name: "Block",
+    action: "block",
+    reversible: false,
+    description: "Refuse the request entirely whenever any rule in this detection matches."
+  }
+};
+function builtinPolicyToAction(id) {
+  return BUILTIN_POLICY_SPECS[id].action;
+}
+var PALETTE_WEAKEST_FIRST = [
+  ...new Set(KNOWN_BUILTIN_IDS.map(builtinPolicyToAction))
+];
+var BELOW_PALETTE = ACTION_TAKEN_KEYS.filter(
+  (action) => !PALETTE_WEAKEST_FIRST.includes(action)
+);
+var ACTION_STRENGTH_ORDER = [
+  ...BELOW_PALETTE,
+  ...PALETTE_WEAKEST_FIRST
+];
+function actionRank(action) {
+  return ACTION_STRENGTH_ORDER.indexOf(action);
+}
+function isActionAtLeast(action, floor) {
+  return actionRank(action) >= actionRank(floor);
+}
+function strongerAction(a, b) {
+  return actionRank(a) >= actionRank(b) ? a : b;
+}
+function weakestBuiltinAtLeast(floor) {
+  return KNOWN_BUILTIN_IDS.find((id) => isActionAtLeast(builtinPolicyToAction(id), floor)) ?? "block";
+}
+var PackPolicyFloor = external_exports.object({
+  /**
+   * The weakest archetype the device may assign. Stated as a BuiltinPolicyId
+   * rather than a raw ActionTaken because that is the vocabulary the user
+   * picks from — a floor a UI cannot name is one it cannot explain.
+   */
+  floor: BuiltinPolicyId,
+  /**
+   * True when the organization AUTHORED a policy governing this pack rather
+   * than stating a minimum: it gave the answer, so the pack is not
+   * re-assignable locally in either direction.
+   */
+  locked: external_exports.boolean()
+}).describe("PackPolicyFloor");
+var CATEGORY_EXPRESSIBLE_IDS = KNOWN_BUILTIN_IDS.filter(
+  (id) => !BUILTIN_POLICY_SPECS[id].reversible
+);
+var CATEGORY_INEXPRESSIBLE_IDS = KNOWN_BUILTIN_IDS.filter(
+  (id) => BUILTIN_POLICY_SPECS[id].reversible
+);
+var CategoryPolicyId = external_exports.enum(CATEGORY_EXPRESSIBLE_IDS).meta({ id: "CategoryPolicyId" });
+function builtinPolicyIsReversible(id) {
+  return BUILTIN_POLICY_SPECS[id].reversible;
+}
+function policyIdIsReversible(policyId) {
+  const parsed2 = BuiltinPolicyId.safeParse(policyId ?? DEFAULT_PACK_POLICY_ID);
+  const id = parsed2.success ? parsed2.data : DEFAULT_PACK_POLICY_ID;
+  return builtinPolicyIsReversible(id);
+}
+var DEFAULT_ACTIONS = Object.fromEntries(
+  DetectionCategory.options.map((c) => [c, builtinPolicyToAction(severityFloorPolicy(c))])
+);
+var BUILTIN_POLICIES = Object.fromEntries(
+  KNOWN_BUILTIN_IDS.map((id) => [id, { id, ...BUILTIN_POLICY_SPECS[id] }])
+);
+var DEFAULT_PACK_POLICY_ID = "monitor";
+function policyIdToAction(policyId) {
+  const parsed2 = BuiltinPolicyId.safeParse(policyId ?? DEFAULT_PACK_POLICY_ID);
+  const id = parsed2.success ? parsed2.data : DEFAULT_PACK_POLICY_ID;
+  return BUILTIN_POLICIES[id].action;
+}
+var UsedByItem = external_exports.object({
+  id: external_exports.string(),
+  name: external_exports.string(),
+  ruleCount: external_exports.number().int().nonnegative(),
+  enabled: external_exports.boolean()
+}).meta({ id: "UsedByItem" });
+var PolicyListItem = external_exports.object({
+  id: external_exports.string(),
+  kind: PolicyKind,
+  name: external_exports.string(),
+  enabled: external_exports.boolean(),
+  usedByCount: external_exports.number().int().nonnegative()
+}).meta({ id: "PolicyListItem" });
+var ListPoliciesResponse = external_exports.object({ items: external_exports.array(PolicyListItem) }).meta({ id: "ListPoliciesResponse" });
+var PolicyDetail = external_exports.object({
+  specVersion: external_exports.literal(1),
+  id: external_exports.string(),
+  kind: PolicyKind,
+  name: external_exports.string(),
+  enabled: external_exports.boolean(),
+  description: external_exports.string(),
+  usedBy: external_exports.array(UsedByItem)
+}).meta({ id: "PolicyDetail" });
+var PolicyStatsResponse = external_exports.object({
+  policies: external_exports.number().int().nonnegative(),
+  builtin: external_exports.number().int().nonnegative(),
+  custom: external_exports.number().int().nonnegative(),
+  detectionsGoverned: external_exports.number().int().nonnegative()
+}).meta({ id: "PolicyStatsResponse" });
+
 // ../../packages/schema/src/zod/vault.ts
 var POINTER_FORMAT_VERSION = 2;
 var CATEGORY_ALTERNATION = DetectionCategory.options.join("|");
@@ -23201,6 +23500,14 @@ var VaultEntry = external_exports.object({
   // How many times this value has been detected on this machine — the reuse
   // signal the vault dashboard reads. Distinct from VaultDeref.pointerCount.
   occurrenceCount: external_exports.number().int().nonnegative(),
+  // True when a PERSON asked for this value to be replaced — the surfaced-
+  // secrets strike — rather than a pack enforcing its assignment. One value is
+  // one row however many paths vault it, so this is what tells a policy sweep
+  // that the row carries somebody's own instruction and not just an assignment
+  // that has since been lowered. STICKY and MONOTONIC: a later automatic
+  // vaulting of the same value must never clear it — what the user said about
+  // the value does not expire.
+  userAuthorized: external_exports.boolean(),
   firstSeen: external_exports.string(),
   lastSeen: external_exports.string()
 });
@@ -23319,9 +23626,9 @@ var VaultConsent = external_exports.object({
 });
 
 // ../../packages/schema/src/zod/local.ts
-var WORKSPACE_SETTINGS_SPEC_VERSION = 6;
+var WORKSPACE_SETTINGS_SPEC_VERSION = 7;
 var MODEL_JUDGE_PAYLOAD_VERSION = 1;
-var HISTORY_SYNC_PAYLOAD_VERSION = 1;
+var HISTORY_SYNC_PAYLOAD_VERSION = 2;
 var RunMode = external_exports.enum(["standalone", "attached"]);
 var ControlPlaneConnection = external_exports.object({
   endpoint: external_exports.string().min(1),
@@ -23366,6 +23673,19 @@ var WorkspaceSettings = external_exports.object({
   vaultKeyCustody: VaultKeyCustody.default("file"),
   // How a pointer renders in assistant prose on screen (see VaultInlineReveal).
   vaultInlineReveal: VaultInlineReveal.default("masked"),
+  // What a `redact` policy degrades to on a FIELD the host cannot rewrite in
+  // place. Not a handling policy: the policy has already resolved to redact,
+  // and this only says what happens when the host offers no channel to carry it
+  // out — Antigravity's PreToolUse has no updatedInput at all, and Codex and
+  // Claude Code decline to mask a field that EXECUTES because masking would
+  // change what runs. Per FIELD rather than per host, so a host that can
+  // rewrite some inputs keeps true redaction on those.
+  //
+  // Spelled in the built-in policy vocabulary rather than as a fresh enum, so
+  // an attached machine's merge is `strongerAction` over the one action ladder
+  // and no second rank order exists to drift from it. 'deny' is a host wire
+  // word and stays out of the stored value.
+  redactFallback: RedactFallback.default("warn"),
   // Absent until /aka:setup completes; its presence is what "onboarded" means.
   onboardedAt: external_exports.iso.datetime().optional(),
   // Records that the user consented to sending findings to the model API for
@@ -23373,10 +23693,12 @@ var WorkspaceSettings = external_exports.object({
   // Absent until granted; a stale payloadVersion means the consent no longer
   // covers the current payload and must be re-granted.
   modelJudgeConsent: ModelJudgeConsent.optional(),
-  // Records that the user consented to sending the activity already recorded on
-  // this machine to the deployment it is attached to, along with the payload
-  // shape and the endpoint they agreed to. Absent until granted, and a grant for
-  // a different endpoint or an older payload no longer counts.
+  // Records that the user consented to the DEFERRED send — the outbox — along
+  // with the payload shape and the endpoint they agreed to. Since payload v2
+  // that covers both the pre-attach backlog and undelivered captures (which
+  // carry prompt/reply text in `content`); the key name predates the widening.
+  // Absent until granted, and a grant for a different endpoint or an older
+  // payload no longer counts.
   historySyncConsent: HistorySyncConsent.optional()
 });
 function defaultWorkspaceSettings() {
@@ -23504,7 +23826,8 @@ var ManagedSettingKey = external_exports.enum([
   "vaultKeyCustody",
   "vaultInlineReveal",
   "modelJudgeConsent",
-  "dataSharesInPlace"
+  "dataSharesInPlace",
+  "redactFallback"
 ]).meta({ id: "ManagedSettingKey" });
 var ManagedSettingsValues = external_exports.object({
   runMode: external_exports.enum(["standalone", "attached"]).optional(),
@@ -23517,7 +23840,8 @@ var ManagedSettingsValues = external_exports.object({
   vaultKeyCustody: external_exports.enum(["file", "keychain"]).optional(),
   vaultInlineReveal: external_exports.enum(["masked", "full", "off"]).optional(),
   modelJudgeConsent: external_exports.boolean().optional(),
-  dataSharesInPlace: external_exports.boolean().optional()
+  dataSharesInPlace: external_exports.boolean().optional(),
+  redactFallback: RedactFallback.optional()
 }).meta({ id: "ManagedSettingsValues" });
 var ManagedSettings = external_exports.object({
   specVersion: external_exports.number().int().positive().default(MANAGED_SETTINGS_SPEC_VERSION),
@@ -23532,186 +23856,6 @@ var ManagedSettings = external_exports.object({
   lockedFields: external_exports.array(ManagedSettingKey).default([])
 }).meta({ id: "ManagedSettings" });
 
-// ../../packages/schema/src/zod/policy.ts
-var PolicyScope = external_exports.enum(["global", "repo", "user"]).meta({ id: "PolicyScope" });
-var PolicyTarget = external_exports.union([external_exports.object({ ruleId: external_exports.string() }), external_exports.object({ category: DetectionCategory })]).meta({ id: "PolicyTarget" });
-var Policy = external_exports.object({
-  id: external_exports.guid(),
-  scope: PolicyScope,
-  target: PolicyTarget,
-  action: ActionTaken,
-  enabled: external_exports.boolean().default(true),
-  customKeywords: external_exports.array(external_exports.string()).optional(),
-  // Display name — optional so older policy rows without name still parse.
-  // Added for the findings API (policy.name column migration).
-  name: external_exports.string().optional()
-}).meta({ id: "Policy" });
-var PolicyBundle = external_exports.object({
-  version: external_exports.string(),
-  policies: external_exports.array(Policy),
-  // Rules from the installed marketplace packs (snapshotted by the
-  // control plane). The plugin registers these in addition to its bundled
-  // packs. Optional so older backends — and older on-disk caches — that omit
-  // the field still parse; consumers read `bundle.rules ?? []`.
-  rules: external_exports.array(Rule).optional(),
-  // When true, `rules` IS the complete effective ruleset and the runtime must
-  // NOT merge its compiled-in bundled packs — the standalone gateway sets this
-  // after reading the user's installed snapshot (installed_packs, enabled
-  // packs only), which is how detection updates stay manual: new bundled
-  // rules run only after the user applies the pack update. Absent/false keeps
-  // the historical composition (bundled packs + rules) — older caches.
-  rulesComplete: external_exports.boolean().optional(),
-  // Active detection exceptions, evaluation subset only (see
-  // ExceptionBundleEntry). Optional so older bundle producers — and older
-  // on-disk caches — that omit the field still parse; consumers read
-  // `bundle.exceptions ?? []`.
-  exceptions: external_exports.array(ExceptionBundleEntry).optional(),
-  // Rule ids whose pack is assigned a REVERSIBLE archetype (Redact & Vault).
-  // A second axis over the same `redact` action, carried beside the policies
-  // rather than on them: nothing writes ruleId-targeted policies to disk, so
-  // widening Policy itself would change a persisted shape to express something
-  // only the in-memory bundle needs. Optional so an older producer — or an
-  // older on-disk cache — still parses; consumers read `?? []` and get the
-  // pre-existing one-way behaviour, which is the safe direction to default.
-  reversibleRuleIds: external_exports.array(external_exports.string()).optional(),
-  // Installed pack version, keyed by ruleId, for rules in `rules` that came
-  // from a versioned installed pack. Optional so older backends — and older
-  // on-disk caches — that omit the field still parse; consumers fall back to
-  // the rule's own spec version. NOT the bundle version above — see
-  // installedRuleset's ruleVersions for the source of truth.
-  ruleVersions: external_exports.record(external_exports.string(), external_exports.string()).optional(),
-  // Model ids (the raw `model` string a harness reports, e.g.
-  // `claude-opus-4-1`) the tenant has PROHIBITED. The plugin refuses to switch
-  // a session onto one (PreModelSwitch) and refuses a turn that would run on
-  // one (UserPromptSubmit). Optional so an older backend — and an older
-  // on-disk cache — still parses; consumers read `?? []`, which is the
-  // unenforced behaviour that predates this field and the safe direction to
-  // default.
-  //
-  // Ids, not display names: the governance decision is keyed on the exact
-  // string the harness reports (`model_status_override.versionId` in the
-  // control plane), so no name resolution stands between the decision and the
-  // comparison.
-  prohibitedModels: external_exports.array(external_exports.string()).optional(),
-  customKeywords: external_exports.array(external_exports.string()),
-  fetchedAt: external_exports.iso.datetime()
-}).meta({ id: "PolicyBundle" });
-var OBSERVE_ONLY_CATEGORIES = ["config"];
-var ENFORCEABLE_CATEGORIES = DetectionCategory.options.filter((c) => !OBSERVE_ONLY_CATEGORIES.includes(c));
-var CATEGORY_PEAK_SEVERITY = {
-  secret: "critical",
-  financial: "critical",
-  // core-financial/credit-card
-  code_flaw: "critical",
-  pii: "high",
-  phi: "high",
-  custom: "high",
-  // user-defined; conservative
-  code_context: "low",
-  config: "low"
-  // observe-only; floors to monitor regardless
-};
-function severityFloorPolicy(category) {
-  if (OBSERVE_ONLY_CATEGORIES.includes(category)) return "monitor";
-  const peak = CATEGORY_PEAK_SEVERITY[category];
-  return peak === "critical" || peak === "high" ? "warn" : "monitor";
-}
-var PolicyKind = external_exports.enum(["builtin", "custom"]).meta({ id: "PolicyKind" });
-var KNOWN_BUILTIN_IDS = ["monitor", "warn", "redact", "vault", "block"];
-var BuiltinPolicyId = external_exports.enum(KNOWN_BUILTIN_IDS).meta({ id: "BuiltinPolicyId" });
-var BUILTIN_ORDER = KNOWN_BUILTIN_IDS;
-var BUILTIN_POLICY_SPECS = {
-  monitor: {
-    name: "Monitor",
-    action: "log",
-    reversible: false,
-    description: "Log every match for audit. The request is allowed through untouched."
-  },
-  warn: {
-    name: "Warn",
-    action: "warn",
-    reversible: false,
-    description: "Allow the request, but warn the user inline before it is sent."
-  },
-  redact: {
-    name: "Redact",
-    action: "redact",
-    reversible: false,
-    description: "Strip the matched value from the request and destroy it, then continue. What was removed cannot be recovered."
-  },
-  vault: {
-    name: "Redact & Vault",
-    action: "redact",
-    reversible: true,
-    description: "Strip the matched value from the request and keep an encrypted, recoverable copy in the local vault, leaving a pointer in its place. Needs the vault consent granted under Settings; without it this behaves as Redact."
-  },
-  block: {
-    name: "Block",
-    action: "block",
-    reversible: false,
-    description: "Refuse the request entirely whenever any rule in this detection matches."
-  }
-};
-function builtinPolicyToAction(id) {
-  return BUILTIN_POLICY_SPECS[id].action;
-}
-var CATEGORY_EXPRESSIBLE_IDS = KNOWN_BUILTIN_IDS.filter(
-  (id) => !BUILTIN_POLICY_SPECS[id].reversible
-);
-var CATEGORY_INEXPRESSIBLE_IDS = KNOWN_BUILTIN_IDS.filter(
-  (id) => BUILTIN_POLICY_SPECS[id].reversible
-);
-var CategoryPolicyId = external_exports.enum(CATEGORY_EXPRESSIBLE_IDS).meta({ id: "CategoryPolicyId" });
-function builtinPolicyIsReversible(id) {
-  return BUILTIN_POLICY_SPECS[id].reversible;
-}
-function policyIdIsReversible(policyId) {
-  const parsed2 = BuiltinPolicyId.safeParse(policyId ?? DEFAULT_PACK_POLICY_ID);
-  const id = parsed2.success ? parsed2.data : DEFAULT_PACK_POLICY_ID;
-  return builtinPolicyIsReversible(id);
-}
-var DEFAULT_ACTIONS = Object.fromEntries(
-  DetectionCategory.options.map((c) => [c, builtinPolicyToAction(severityFloorPolicy(c))])
-);
-var BUILTIN_POLICIES = Object.fromEntries(
-  KNOWN_BUILTIN_IDS.map((id) => [id, { id, ...BUILTIN_POLICY_SPECS[id] }])
-);
-var DEFAULT_PACK_POLICY_ID = "monitor";
-function policyIdToAction(policyId) {
-  const parsed2 = BuiltinPolicyId.safeParse(policyId ?? DEFAULT_PACK_POLICY_ID);
-  const id = parsed2.success ? parsed2.data : DEFAULT_PACK_POLICY_ID;
-  return BUILTIN_POLICIES[id].action;
-}
-var UsedByItem = external_exports.object({
-  id: external_exports.string(),
-  name: external_exports.string(),
-  ruleCount: external_exports.number().int().nonnegative(),
-  enabled: external_exports.boolean()
-}).meta({ id: "UsedByItem" });
-var PolicyListItem = external_exports.object({
-  id: external_exports.string(),
-  kind: PolicyKind,
-  name: external_exports.string(),
-  enabled: external_exports.boolean(),
-  usedByCount: external_exports.number().int().nonnegative()
-}).meta({ id: "PolicyListItem" });
-var ListPoliciesResponse = external_exports.object({ items: external_exports.array(PolicyListItem) }).meta({ id: "ListPoliciesResponse" });
-var PolicyDetail = external_exports.object({
-  specVersion: external_exports.literal(1),
-  id: external_exports.string(),
-  kind: PolicyKind,
-  name: external_exports.string(),
-  enabled: external_exports.boolean(),
-  description: external_exports.string(),
-  usedBy: external_exports.array(UsedByItem)
-}).meta({ id: "PolicyDetail" });
-var PolicyStatsResponse = external_exports.object({
-  policies: external_exports.number().int().nonnegative(),
-  builtin: external_exports.number().int().nonnegative(),
-  custom: external_exports.number().int().nonnegative(),
-  detectionsGoverned: external_exports.number().int().nonnegative()
-}).meta({ id: "PolicyStatsResponse" });
-
 // ../../packages/schema/src/zod/project-files.ts
 var ProjectFileInput = external_exports.object({
   path: external_exports.string().min(1),
@@ -23957,10 +24101,12 @@ var DismissRecommendedActionResponse = external_exports.object({ id: external_ex
 var RecommendedActionIdParam = external_exports.object({ id: external_exports.string() });
 
 // ../../packages/schema/src/zod/settings-action.ts
+var HistorySyncConsentChoice = external_exports.enum(["granted", "revoked", "unchanged"]).meta({ id: "HistorySyncConsentChoice" });
+var ModelJudgeConsentChoice = external_exports.enum(["granted", "revoked", "unchanged"]).meta({ id: "ModelJudgeConsentChoice" });
 var SaveSettingsInput = external_exports.object({
   historicalAccess: external_exports.string(),
-  modelJudgeConsent: external_exports.boolean(),
-  historySyncConsent: external_exports.boolean(),
+  modelJudgeConsent: ModelJudgeConsentChoice,
+  historySyncConsent: HistorySyncConsentChoice,
   vaultConsent: external_exports.string(),
   vaultInlineReveal: external_exports.string()
 });
@@ -24110,9 +24256,9 @@ function deriveReviewReasons(trust, transports) {
   if (transports.includes("http") || transports.includes("ws")) reasons.push("plaintext_transport");
   return reasons;
 }
-function buildReviewInfo(trust, transports) {
+function buildReviewInfo(trust, transports, decided) {
   const reasons = deriveReviewReasons(trust, transports);
-  return { needsReview: reasons.length > 0, reasons };
+  return { needsReview: reasons.length > 0 && !decided, reasons };
 }
 function distinctTransports(transports) {
   return Array.from(new Set(transports));
@@ -24269,8 +24415,8 @@ function readControlPlaneCredentialFile(settingsDir2, connection) {
 }
 
 // ../../packages/persistence/src/database.ts
-import { randomUUID as randomUUID10 } from "crypto";
-import { join as join4, sep } from "path";
+import { randomUUID as randomUUID11 } from "crypto";
+import { dirname as dirname2, join as join7, sep } from "path";
 import { DatabaseSync } from "node:sqlite";
 
 // ../../packages/persistence/src/ids.ts
@@ -24303,6 +24449,16 @@ function captureId(sessionId, contentHash, filePath = null) {
     canonicalIdentity(["capture", sessionId ?? NO_SESSION, contentHash, filePath ?? NO_PATH])
   );
 }
+function uuidFromDigest(digest) {
+  const h = digest.slice(0, 32);
+  const version2 = "8";
+  const variant = (Number.parseInt(h.charAt(16), 16) & 3 | 8).toString(16);
+  const b = h.slice(0, 12) + version2 + h.slice(13, 16) + variant + h.slice(17, 32);
+  return `${b.slice(0, 8)}-${b.slice(8, 12)}-${b.slice(12, 16)}-${b.slice(16, 20)}-${b.slice(20, 32)}`;
+}
+function captureWireId(sessionId, contentHash, filePath = null) {
+  return uuidFromDigest(captureId(sessionId, contentHash, filePath));
+}
 
 // ../../packages/persistence/src/internal/snapshot.ts
 import { randomUUID } from "crypto";
@@ -24514,6 +24670,10 @@ function allRows(stmt, params) {
   if (Array.isArray(params)) return stmt.all(...params);
   return stmt.all(params);
 }
+function* iterateRows(stmt, params) {
+  const rows = params === void 0 ? stmt.iterate() : Array.isArray(params) ? stmt.iterate(...params) : stmt.iterate(params);
+  for (const row of rows) yield row;
+}
 function getRow(stmt, params) {
   if (params === void 0) return stmt.get();
   if (Array.isArray(params)) return stmt.get(...params);
@@ -24982,10 +25142,17 @@ function ensureSyncedAtColumn(db, table) {
   if (!columns.includes("sync_claimed_at")) {
     db.exec(`ALTER TABLE ${table} ADD COLUMN sync_claimed_at integer`);
   }
+  if (!columns.includes("outbox_owed")) {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN outbox_owed integer`);
+  }
   db.exec(
     `CREATE INDEX IF NOT EXISTS idx_audit_events_sync
        ON audit_events (event_type, synced_at, sync_claimed_at, started_at)`
   );
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS idx_audit_outbox_owed
+       ON audit_events (event_type, synced_at, sync_claimed_at, started_at) WHERE outbox_owed = 1`
+  );
   db.exec(
     `CREATE INDEX IF NOT EXISTS idx_audit_claimed
        ON audit_events (sync_claimed_at) WHERE sync_claimed_at IS NOT NULL`
@@ -25090,7 +25257,6 @@ function decodeKeysetCursor(cursor) {
 // ../../packages/persistence/src/repositories/activity.ts
 var DAY_MS = 864e5;
 var LIVE_ACTIVITY_WINDOW_MS = 30 * 6e4;
-var LAST_ACTIVITY_EXPR = `max(started_at, coalesce(ended_at, started_at))`;
 function defaultTimeZone() {
   try {
     return Intl.DateTimeFormat().resolvedOptions().timeZone;
@@ -25145,6 +25311,7 @@ var DB_EVENT_TYPE_TO_KIND = {
   error: "error",
   active: "active"
 };
+var TIMELINE_EVENT_TYPES = Object.keys(DB_EVENT_TYPE_TO_KIND).map((kind) => `'${kind}'`).join(", ");
 function safeParseStringArray(raw) {
   if (!raw) return [];
   const parsed2 = safeJson(raw, null);
@@ -25218,6 +25385,37 @@ var TIMELINE_COLUMNS = `
   json_extract(attributes, '$.targetId') AS target_id,
   json_extract(attributes, '$.internal') AS internal,
   json_extract(attributes, '$.flagged') AS flagged`;
+var LLM_USAGE_SELECT = `
+  SELECT root_session_id AS sessionId,
+         provider,
+         model,
+         service_tier AS serviceTier,
+         coalesce(sum(input_tokens), 0) AS inputTokens,
+         coalesce(sum(output_tokens), 0) AS outputTokens,
+         coalesce(sum(cache_creation_input_tokens), 0) AS cacheCreationTokens,
+         coalesce(sum(cache_read_input_tokens), 0) AS cacheReadTokens,
+         coalesce(sum(ephemeral_1h_input_tokens), 0) AS ephemeral1hTokens,
+         coalesce(sum(ephemeral_5m_input_tokens), 0) AS ephemeral5mTokens,
+         coalesce(sum(web_search_requests), 0) AS webSearchRequests`;
+var LLM_USAGE_SCOPE = `event_type = 'llm_call' AND attributes IS NOT NULL AND root_session_id IS NOT NULL`;
+var LLM_USAGE_GROUP = `GROUP BY root_session_id, provider, model, service_tier`;
+function usageLeaves(rows) {
+  return rows.map((row) => {
+    const attributes = {
+      input_tokens: row.inputTokens,
+      output_tokens: row.outputTokens,
+      cache_creation_input_tokens: row.cacheCreationTokens,
+      cache_read_input_tokens: row.cacheReadTokens,
+      ephemeral_1h_input_tokens: row.ephemeral1hTokens,
+      ephemeral_5m_input_tokens: row.ephemeral5mTokens,
+      web_search_requests: row.webSearchRequests
+    };
+    if (row.provider !== null) attributes.provider = row.provider;
+    if (row.model !== null) attributes.model = row.model;
+    if (row.serviceTier !== null) attributes.service_tier = row.serviceTier;
+    return { sessionId: row.sessionId, attributes };
+  });
+}
 var SESSION_ROOT = `event_type = 'session'`;
 var HAS_ACTIVITY = `EXISTS (
   SELECT 1 FROM audit_events c
@@ -25243,16 +25441,17 @@ var SqliteActivityRepository = class {
     const liveThreshold = this.now() - LIVE_ACTIVITY_WINDOW_MS;
     const liveNow = countScalar(
       this.db,
-      `SELECT count(*) AS n FROM audit_events s
+      `SELECT count(*) AS n FROM audit_events s INDEXED BY sqlite_autoindex_audit_events_1
            WHERE s.event_type = 'session' AND s.ended_at IS NULL
-             AND max(
-               s.started_at,
-               coalesce(
-                 (SELECT max(${LAST_ACTIVITY_EXPR}) FROM audit_events e WHERE e.root_session_id = s.id),
-                 s.started_at
-               )
-             ) >= ?`,
-      [liveThreshold]
+             AND s.id IN (
+               SELECT id FROM audit_events WHERE event_type = 'session' AND started_at >= ?
+               UNION
+               SELECT root_session_id FROM audit_events INDEXED BY idx_audit_started_at
+                WHERE started_at >= ?
+               UNION
+               SELECT root_session_id FROM audit_events INDEXED BY idx_audit_ended_at
+                WHERE ended_at >= ?)`,
+      [liveThreshold, liveThreshold, liveThreshold]
     );
     const toolCallsToday = countScalar(
       this.db,
@@ -25382,7 +25581,7 @@ var SqliteActivityRepository = class {
       this.db.prepare(
         `SELECT ${TIMELINE_COLUMNS}
          FROM audit_events
-         WHERE id = ? OR root_session_id = ?
+         WHERE (id = ? OR root_session_id = ?) AND event_type IN (${TIMELINE_EVENT_TYPES})
          ORDER BY started_at ASC, id ASC`
       ),
       [sessionId, sessionId]
@@ -25395,14 +25594,14 @@ var SqliteActivityRepository = class {
            coalesce(sum(output_tokens), 0) AS output,
            coalesce(sum(cache_creation_input_tokens), 0) AS cache_creation,
            coalesce(sum(cache_read_input_tokens), 0) AS cache_read
-         FROM audit_events
+         FROM audit_events INDEXED BY idx_audit_session_type
          WHERE root_session_id = ? AND event_type = 'llm_call'`
       ),
       [sessionId]
     ) ?? { input: 0, output: 0, cache_creation: 0, cache_read: 0 };
     const primaryModel = getRow(
       this.db.prepare(
-        `SELECT model, provider FROM audit_events
+        `SELECT model, provider FROM audit_events INDEXED BY idx_audit_session_type
          WHERE root_session_id = ? AND event_type = 'llm_call'
          ORDER BY started_at ASC, id ASC
          LIMIT 1`
@@ -25413,7 +25612,7 @@ var SqliteActivityRepository = class {
       this.db.prepare(
         `SELECT coalesce(json_extract(attributes, '$.tool_name'), json_extract(attributes, '$.tool')) AS tool,
                 count(*) AS n
-         FROM audit_events
+         FROM audit_events INDEXED BY idx_audit_session
          WHERE root_session_id = ? AND event_type = 'tool_call'
          GROUP BY coalesce(json_extract(attributes, '$.tool_name'), json_extract(attributes, '$.tool'))`
       ),
@@ -25421,7 +25620,7 @@ var SqliteActivityRepository = class {
     );
     const modelRows = allRows(
       this.db.prepare(
-        `SELECT DISTINCT model FROM audit_events
+        `SELECT DISTINCT model FROM audit_events INDEXED BY idx_audit_session_type
          WHERE root_session_id = ? AND event_type = 'llm_call' AND model IS NOT NULL AND model <> ''
          ORDER BY model`
       ),
@@ -25430,7 +25629,7 @@ var SqliteActivityRepository = class {
     const derivedModels = modelRows.map((r) => r.model);
     const commits = countScalar(
       this.db,
-      `SELECT count(*) AS n FROM audit_events
+      `SELECT count(*) AS n FROM audit_events INDEXED BY idx_audit_session
            WHERE root_session_id = ? AND event_type = 'commit'`,
       [sessionId]
     );
@@ -25466,25 +25665,57 @@ var SqliteActivityRepository = class {
     return Promise.resolve(session);
   }
   /**
-   * Cross-session token report — every `llm_call` leaf (optionally windowed to
-   * `started_at >= fromMs`) grouped into per-session `SessionTokenReport`s, with
-   * USD cost DERIVED at read time via the shared `defaultCostModel` (never
-   * stored). `fromMs` lets the Activity page scope the usage panel to its
-   * selected time range; omit it for all-time (the CLI/TUI overview). The
-   * caller collapses these onto per-model rows with `aggregateTokenUsage`.
+   * Cross-session token report — every `llm_call` in the store (or in a
+   * `started_at >= fromMs` window, the Activity page's range) grouped per
+   * session, with USD cost DERIVED at read time via the shared
+   * `defaultCostModel` (never stored). The caller collapses these onto
+   * per-model rows with `aggregateTokenUsage`.
+   *
+   * Grouped in SQL over `idx_audit_llm_usage` — one entry per call carrying
+   * the members the rollup sums — and priced once per group, which is exact
+   * (see LlmUsageRow). Reading the bags and folding them in JS measured 31 ms
+   * for a seven-day window at 50k calls, and naming the VIRTUAL columns
+   * against the table 40 ms, since each is a json_extract recomputed per row;
+   * the index stores the values once, at write, and answers the same window in
+   * 8.5 ms. `INDEXED BY` is deliberate: with or without ANALYZE statistics the
+   * planner prefers the general event-type index and fetches every row to
+   * recompute the columns it could have read. The index is one every open
+   * store carries, since opening runs the migrations, so the hard requirement
+   * `INDEXED BY` introduces is already met; token-rollup-plans.test.ts pins
+   * the plan. All-time is a scan of the whole index — still one narrow entry
+   * per call, no bag parsed.
    */
   tokenReports(fromMs) {
-    const leaves = this.readLlmCallLeaves(fromMs === void 0 ? {} : { fromMs });
-    return Promise.resolve(buildTokenReports(leaves, defaultCostModel));
+    const rows = allRows(
+      this.db.prepare(
+        `${LLM_USAGE_SELECT}
+           FROM audit_events INDEXED BY idx_audit_llm_usage
+          WHERE ${LLM_USAGE_SCOPE}${fromMs === void 0 ? "" : " AND started_at >= ?"}
+          ${LLM_USAGE_GROUP}`
+      ),
+      fromMs === void 0 ? void 0 : [fromMs]
+    );
+    return Promise.resolve(buildTokenReports(usageLeaves(rows), defaultCostModel));
   }
   /**
-   * One session's token report — its `llm_call` leaves grouped per (provider,
-   * model) with derived cost, or `null` when the session made no `llm_call`s
-   * (an empty/tool-only session). Feeds the session-detail pane's per-model
-   * breakdown + estimated cost.
+   * One session's token report — its `llm_call`s grouped per (provider,
+   * model, tier) with derived cost, or `null` when the session made no
+   * `llm_call`s (an empty/tool-only session). Feeds the session-detail pane's
+   * per-model breakdown + estimated cost. The same rollup as `tokenReports`,
+   * seeking one root through a root-led `llm_call` index; the bag-reading fold
+   * it replaces walked every `llm_call` in the store to find one session's.
    */
   tokenReportForSession(sessionId) {
-    const reports = buildTokenReports(this.readLlmCallLeaves({ sessionId }), defaultCostModel);
+    const rows = allRows(
+      this.db.prepare(
+        `${LLM_USAGE_SELECT}
+           FROM audit_events
+          WHERE ${LLM_USAGE_SCOPE} AND root_session_id = ?
+          ${LLM_USAGE_GROUP}`
+      ),
+      [sessionId]
+    );
+    const reports = buildTokenReports(usageLeaves(rows), defaultCostModel);
     return Promise.resolve(reports[0] ?? null);
   }
   /**
@@ -25508,42 +25739,6 @@ var SqliteActivityRepository = class {
     for (const row of rows) seen.add(toHarness(row.harness));
     return Promise.resolve([...seen]);
   }
-  /**
-   * The raw `llm_call` leaves (session id + parsed attribute bag) for the token
-   * rollups, optionally narrowed to one session and/or a `started_at >= fromMs`
-   * window. A leaf whose attributes blob is NULL or unparseable is skipped
-   * (best-effort read — a corrupt bag never breaks the report). `root_session_id`
-   * is the leaf's session (the reconciler sets parent_id = root_session_id).
-   */
-  readLlmCallLeaves(opts = {}) {
-    const conditions = ["event_type = 'llm_call'", "attributes IS NOT NULL"];
-    const params = [];
-    if (opts.sessionId !== void 0) {
-      conditions.push("root_session_id = ?");
-      params.push(opts.sessionId);
-    }
-    if (opts.fromMs !== void 0) {
-      conditions.push("started_at >= ?");
-      params.push(opts.fromMs);
-    }
-    const rows = allRows(
-      this.db.prepare(
-        `SELECT root_session_id AS sessionId, attributes
-           FROM audit_events
-          WHERE ${conditions.join(" AND ")}`
-      ),
-      params
-    );
-    return mapRowsTolerant(
-      rows.filter(
-        (row) => row.sessionId !== null
-      ),
-      (row) => ({
-        sessionId: row.sessionId,
-        attributes: JSON.parse(row.attributes)
-      })
-    );
-  }
   /**
    * Per-session turns/findings/shares + last-activity for a page of session ids,
    * in grouped queries (not one per row). An id with no matching rows still
@@ -25558,20 +25753,23 @@ var SqliteActivityRepository = class {
     const inClause = placeholders(sessionIds.length);
     const lastActivityRows = allRows(
       this.db.prepare(
-        `SELECT root_session_id AS id, max(${LAST_ACTIVITY_EXPR}) AS m FROM audit_events
-         WHERE root_session_id IN (${inClause})
-         GROUP BY root_session_id`
+        `SELECT ids.value AS id,
+                (SELECT max(started_at) FROM audit_events e WHERE e.root_session_id = ids.value) AS ms,
+                (SELECT max(ended_at) FROM audit_events e
+                  WHERE e.root_session_id = ids.value AND e.ended_at IS NOT NULL) AS me
+         FROM json_each(?) AS ids`
       ),
-      sessionIds
+      [JSON.stringify(sessionIds)]
     );
     for (const row of lastActivityRows) {
-      if (row.id === null) continue;
       const entry = result.get(row.id);
-      if (entry && row.m !== null) entry.lastActivityMs = row.m;
+      const last = Math.max(row.ms ?? 0, row.me ?? 0);
+      if (entry && last > 0) entry.lastActivityMs = last;
     }
     const turnsRows = allRows(
       this.db.prepare(
-        `SELECT root_session_id AS id, count(*) AS n FROM audit_events
+        `SELECT root_session_id AS id, count(*) AS n
+         FROM audit_events INDEXED BY idx_audit_session_prompt
          WHERE root_session_id IN (${inClause}) AND event_type = 'prompt'
          GROUP BY root_session_id`
       ),
@@ -25586,7 +25784,7 @@ var SqliteActivityRepository = class {
       this.db.prepare(
         `SELECT root_session_id AS id,
                 count(DISTINCT json_extract(attributes, '$.run_key')) AS n
-         FROM audit_events
+         FROM audit_events INDEXED BY idx_audit_session_run_key
          WHERE root_session_id IN (${inClause}) AND event_type = 'llm_call'
            AND json_extract(attributes, '$.run_key') IS NOT NULL
          GROUP BY root_session_id`
@@ -25616,7 +25814,7 @@ var SqliteActivityRepository = class {
       this.db.prepare(
         `SELECT root_session_id AS id,
                 count(DISTINCT json_extract(attributes, '$.destination')) AS n
-         FROM audit_events
+         FROM audit_events INDEXED BY idx_audit_session_share
          WHERE root_session_id IN (${inClause}) AND event_type = 'share'
          GROUP BY root_session_id`
       ),
@@ -26645,7 +26843,6 @@ var LATEST_RESOLUTION_BY_KEY_SQL = `(
 
 // ../../packages/persistence/src/repositories/findings.ts
 var PREVIEW_INSTANCES_PER_GROUP = 200;
-var SCAN_BATCH_ROWS = 1e3;
 var DEFAULT_LOCATIONS_LIMIT = 100;
 var LOCATION_RULE_IDS_CAP = 20;
 function compareLocationOrder(a, b) {
@@ -26674,6 +26871,25 @@ function deriveInstanceStatus(row) {
     latestResolutionStatus: row.latest_status
   });
 }
+function toFlatFindingRow(r) {
+  return {
+    id: r.id,
+    ruleId: r.rule_id,
+    category: r.category,
+    severity: r.severity,
+    maskedMatch: r.masked_match,
+    actionTaken: r.action_taken,
+    confidence: r.confidence,
+    occurredAt: epochMillisToIso(r.occurred_at),
+    sourceTool: r.source_tool,
+    repo: r.repo ?? "",
+    file: r.file ?? "",
+    ...r.tool_name === null ? {} : { toolName: r.tool_name },
+    eventId: r.event_id,
+    ...r.session_id === null ? {} : { sessionId: r.session_id },
+    status: deriveInstanceStatus(r)
+  };
+}
 function encodeGroupCursor(group) {
   const payload = {
     sev: group.severity,
@@ -26749,7 +26965,7 @@ var SqliteFindingsRepository = class {
       this.db.prepare(
         `SELECT f.id, f.audit_event_id AS event_id, d.rule_id, d.category, d.severity,
                 f.masked_match, f.action_taken, f.confidence, e.started_at AS occurred_at,
-                json_extract(e.attributes, '$.source_tool') AS source_tool,
+                e.source_tool AS source_tool,
                 e.event_type AS kind
          FROM audit_events e
          CROSS JOIN inspection_findings f ON f.audit_event_id = e.id
@@ -26857,56 +27073,11 @@ var SqliteFindingsRepository = class {
       predicate,
       params: sessionParams
     });
-    const rows = allRows(
-      this.db.prepare(
-        `SELECT id, rule_id, category, severity, masked_match, action_taken, confidence,
-                occurred_at, source_tool, repo, file, tool_name, event_id, session_id,
-                kind, finding_key, latest_status
-         FROM (
-           SELECT f.id AS id, d.rule_id AS rule_id, d.category AS category,
-                  d.severity AS severity, f.masked_match AS masked_match,
-                  f.action_taken AS action_taken, f.confidence AS confidence,
-                  e.started_at AS occurred_at,
-                  json_extract(e.attributes, '$.source_tool') AS source_tool,
-                  json_extract(e.attributes, '$.repo') AS repo,
-                  json_extract(e.attributes, '$.file_path') AS file,
-                  json_extract(e.attributes, '$.tool_name') AS tool_name,
-                  f.audit_event_id AS event_id, e.root_session_id AS session_id,
-                  e.event_type AS kind, f.finding_key AS finding_key,
-                  latest.status AS latest_status,
-                  ROW_NUMBER() OVER (
-                    PARTITION BY d.rule_id
-                    ORDER BY e.started_at DESC, f.id DESC
-                  ) AS rn
-             FROM inspection_findings f
-             JOIN audit_events e ON e.id = f.audit_event_id
-             JOIN inspection_definitions d ON d.id = f.inspection_definition_id
-             LEFT JOIN ${LATEST_RESOLUTION_BY_KEY_SQL} latest
-               ON latest.finding_key = f.finding_key
-             ${predicate}
-         )
-         WHERE rn <= :cap
-         ORDER BY occurred_at DESC, id DESC`
-      ),
-      { cap: PREVIEW_INSTANCES_PER_GROUP, ...sessionParams }
-    );
-    const groupable = rows.map((r) => ({
-      id: r.id,
-      ruleId: r.rule_id,
-      category: r.category,
-      severity: r.severity,
-      maskedMatch: r.masked_match,
-      actionTaken: r.action_taken,
-      confidence: r.confidence,
-      occurredAt: epochMillisToIso(r.occurred_at),
-      sourceTool: r.source_tool,
-      repo: r.repo ?? "",
-      file: r.file ?? "",
-      ...r.tool_name === null ? {} : { toolName: r.tool_name },
-      eventId: r.event_id,
-      ...r.session_id === null ? {} : { sessionId: r.session_id },
-      status: deriveInstanceStatus(r)
-    }));
+    const rows = this.previewRows(aggregates, {
+      sessionId: query.sessionId,
+      from: query.from
+    });
+    const groupable = rows.map(toFlatFindingRow);
     const allGroups = buildFindingGroups(groupable, { aggregates });
     const filterOpts = {
       severity: query.severity,
@@ -26992,8 +27163,10 @@ var SqliteFindingsRepository = class {
    *
    * The scan runs from the top of the scope on every request, not from the
    * cursor: `totals` and `facets` describe the whole filtered scope and must not
-   * move as the caller pages. Rows are pulled in batches so memory stays flat
-   * while the counting runs, and only the page itself is retained.
+   * move as the caller pages. Rows come off ONE statement, iterated rather
+   * than materialized (`scanFindingRows`), so memory stays flat while the
+   * counting runs — a generator streaming the index order, not a sequence of
+   * fetched batches; only the page itself is retained.
    */
   listFindingInstances(query) {
     const opts = {
@@ -27009,6 +27182,10 @@ var SqliteFindingsRepository = class {
     };
     const limit = query.limit ?? DEFAULT_FLAT_FINDINGS_LIMIT;
     const cursor = query.cursor === void 0 ? null : decodeKeysetCursor(query.cursor);
+    const isPastCursor = cursor === null ? () => true : (row) => {
+      const rowMs = isoToEpochMillis(row.occurredAt);
+      return rowMs <= cursor.startedAtMs && (rowMs < cursor.startedAtMs || row.id < cursor.id);
+    };
     const accumulator = createInstanceFacetAccumulator(opts);
     const items = [];
     let total = 0;
@@ -27021,6 +27198,7 @@ var SqliteFindingsRepository = class {
       accumulator.add(row);
       if (!matchesInstanceFilters(row, opts)) continue;
       total += 1;
+      if (!isPastCursor(row)) continue;
       if (items.length < limit) {
         items.push(toInstanceDetail(row));
         last = row;
@@ -27029,15 +27207,6 @@ var SqliteFindingsRepository = class {
       }
     }
     const nextCursor = hasMore && last ? encodeKeysetCursor({ startedAtMs: isoToEpochMillis(last.occurredAt), id: last.id }) : null;
-    if (cursor !== null) {
-      const resumed = this.pageAfter(cursor, opts, limit, query);
-      return Promise.resolve({
-        totals: { findings: total },
-        facets: accumulator.facets(),
-        items: resumed.items,
-        nextCursor: resumed.nextCursor
-      });
-    }
     return Promise.resolve({
       totals: { findings: total },
       facets: accumulator.facets(),
@@ -27045,35 +27214,6 @@ var SqliteFindingsRepository = class {
       nextCursor
     });
   }
-  /**
-   * The page of matching rows strictly after `cursor`. Separate from the
-   * counting pass because that one starts at the top of the scope by design;
-   * this one narrows the scan with the same keyset predicate the activity list
-   * uses, so a later page costs less than the first rather than more.
-   */
-  pageAfter(cursor, opts, limit, query) {
-    const items = [];
-    let last;
-    let hasMore = false;
-    for (const row of this.scanFindingRows({
-      sessionId: query.sessionId,
-      from: query.from,
-      after: cursor
-    })) {
-      if (!matchesInstanceFilters(row, opts)) continue;
-      if (items.length < limit) {
-        items.push(toInstanceDetail(row));
-        last = row;
-      } else {
-        hasMore = true;
-        break;
-      }
-    }
-    return {
-      items,
-      nextCursor: hasMore && last ? encodeKeysetCursor({ startedAtMs: isoToEpochMillis(last.occurredAt), id: last.id }) : null
-    };
-  }
   /**
    * The same findings folded by location: repository, then file within it.
    *
@@ -27156,25 +27296,111 @@ var SqliteFindingsRepository = class {
     });
   }
   /**
-   * Every finding in scope as a FlatFindingRow, newest first, pulled in batches.
+   * Each group's newest instances, for the table's expanded rows.
+   *
+   * ONE index-ordered scan with early termination, and the shape is the point.
+   * The natural spelling — `ROW_NUMBER() OVER (PARTITION BY rule_id ORDER BY
+   * started_at DESC)` then `WHERE rn <= cap` — sorts EVERY finding in scope
+   * through a temp B-tree to keep a bounded preview of each group, and then
+   * sorts the survivors again for the page order. Both sorts grow with the
+   * store while the answer does not.
+   *
+   * Instead the scan walks `audit_events` newest-first off `idx_audit_started_at`
+   * (or the session or window index the scope names — see `findingScanSql`),
+   * which is already the order the page wants, and keeps rows per rule until
+   * each rule has as many as it can show. The aggregate the caller already holds
+   * says how many that is: `min(instanceCount, PREVIEW_INSTANCES_PER_GROUP)`
+   * per rule, summed, is the number of rows this scan has to find, and it stops
+   * on the last one. That sum is bounded by `rules * PREVIEW_INSTANCES_PER_GROUP`
+   * (8,000 at this repo's 40-rule bench corpus), not by a fixed row count — a
+   * store with many firing rules widens it. The bound that DOES hold
+   * unconditionally is the sorted form's floor: this scan visits at most as
+   * many rows as `ROW_NUMBER() OVER (PARTITION BY rule_id …)` would have
+   * sorted, and stops the moment every rule has its cap, where the sorted form
+   * sorts the whole scope regardless. The true worst case — the rarest rule's
+   * wanted instances sitting at the tail of the scope — is one pass over
+   * everything in scope with a block sort of the id tie-break only, never a
+   * sort of the scope, which is still that floor.
+   *
+   * A row whose rule the aggregate did not see is skipped: the two statements
+   * run without a shared snapshot, so a capture landing between them can add a
+   * rule here that has no counts there, and the counts are what the group is
+   * built from.
+   */
+  previewRows(aggregates, scope) {
+    const wanted = /* @__PURE__ */ new Map();
+    let remaining = 0;
+    for (const [ruleId, agg] of aggregates) {
+      const n = Math.min(agg.instanceCount, PREVIEW_INSTANCES_PER_GROUP);
+      wanted.set(ruleId, n);
+      remaining += n;
+    }
+    const rows = [];
+    if (remaining === 0) return rows;
+    const { sql, params } = this.findingScanSql(scope);
+    const taken = /* @__PURE__ */ new Map();
+    for (const r of iterateRows(this.db.prepare(sql), params)) {
+      const want = wanted.get(r.rule_id);
+      if (want === void 0) continue;
+      const have = taken.get(r.rule_id) ?? 0;
+      if (have >= want) continue;
+      taken.set(r.rule_id, have + 1);
+      rows.push(r);
+      remaining -= 1;
+      if (remaining === 0) break;
+    }
+    return rows;
+  }
+  /**
+   * Every finding in scope as a FlatFindingRow, newest first, streamed.
    *
    * A generator so a caller streams the scope without it ever being an array:
    * the flat list counts and facets the whole filtered scope, which on a large
-   * store is far more rows than any page. Each batch advances the same keyset
-   * predicate the page read uses, so the scan is a sequence of bounded reads
-   * rather than one unbounded result set.
+   * store is far more rows than any page. The rows come off ONE statement,
+   * iterated rather than materialized, in the index order `findingScanSql`
+   * arranges — so the scan is a single pass with a block sort of the id
+   * tie-break only, never a sort of the scope, where a sequence of
+   * keyset-bounded batches re-sorted everything below the cursor on every
+   * batch and cost the square of the scope.
    *
-   * The latest-resolution lookup is the CORRELATED form, not the derived table
-   * the grouped path joins: only `status` is needed, idx_finding_resolution_key
-   * makes it a point lookup per row, and the derived table would re-materialize
-   * a window over the whole resolution table once per batch.
-   *
-   * `scope` carries ONLY what no facet counts. A filter dimension narrowed here
-   * would be missing from its own facet, which is computed by excluding that
-   * dimension — see listFindingInstances.
+   * `sessionId` and `from` carry ONLY what no facet counts — a filter
+   * dimension narrowed here would be missing from its own facet, which is
+   * computed by excluding that dimension (see listFindingInstances). There is
+   * no `after`/cursor parameter: a keyset page is collected inline from this
+   * same pass (`listFindingInstances`' `isPastCursor`) rather than by a second,
+   * narrower statement, since the counting pass already visits every row a
+   * page-2+ request would otherwise re-seek for.
    */
   *scanFindingRows(scope) {
-    const conditions = [`e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})`];
+    const { sql, params } = this.findingScanSql(scope);
+    for (const r of iterateRows(this.db.prepare(sql), params)) {
+      yield toFlatFindingRow(r);
+    }
+  }
+  /**
+   * The one statement both instance-level scans run: every finding in scope,
+   * joined to its event and definition, newest first.
+   *
+   * THE PLAN IS THE POINT, and two things in the SQL exist only to pin it —
+   * the same two `recentFindings` documents at length, for the same reason:
+   *
+   *  - **`+e.event_type`** makes the capture-kind predicate non-indexable, so
+   *    the planner cannot pick `idx_audit_type_t` and then sort. That index
+   *    yields `started_at` order per event type, not across the four, so
+   *    satisfying the ORDER BY from it would need a merge SQLite does not do.
+   *    Freed of it, the planner walks `idx_audit_started_at` backwards — or
+   *    `idx_audit_session` for a session scope, which is also `started_at`
+   *    ordered within the session — and the order falls out of the index.
+   *  - **`CROSS JOIN`** pins `audit_events` as the driving table. With plain
+   *    JOINs the planner drives from the findings and sorts everything.
+   *
+   * The latest-resolution lookup is the CORRELATED form: only `status` is
+   * needed, `idx_finding_resolution_key_created` answers it with one backward
+   * index probe per keyed row, and a derived table over the whole resolution
+   * table would be materialized before the first row streamed.
+   */
+  findingScanSql(scope) {
+    const conditions = [`+e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})`];
     const params = [];
     if (scope.sessionId !== void 0 && scope.sessionId !== "") {
       conditions.push("e.root_session_id = ?");
@@ -27188,58 +27414,24 @@ var SqliteFindingsRepository = class {
               d.severity AS severity, f.masked_match AS masked_match,
               f.action_taken AS action_taken, f.confidence AS confidence,
               e.started_at AS occurred_at,
-              json_extract(e.attributes, '$.source_tool') AS source_tool,
-              json_extract(e.attributes, '$.repo') AS repo,
-              json_extract(e.attributes, '$.file_path') AS file,
-              json_extract(e.attributes, '$.tool_name') AS tool_name,
+              e.source_tool AS source_tool,
+              e.repo AS repo,
+              e.file_path AS file,
+              e.tool_name AS tool_name,
               f.audit_event_id AS event_id, e.root_session_id AS session_id,
               e.event_type AS kind, f.finding_key AS finding_key,
               ${latestResolutionStatusSql("f")} AS latest_status
-         FROM inspection_findings f
-         JOIN audit_events e ON e.id = f.audit_event_id
-         JOIN inspection_definitions d ON d.id = f.inspection_definition_id
+         FROM audit_events e
+         CROSS JOIN inspection_findings f ON f.audit_event_id = e.id
+         CROSS JOIN inspection_definitions d ON d.id = f.inspection_definition_id
         WHERE ${conditions.join(" AND ")}
-          AND (e.started_at < ? OR (e.started_at = ? AND f.id < ?))
-        ORDER BY e.started_at DESC, f.id DESC
-        LIMIT ?`;
-    let after = scope.after ?? { startedAtMs: Number.MAX_SAFE_INTEGER, id: "\uFFFF" };
-    for (; ; ) {
-      const rows = allRows(this.db.prepare(sql), [
-        ...params,
-        after.startedAtMs,
-        after.startedAtMs,
-        after.id,
-        SCAN_BATCH_ROWS
-      ]);
-      for (const r of rows) {
-        yield {
-          id: r.id,
-          ruleId: r.rule_id,
-          category: r.category,
-          severity: r.severity,
-          maskedMatch: r.masked_match,
-          actionTaken: r.action_taken,
-          confidence: r.confidence,
-          occurredAt: epochMillisToIso(r.occurred_at),
-          sourceTool: r.source_tool,
-          repo: r.repo ?? "",
-          file: r.file ?? "",
-          ...r.tool_name === null ? {} : { toolName: r.tool_name },
-          eventId: r.event_id,
-          ...r.session_id === null ? {} : { sessionId: r.session_id },
-          status: deriveInstanceStatus(r)
-        };
-      }
-      if (rows.length < SCAN_BATCH_ROWS) return;
-      const lastRow = rows[rows.length - 1];
-      if (lastRow === void 0) return;
-      after = { startedAtMs: lastRow.occurred_at, id: lastRow.id };
-    }
+        ORDER BY e.started_at DESC, f.id DESC`;
+    return { sql, params };
   }
   groupAggregates(withSearchText, scope) {
-    const innerSearchColumns = withSearchText ? `, group_concat(DISTINCT json_extract(e.attributes, '$.repo')) AS repos,
-           group_concat(DISTINCT json_extract(e.attributes, '$.file_path')) AS files,
-           group_concat(DISTINCT 'via ' || json_extract(e.attributes, '$.tool_name')) AS tool_names` : `, NULL AS repos, NULL AS files, NULL AS tool_names`;
+    const innerSearchColumns = withSearchText ? `, group_concat(DISTINCT e.repo) AS repos,
+           group_concat(DISTINCT e.file_path) AS files,
+           group_concat(DISTINCT 'via ' || e.tool_name) AS tool_names` : `, NULL AS repos, NULL AS files, NULL AS tool_names`;
     const rows = this.db.prepare(
       `SELECT rule_id,
                 sum(tuple_count) AS instance_count,
@@ -27257,7 +27449,7 @@ var SqliteFindingsRepository = class {
                       coalesce(latest.status, '') AS status_tuple,
                     count(*) AS tuple_count,
                     max(e.started_at) AS latest_at,
-                    group_concat(DISTINCT json_extract(e.attributes, '$.source_tool')) AS source_tools,
+                    group_concat(DISTINCT e.source_tool) AS source_tools,
                     group_concat(DISTINCT f.action_taken) AS actions_taken
                     ${innerSearchColumns}
                FROM inspection_findings f
@@ -27388,6 +27580,8 @@ function isoDay(ms) {
 // ../../packages/persistence/src/repositories/history-sync.ts
 var STRUCTURAL_EVENT_TYPES = ["session", "llm_call", "tool_call"];
 var TYPE_LIST = STRUCTURAL_EVENT_TYPES.map((t) => `'${t}'`).join(", ");
+var OUTBOX_CAPTURE_EVENT_TYPES = ["prompt", "response", "tool_use"];
+var CAPTURE_TYPE_LIST = OUTBOX_CAPTURE_EVENT_TYPES.map((t) => `'${t}'`).join(", ");
 var SKIPPED = -1;
 var ROW_COLUMNS = `id,
    parent_id AS parentId,
@@ -27427,9 +27621,23 @@ var SqliteHistorySyncRepository = class {
         ORDER BY (event_type = 'session') DESC, started_at
         LIMIT :limit`
     );
-    this.stampStmt = db.prepare(
-      `UPDATE audit_events SET synced_at = :at, sync_claimed_at = NULL WHERE id = :id`
-    );
+    this.captureRowsStmt = db.prepare(
+      `SELECT ${ROW_COLUMNS}
+         FROM audit_events
+        WHERE synced_at IS NULL
+          AND sync_claimed_at IS NULL
+          AND outbox_owed = 1
+          AND event_type IN (${CAPTURE_TYPE_LIST})
+          AND started_at < :before
+        ORDER BY started_at
+        LIMIT :limit`
+    );
+    this.markOwedStmt = db.prepare(
+      `UPDATE audit_events SET outbox_owed = 1 WHERE id = :id AND synced_at IS NULL`
+    );
+    this.stampStmt = db.prepare(
+      `UPDATE audit_events SET synced_at = :at, sync_claimed_at = NULL WHERE id = :id`
+    );
     this.claimRowStmt = db.prepare(
       `UPDATE audit_events SET sync_claimed_at = :at WHERE id = :id AND synced_at IS NULL`
     );
@@ -27458,6 +27666,12 @@ var SqliteHistorySyncRepository = class {
        FROM audit_events
        WHERE event_type IN (${TYPE_LIST})`
     );
+    this.captureSkipCountStmt = db.prepare(
+      `SELECT COUNT(*) AS skipped
+         FROM audit_events
+        WHERE synced_at = ${String(SKIPPED)}
+          AND event_type IN (${CAPTURE_TYPE_LIST})`
+    );
     this.fingerprintStmt = db.prepare(
       `SELECT endpoint_fingerprint AS fingerprint, backlog_before AS backlogBefore
          FROM history_sync WHERE id = 1`
@@ -27467,6 +27681,10 @@ var SqliteHistorySyncRepository = class {
           SET endpoint_fingerprint = :fingerprint, backlog_before = :backlogBefore
         WHERE id = 1`
     );
+    this.disownCapturesStmt = db.prepare(
+      `UPDATE audit_events SET outbox_owed = NULL
+        WHERE outbox_owed IS NOT NULL AND event_type IN (${CAPTURE_TYPE_LIST})`
+    );
     this.rearmStmt = db.prepare(
       `UPDATE audit_events SET synced_at = NULL
         WHERE synced_at > 0 AND event_type IN (${TYPE_LIST})`
@@ -27539,6 +27757,10 @@ var SqliteHistorySyncRepository = class {
   closeWindowStmt;
   releaseBoundaryStmt;
   freezeBoundaryStmt;
+  captureRowsStmt;
+  markOwedStmt;
+  captureSkipCountStmt;
+  disownCapturesStmt;
   partitionStmt;
   claimRowStmt;
   releaseRowStmt;
@@ -27572,6 +27794,34 @@ var SqliteHistorySyncRepository = class {
   pendingRows(sessionId, limit, before) {
     return allRows(this.rowsStmt, { sessionId, limit, before });
   }
+  /**
+   * Captures this machine still owes the deployment, oldest first.
+   *
+   * Selected by the `outbox_owed` marker the attached forward path writes, not
+   * by a time window — see captureRowsStmt for why a window could not express
+   * this. `before` is the grace window that leaves a just-recorded capture to
+   * the live path.
+   */
+  pendingCaptureRows(limit, before) {
+    return allRows(this.captureRowsStmt, { limit, before });
+  }
+  /**
+   * Record that a capture is OWED to the deployment.
+   *
+   * Written by the attached forward path when a live send did not confirm
+   * delivery, and read by the drain as the whole of its eligibility test. It is
+   * a fact rather than an inference: the machine was attached, the send did not
+   * land, so the row is owed — which no time window can state, because the same
+   * window that holds the rows a past attachment left owed also holds every
+   * capture recorded while the machine was DETACHED, and those were never
+   * offered to anyone.
+   *
+   * Idempotent, and never un-set: `markSynced` settling the row is what takes it
+   * out of the drain's read.
+   */
+  markCaptureOwed(id) {
+    this.markOwedStmt.run({ id });
+  }
   /** Record delivery. Called only AFTER the far side has accepted the rows. */
   markSynced(ids, atMs) {
     this.stampAll(ids, atMs);
@@ -27655,10 +27905,12 @@ var SqliteHistorySyncRepository = class {
       this.countsStmt,
       { before }
     );
+    const captures = getRow(this.captureSkipCountStmt);
     return {
       pending: row?.pending ?? 0,
       sent: row?.sent ?? 0,
-      skipped: row?.skipped ?? 0
+      skipped: row?.skipped ?? 0,
+      capturesSkipped: captures?.skipped ?? 0
     };
   }
   /**
@@ -27699,7 +27951,11 @@ var SqliteHistorySyncRepository = class {
     withTransaction(
       this.db,
       () => {
+        const previous = getRow(this.fingerprintStmt)?.fingerprint;
         this.rearmStmt.run();
+        if (previous !== null && previous !== void 0 && previous !== fingerprint) {
+          this.disownCapturesStmt.run();
+        }
         this.setFingerprintStmt.run({ fingerprint, backlogBefore });
       },
       "IMMEDIATE"
@@ -27896,7 +28152,231 @@ var SqliteInspectionFindingsRepository = class {
 };
 
 // ../../packages/persistence/src/repositories/installed-packs.ts
-import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID4 } from "crypto";
+
+// ../../packages/persistence/src/policy-floor.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
+
+// ../../packages/persistence/src/local-layout.ts
+import { renameSync as renameSync3 } from "fs";
+import { mkdir } from "fs/promises";
+import { homedir } from "os";
+import { join as join4 } from "path";
+function defaultDataDir() {
+  return join4(homedir(), ".aka");
+}
+function settingsDir(base = defaultDataDir()) {
+  return join4(base, "settings");
+}
+function dataDir(base = defaultDataDir()) {
+  return join4(base, "data");
+}
+
+// ../../packages/persistence/src/settings.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+
+// ../../packages/persistence/src/file-lock.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import {
+  closeSync,
+  existsSync as existsSync2,
+  openSync,
+  readFileSync as readFileSync2,
+  rmSync as rmSync5,
+  statSync as statSync3,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { hostname as hostname3 } from "os";
+var PARK = new Int32Array(new SharedArrayBuffer(4));
+
+// ../../packages/persistence/src/managed-settings.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { posix, win32 } from "path";
+function managedSettingsPaths(platform2 = process.platform) {
+  if (platform2 === "darwin") {
+    return [
+      posix.join("/Library", "Application Support", "AKASecurity", MANAGED_SETTINGS_FILENAME),
+      posix.join("/Library", "Managed Preferences", MANAGED_SETTINGS_FILENAME)
+    ];
+  }
+  if (platform2 === "win32") {
+    return [win32.join("C:\\", "ProgramData", "AKASecurity", MANAGED_SETTINGS_FILENAME)];
+  }
+  return [posix.join("/etc", "aka", MANAGED_SETTINGS_FILENAME)];
+}
+function readManagedSettings(paths = managedSettingsPaths()) {
+  for (const path of paths) {
+    let text;
+    try {
+      text = readFileSync3(path, "utf8");
+    } catch {
+      continue;
+    }
+    const record2 = parseJsonObject(text);
+    if (!record2) continue;
+    const parsed2 = ManagedSettings.safeParse(record2);
+    if (parsed2.success) return parsed2.data;
+  }
+  return null;
+}
+function overlayManagedSettings(settings, managed, now = () => /* @__PURE__ */ new Date()) {
+  if (!managed) return settings;
+  const { values } = managed;
+  const merged = { ...settings };
+  if (values.runMode !== void 0) merged.runMode = values.runMode;
+  if (values.controlPlane !== void 0) {
+    merged.controlPlane = {
+      ...values.controlPlane,
+      // The administrator pinned WHICH deployment, not WHEN this machine
+      // joined it. Keep the user's own attach time when the endpoint is
+      // unchanged, so a managed machine does not appear to re-attach on every
+      // read; stamp a fresh one when the administrator moved it.
+      attachedAt: settings.controlPlane?.endpoint === values.controlPlane.endpoint ? settings.controlPlane.attachedAt : now().toISOString()
+    };
+  }
+  if (values.historicalAccess !== void 0) merged.historicalAccess = values.historicalAccess;
+  if (values.vaultKeyCustody !== void 0) merged.vaultKeyCustody = values.vaultKeyCustody;
+  if (values.vaultInlineReveal !== void 0) merged.vaultInlineReveal = values.vaultInlineReveal;
+  if (values.dataSharesInPlace !== void 0) merged.dataSharesInPlace = values.dataSharesInPlace;
+  if (values.redactFallback !== void 0) merged.redactFallback = values.redactFallback;
+  if (values.vaultConsent !== void 0) {
+    merged.vaultConsent = values.vaultConsent ? (
+      // Keep an existing valid grant so its acknowledgedAt survives; mint one
+      // at the current version otherwise.
+      settings.vaultConsent?.version === VAULT_CONSENT_VERSION ? settings.vaultConsent : { acknowledgedAt: now().toISOString(), version: VAULT_CONSENT_VERSION }
+    ) : void 0;
+  }
+  if (values.modelJudgeConsent !== void 0) {
+    merged.modelJudgeConsent = values.modelJudgeConsent ? settings.modelJudgeConsent?.payloadVersion === MODEL_JUDGE_PAYLOAD_VERSION ? settings.modelJudgeConsent : {
+      acknowledgedAt: now().toISOString(),
+      payloadVersion: MODEL_JUDGE_PAYLOAD_VERSION
+    } : void 0;
+  }
+  return merged;
+}
+
+// ../../packages/persistence/src/settings.ts
+var SETTINGS_FILENAME = "settings.json";
+function readWorkspaceSettings(base = defaultDataDir()) {
+  return overlayManagedSettings(readUserSettings(base), readManagedSettings());
+}
+function readUserSettings(base) {
+  const record2 = readJson(join5(settingsDir(base), SETTINGS_FILENAME));
+  if (!record2) return defaultWorkspaceSettings();
+  try {
+    return WorkspaceSettings.parse(record2);
+  } catch {
+    return defaultWorkspaceSettings();
+  }
+}
+function readJson(file2) {
+  let text;
+  try {
+    text = readFileSync4(file2, "utf8");
+  } catch {
+    return null;
+  }
+  return parseJsonObject(text) ?? null;
+}
+
+// ../../packages/persistence/src/policy-floor.ts
+function refusalMessage(pack, attempted, floor, refusal) {
+  switch (refusal) {
+    case "lock":
+      return `refusing to re-assign '${pack}': its policy is set by the connected control plane`;
+    case "disable":
+      return `refusing to disable '${pack}': it is governed by the connected control plane`;
+    case "floor":
+      return `refusing to set '${pack}' to '${attempted ?? "unassigned"}': the connected control plane requires at least '${floor}'`;
+  }
+}
+var PolicyFloorError = class extends Error {
+  /** `namespace/packId` of the detection whose write was refused. */
+  pack;
+  /**
+   * The archetype the caller asked for, or null when the write named none —
+   * clearing the assignment, or switching the detection off.
+   */
+  attempted;
+  /** The weakest archetype the control plane permits for this pack. */
+  floor;
+  refusal;
+  constructor(pack, attempted, floor, refusal) {
+    super(refusalMessage(pack, attempted, floor, refusal));
+    this.name = "PolicyFloorError";
+    this.pack = pack;
+    this.attempted = attempted;
+    this.floor = floor;
+    this.refusal = refusal;
+  }
+};
+function readCachedPolicyBundle(base = defaultDataDir()) {
+  try {
+    const raw = readFileSync5(join6(dataDir(base), POLICY_CACHE_FILENAME), "utf8");
+    const parsed2 = JSON.parse(raw);
+    if (typeof parsed2 !== "object" || parsed2 === null) return null;
+    return PolicyBundle.parse(parsed2.bundle);
+  } catch {
+    return null;
+  }
+}
+function indexEnabled(policies) {
+  const byRuleId = /* @__PURE__ */ new Map();
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const policy of policies) {
+    if (!policy.enabled) continue;
+    if ("ruleId" in policy.target) {
+      if (!byRuleId.has(policy.target.ruleId)) byRuleId.set(policy.target.ruleId, policy.action);
+    } else if (!byCategory.has(policy.target.category)) {
+      byCategory.set(policy.target.category, policy.action);
+    }
+  }
+  return { byRuleId, byCategory };
+}
+function hasAuthoredPolicy(policies, rules, byRuleId) {
+  const ruleIds = new Set(rules.map((rule) => rule.id));
+  const categories = new Set(rules.map((rule) => rule.category));
+  const bundleNamesPack = rules.some((rule) => byRuleId.has(rule.id));
+  return policies.some((policy) => {
+    if (!policy.enabled || policy.provenance !== "authored") return false;
+    return "ruleId" in policy.target ? ruleIds.has(policy.target.ruleId) : bundleNamesPack && categories.has(policy.target.category);
+  });
+}
+function controlPlanePolicyFloor(rules, base = defaultDataDir()) {
+  const floors = openControlPlaneFloors(base);
+  return floors === null ? null : floors.floorFor(rules);
+}
+function openControlPlaneFloors(base = defaultDataDir()) {
+  if (!isAttached(readWorkspaceSettings(base))) return null;
+  const bundle = readCachedPolicyBundle(base);
+  if (bundle === null) return null;
+  const indexes = indexEnabled(bundle.policies);
+  return { floorFor: (rules) => resolveFloor(rules, bundle.policies, indexes) };
+}
+function resolveFloor(rules, policies, { byRuleId, byCategory }) {
+  let action = null;
+  for (const rule of rules) {
+    const resolved = byRuleId.get(rule.id) ?? byCategory.get(rule.category);
+    if (resolved === void 0) continue;
+    action = action === null ? resolved : strongerAction(action, resolved);
+  }
+  if (action === null) return null;
+  return {
+    floor: weakestBuiltinAtLeast(action),
+    locked: hasAuthoredPolicy(policies, rules, byRuleId)
+  };
+}
+function policyAssignmentRefusal(policyId, floor) {
+  if (floor.locked) return "lock";
+  const effective = policyId ?? DEFAULT_PACK_POLICY_ID;
+  return isActionAtLeast(builtinPolicyToAction(effective), builtinPolicyToAction(floor.floor)) ? null : "floor";
+}
+function packEnablementRefusal(enabled, floor) {
+  if (floor === null || enabled) return null;
+  return "disable";
+}
 
 // ../../packages/persistence/src/semver.ts
 function parse3(version2) {
@@ -27990,8 +28470,19 @@ function ruleIdsOf(rulesJson) {
   return ids;
 }
 var SqliteInstalledPacksRepository = class {
-  constructor(db) {
+  /**
+   * `baseDir` is the `~/.aka` LAYOUT BASE, not the data dir — the control-plane
+   * floor needs both halves of it (settings/ says whether this machine is
+   * attached, data/ holds the cached bundle). It is optional because a caller
+   * holding only a DatabaseSync — every test construction site, and any embedder
+   * that opens the store itself — has no layout to point at, and such a caller
+   * gets the pre-existing behaviour: no floor, no lock. Production threads it in
+   * from `openLocalDatabase`, which is the single construction site that owns a
+   * real `~/.aka`.
+   */
+  constructor(db, baseDir) {
     this.db = db;
+    this.baseDir = baseDir;
     this.insertMissingStmt = db.prepare(
       `INSERT INTO installed_packs (id, namespace, pack_id, version, name, rules_json, enabled, created_at, updated_at)
        VALUES (:id, :namespace, :packId, :version, :name, :rulesJson, 1, :now, :now)
@@ -28013,11 +28504,17 @@ var SqliteInstalledPacksRepository = class {
     this.signatureStmt = db.prepare(
       `SELECT namespace, pack_id AS packId, version, rules_json AS rulesJson FROM available_packs`
     );
+    this.packRulesStmt = db.prepare(
+      `SELECT rules_json AS rulesJson FROM installed_packs
+        WHERE namespace = ? AND pack_id = ?`
+    );
   }
   db;
+  baseDir;
   insertMissingStmt;
   upsertAvailableStmt;
   signatureStmt;
+  packRulesStmt;
   /**
    * Record the running binary's detection inventory. Refreshes the
    * available_packs mirror (pruning packs the binary no longer ships) and
@@ -28059,7 +28556,7 @@ var SqliteInstalledPacksRepository = class {
           let behind = false;
           for (const row of rows) {
             const params = {
-              id: randomUUID3(),
+              id: randomUUID4(),
               namespace: row.namespace,
               packId: row.packId,
               version: row.version,
@@ -28071,7 +28568,7 @@ var SqliteInstalledPacksRepository = class {
             if (stored === void 0 || !isMirrorDowngrade(row, stored)) {
               this.upsertAvailableStmt.run({
                 ...params,
-                id: randomUUID3(),
+                id: randomUUID4(),
                 recordedBy: meta4?.recordedBy ?? null
               });
             } else {
@@ -28317,9 +28814,65 @@ var SqliteInstalledPacksRepository = class {
   // NOT on the hook path — so, unlike recordInventory, these surface errors to the
   // caller rather than swallowing them. Each returns whether a row matched, so the
   // caller can tell an edit from a no-such-detection.
+  /**
+   * The rules one installed pack owns, reduced to what a floor computation
+   * reads. Display-tolerant parsing on purpose: a pack whose snapshot is
+   * unreadable contributes no rules to a scan either, so it is not a detection
+   * the control plane can be governing, and an empty list correctly imposes no
+   * floor. Enabled state is deliberately not filtered — a disabled pack is one
+   * the user can re-enable, and its assignment stays governed meanwhile.
+   */
+  packFloorRules(namespace, packId) {
+    const row = getRow(this.packRulesStmt, [namespace, packId]);
+    if (!row) return [];
+    return parseRules(row.rulesJson).map((rule) => ({ id: rule.id, category: rule.category }));
+  }
+  /**
+   * What the connected control plane imposes on one installed pack, or null on a
+   * machine that is its own authority (standalone, no cached bundle, or a
+   * repository constructed without a layout base).
+   *
+   * Exposed as a READ so a surface can render the constraint — grey out the
+   * choices below the floor, mark a locked detection as locked — rather than
+   * offer the user a picker whose selections it will then be told it may not
+   * make. The refusal in `setPolicy` does not depend on any surface calling this.
+   */
+  policyFloor(namespace, packId) {
+    if (this.baseDir === void 0) return null;
+    return controlPlanePolicyFloor(this.packFloorRules(namespace, packId), this.baseDir);
+  }
+  /**
+   * The same answer for several packs, keyed `namespace/packId` and carrying an
+   * entry only for a pack the control plane actually governs.
+   *
+   * A surface listing every detection asks per pack, and asking through
+   * `policyFloor` re-reads the settings, re-reads and re-parses the whole cached
+   * bundle and rebuilds its indexes once per pack — the entire cost of one
+   * answer, repeated for each row, on every render. This reads all of that once.
+   * Packs whose rules the snapshot cannot produce simply contribute no entry,
+   * exactly as the single-pack read returns null for them.
+   */
+  policyFloors(packs) {
+    const floors = /* @__PURE__ */ new Map();
+    if (this.baseDir === void 0) return floors;
+    const source = openControlPlaneFloors(this.baseDir);
+    if (source === null) return floors;
+    for (const pack of packs) {
+      const floor = source.floorFor(this.packFloorRules(pack.namespace, pack.packId));
+      if (floor !== null) floors.set(`${pack.namespace}/${pack.packId}`, floor);
+    }
+    return floors;
+  }
   /**
    * Assign (or clear, with null) the enforcement policy for one installed pack.
-   * `policyId` must be a known built-in id (monitor/warn/redact/block).
+   * `policyId` must be a known built-in id (monitor/warn/redact/block/vault).
+   *
+   * On an ATTACHED machine the organization's bundle is a floor this refuses to
+   * write below, and a detection the organization has authored a policy for is
+   * refused outright — see policy-floor.ts for both, and for why the refusal is
+   * a throw rather than a silently substituted value. This is the one device-local
+   * write path for the assignment, so the check belongs here rather than on any
+   * surface that offers the choice.
    */
   setPolicy(namespace, packId, policyId) {
     if (policyId !== null && !BuiltinPolicyId.safeParse(policyId).success) {
@@ -28327,14 +28880,38 @@ var SqliteInstalledPacksRepository = class {
         `Unknown policy '${policyId}'. Must be one of: ${KNOWN_BUILTIN_IDS.join(", ")}.`
       );
     }
+    const requested = policyId;
+    const floor = this.policyFloor(namespace, packId);
+    if (floor !== null) {
+      const refusal = policyAssignmentRefusal(requested, floor);
+      if (refusal !== null) {
+        throw new PolicyFloorError(`${namespace}/${packId}`, requested, floor.floor, refusal);
+      }
+    }
     const res = this.db.prepare(
       `UPDATE installed_packs SET policy_id = :policyId, updated_at = :now
          WHERE namespace = :namespace AND pack_id = :packId`
     ).run({ policyId, now: Date.now(), namespace, packId });
     return Number(res.changes) > 0;
   }
-  /** Enable or disable one installed pack. */
+  /**
+   * Enable or disable one installed pack.
+   *
+   * On an ATTACHED machine a detection the organization's bundle governs at all
+   * may not be switched OFF here — see packEnablementRefusal for why that is not
+   * merely another point below the floor, and why re-enabling stays open. Like
+   * the assignment above, the check belongs at this write path rather than on a
+   * surface: this is the one device-local writer of the column, and a refusal
+   * that lived in a page would leave the CLI free.
+   */
   setEnabled(namespace, packId, enabled) {
+    const floor = this.policyFloor(namespace, packId);
+    if (floor !== null) {
+      const refusal = packEnablementRefusal(enabled, floor);
+      if (refusal !== null) {
+        throw new PolicyFloorError(`${namespace}/${packId}`, null, floor.floor, refusal);
+      }
+    }
     const res = this.db.prepare(
       `UPDATE installed_packs SET enabled = :enabled, updated_at = :now
          WHERE namespace = :namespace AND pack_id = :packId`
@@ -28420,7 +28997,7 @@ var SqliteInventoryRepository = class {
 };
 
 // ../../packages/persistence/src/repositories/inventory-assets.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 var CATEGORY_ORDER = ["config", "skill", "mcp", "hook"];
 var VALID_HARNESS_IDS = new Set(HarnessId.options);
 var WORKTREE_CHECKOUT_FILTER = "(url IS NULL OR (url NOT LIKE '%/.claude/worktrees/%' AND url NOT LIKE '%\\.claude\\worktrees\\%'))";
@@ -28909,7 +29486,7 @@ var SqliteInventoryAssetsRepository = class {
         `INSERT INTO file_access_override (id, project_id, path, access, created_at, updated_at)
            VALUES (:id, :projectId, :path, :access, :now, :now)
            ON CONFLICT (project_id, path) DO UPDATE SET access = excluded.access, updated_at = excluded.updated_at`
-      ).run({ id: randomUUID4(), projectId, path, access, now: Date.now() });
+      ).run({ id: randomUUID5(), projectId, path, access, now: Date.now() });
     }
     return true;
   }
@@ -28930,7 +29507,7 @@ var SqliteInventoryAssetsRepository = class {
         `INSERT INTO mcp_trust_override (id, asset_id, trust, created_at, updated_at)
            VALUES (:id, :assetId, :trust, :now, :now)
            ON CONFLICT (asset_id) DO UPDATE SET trust = excluded.trust, updated_at = excluded.updated_at`
-      ).run({ id: randomUUID4(), assetId, trust, now: Date.now() });
+      ).run({ id: randomUUID5(), assetId, trust, now: Date.now() });
     }
     this.configRowsCache = void 0;
     return "ok";
@@ -29227,7 +29804,7 @@ var SqliteInventoryAssetsRepository = class {
 };
 
 // ../../packages/persistence/src/repositories/policies.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var SqlitePoliciesRepository = class {
   constructor(db) {
     this.db = db;
@@ -29262,7 +29839,7 @@ var SqlitePoliciesRepository = class {
     failOpenTransaction(this.db, () => {
       for (const [category, action] of Object.entries(DEFAULT_ACTIONS)) {
         stmt.run({
-          id: randomUUID5(),
+          id: randomUUID6(),
           target: JSON.stringify({ category }),
           action,
           now: Date.now()
@@ -29282,7 +29859,7 @@ var SqlitePoliciesRepository = class {
       `INSERT INTO policies (id, scope, target, action, enabled, created_at, updated_at)
          VALUES (:id, 'global', :target, :action, 1, :now, :now)
          ON CONFLICT(scope, target) DO UPDATE SET action = excluded.action, enabled = 1, updated_at = excluded.updated_at`
-    ).run({ id: randomUUID5(), target: JSON.stringify({ category }), action, now });
+    ).run({ id: randomUUID6(), target: JSON.stringify({ category }), action, now });
   }
   // Caps every global per-category policy currently set to block/redact down
   // to warn (see warn-era-cap.ts). Rule-targeted policies are untouched.
@@ -29350,7 +29927,7 @@ var SqlitePolicyCatalogRepository = class {
 };
 
 // ../../packages/persistence/src/repositories/project-files.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 var SqliteProjectFilesRepository = class {
   constructor(db) {
     this.db = db;
@@ -29382,7 +29959,7 @@ var SqliteProjectFilesRepository = class {
     const stamp = Math.max(now, maxStamp + 1);
     for (const file2 of scan2.files) {
       this.upsertStmt.run({
-        id: randomUUID6(),
+        id: randomUUID7(),
         projectId,
         path: file2.path,
         name: file2.name,
@@ -29396,9 +29973,9 @@ var SqliteProjectFilesRepository = class {
 };
 
 // ../../packages/persistence/src/repositories/resolutions.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 var SqliteResolutionsRepository = class {
-  constructor(db, now = () => Date.now(), newId = () => randomUUID7()) {
+  constructor(db, now = () => Date.now(), newId = () => randomUUID8()) {
     this.db = db;
     this.now = now;
     this.newId = newId;
@@ -29611,7 +30188,7 @@ var SqliteScanLedgerRepository = class {
 };
 
 // ../../packages/persistence/src/repositories/secret-vault.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 function pageLimit(requested, fallback) {
   if (requested === void 0) return fallback;
   return Math.min(Math.max(1, Math.trunc(requested)), MAX_VAULT_PAGE_LIMIT);
@@ -29657,12 +30234,14 @@ var SELECT_COLUMNS = `
   ciphertext,
   nonce,
   auth_tag AS authTag,
+  user_authorized AS userAuthorized,
   occurrence_count AS occurrenceCount,
   first_seen AS firstSeen,
   last_seen AS lastSeen`;
 function toRow(raw) {
-  const { provider, ...rest } = raw;
-  return provider === null ? rest : { ...rest, provider };
+  const { provider, userAuthorized, ...rest } = raw;
+  const row = { ...rest, userAuthorized: userAuthorized !== 0 };
+  return provider === null ? row : { ...row, provider };
 }
 var SqliteSecretVaultRepository = class {
   constructor(db) {
@@ -29672,17 +30251,18 @@ var SqliteSecretVaultRepository = class {
          pointer_id, value_fingerprint, fingerprint_key_version, key_version,
          format_version, category, rule_id, masked_match, provider,
          ciphertext, nonce, auth_tag,
-         occurrence_count, first_seen, last_seen
+         user_authorized, occurrence_count, first_seen, last_seen
        ) VALUES (
          :pointerId, :valueFingerprint, :fingerprintKeyVersion, :keyVersion,
          :formatVersion, :category, :ruleId, :maskedMatch, :provider,
          :ciphertext, :nonce, :authTag,
-         1, :now, :now
+         :userAuthorized, 1, :now, :now
        )`
     );
     this.bumpStmt = db.prepare(
       `UPDATE secret_vault
-       SET occurrence_count = occurrence_count + 1, last_seen = :now
+       SET occurrence_count = occurrence_count + 1, last_seen = :now,
+           user_authorized = max(user_authorized, :userAuthorized)
        WHERE value_fingerprint = :valueFingerprint`
     );
     this.byPointerStmt = db.prepare(
@@ -29702,6 +30282,7 @@ var SqliteSecretVaultRepository = class {
        SET value_fingerprint = :valueFingerprint, fingerprint_key_version = :fingerprintKeyVersion
        WHERE pointer_id = :pointerId`
     );
+    this.deleteByPointerStmt = db.prepare(`DELETE FROM secret_vault WHERE pointer_id = :pointerId`);
     this.derefStmt = db.prepare(
       `INSERT INTO secret_vault_deref (id, pointer_id, at, target, reason, outcome, grant_id, pointer_count)
        VALUES (:id, :pointerId, :at, :target, :reason, :outcome, :grantId, :pointerCount)`
@@ -29715,6 +30296,7 @@ var SqliteSecretVaultRepository = class {
   listStmt;
   replaceCiphertextStmt;
   refreshFingerprintStmt;
+  deleteByPointerStmt;
   derefStmt;
   /**
    * Vault a value, or record another sighting of one already vaulted. Keyed on
@@ -29723,6 +30305,11 @@ var SqliteSecretVaultRepository = class {
    * pointer, category and ciphertext, so the same secret always resolves to one
    * wire token. `minted` is true only when this call created the row.
    *
+   * `userAuthorized` is the one field a repeat call may still change, and only
+   * upwards: it records that a PERSON asked for this value to be replaced, and
+   * the row is shared with every automatic path that vaults the same value. See
+   * `bumpStmt` for why clearing it is the defect this shape exists to refuse.
+   *
    * The read-then-write runs in one IMMEDIATE transaction so two concurrent
    * writers cannot both decide they are minting.
    */
@@ -29749,13 +30336,18 @@ var SqliteSecretVaultRepository = class {
               ciphertext: input2.ciphertext,
               nonce: input2.nonce,
               authTag: input2.authTag,
+              userAuthorized: input2.userAuthorized === true ? 1 : 0,
               now
             })
           );
           minted = true;
           return;
         }
-        this.bumpStmt.run({ valueFingerprint: input2.valueFingerprint, now });
+        this.bumpStmt.run({
+          valueFingerprint: input2.valueFingerprint,
+          userAuthorized: input2.userAuthorized === true ? 1 : 0,
+          now
+        });
       },
       "IMMEDIATE"
     );
@@ -29815,6 +30407,42 @@ var SqliteSecretVaultRepository = class {
     );
     return destroyed;
   }
+  /**
+   * Destroy the named entries and report WHICH ones went — the scoped
+   * counterpart to `purgeAll`, for a caller that has already put those specific
+   * values back where they came from. Ids the store does not hold are absent
+   * from the answer rather than an error, so a set assembled from a stale read
+   * is not a fault. The deref audit is left alone, exactly as the purge leaves
+   * it.
+   *
+   * The ids come back rather than a count because the caller's next act is to
+   * write a purge row per destroyed entry, and a record of destruction has to
+   * be a record of what was really destroyed: a selection is a claim about a
+   * read that has since gone stale, and auditing from it invents a purge for an
+   * entry still sitting in the vault.
+   *
+   * One transaction over the whole set rather than a statement per id: the
+   * caller hands this the result of a restore pass it has completed, and a
+   * fault partway through must leave the vault as it was found rather than
+   * destroying a prefix of it. The vault holds the only copy of what a pointer
+   * stands for, so half a delete is not a state anything can recover from.
+   */
+  deleteByPointerIds(pointerIds) {
+    if (pointerIds.length === 0) return [];
+    const deleted = [];
+    withTransaction(
+      this.db,
+      () => {
+        for (const pointerId of pointerIds) {
+          if (Number(this.deleteByPointerStmt.run({ pointerId }).changes) > 0) {
+            deleted.push(pointerId);
+          }
+        }
+      },
+      "IMMEDIATE"
+    );
+    return deleted;
+  }
   /**
    * Record (or re-stamp) one place a pointer has been written. One row per
    * (pointer, location); a re-sighting bumps last_seen. Best-effort bookkeeping
@@ -29827,7 +30455,7 @@ var SqliteSecretVaultRepository = class {
          VALUES (:id, :pointerId, :location, :kind, :now, :now)
          ON CONFLICT (pointer_id, location) DO UPDATE SET last_seen = :now`
     ).run({
-      id: randomUUID8(),
+      id: randomUUID9(),
       pointerId: entry.pointerId,
       location: entry.location,
       kind: entry.kind,
@@ -30340,15 +30968,15 @@ var SqliteSecurityRepository = class {
     const from = now - RANGE_DAYS[range] * DAY_MS4;
     const rows = allRows(
       this.db.prepare(
-        `SELECT json_extract(e.attributes, '$.repo') AS repo, count(*) AS c
+        `SELECT e.repo AS repo, count(*) AS c
          FROM inspection_findings f
          JOIN audit_events e ON e.id = f.audit_event_id
          WHERE e.started_at >= :from AND e.started_at < :to
            AND e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})
-           AND json_extract(e.attributes, '$.repo') IS NOT NULL
-           AND json_extract(e.attributes, '$.repo') != ''
-         GROUP BY repo
-         ORDER BY c DESC, repo
+           AND e.repo IS NOT NULL
+           AND e.repo != ''
+         GROUP BY e.repo
+         ORDER BY c DESC, e.repo
          LIMIT :limit`
       ),
       { from, to: now, limit }
@@ -30410,7 +31038,7 @@ var SqliteSecurityRepository = class {
         `SELECT f.finding_key AS finding_key,
                 d.rule_id AS rule_id,
                 d.severity AS severity,
-                json_extract(e.attributes, '$.file_path') AS path,
+                e.file_path AS path,
                 COALESCE(f.first_detected_at, e.started_at) AS first_detected_at,
                 latest.resolved_at AS latest_resolved_at
          FROM ${LATEST_RESOLUTION_BY_KEY_SQL} latest
@@ -30463,7 +31091,7 @@ var SqliteSecurityRepository = class {
 };
 
 // ../../packages/persistence/src/repositories/shares.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 var MAX_EGRESS_CALL_SITES_PER_PROJECT = 5e3;
 var IN_CHUNK = 500;
 var KIND_ORDER = ["provider", "internal", "external", "ip"];
@@ -30551,7 +31179,7 @@ function buildSummary(dest, endpoints) {
     callSiteCount,
     transports: distinctTransports(transports),
     dataClasses: distinctDataClasses(dataClasses),
-    review: buildReviewInfo(dest.trust, transports),
+    review: buildReviewInfo(dest.trust, transports, dest.overrideDecision !== null),
     network: dest.kind === "provider" ? null : parseNetwork(dest.networkJson),
     endpoints: endpoints.map(toEndpointSummary)
   };
@@ -30578,7 +31206,7 @@ function buildDetail(dest, endpoints, callSites) {
     lastSeen: new Date(lastSeenMs).toISOString(),
     transports: distinctTransports(transports),
     dataClasses: distinctDataClasses(endpoints.map((e) => e.dataClass)),
-    review: buildReviewInfo(dest.trust, transports),
+    review: buildReviewInfo(dest.trust, transports, dest.overrideDecision !== null),
     network: dest.kind === "provider" ? null : parseNetwork(dest.networkJson),
     note: dest.note,
     endpoints: endpoints.map((ep) => ({
@@ -30607,7 +31235,11 @@ var SqliteSharesRepository = class {
        FROM share_destination d
        LEFT JOIN share_endpoint e ON e.destination_id = d.id
          AND e.transport IN ${PLAINTEXT_TRANSPORT_SQL}
-       WHERE d.trust IN ('unverified', 'ip') OR e.id IS NOT NULL`
+       WHERE (d.trust IN ('unverified', 'ip') OR e.id IS NOT NULL)
+         AND NOT EXISTS (
+           SELECT 1 FROM egress_decision_override o
+           WHERE o.host = d.host OR (o.destination_id = d.id AND o.host IS NULL)
+         )`
     );
     const kindCounts = countBy(
       this.db,
@@ -30719,7 +31351,7 @@ var SqliteSharesRepository = class {
                (id, destination_id, host, decision, created_at, updated_at)
              VALUES (:id, :destinationId, :host, :decision, :now, :now)`
         ).run({
-          id: randomUUID9(),
+          id: randomUUID10(),
           destinationId,
           host: dest.host,
           decision,
@@ -30868,7 +31500,7 @@ var SqliteSharesRepository = class {
       let destinationId = destIds.get(hit.host);
       if (destinationId === void 0) {
         destStmt.run({
-          id: randomUUID9(),
+          id: randomUUID10(),
           kind: hit.kind,
           name: hit.name,
           host: hit.host,
@@ -30884,7 +31516,7 @@ var SqliteSharesRepository = class {
       let endpointId = endpointIds.get(endpointKey);
       if (endpointId === void 0) {
         endpointStmt.run({
-          id: randomUUID9(),
+          id: randomUUID10(),
           destinationId,
           method: hit.method,
           transport: hit.transport,
@@ -30897,7 +31529,7 @@ var SqliteSharesRepository = class {
         endpointIds.set(endpointKey, endpointId);
       }
       siteStmt.run({
-        id: randomUUID9(),
+        id: randomUUID10(),
         endpointId,
         project: input2.project,
         projectKey: input2.projectKey,
@@ -31262,6 +31894,7 @@ function purgeSampleData(db) {
 }
 
 // ../../packages/persistence/src/database.ts
+var CAPTURE_GRAIN = new Set(EventKind.options);
 var UNSAFE_TEST_ONLY_RAW_HANDLE = /* @__PURE__ */ Symbol(
   "aka.persistence.unsafeTestOnlyRawHandle"
 );
@@ -31309,7 +31942,7 @@ function backupLegacyStore(db, file2) {
   discardStore(file2, backup);
   return backup;
 }
-function openAndInitialize(file2) {
+function openAndInitialize(file2, base) {
   let db = openWithPragmas(file2);
   try {
     if (isForeignSqliteLineage(db)) {
@@ -31322,7 +31955,7 @@ function openAndInitialize(file2) {
     applyMigrations(db, file2);
     tightenPerms(file2);
     const policies = new SqlitePoliciesRepository(db);
-    const installedPacks = new SqliteInstalledPacksRepository(db);
+    const installedPacks = new SqliteInstalledPacksRepository(db, base);
     const repositories = {
       events: new SqliteEventsRepository(db),
       findings: new SqliteFindingsRepository(db),
@@ -31358,7 +31991,7 @@ function openAndInitialize(file2) {
 }
 function openLocalDatabase(dir) {
   ensureDataDirSync(dir);
-  const file2 = join4(dir, DB_FILENAME);
+  const file2 = join7(dir, DB_FILENAME);
   reapStalePartials(file2);
   const {
     db,
@@ -31386,7 +32019,13 @@ function openLocalDatabase(dir) {
     inspectionDefinitions,
     inspectionFindings,
     configInventory
-  } = openAndInitialize(file2);
+  } = openAndInitialize(
+    file2,
+    // `dir` is always `<base>/data` — every caller resolves it through
+    // `dataDir()` — so its parent is the `~/.aka` base the layout splits into
+    // settings/ and data/, and the pack-policy floor needs both halves.
+    dirname2(dir)
+  );
   function captureRowId(event) {
     return captureId(
       event.metadata?.sessionId ?? null,
@@ -31399,6 +32038,21 @@ function openLocalDatabase(dir) {
       historySync.markSynced([captureRowId(event)], atMs);
     });
   }
+  function markCaptureOwed(event) {
+    failOpenTransaction(db, () => {
+      historySync.markCaptureOwed(captureRowId(event));
+    });
+  }
+  function markAuditEventsDelivered(events2, atMs) {
+    const stampable = events2.filter((event) => !CAPTURE_GRAIN.has(event.eventType));
+    if (stampable.length === 0) return;
+    failOpenTransaction(db, () => {
+      historySync.markSynced(
+        stampable.map((event) => event.id),
+        atMs
+      );
+    });
+  }
   function recordCapture(event, detected) {
     failOpenTransaction(db, () => {
       const sessionId = event.metadata?.sessionId;
@@ -31485,7 +32139,7 @@ function openLocalDatabase(dir) {
         const definitionId = definitionIds.get(`${finding.ruleId}@${finding.version}`);
         if (!definitionId) continue;
         inspectionFindings.insertFinding({
-          id: randomUUID10(),
+          id: randomUUID11(),
           auditEventId: record2.scanEvent.id,
           inspectionDefinitionId: definitionId,
           span: finding.span,
@@ -31581,6 +32235,8 @@ function openLocalDatabase(dir) {
     inspectionFindings,
     recordCapture,
     markCaptureDelivered,
+    markCaptureOwed,
+    markAuditEventsDelivered,
     ensureInventory,
     recordConfigScan,
     recordProjectFiles,
@@ -31599,179 +32255,360 @@ function openLocalDatabase(dir) {
   };
 }
 
-// ../../packages/persistence/src/file-lock.ts
-import { randomUUID as randomUUID11 } from "crypto";
-import {
-  closeSync,
-  existsSync as existsSync2,
-  openSync,
-  readFileSync as readFileSync2,
-  rmSync as rmSync5,
-  statSync as statSync3,
-  writeFileSync as writeFileSync2
-} from "fs";
-import { hostname as hostname3 } from "os";
-var PARK = new Int32Array(new SharedArrayBuffer(4));
-
 // ../../packages/persistence/src/finding-key.ts
 import { createHash as createHash3 } from "crypto";
 
 // ../../packages/persistence/src/fingerprint.ts
 import { createHmac, randomBytes } from "crypto";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync6 } from "fs";
+import { join as join8 } from "path";
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 
 // ../../packages/persistence/src/history-preview.ts
 import { existsSync as existsSync4 } from "fs";
-import { join as join6 } from "path";
+import { join as join9 } from "path";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 
-// ../../packages/persistence/src/local-layout.ts
-import { renameSync as renameSync3 } from "fs";
-import { mkdir } from "fs/promises";
-import { homedir } from "os";
-import { join as join7 } from "path";
-function defaultDataDir() {
-  return join7(homedir(), ".aka");
-}
-function settingsDir(base = defaultDataDir()) {
-  return join7(base, "settings");
-}
-function dataDir(base = defaultDataDir()) {
-  return join7(base, "data");
-}
+// ../../packages/persistence/src/store-symlinks.ts
+import { existsSync as existsSync5, lstatSync as lstatSync3, readlinkSync, realpathSync, statSync as statSync4 } from "fs";
+import { dirname as dirname3, join as join10, resolve } from "path";
 
-// ../../packages/persistence/src/managed-settings.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { posix, win32 } from "path";
-function managedSettingsPaths(platform2 = process.platform) {
-  if (platform2 === "darwin") {
-    return [
-      posix.join("/Library", "Application Support", "AKASecurity", MANAGED_SETTINGS_FILENAME),
-      posix.join("/Library", "Managed Preferences", MANAGED_SETTINGS_FILENAME)
-    ];
-  }
-  if (platform2 === "win32") {
-    return [win32.join("C:\\", "ProgramData", "AKASecurity", MANAGED_SETTINGS_FILENAME)];
+// ../../packages/persistence/src/vault/crypto.ts
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHmac as createHmac2,
+  hkdfSync,
+  timingSafeEqual
+} from "crypto";
+
+// ../../packages/persistence/src/vault/key-provider.ts
+import { execFileSync } from "child_process";
+import { randomBytes as randomBytes2 } from "crypto";
+import { chmodSync as chmodSync3, readFileSync as readFileSync7, renameSync as renameSync4, rmSync as rmSync6, statSync as statSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join11 } from "path";
+
+// ../../packages/persistence/src/vault/vault.ts
+import { randomBytes as randomBytes3, randomUUID as randomUUID12 } from "crypto";
+
+// ../../packages/persistence/src/warn-era-cap.ts
+import { existsSync as existsSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join12 } from "path";
+
+// ../../packages/remote/src/http.ts
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
+var RemoteRequestError = class extends Error {
+  constructor(status) {
+    super(`control-plane request failed with status ${String(status)}`);
+    this.status = status;
+    this.name = "RemoteRequestError";
   }
-  return [posix.join("/etc", "aka", MANAGED_SETTINGS_FILENAME)];
-}
-function readManagedSettings(paths = managedSettingsPaths()) {
-  for (const path of paths) {
-    let text;
-    try {
-      text = readFileSync4(path, "utf8");
-    } catch {
-      continue;
-    }
-    const record2 = parseJsonObject(text);
-    if (!record2) continue;
-    const parsed2 = ManagedSettings.safeParse(record2);
-    if (parsed2.success) return parsed2.data;
+  status;
+};
+var RemoteRouteAbsent = class extends Error {
+  constructor(route) {
+    super(`control plane does not serve ${route}`);
+    this.route = route;
+    this.name = "RemoteRouteAbsent";
   }
-  return null;
-}
-function overlayManagedSettings(settings, managed, now = () => /* @__PURE__ */ new Date()) {
-  if (!managed) return settings;
-  const { values } = managed;
-  const merged = { ...settings };
-  if (values.runMode !== void 0) merged.runMode = values.runMode;
-  if (values.controlPlane !== void 0) {
-    merged.controlPlane = {
-      ...values.controlPlane,
-      // The administrator pinned WHICH deployment, not WHEN this machine
-      // joined it. Keep the user's own attach time when the endpoint is
-      // unchanged, so a managed machine does not appear to re-attach on every
-      // read; stamp a fresh one when the administrator moved it.
-      attachedAt: settings.controlPlane?.endpoint === values.controlPlane.endpoint ? settings.controlPlane.attachedAt : now().toISOString()
-    };
+  route;
+};
+var RemoteRequestInvalid = class extends Error {
+  constructor(route, cause) {
+    super(`refusing to send a malformed body to ${route}`);
+    this.cause = cause;
+    this.name = "RemoteRequestInvalid";
   }
-  if (values.historicalAccess !== void 0) merged.historicalAccess = values.historicalAccess;
-  if (values.vaultKeyCustody !== void 0) merged.vaultKeyCustody = values.vaultKeyCustody;
-  if (values.vaultInlineReveal !== void 0) merged.vaultInlineReveal = values.vaultInlineReveal;
-  if (values.dataSharesInPlace !== void 0) merged.dataSharesInPlace = values.dataSharesInPlace;
-  if (values.vaultConsent !== void 0) {
-    merged.vaultConsent = values.vaultConsent ? (
-      // Keep an existing valid grant so its acknowledgedAt survives; mint one
-      // at the current version otherwise.
-      settings.vaultConsent?.version === VAULT_CONSENT_VERSION ? settings.vaultConsent : { acknowledgedAt: now().toISOString(), version: VAULT_CONSENT_VERSION }
-    ) : void 0;
+  cause;
+};
+var RemoteResponseInvalid = class extends Error {
+  constructor(route, detail) {
+    super(`control plane answered ${route} with ${detail}`);
+    this.name = "RemoteResponseInvalid";
   }
-  if (values.modelJudgeConsent !== void 0) {
-    merged.modelJudgeConsent = values.modelJudgeConsent ? settings.modelJudgeConsent?.payloadVersion === MODEL_JUDGE_PAYLOAD_VERSION ? settings.modelJudgeConsent : {
-      acknowledgedAt: now().toISOString(),
-      payloadVersion: MODEL_JUDGE_PAYLOAD_VERSION
-    } : void 0;
+};
+var RemoteTransportError = class extends Error {
+  /**
+   * The status the peer sent, when headers arrived and only the BODY was
+   * refused.
+   *
+   * Undefined for the ordinary case this class was written for — no answer at
+   * all. It exists because two paths reject after a status has already been
+   * delivered: an oversized body and an aborted response. Discarding it there
+   * reported a deployment answering 401 with a verbose body as a network
+   * outage, which sends the reader to look at their network instead of their
+   * credential.
+   */
+  constructor(reason, status) {
+    super(`control-plane request did not complete: ${reason}`);
+    this.status = status;
+    this.name = "RemoteTransportError";
   }
-  return merged;
+  status;
+};
+async function send(options) {
+  const url2 = new URL(options.url);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const send_ = url2.protocol === "http:" ? httpRequest : httpsRequest;
+  const requestOptions = {
+    method: options.method,
+    headers: {
+      // CALLER HEADERS FIRST, so this module's own are not overridable. Spread
+      // last they win, and two of the values below are ones no caller may
+      // replace: `x-api-key` is the credential, and `content-length` is the
+      // byte count that stops a multi-byte body being truncated by the
+      // receiver. `SendOptions.headers` is a free-form record on an exported
+      // function, so "no caller does that today" is not the guarantee to rely
+      // on. The one header any caller actually passes — `if-none-match` on the
+      // conditional GET — is untouched by this order.
+      ...options.headers,
+      // The credential. One header, matching what the deployment authenticates
+      // on; a second copy in an `Authorization` header would be one more place
+      // it can be logged by an intermediary for no gain.
+      //
+      // Spread conditionally rather than assigned as `undefined`: Node's header
+      // handling and `content-length` bookkeeping treat a present-but-undefined
+      // key differently from an absent one, and "the header is not there" is
+      // the property the attach flow needs.
+      ...options.apiKey === void 0 ? {} : { "x-api-key": options.apiKey },
+      accept: "application/json",
+      ...options.body === void 0 ? {} : {
+        "content-type": "application/json",
+        // Byte length, not string length: a multi-byte body sent with a
+        // character count is truncated by the receiver.
+        "content-length": String(Buffer.byteLength(options.body))
+      }
+    }
+  };
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const fail = (reason, status) => {
+      if (settled) return;
+      settled = true;
+      reject(new RemoteTransportError(reason, status));
+    };
+    const req = send_(url2, requestOptions, (res) => {
+      const chunks = [];
+      let size = 0;
+      res.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > MAX_RESPONSE_BYTES) {
+          fail(`response exceeded ${String(MAX_RESPONSE_BYTES)} bytes`, res.statusCode);
+          res.destroy();
+          req.destroy();
+          return;
+        }
+        chunks.push(chunk);
+      });
+      res.on("aborted", () => {
+        fail("the response was aborted", res.statusCode);
+      });
+      res.on("end", () => {
+        if (settled) return;
+        settled = true;
+        resolve2({
+          status: res.statusCode ?? 0,
+          headers: res.headers,
+          body: Buffer.concat(chunks).toString("utf8")
+        });
+      });
+    });
+    const deadline = setTimeout(() => {
+      fail(`no response within ${String(timeoutMs)}ms`);
+      req.destroy();
+    }, timeoutMs);
+    deadline.unref();
+    req.on("upgrade", (_res, socket) => {
+      fail("the deployment answered with a protocol upgrade");
+      socket.destroy();
+    });
+    req.on("close", () => {
+      fail("the connection closed before a response was read");
+      clearTimeout(deadline);
+    });
+    req.on("error", (err) => {
+      fail(err.message);
+    });
+    if (options.body !== void 0) req.write(options.body);
+    req.end();
+  });
 }
 
-// ../../packages/persistence/src/settings.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { join as join8 } from "path";
-var SETTINGS_FILENAME = "settings.json";
-function readWorkspaceSettings(base = defaultDataDir()) {
-  return overlayManagedSettings(readUserSettings(base), readManagedSettings());
+// ../../packages/remote/src/client.ts
+var ROUTES = {
+  events: "/v1/events",
+  auditEvents: "/v1/audit-events",
+  auditEventsBatch: "/v1/audit-events/batch",
+  inventory: "/v1/inventory",
+  storePosture: "/v1/store-posture",
+  policyBundle: "/v1/policy-bundle",
+  whoami: "/v1/plugin/whoami",
+  shares: "/v1/shares",
+  commands: "/v1/plugin/commands"
+};
+function ackRoute(id) {
+  return `${ROUTES.commands}/${encodeURIComponent(id)}/ack`;
 }
-function readUserSettings(base) {
-  const record2 = readJson(join8(settingsDir(base), SETTINGS_FILENAME));
-  if (!record2) return defaultWorkspaceSettings();
-  try {
-    return WorkspaceSettings.parse(record2);
-  } catch {
-    return defaultWorkspaceSettings();
+function headerValue(response, name) {
+  const raw = response.headers[name];
+  if (raw === void 0) return void 0;
+  return Array.isArray(raw) ? raw[0] : raw;
+}
+function okBody(response) {
+  if (response.status < 200 || response.status >= 300) {
+    throw new RemoteRequestError(response.status);
   }
+  return response.body;
 }
-function readJson(file2) {
-  let text;
+function parsed(schema, body, route) {
+  let json2;
   try {
-    text = readFileSync5(file2, "utf8");
+    json2 = JSON.parse(body);
   } catch {
-    return null;
+    throw new RemoteResponseInvalid(route, "a body that is not JSON");
   }
-  return parseJsonObject(text) ?? null;
+  const result = schema.safeParse(json2);
+  if (!result.success) {
+    throw new RemoteResponseInvalid(route, "a body this client cannot read");
+  }
+  return result.data;
+}
+function withoutTrailingSlashes(endpoint) {
+  let end = endpoint.length;
+  while (end > 0 && endpoint.charCodeAt(end - 1) === SLASH) end -= 1;
+  return endpoint.slice(0, end);
+}
+var SLASH = "/".charCodeAt(0);
+function createRemoteClient(options) {
+  const base = withoutTrailingSlashes(options.endpoint);
+  const url2 = (route) => `${base}${route}`;
+  const common = { apiKey: options.apiKey, timeoutMs: options.timeoutMs };
+  const sendOne = async (event) => {
+    const validated = RecordAuditEventRequest.safeParse(event);
+    if (!validated.success) throw new RemoteRequestInvalid(ROUTES.auditEvents, validated.error);
+    const response = await send({
+      ...common,
+      method: "POST",
+      url: url2(ROUTES.auditEvents),
+      body: JSON.stringify(validated.data)
+    });
+    okBody(response);
+  };
+  return {
+    async ingestEvents(batch) {
+      const response = await send({
+        ...common,
+        method: "POST",
+        url: url2(ROUTES.events),
+        body: JSON.stringify(batch)
+      });
+      return parsed(IngestAck, okBody(response), ROUTES.events);
+    },
+    async ingestInventory(context) {
+      const response = await send({
+        ...common,
+        method: "POST",
+        url: url2(ROUTES.inventory),
+        body: JSON.stringify(context)
+      });
+      return parsed(ResolvedInventory, okBody(response), ROUTES.inventory);
+    },
+    async recordAuditEvent(event) {
+      await sendOne(event);
+    },
+    async recordAuditEvents(events, opts) {
+      const validated = RecordAuditEventBatch.safeParse({ events });
+      if (!validated.success) {
+        throw new RemoteRequestInvalid(ROUTES.auditEventsBatch, validated.error);
+      }
+      const response = await send({
+        ...common,
+        method: "POST",
+        url: url2(ROUTES.auditEventsBatch),
+        body: JSON.stringify(validated.data)
+      });
+      if (response.status === 404) {
+        if (opts?.fallbackToSingleEvents !== true) {
+          throw new RemoteRouteAbsent(ROUTES.auditEventsBatch);
+        }
+        for (const event of validated.data.events) await sendOne(event);
+        return { accepted: validated.data.events.length };
+      }
+      return parsed(AuditEventBatchAck, okBody(response), ROUTES.auditEventsBatch);
+    },
+    async reportStorePosture(snapshot) {
+      const response = await send({
+        ...common,
+        method: "POST",
+        url: url2(ROUTES.storePosture),
+        body: JSON.stringify(snapshot)
+      });
+      okBody(response);
+    },
+    async getPolicyBundle(etag) {
+      const response = await send({
+        ...common,
+        method: "GET",
+        url: url2(ROUTES.policyBundle),
+        ...etag === void 0 ? {} : { headers: { "if-none-match": etag } }
+      });
+      if (response.status === 304) {
+        return { changed: false, etag: headerValue(response, "etag") ?? etag };
+      }
+      const bundle = parsed(PolicyBundle, okBody(response), ROUTES.policyBundle);
+      return { changed: true, bundle, etag: headerValue(response, "etag") };
+    },
+    async whoami() {
+      const response = await send({ ...common, method: "GET", url: url2(ROUTES.whoami) });
+      return parsed(PluginWhoami, okBody(response), ROUTES.whoami);
+    },
+    async recordProjectEgress(request) {
+      const validated = EgressIngestRequest.safeParse(request);
+      if (!validated.success) throw new RemoteRequestInvalid(ROUTES.shares, validated.error);
+      const response = await send({
+        ...common,
+        method: "POST",
+        url: url2(ROUTES.shares),
+        body: JSON.stringify(validated.data)
+      });
+      okBody(response);
+    },
+    async pollCommand() {
+      const response = await send({ ...common, method: "GET", url: url2(ROUTES.commands) });
+      if (response.status === 404) return null;
+      return parsed(DeviceCommandPollResponse, okBody(response), ROUTES.commands).command;
+    },
+    async ackCommand(id, body) {
+      const validated = DeviceCommandAckBody.safeParse(body);
+      const route = ackRoute(id);
+      if (!validated.success) throw new RemoteRequestInvalid(route, validated.error);
+      const response = await send({
+        ...common,
+        method: "POST",
+        url: url2(route),
+        body: JSON.stringify(validated.data)
+      });
+      okBody(response);
+    }
+  };
 }
 
-// ../../packages/persistence/src/store-symlinks.ts
-import { existsSync as existsSync5, lstatSync as lstatSync3, readlinkSync, realpathSync, statSync as statSync4 } from "fs";
-import { dirname as dirname2, join as join9, resolve } from "path";
-
-// ../../packages/persistence/src/vault/crypto.ts
-import {
-  createCipheriv,
-  createDecipheriv,
-  createHmac as createHmac2,
-  hkdfSync,
-  timingSafeEqual
-} from "crypto";
-
-// ../../packages/persistence/src/vault/key-provider.ts
-import { execFileSync } from "child_process";
-import { randomBytes as randomBytes2 } from "crypto";
-import { chmodSync as chmodSync3, readFileSync as readFileSync6, renameSync as renameSync4, rmSync as rmSync6, statSync as statSync5, writeFileSync as writeFileSync3 } from "fs";
-import { join as join10 } from "path";
-
-// ../../packages/persistence/src/vault/vault.ts
-import { randomBytes as randomBytes3, randomUUID as randomUUID12 } from "crypto";
-
-// ../../packages/persistence/src/warn-era-cap.ts
-import { existsSync as existsSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join11 } from "path";
-
 // ../../packages/plugin-runtime/src/attached/forward-drops.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join13 } from "path";
 
 // ../../packages/plugin-runtime/src/attached/forward-policy.ts
 import { randomUUID as randomUUID15 } from "crypto";
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { readFile, rename, writeFile } from "fs/promises";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 
 // ../../packages/plugin-sdk/src/config.ts
 import { existsSync as existsSync7 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 
 // ../../packages/plugin-sdk/src/provider-env.ts
 var booleanish = external_exports.string().optional().transform((v) => {
@@ -31792,9 +32629,9 @@ var providerEnvShape = {
 var ProviderEnvSchema = external_exports.object(providerEnvShape);
 
 // ../../packages/plugin-sdk/src/config-inventory.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync9, realpathSync as realpathSync2, statSync as statSync7 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync10, realpathSync as realpathSync2, statSync as statSync7 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename as basename3, join as join15 } from "path";
+import { basename as basename3, join as join16 } from "path";
 
 // ../../packages/detections/src/egress/registry.ts
 var EXTRACTOR_VERSION = "1";
@@ -32552,8 +33389,8 @@ var CPU_CORROBORATION_SHARE = 0.2;
 var CORROBORATION_FLOOR_MS = BUDGET_MS * CPU_CORROBORATION_SHARE;
 
 // ../../packages/plugin-sdk/src/repo.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8, statSync as statSync6 } from "fs";
-import { basename as basename2, dirname as dirname3, isAbsolute, join as join14, sep as sep2 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
+import { basename as basename2, dirname as dirname4, isAbsolute, join as join15, sep as sep2 } from "path";
 
 // ../../packages/plugin-sdk/src/events.ts
 import { createHash as createHash5, randomUUID as randomUUID13 } from "crypto";
@@ -32565,8 +33402,8 @@ import { Worker } from "worker_threads";
 
 // ../../packages/plugin-sdk/src/ignore-layers.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import { readFileSync as readFileSync10 } from "fs";
-import { join as join16 } from "path";
+import { readFileSync as readFileSync11 } from "fs";
+import { join as join17 } from "path";
 
 // ../../packages/plugin-sdk/src/inventory-resolver.ts
 import { arch, hostname as hostname4, platform, release } from "os";
@@ -32577,24 +33414,24 @@ import {
   fstatSync,
   mkdirSync as mkdirSync2,
   openSync as openSync2,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   readSync,
   writeFileSync as writeFileSync5
 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 var TAIL_BYTES = 256 * 1024;
 
 // ../../packages/plugin-sdk/src/nudge.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "fs";
-import { join as join18 } from "path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
+import { join as join19 } from "path";
 
 // ../../packages/plugin-sdk/src/paths.ts
 import { readdirSync as readdirSync3, realpathSync as realpathSync3 } from "fs";
-import { basename as basename4, dirname as dirname4, sep as sep3 } from "path";
+import { basename as basename4, dirname as dirname5, sep as sep3 } from "path";
 
 // ../../packages/plugin-sdk/src/project-files.ts
 import { existsSync as existsSync10, readdirSync as readdirSync4 } from "fs";
-import { basename as basename5, join as join19 } from "path";
+import { basename as basename5, join as join20 } from "path";
 
 // ../../packages/plugin-sdk/src/provider-env-antigravity.ts
 var optionalBaseUrl2 = external_exports.preprocess((v) => {
@@ -32630,7 +33467,7 @@ var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
 
 // ../../packages/plugin-sdk/src/throttle.ts
 import { mkdirSync as mkdirSync4, statSync as statSync8, writeFileSync as writeFileSync7 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 
 // ../../packages/plugin-runtime/src/attached/forward-policy.ts
 var BREAKER_COOLDOWN_MS = 3e4;
@@ -32656,15 +33493,15 @@ function parseBreakerState(raw, nowMs) {
 }
 function readForwardHealth(dir, nowMs = Date.now()) {
   try {
-    return parseBreakerState(readFileSync13(join21(dir, STATE_FILENAME), "utf8"), nowMs);
+    return parseBreakerState(readFileSync14(join22(dir, STATE_FILENAME), "utf8"), nowMs);
   } catch {
     return null;
   }
 }
 
 // ../../packages/plugin-runtime/src/attached/history-state.ts
-import { readFileSync as readFileSync14 } from "fs";
-import { join as join22 } from "path";
+import { readFileSync as readFileSync15 } from "fs";
+import { join as join23 } from "path";
 var HISTORY_SYNC_STATE_FILENAME = ATTACHED_HISTORY_SYNC_STATE_FILENAME;
 var PHASES = /* @__PURE__ */ new Set(["filling", "complete"]);
 var OUTCOMES = /* @__PURE__ */ new Set([
@@ -32672,332 +33509,159 @@ var OUTCOMES = /* @__PURE__ */ new Set([
   "unreachable",
   "refused",
   "interrupted"
-]);
-var SPEC_VERSION = 1;
-function historySyncStatePath(dataDir2) {
-  return join22(dataDir2, HISTORY_SYNC_STATE_FILENAME);
-}
-function writeHistorySyncState(dataDir2, state) {
-  try {
-    ensureDataDirSync(dataDir2);
-    const persisted = { specVersion: SPEC_VERSION, ...state };
-    writeOwnerOnlyFileSync(historySyncStatePath(dataDir2), `${JSON.stringify(persisted)}
-`);
-  } catch {
-  }
-}
-function readHistorySyncState(dataDir2) {
-  try {
-    const parsed2 = JSON.parse(readFileSync14(historySyncStatePath(dataDir2), "utf8"));
-    if (typeof parsed2 !== "object" || parsed2 === null) return null;
-    const r = parsed2;
-    if (r.specVersion !== SPEC_VERSION) return null;
-    if (typeof r.phase !== "string" || !PHASES.has(r.phase)) return null;
-    if (typeof r.lastOutcome !== "string" || !OUTCOMES.has(r.lastOutcome)) return null;
-    if (!isCount(r.lastPassAtMs)) return null;
-    if (!isCount(r.sentTotal) || !isCount(r.pendingTotal) || !isCount(r.skippedTotal)) return null;
-    if (!isNullableCount(r.startedAtMs) || !isNullableCount(r.completedAtMs)) return null;
-    return {
-      specVersion: SPEC_VERSION,
-      phase: r.phase,
-      lastOutcome: r.lastOutcome,
-      lastPassAtMs: r.lastPassAtMs,
-      sentTotal: r.sentTotal,
-      pendingTotal: r.pendingTotal,
-      skippedTotal: r.skippedTotal,
-      startedAtMs: r.startedAtMs,
-      completedAtMs: r.completedAtMs
-    };
-  } catch {
-    return null;
-  }
-}
-function isCount(v) {
-  return typeof v === "number" && Number.isFinite(v) && v >= 0;
-}
-function isNullableCount(v) {
-  return v === null || isCount(v);
-}
-
-// ../../packages/plugin-runtime/src/attached/history-sync.ts
-import { createHash as createHash6 } from "crypto";
-import { hostname as hostname5 } from "os";
-
-// ../../packages/remote/src/http.ts
-import { request as httpRequest } from "http";
-import { request as httpsRequest } from "https";
-var DEFAULT_TIMEOUT_MS = 1e4;
-var MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
-var RemoteRequestError = class extends Error {
-  constructor(status) {
-    super(`control-plane request failed with status ${String(status)}`);
-    this.status = status;
-    this.name = "RemoteRequestError";
-  }
-  status;
-};
-var RemoteRequestInvalid = class extends Error {
-  constructor(route, cause) {
-    super(`refusing to send a malformed body to ${route}`);
-    this.cause = cause;
-    this.name = "RemoteRequestInvalid";
-  }
-  cause;
-};
-var RemoteResponseInvalid = class extends Error {
-  constructor(route, detail) {
-    super(`control plane answered ${route} with ${detail}`);
-    this.name = "RemoteResponseInvalid";
-  }
-};
-var RemoteTransportError = class extends Error {
-  /**
-   * The status the peer sent, when headers arrived and only the BODY was
-   * refused.
-   *
-   * Undefined for the ordinary case this class was written for — no answer at
-   * all. It exists because two paths reject after a status has already been
-   * delivered: an oversized body and an aborted response. Discarding it there
-   * reported a deployment answering 401 with a verbose body as a network
-   * outage, which sends the reader to look at their network instead of their
-   * credential.
-   */
-  constructor(reason, status) {
-    super(`control-plane request did not complete: ${reason}`);
-    this.status = status;
-    this.name = "RemoteTransportError";
-  }
-  status;
-};
-async function send(options) {
-  const url2 = new URL(options.url);
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const send_ = url2.protocol === "http:" ? httpRequest : httpsRequest;
-  const requestOptions = {
-    method: options.method,
-    headers: {
-      // CALLER HEADERS FIRST, so this module's own are not overridable. Spread
-      // last they win, and two of the values below are ones no caller may
-      // replace: `x-api-key` is the credential, and `content-length` is the
-      // byte count that stops a multi-byte body being truncated by the
-      // receiver. `SendOptions.headers` is a free-form record on an exported
-      // function, so "no caller does that today" is not the guarantee to rely
-      // on. The one header any caller actually passes — `if-none-match` on the
-      // conditional GET — is untouched by this order.
-      ...options.headers,
-      // The credential. One header, matching what the deployment authenticates
-      // on; a second copy in an `Authorization` header would be one more place
-      // it can be logged by an intermediary for no gain.
-      //
-      // Spread conditionally rather than assigned as `undefined`: Node's header
-      // handling and `content-length` bookkeeping treat a present-but-undefined
-      // key differently from an absent one, and "the header is not there" is
-      // the property the attach flow needs.
-      ...options.apiKey === void 0 ? {} : { "x-api-key": options.apiKey },
-      accept: "application/json",
-      ...options.body === void 0 ? {} : {
-        "content-type": "application/json",
-        // Byte length, not string length: a multi-byte body sent with a
-        // character count is truncated by the receiver.
-        "content-length": String(Buffer.byteLength(options.body))
-      }
-    }
-  };
-  return new Promise((resolve2, reject) => {
-    let settled = false;
-    const fail = (reason, status) => {
-      if (settled) return;
-      settled = true;
-      reject(new RemoteTransportError(reason, status));
-    };
-    const req = send_(url2, requestOptions, (res) => {
-      const chunks = [];
-      let size = 0;
-      res.on("data", (chunk) => {
-        size += chunk.length;
-        if (size > MAX_RESPONSE_BYTES) {
-          fail(`response exceeded ${String(MAX_RESPONSE_BYTES)} bytes`, res.statusCode);
-          res.destroy();
-          req.destroy();
-          return;
-        }
-        chunks.push(chunk);
-      });
-      res.on("aborted", () => {
-        fail("the response was aborted", res.statusCode);
-      });
-      res.on("end", () => {
-        if (settled) return;
-        settled = true;
-        resolve2({
-          status: res.statusCode ?? 0,
-          headers: res.headers,
-          body: Buffer.concat(chunks).toString("utf8")
-        });
-      });
-    });
-    const deadline = setTimeout(() => {
-      fail(`no response within ${String(timeoutMs)}ms`);
-      req.destroy();
-    }, timeoutMs);
-    deadline.unref();
-    req.on("upgrade", (_res, socket) => {
-      fail("the deployment answered with a protocol upgrade");
-      socket.destroy();
-    });
-    req.on("close", () => {
-      fail("the connection closed before a response was read");
-      clearTimeout(deadline);
-    });
-    req.on("error", (err) => {
-      fail(err.message);
-    });
-    if (options.body !== void 0) req.write(options.body);
-    req.end();
-  });
-}
-
-// ../../packages/remote/src/client.ts
-var ROUTES = {
-  events: "/v1/events",
-  auditEvents: "/v1/audit-events",
-  auditEventsBatch: "/v1/audit-events/batch",
-  inventory: "/v1/inventory",
-  storePosture: "/v1/store-posture",
-  policyBundle: "/v1/policy-bundle",
-  whoami: "/v1/plugin/whoami",
-  shares: "/v1/shares"
-};
-function headerValue(response, name) {
-  const raw = response.headers[name];
-  if (raw === void 0) return void 0;
-  return Array.isArray(raw) ? raw[0] : raw;
+]);
+var SPEC_VERSION = 1;
+function historySyncStatePath(dataDir2) {
+  return join23(dataDir2, HISTORY_SYNC_STATE_FILENAME);
 }
-function okBody(response) {
-  if (response.status < 200 || response.status >= 300) {
-    throw new RemoteRequestError(response.status);
+function writeHistorySyncState(dataDir2, state) {
+  try {
+    ensureDataDirSync(dataDir2);
+    const persisted = { specVersion: SPEC_VERSION, ...state };
+    writeOwnerOnlyFileSync(historySyncStatePath(dataDir2), `${JSON.stringify(persisted)}
+`);
+  } catch {
   }
-  return response.body;
 }
-function parsed(schema, body, route) {
-  let json2;
+function readHistorySyncState(dataDir2) {
   try {
-    json2 = JSON.parse(body);
+    const parsed2 = JSON.parse(readFileSync15(historySyncStatePath(dataDir2), "utf8"));
+    if (typeof parsed2 !== "object" || parsed2 === null) return null;
+    const r = parsed2;
+    if (r.specVersion !== SPEC_VERSION) return null;
+    if (typeof r.phase !== "string" || !PHASES.has(r.phase)) return null;
+    if (typeof r.lastOutcome !== "string" || !OUTCOMES.has(r.lastOutcome)) return null;
+    if (!isCount(r.lastPassAtMs)) return null;
+    if (!isCount(r.sentTotal) || !isCount(r.pendingTotal) || !isCount(r.skippedTotal)) return null;
+    if (!isNullableCount(r.startedAtMs) || !isNullableCount(r.completedAtMs)) return null;
+    return {
+      specVersion: SPEC_VERSION,
+      phase: r.phase,
+      lastOutcome: r.lastOutcome,
+      lastPassAtMs: r.lastPassAtMs,
+      sentTotal: r.sentTotal,
+      pendingTotal: r.pendingTotal,
+      skippedTotal: r.skippedTotal,
+      startedAtMs: r.startedAtMs,
+      completedAtMs: r.completedAtMs
+    };
   } catch {
-    throw new RemoteResponseInvalid(route, "a body that is not JSON");
+    return null;
   }
-  const result = schema.safeParse(json2);
-  if (!result.success) {
-    throw new RemoteResponseInvalid(route, "a body this client cannot read");
+}
+function isCount(v) {
+  return typeof v === "number" && Number.isFinite(v) && v >= 0;
+}
+function isNullableCount(v) {
+  return v === null || isCount(v);
+}
+
+// ../../packages/plugin-runtime/src/attached/history-sync.ts
+import { createHash as createHash6 } from "crypto";
+import { hostname as hostname5 } from "os";
+
+// ../../packages/plugin-runtime/src/attached/capture-rebuild.ts
+function rebuildCapture(row) {
+  const kind = EventKind.safeParse(row.eventType);
+  if (!kind.success) return void 0;
+  if (kind.data === "code_change") return void 0;
+  const content = row.content ?? null;
+  const contentHash = row.contentHash ?? null;
+  const rootSessionId = row.rootSessionId ?? null;
+  if (content === null || contentHash === null) return void 0;
+  const occurredAt = isoOrUndefined(row.startedAt);
+  if (occurredAt === void 0) return void 0;
+  const attributes = parseAttributes(row.attributes ?? null);
+  const sourceTool = SourceTool.safeParse(attributes.source_tool);
+  if (!sourceTool.success) return void 0;
+  const keep = (value, schema) => value !== void 0 && schema.safeParse(value).success ? value : void 0;
+  const rawFilePath = typeof attributes.file_path === "string" ? attributes.file_path : null;
+  const filePath = stringOrUndefined(attributes.file_path);
+  const metadata = {
+    ...rootSessionId === null ? {} : { sessionId: rootSessionId },
+    ...filePath === void 0 ? {} : { filePath },
+    ...pick2(attributes, { repo: "repo", toolName: "tool_name", model: "model" }),
+    // The two constrained strings, kept only if they satisfy the wire.
+    ...withField("traceId", keep(stringOrUndefined(attributes.trace_id), TRACE_ID)),
+    ...withField(
+      "correlationId",
+      keep(stringOrUndefined(attributes.correlation_id), CORRELATION_ID)
+    ),
+    ...typeof attributes.gitignored === "boolean" ? { gitignored: attributes.gitignored } : {},
+    ...typeof attributes.whole_file === "boolean" ? { wholeFile: attributes.whole_file } : {},
+    ...typeof attributes.turn_index === "number" && Number.isInteger(attributes.turn_index) && attributes.turn_index >= 0 ? { turnIndex: attributes.turn_index } : {},
+    // Carried, unlike inspectionMs below. The live forward sends it, and it is
+    // the enforcement audit trail's link back to the grant that authorized a
+    // bypass — dropping it would make the same capture mean different things to
+    // the deployment depending on which route delivered it.
+    //
+    // Filtered ELEMENT-WISE against the wire's own element schema, for the same
+    // reason the two constrained strings above are: a bag holding
+    // ['legacy-grant-7'] is a plain array of strings, so a `typeof` filter passes
+    // it, IngestEvent.safeParse then refuses the assembled event, and the whole
+    // capture becomes a permanent skip. That is the per-row door the rest of this
+    // function exists to avoid, and this field was the last one still using it.
+    ...withList("exceptionIds", keepAll(attributes.exception_ids, EXCEPTION_ID))
+    // inspectionMs is DELIBERATELY not carried. It measures latency a live host
+    // session actually waited on, and a row being drained hours later is not
+    // that; the field's own contract says a replay leaves it absent rather than
+    // reporting a number no session experienced.
+  };
+  const parsed2 = IngestEvent.safeParse({
+    id: captureWireId(rootSessionId, contentHash, rawFilePath),
+    sourceTool: sourceTool.data,
+    kind: kind.data,
+    occurredAt,
+    contentHash,
+    content,
+    metadata
+  });
+  return parsed2.success ? parsed2.data : void 0;
+}
+function withField(name, value) {
+  return value === void 0 ? {} : { [name]: value };
+}
+function withList(name, values) {
+  return values.length === 0 ? {} : { [name]: values };
+}
+function keepAll(value, schema) {
+  return Array.isArray(value) ? value.filter((v) => typeof v === "string" && schema.safeParse(v).success) : [];
+}
+var CORRELATION_ID = EventMetadata.shape.correlationId;
+var TRACE_ID = EventMetadata.shape.traceId;
+var EXCEPTION_ID = EventMetadata.shape.exceptionIds.unwrap().element;
+function isoOrUndefined(epochMs) {
+  if (!Number.isFinite(epochMs)) return void 0;
+  const iso = new Date(epochMs);
+  return Number.isNaN(iso.getTime()) ? void 0 : iso.toISOString();
+}
+function parseAttributes(raw) {
+  if (raw === null) return {};
+  try {
+    const parsed2 = JSON.parse(raw);
+    return typeof parsed2 === "object" && parsed2 !== null && !Array.isArray(parsed2) ? parsed2 : {};
+  } catch {
+    return {};
   }
-  return result.data;
 }
-function withoutTrailingSlashes(endpoint) {
-  let end = endpoint.length;
-  while (end > 0 && endpoint.charCodeAt(end - 1) === SLASH) end -= 1;
-  return endpoint.slice(0, end);
+function stringOrUndefined(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-var SLASH = "/".charCodeAt(0);
-function createRemoteClient(options) {
-  const base = withoutTrailingSlashes(options.endpoint);
-  const url2 = (route) => `${base}${route}`;
-  const common = { apiKey: options.apiKey, timeoutMs: options.timeoutMs };
-  const sendOne = async (event) => {
-    const validated = RecordAuditEventRequest.safeParse(event);
-    if (!validated.success) throw new RemoteRequestInvalid(ROUTES.auditEvents, validated.error);
-    const response = await send({
-      ...common,
-      method: "POST",
-      url: url2(ROUTES.auditEvents),
-      body: JSON.stringify(validated.data)
-    });
-    okBody(response);
-  };
-  return {
-    async ingestEvents(batch) {
-      const response = await send({
-        ...common,
-        method: "POST",
-        url: url2(ROUTES.events),
-        body: JSON.stringify(batch)
-      });
-      return parsed(IngestAck, okBody(response), ROUTES.events);
-    },
-    async ingestInventory(context) {
-      const response = await send({
-        ...common,
-        method: "POST",
-        url: url2(ROUTES.inventory),
-        body: JSON.stringify(context)
-      });
-      return parsed(ResolvedInventory, okBody(response), ROUTES.inventory);
-    },
-    async recordAuditEvent(event) {
-      await sendOne(event);
-    },
-    async recordAuditEvents(events) {
-      const validated = RecordAuditEventBatch.safeParse({ events });
-      if (!validated.success) {
-        throw new RemoteRequestInvalid(ROUTES.auditEventsBatch, validated.error);
-      }
-      const response = await send({
-        ...common,
-        method: "POST",
-        url: url2(ROUTES.auditEventsBatch),
-        body: JSON.stringify(validated.data)
-      });
-      if (response.status === 404) {
-        for (const event of validated.data.events) await sendOne(event);
-        return { accepted: validated.data.events.length };
-      }
-      return parsed(AuditEventBatchAck, okBody(response), ROUTES.auditEventsBatch);
-    },
-    async reportStorePosture(snapshot) {
-      const response = await send({
-        ...common,
-        method: "POST",
-        url: url2(ROUTES.storePosture),
-        body: JSON.stringify(snapshot)
-      });
-      okBody(response);
-    },
-    async getPolicyBundle(etag) {
-      const response = await send({
-        ...common,
-        method: "GET",
-        url: url2(ROUTES.policyBundle),
-        ...etag === void 0 ? {} : { headers: { "if-none-match": etag } }
-      });
-      if (response.status === 304) {
-        return { changed: false, etag: headerValue(response, "etag") ?? etag };
-      }
-      const bundle = parsed(PolicyBundle, okBody(response), ROUTES.policyBundle);
-      return { changed: true, bundle, etag: headerValue(response, "etag") };
-    },
-    async whoami() {
-      const response = await send({ ...common, method: "GET", url: url2(ROUTES.whoami) });
-      return parsed(PluginWhoami, okBody(response), ROUTES.whoami);
-    },
-    async recordProjectEgress(request) {
-      const validated = EgressIngestRequest.safeParse(request);
-      if (!validated.success) throw new RemoteRequestInvalid(ROUTES.shares, validated.error);
-      const response = await send({
-        ...common,
-        method: "POST",
-        url: url2(ROUTES.shares),
-        body: JSON.stringify(validated.data)
-      });
-      okBody(response);
-    }
-  };
+function pick2(attributes, mapping) {
+  const out = {};
+  for (const [wire, column] of Object.entries(mapping)) {
+    const value = stringOrUndefined(attributes[column]);
+    if (value !== void 0) out[wire] = value;
+  }
+  return out;
 }
 
 // ../../packages/plugin-runtime/src/attached/history-rebuild.ts
 var CAPTURE_VERSION_PREFIX2 = "capture/";
 function rebuildAuditEvent(row, inspections = []) {
-  const startedAt = isoOrUndefined(row.startedAt);
+  const startedAt = isoOrUndefined2(row.startedAt);
   if (startedAt === void 0) return void 0;
-  const endedAt = isoOrUndefined(row.endedAt);
+  const endedAt = isoOrUndefined2(row.endedAt);
   const candidate = {
     id: row.id,
     eventType: row.eventType,
@@ -33026,7 +33690,7 @@ function rebuildAuditEvent(row, inspections = []) {
   return parsed2.success ? parsed2.data : void 0;
 }
 var MAX_EPOCH_MS = 864e13;
-function isoOrUndefined(ms) {
+function isoOrUndefined2(ms) {
   if (ms === null || ms === void 0 || !Number.isFinite(ms)) return void 0;
   if (Math.abs(ms) > MAX_EPOCH_MS) return void 0;
   return epochMillisToIso(ms);
@@ -33052,10 +33716,17 @@ var MAX_ATTEMPTS = 4;
 var MAX_BACKOFF_MS = 6e4;
 var SESSION_PAGE = 25;
 var ROW_PAGE = 200;
+var CAPTURE_GRACE_MS = 3e4;
+var CAPTURE_BATCH_SIZE = INGEST_BATCH_MAX;
+var STRUCTURAL_BUDGET_SHARE = 0.7;
 var BATCH_SIZE = AUDIT_EVENT_BATCH_MAX;
 function endpointFingerprint(endpoint) {
   return createHash6("sha256").update(endpoint).digest("hex");
 }
+var didNotRun = (reason) => ({
+  attempted: false,
+  reason
+});
 async function runHistorySync(deps) {
   const now = deps.now ?? (() => Date.now());
   const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
@@ -33064,19 +33735,23 @@ async function runHistorySync(deps) {
   let db;
   try {
     const settings = readWorkspaceSettings(deps.base);
-    if (!isAttached(settings)) return null;
+    if (!isAttached(settings)) return didNotRun("not-attached");
     const connection = settings.controlPlane;
-    if (connection === void 0) return null;
-    if (!isHistorySyncConsentValid(settings.historySyncConsent, connection.endpoint)) return null;
+    if (connection === void 0) return didNotRun("not-attached");
+    if (!isHistorySyncConsentValid(settings.historySyncConsent, connection.endpoint)) {
+      return didNotRun("no-consent");
+    }
     const state = readControlPlaneCredentialFile(deps.settingsDir, connection);
-    if (!state.usable) return null;
+    if (!state.usable) return didNotRun("credential-unusable");
     const nowMs = now();
     const openedAtMs = readForwardHealth(deps.dataDir, nowMs)?.openedAtMs ?? null;
-    if (openedAtMs !== null && nowMs - openedAtMs < BREAKER_COOLDOWN_MS) return null;
+    if (openedAtMs !== null && nowMs - openedAtMs < BREAKER_COOLDOWN_MS) {
+      return didNotRun("breaker-open");
+    }
     db = (deps.openStore ?? openLocalDatabase)(deps.dataDir);
     const ledger = db.historySync;
     const attachedAtMs = Date.parse(connection.attachedAt);
-    if (!Number.isFinite(attachedAtMs)) return null;
+    if (!Number.isFinite(attachedAtMs)) return didNotRun("attachment-unreadable");
     const fingerprint = endpointFingerprint(connection.endpoint);
     const recorded = ledger.deployment();
     let backlogBefore;
@@ -33090,24 +33765,46 @@ async function runHistorySync(deps) {
       backlogBefore = recorded.backlogBefore;
     }
     const pid = process.pid;
-    if (!ledger.claim(pid, hostname5(), now(), HISTORY_LEASE_STALE_MS)) return null;
-    const send2 = deps.sendBatch ?? (() => {
-      const client = createRemoteClient({
-        endpoint: connection.endpoint,
-        apiKey: state.credential.apiKey,
-        timeoutMs: HISTORY_REQUEST_TIMEOUT_MS
-      });
-      return async (events) => {
-        await client.recordAuditEvents(events);
-      };
-    })();
+    if (!ledger.claim(pid, hostname5(), now(), HISTORY_LEASE_STALE_MS)) {
+      return didNotRun("already-running");
+    }
+    const client = deps.sendBatch !== void 0 && deps.sendCaptures !== void 0 && deps.sendOne !== void 0 ? void 0 : createRemoteClient({
+      endpoint: connection.endpoint,
+      apiKey: state.credential.apiKey,
+      timeoutMs: HISTORY_REQUEST_TIMEOUT_MS
+    });
+    const send2 = deps.sendBatch ?? (async (events) => {
+      if (client === void 0) throw new Error("history sync: no transport");
+      const ack = await client.recordAuditEvents(events, { fallbackToSingleEvents: true });
+      return { settled: ack.accepted };
+    });
+    const sendOne = deps.sendOne ?? (async (event) => {
+      if (client === void 0) throw new Error("history sync: no transport");
+      await client.recordAuditEvent(event);
+    });
+    const sendCaptures = deps.sendCaptures ?? (async (events) => {
+      if (client === void 0) throw new Error("history sync: no transport");
+      const ack = await client.ingestEvents({ events: [...events] });
+      return { settled: ack.accepted + ack.duplicates };
+    });
     try {
-      return await drain({ ledger, send: send2, now, sleep, random, budgetMs, pid, backlogBefore });
+      return await drain({
+        ledger,
+        send: send2,
+        sendOne,
+        sendCaptures,
+        now,
+        sleep,
+        random,
+        budgetMs,
+        pid,
+        backlogBefore
+      });
     } finally {
       ledger.release(pid);
     }
   } catch {
-    return null;
+    return didNotRun("failed");
   } finally {
     try {
       db?.close();
@@ -33118,76 +33815,207 @@ async function runHistorySync(deps) {
 async function drain(d) {
   const startedAt = d.now();
   const deadline = startedAt + d.budgetMs;
+  const structuralDeadline = Math.min(deadline, startedAt + d.budgetMs * STRUCTURAL_BUDGET_SHARE);
   let sent = 0;
   let skipped = 0;
   let lastHeartbeat = startedAt;
-  let outcome = "ok";
   const beat = () => {
     const at = d.now();
     if (at - lastHeartbeat < HEARTBEAT_EVERY_MS) return;
     d.ledger.heartbeat(d.pid, at);
     lastHeartbeat = at;
   };
-  outer: while (d.now() < deadline) {
-    const sessions = d.ledger.pendingSessions(SESSION_PAGE, d.backlogBefore);
-    if (sessions.length === 0) break;
-    for (const sessionId of sessions) {
-      const rows = d.ledger.pendingRows(sessionId, ROW_PAGE, d.backlogBefore);
-      if (rows.length === 0) continue;
-      const ready = [];
-      for (const row of rows) {
-        const event = rebuildAuditEvent(row, d.ledger.inspectionsFor(row.id));
-        if (event === void 0) {
-          d.ledger.markSkipped([row.id]);
-          skipped += 1;
-          continue;
-        }
-        ready.push({ id: row.id, event });
-      }
-      for (let i = 0; i < ready.length; i += BATCH_SIZE) {
-        if (d.now() >= deadline) {
-          outcome = "interrupted";
-          break outer;
+  const drainStructural = async (until) => {
+    let stopped = "ok";
+    outer: while (d.now() < until) {
+      const sessions = d.ledger.pendingSessions(SESSION_PAGE, d.backlogBefore);
+      if (sessions.length === 0) break;
+      for (const sessionId of sessions) {
+        const rows = d.ledger.pendingRows(sessionId, ROW_PAGE, d.backlogBefore);
+        if (rows.length === 0) continue;
+        const ready = [];
+        for (const row of rows) {
+          const event = rebuildAuditEvent(row, d.ledger.inspectionsFor(row.id));
+          if (event === void 0) {
+            d.ledger.markSkipped([row.id]);
+            skipped += 1;
+            continue;
+          }
+          ready.push({ id: row.id, event });
         }
-        const chunk = ready.slice(i, i + BATCH_SIZE);
-        const result = await sendChunk(d, chunk, beat);
-        sent += result.sent;
-        skipped += result.skipped;
-        if (result.stopped !== void 0) {
-          outcome = result.stopped;
-          break outer;
+        for (let i = 0; i < ready.length; i += BATCH_SIZE) {
+          if (d.now() >= until) {
+            stopped = "interrupted";
+            break outer;
+          }
+          const chunk = ready.slice(i, i + BATCH_SIZE);
+          const result = await sendChunk(d, chunk, beat);
+          sent += result.sent;
+          skipped += result.skipped;
+          if (result.stopped !== void 0) {
+            stopped = result.stopped;
+            break outer;
+          }
+          beat();
+          await d.sleep(PACE_INTERVAL_MS);
         }
-        beat();
-        await d.sleep(PACE_INTERVAL_MS);
       }
     }
+    return stopped;
+  };
+  let outcome = await drainStructural(structuralDeadline);
+  if (outcome === "interrupted" && d.now() < deadline) outcome = "ok";
+  if (outcome === "ok") {
+    const captures = await drainCaptures(d, deadline, beat);
+    sent += captures.sent;
+    skipped += captures.skipped;
+    if (captures.stopped !== void 0) outcome = captures.stopped;
+  }
+  if (outcome === "ok" && d.now() < deadline && d.ledger.pendingCaptureRows(1, d.now() - CAPTURE_GRACE_MS).length === 0) {
+    outcome = await drainStructural(deadline);
   }
   if (outcome === "ok" && d.now() >= deadline && d.ledger.counts(d.backlogBefore).pending > 0) {
     outcome = "interrupted";
   }
-  return { outcome, sent, skipped, counts: d.ledger.counts(d.backlogBefore), atMs: d.now() };
+  return {
+    attempted: true,
+    outcome,
+    sent,
+    skipped,
+    // LIMIT 1 — this asks "is anything owed", never "how much", so it must not
+    // pay for a count over the capture grain on every pass.
+    capturesPending: d.ledger.pendingCaptureRows(1, d.now() - CAPTURE_GRACE_MS).length > 0,
+    counts: d.ledger.counts(d.backlogBefore),
+    atMs: d.now()
+  };
+}
+async function drainCaptures(d, deadline, beat) {
+  let sent = 0;
+  let skipped = 0;
+  for (; ; ) {
+    if (d.now() >= deadline) return { sent, skipped, stopped: "interrupted" };
+    const rows = d.ledger.pendingCaptureRows(CAPTURE_BATCH_SIZE, d.now() - CAPTURE_GRACE_MS);
+    if (rows.length === 0) return { sent, skipped };
+    const ready = [];
+    const unbuildable = [];
+    for (const row of rows) {
+      const event = rebuildCapture(row);
+      if (event === void 0) {
+        unbuildable.push(row.id);
+        continue;
+      }
+      ready.push({ id: row.id, event });
+    }
+    if (unbuildable.length > 0) {
+      d.ledger.markSkipped(unbuildable);
+      skipped += unbuildable.length;
+    }
+    if (ready.length === 0) {
+      beat();
+      await d.sleep(PACE_INTERVAL_MS);
+      continue;
+    }
+    const result = await sendCaptureChunk(d, ready, beat);
+    sent += result.sent;
+    skipped += result.skipped;
+    if (result.stopped !== void 0) return { sent, skipped, stopped: result.stopped };
+    if (result.sent === 0 && result.skipped === 0) return { sent, skipped, stopped: "unreachable" };
+    beat();
+    await d.sleep(PACE_INTERVAL_MS);
+  }
 }
-async function sendChunk(d, chunk, beat) {
-  const verdict = await sendWithRetries(
-    d,
-    chunk.map((c) => c.event),
-    beat
-  );
-  if (verdict === "sent") {
+async function sendCaptureChunk(d, chunk, beat) {
+  const outcome = await sendCapturesWithRetries(d, chunk, beat);
+  if (outcome.verdict === "refused") return { sent: 0, skipped: 0, stopped: "refused" };
+  if (outcome.verdict === "unreachable") return { sent: 0, skipped: 0, stopped: "unreachable" };
+  if (outcome.verdict === "sent") {
+    const settled = outcome.settled;
+    if (settled < chunk.length) {
+      if (chunk.length > 1) return await isolate(d, chunk, beat);
+      return { sent: 0, skipped: 0, stopped: "unreachable" };
+    }
     d.ledger.markSynced(
       chunk.map((c) => c.id),
       d.now()
     );
     return { sent: chunk.length, skipped: 0 };
   }
-  if (verdict === "refused" || verdict === "unreachable") {
-    return { sent: 0, skipped: 0, stopped: verdict };
+  {
+    const only = chunk.length === 1 ? chunk[0] : void 0;
+    if (only !== void 0) {
+      d.ledger.markSkipped([only.id]);
+      return { sent: 0, skipped: 1 };
+    }
+    return await isolate(d, chunk, beat);
+  }
+}
+async function isolate(d, chunk, beat) {
+  let sent = 0;
+  let skipped = 0;
+  for (const [index, one] of chunk.entries()) {
+    if (index > 0) await d.sleep(PACE_INTERVAL_MS);
+    beat();
+    const single = await sendCaptureChunk(d, [one], beat);
+    sent += single.sent;
+    skipped += single.skipped;
+    if (single.stopped !== void 0) return { sent, skipped, stopped: single.stopped };
+  }
+  return { sent, skipped };
+}
+async function sendCapturesWithRetries(d, chunk, beat) {
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
+    try {
+      const ack = await d.sendCaptures(chunk.map((c) => c.event));
+      return { verdict: "sent", settled: ack.settled };
+    } catch (err) {
+      const kind = classify(err);
+      if (kind === "refused") return { verdict: "refused" };
+      if (kind === "skip") return { verdict: "skip" };
+      if (attempt === MAX_ATTEMPTS - 1) return { verdict: "unreachable" };
+      const ceiling = Math.min(MAX_BACKOFF_MS, 1e3 * 2 ** attempt);
+      beat();
+      await d.sleep(Math.floor(d.random() * ceiling));
+    }
   }
+  return { verdict: "unreachable" };
+}
+async function sendChunk(d, chunk, beat) {
   const only = chunk.length === 1 ? chunk[0] : void 0;
-  if (only !== void 0) {
-    d.ledger.markSkipped([only.id]);
-    return { sent: 0, skipped: 1 };
+  if (only !== void 0) return await sendSingleRow(d, only, beat);
+  const outcome = await sendWithRetries(d, () => d.send(chunk.map((c) => c.event)), beat);
+  if (outcome.verdict === "sent") {
+    const settled = outcome.settled;
+    if (settled < chunk.length) {
+      return await isolateStructural(d, chunk, beat);
+    }
+    d.ledger.markSynced(
+      chunk.map((c) => c.id),
+      d.now()
+    );
+    return { sent: chunk.length, skipped: 0 };
+  }
+  if (outcome.verdict === "refused" || outcome.verdict === "unreachable") {
+    return { sent: 0, skipped: 0, stopped: outcome.verdict };
+  }
+  return await isolateStructural(d, chunk, beat);
+}
+async function sendSingleRow(d, one, beat) {
+  const outcome = await sendWithRetries(
+    d,
+    () => d.sendOne(one.event).then(() => ({ settled: 1 })),
+    beat
+  );
+  if (outcome.verdict === "sent") {
+    d.ledger.markSynced([one.id], d.now());
+    return { sent: 1, skipped: 0 };
+  }
+  if (outcome.verdict === "refused" || outcome.verdict === "unreachable") {
+    return { sent: 0, skipped: 0, stopped: outcome.verdict };
   }
+  d.ledger.markSkipped([one.id]);
+  return { sent: 0, skipped: 1 };
+}
+async function isolateStructural(d, chunk, beat) {
   let sent = 0;
   let skipped = 0;
   for (const [index, one] of chunk.entries()) {
@@ -33200,24 +34028,24 @@ async function sendChunk(d, chunk, beat) {
   }
   return { sent, skipped };
 }
-async function sendWithRetries(d, events, beat) {
-  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
+async function sendWithRetries(d, attempt, beat) {
+  for (let i = 0; i < MAX_ATTEMPTS; i += 1) {
     try {
-      await d.send(events);
-      return "sent";
+      const { settled } = await attempt();
+      return { verdict: "sent", settled };
     } catch (err) {
       const kind = classify(err);
-      if (kind === "refused") return "refused";
-      if (kind === "skip") return "skip";
-      if (attempt === MAX_ATTEMPTS - 1) return "unreachable";
-      const ceiling = Math.min(MAX_BACKOFF_MS, 1e3 * 2 ** attempt);
+      if (kind === "refused") return { verdict: "refused" };
+      if (kind === "skip") return { verdict: "skip" };
+      if (i === MAX_ATTEMPTS - 1) return { verdict: "unreachable" };
+      const ceiling = Math.min(MAX_BACKOFF_MS, 1e3 * 2 ** i);
       beat();
       await d.sleep(Math.floor(d.random() * ceiling));
     }
   }
-  return "unreachable";
+  return { verdict: "unreachable" };
 }
-function statusOf(err) {
+function statusOf2(err) {
   if (typeof err !== "object" || err === null || !("status" in err)) return null;
   const { status } = err;
   if (typeof status !== "number" || !Number.isInteger(status)) return null;
@@ -33225,7 +34053,7 @@ function statusOf(err) {
 }
 function classify(err) {
   if (err.name === "RemoteRequestInvalid") return "skip";
-  switch (statusOf(err)) {
+  switch (statusOf2(err)) {
     // Terminal in a way a timeout is not: the credential may have died with an
     // offboarded member, and every later row would fail the same way.
     case 401:
@@ -33243,33 +34071,58 @@ function classify(err) {
 }
 
 // ../../packages/plugin-runtime/src/attached/history-sync-entry.ts
-async function runHistorySyncPass(base = defaultDataDir()) {
+async function runHistorySyncPass(base = defaultDataDir(), seams = {}) {
   try {
     const dir = dataDir(base);
     const result = await runHistorySync({
       base,
       settingsDir: settingsDir(base),
-      dataDir: dir
+      dataDir: dir,
+      ...seams
     });
-    if (result === null) return;
+    if (!result.attempted) return result.reason;
     const previous = readHistorySyncState(dir);
-    const done = result.counts.pending === 0;
+    const done = result.counts.pending === 0 && !result.capturesPending;
     writeHistorySyncState(dir, {
       phase: done ? "complete" : "filling",
       lastOutcome: result.outcome,
       lastPassAtMs: result.atMs,
       sentTotal: result.counts.sent,
       pendingTotal: result.counts.pending,
-      skippedTotal: result.counts.skipped,
+      // BOTH lanes, and BOTH lifetime. `counts.skipped` filters to structural
+      // rows, so a capture rebuildCapture refused — stamped -1 and dropped for
+      // ever — was counted on no surface at all. Silence is the right shape for a
+      // TRANSIENT failure everywhere else in this repo; this one is terminal, so
+      // it owes a number.
+      //
+      // Both terms are ledger totals rather than this pass's tally, which is the
+      // part that matters: a per-pass delta added to a lifetime total gives a
+      // field whose capture half is one pass wide, so the surface beside
+      // `sentTotal` and `pendingTotal` would announce a permanent loss once and
+      // drop it on the next pass, while the rows stayed gone.
+      skippedTotal: result.counts.skipped + result.counts.capturesSkipped,
       // The first pass that ran is when this machine started sending, and it
       // keeps that answer across every later pass.
       startedAtMs: previous?.startedAtMs ?? result.atMs,
-      // Stamped when the drain empties. The backlog is a FIXED set — everything
-      // recorded before the machine attached — so unlike a tally over a store
-      // that keeps growing, this one genuinely finishes and stays finished.
-      completedAtMs: done ? previous?.completedAtMs ?? result.atMs : null
+      // Stamped the first time BOTH lanes were empty. The structural backlog is
+      // a fixed set — everything recorded before the machine attached — and it
+      // genuinely finishes. The capture lane does not: its subject grows with
+      // every live session that fails to forward, so `phase` can go back to
+      // 'filling' after reading 'complete'. This keeps its original meaning
+      // either way — the first moment this machine owed the deployment nothing —
+      // which is why it is pinned rather than recomputed.
+      // WRITTEN ONCE, on the false→true transition, and never cleared. Under v1
+      // this was monotone because the structural lane only ever drained; the
+      // capture lane is what makes `done` flap, and clearing on every flap would
+      // erase the pin and re-stamp it on the next catch-up — so a consumer
+      // reading "when this machine first caught up" would get the most recent
+      // one instead. Carrying the previous value through the false case is what
+      // keeps the original meaning.
+      completedAtMs: previous?.completedAtMs ?? (done ? result.atMs : null)
     });
+    return result.outcome;
   } catch {
+    return "failed";
   }
 }
 
@@ -33279,12 +34132,12 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 var HISTORY_SYNC_THROTTLE_MS = 5 * 60 * 1e3;
 
 // ../../packages/plugin-runtime/src/attached/plugin-block.ts
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 
 // ../../packages/plugin-runtime/src/attached/policy-store.ts
 import { randomUUID as randomUUID16 } from "crypto";
 import { readFile as readFile2, rm, writeFile as writeFile2 } from "fs/promises";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 
 // ../../packages/plugin-runtime/src/attached/atomic-publish.ts
 import { rename as rename2 } from "fs/promises";
@@ -33299,11 +34152,11 @@ import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
 // ../../packages/plugin-runtime/src/attached/posture-store.ts
 import { randomUUID as randomUUID17 } from "crypto";
 import { readFile as readFile3, rm as rm2, writeFile as writeFile3 } from "fs/promises";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 
 // ../../packages/plugin-runtime/src/attached/sync-state.ts
-import { readFileSync as readFileSync16 } from "fs";
-import { join as join25 } from "path";
+import { readFileSync as readFileSync17 } from "fs";
+import { join as join26 } from "path";
 
 // ../../packages/plugin-runtime/src/attached/status.ts
 var REFUSAL_LINES = {