@sixb/sqlite 0.1.16 → 0.1.18

package/dist/index.js

@@ -4670,6 +4670,172 @@ DROP TABLE legacy_ontology_sources;
 -- describe empty tables forever and steer the planner to partial indexes over primary keys.
 `;
 
+// src/migrations/053-replacement-plans.sql
+var _053_replacement_plans_default = `-- The plan of a ready replacement candidate, built outside its commit transaction. Its rows are a
+-- cache the commit verifies again, keyed by the candidate's source version, which outlives it:
+-- maintenance deletes a plan once its candidate is no longer ready, and only then the version.
+CREATE TABLE ontology_replacement_plans (
+  version_id INTEGER PRIMARY KEY REFERENCES ontology_sources (version_id) ON DELETE RESTRICT,
+  project_id TEXT NOT NULL,
+  -- The commit the plan's work carries, at the time fixed when the plan opened.
+  commit_id TEXT NOT NULL,
+  committed_at TEXT NOT NULL,
+  -- The active source the plan replaces, NULL when none was: a plan resumed once that moved
+  -- starts over.
+  replaced_materialization_id TEXT,
+  replaced_last_commit_id TEXT,
+  -- The last commit row every planned identity is known fresh against.
+  watermark INTEGER NOT NULL
+);
+
+-- One row per entity the plan decides. \`read_revision\` is the revision of the inputs its state was
+-- last read at; \`planned_revision\` the one its work was planned from, NULL while still to plan.
+-- \`classified\` and \`change\` summarize that work for the commit's change counts.
+CREATE TABLE ontology_replacement_plan_identities (
+  version_id INTEGER NOT NULL,
+  entity_kind TEXT NOT NULL CHECK (entity_kind IN ('object', 'link')),
+  identity_key TEXT NOT NULL,
+  sort_key TEXT NOT NULL,
+  diff_required INTEGER NOT NULL CHECK (diff_required IN (0, 1)),
+  read_revision TEXT,
+  planned_revision TEXT,
+  classified INTEGER NOT NULL DEFAULT 0 CHECK (classified IN (0, 1)),
+  change TEXT CHECK (change IN ('created', 'updated', 'deleted')),
+  PRIMARY KEY (version_id, entity_kind, identity_key)
+);
+-- The identities still to plan, in planning order: a round that plans a few again finds them
+-- without walking the rest.
+CREATE INDEX idx_ontology_replacement_plan_identities_unplanned
+  ON ontology_replacement_plan_identities (version_id, entity_kind, sort_key)
+  WHERE planned_revision IS NULL;
+
+-- Planned work, with the same columns as a session's work table plus the identity it belongs to.
+CREATE TABLE ontology_replacement_plan_work (
+  work_id INTEGER NOT NULL,
+  entity_kind TEXT NOT NULL,
+  identity_key TEXT NOT NULL,
+  record_key TEXT NOT NULL,
+  unique_key TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  lane TEXT NOT NULL,
+  major_order INTEGER NOT NULL,
+  minor_order INTEGER NOT NULL,
+  sort_one TEXT NOT NULL,
+  sort_two TEXT NOT NULL,
+  classification_entity_kind TEXT,
+  classification_identity_key TEXT,
+  cardinality_view TEXT,
+  cardinality_occupied INTEGER,
+  cardinality_source_type_id TEXT,
+  cardinality_source_primary_id TEXT,
+  cardinality_link_id TEXT,
+  cardinality_target_type_id TEXT,
+  cardinality_target_primary_id TEXT,
+  payload TEXT NOT NULL CHECK (json_valid(payload)),
+  PRIMARY KEY (work_id, record_key),
+  UNIQUE (work_id, unique_key)
+);
+CREATE INDEX idx_ontology_replacement_plan_work_identity
+  ON ontology_replacement_plan_work (work_id, entity_kind, identity_key);
+-- The few objects whose existence the plan flips, which link expansion starts from.
+CREATE INDEX idx_ontology_replacement_plan_work_incident
+  ON ontology_replacement_plan_work (work_id) WHERE kind = 'incident-object';
+CREATE INDEX idx_ontology_replacement_plan_work_lane
+  ON ontology_replacement_plan_work (
+    work_id, lane, major_order, minor_order, sort_one, sort_two, record_key
+  );
+`;
+
+// src/migrations/054-slim-ontology-outbox.sql
+var _054_slim_ontology_outbox_default = `-- An outbox event stores what changed and nothing it can be rebuilt from: delivery rebuilds the
+-- event from its commit and the execution that commit ran under. The commit also stops copying
+-- \`requested_by\` and \`executor\` from that execution (047): the execution is canonical, immutable,
+-- and already referenced by the commit. The migration step checks beforehand that every stored
+-- event rebuilds exactly as it was stored.
+--
+-- SQLite cannot add a NOT NULL column without a default; every insert supplies the event, and the
+-- UPDATE below replaces the placeholder on every row.
+ALTER TABLE ontology_outbox ADD COLUMN event TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(event));
+UPDATE ontology_outbox SET event = json_object(
+  'payload', CASE
+    WHEN envelope ->> '$.type' IN ('object.created', 'link.created')
+      THEN json_remove(envelope -> '$.payload', '$.propertyChanges')
+    ELSE envelope -> '$.payload'
+  END,
+  'type', envelope ->> '$.type'
+);
+ALTER TABLE ontology_outbox DROP COLUMN envelope;
+
+ALTER TABLE ontology_commits DROP COLUMN requested_by;
+ALTER TABLE ontology_commits DROP COLUMN executor;
+`;
+
+// src/migrations/055-commit-touches.sql
+var _055_commit_touches_default = `-- Every commit records the entities whose plan inputs it changed, so a replacement plan's refresh
+-- rechecks only what the commits since it was last fresh touched, instead of the whole plan.
+CREATE TABLE ontology_commit_touches (
+  project_id TEXT NOT NULL,
+  commit_id TEXT NOT NULL,
+  entity_kind TEXT NOT NULL CHECK (entity_kind IN ('object', 'link', 'scope')),
+  -- \`objectRefKey\`, \`linkRefKey\` or \`linkScopeKey\`.
+  identity_key TEXT NOT NULL
+);
+CREATE INDEX idx_ontology_commit_touches_commit ON ontology_commit_touches (project_id, commit_id);
+
+-- Existing plans predate the touches of the commits since their watermark: they plan again.
+DELETE FROM ontology_replacement_plan_work;
+DELETE FROM ontology_replacement_plan_identities;
+DELETE FROM ontology_replacement_plans;
+
+-- Link expansion starts only from what changed since it last ran: \`expansions\` counts the runs,
+-- and an identity's \`expand_at\` is the run that has yet to start from it (an object once planned,
+-- a link once it needs a diff). \`source_key\` and \`target_key\` find a link from either endpoint.
+ALTER TABLE ontology_replacement_plans ADD COLUMN expansions INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE ontology_replacement_plan_identities ADD COLUMN expand_at INTEGER;
+ALTER TABLE ontology_replacement_plan_identities ADD COLUMN source_key TEXT;
+ALTER TABLE ontology_replacement_plan_identities ADD COLUMN target_key TEXT;
+CREATE INDEX idx_ontology_replacement_plan_identities_expand
+  ON ontology_replacement_plan_identities (version_id, entity_kind, expand_at);
+CREATE INDEX idx_ontology_replacement_plan_identities_source
+  ON ontology_replacement_plan_identities (version_id, source_key)
+  WHERE source_key IS NOT NULL;
+CREATE INDEX idx_ontology_replacement_plan_identities_target
+  ON ontology_replacement_plan_identities (version_id, target_key)
+  WHERE target_key IS NOT NULL;
+`;
+
+// src/migrations/056-audio-transcription.sql
+var _056_audio_transcription_default = `ALTER TABLE ai_model_call_usage
+  ADD COLUMN audio_duration_ms INTEGER
+  CHECK (audio_duration_ms IS NULL OR audio_duration_ms >= 0);
+
+ALTER TABLE ai_model_call_usage
+  ADD COLUMN model_kind TEXT
+  CHECK (
+    model_kind IS NULL
+    OR model_kind IN ('language', 'image', 'video', 'embedding', 'decision', 'transcription')
+  );
+`;
+
+// src/migrations/057-reranking-model-kind.sql
+var _057_reranking_model_kind_default = `-- SQLite cannot alter a CHECK constraint. Swapping the column avoids rebuilding a table that
+-- usage groups, costs and limit reservations reference.
+ALTER TABLE ai_model_call_usage
+  ADD COLUMN model_kind_next TEXT
+  CHECK (
+    model_kind_next IS NULL
+    OR model_kind_next IN (
+      'language', 'image', 'video', 'embedding', 'decision', 'transcription', 'reranking'
+    )
+  );
+
+UPDATE ai_model_call_usage SET model_kind_next = model_kind;
+
+ALTER TABLE ai_model_call_usage DROP COLUMN model_kind;
+
+ALTER TABLE ai_model_call_usage RENAME COLUMN model_kind_next TO model_kind;
+`;
+
 // src/migrations/037-execution-requester-groups.sql
 var _037_execution_requester_groups_default = `ALTER TABLE executions ADD COLUMN requester_group_ids TEXT NOT NULL DEFAULT '[]';
 
@@ -4790,6 +4956,44 @@ CREATE INDEX idx_file_upload_sessions_abandoned
   WHERE status = 'pending' AND provider_upload IS NOT NULL;
 `;
 
+// src/migrations/058-file-download-grants.sql
+var _058_file_download_grants_default = `-- URLs issued by blobs.createDownloadUrl(). Only the SHA-256 of each URL's token is stored.
+-- Timestamps are ISO-8601 UTC text and compare lexicographically.
+CREATE TABLE file_download_grants (
+  project_id TEXT NOT NULL CHECK (length(trim(project_id)) > 0),
+  id TEXT NOT NULL CHECK (length(trim(id)) > 0),
+  token_hash TEXT NOT NULL CHECK (
+    length(token_hash) = 64
+    AND token_hash = lower(token_hash)
+    AND token_hash NOT GLOB '*[^0-9a-f]*'
+  ),
+  file TEXT NOT NULL CHECK (json_type(file) = 'object'),
+  execution_id TEXT NOT NULL CHECK (length(trim(execution_id)) > 0),
+  created_at TEXT NOT NULL,
+  expires_at TEXT NOT NULL,
+  revoked_at TEXT,
+  PRIMARY KEY (project_id, id),
+  UNIQUE (project_id, token_hash),
+  CHECK (expires_at > created_at)
+);
+
+CREATE INDEX idx_file_download_grants_expiry ON file_download_grants (project_id, expires_at);
+`;
+
+// src/migrations/059-drained-source-versions.sql
+var _059_drained_source_versions_default = `-- A superseded version's \`root_count\` counts the roots it still holds: cleanup lowers it as it
+-- deletes them. A version that reaches zero is found through this index, instead of every
+-- superseded version being walked and probed for roots on every maintenance pass.
+UPDATE ontology_sources
+SET root_count = (SELECT count(*) FROM ontology_source_roots AS roots
+  WHERE roots.version_id = ontology_sources.version_id)
+WHERE status = 'superseded' AND root_count <> (SELECT count(*) FROM ontology_source_roots AS roots
+  WHERE roots.version_id = ontology_sources.version_id);
+CREATE INDEX idx_ontology_sources_drained
+  ON ontology_sources (project_id, terminal_at, source_id, materialization_id)
+  WHERE status = 'superseded' AND root_count = 0;
+`;
+
 // src/migrations.ts
 var MIGRATIONS_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS sixb_migrations (
@@ -4883,7 +5087,20 @@ var sqliteStorageMigrations = defineMigrations({
       if (after.versions !== before.versions || after.roots !== before.roots || after.rows !== before.rows) {
         throw new Error("[SixbSqliteStorage] Source versions, roots or rows were lost while compacting source storage.");
       }
-    }, { checksum: checksum(_052_compact_source_storage_default) })
+    }, { checksum: checksum(_052_compact_source_storage_default) }),
+    sqliteSql("053-replacement-plans", _053_replacement_plans_default),
+    sqliteStep("054-slim-ontology-outbox", (db) => {
+      const mismatched = unrebuildableOutboxEvents(db);
+      if (mismatched > 0) {
+        throw new Error(`[SixbSqliteStorage] ${mismatched} outbox events would not rebuild from their commit.`);
+      }
+      db.run(_054_slim_ontology_outbox_default);
+    }, { checksum: checksum(_054_slim_ontology_outbox_default) }),
+    sqliteSql("055-commit-touches", _055_commit_touches_default),
+    sqliteSql("056-audio-transcription", _056_audio_transcription_default),
+    sqliteSql("057-reranking-model-kind", _057_reranking_model_kind_default),
+    sqliteSql("058-file-download-grants", _058_file_download_grants_default),
+    sqliteSql("059-drained-source-versions", _059_drained_source_versions_default)
   ]
 });
 function sqliteStoragePath(basePath) {
@@ -5003,6 +5220,82 @@ function sourceStorageCounts(db) {
       (SELECT count(*) FROM ontology_source_roots) AS roots,
       (SELECT count(*) FROM ontology_source_rows) AS rows`).get();
 }
+function unrebuildableOutboxEvents(db) {
+  const row = db.query(`SELECT COUNT(*) AS mismatched
+       FROM ontology_outbox AS outbox
+       LEFT JOIN ontology_commits AS commits
+         ON commits.project_id = outbox.project_id AND commits.id = outbox.commit_id
+       LEFT JOIN executions
+         ON executions.project_id = commits.project_id AND executions.id = commits.execution_id
+       WHERE executions.id IS NULL
+         OR outbox.envelope ->> '$.id' IS NOT outbox.id
+         OR outbox.envelope ->> '$.commitOrdinal' IS NOT outbox.commit_ordinal
+         OR outbox.envelope ->> '$.commitId' IS NOT commits.id
+         OR outbox.envelope ->> '$.projectId' IS NOT commits.project_id
+         OR outbox.envelope ->> '$.schemaVersion' IS NOT 1
+         OR outbox.envelope ->> '$.occurredAt' IS NOT commits.committed_at
+         OR outbox.envelope -> '$.origin' IS NOT json(commits.origin)
+         OR outbox.envelope ->> '$.correlationId' IS NOT executions.correlation_id
+         OR outbox.envelope -> '$.requestedBy' IS NOT CASE
+           WHEN executions.requested_by_user_id IS NOT NULL
+             THEN json_object('id', executions.requested_by_user_id, 'type', 'user')
+           WHEN executions.requested_by_service_account_id IS NOT NULL
+             THEN json_object('id', executions.requested_by_service_account_id, 'type', 'serviceAccount')
+         END
+         OR outbox.envelope -> '$.executor' IS NOT CASE executions.executor_kind
+           WHEN 'request' THEN json_object('requestId', executions.executor_id, 'type', 'request')
+           WHEN 'agent' THEN json_object('runId', executions.executor_id, 'type', 'agent')
+           WHEN 'kernel' THEN json_object(
+             'operation',
+             CASE executions.authority_kernel_operation
+               WHEN 'ontology.recover'
+                 THEN json_object('recoveryId', executions.executor_id, 'type', 'ontology.recover')
+               ELSE json_object('indexingId', executions.executor_id, 'type', 'ontology.indexVectors')
+             END,
+             'type', 'kernel'
+           )
+           ELSE json_object(
+             'id', executions.authority_primitive_id,
+             'kind', executions.executor_kind,
+             'runId', executions.executor_id,
+             'type', 'primitive'
+           )
+         END
+         OR outbox.envelope ->> '$.topic' IS NOT CASE substr(outbox.envelope ->> '$.type', 1, 4)
+           WHEN 'obje' THEN 'objects'
+           WHEN 'link' THEN 'links'
+           WHEN 'tele' THEN 'telemetry'
+         END
+         OR outbox.envelope ->> '$.partitionKey' IS NOT CASE outbox.envelope ->> '$.topic'
+           WHEN 'objects' THEN (outbox.envelope ->> '$.payload.objectTypeId') || ':' ||
+             (outbox.envelope ->> '$.payload.primaryId')
+           WHEN 'links' THEN (outbox.envelope ->> '$.payload.sourceTypeId') || ':' ||
+             (outbox.envelope ->> '$.payload.sourceId') || ':' ||
+             (outbox.envelope ->> '$.payload.linkId')
+           WHEN 'telemetry' THEN (outbox.envelope ->> '$.payload.objectTypeId') || ':' ||
+             (outbox.envelope ->> '$.payload.objectId') || ':' ||
+             (outbox.envelope ->> '$.payload.propertyId')
+         END
+         OR (
+           outbox.envelope ->> '$.type' IN ('object.created', 'link.created')
+           AND (
+             (SELECT COUNT(*) FROM json_each(outbox.envelope, '$.payload.propertyChanges'))
+               IS NOT (SELECT COUNT(*) FROM json_each(outbox.envelope, '$.payload.properties'))
+             OR EXISTS (
+               SELECT 1
+               FROM json_each(outbox.envelope, '$.payload.propertyChanges') AS change
+               LEFT JOIN json_each(outbox.envelope, '$.payload.properties') AS property
+                 ON property.key = change.key
+               WHERE property.key IS NULL
+                 OR change.value ->> '$.operation' IS NOT 'created'
+                 OR json_type(change.value, '$.after') IS NOT property.type
+                 OR change.value ->> '$.after' IS NOT property.value
+                 OR (SELECT COUNT(*) FROM json_each(change.value)) IS NOT 2
+             )
+           )
+         )`).get();
+  return row.mismatched;
+}
 function checksum(value) {
   return createHash("sha256").update(value).digest("hex");
 }
@@ -6592,6 +6885,7 @@ class SqliteAiUsageStorage {
             provider_id,
             provider_ids,
             requested_model_id,
+            model_kind,
             requested_reasoning,
             response_model_id,
             response_id,
@@ -6603,14 +6897,15 @@ class SqliteAiUsageStorage {
             cache_write_input_tokens,
             text_output_tokens,
             reasoning_output_tokens,
+            audio_duration_ms,
             reporting_status,
             raw_usage,
             occurred_at,
             recorded_at
           ) VALUES (
-            ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+            ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
           )
-        `).run(record.projectId, record.id, record.executionId, record.attempt, record.callId, record.providerId, record.providerIds === undefined ? null : JSON.stringify(record.providerIds), record.requestedModelId, record.requestedReasoning === undefined ? null : JSON.stringify(record.requestedReasoning), record.responseModelId ?? null, record.responseId, record.usage.inputTokens ?? null, record.usage.outputTokens ?? null, record.usage.totalTokens ?? null, record.usage.uncachedInputTokens ?? null, record.usage.cacheReadInputTokens ?? null, record.usage.cacheWriteInputTokens ?? null, record.usage.textOutputTokens ?? null, record.usage.reasoningOutputTokens ?? null, record.usage.reportingStatus, record.rawUsage === undefined ? null : JSON.stringify(record.rawUsage), record.occurredAt.toISOString(), record.recordedAt.toISOString());
+        `).run(record.projectId, record.id, record.executionId, record.attempt, record.callId, record.providerId, record.providerIds === undefined ? null : JSON.stringify(record.providerIds), record.requestedModelId, record.modelKind ?? null, record.requestedReasoning === undefined ? null : JSON.stringify(record.requestedReasoning), record.responseModelId ?? null, record.responseId, record.usage.inputTokens ?? null, record.usage.outputTokens ?? null, record.usage.totalTokens ?? null, record.usage.uncachedInputTokens ?? null, record.usage.cacheReadInputTokens ?? null, record.usage.cacheWriteInputTokens ?? null, record.usage.textOutputTokens ?? null, record.usage.reasoningOutputTokens ?? null, record.usage.audioDurationMs ?? null, record.usage.reportingStatus, record.rawUsage === undefined ? null : JSON.stringify(record.rawUsage), record.occurredAt.toISOString(), record.recordedAt.toISOString());
   }
   findByIdempotencyKey(record) {
     const row = this.connection.db.query(`
@@ -6645,6 +6940,7 @@ class SqliteAiUsageStorage {
       providerId: row.provider_id,
       ...row.provider_ids === null ? {} : { providerIds: normalizeModelProviderIds(JSON.parse(row.provider_ids)) },
       requestedModelId: row.requested_model_id,
+      ...row.model_kind === null ? {} : { modelKind: row.model_kind },
       ...row.requested_reasoning === null ? {} : { requestedReasoning: requestedReasoningFromRow(row.requested_reasoning) },
       ...row.response_model_id === null ? {} : { responseModelId: row.response_model_id },
       responseId: row.response_id,
@@ -6701,7 +6997,8 @@ function usageFromRow(row) {
     ...row.cache_read_input_tokens === null ? {} : { cacheReadInputTokens: row.cache_read_input_tokens },
     ...row.cache_write_input_tokens === null ? {} : { cacheWriteInputTokens: row.cache_write_input_tokens },
     ...row.text_output_tokens === null ? {} : { textOutputTokens: row.text_output_tokens },
-    ...row.reasoning_output_tokens === null ? {} : { reasoningOutputTokens: row.reasoning_output_tokens }
+    ...row.reasoning_output_tokens === null ? {} : { reasoningOutputTokens: row.reasoning_output_tokens },
+    ...row.audio_duration_ms === null ? {} : { audioDurationMs: row.audio_duration_ms }
   };
 }
 function requestedReasoningFromRow(value) {
@@ -6882,6 +7179,7 @@ var SQLITE_ACCOUNTING_OVERVIEW_SQL = `
       usage.cache_write_input_tokens,
       usage.text_output_tokens,
       usage.reasoning_output_tokens,
+      usage.audio_duration_ms,
       usage.reporting_status,
       CASE
         WHEN direct_agent.kind = 'conversation' THEN 'agent'
@@ -6966,6 +7264,8 @@ var SQLITE_ACCOUNTING_OVERVIEW_SQL = `
     CAST(SUM(text_output_tokens) AS TEXT) AS text_output_tokens_sum,
     CAST(COUNT(reasoning_output_tokens) AS TEXT) AS reasoning_output_tokens_count,
     CAST(SUM(reasoning_output_tokens) AS TEXT) AS reasoning_output_tokens_sum,
+    CAST(COUNT(audio_duration_ms) AS TEXT) AS audio_duration_ms_count,
+    CAST(SUM(audio_duration_ms) AS TEXT) AS audio_duration_ms_sum,
     CAST(SUM(CASE WHEN valuation_status = 'rated' THEN 1 ELSE 0 END) AS TEXT)
       AS rated_call_count,
     CAST(SUM(CASE WHEN valuation_status = 'unpriceable' THEN 1 ELSE 0 END) AS TEXT)
@@ -7011,7 +7311,8 @@ function aggregateFragmentFromRow(row) {
       cacheReadInputTokens: meterFragment(row.cache_read_input_tokens_count, row.cache_read_input_tokens_sum),
       cacheWriteInputTokens: meterFragment(row.cache_write_input_tokens_count, row.cache_write_input_tokens_sum),
       textOutputTokens: meterFragment(row.text_output_tokens_count, row.text_output_tokens_sum),
-      reasoningOutputTokens: meterFragment(row.reasoning_output_tokens_count, row.reasoning_output_tokens_sum)
+      reasoningOutputTokens: meterFragment(row.reasoning_output_tokens_count, row.reasoning_output_tokens_sum),
+      audioDurationMs: meterFragment(row.audio_duration_ms_count, row.audio_duration_ms_sum)
     },
     costs: {
       ...row.amount_currency === null || row.amount_high === null || row.amount_middle === null || row.amount_low === null ? {} : {
@@ -7067,6 +7368,7 @@ function usageFromRow2(row, requesterGroupIds) {
     providerId: row.provider_id,
     ...row.provider_ids === null ? {} : { providerIds: normalizeModelProviderIds2(JSON.parse(row.provider_ids)) },
     requestedModelId: row.requested_model_id,
+    ...row.model_kind === null ? {} : { modelKind: row.model_kind },
     ...row.requested_reasoning === null ? {} : { requestedReasoning: requestedReasoningFromRow(row.requested_reasoning) },
     ...row.response_model_id === null ? {} : { responseModelId: row.response_model_id },
     responseId: row.response_id,
@@ -7079,6 +7381,7 @@ function usageFromRow2(row, requesterGroupIds) {
       ...row.cache_write_input_tokens === null ? {} : { cacheWriteInputTokens: row.cache_write_input_tokens },
       ...row.text_output_tokens === null ? {} : { textOutputTokens: row.text_output_tokens },
       ...row.reasoning_output_tokens === null ? {} : { reasoningOutputTokens: row.reasoning_output_tokens },
+      ...row.audio_duration_ms === null ? {} : { audioDurationMs: row.audio_duration_ms },
       reportingStatus: row.reporting_status
     },
     ...row.raw_usage === null ? {} : { rawUsage: JSON.parse(row.raw_usage) },
@@ -7219,6 +7522,7 @@ function required(value) {
 // src/ai-limit-storage.ts
 import {
   aiLimitAmountKey,
+  aiLimitMeterApplies,
   aiLimitQuantityFromAmount,
   aiLimitReservationBuckets,
   aiLimitReservationRequestKey,
@@ -7327,8 +7631,9 @@ class SqliteAiLimitStorage {
       const unavailablePolicies = [];
       const unavailableReasons = new Set;
       for (const policy of enabledPolicies) {
-        if (!subjectKeys.has(aiLimitSubjectKey(policy.subject)))
+        if (!subjectKeys.has(aiLimitSubjectKey(policy.subject)) || !aiLimitMeterApplies(policy.limit.meter, request.modelKind)) {
           continue;
+        }
         const limit = normalizeAiLimitAmount(policy.limit);
         const estimate = estimates.get(aiLimitAmountKey(limit));
         const status = this.statusForPolicy(policy, request.period);
@@ -7362,7 +7667,7 @@ class SqliteAiLimitStorage {
           resetAt: new Date(Math.min(...exhaustedPolicies.map((status) => status.period.resetAt.getTime())))
         };
       }
-      const buckets = aiLimitReservationBuckets(enabledPolicies, request.subjects, request.estimates);
+      const buckets = aiLimitReservationBuckets(enabledPolicies, request.subjects, request.estimates, request.modelKind);
       if (buckets.length === 0)
         return { status: "notRequired" };
       for (const bucket of buckets) {
@@ -7576,6 +7881,7 @@ class SqliteAiLimitStorage {
           SELECT usage.project_id, usage.id AS usage_record_id, usage.execution_id,
                  usage.attempt, usage.call_id, usage.occurred_at,
                  CAST(usage.total_tokens AS TEXT) AS total_tokens,
+                 usage.model_kind,
                  executions.requested_by_user_id,
                  executions.requested_by_service_account_id,
                  valuations.status AS valuation_status,
@@ -7614,6 +7920,7 @@ class SqliteAiLimitStorage {
           SELECT usage.project_id, usage.id AS usage_record_id, usage.execution_id,
                  usage.attempt, usage.call_id, usage.occurred_at,
                  CAST(usage.total_tokens AS TEXT) AS total_tokens,
+                 usage.model_kind,
                  executions.requested_by_user_id,
                  executions.requested_by_service_account_id,
                  valuations.status AS valuation_status,
@@ -7691,6 +7998,7 @@ function accountingEntryFromRow(row, subject, requesterGroupIds = subject?.type
     attempt: row.attempt,
     callId: row.call_id,
     occurredAt: new Date(row.occurred_at),
+    ...row.model_kind === null ? {} : { modelKind: row.model_kind },
     ...totalTokens !== undefined && Number.isSafeInteger(totalTokens) ? { totalTokens } : {},
     requesterGroupIds,
     ...requester ? { requester } : {},
@@ -10410,9 +10718,12 @@ class SqliteExecutionStorage {
         FROM executions
         WHERE project_id = ? AND id = ?
       `).get(params.projectId, params.id);
-    return row ? executionRecordFromStorageRow(toStorageRow(row)) : null;
+    return row ? sqliteExecutionRecord(row) : null;
   }
 }
+function sqliteExecutionRecord(row) {
+  return executionRecordFromStorageRow(toStorageRow(row));
+}
 function toStorageRow(row) {
   return {
     projectId: row.project_id,
@@ -10444,6 +10755,43 @@ function isDuplicateExecutionError(error) {
   return error instanceof Error && error.message.includes("UNIQUE constraint failed: executions.project_id, executions.id");
 }
 
+// src/file-download-grant-storage.ts
+import { parseFileDownloadGrantRow } from "@sixb/core/internal/storage";
+var GRANT_COLUMNS = `
+  project_id AS projectId, id, token_hash AS tokenHash, file, execution_id AS executionId,
+  created_at AS createdAt, expires_at AS expiresAt, revoked_at AS revokedAt
+`;
+
+class SqliteFileDownloadGrantStorage {
+  db;
+  constructor(connection) {
+    this.db = connection.db;
+  }
+  async create(record) {
+    this.db.query(`INSERT INTO file_download_grants (
+          project_id, id, token_hash, file, execution_id, created_at, expires_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(record.projectId, record.id, record.tokenHash, JSON.stringify(record.file), record.executionId, record.createdAt.toISOString(), record.expiresAt.toISOString());
+  }
+  async findByTokenHash(input) {
+    const row = this.db.query(`SELECT ${GRANT_COLUMNS} FROM file_download_grants WHERE project_id = ? AND token_hash = ?`).get(input.projectId, input.tokenHash);
+    return row ? parseFileDownloadGrantRow(row) : null;
+  }
+  async revoke(input) {
+    const row = this.db.query(`UPDATE file_download_grants SET revoked_at = COALESCE(revoked_at, ?)
+         WHERE project_id = ? AND id = ?
+         RETURNING ${GRANT_COLUMNS}`).get(input.revokedAt.toISOString(), input.projectId, input.id);
+    return row ? parseFileDownloadGrantRow(row) : null;
+  }
+  async deleteExpired(input) {
+    return this.db.query(`DELETE FROM file_download_grants WHERE rowid IN (
+          SELECT rowid FROM file_download_grants
+          WHERE project_id = ? AND expires_at < ?
+          ORDER BY expires_at
+          LIMIT ?
+        )`).run(input.projectId, input.expiredBefore.toISOString(), input.limit).changes;
+  }
+}
+
 // src/file-upload-session-storage.ts
 import {
   DurableFileUploadSessions,
@@ -10584,6 +10932,8 @@ function exactContext(ctx) {
 }
 function compileObjectQueryInternal(projectId, query, ctx) {
   switch (query.kind) {
+    case "rerank":
+      throw new ObjectQueryExecutionError("reranking_requires_runtime", "Reranking must execute in the model runtime, not storage.");
     case "start":
       return compileStart(projectId, query, ctx);
     case "refs":
@@ -11716,6 +12066,7 @@ class SqliteObjectReader {
       source
     });
     return {
+      total: readTotal(this.db, compiled),
       facets: params.facets.map((facet) => ({
         propertyId: facet.propertyId,
         buckets: readFacetBuckets(this.db, compiled, facet)
@@ -12496,9 +12847,7 @@ class SqliteObjectStorage {
     return this.reader.existsObjects(params);
   }
   async facetObjects(params) {
-    if (hasVectorProfile3(params.query))
-      return runDeferredReadTransaction(this.db, () => this.reader.facetObjects(params));
-    return this.reader.facetObjects(params);
+    return runDeferredReadTransaction(this.db, () => this.reader.facetObjects(params));
   }
   async getByPrimaryId(params) {
     return this.reader.getByPrimaryId(params);
@@ -12547,13 +12896,14 @@ class SqliteObjectStorage {
   }
   async listByPrimaryIdPage(params) {
     assertReconciliationPageLimit(params.limit);
+    const cursor = params.afterPrimaryId === undefined ? [] : [params.afterPrimaryId];
     const rows = this.db.query(`
           SELECT * FROM objects
           WHERE project_id = ? AND object_type_id = ?
-            AND (? IS NULL OR primary_id > ?)
+            ${cursor.length > 0 ? "AND primary_id > ?" : ""}
           ORDER BY primary_id ASC
           LIMIT ?
-        `).all(params.projectId, params.objectTypeId, params.afterPrimaryId ?? null, params.afterPrimaryId ?? null, params.limit + 1);
+        `).all(params.projectId, params.objectTypeId, ...cursor, params.limit + 1);
     const hasMore = rows.length > params.limit;
     const objects = rows.slice(0, params.limit).map((row) => rowToObject(row));
     const last = objects.at(-1);
@@ -12646,10 +12996,6 @@ function commitRecord(row) {
     requestHash: row.request_hash,
     executionId: row.execution_id,
     origin: parseJson2(row.origin),
-    ...row.requested_by === null ? {} : {
-      requestedBy: parseJson2(row.requested_by)
-    },
-    executor: parseJson2(row.executor),
     ontologyRevision: row.ontology_revision,
     ...row.projection_revision === null ? {} : { projectionRevision: row.projection_revision },
     ...row.ownership_hash === null ? {} : { ownershipHash: row.ownership_hash },
@@ -12659,9 +13005,15 @@ function commitRecord(row) {
   const result = parseJson2(row.result);
   return { ...base, intent, result };
 }
-function outboxRecord(row) {
+function claimedOutboxDraft(row) {
+  if (row.lease_id === null || row.lease_expires_at === null) {
+    throw new MaterializationConflictError("outbox-lease", "Ontology outbox claim returned an unpaired lease.");
+  }
   return {
-    envelope: parseJson2(row.envelope),
+    id: row.id,
+    commitId: row.commit_id,
+    commitOrdinal: row.commit_ordinal,
+    event: parseJson2(row.event),
     availableAt: row.available_at,
     attempts: row.attempts,
     leaseId: row.lease_id,
@@ -12795,9 +13147,9 @@ import {
   linkRefKey as linkRefKey3,
   linkRefSortKey,
   linkScopeSortKey as linkScopeSortKey2,
-  MaterializationConflictError as MaterializationConflictError6,
-  MaterializationValidationError as MaterializationValidationError2,
-  objectRefKey as objectRefKey3,
+  MaterializationConflictError as MaterializationConflictError7,
+  MaterializationValidationError as MaterializationValidationError3,
+  objectRefKey as objectRefKey4,
   objectRefSortKey,
   telemetryPointKey as telemetryPointKey2,
   telemetryPointSortKey as telemetryPointSortKey2
@@ -12808,24 +13160,24 @@ import {
   assertExpectedObjectRevision,
   assertMaterializationFinalizationCorrelation,
   assertMaterializationHeader,
-  assertMaterializationLaneCompletion,
-  assertPageRows,
-  assertPlanChunkCorrelations,
+  assertPageRows as assertPageRows2,
   assertSourceActivationCorrelation,
+  beginMaterializationApply,
+  beginMaterializationVectorChanges,
+  createCardinalityValidator,
   invalidCorrelation as invalidCorrelation2,
+  materializationOutboxWrite,
+  materializationPlanChunk,
   sameNonnegativeCounts as sameCounts,
   uniqueSorted
 } from "@sixb/core/internal/ontology-storage-provider";
 
 // src/ontology-storage/materialization-session.ts
 import {
-  MaterializationConflictError as MaterializationConflictError4
+  MaterializationConflictError as MaterializationConflictError5
 } from "@sixb/core/internal/materialization";
 import {
-  correlateMaterializationChunk,
   duplicateMaterializationWork as duplicateWork,
-  invalidCorrelation,
-  materializationPlanItems,
   ProviderMaterializationSessionState,
   prepareMaterializationWork
 } from "@sixb/core/internal/ontology-storage-provider";
@@ -12936,18 +13288,35 @@ function stageSourceRoots(db, manifest, input) {
     }
   }
 }
-function activateSourceRoots(db, projectId, candidate, activation) {
+function activateSourceRoots(db, projectId, commitId, candidate, activation) {
   if (candidate.base_materialization_id !== null && (candidate.base_materialization_id !== activation.expected.activeMaterializationId || candidate.base_commit_id !== activation.expected.lastCommitId))
     throw new MaterializationConflictError2("projection-fence", "Source delta base changed before activation.");
   if (candidate.base_materialization_id !== null && candidate.root_count === 0)
     return;
   const delta = candidate.base_materialization_id !== null;
-  db.query(`UPDATE ontology_source_roots SET retired_at = ?
-    WHERE retired_at IS NULL AND deleted = 0
-      AND version_id IN (SELECT version_id FROM ontology_sources
-        WHERE project_id = ? AND source_id = ? AND status IN ${PUBLISHED})
-      ${delta ? `AND project_id = ? AND root_key IN (
-        SELECT root_key FROM ontology_source_roots WHERE version_id = ?)` : ""}`).run(activation.updatedAt, projectId, activation.source.projectionId, ...delta ? [projectId, candidate.version_id] : []);
+  const replaced = `retired_at IS NULL AND deleted = 0
+    AND version_id IN (SELECT version_id FROM ontology_sources
+      WHERE project_id = ? AND source_id = ? AND status IN ${PUBLISHED})
+    ${delta ? `AND project_id = ? AND root_key IN (
+      SELECT root_key FROM ontology_source_roots WHERE version_id = ?)` : ""}`;
+  const replacedParams = [
+    projectId,
+    activation.source.projectionId,
+    ...delta ? [projectId, candidate.version_id] : []
+  ];
+  db.query(`INSERT INTO ontology_commit_touches (project_id, commit_id, entity_kind, identity_key)
+    SELECT DISTINCT ?, ?, 'link', json_array(
+      rows.source_type_id, rows.source_primary_id, rows.link_id, rows.target_type_id,
+      rows.target_primary_id
+    )
+    FROM (
+      SELECT id FROM ontology_source_roots WHERE ${replaced}
+      UNION ALL
+      SELECT id FROM ontology_source_roots WHERE version_id = ?
+    ) AS changed
+    CROSS JOIN ontology_source_rows AS rows ON rows.root_id = changed.id
+    WHERE rows.entity_kind = 'link'`).run(projectId, commitId, ...replacedParams, candidate.version_id);
+  db.query(`UPDATE ontology_source_roots SET retired_at = ? WHERE ${replaced}`).run(activation.updatedAt, ...replacedParams);
   db.query(`UPDATE ontology_source_roots SET retired_at = ?
     WHERE version_id = ? AND deleted = 1`).run(activation.updatedAt, candidate.version_id);
 }
@@ -13000,7 +13369,6 @@ function replacementAssertionRows(db, input) {
 
 // src/ontology-storage/materialization-state.ts
 var SQLITE_MATERIALIZATION_WORK_TABLE = "ontology_materialization_work";
-var SQLITE_REPLACEMENT_WORK_TABLE = "ontology_replacement_work";
 function linkScopeRequestJson(scopes) {
   return canonicalJson(scopes.map(({ source, linkId }) => ({
     scopeSortKey: linkScopeSortKey(source, linkId),
@@ -13328,20 +13696,6 @@ class SqliteMaterializationStateReader {
       cursor = rows[rows.length - 1]?.sort_key ?? null;
     }
   }
-  *replacementIdentities(input) {
-    this.prepareReplacementIdentities(input);
-    let cursor = null;
-    while (true) {
-      const rows = this.replacementRows(input, cursor);
-      if (rows.length === 0)
-        break;
-      yield rows.map(replacementIdentity);
-      if (rows.length < input.pageRows)
-        break;
-      const last = rows[rows.length - 1];
-      cursor = { sortKey: last.sort_key, identityKey: last.identity_key };
-    }
-  }
   replacementObjectStates(sourceId, candidateMaterializationId, refs) {
     const base = this.objectStates(refs);
     const candidates = this.replacementSources(sourceId, [candidateMaterializationId], refs.map((ref) => ({ kind: "object", ref })));
@@ -13407,174 +13761,6 @@ class SqliteMaterializationStateReader {
     }
     return { owned, byMaterialization };
   }
-  prepareReplacementIdentities(input) {
-    if (input.kind === "object") {
-      this.prepareReplacementObjects(input);
-      return;
-    }
-    this.prepareReplacementLinks(input);
-  }
-  prepareReplacementObjects(input) {
-    const rows = replacementSourceRows(this.db, {
-      projectId: this.projectId,
-      sourceId: input.sourceId,
-      materializationId: input.candidateMaterializationId,
-      incremental: input.incremental ?? false
-    });
-    this.db.query(`
-          INSERT INTO ${SQLITE_REPLACEMENT_WORK_TABLE} (
-            session_id, entity_kind, identity_key, sort_key, diff_required
-          )
-          SELECT ?, 'object', json_array(object_type_id, primary_id),
-            ${objectSortExpression()}, 1
-          FROM (${rows.sql}) AS rows
-          WHERE entity_kind = 'object'
-          GROUP BY object_type_id, primary_id
-        `).run(input.sessionId, ...rows.values);
-  }
-  prepareReplacementLinks(input) {
-    const rows = replacementSourceRows(this.db, {
-      projectId: this.projectId,
-      sourceId: input.sourceId,
-      materializationId: input.candidateMaterializationId,
-      incremental: input.incremental ?? false
-    });
-    this.db.query(`
-          WITH incident_objects AS (
-            SELECT DISTINCT
-              json_extract(payload, '$.ref.objectTypeId') AS object_type_id,
-              json_extract(payload, '$.ref.primaryId') AS primary_id
-            FROM ${SQLITE_MATERIALIZATION_WORK_TABLE}
-            WHERE session_id = ? AND kind = 'incident-object'
-          ), replacement_links AS (
-            SELECT source_type_id, source_primary_id AS source_id, link_id,
-              target_type_id, target_primary_id AS target_id
-            FROM (${rows.sql}) AS rows
-            WHERE entity_kind = 'link'
-          ), incident_links AS (
-            SELECT links.source_type_id, links.source_id, links.link_id,
-              links.target_type_id, links.target_id
-            FROM links
-            JOIN incident_objects
-              ON incident_objects.object_type_id = links.source_type_id
-             AND incident_objects.primary_id = links.source_id
-            WHERE links.project_id = ?
-            UNION
-            SELECT links.source_type_id, links.source_id, links.link_id,
-              links.target_type_id, links.target_id
-            FROM links
-            JOIN incident_objects
-              ON incident_objects.object_type_id = links.target_type_id
-             AND incident_objects.primary_id = links.target_id
-            WHERE links.project_id = ?
-            UNION
-            SELECT overrides.source_type_id,
-              overrides.source_primary_id AS source_id,
-              overrides.link_id, overrides.target_type_id,
-              overrides.target_primary_id AS target_id
-            FROM ontology_link_overrides AS overrides
-            JOIN incident_objects
-              ON incident_objects.object_type_id = overrides.source_type_id
-             AND incident_objects.primary_id = overrides.source_primary_id
-            WHERE overrides.project_id = ?
-            UNION
-            SELECT overrides.source_type_id,
-              overrides.source_primary_id AS source_id,
-              overrides.link_id, overrides.target_type_id,
-              overrides.target_primary_id AS target_id
-            FROM ontology_link_overrides AS overrides
-            JOIN incident_objects
-              ON incident_objects.object_type_id = overrides.target_type_id
-             AND incident_objects.primary_id = overrides.target_primary_id
-            WHERE overrides.project_id = ?
-            UNION
-            SELECT rows.source_type_id, rows.source_primary_id AS source_id,
-              rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
-            FROM incident_objects
-            CROSS JOIN ontology_source_rows AS rows
-              ON rows.entity_kind = 'link'
-             AND rows.source_type_id = incident_objects.object_type_id
-             AND rows.source_primary_id = incident_objects.primary_id
-            ${LIVE_SOURCE_ROWS_JOIN}
-            UNION
-            SELECT rows.source_type_id, rows.source_primary_id AS source_id,
-              rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
-            FROM incident_objects
-            CROSS JOIN ontology_source_rows AS rows
-              ON rows.entity_kind = 'link'
-             AND rows.target_type_id = incident_objects.object_type_id
-             AND rows.target_primary_id = incident_objects.primary_id
-            ${LIVE_SOURCE_ROWS_JOIN}
-          ), diff_links AS (
-            SELECT * FROM replacement_links
-            UNION SELECT * FROM incident_links
-          ), affected_scopes AS (
-            SELECT DISTINCT source_type_id, source_id, link_id FROM diff_links
-          ), all_links AS (
-            SELECT *, 1 AS diff_required FROM diff_links
-            UNION ALL
-            SELECT links.source_type_id, links.source_id, links.link_id,
-              links.target_type_id, links.target_id, 0 AS diff_required
-            FROM links
-            JOIN affected_scopes USING (source_type_id, source_id, link_id)
-            WHERE links.project_id = ?
-            UNION ALL
-            SELECT overrides.source_type_id, overrides.source_primary_id AS source_id,
-              overrides.link_id, overrides.target_type_id,
-              overrides.target_primary_id AS target_id, 0 AS diff_required
-            FROM ontology_link_overrides AS overrides
-            JOIN affected_scopes
-              ON affected_scopes.source_type_id = overrides.source_type_id
-             AND affected_scopes.source_id = overrides.source_primary_id
-             AND affected_scopes.link_id = overrides.link_id
-            WHERE overrides.project_id = ? AND overrides.identity_kind = 'slot'
-          ), selected AS (
-            SELECT source_type_id, source_id, link_id, target_type_id, target_id,
-              ${linkSortExpression("all_links")} AS sort_key,
-              MAX(diff_required) AS diff_required
-            FROM all_links
-            GROUP BY source_type_id, source_id, link_id, target_type_id, target_id
-          )
-          INSERT INTO ${SQLITE_REPLACEMENT_WORK_TABLE} (
-            session_id, entity_kind, identity_key, sort_key, diff_required
-          )
-          SELECT ?, 'link',
-            json_array(source_type_id, source_id, link_id, target_type_id, target_id),
-            sort_key, diff_required
-          FROM selected
-        `).run(input.sessionId, ...rows.values, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, input.sessionId);
-  }
-  replacementRows(input, cursor) {
-    return this.db.query(`
-          SELECT entity_kind, identity_key, sort_key, diff_required
-          FROM ${SQLITE_REPLACEMENT_WORK_TABLE}
-          WHERE session_id = ? AND entity_kind = ?
-            AND (? IS NULL OR (sort_key, identity_key) > (?, ?))
-          ORDER BY sort_key, identity_key
-          LIMIT ?
-        `).all(input.sessionId, input.kind, cursor?.sortKey ?? null, cursor?.sortKey ?? null, cursor?.identityKey ?? null, input.pageRows);
-  }
-}
-function replacementIdentity(row) {
-  const parts = parseJson2(row.identity_key);
-  if (row.entity_kind === "object") {
-    return {
-      kind: "object",
-      ref: { objectTypeId: parts[0], primaryId: parts[1] },
-      sortKey: row.sort_key,
-      diffRequired: true
-    };
-  }
-  return {
-    kind: "link",
-    ref: {
-      source: { objectTypeId: parts[0], primaryId: parts[1] },
-      linkId: parts[2],
-      target: { objectTypeId: parts[3], primaryId: parts[4] }
-    },
-    sortKey: row.sort_key,
-    diffRequired: row.diff_required === 1
-  };
 }
 function activeSourceMap(rows) {
   const result = new Map;
@@ -13702,20 +13888,709 @@ function storedPoint(row) {
     lastCommitId: row.last_commit_id
   };
 }
-function objectSortExpression(alias) {
-  const prefix = alias ? `${alias}.` : "";
-  return `LOWER(HEX(CAST(json_array(${prefix}object_type_id, ${prefix}primary_id) AS BLOB)))`;
-}
 function linkSortExpression(alias) {
   const prefix = alias ? `${alias}.` : "";
   return `LOWER(HEX(CAST(json_array(${prefix}source_type_id, ${prefix}source_id, ${prefix}link_id, ${prefix}target_type_id, ${prefix}target_id) AS BLOB)))`;
 }
 
+// src/ontology-storage/replacement-plans.ts
+import {
+  MaterializationConflictError as MaterializationConflictError4,
+  MaterializationValidationError as MaterializationValidationError2,
+  objectRefKey as objectRefKey2
+} from "@sixb/core/internal/materialization";
+import {
+  assertNonblank as assertNonblank2,
+  assertPageRows,
+  assertPositiveInteger as assertPositiveInteger2,
+  assertReplacementPlanCommit,
+  canonicalJson as canonicalJson2,
+  duplicateMaterializationWork,
+  invalidCorrelation,
+  materializationWorkColumns,
+  prepareReplacementIdentities,
+  workUniquenessKey
+} from "@sixb/core/internal/ontology-storage-provider";
+var SQLITE_PLAN_WORK_TABLE = "ontology_replacement_plan_work";
+var IDENTITIES = "ontology_replacement_plan_identities";
+var SORT_KEY = "LOWER(HEX(CAST(identity_key AS BLOB)))";
+function objectRevision(type, id) {
+  const series = (alias) => `${alias}.project_id = $projectId AND ${alias}.object_type_id = ${type} AND ${alias}.object_id = ${id}`;
+  return `json_array(
+    (SELECT json_array(version, last_commit_id) FROM objects
+      WHERE project_id = $projectId AND object_type_id = ${type} AND primary_id = ${id}),
+    (SELECT last_commit_id FROM ontology_object_overrides
+      WHERE project_id = $projectId AND object_type_id = ${type} AND primary_id = ${id}),
+    (WITH RECURSIVE properties(property_id) AS (
+      SELECT MIN(first.property_id) FROM timeseries AS first WHERE ${series("first")}
+      UNION ALL
+      SELECT (SELECT MIN(next.property_id) FROM timeseries AS next
+        WHERE ${series("next")} AND next.property_id > properties.property_id)
+      FROM properties WHERE properties.property_id IS NOT NULL
+    )
+    SELECT json_group_array(json((
+      SELECT json_array(points.property_id, points.at, points.last_commit_id)
+      FROM timeseries AS points
+      WHERE ${series("points")} AND points.property_id = properties.property_id
+      ORDER BY points.at DESC LIMIT 1
+    ))) FROM properties WHERE properties.property_id IS NOT NULL)
+  )`;
+}
+function endpointRevision(type, id) {
+  return `CASE WHEN EXISTS (
+      SELECT 1 FROM ${IDENTITIES} AS endpoint
+      WHERE endpoint.version_id = $versionId AND endpoint.entity_kind = 'object'
+        AND endpoint.identity_key = json_array(${type}, ${id})
+    ) THEN ${objectRevision(type, id)}
+    ELSE json(CASE WHEN EXISTS (
+      SELECT 1 FROM objects
+      WHERE project_id = $projectId AND object_type_id = ${type} AND primary_id = ${id}
+    ) THEN 'true' ELSE 'false' END)
+  END`;
+}
+function linkRevision(key) {
+  const part = (index) => `json_extract(${key}, '$[${index}]')`;
+  return `json_array(
+    (SELECT last_commit_id FROM links
+      WHERE project_id = $projectId AND source_type_id = ${part(0)} AND source_id = ${part(1)}
+        AND link_id = ${part(2)} AND target_type_id = ${part(3)} AND target_id = ${part(4)}),
+    (SELECT overrides.last_commit_id FROM ontology_link_overrides AS overrides
+      WHERE overrides.project_id = $projectId AND overrides.identity_kind = 'edge'
+        AND overrides.identity_key = ${key}),
+    (SELECT overrides.last_commit_id FROM ontology_link_overrides AS overrides
+      WHERE overrides.project_id = $projectId AND overrides.identity_kind = 'slot'
+        AND overrides.identity_key = json_array(${part(0)}, ${part(1)}, ${part(2)})),
+    (SELECT MAX(roots.id) FROM ontology_source_roots AS roots
+      CROSS JOIN ontology_sources AS versions ON versions.version_id = roots.version_id
+        AND versions.status IN ${PUBLISHED}
+      WHERE roots.project_id = $projectId AND roots.retired_at IS NULL AND roots.deleted = 0
+        AND roots.root_key IN (
+          '["link",' || substr(${key}, 2),
+          '["object",' || substr(json_array(${part(0)}, ${part(1)}), 2)
+        )
+        AND EXISTS (
+          -- \`+\` keeps the lookup on the root's few rows, not on every row of a hub source.
+          SELECT 1 FROM ontology_source_rows AS rows
+          WHERE rows.root_id = roots.id AND +rows.entity_kind = 'link'
+            AND +rows.source_type_id = ${part(0)} AND +rows.source_primary_id = ${part(1)}
+            AND +rows.link_id = ${part(2)} AND +rows.target_type_id = ${part(3)}
+            AND +rows.target_primary_id = ${part(4)}
+        )),
+    ${endpointRevision(part(0), part(1))},
+    ${endpointRevision(part(3), part(4))}
+  )`;
+}
+function identityRevision(kind) {
+  const key = "identities.identity_key";
+  return kind === "object" ? objectRevision(`json_extract(${key}, '$[0]')`, `json_extract(${key}, '$[1]')`) : linkRevision(key);
+}
+function linkKeys(relation) {
+  return `SELECT json_array(source_type_id, source_id, link_id, target_type_id, target_id)
+      AS identity_key, json_array(source_type_id, source_id) AS source_key,
+      json_array(target_type_id, target_id) AS target_key
+    FROM ${relation}`;
+}
+var NEXT_EXPANSION = `(
+  SELECT expansions FROM ontology_replacement_plans WHERE version_id = $versionId
+)`;
+var INSERT_INCIDENT_LINKS = `
+  INSERT INTO ${IDENTITIES} (
+    version_id, entity_kind, identity_key, sort_key, diff_required, expand_at, source_key,
+    target_key
+  )
+  SELECT $versionId, 'link', identity_key, ${SORT_KEY}, 1, ${NEXT_EXPANSION}, source_key,
+    target_key
+  FROM (${linkKeys("incident_links")}) WHERE true
+  ON CONFLICT (version_id, entity_kind, identity_key) DO UPDATE
+  SET diff_required = 1, read_revision = NULL, planned_revision = NULL, classified = 0,
+    change = NULL, expand_at = excluded.expand_at
+  WHERE ${IDENTITIES}.diff_required = 0`;
+var INSERT_MEMBER_LINKS = `
+  INSERT INTO ${IDENTITIES} (
+    version_id, entity_kind, identity_key, sort_key, diff_required, source_key, target_key
+  )
+  SELECT $versionId, 'link', identity_key, ${SORT_KEY}, 0, source_key, target_key
+  FROM (${linkKeys("members")}) WHERE true
+  ON CONFLICT (version_id, entity_kind, identity_key) DO NOTHING`;
+var LIVE_ROWS = `CROSS JOIN ontology_source_roots AS roots ON roots.id = rows.root_id
+      AND roots.project_id = $projectId AND roots.retired_at IS NULL AND roots.deleted = 0
+    CROSS JOIN ontology_sources AS versions ON versions.version_id = roots.version_id
+      AND versions.status IN ${PUBLISHED}`;
+var EXPAND_LINK_STATEMENTS = {
+  incident: `WITH incident_objects AS MATERIALIZED (
+    SELECT json_extract(work.payload, '$.ref.objectTypeId') AS object_type_id,
+      json_extract(work.payload, '$.ref.primaryId') AS primary_id
+    FROM ${IDENTITIES} AS objects
+    CROSS JOIN ${SQLITE_PLAN_WORK_TABLE} AS work ON work.work_id = $versionId
+      AND work.unique_key = 'incident-object:' || objects.identity_key
+    WHERE objects.version_id = $versionId AND objects.entity_kind = 'object'
+      AND objects.expand_at = ${NEXT_EXPANSION}
+  ), incident_links AS (
+    SELECT links.source_type_id, links.source_id, links.link_id,
+      links.target_type_id, links.target_id
+    FROM incident_objects CROSS JOIN links
+      ON links.project_id = $projectId
+     AND links.source_type_id = incident_objects.object_type_id
+     AND links.source_id = incident_objects.primary_id
+    UNION
+    SELECT links.source_type_id, links.source_id, links.link_id,
+      links.target_type_id, links.target_id
+    FROM incident_objects CROSS JOIN links INDEXED BY idx_links_target
+      ON links.project_id = $projectId
+     AND links.target_type_id = incident_objects.object_type_id
+     AND links.target_id = incident_objects.primary_id
+    UNION
+    SELECT overrides.source_type_id, overrides.source_primary_id, overrides.link_id,
+      overrides.target_type_id, overrides.target_primary_id
+    FROM incident_objects CROSS JOIN ontology_link_overrides AS overrides
+      ON overrides.project_id = $projectId AND overrides.identity_kind IN ('edge', 'slot')
+     AND overrides.source_type_id = incident_objects.object_type_id
+     AND overrides.source_primary_id = incident_objects.primary_id
+    UNION
+    SELECT overrides.source_type_id, overrides.source_primary_id, overrides.link_id,
+      overrides.target_type_id, overrides.target_primary_id
+    FROM incident_objects
+    CROSS JOIN ontology_link_overrides AS overrides INDEXED BY idx_ontology_link_overrides_target
+      ON overrides.project_id = $projectId
+     AND overrides.target_type_id = incident_objects.object_type_id
+     AND overrides.target_primary_id = incident_objects.primary_id
+    UNION
+    SELECT rows.source_type_id, rows.source_primary_id, rows.link_id,
+      rows.target_type_id, rows.target_primary_id
+    FROM incident_objects CROSS JOIN ontology_source_rows AS rows
+      ON rows.entity_kind = 'link'
+     AND rows.source_type_id = incident_objects.object_type_id
+     AND rows.source_primary_id = incident_objects.primary_id
+    ${LIVE_ROWS}
+    UNION
+    SELECT rows.source_type_id, rows.source_primary_id, rows.link_id,
+      rows.target_type_id, rows.target_primary_id
+    FROM incident_objects CROSS JOIN ontology_source_rows AS rows
+      ON rows.entity_kind = 'link'
+     AND rows.target_type_id = incident_objects.object_type_id
+     AND rows.target_primary_id = incident_objects.primary_id
+    ${LIVE_ROWS}
+  )
+  ${INSERT_INCIDENT_LINKS}`,
+  members: `WITH scopes AS (
+    SELECT DISTINCT json_extract(identity_key, '$[0]') AS source_type_id,
+      json_extract(identity_key, '$[1]') AS source_id,
+      json_extract(identity_key, '$[2]') AS link_id
+    FROM ${IDENTITIES}
+    WHERE version_id = $versionId AND entity_kind = 'link' AND diff_required = 1
+      AND expand_at = ${NEXT_EXPANSION}
+  ), members AS (
+    SELECT links.source_type_id, links.source_id, links.link_id,
+      links.target_type_id, links.target_id
+    FROM scopes CROSS JOIN links
+      ON links.project_id = $projectId
+     AND links.source_type_id = scopes.source_type_id
+     AND links.source_id = scopes.source_id AND links.link_id = scopes.link_id
+    UNION
+    SELECT overrides.source_type_id, overrides.source_primary_id, overrides.link_id,
+      overrides.target_type_id, overrides.target_primary_id
+    FROM scopes CROSS JOIN ontology_link_overrides AS overrides
+      ON overrides.project_id = $projectId AND overrides.identity_kind = 'slot'
+     AND overrides.source_type_id = scopes.source_type_id
+     AND overrides.source_primary_id = scopes.source_id
+     AND overrides.link_id = scopes.link_id
+  )
+  ${INSERT_MEMBER_LINKS}`
+};
+var TOUCHED = `touched AS MATERIALIZED (
+  SELECT DISTINCT touches.entity_kind, touches.identity_key
+  FROM ontology_commits AS commits
+  CROSS JOIN ontology_commit_touches AS touches
+    ON touches.project_id = commits.project_id AND touches.commit_id = commits.id
+  WHERE commits.rowid > (
+      SELECT watermark FROM ontology_replacement_plans WHERE version_id = $versionId
+    ) AND +commits.project_id = $projectId
+)`;
+var TOUCHED_REFRESH_STATEMENTS = {
+  object: `WITH ${TOUCHED}
+  UPDATE ${IDENTITIES} AS identities
+  SET read_revision = NULL, planned_revision = NULL, classified = 0, change = NULL
+  WHERE identities.version_id = $versionId AND identities.entity_kind = 'object'
+    AND identities.identity_key IN (SELECT identity_key FROM touched WHERE entity_kind = 'object')
+    AND identities.planned_revision IS NOT ${identityRevision("object")}`,
+  link: `WITH ${TOUCHED}, candidates AS (
+    SELECT identity_key FROM touched WHERE entity_kind = 'link'
+    UNION
+    SELECT links.identity_key FROM touched CROSS JOIN ${IDENTITIES} AS links
+      ON links.version_id = $versionId
+     AND links.source_key = json_array(
+       json_extract(touched.identity_key, '$[0]'), json_extract(touched.identity_key, '$[1]')
+     )
+    WHERE touched.entity_kind IN ('object', 'scope')
+    UNION
+    SELECT links.identity_key FROM touched CROSS JOIN ${IDENTITIES} AS links
+      ON links.version_id = $versionId AND links.target_key = touched.identity_key
+    WHERE touched.entity_kind = 'object'
+  )
+  UPDATE ${IDENTITIES} AS identities
+  SET read_revision = NULL, planned_revision = NULL, classified = 0, change = NULL
+  WHERE identities.version_id = $versionId AND identities.entity_kind = 'link'
+    AND identities.identity_key IN (SELECT identity_key FROM candidates)
+    AND identities.planned_revision IS NOT ${identityRevision("link")}`
+};
+var TOUCHED_LINKS = `touched_links AS (
+  SELECT identity_key, json_extract(identity_key, '$[0]') AS source_type_id,
+    json_extract(identity_key, '$[1]') AS source_id, json_extract(identity_key, '$[2]') AS link_id,
+    json_extract(identity_key, '$[3]') AS target_type_id,
+    json_extract(identity_key, '$[4]') AS target_id
+  FROM touched WHERE entity_kind = 'link'
+), slot_targets AS (
+  SELECT overrides.source_type_id, overrides.source_primary_id AS source_id, overrides.link_id,
+    overrides.target_type_id, overrides.target_primary_id AS target_id
+  FROM touched CROSS JOIN ontology_link_overrides AS overrides
+    ON overrides.project_id = $projectId AND overrides.identity_kind = 'slot'
+   AND overrides.identity_key = touched.identity_key
+  WHERE touched.entity_kind = 'scope'
+)`;
+var LINK_COLUMNS = "source_type_id, source_id, link_id, target_type_id, target_id";
+var EFFECTIVE_TOUCHED_LINK = `EXISTS (
+  SELECT 1 FROM links AS stored
+  WHERE stored.project_id = $projectId AND stored.source_type_id = touched_links.source_type_id
+    AND stored.source_id = touched_links.source_id AND stored.link_id = touched_links.link_id
+    AND stored.target_type_id = touched_links.target_type_id
+    AND stored.target_id = touched_links.target_id
+)`;
+var EXPAND_TOUCHED_STATEMENTS = {
+  incident: `WITH ${TOUCHED}, ${TOUCHED_LINKS}, incident_links AS (
+    SELECT candidates.* FROM (
+      SELECT ${LINK_COLUMNS} FROM touched_links
+      WHERE ${EFFECTIVE_TOUCHED_LINK} OR EXISTS (
+        SELECT 1 FROM ontology_link_overrides AS overrides
+        WHERE overrides.project_id = $projectId AND overrides.identity_kind = 'edge'
+          AND overrides.identity_key = touched_links.identity_key
+      ) OR EXISTS (
+        SELECT 1 FROM ontology_source_rows AS rows ${LIVE_ROWS}
+        WHERE rows.entity_kind = 'link' AND rows.source_type_id = touched_links.source_type_id
+          AND rows.source_primary_id = touched_links.source_id
+          AND rows.link_id = touched_links.link_id
+          AND rows.target_type_id = touched_links.target_type_id
+          AND rows.target_primary_id = touched_links.target_id
+      )
+      UNION
+      SELECT ${LINK_COLUMNS} FROM slot_targets
+    ) AS candidates
+    WHERE EXISTS (
+      SELECT 1 FROM ${SQLITE_PLAN_WORK_TABLE} AS work
+      WHERE work.work_id = $versionId AND work.unique_key IN (
+        'incident-object:' || json_array(candidates.source_type_id, candidates.source_id),
+        'incident-object:' || json_array(candidates.target_type_id, candidates.target_id)
+      )
+    )
+  )
+  ${INSERT_INCIDENT_LINKS}`,
+  members: `WITH ${TOUCHED}, ${TOUCHED_LINKS}, members AS (
+    SELECT candidates.* FROM (
+      SELECT ${LINK_COLUMNS} FROM touched_links WHERE ${EFFECTIVE_TOUCHED_LINK}
+      UNION
+      SELECT ${LINK_COLUMNS} FROM slot_targets
+    ) AS candidates
+    WHERE EXISTS (
+      SELECT 1 FROM ${IDENTITIES} AS changed
+      WHERE changed.version_id = $versionId
+        AND changed.source_key = json_array(candidates.source_type_id, candidates.source_id)
+        AND changed.diff_required = 1
+        AND json_extract(changed.identity_key, '$[2]') = candidates.link_id
+    )
+  )
+  ${INSERT_MEMBER_LINKS}`
+};
+var PURGE_TOUCHES_STATEMENT = `DELETE FROM ontology_commit_touches WHERE rowid IN (
+  SELECT touches.rowid FROM ontology_commit_touches AS touches
+  CROSS JOIN ontology_commits AS commits
+    ON commits.project_id = touches.project_id AND commits.id = touches.commit_id
+  WHERE touches.project_id = $projectId AND commits.rowid <= COALESCE(
+    (SELECT MIN(plans.watermark) FROM ontology_replacement_plans AS plans
+      JOIN ontology_sources AS versions USING (version_id)
+      WHERE plans.project_id = $projectId AND versions.status = 'ready'),
+    (SELECT COALESCE(MAX(rowid), 0) FROM ontology_commits)
+  )
+  LIMIT $limit
+)`;
+
+class SqliteOntologyReplacementPlanStorage {
+  db;
+  runRootOperation;
+  constructor(db, runRootOperation) {
+    this.db = db;
+    this.runRootOperation = runRootOperation;
+  }
+  async open(input) {
+    return this.runRootOperation(() => {
+      const { commit } = input;
+      assertReplacementPlanCommit(commit);
+      const candidate = this.requireCandidate(input);
+      const active = this.db.query(`SELECT materialization_id, last_commit_id FROM ontology_sources
+           WHERE project_id = ? AND source_id = ? AND status = 'active'`).get(input.projectId, input.source.projectionId);
+      const replacedMaterializationId = active?.materialization_id ?? null;
+      const replacedLastCommitId = active?.last_commit_id ?? null;
+      const existing = planRow(this.db, candidate.version_id);
+      if (existing?.replaced_materialization_id === replacedMaterializationId && existing.replaced_last_commit_id === replacedLastCommitId) {
+        return { committedAt: existing.committed_at };
+      }
+      if (existing)
+        deletePlan(this.db, candidate.version_id);
+      this.db.query(`INSERT INTO ontology_replacement_plans (
+             version_id, project_id, commit_id, committed_at, replaced_materialization_id,
+             replaced_last_commit_id, watermark
+           ) VALUES (?, ?, ?, ?, ?, ?, (SELECT COALESCE(MAX(rowid), 0) FROM ontology_commits))`).run(candidate.version_id, input.projectId, commit.id, commit.committedAt, replacedMaterializationId, replacedLastCommitId);
+      const rows = replacementSourceRows(this.db, {
+        projectId: input.projectId,
+        sourceId: input.source.projectionId,
+        materializationId: input.materializationId,
+        incremental: candidate.base_materialization_id !== null
+      });
+      this.db.query(`INSERT INTO ${IDENTITIES} (
+             version_id, entity_kind, identity_key, sort_key, diff_required, expand_at,
+             source_key, target_key
+           )
+           SELECT ?, entity_kind, identity_key, ${SORT_KEY}, 1,
+             CASE entity_kind WHEN 'link' THEN 0 END, source_key, target_key
+           FROM (
+             SELECT entity_kind, CASE entity_kind
+               WHEN 'object' THEN json_array(object_type_id, primary_id)
+               ELSE json_array(
+                 source_type_id, source_primary_id, link_id, target_type_id, target_primary_id
+               )
+             END AS identity_key,
+             CASE entity_kind
+               WHEN 'link' THEN json_array(source_type_id, source_primary_id)
+             END AS source_key,
+             CASE entity_kind
+               WHEN 'link' THEN json_array(target_type_id, target_primary_id)
+             END AS target_key
+             FROM (${rows.sql}) AS rows
+           )
+           GROUP BY entity_kind, identity_key`).run(candidate.version_id, ...rows.values);
+      return { committedAt: commit.committedAt };
+    });
+  }
+  async* streamState(input) {
+    assertPageRows(input.pageRows);
+    await this.runRootOperation(() => {
+      const { candidate } = this.requirePlan(input);
+      if (input.entityKind === "object" && candidate.projection_kind !== "object") {
+        throw new MaterializationConflictError4("source-materialization", "Link projection replacement cannot stream object state.");
+      }
+      if (input.entityKind === "link") {
+        if (unplannedCount(this.db, candidate.version_id, "object") > 0) {
+          throw new MaterializationConflictError4("effective-state", "Object projection replacement must plan every object before its links.");
+        }
+        this.expandLinks(candidate.version_id, input.projectId);
+      }
+    });
+    let after = "";
+    while (true) {
+      const page = await this.runRootOperation(() => {
+        const { candidate } = this.requirePlan(input);
+        const rows = this.db.query(`SELECT identity_key, sort_key, diff_required FROM ${IDENTITIES}
+             WHERE version_id = ? AND entity_kind = ? AND planned_revision IS NULL AND sort_key > ?
+             ORDER BY sort_key
+             LIMIT ?`).all(candidate.version_id, input.entityKind, after, input.pageRows);
+        if (rows.length === 0)
+          return null;
+        after = rows[rows.length - 1].sort_key;
+        const state = this.readPage(input, candidate, rows);
+        this.db.query(`UPDATE ${IDENTITIES} AS identities SET read_revision = ${identityRevision(input.entityKind)}
+             WHERE identities.version_id = $versionId AND identities.entity_kind = $entityKind
+               AND identities.identity_key IN (SELECT value FROM json_each($keys))`).run({
+          $projectId: input.projectId,
+          $versionId: candidate.version_id,
+          $entityKind: input.entityKind,
+          $keys: JSON.stringify(rows.map((row) => row.identity_key))
+        });
+        return state;
+      });
+      if (!page)
+        return;
+      yield page;
+    }
+  }
+  async stage(input) {
+    await this.runRootOperation(() => {
+      const { plan, candidate } = this.requirePlan(input);
+      const identities = prepareReplacementIdentities(input, {
+        commitId: plan.commit_id,
+        committedAt: plan.committed_at
+      });
+      const versionId = candidate.version_id;
+      this.db.run("SAVEPOINT sixb_replacement_plan_stage");
+      let recordKey;
+      try {
+        const known = this.db.query(`SELECT read_revision, planned_revision FROM ${IDENTITIES}
+           WHERE version_id = ? AND entity_kind = ? AND identity_key = ?`);
+        const insert = this.db.query(`INSERT INTO ${SQLITE_PLAN_WORK_TABLE} (
+             work_id, entity_kind, identity_key, record_key, unique_key, kind, lane,
+             major_order, minor_order, sort_one, sort_two,
+             classification_entity_kind, classification_identity_key,
+             cardinality_view, cardinality_occupied, cardinality_source_type_id,
+             cardinality_source_primary_id, cardinality_link_id,
+             cardinality_target_type_id, cardinality_target_primary_id, payload
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, json(?))`);
+        const planned = this.db.query(`UPDATE ${IDENTITIES}
+           SET planned_revision = read_revision, classified = ?, change = ?,
+             expand_at = CASE entity_kind
+               WHEN 'object' THEN (
+                 SELECT expansions FROM ontology_replacement_plans WHERE version_id = ?
+               )
+               ELSE expand_at
+             END
+           WHERE version_id = ? AND entity_kind = ? AND identity_key = ?`);
+        for (const identity of identities) {
+          const row = known.get(versionId, identity.kind, identity.key);
+          if (row?.read_revision == null || row.planned_revision !== null) {
+            throw new MaterializationValidationError2(`Replacement identity ${identity.entityKey} is not streamed and still to plan.`);
+          }
+          for (const record of identity.records) {
+            recordKey = record.recordKey;
+            const columns = materializationWorkColumns(record);
+            const classification = record.kind === "classification" ? record : null;
+            const cardinality = record.kind === "cardinality" ? record : null;
+            insert.run(versionId, identity.kind, identity.key, record.recordKey, workUniquenessKey(record), record.kind, columns.lane, columns.majorOrder, columns.minorOrder, columns.sortOne, columns.sortTwo, classification?.entityKind ?? null, classification?.identityKey ?? null, cardinality?.view ?? null, cardinality ? Number(cardinality.occupied) : null, cardinality?.ref.source.objectTypeId ?? null, cardinality?.ref.source.primaryId ?? null, cardinality?.ref.linkId ?? null, cardinality?.ref.target.objectTypeId ?? null, cardinality?.ref.target.primaryId ?? null, canonicalJson2(record));
+          }
+          planned.run(Number(identity.classified), identity.change, versionId, versionId, identity.kind, identity.key);
+        }
+        this.db.run("RELEASE SAVEPOINT sixb_replacement_plan_stage");
+      } catch (error) {
+        this.db.run("ROLLBACK TO SAVEPOINT sixb_replacement_plan_stage");
+        this.db.run("RELEASE SAVEPOINT sixb_replacement_plan_stage");
+        if (isSqliteConstraintError(error))
+          throw duplicateMaterializationWork(recordKey);
+        throw error;
+      }
+    });
+  }
+  async refresh(input) {
+    return this.runRootOperation(() => {
+      const { plan, candidate } = this.requirePlan(input);
+      const versionId = candidate.version_id;
+      const pending = unplannedCount(this.db, versionId);
+      if (pending > 0)
+        return { fresh: false, unplanned: pending };
+      if (!committedSince(this.db, plan, input.projectId)) {
+        return { fresh: true, counts: replacementPlanCounts(this.db, versionId) };
+      }
+      const params = { $projectId: input.projectId, $versionId: versionId };
+      let unplanned = 0;
+      for (const kind of ["object", "link"]) {
+        const stale = this.db.query(TOUCHED_REFRESH_STATEMENTS[kind]).run(params).changes;
+        if (stale === 0)
+          continue;
+        dropUnplannedWork(this.db, versionId, kind);
+        unplanned += stale;
+      }
+      unplanned += this.expandTouched(versionId, input.projectId);
+      this.db.query(`UPDATE ontology_replacement_plans
+           SET watermark = (SELECT COALESCE(MAX(rowid), 0) FROM ontology_commits)
+           WHERE version_id = ?`).run(versionId);
+      if (unplanned > 0)
+        return { fresh: false, unplanned };
+      return { fresh: true, counts: replacementPlanCounts(this.db, versionId) };
+    });
+  }
+  async purge(input) {
+    return this.runRootOperation(() => {
+      assertNonblank2(input.projectId, "Replacement plan purge project id");
+      assertPositiveInteger2(input.limit, "Replacement plan purge limit");
+      const spentPlan = this.db.query(`SELECT plans.version_id FROM ontology_replacement_plans AS plans
+         JOIN ontology_sources AS versions USING (version_id)
+         WHERE plans.project_id = ? AND versions.status <> 'ready'
+         ORDER BY plans.version_id
+         LIMIT 1`);
+      let deleted = 0;
+      while (deleted < input.limit) {
+        const spent = spentPlan.get(input.projectId);
+        if (!spent)
+          break;
+        for (const [table, column] of [
+          [SQLITE_PLAN_WORK_TABLE, "work_id"],
+          [IDENTITIES, "version_id"]
+        ]) {
+          deleted += this.db.query(`DELETE FROM ${table} WHERE rowid IN (
+                 SELECT rowid FROM ${table} WHERE ${column} = ? LIMIT ?
+               )`).run(spent.version_id, input.limit - deleted).changes;
+          if (deleted >= input.limit)
+            return deleted;
+        }
+        this.db.query(`DELETE FROM ontology_replacement_plans WHERE version_id = ?`).run(spent.version_id);
+        deleted += 1;
+      }
+      if (deleted >= input.limit)
+        return deleted;
+      return deleted + this.db.query(PURGE_TOUCHES_STATEMENT).run({ $projectId: input.projectId, $limit: input.limit - deleted }).changes;
+    });
+  }
+  readPage(input, candidate, rows) {
+    const reader = new SqliteMaterializationStateReader(this.db, input.projectId);
+    if (input.entityKind === "object") {
+      const refs = rows.map((row) => {
+        const [objectTypeId, primaryId] = parseJson2(row.identity_key);
+        return { objectTypeId, primaryId };
+      });
+      return {
+        objects: reader.replacementObjectStates(input.source.projectionId, input.materializationId, refs),
+        links: [],
+        endpoints: []
+      };
+    }
+    const identities = rows.map((row) => {
+      const parts = parseJson2(row.identity_key);
+      const ref = {
+        source: { objectTypeId: parts[0], primaryId: parts[1] },
+        linkId: parts[2],
+        target: { objectTypeId: parts[3], primaryId: parts[4] }
+      };
+      return {
+        ref,
+        sortKey: row.sort_key,
+        diffRequired: row.diff_required === 1
+      };
+    });
+    const previous = this.db.query(`SELECT materialization_id FROM ontology_sources
+         WHERE project_id = ? AND source_id = ? AND status = 'active'`).get(input.projectId, input.source.projectionId);
+    const links = reader.replacementLinkStates(input.source.projectionId, input.materializationId, [input.materializationId, ...previous ? [previous.materialization_id] : []], identities, candidate.base_materialization_id !== null);
+    return {
+      objects: [],
+      links,
+      endpoints: this.endpoints(candidate.version_id, input.projectId, identities.flatMap(({ ref }) => [ref.source, ref.target]))
+    };
+  }
+  endpoints(versionId, projectId, refs) {
+    const unique = [...new Map(refs.map((ref) => [objectRefKey2(ref), ref])).values()];
+    const rows = this.db.query(`SELECT requested.value AS identity_key, (
+           SELECT json_extract(work.payload, '$.exists') FROM ${SQLITE_PLAN_WORK_TABLE} AS work
+           WHERE work.work_id = ? AND work.unique_key = 'object-existence:' || requested.value
+         ) AS planned, EXISTS (
+           SELECT 1 FROM objects
+           WHERE project_id = ? AND object_type_id = json_extract(requested.value, '$[0]')
+             AND primary_id = json_extract(requested.value, '$[1]')
+         ) AS effective
+         FROM json_each(?) AS requested`).all(versionId, projectId, JSON.stringify(unique.map((ref) => objectRefKey2(ref))));
+    const existence = new Map(rows.map((row) => [row.identity_key, (row.planned ?? row.effective) === 1]));
+    return unique.map((ref) => ({ ref, exists: existence.get(objectRefKey2(ref)) ?? false }));
+  }
+  expandLinks(versionId, projectId) {
+    const added = this.expand(versionId, projectId, EXPAND_LINK_STATEMENTS);
+    this.db.query(`UPDATE ontology_replacement_plans SET expansions = expansions + 1 WHERE version_id = ?`).run(versionId);
+    return added;
+  }
+  expandTouched(versionId, projectId) {
+    return this.expand(versionId, projectId, EXPAND_TOUCHED_STATEMENTS);
+  }
+  expand(versionId, projectId, statements) {
+    const run = (statement) => this.db.query(statement).run({ $projectId: projectId, $versionId: versionId }).changes;
+    const diffLinks = run(statements.incident);
+    if (diffLinks > 0)
+      dropUnplannedWork(this.db, versionId, "link");
+    return diffLinks + run(statements.members);
+  }
+  requireCandidate(input) {
+    const candidate = sourceRow(this.db, input.projectId, input.source.projectionId, input.materializationId);
+    if (!candidate || candidate.status !== "ready" || candidate.projection_run_id !== input.execution.projectionRunId || candidate.execution_token !== input.execution.executionToken) {
+      throw new MaterializationConflictError4("source-materialization", `Candidate source materialization '${input.materializationId}' is missing, not ready, or owned by another execution.`);
+    }
+    assertProjectionExecution(this.db, {
+      projectId: input.projectId,
+      sourceId: input.source.projectionId,
+      projectionRunId: input.execution.projectionRunId,
+      executionToken: input.execution.executionToken
+    });
+    return candidate;
+  }
+  requirePlan(input) {
+    const candidate = this.requireCandidate(input);
+    const plan = planRow(this.db, candidate.version_id);
+    if (!plan) {
+      throw new MaterializationConflictError4("source-materialization", `Candidate source materialization '${input.materializationId}' has no open plan.`);
+    }
+    return { plan, candidate };
+  }
+}
+function assertReplacementPlanCoverage(db, plan) {
+  const mismatch = db.query(`SELECT 1 FROM ${IDENTITIES}
+       WHERE version_id = ?
+         AND classified <> (diff_required AND (entity_kind = 'link' OR ? = 1))
+       LIMIT 1`).get(plan.versionId, plan.projectionKind === "object" ? 1 : 0);
+  if (mismatch) {
+    invalidCorrelation("Projection replacement classification coverage does not match its plan.");
+  }
+}
+function replacementPlanCounts(db, versionId) {
+  const rows = db.query(`SELECT entity_kind, COALESCE(change, 'unchanged') AS change, COUNT(*) AS count
+       FROM ${IDENTITIES}
+       WHERE version_id = ? AND classified = 1
+       GROUP BY entity_kind, COALESCE(change, 'unchanged')`).all(versionId);
+  const count = (kind, change) => rows.find((row) => row.entity_kind === kind && row.change === change)?.count ?? 0;
+  return {
+    objectsCreated: count("object", "created"),
+    objectsUpdated: count("object", "updated"),
+    objectsDeleted: count("object", "deleted"),
+    objectsUnchanged: count("object", "unchanged"),
+    linksCreated: count("link", "created"),
+    linksUpdated: count("link", "updated"),
+    linksDeleted: count("link", "deleted"),
+    linksUnchanged: count("link", "unchanged")
+  };
+}
+function unplannedCount(db, versionId, kind) {
+  const row = db.query(`SELECT COUNT(*) AS count FROM ${IDENTITIES}
+       WHERE version_id = ? AND planned_revision IS NULL AND (? IS NULL OR entity_kind = ?)`).get(versionId, kind ?? null, kind ?? null);
+  return row.count;
+}
+function committedSince(db, plan, projectId) {
+  return db.query(`SELECT 1 FROM ontology_commits WHERE rowid > ? AND +project_id = ? LIMIT 1`).get(plan.watermark, projectId) !== null;
+}
+function dropUnplannedWork(db, versionId, kind) {
+  db.query(`DELETE FROM ${SQLITE_PLAN_WORK_TABLE}
+     WHERE work_id = ? AND entity_kind = ? AND identity_key IN (
+       SELECT identity_key FROM ${IDENTITIES}
+       WHERE version_id = ? AND entity_kind = ? AND planned_revision IS NULL
+     )`).run(versionId, kind, versionId, kind);
+}
+function deletePlan(db, versionId) {
+  db.query(`DELETE FROM ${SQLITE_PLAN_WORK_TABLE} WHERE work_id = ?`).run(versionId);
+  db.query(`DELETE FROM ${IDENTITIES} WHERE version_id = ?`).run(versionId);
+  db.query(`DELETE FROM ontology_replacement_plans WHERE version_id = ?`).run(versionId);
+}
+function planRow(db, versionId) {
+  return db.query(`SELECT * FROM ontology_replacement_plans WHERE version_id = ?`).get(versionId);
+}
+function sourceRow(db, projectId, sourceId, materializationId) {
+  return db.query(`SELECT * FROM ontology_sources
+       WHERE project_id = ? AND source_id = ? AND materialization_id = ?`).get(projectId, sourceId, materializationId);
+}
+function boundReplacementPlan(db, header) {
+  const ref = header.plan;
+  const candidate = ref ? sourceRow(db, header.commit.projectId, ref.source.projectionId, ref.materializationId) : null;
+  const plan = candidate ? planRow(db, candidate.version_id) : null;
+  if (!ref || !candidate || !plan || header.commit.intent.kind !== "projection") {
+    throw new MaterializationConflictError4("source-materialization", "A plan-bound session needs the open plan of a projection candidate.");
+  }
+  if (plan.commit_id !== header.commit.id || plan.committed_at !== header.commit.committedAt) {
+    throw new MaterializationValidationError2("A plan-bound session must begin with the commit its plan carries.");
+  }
+  if (committedSince(db, plan, header.commit.projectId) || unplannedCount(db, candidate.version_id) > 0) {
+    throw new MaterializationValidationError2("A replacement plan applies only fully planned and just refreshed.");
+  }
+  return { versionId: candidate.version_id, projectionKind: candidate.projection_kind };
+}
+
 // src/ontology-storage/materialization-session.ts
 class SqliteMaterializationSessionState extends ProviderMaterializationSessionState {
-  appliedPlanCursor = null;
-  appliedEventCursor = null;
+  plan;
   summary = emptyWorkSummary();
+  workTable;
+  workId;
+  constructor(header, transactionId, plan) {
+    super(header, transactionId);
+    this.plan = plan;
+    this.workTable = plan ? SQLITE_PLAN_WORK_TABLE : SQLITE_MATERIALIZATION_WORK_TABLE;
+    this.workId = plan ? plan.versionId : this.id;
+  }
 }
 
 class SqliteMaterializationSessions {
@@ -13727,12 +14602,12 @@ class SqliteMaterializationSessions {
     this.db = db;
     this.context = context;
   }
-  create(header) {
+  create(header, plan) {
     if (!this.context?.active) {
-      throw new MaterializationConflictError4("effective-state", "Materialization sessions require an active storage transaction.");
+      throw new MaterializationConflictError5("effective-state", "Materialization sessions require an active storage transaction.");
     }
     this.ensureTables();
-    const session = new SqliteMaterializationSessionState(structuredClone(header), this.context.id);
+    const session = new SqliteMaterializationSessionState(structuredClone(header), this.context.id, plan);
     this.sessions.set(session.providerToken, session);
     this.live.add(session);
     this.context.materializations.register(session.providerToken);
@@ -13741,7 +14616,7 @@ class SqliteMaterializationSessions {
   require(session) {
     const value = this.sessions.get(session.providerToken);
     if (!value || !value.active || !this.context?.active || value.transactionId !== this.context.id) {
-      throw new MaterializationConflictError4("effective-state", "Materialization session is inactive.");
+      throw new MaterializationConflictError5("effective-state", "Materialization session is inactive.");
     }
     return value;
   }
@@ -13749,11 +14624,10 @@ class SqliteMaterializationSessions {
     if (!session.active)
       return;
     session.active = false;
-    session.replacement = null;
     this.live.delete(session);
     if (this.live.size === 0)
       this.dropWorkTables();
-    else
+    else if (!session.plan)
       this.deleteWork(session.id);
     this.context?.materializations.complete(session.providerToken);
   }
@@ -13768,7 +14642,7 @@ class SqliteMaterializationSessions {
       return;
     const insert = this.db.query(`
         INSERT INTO ${SQLITE_MATERIALIZATION_WORK_TABLE} (
-          session_id, record_key, unique_key, kind, lane,
+          work_id, record_key, unique_key, kind, lane,
           major_order, minor_order, sort_one, sort_two,
           classification_entity_kind, classification_identity_key,
           cardinality_view, cardinality_occupied, cardinality_source_type_id,
@@ -13795,74 +14669,62 @@ class SqliteMaterializationSessions {
       throw error;
     }
     for (const prepared of records)
-      recordSummary(session.summary, prepared.record, prepared.columns);
+      recordSummary(session.summary, prepared.record);
   }
-  async* stream(input) {
-    const session = this.require(input.session);
-    const stream = session.workStreams[input.order];
-    if (stream.started) {
-      throw new MaterializationConflictError4("effective-state", `Materialization ${input.order} work may only be streamed once per session.`);
-    }
-    stream.started = true;
-    session.workSealed = true;
+  *lanePages(session, lane, pageRows) {
     let cursor = null;
     while (true) {
-      this.require(input.session);
-      const rows = this.readLane(input.order, session.id, cursor, input.pageRows);
+      this.require(session.publicSession());
+      const rows = this.readLane(session, lane, cursor, pageRows);
       if (rows.length === 0)
-        break;
-      const records = rows.map((row) => parseJson2(row.payload));
+        return;
       cursor = workCursor(rows[rows.length - 1]);
-      stream.emittedCount += records.length;
-      yield { records };
+      yield rows.map((row) => parseJson2(row.payload));
     }
-    this.require(input.session);
-    stream.completed = true;
   }
-  readObjectExistence(session, refs) {
-    const lookup = this.db.query(`
-        SELECT payload FROM ${SQLITE_MATERIALIZATION_WORK_TABLE}
-        WHERE session_id = ? AND unique_key = ? AND kind = 'object-existence'
+  *vectorChangePages(session, objectTypeIds, pageRows) {
+    if (objectTypeIds.length === 0 && !this.db.query(`SELECT 1 FROM object_vectors WHERE project_id = ? LIMIT 1`).get(session.header.commit.projectId)) {
+      return;
+    }
+    const query = this.db.query(`
+        WITH changes AS (
+          SELECT record_key, payload,
+            coalesce(
+              json_extract(payload, '$.item.value.row.ref.objectTypeId'),
+              json_extract(payload, '$.item.value.ref.objectTypeId')
+            ) AS object_type_id,
+            coalesce(
+              json_extract(payload, '$.item.value.row.ref.primaryId'),
+              json_extract(payload, '$.item.value.ref.primaryId')
+            ) AS primary_id
+          FROM ${session.workTable}
+          WHERE work_id = ? AND lane = 'apply' AND kind = 'plan'
+            AND json_extract(payload, '$.item.kind') IN ('object-upsert', 'object-delete')
+            AND record_key > ?
+        )
+        SELECT record_key, payload FROM changes
+        WHERE object_type_id IN (SELECT value FROM json_each(?))
+          OR EXISTS (
+            SELECT 1 FROM object_vectors
+            WHERE project_id = ? AND object_type_id = changes.object_type_id
+              AND primary_id = changes.primary_id
+          )
+        ORDER BY record_key
+        LIMIT ?
       `);
-    return refs.flatMap((ref) => {
-      const key = `object-existence:${JSON.stringify([ref.objectTypeId, ref.primaryId])}`;
-      const row = lookup.get(session.id, key);
-      if (!row)
-        return [];
-      const record = parseJson2(row.payload);
-      return [{ ref: record.ref, exists: record.exists }];
-    });
-  }
-  prepareChunkSequence(session, chunk) {
-    const items = materializationPlanItems(chunk);
-    const planRows = this.readLane("apply", session.id, session.appliedPlanCursor, items.length);
-    const expectedItems = planRows.map((row) => {
-      const record = parseJson2(row.payload);
-      return record.item;
-    });
-    const eventRows = this.readLane("event", session.id, session.appliedEventCursor, chunk.outbox.length);
-    const expectedEvents = eventRows.map((row) => parseJson2(row.payload));
-    const progress = correlateMaterializationChunk(session, chunk, items, expectedItems, expectedEvents);
-    return {
-      ...progress,
-      appliedPlanCursor: planRows.length === 0 ? session.appliedPlanCursor : workCursor(planRows[planRows.length - 1]),
-      appliedEventCursor: eventRows.length === 0 ? session.appliedEventCursor : workCursor(eventRows[eventRows.length - 1])
-    };
-  }
-  commitChunkSequence(session, progress) {
-    session.appliedPlanCount = progress.appliedPlanCount;
-    session.appliedOutboxCount = progress.appliedOutboxCount;
-    session.appliedPlanCursor = progress.appliedPlanCursor;
-    session.appliedEventCursor = progress.appliedEventCursor;
-  }
-  laneCounts(session) {
-    return {
-      apply: session.summary.apply,
-      cardinality: session.summary.cardinality,
-      event: session.summary.event
-    };
+    let after = "";
+    while (true) {
+      this.require(session.publicSession());
+      const rows = query.all(session.workId, after, JSON.stringify(objectTypeIds), session.header.commit.projectId, pageRows);
+      if (rows.length === 0)
+        return;
+      after = rows[rows.length - 1].record_key;
+      yield rows.map((row) => parseJson2(row.payload).item);
+    }
   }
   projectionCounts(session) {
+    if (session.plan)
+      return replacementPlanCounts(this.db, session.plan.versionId);
     const summary = session.summary;
     return {
       objectsCreated: summary.objectsCreated,
@@ -13888,67 +14750,29 @@ class SqliteMaterializationSessions {
     };
   }
   assertClassificationCoverage(session) {
-    if (!session.replacement)
-      return;
-    const expectedObject = session.replacement.projectionKind === "object" ? 1 : 0;
-    const mismatch = this.db.query(`
-          WITH invalid AS (
-            SELECT 1
-            FROM ${SQLITE_REPLACEMENT_WORK_TABLE} AS expected
-            WHERE expected.session_id = ? AND expected.diff_required = 1
-              AND (expected.entity_kind = 'link' OR ? = 1)
-              AND NOT EXISTS (
-                SELECT 1 FROM ${SQLITE_MATERIALIZATION_WORK_TABLE} AS actual
-                WHERE actual.session_id = expected.session_id
-                  AND actual.unique_key = 'classification:' || expected.entity_kind || ':'
-                    || expected.identity_key
-              )
-            UNION ALL
-            SELECT 1
-            FROM ${SQLITE_MATERIALIZATION_WORK_TABLE} AS actual
-            WHERE actual.session_id = ?
-              -- A bounded range uses the existing (session_id, unique_key) unique index and scans
-              -- classification entries only, instead of sorting the complete JSON work spool.
-              AND actual.unique_key >= 'classification:'
-              AND actual.unique_key < 'classification;'
-              AND (
-                actual.classification_entity_kind = 'point'
-                OR NOT EXISTS (
-                  SELECT 1 FROM ${SQLITE_REPLACEMENT_WORK_TABLE} AS expected
-                  WHERE expected.session_id = actual.session_id
-                    AND expected.entity_kind = actual.classification_entity_kind
-                    AND expected.identity_key = actual.classification_identity_key
-                    AND expected.diff_required = 1
-                    AND (expected.entity_kind = 'link' OR ? = 1)
-                )
-              )
-          )
-          SELECT 1 FROM invalid LIMIT 1
-        `).get(session.id, expectedObject, session.id, expectedObject);
-    if (mismatch) {
-      invalidCorrelation("Projection replacement classification coverage does not match its streamed state.");
-    }
+    if (session.plan)
+      assertReplacementPlanCoverage(this.db, session.plan);
   }
-  readLane(lane, sessionId, cursor, limit) {
+  readLane(session, lane, cursor, limit) {
     if (limit === 0)
       return [];
     const selected = `record_key, major_order, minor_order, sort_one, sort_two, payload`;
     if (!cursor) {
-      return this.db.query(`SELECT ${selected} FROM ${SQLITE_MATERIALIZATION_WORK_TABLE}
-           WHERE session_id = ? AND lane = ?
+      return this.db.query(`SELECT ${selected} FROM ${session.workTable}
+           WHERE work_id = ? AND lane = ?
            ORDER BY major_order, minor_order, sort_one, sort_two, record_key
-           LIMIT ?`).all(sessionId, lane, limit);
+           LIMIT ?`).all(session.workId, lane, limit);
     }
-    return this.db.query(`SELECT ${selected} FROM ${SQLITE_MATERIALIZATION_WORK_TABLE}
-         WHERE session_id = ? AND lane = ?
+    return this.db.query(`SELECT ${selected} FROM ${session.workTable}
+         WHERE work_id = ? AND lane = ?
            AND (major_order, minor_order, sort_one, sort_two, record_key) > (?, ?, ?, ?, ?)
          ORDER BY major_order, minor_order, sort_one, sort_two, record_key
-         LIMIT ?`).all(sessionId, lane, cursor.majorOrder, cursor.minorOrder, cursor.sortOne, cursor.sortTwo, cursor.recordKey, limit);
+         LIMIT ?`).all(session.workId, lane, cursor.majorOrder, cursor.minorOrder, cursor.sortOne, cursor.sortTwo, cursor.recordKey, limit);
   }
   ensureTables() {
     this.db.run(`
       CREATE TEMP TABLE IF NOT EXISTS ${SQLITE_MATERIALIZATION_WORK_TABLE} (
-        session_id TEXT NOT NULL,
+        work_id TEXT NOT NULL,
         record_key TEXT NOT NULL,
         unique_key TEXT NOT NULL,
         kind TEXT NOT NULL,
@@ -13967,35 +14791,21 @@ class SqliteMaterializationSessions {
         cardinality_target_type_id TEXT,
         cardinality_target_primary_id TEXT,
         payload TEXT NOT NULL CHECK (json_valid(payload)),
-        PRIMARY KEY (session_id, record_key),
-        UNIQUE (session_id, unique_key)
+        PRIMARY KEY (work_id, record_key),
+        UNIQUE (work_id, unique_key)
       );
       CREATE INDEX IF NOT EXISTS idx_ontology_materialization_work_lane
         ON ${SQLITE_MATERIALIZATION_WORK_TABLE}(
-          session_id, lane, major_order, minor_order, sort_one, sort_two, record_key
-        );
-      CREATE TEMP TABLE IF NOT EXISTS ${SQLITE_REPLACEMENT_WORK_TABLE} (
-        session_id TEXT NOT NULL,
-        entity_kind TEXT NOT NULL,
-        identity_key TEXT NOT NULL,
-        sort_key TEXT NOT NULL,
-        diff_required INTEGER NOT NULL CHECK (diff_required IN (0, 1)),
-        PRIMARY KEY (session_id, entity_kind, identity_key)
-      );
-      CREATE INDEX IF NOT EXISTS idx_ontology_replacement_work_order
-        ON ${SQLITE_REPLACEMENT_WORK_TABLE}(
-          session_id, entity_kind, sort_key, identity_key
+          work_id, lane, major_order, minor_order, sort_one, sort_two, record_key
         );
     `);
   }
   deleteWork(sessionId) {
-    this.db.query(`DELETE FROM ${SQLITE_MATERIALIZATION_WORK_TABLE} WHERE session_id = ?`).run(sessionId);
-    this.db.query(`DELETE FROM ${SQLITE_REPLACEMENT_WORK_TABLE} WHERE session_id = ?`).run(sessionId);
+    this.db.query(`DELETE FROM ${SQLITE_MATERIALIZATION_WORK_TABLE} WHERE work_id = ?`).run(sessionId);
   }
   dropWorkTables() {
     this.db.run(`
       DROP TABLE IF EXISTS ${SQLITE_MATERIALIZATION_WORK_TABLE};
-      DROP TABLE IF EXISTS ${SQLITE_REPLACEMENT_WORK_TABLE};
     `);
   }
 }
@@ -14010,9 +14820,6 @@ function workCursor(row) {
 }
 function emptyWorkSummary() {
   return {
-    apply: 0,
-    cardinality: 0,
-    event: 0,
     objectClassifications: 0,
     linkClassifications: 0,
     pointClassifications: 0,
@@ -14027,9 +14834,7 @@ function emptyWorkSummary() {
     latestObjectsChanged: 0
   };
 }
-function recordSummary(summary, record, columns) {
-  if (columns.lane !== "none")
-    summary[columns.lane] += 1;
+function recordSummary(summary, record) {
   if (record.kind === "classification") {
     if (record.entityKind === "object")
       summary.objectClassifications += 1;
@@ -14078,11 +14883,13 @@ function recordSummary(summary, record, columns) {
 // src/ontology-storage/materialization-writer.ts
 import {
   linkRefKey as linkRefKey2,
-  MaterializationConflictError as MaterializationConflictError5,
-  objectRefKey as objectRefKey2,
+  MaterializationConflictError as MaterializationConflictError6,
+  objectRefKey as objectRefKey3,
   telemetryPointKey
 } from "@sixb/core/internal/materialization";
-import { effectiveConflict } from "@sixb/core/internal/ontology-storage-provider";
+import {
+  effectiveConflict
+} from "@sixb/core/internal/ontology-storage-provider";
 function linkOverrideConflictMessage(identityKind) {
   return identityKind === "edge" ? "Expected link edge override changed." : "Expected link slot override changed.";
 }
@@ -14178,7 +14985,7 @@ class SqliteMaterializationWriter {
     for (const item of chunk.effective.objectDeletes) {
       requireChanges(this.db.query(`DELETE FROM objects
              WHERE project_id = ? AND object_type_id = ? AND primary_id = ?
-               AND version = ? AND last_commit_id = ?`).run(projectId, item.ref.objectTypeId, item.ref.primaryId, item.expected.version, item.expected.lastCommitId).changes, "effective-state", `Expected object ${objectRefKey2(item.ref)} changed.`);
+               AND version = ? AND last_commit_id = ?`).run(projectId, item.ref.objectTypeId, item.ref.primaryId, item.expected.version, item.expected.lastCommitId).changes, "effective-state", `Expected object ${objectRefKey3(item.ref)} changed.`);
     }
     for (const item of chunk.effective.objectUpserts)
       this.applyObject(projectId, item);
@@ -14197,7 +15004,7 @@ class SqliteMaterializationWriter {
             `).run(projectId, row.ref.objectTypeId, row.ref.primaryId, canonicalJson(row.properties), row.createdAt, row.updatedAt, row.version, row.lastCommitId);
       } catch (error) {
         if (isSqliteConstraintError(error)) {
-          throw effectiveConflict(`Expected object ${objectRefKey2(row.ref)} to be absent.`);
+          throw effectiveConflict(`Expected object ${objectRefKey3(row.ref)} to be absent.`);
         }
         throw error;
       }
@@ -14209,7 +15016,7 @@ class SqliteMaterializationWriter {
               last_commit_id = ?
             WHERE project_id = ? AND object_type_id = ? AND primary_id = ?
               AND version = ? AND last_commit_id = ?
-          `).run(canonicalJson(row.properties), row.createdAt, row.updatedAt, row.version, row.lastCommitId, projectId, row.ref.objectTypeId, row.ref.primaryId, expected.version, expected.lastCommitId).changes, "effective-state", `Expected object ${objectRefKey2(row.ref)} changed.`);
+          `).run(canonicalJson(row.properties), row.createdAt, row.updatedAt, row.version, row.lastCommitId, projectId, row.ref.objectTypeId, row.ref.primaryId, expected.version, expected.lastCommitId).changes, "effective-state", `Expected object ${objectRefKey3(row.ref)} changed.`);
   }
   applyLink(projectId, item) {
     const { row, expected } = item;
@@ -14250,7 +15057,7 @@ class SqliteMaterializationWriter {
               `).run(projectId, point.series.object.objectTypeId, point.series.object.primaryId, point.series.propertyId, canonicalJson(point.value), point.unit ?? null, point.at, point.lastCommitId);
         } catch (error) {
           if (isSqliteConstraintError(error)) {
-            throw new MaterializationConflictError5("timeseries-point", `Telemetry point ${telemetryPointKey(point.series, point.at)} changed.`);
+            throw new MaterializationConflictError6("timeseries-point", `Telemetry point ${telemetryPointKey(point.series, point.at)} changed.`);
           }
           throw error;
         }
@@ -14267,19 +15074,18 @@ class SqliteMaterializationWriter {
   applyOutbox(projectId, commitId, chunk) {
     const insert = this.db.query(`
         INSERT INTO ontology_outbox (
-          project_id, id, commit_id, commit_ordinal, envelope,
+          project_id, id, commit_id, commit_ordinal, event,
           available_at, attempts, lease_id, lease_expires_at,
           published_at, last_failure, created_at
         ) VALUES (?, ?, ?, ?, json(?), ?, 0, NULL, NULL, NULL, NULL, ?)
       `);
     for (const item of chunk.outbox) {
-      assertTimestamp(item.availableAt, "Outbox availableAt");
       assertTimestamp(item.createdAt, "Outbox createdAt");
       try {
-        insert.run(projectId, item.envelope.id, commitId, item.envelope.commitOrdinal, canonicalJson(item.envelope), item.availableAt, item.createdAt);
+        insert.run(projectId, item.id, commitId, item.commitOrdinal, canonicalJson(item.event), item.createdAt, item.createdAt);
       } catch (error) {
         if (isSqliteConstraintError(error)) {
-          throw effectiveConflict(`Duplicate outbox event '${item.envelope.id}'.`);
+          throw effectiveConflict(`Duplicate outbox event '${item.id}'.`);
         }
         throw error;
       }
@@ -14288,6 +15094,48 @@ class SqliteMaterializationWriter {
 }
 
 // src/ontology-storage/materializations.ts
+var APPLY_PAGE_ROWS = 1000;
+function touchAppliedWorkStatement(workTable) {
+  return `
+  INSERT INTO ontology_commit_touches (project_id, commit_id, entity_kind, identity_key)
+  SELECT DISTINCT $projectId, $commitId, kind, CASE kind
+    WHEN 'object' THEN
+      json_array(json_extract(ref, '$.objectTypeId'), json_extract(ref, '$.primaryId'))
+    WHEN 'scope' THEN json_array(
+      json_extract(ref, '$.source.objectTypeId'), json_extract(ref, '$.source.primaryId'),
+      json_extract(ref, '$.linkId')
+    )
+    ELSE json_array(
+      json_extract(ref, '$.source.objectTypeId'), json_extract(ref, '$.source.primaryId'),
+      json_extract(ref, '$.linkId'), json_extract(ref, '$.target.objectTypeId'),
+      json_extract(ref, '$.target.primaryId')
+    )
+  END
+  FROM (
+    SELECT CASE json_extract(payload, '$.item.kind')
+        WHEN 'object-upsert' THEN 'object'
+        WHEN 'object-delete' THEN 'object'
+        WHEN 'object-override-upsert' THEN 'object'
+        WHEN 'object-override-delete' THEN 'object'
+        WHEN 'point-upsert' THEN 'object'
+        WHEN 'link-upsert' THEN 'link'
+        WHEN 'link-delete' THEN 'link'
+        WHEN 'link-override-upsert' THEN 'link'
+        WHEN 'link-override-delete' THEN 'link'
+        WHEN 'link-slot-override-upsert' THEN 'scope'
+        WHEN 'link-slot-override-delete' THEN 'scope'
+      END AS kind,
+      CASE json_extract(payload, '$.item.kind')
+        WHEN 'object-upsert' THEN json_extract(payload, '$.item.value.row.ref')
+        WHEN 'link-upsert' THEN json_extract(payload, '$.item.value.row.ref')
+        WHEN 'point-upsert' THEN json_extract(payload, '$.item.value.point.series.object')
+        ELSE json_extract(payload, '$.item.value.ref')
+      END AS ref
+    FROM ${workTable}
+    WHERE work_id = $workId AND lane = 'apply'
+  )`;
+}
+
 class SqliteOntologyMaterializationStorage {
   db;
   sessions;
@@ -14300,12 +15148,12 @@ class SqliteOntologyMaterializationStorage {
   assertVectorSession(session, projectId, commitId) {
     const active = this.sessions.require(session);
     if (active.header.commit.projectId !== projectId || commitId !== undefined && active.header.commit.id !== commitId) {
-      throw new MaterializationValidationError2("Vector mutation does not belong to this materialization session.");
+      throw new MaterializationValidationError3("Vector mutation does not belong to this materialization session.");
     }
   }
   async begin(input) {
     assertMaterializationHeader(input);
-    const session = this.sessions.create(input);
+    const session = this.sessions.create(input, input.plan ? boundReplacementPlan(this.db, input) : null);
     try {
       this.assertCommitAbsent(input);
       const reader = new SqliteMaterializationStateReader(this.db, input.commit.projectId);
@@ -14324,7 +15172,7 @@ class SqliteOntologyMaterializationStorage {
       for (const expected of input.expected.points) {
         const point = reader.exactPoint(expected.series, expected.at);
         if ((point?.lastCommitId ?? null) !== expected.lastCommitId) {
-          throw new MaterializationConflictError6("timeseries-point", `Telemetry point ${telemetryPointKey2(expected.series, expected.at)} changed.`);
+          throw new MaterializationConflictError7("timeseries-point", `Telemetry point ${telemetryPointKey2(expected.series, expected.at)} changed.`);
         }
       }
       return session.publicSession();
@@ -14335,11 +15183,11 @@ class SqliteOntologyMaterializationStorage {
   }
   async* streamState(input) {
     const session = this.sessions.require(input.session);
-    assertPageRows(input.pageRows);
+    assertPageRows2(input.pageRows);
     const reader = new SqliteMaterializationStateReader(this.db, session.header.commit.projectId);
     for await (const request of input.requests) {
       this.sessions.require(input.session);
-      const objects = uniqueSorted(request.objects, objectRefKey3, objectRefSortKey);
+      const objects = uniqueSorted(request.objects, objectRefKey4, objectRefSortKey);
       for (let offset = 0;offset < objects.length; offset += input.pageRows) {
         const page = reader.objectStates(objects.slice(offset, offset + input.pageRows));
         yield { objects: page, links: [], linkScopes: [], points: [] };
@@ -14375,103 +15223,50 @@ class SqliteOntologyMaterializationStorage {
       }
     }
   }
-  async* streamSourceReplacementState(input) {
-    const session = this.sessions.require(input.session);
-    assertPageRows(input.pageRows);
-    const replacement = this.requireReplacement(session, input);
-    const reader = new SqliteMaterializationStateReader(this.db, session.header.commit.projectId);
-    if (input.entityKind === "object") {
-      if (replacement.projectionKind !== "object") {
-        throw new MaterializationConflictError6("source-materialization", "Link projection replacement cannot stream object state.");
-      }
-      if (replacement.objectStreamStarted) {
-        throw new MaterializationConflictError6("effective-state", "Replacement object state may only be streamed once per session.");
-      }
-      replacement.objectStreamStarted = true;
-      for (const identities of reader.replacementIdentities({
-        sessionId: session.id,
-        sourceId: replacement.sourceId,
-        candidateMaterializationId: replacement.candidateMaterializationId,
-        previousMaterializationId: replacement.previousMaterializationId,
-        incremental: replacement.incremental,
-        kind: "object",
-        pageRows: input.pageRows
-      })) {
-        this.sessions.require(input.session);
-        const refs = identities.map((identity) => {
-          if (identity.kind !== "object") {
-            invalidCorrelation2("Object replacement returned a link identity.");
-          }
-          return identity.ref;
-        });
-        const objects = reader.replacementObjectStates(replacement.sourceId, replacement.candidateMaterializationId, refs);
-        yield { objects, links: [] };
-      }
-      this.sessions.require(input.session);
-      replacement.objectStreamCompleted = true;
-      return;
-    }
-    if (replacement.projectionKind === "object" && !replacement.objectStreamCompleted) {
-      throw new MaterializationConflictError6("effective-state", "Object projection replacement must fully stream object state before link state.");
-    }
-    if (replacement.linkStreamStarted) {
-      throw new MaterializationConflictError6("effective-state", "Replacement link state may only be streamed once per session.");
-    }
-    replacement.linkStreamStarted = true;
-    const materializationIds = [
-      replacement.candidateMaterializationId,
-      ...replacement.previousMaterializationId ? [replacement.previousMaterializationId] : []
-    ];
-    for (const identities of reader.replacementIdentities({
-      sessionId: session.id,
-      sourceId: replacement.sourceId,
-      candidateMaterializationId: replacement.candidateMaterializationId,
-      previousMaterializationId: replacement.previousMaterializationId,
-      incremental: replacement.incremental,
-      kind: "link",
-      pageRows: input.pageRows
-    })) {
-      this.sessions.require(input.session);
-      const linkIdentities = identities.map((identity) => {
-        if (identity.kind !== "link") {
-          invalidCorrelation2("Link replacement returned an object identity.");
-        }
-        return identity;
-      });
-      const links = reader.replacementLinkStates(replacement.sourceId, replacement.candidateMaterializationId, materializationIds, linkIdentities, replacement.incremental);
-      yield { objects: [], links };
-    }
-    this.sessions.require(input.session);
-    replacement.linkStreamCompleted = true;
-  }
   async stageWork(input) {
     this.sessions.stage(input);
     await yieldSqliteEventLoop();
   }
-  streamWork(input) {
-    assertPageRows(input.pageRows);
-    return this.sessions.stream(input);
-  }
-  async readObjectExistence(input) {
+  async* streamVectorChanges(input) {
     const session = this.sessions.require(input.session);
-    return this.sessions.readObjectExistence(session, input.refs);
+    assertPageRows2(input.pageRows);
+    beginMaterializationVectorChanges(session);
+    for (const items of this.sessions.vectorChangePages(session, input.objectTypeIds, input.pageRows)) {
+      yield { items };
+    }
   }
-  async applyChunk(input) {
+  async apply(input) {
     const session = this.sessions.require(input.session);
+    beginMaterializationApply(session);
     const { commit } = session.header;
-    assertPlanChunkCorrelations(input.chunk, commit);
-    const sequence = this.sessions.prepareChunkSequence(session, input.chunk);
-    this.db.run("SAVEPOINT sixb_ontology_apply_chunk");
+    const cardinality = createCardinalityValidator();
+    for (const records of this.sessions.lanePages(session, "cardinality", APPLY_PAGE_ROWS)) {
+      for (const record of records)
+        cardinality.accept(record);
+    }
+    let eventCount = 0;
+    this.db.run("SAVEPOINT sixb_ontology_apply");
     try {
-      this.writer.apply(commit.projectId, commit.id, input.chunk);
-      this.db.run("RELEASE SAVEPOINT sixb_ontology_apply_chunk");
-      this.sessions.commitChunkSequence(session, sequence);
+      for (const records of this.sessions.lanePages(session, "apply", APPLY_PAGE_ROWS)) {
+        for (const phase of splitByPhase(records)) {
+          this.writer.apply(commit.projectId, commit.id, materializationPlanChunk(phase.map((record) => record.item)));
+        }
+        await yieldSqliteEventLoop();
+      }
+      for (const records of this.sessions.lanePages(session, "event", APPLY_PAGE_ROWS)) {
+        const outbox = records.map((record) => materializationOutboxWrite(commit, record.draft, eventCount++));
+        this.writer.apply(commit.projectId, commit.id, materializationPlanChunk([], outbox));
+        await yieldSqliteEventLoop();
+      }
+      this.db.query(touchAppliedWorkStatement(session.workTable)).run({ $projectId: commit.projectId, $commitId: commit.id, $workId: session.workId });
+      this.db.run("RELEASE SAVEPOINT sixb_ontology_apply");
     } catch (error) {
-      this.db.run("ROLLBACK TO SAVEPOINT sixb_ontology_apply_chunk");
-      this.db.run("RELEASE SAVEPOINT sixb_ontology_apply_chunk");
+      this.db.run("ROLLBACK TO SAVEPOINT sixb_ontology_apply");
+      this.db.run("RELEASE SAVEPOINT sixb_ontology_apply");
       throw error;
     }
-    await yieldSqliteEventLoop();
+    session.appliedEventCount = eventCount;
+    return { eventCount };
   }
   async finalize(input) {
     const session = this.sessions.require(input.session);
@@ -14487,41 +15282,6 @@ class SqliteOntologyMaterializationStorage {
   deactivateSessions() {
     this.sessions.deactivateAll();
   }
-  requireReplacement(session, input) {
-    if (session.replacement) {
-      if (session.replacement.sourceId !== input.source.projectionId || session.replacement.candidateMaterializationId !== input.candidateMaterializationId) {
-        throw new MaterializationConflictError6("source-materialization", "Materialization session already owns another replacement union.");
-      }
-      return session.replacement;
-    }
-    const projectId = session.header.commit.projectId;
-    const candidate = this.getSource(projectId, input.source.projectionId, input.candidateMaterializationId);
-    if (!candidate || candidate.status !== "ready" || candidate.execution_token === null) {
-      throw new MaterializationConflictError6("source-materialization", `Candidate source materialization '${input.candidateMaterializationId}' is missing or is not ready.`);
-    }
-    assertProjectionExecution(this.db, {
-      projectId,
-      sourceId: input.source.projectionId,
-      projectionRunId: candidate.projection_run_id,
-      executionToken: candidate.execution_token
-    });
-    const previous = this.getActiveSource(projectId, input.source.projectionId);
-    if (candidate.protocol !== "replacement" || previous && (previous.protocol !== candidate.protocol || previous.projection_kind !== candidate.projection_kind)) {
-      throw new MaterializationConflictError6("source-materialization", "Source replacement kind or protocol does not match its active materialization.");
-    }
-    session.replacement = {
-      sourceId: input.source.projectionId,
-      candidateMaterializationId: input.candidateMaterializationId,
-      previousMaterializationId: previous?.materialization_id ?? null,
-      incremental: candidate.base_materialization_id !== null,
-      projectionKind: candidate.projection_kind,
-      objectStreamStarted: false,
-      objectStreamCompleted: false,
-      linkStreamStarted: false,
-      linkStreamCompleted: false
-    };
-    return session.replacement;
-  }
   assertCommitAbsent(header) {
     const origin = originColumns(header.commit.origin);
     const duplicate = this.db.query(`
@@ -14542,25 +15302,23 @@ class SqliteOntologyMaterializationStorage {
     if (!duplicate)
       return;
     if (duplicate.duplicate === "origin") {
-      throw new MaterializationConflictError6("run-correlation", "Ontology commit origin already has an authoritative commit.");
+      throw new MaterializationConflictError7("run-correlation", "Ontology commit origin already has an authoritative commit.");
     }
-    throw new MaterializationConflictError6("idempotency", duplicate.duplicate === "id" ? `Ontology commit '${header.commit.id}' already exists.` : "Ontology idempotency key already exists.");
+    throw new MaterializationConflictError7("idempotency", duplicate.duplicate === "id" ? `Ontology commit '${header.commit.id}' already exists.` : "Ontology idempotency key already exists.");
   }
   assertSource(expected, projectId) {
     const active = this.getActiveSource(projectId, expected.source.projectionId);
     if ((active?.materialization_id ?? null) !== expected.activeMaterializationId || (active?.last_commit_id ?? null) !== expected.lastCommitId) {
-      throw new MaterializationConflictError6("projection-fence", `Source '${expected.source.projectionId}' changed.`);
+      throw new MaterializationConflictError7("projection-fence", `Source '${expected.source.projectionId}' changed.`);
     }
   }
   async assertFinalization(session, input) {
     const { commit } = session.header;
     const { result } = input.finalization;
     assertMaterializationFinalizationCorrelation(session, input);
-    const laneCounts = this.sessions.laneCounts(session);
-    assertMaterializationLaneCompletion(session, laneCounts);
     this.assertFinalCardinality(session);
     await yieldSqliteEventLoop();
-    const eventCount = laneCounts.event;
+    const eventCount = session.appliedEventCount;
     const outbox = this.db.query(`
           SELECT COUNT(*) AS count, MIN(commit_ordinal) AS minimum, MAX(commit_ordinal) AS maximum
           FROM ontology_outbox WHERE project_id = ? AND commit_id = ?
@@ -14603,8 +15361,8 @@ class SqliteOntologyMaterializationStorage {
                 THEN cardinality_target_type_id END) AS expected_target_type_id,
               MAX(CASE WHEN cardinality_occupied = 1
                 THEN cardinality_target_primary_id END) AS expected_target_id
-            FROM ${SQLITE_MATERIALIZATION_WORK_TABLE}
-            WHERE session_id = ? AND kind = 'cardinality'
+            FROM ${session.workTable}
+            WHERE work_id = ? AND kind = 'cardinality'
               AND cardinality_view = 'effective'
             GROUP BY sort_one, cardinality_source_type_id,
               cardinality_source_primary_id, cardinality_link_id
@@ -14624,16 +15382,11 @@ class SqliteOntologyMaterializationStorage {
             GROUP BY scopes.scope_sort_key, scopes.expected_count,
               scopes.expected_target_type_id, scopes.expected_target_id
           )
-          SELECT CASE WHEN expected_count > 1 THEN 'duplicate' ELSE 'mismatch' END AS reason
+          SELECT 1 AS mismatch
           FROM validated
-          WHERE expected_count > 1
-            OR actual_count <> expected_count
-            OR matching_count <> expected_count
+          WHERE actual_count <> expected_count OR matching_count <> expected_count
           LIMIT 1
-        `).get(session.id, session.header.commit.projectId);
-    if (violation?.reason === "duplicate") {
-      invalidCorrelation2("Materialization cardinality work violates cardinality-one.");
-    }
+        `).get(session.workId, session.header.commit.projectId);
     if (violation) {
       invalidCorrelation2("Materialization cardinality work does not match the final effective link scope.");
     }
@@ -14643,7 +15396,7 @@ class SqliteOntologyMaterializationStorage {
     assertSourceActivationCorrelation(session, activation);
     const candidate = this.getSource(commit.projectId, activation.source.projectionId, activation.materializationId);
     if (!candidate || candidate.status !== "ready" || candidate.execution_token === null) {
-      throw new MaterializationConflictError6("source-materialization", "Source activation candidate is missing or is not ready.");
+      throw new MaterializationConflictError7("source-materialization", "Source activation candidate is missing or is not ready.");
     }
     assertProjectionExecution(this.db, {
       projectId: commit.projectId,
@@ -14655,7 +15408,7 @@ class SqliteOntologyMaterializationStorage {
       invalidCorrelation2("Source activation does not match its ready candidate identity.");
     }
     this.assertSource(activation.expected, commit.projectId);
-    activateSourceRoots(this.db, commit.projectId, candidate, activation);
+    activateSourceRoots(this.db, commit.projectId, commit.id, candidate, activation);
     const previous = this.getActiveSource(commit.projectId, activation.source.projectionId);
     if (previous) {
       assertPinnedDatasetWatermark({
@@ -14688,16 +15441,14 @@ class SqliteOntologyMaterializationStorage {
       this.db.query(`
             INSERT INTO ontology_commits (
               project_id, id, idempotency_key, request_hash, execution_id,
-              origin_kind, origin_run_id, origin_batch_ordinal, origin, requested_by, executor,
+              origin_kind, origin_run_id, origin_batch_ordinal, origin,
               ontology_revision, projection_revision, ownership_hash,
               intent, result, committed_at
-            ) VALUES (
-              ?, ?, ?, ?, ?, ?, ?, ?, json(?), json(?), json(?), ?, ?, ?, json(?), json(?), ?
-            )
-          `).run(commit.projectId, commit.id, commit.idempotencyKey, commit.requestHash, commit.executionId, origin.kind, origin.runId, origin.batchOrdinal, canonicalJson(commit.origin), commit.requestedBy === undefined ? null : canonicalJson(commit.requestedBy), canonicalJson(commit.executor), commit.ontologyRevision, commit.projectionRevision ?? null, commit.ownershipHash ?? null, canonicalJson(commit.intent), canonicalJson(input.finalization.result), commit.committedAt);
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, json(?), ?, ?, ?, json(?), json(?), ?)
+          `).run(commit.projectId, commit.id, commit.idempotencyKey, commit.requestHash, commit.executionId, origin.kind, origin.runId, origin.batchOrdinal, canonicalJson(commit.origin), commit.ontologyRevision, commit.projectionRevision ?? null, commit.ownershipHash ?? null, canonicalJson(commit.intent), canonicalJson(input.finalization.result), commit.committedAt);
     } catch (error) {
       if (isSqliteConstraintError(error)) {
-        throw new MaterializationConflictError6("idempotency", "Ontology commit identity already exists.");
+        throw new MaterializationConflictError7("idempotency", "Ontology commit identity already exists.");
       }
       throw error;
     }
@@ -14713,13 +15464,27 @@ class SqliteOntologyMaterializationStorage {
          WHERE project_id = ? AND source_id = ? AND materialization_id = ?`).get(projectId, sourceId, materializationId);
   }
 }
+function splitByPhase(records) {
+  const phases = [];
+  for (const record of records) {
+    const current = phases[phases.length - 1];
+    if (current && current[0].applyPhase === record.applyPhase)
+      current.push(record);
+    else
+      phases.push([record]);
+  }
+  return phases;
+}
 
 // src/ontology-storage/outbox.ts
 import { serializeSixbFailure as serializeSixbFailure2 } from "@sixb/core/internal/errors";
 import {
-  MaterializationConflictError as MaterializationConflictError7,
-  MaterializationValidationError as MaterializationValidationError3
+  MaterializationConflictError as MaterializationConflictError8,
+  MaterializationValidationError as MaterializationValidationError4
 } from "@sixb/core/internal/materialization";
+import {
+  claimedOutboxRows
+} from "@sixb/core/internal/ontology-storage-provider";
 import { ONTOLOGY_OUTBOX_FAILURE_CODES as ONTOLOGY_OUTBOX_FAILURE_CODES2 } from "@sixb/core/storage";
 class SqliteOntologyOutboxStorage {
   db;
@@ -14736,7 +15501,7 @@ class SqliteOntologyOutboxStorage {
       const leaseExpiry = assertTimestamp(input.leaseExpiresAt, "Ontology outbox lease expiry");
       assertNonblank(input.leaseId, "Ontology outbox lease id");
       if (leaseExpiry <= now) {
-        throw new MaterializationValidationError3("Ontology outbox lease expiry must be later than the claim time.");
+        throw new MaterializationValidationError4("Ontology outbox lease expiry must be later than the claim time.");
       }
       const eligible = this.db.query(`SELECT CAST(rowid AS TEXT) AS rowId
            FROM ontology_outbox INDEXED BY idx_ontology_outbox_claim
@@ -14755,15 +15520,19 @@ class SqliteOntologyOutboxStorage {
             UPDATE ontology_outbox
             SET attempts = attempts + 1, lease_id = ?, lease_expires_at = ?
             WHERE rowid IN (SELECT CAST(value AS INTEGER) FROM json_each(?))
-            RETURNING envelope, available_at, attempts, lease_id, lease_expires_at,
-              published_at, last_failure, created_at
+            RETURNING id, commit_id, commit_ordinal, event, available_at, attempts, lease_id,
+              lease_expires_at, published_at, last_failure, created_at
           `).all(input.leaseId, input.leaseExpiresAt, JSON.stringify(selected.map((row) => row.rowId)));
-      return rows.map((row) => outboxRecord(row)).sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.envelope.id.localeCompare(right.envelope.id)).map((record) => {
-        if (record.leaseId === null || record.leaseExpiresAt === null) {
-          throw new MaterializationConflictError7("outbox-lease", "Ontology outbox claim returned an unpaired lease.");
-        }
-        return { ...record, leaseId: record.leaseId, leaseExpiresAt: record.leaseExpiresAt };
-      });
+      const contexts = this.db.query(`SELECT commits.id AS commit_id, commits.committed_at AS commit_committed_at,
+             commits.origin AS commit_origin, executions.*
+           FROM json_each(?) AS requested
+           CROSS JOIN ontology_commits AS commits
+             ON commits.project_id = ? AND commits.id = requested.value
+           CROSS JOIN executions
+             ON executions.project_id = commits.project_id AND executions.id = commits.execution_id`).all(JSON.stringify([...new Set(rows.map((row) => row.commit_id))]), input.projectId);
+      const contextOf = new Map(contexts.map((row) => [row.commit_id, outboxEventContext(input.projectId, row)]));
+      const drafts = rows.map(claimedOutboxDraft).sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id));
+      return claimedOutboxRows(drafts, (commitId) => contextOf.get(commitId));
     });
   }
   async markPublished(input) {
@@ -14856,12 +15625,23 @@ class SqliteOntologyOutboxStorage {
     });
   }
 }
+function outboxEventContext(projectId, row) {
+  return {
+    commit: {
+      projectId,
+      id: row.commit_id,
+      committedAt: row.commit_committed_at,
+      origin: parseJson2(row.commit_origin)
+    },
+    execution: sqliteExecutionRecord(row)
+  };
+}
 function validateLeaseIds(ids) {
   const seen = new Set;
   for (const id of ids) {
     assertNonblank(id, "Ontology outbox event id");
     if (seen.has(id)) {
-      throw new MaterializationValidationError3(`Ontology outbox lease batch repeats event '${id}'.`);
+      throw new MaterializationValidationError4(`Ontology outbox lease batch repeats event '${id}'.`);
     }
     seen.add(id);
   }
@@ -14872,11 +15652,11 @@ function assertLeaseInput(input) {
   assertNonblank(input.leaseId, "Ontology outbox lease id");
 }
 function leaseConflict() {
-  return new MaterializationConflictError7("outbox-lease", "Ontology outbox lease does not match.");
+  return new MaterializationConflictError8("outbox-lease", "Ontology outbox lease does not match.");
 }
 
 // src/ontology-storage/sources.ts
-import { MaterializationValidationError as MaterializationValidationError4 } from "@sixb/core/internal/materialization";
+import { MaterializationValidationError as MaterializationValidationError5 } from "@sixb/core/internal/materialization";
 import {
   assertSourceBeginInput as assertBeginInput,
   assertSourceExecutionIdentity as assertExecutionIdentity,
@@ -14894,13 +15674,16 @@ import {
 } from "@sixb/core/internal/ontology-storage-provider";
 
 // src/ontology-storage/source-cleanup.ts
+var PLAN_PURGED = `NOT EXISTS (
+  SELECT 1 FROM ontology_replacement_plans AS plans WHERE plans.version_id = versions.version_id
+)`;
 function purgeAbandonedSourceVersions(db, input) {
   let remaining = input.limit;
   let rowsDeleted = 0;
   let materializationsDeleted = 0;
   const nextCandidate = db.query(`
-    SELECT version_id FROM ontology_sources
-    WHERE project_id = ? AND status = 'abandoned'
+    SELECT version_id FROM ontology_sources AS versions
+    WHERE project_id = ? AND status = 'abandoned' AND ${PLAN_PURGED}
     ORDER BY terminal_at, source_id, materialization_id LIMIT 1
   `);
   const deleteRows = db.query(`DELETE FROM ontology_source_rows WHERE rowid IN (
@@ -14951,15 +15734,20 @@ function cleanupSourceVersions(db, input) {
       WHERE ${retired}
         AND NOT EXISTS (SELECT 1 FROM ontology_source_rows AS rows WHERE rows.root_id = roots.id)
       ORDER BY roots.retired_at, roots.id LIMIT ?
-    )`).run(input.projectId, input.terminalBefore, remaining).changes;
-    rowsDeleted += removed;
-    remaining -= removed;
+    ) RETURNING version_id`).all(input.projectId, input.terminalBefore, remaining);
+    const counts = new Map;
+    for (const root of removed)
+      counts.set(root.version_id, (counts.get(root.version_id) ?? 0) + 1);
+    const drain = db.query("UPDATE ontology_sources SET root_count = root_count - ? WHERE version_id = ?");
+    for (const [versionId, count] of counts)
+      drain.run(count, versionId);
+    rowsDeleted += removed.length;
+    remaining -= removed.length;
   }
   const materializationsDeleted = remaining === 0 ? 0 : db.query(`DELETE FROM ontology_sources WHERE version_id IN (
     SELECT versions.version_id FROM ontology_sources AS versions
-    WHERE project_id = ? AND status = 'superseded' AND terminal_at < ?
-      AND NOT EXISTS (SELECT 1 FROM ontology_source_roots AS roots
-        WHERE roots.version_id = versions.version_id)
+    WHERE project_id = ? AND status = 'superseded' AND root_count = 0 AND terminal_at < ?
+      AND ${PLAN_PURGED}
     ORDER BY terminal_at, source_id, materialization_id LIMIT ?
   )`).run(input.projectId, input.terminalBefore, remaining).changes;
   return { rowsDeleted, materializationsDeleted };
@@ -15045,7 +15833,7 @@ class SqliteOntologySourceStorage {
         throw sourceConflict(`Source materialization '${input.materializationId}' cannot transition from '${manifest.status}' to 'ready'.`);
       }
       if (input.readyAt < manifest.created_at) {
-        throw new MaterializationValidationError4("Source readyAt cannot precede source createdAt.");
+        throw new MaterializationValidationError5("Source readyAt cannot precede source createdAt.");
       }
       this.assertReadyState(manifest, input.rootCount, input.assertionCount);
       const result = this.db.query(`
@@ -15121,20 +15909,6 @@ class SqliteOntologySourceStorage {
       return purgeAbandonedSourceVersions(this.db, input);
     });
   }
-  async summarizeTerminal(input) {
-    return this.runRootOperation(() => {
-      assertNonblank(input.projectId, "Terminal source summary project id");
-      const summary = this.db.query(`
-            SELECT COUNT(*) AS terminal_count, MIN(terminal_at) AS oldest_terminal_at
-            FROM ontology_sources
-            WHERE project_id = ? AND status IN ('superseded', 'abandoned')
-          `).get(input.projectId);
-      return {
-        count: summary.terminal_count,
-        oldestTerminalAt: summary.oldest_terminal_at
-      };
-    });
-  }
   abandonCandidate(input) {
     const manifest = this.requireManifest(input.projectId, input.source.projectionId, input.materializationId);
     if (manifest.status === "abandoned") {
@@ -15163,7 +15937,7 @@ class SqliteOntologySourceStorage {
   }
   transitionToAbandoned(manifest, abandonedAt) {
     if (abandonedAt < manifest.created_at || manifest.ready_at !== null && abandonedAt < manifest.ready_at) {
-      throw new MaterializationValidationError4("Source abandonedAt cannot precede source creation or readiness.");
+      throw new MaterializationValidationError5("Source abandonedAt cannot precede source creation or readiness.");
     }
     const changed = this.db.query(`
           UPDATE ontology_sources
@@ -15187,7 +15961,7 @@ class SqliteOntologySourceStorage {
           WHERE version_id = ?1
         `).get(manifest.version_id);
     if (counts.assertions !== assertionCount || counts.roots !== rootCount || counts.ordinals !== rootCount || rootCount > 0 && (counts.min_ordinal !== 0 || counts.max_ordinal !== rootCount - 1)) {
-      throw new MaterializationValidationError4("Source ready counts do not match the staged roots and assertions.");
+      throw new MaterializationValidationError5("Source ready counts do not match the staged roots and assertions.");
     }
     assertSourceRootCoverage(this.db, manifest);
     const invalid = this.db.query(manifest.projection_kind === "link" ? `
@@ -15230,7 +16004,7 @@ class SqliteOntologySourceStorage {
               LIMIT 1
             `).get(manifest.version_id);
     if (invalid) {
-      throw new MaterializationValidationError4(manifest.projection_kind === "link" ? "Link projection roots must contain exactly their matching link assertion." : "Object projection roots must contain exactly their matching object assertion plus links sourced from that root.");
+      throw new MaterializationValidationError5(manifest.projection_kind === "link" ? "Link projection roots must contain exactly their matching link assertion." : "Object projection roots must contain exactly their matching object assertion plus links sourced from that root.");
     }
   }
   findStageRows(manifest, rows) {
@@ -15414,7 +16188,7 @@ function decode(row) {
 }
 
 // src/ontology-storage/vectors.ts
-import { MaterializationConflictError as MaterializationConflictError8 } from "@sixb/core/internal/materialization";
+import { MaterializationConflictError as MaterializationConflictError9 } from "@sixb/core/internal/materialization";
 class SqliteOntologyVectorStorage {
   db;
   runRootOperation;
@@ -15520,7 +16294,7 @@ class SqliteOntologyVectorStorage {
   }
 }
 function vectorConflict() {
-  return new MaterializationConflictError8("effective-state", "Vector changed since it was prepared.");
+  return new MaterializationConflictError9("effective-state", "Vector changed since it was prepared.");
 }
 
 // src/ontology-storage/index.ts
@@ -15528,6 +16302,7 @@ class SqliteOntologyStorage {
   commits;
   sources;
   materializations;
+  replacementPlans;
   vectorIndexing;
   vectors;
   outbox;
@@ -15535,6 +16310,7 @@ class SqliteOntologyStorage {
     this.commits = new SqliteOntologyCommitStorage(input.db, input.runRootOperation);
     this.sources = new SqliteOntologySourceStorage(input.db, input.runRootOperation);
     this.materializations = new SqliteOntologyMaterializationStorage(input.db, input.transactionContext);
+    this.replacementPlans = new SqliteOntologyReplacementPlanStorage(input.db, input.runRootOperation);
     this.vectorIndexing = new SqliteVectorIndexingStorage(input.db, input.runRootOperation, (session, projectId) => this.materializations.assertVectorSession(session, projectId));
     this.vectors = new SqliteOntologyVectorStorage(input.db, input.runRootOperation, (session, projectId, commitId) => this.materializations.assertVectorSession(session, projectId, commitId));
     this.outbox = new SqliteOntologyOutboxStorage(input.db, input.runRootOperation);
@@ -16137,7 +16913,7 @@ class SqliteProjectionRunStorage {
   }
   async list(input) {
     assertProjectionRunNonEmpty(input.projectId, "projectId");
-    if (input.statuses && input.statuses.length === 0) {
+    if (input.statuses?.length === 0 || input.errorCodes?.length === 0) {
       return { runs: [], hasMore: false, total: 0 };
     }
     const whereClauses = ["project_id = ?"];
@@ -16170,6 +16946,10 @@ class SqliteProjectionRunStorage {
       whereClauses.push(`status IN (${input.statuses.map(() => "?").join(", ")})`);
       args.push(...input.statuses);
     }
+    if (input.errorCodes) {
+      whereClauses.push(`json_extract(error, '$.code') IN (${input.errorCodes.map(() => "?").join(", ")})`);
+      args.push(...input.errorCodes);
+    }
     if (input.startedAfter) {
       whereClauses.push("COALESCE(started_at, queued_at) >= ?");
       args.push(input.startedAfter.toISOString());
@@ -16479,17 +17259,16 @@ class SqliteRulesStorage {
   }
   async listReconciliationPage(input) {
     assertPositiveLimit(input.limit);
+    const { after } = input;
+    const cursor = after ? [after.ruleId, after.objectTypeId, after.primaryId] : [];
     const rows = this.db.query(`
           SELECT project_id, rule_id, subject_kind, object_type_id, primary_id, triggered_at
           FROM rule_states
-          WHERE project_id = ? AND subject_kind = 'object'
-            AND (
-              ? IS NULL OR
-              (rule_id, object_type_id, primary_id) > (?, ?, ?)
-            )
-          ORDER BY rule_id ASC, object_type_id ASC, primary_id ASC
+          WHERE project_id = ?
+            ${cursor.length > 0 ? "AND (rule_id, subject_kind, object_type_id, primary_id) > (?, 'object', ?, ?)" : ""}
+          ORDER BY rule_id ASC, subject_kind ASC, object_type_id ASC, primary_id ASC
           LIMIT ?
-        `).all(input.projectId, input.after?.ruleId ?? null, input.after?.ruleId ?? null, input.after?.objectTypeId ?? null, input.after?.primaryId ?? null, input.limit + 1);
+        `).all(input.projectId, ...cursor, input.limit + 1);
     return reconciliationPage(rows, input.limit);
   }
   async applyTriggered(event) {
@@ -17080,10 +17859,8 @@ function isUniqueConstraintError4(error) {
 
 // src/testing.ts
 var adapters = new WeakMap;
-function registerSqliteStorageTestingAdapter(storage, advanceConnectorConnectionTime) {
-  adapters.set(storage, {
-    advanceConnectorConnectionTime
-  });
+function registerSqliteStorageTestingAdapter(storage, adapter) {
+  adapters.set(storage, adapter);
 }
 
 // src/timeseries-storage.ts
@@ -18239,6 +19016,7 @@ class SqliteStorage {
   shareSessions;
   connectorConnections;
   fileUploadSessions;
+  fileDownloadGrants;
   migrators;
   connection;
   readConnection;
@@ -18290,8 +19068,12 @@ class SqliteStorage {
     this.shareSessions = createOperationScopedFacade(stores.shareSessions, scope);
     this.connectorConnections = createOperationScopedFacade(stores.connectorConnections, scope);
     this.fileUploadSessions = createOperationScopedFacade(stores.fileUploadSessions, scope);
+    this.fileDownloadGrants = createOperationScopedFacade(stores.fileDownloadGrants, scope);
     this.migrators = options.path ? createSqliteStorageMigrators(options.path) : [];
-    registerSqliteStorageTestingAdapter(this, (durationMs) => stores.connectorConnections.advanceTimeForTesting(durationMs));
+    registerSqliteStorageTestingAdapter(this, {
+      advanceConnectorConnectionTime: (durationMs) => stores.connectorConnections.advanceTimeForTesting(durationMs),
+      db: this.connection.db
+    });
   }
   async ping() {
     this.assertRootOperationAvailable();
@@ -18415,7 +19197,8 @@ function createSqliteStores(connection, options) {
     shareGrants,
     shareSessions,
     connectorConnections: new SqliteConnectorConnectionStorage(connection),
-    fileUploadSessions: new SqliteFileUploadSessionStorage(connection)
+    fileUploadSessions: new SqliteFileUploadSessionStorage(connection),
+    fileDownloadGrants: new SqliteFileDownloadGrantStorage(connection)
   };
 }
 export {
@@ -18423,4 +19206,4 @@ export {
   migrateSqliteStorage
 };
 
-//# debugId=A2CEAFAB428734DF64756E2164756E21
+//# debugId=0E043C316BC5C57264756E2164756E21