@sixb/sqlite 0.1.8 → 0.1.10

package/dist/index.js

@@ -2,6 +2,10 @@
 // src/index.ts
 import { AsyncLocalStorage } from "async_hooks";
 import { ProviderMaterializationTransactionLifecycle } from "@sixb/core/internal/ontology-storage-provider";
+import {
+  createTransactionStorageProxy,
+  throwNestedStorageTransaction
+} from "@sixb/core/internal/storage";
 import {
   createAgentOperationScope,
   createAuthOperationScope,
@@ -12,9 +16,7 @@ import {
   createWorkflowRunOperationScope
 } from "@sixb/core/internal/storage-operation-scope";
 import {
-  createTransactionStorageProxy,
-  StorageTransactionError,
-  throwNestedStorageTransaction
+  StorageTransactionError
 } from "@sixb/core/storage";
 
 // src/action-run-storage.ts
@@ -24,12 +26,11 @@ import {
 } from "@sixb/core/internal/action-run-storage";
 import { assertActionRunExecution } from "@sixb/core/internal/action-run-storage-provider";
 import {
-  ActionRunError,
   actionRunPhaseRecordsEqual,
   canRequeueActionRunAfterEnqueueFailure,
-  finishActionRunPhase,
-  isTerminalActionRun
-} from "@sixb/core/storage";
+  finishActionRunPhase
+} from "@sixb/core/internal/storage";
+import { ActionRunError, isTerminalActionRun } from "@sixb/core/storage";
 
 // src/migrations.ts
 import { Database } from "bun:sqlite";
@@ -3931,6 +3932,135 @@ DROP TABLE executions;
 ALTER TABLE executions_v2 RENAME TO executions;
 `;
 
+// src/migrations/038-projection-source-roots.sql
+var _038_projection_source_roots_default = `ALTER TABLE ontology_sources ADD COLUMN base_materialization_id TEXT;
+ALTER TABLE ontology_sources ADD COLUMN base_commit_id TEXT
+  CHECK ((base_materialization_id IS NULL) = (base_commit_id IS NULL));
+
+CREATE TABLE ontology_source_roots (
+  project_id TEXT NOT NULL,
+  source_id TEXT NOT NULL,
+  materialization_id TEXT NOT NULL,
+  root_sort_key TEXT NOT NULL,
+  root_kind TEXT NOT NULL CHECK (root_kind IN ('object', 'link')),
+  root_key TEXT NOT NULL CHECK (json_valid(root_key)),
+  root TEXT NOT NULL CHECK (json_valid(root)),
+  staging_ordinal INTEGER NOT NULL CHECK (staging_ordinal >= 0),
+  deleted INTEGER NOT NULL DEFAULT 0 CHECK (deleted IN (0, 1)),
+  active INTEGER NOT NULL DEFAULT 0 CHECK (active IN (0, 1)),
+  retired_at TEXT,
+  PRIMARY KEY (project_id, source_id, materialization_id, root_sort_key),
+  UNIQUE (project_id, source_id, materialization_id, staging_ordinal),
+  FOREIGN KEY (project_id, source_id, materialization_id)
+    REFERENCES ontology_sources(project_id, source_id, materialization_id) ON DELETE RESTRICT,
+  CHECK (active = 0 OR (deleted = 0 AND retired_at IS NULL))
+);
+CREATE UNIQUE INDEX idx_ontology_source_roots_active
+  ON ontology_source_roots (project_id, source_id, root_sort_key) WHERE active = 1;
+CREATE INDEX idx_ontology_source_roots_lookup
+  ON ontology_source_roots (project_id, root_sort_key, source_id) WHERE active = 1;
+CREATE INDEX idx_ontology_source_roots_cleanup
+  ON ontology_source_roots (project_id, retired_at, source_id, materialization_id, root_sort_key)
+  WHERE active = 0 AND retired_at IS NOT NULL;
+
+INSERT INTO ontology_source_roots (
+  project_id, source_id, materialization_id, root_sort_key, root_kind, root_key, root,
+  staging_ordinal, active, retired_at
+)
+SELECT DISTINCT rows.project_id, rows.source_id, rows.materialization_id,
+  rows.root_sort_key, rows.root_kind, rows.root_key, rows.root, rows.staging_ordinal,
+  sources.status = 'active', sources.terminal_at
+FROM ontology_source_rows AS rows
+JOIN ontology_sources AS sources USING (project_id, source_id, materialization_id);
+
+ANALYZE ontology_source_roots;
+
+ALTER TABLE projection_runs ADD COLUMN source_changes_read INTEGER
+  CHECK (source_changes_read IS NULL OR source_changes_read >= 0);
+`;
+
+// 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 '[]';
+
+-- Preserve each admitted snapshot, including an intentionally empty one. Executions without
+-- their own historical snapshot inherit from their parent; historical roots remain unknown/empty.
+WITH RECURSIVE attribution(project_id, id, groups) AS (
+  SELECT e.project_id, e.id, COALESCE(w.requester_group_ids, a.requester_group_ids, '[]')
+  FROM executions e
+  LEFT JOIN workflow_runs w ON w.project_id = e.project_id AND w.execution_id = e.id
+  LEFT JOIN agent_runs a ON a.project_id = e.project_id AND a.execution_id = e.id
+  WHERE e.parent_execution_id IS NULL
+  UNION ALL
+  SELECT e.project_id, e.id, COALESCE(w.requester_group_ids, a.requester_group_ids, p.groups)
+  FROM executions e
+  JOIN attribution p ON p.project_id = e.project_id AND p.id = e.parent_execution_id
+  LEFT JOIN workflow_runs w ON w.project_id = e.project_id AND w.execution_id = e.id
+  LEFT JOIN agent_runs a ON a.project_id = e.project_id AND a.execution_id = e.id
+)
+UPDATE executions SET requester_group_ids = (
+  SELECT groups FROM attribution
+  WHERE attribution.project_id = executions.project_id AND attribution.id = executions.id
+);
+
+ALTER TABLE workflow_runs DROP COLUMN requester_group_ids;
+ALTER TABLE agent_runs DROP COLUMN requester_group_ids;
+`;
+
+// src/migrations/039-connector-optional-pkce.sql
+var _039_connector_optional_pkce_default = `-- Rebuild to remove NOT NULL while preserving existing attempts and their constraints.
+CREATE TABLE connector_authorization_attempts_optional_pkce (
+  project_id TEXT NOT NULL,
+  connector_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  slot TEXT NOT NULL,
+  initiated_by_execution_id TEXT NOT NULL,
+  state_hash TEXT NOT NULL,
+  code_verifier TEXT CHECK (
+    code_verifier IS NULL
+    OR (json_valid(code_verifier) AND json_type(code_verifier) = 'object')
+  ),
+  redirect_uri TEXT NOT NULL,
+  connection_run_id TEXT,
+  return_to TEXT,
+  callback_binding_hash TEXT,
+  reauthorization_id TEXT,
+  reauthorization_revision INTEGER CHECK (
+    reauthorization_revision IS NULL OR reauthorization_revision >= 0
+  ),
+  reauthorization_connection_ids TEXT CHECK (
+    reauthorization_connection_ids IS NULL
+    OR (json_valid(reauthorization_connection_ids) AND json_type(reauthorization_connection_ids) = 'array')
+  ),
+  created_at TEXT NOT NULL,
+  expires_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, connector_id, id),
+  UNIQUE (project_id, id),
+  UNIQUE (project_id, connector_id, connection_run_id),
+  FOREIGN KEY (project_id, connector_id, connection_run_id)
+    REFERENCES connector_connection_runs (project_id, connector_id, id)
+    ON DELETE RESTRICT,
+  CHECK (
+    (connection_run_id IS NULL AND return_to IS NULL AND callback_binding_hash IS NULL)
+    OR
+    (connection_run_id IS NOT NULL AND return_to IS NOT NULL AND callback_binding_hash IS NOT NULL)
+  ),
+  CHECK (
+    (reauthorization_id IS NULL AND reauthorization_revision IS NULL AND reauthorization_connection_ids IS NULL)
+    OR
+    (reauthorization_id IS NOT NULL AND reauthorization_revision IS NOT NULL AND reauthorization_connection_ids IS NOT NULL)
+  )
+);
+
+INSERT INTO connector_authorization_attempts_optional_pkce
+SELECT * FROM connector_authorization_attempts;
+
+DROP TABLE connector_authorization_attempts;
+ALTER TABLE connector_authorization_attempts_optional_pkce RENAME TO connector_authorization_attempts;
+
+CREATE INDEX idx_connector_attempts_expiry
+  ON connector_authorization_attempts (project_id, connector_id, expires_at);
+`;
+
 // src/migrations.ts
 var MIGRATIONS_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS sixb_migrations (
@@ -4001,7 +4131,10 @@ var sqliteStorageMigrations = defineMigrations({
     sqliteSql("033-retire-agent-definitions", _033_retire_agent_definitions_default),
     sqliteSql("034-device-authorizations", _034_device_authorizations_default),
     sqliteSql("035-share-grants", _035_share_grants_default),
-    sqliteSql("036-share-sessions", _036_share_sessions_default)
+    sqliteSql("036-share-sessions", _036_share_sessions_default),
+    sqliteSql("037-execution-requester-groups", _037_execution_requester_groups_default),
+    sqliteSql("038-projection-source-roots", _038_projection_source_roots_default),
+    sqliteSql("039-connector-optional-pkce", _039_connector_optional_pkce_default)
   ]
 });
 function sqliteStoragePath(basePath) {
@@ -4710,7 +4843,6 @@ function rowToRunRecord(row) {
     id: row.id,
     projectId: row.project_id,
     executionId: row.execution_id,
-    requesterGroupIds: JSON.parse(row.requester_group_ids),
     status: row.status,
     modelId: row.model_id ?? undefined,
     finishReason: coerceAgentRunFinishReason(row.finish_reason),
@@ -5056,7 +5188,6 @@ import {
   assertSubagentRunResult,
   subagentRunMatchesCreateInput
 } from "@sixb/core/internal/agent-run-storage-provider";
-import { normalizeRequesterGroupIds } from "@sixb/core/internal/auth";
 import { serializeSixbFailure } from "@sixb/core/internal/errors";
 import {
   AGENT_RUN_FAILURE_CODES as AGENT_RUN_FAILURE_CODES2,
@@ -5151,12 +5282,11 @@ class SqliteAgentRunStore {
               thread_id,
               trigger_message_id,
               spec,
-              requester_group_ids,
               status,
               attempt,
               created_at
-            ) VALUES (?, ?, ?, 'conversation', ?, ?, ?, ?, 'queued', 0, ?)
-          `).run(input.projectId, input.id, input.executionId, input.threadId, input.triggerMessageId, JSON.stringify(input.spec), JSON.stringify(normalizeRequesterGroupIds(input.requesterGroupIds)), createdAt.toISOString());
+            ) VALUES (?, ?, ?, 'conversation', ?, ?, ?, 'queued', 0, ?)
+          `).run(input.projectId, input.id, input.executionId, input.threadId, input.triggerMessageId, JSON.stringify(input.spec), createdAt.toISOString());
       } catch (error) {
         if (isUniqueConstraintError2(error)) {
           throw new AgentStorageError3("duplicate_id", `[SixbSqlite] Agent run '${input.id}' already exists for project '${input.projectId}'.`);
@@ -5209,9 +5339,9 @@ class SqliteAgentRunStore {
         this.db.query(`
             INSERT INTO agent_runs (
               project_id, id, execution_id, kind, parent_run_id, spawn_key, spec,
-              requester_group_ids, status, attempt, created_at
-            ) VALUES (?, ?, ?, 'subagent', ?, ?, ?, ?, 'queued', 0, ?)
-          `).run(input.projectId, input.id, input.executionId, input.parentRunId, input.spawnKey, JSON.stringify(input.spec), parentRow.requester_group_ids, (input.createdAt ?? new Date).toISOString());
+              status, attempt, created_at
+            ) VALUES (?, ?, ?, 'subagent', ?, ?, ?, 'queued', 0, ?)
+          `).run(input.projectId, input.id, input.executionId, input.parentRunId, input.spawnKey, JSON.stringify(input.spec), (input.createdAt ?? new Date).toISOString());
       } catch (error) {
         if (isUniqueConstraintError2(error)) {
           throw new AgentStorageError3("duplicate_id", `[SixbSqlite] Subagent run '${input.id}' conflicts with an existing durable spawn.`);
@@ -5499,6 +5629,7 @@ import {
   aiModelCallCostDetails,
   aiModelCallCostMatchesUsage,
   buildAiAccountingOverviewFromFragments,
+  directModelCallAttribution,
   normalizeAiAccountingQuery,
   normalizeAiModelCallAccountingQuery as normalizeAiModelCallAccountingQuery2,
   normalizeAiModelCallCostRecord,
@@ -5539,6 +5670,7 @@ WITH filtered AS (
   SELECT COALESCE(root_agent.execution_id, usage.execution_id) AS root_execution_id,
     usage.execution_id, usage.provider_id, usage.requested_model_id, usage.occurred_at,
     usage.total_tokens,
+    execution.executor_kind, execution.executor_id, execution.authority_primitive_id AS primitive_id,
     COALESCE(cost.status, 'unvalued') AS valuation_status,
     cost.currency AS amount_currency, cost.amount_nanos,
     root_agent.id AS root_agent_run_id,
@@ -5551,6 +5683,7 @@ WITH filtered AS (
     workflow_node.workflow_id AS workflow_id,
     workflow_node.workflow_run_id AS workflow_run_id
   FROM ai_model_call_usage AS usage
+  JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
   LEFT JOIN agent_runs AS direct_agent
     ON direct_agent.project_id = usage.project_id AND direct_agent.execution_id = usage.execution_id
   LEFT JOIN agent_runs AS root_agent
@@ -5588,6 +5721,7 @@ SELECT filtered.root_execution_id, execution_id, provider_id, requested_model_id
   CAST(SUM((amount_nanos / 1000000) % 1000000) AS TEXT) AS amount_middle,
   CAST(SUM(amount_nanos % 1000000) AS TEXT) AS amount_low,
   MAX(root_agent_run_id) AS root_agent_run_id,
+  MAX(executor_kind) AS executor_kind, MAX(executor_id) AS executor_id, MAX(primitive_id) AS primitive_id,
   MAX(root_thread_id) AS root_thread_id,
   MAX(direct_kind) AS direct_kind,
   MAX(direct_run_id) AS direct_run_id,
@@ -5602,12 +5736,11 @@ GROUP BY filtered.root_execution_id, execution_id, provider_id, requested_model_
 `;
 
 // src/ai-usage-storage.ts
+import { assertAiUsageExecutionId, normalizeAiModelCallRecord } from "@sixb/core/internal/storage";
 import { isModelReasoning, normalizeModelProviderIds } from "@sixb/core/models";
 import {
   AiUsageStorageError,
-  aggregateAiModelCallUsage,
-  assertAiUsageExecutionId,
-  normalizeAiModelCallRecord
+  aggregateAiModelCallUsage
 } from "@sixb/core/storage";
 class SqliteAiUsageStorage {
   connection;
@@ -5930,6 +6063,7 @@ var SQLITE_ACCOUNTING_LIST_PAGE_SQL = `
     workflow_agent.node_run_id AS attribution_node_run_id,
     workflow_node.workflow_id AS attribution_workflow_id,
     workflow_node.workflow_run_id AS attribution_workflow_run_id,
+    execution.executor_kind, execution.executor_id, execution.authority_primitive_id AS primitive_id,
     COALESCE((
       SELECT json_group_array(group_id) FROM (
         SELECT group_id FROM ai_model_call_usage_groups
@@ -5946,6 +6080,7 @@ var SQLITE_ACCOUNTING_LIST_PAGE_SQL = `
     cost.details AS cost_details,
     cost.rated_at AS cost_rated_at
   FROM ai_model_call_usage AS usage
+  JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
   LEFT JOIN agent_runs AS direct_agent
     ON direct_agent.project_id = usage.project_id
     AND direct_agent.execution_id = usage.execution_id
@@ -5980,7 +6115,9 @@ var SQLITE_ACCOUNTING_OVERVIEW_SQL = `
         ELSE NULL
       END AS attribution_agent_kind,
       workflow_node.node_id AS attribution_agent_step_id,
-      workflow_node.workflow_id AS attribution_workflow_id,
+      COALESCE(workflow_node.workflow_id,
+        CASE WHEN execution.executor_kind = 'workflow' THEN execution.authority_primitive_id END
+      ) AS attribution_workflow_id,
       CASE
         WHEN cost.status = 'rated' THEN 'rated'
         WHEN cost.status = 'unpriceable' THEN 'unpriceable'
@@ -5989,6 +6126,7 @@ var SQLITE_ACCOUNTING_OVERVIEW_SQL = `
       CASE WHEN cost.status = 'rated' THEN cost.currency ELSE NULL END AS amount_currency,
       CASE WHEN cost.status = 'rated' THEN cost.amount_nanos ELSE NULL END AS amount_nanos
     FROM ai_model_call_usage AS usage
+    JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
     LEFT JOIN agent_runs AS direct_agent
       ON direct_agent.project_id = usage.project_id
       AND direct_agent.execution_id = usage.execution_id
@@ -6120,7 +6258,7 @@ function sqliteAggregateAmount(row) {
 function accountingItemFromRow(row) {
   const usage = usageFromRow2(row, parseStringArray(row.requester_group_ids));
   const cost = row.cost_status === null ? undefined : costFromJoinedRow(row);
-  const attribution = row.attribution_kind === null ? undefined : row.attribution_kind === "agent" ? {
+  const attribution = row.attribution_kind === null ? directModelCallAttribution(row.executor_kind, row.executor_id, row.primitive_id) : row.attribution_kind === "agent" ? {
     kind: "agent",
     agentRunId: required(row.attribution_agent_run_id),
     threadId: required(row.attribution_thread_id)
@@ -7532,8 +7670,8 @@ class SqliteAuthAccessTokenStore {
 }
 function assertSubjectExists(db, projectId, subjectType, subjectId) {
   if (subjectType === "user") {
-    const row2 = db.query("SELECT * FROM auth_users WHERE project_id = ? AND id = ?").get(projectId, subjectId);
-    if (row2)
+    const row = db.query("SELECT * FROM auth_users WHERE project_id = ? AND id = ?").get(projectId, subjectId);
+    if (row)
       return;
     throw new AuthStorageError2("missing_user", `[Sixb] User '${subjectId}' not found for project '${projectId}'.`);
   }
@@ -8664,7 +8802,7 @@ class SqliteAuthStorage {
       }
       this.consumeOidcAttempt(input, completedAt, projectId);
       if (!userRow) {
-        const user2 = this.insertUser({
+        const user = this.insertUser({
           id: newUserId ?? assertNonEmpty(input.newUserId, "User id"),
           projectId,
           email,
@@ -8673,14 +8811,14 @@ class SqliteAuthStorage {
           createdAt: completedAt
         });
         userRow = {
-          project_id: user2.projectId,
-          id: user2.id,
-          email: user2.email,
-          display_name: user2.displayName ?? null,
-          avatar_url: user2.avatarUrl ?? null,
-          status: user2.status,
-          created_at: toIso(user2.createdAt),
-          updated_at: toIso(user2.updatedAt)
+          project_id: user.projectId,
+          id: user.id,
+          email: user.email,
+          display_name: user.displayName ?? null,
+          avatar_url: user.avatarUrl ?? null,
+          status: user.status,
+          created_at: toIso(user.createdAt),
+          updated_at: toIso(user.updatedAt)
         };
       }
       const user = rowToUserRecord(userRow);
@@ -8980,7 +9118,7 @@ class SqliteConnectorConnectionPersistence {
             callback_binding_hash, reauthorization_id, reauthorization_revision,
             reauthorization_connection_ids, created_at, expires_at
           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run(record.projectId, record.connectorId, record.id, record.slot, record.initiatedByExecutionId, record.stateHash, json(record.codeVerifier), record.redirectUri, record.connectionRunId ?? null, record.returnTo ?? null, record.callbackBindingHash ?? null, record.reauthorizationId ?? null, record.reauthorizationRevision ?? null, record.reauthorizationConnectionIds ? json(record.reauthorizationConnectionIds) : null, iso(record.createdAt), iso(record.expiresAt));
+        `).run(record.projectId, record.connectorId, record.id, record.slot, record.initiatedByExecutionId, record.stateHash, record.codeVerifier === undefined ? null : json(record.codeVerifier), record.redirectUri, record.connectionRunId ?? null, record.returnTo ?? null, record.callbackBindingHash ?? null, record.reauthorizationId ?? null, record.reauthorizationRevision ?? null, record.reauthorizationConnectionIds ? json(record.reauthorizationConnectionIds) : null, iso(record.createdAt), iso(record.expiresAt));
       return true;
     } catch (error) {
       if (isUniqueConstraintError2(error))
@@ -9161,7 +9299,7 @@ function authorizationAttemptFromRow(row) {
     slot: row.slot,
     initiatedByExecutionId: row.initiated_by_execution_id,
     stateHash: row.state_hash,
-    codeVerifier: parseJson(row.code_verifier),
+    ...row.code_verifier === null ? {} : { codeVerifier: parseJson(row.code_verifier) },
     redirectUri: row.redirect_uri,
     ...row.connection_run_id === null ? {} : { connectionRunId: row.connection_run_id },
     ...row.return_to === null ? {} : { returnTo: row.return_to },
@@ -9398,8 +9536,7 @@ function assertChanged(changes, label, id) {
 import {
   executionRecordFromStorageRow,
   executionRecordToStorageRow,
-  normalizeExecutionRecord,
-  validateExecutionRecordReferences
+  prepareExecutionRecord
 } from "@sixb/core/internal/execution-storage";
 import { ExecutionStorageError } from "@sixb/core/storage";
 
@@ -9413,8 +9550,7 @@ class SqliteExecutionStorage {
     this.shareSessions = shareSessions;
   }
   async create(input) {
-    const record = normalizeExecutionRecord(input);
-    await validateExecutionRecordReferences(record, {
+    const record = await prepareExecutionRecord(input, {
       auth: this.auth,
       getExecution: (params) => this.getById(params),
       getShareSession: (params) => this.shareSessions.getById(params)
@@ -9431,6 +9567,7 @@ class SqliteExecutionStorage {
             source_id,
             requested_by_user_id,
             requested_by_service_account_id,
+            requester_group_ids,
             correlation_id,
             parent_execution_id,
             authority_kind,
@@ -9445,8 +9582,8 @@ class SqliteExecutionStorage {
             authority_delegation_id,
             authority_delegation_session_id,
             created_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run(row.projectId, row.id, row.executorKind, row.executorId, row.sourceKind, row.sourceId, row.requestedByUserId, row.requestedByServiceAccountId, row.correlationId, row.parentExecutionId, row.authorityKind, row.authorityUserId, row.authorityServiceAccountId, row.authoritySessionId, row.authorityAccessTokenId, row.authorityPrimitiveKind, row.authorityPrimitiveId, row.authorityKernelOperation, row.authorityDelegationKind, row.authorityDelegationId, row.authorityDelegationSessionId, row.createdAt.toISOString());
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(row.projectId, row.id, row.executorKind, row.executorId, row.sourceKind, row.sourceId, row.requestedByUserId, row.requestedByServiceAccountId, JSON.stringify(row.requesterGroupIds), row.correlationId, row.parentExecutionId, row.authorityKind, row.authorityUserId, row.authorityServiceAccountId, row.authoritySessionId, row.authorityAccessTokenId, row.authorityPrimitiveKind, row.authorityPrimitiveId, row.authorityKernelOperation, row.authorityDelegationKind, row.authorityDelegationId, row.authorityDelegationSessionId, row.createdAt.toISOString());
     } catch (error) {
       if (isDuplicateExecutionError(error)) {
         throw new ExecutionStorageError("duplicate_execution", `[SixbSqlite] Execution '${record.id}' already exists in project '${record.projectId}'.`, { cause: error });
@@ -9474,6 +9611,7 @@ function toStorageRow(row) {
     sourceId: row.source_id,
     requestedByUserId: row.requested_by_user_id,
     requestedByServiceAccountId: row.requested_by_service_account_id,
+    requesterGroupIds: JSON.parse(row.requester_group_ids),
     correlationId: row.correlation_id,
     parentExecutionId: row.parent_execution_id,
     authorityKind: row.authority_kind,
@@ -9901,18 +10039,18 @@ function compileExpansionOrder(expansion, target, neighborType, neighborId) {
 }
 function compileSet(projectId, op, inputs, ctx) {
   if (inputs.length === 0) {
-    const order2 = compileOrder(identityOrderFields());
+    const order = compileOrder(identityOrderFields());
     return {
       sql: `
         SELECT *
         FROM ${ctx.source.objectsTable}
         WHERE 1 = 0
-        ORDER BY ${order2.sql}
+        ORDER BY ${order.sql}
       `,
-      args: order2.args,
+      args: order.args,
       totalSql: "SELECT 0 as total",
       totalArgs: [],
-      order: order2,
+      order,
       hasMore: () => false,
       trimRows: identityRows,
       nextPageToken: () => {
@@ -11353,6 +11491,12 @@ function sourceRecord(row) {
     projectionRevision: row.projection_revision,
     ownershipHash: row.ownership_hash,
     ontologyRevision: row.ontology_revision,
+    ...row.base_materialization_id === null ? {} : {
+      base: {
+        materializationId: row.base_materialization_id,
+        lastCommitId: row.base_commit_id
+      }
+    },
     rootCount: row.root_count,
     assertionCount: row.assertion_count,
     createdAt: row.created_at,
@@ -11524,7 +11668,7 @@ import {
   linkRefKey as linkRefKey3,
   linkRefSortKey,
   linkScopeSortKey as linkScopeSortKey2,
-  MaterializationConflictError as MaterializationConflictError5,
+  MaterializationConflictError as MaterializationConflictError6,
   objectRefKey as objectRefKey3,
   objectRefSortKey,
   telemetryPointKey as telemetryPointKey2,
@@ -11544,7 +11688,7 @@ import {
 
 // src/ontology-storage/materialization-session.ts
 import {
-  MaterializationConflictError as MaterializationConflictError3
+  MaterializationConflictError as MaterializationConflictError4
 } from "@sixb/core/internal/materialization";
 import {
   correlateMaterializationChunk,
@@ -11559,9 +11703,9 @@ import {
 import {
   linkRefKey,
   linkScopeSortKey,
-  MaterializationConflictError as MaterializationConflictError2,
+  MaterializationConflictError as MaterializationConflictError3,
   objectRefKey,
-  projectionEntityKey,
+  projectionEntityKey as projectionEntityKey2,
   telemetryPointSortKey
 } from "@sixb/core/internal/materialization";
 import {
@@ -11570,6 +11714,132 @@ import {
   linkSlotOverrideValue,
   startScopeAccumulator
 } from "@sixb/core/internal/ontology-storage-provider";
+
+// src/ontology-storage/source-roots.ts
+import {
+  MaterializationConflictError as MaterializationConflictError2,
+  MaterializationValidationError,
+  projectionEntityKey
+} from "@sixb/core/internal/materialization";
+import { sourceStageRoots, utf8SortKey } from "@sixb/core/internal/ontology-storage-provider";
+function replacementSourceRows(input) {
+  const roots = input.incremental ? `ontology_source_roots AS changed
+    CROSS JOIN ontology_source_roots AS roots ON roots.project_id = changed.project_id
+      AND roots.source_id = changed.source_id AND roots.root_sort_key = changed.root_sort_key AND roots.active = 1` : "ontology_source_roots AS roots";
+  const selected = input.incremental ? "changed" : "roots";
+  return {
+    sql: `SELECT * FROM ontology_source_rows WHERE project_id = ? AND source_id = ? AND materialization_id = ?
+      UNION ALL
+      SELECT rows.* FROM ${roots}
+      CROSS JOIN ontology_source_rows AS rows ON rows.project_id = roots.project_id
+        AND rows.source_id = roots.source_id AND rows.materialization_id = roots.materialization_id
+        AND rows.root_sort_key = roots.root_sort_key
+      WHERE ${selected}.project_id = ? AND ${selected}.source_id = ?
+        AND ${input.incremental ? "changed.materialization_id = ?" : "roots.active = 1"}`,
+    values: [
+      input.projectId,
+      input.sourceId,
+      input.materializationId,
+      input.projectId,
+      input.sourceId,
+      ...input.incremental ? [input.materializationId] : []
+    ]
+  };
+}
+function stageSourceRoots(db, manifest, input) {
+  const roots = sourceStageRoots(manifest.projection_kind, input);
+  if (!manifest.base_materialization_id && roots.some((root) => root.deleted)) {
+    throw new MaterializationValidationError("Root deletions require a source delta base.");
+  }
+  const existing = db.query(`SELECT staging_ordinal, deleted FROM ontology_source_roots
+    WHERE project_id = ? AND source_id = ? AND materialization_id = ? AND root_sort_key = ?`);
+  const insert = db.query(`INSERT INTO ontology_source_roots (
+    project_id, source_id, materialization_id, root_sort_key, root_kind, root_key, root, staging_ordinal, deleted
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT DO NOTHING RETURNING root_sort_key`);
+  for (const root of roots) {
+    const inserted = insert.get(input.projectId, input.source.projectionId, input.materializationId, root.sortKey, root.root.kind, root.rootKey, canonicalJson(root.root), root.stagingOrdinal, Number(root.deleted));
+    if (inserted)
+      continue;
+    const previous = existing.get(input.projectId, input.source.projectionId, input.materializationId, root.sortKey);
+    if (!previous || previous.staging_ordinal !== root.stagingOrdinal || Boolean(previous.deleted) !== root.deleted) {
+      throw new MaterializationValidationError("Source materialization repeats root or stream ordinal with different content.");
+    }
+  }
+}
+function activateSourceRoots(db, projectId, 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 scope = [projectId, activation.source.projectionId, activation.materializationId];
+  db.query(`UPDATE ontology_source_roots AS roots SET active = 0, retired_at = ?
+    WHERE project_id = ? AND source_id = ? AND active = 1
+      ${candidate.base_materialization_id === null ? "" : `AND root_sort_key IN (
+        SELECT root_sort_key FROM ontology_source_roots
+        WHERE project_id = ? AND source_id = ? AND materialization_id = ?)`}`).run(activation.updatedAt, projectId, activation.source.projectionId, ...candidate.base_materialization_id === null ? [] : [...scope]);
+  db.query(`UPDATE ontology_source_roots SET active = CASE WHEN deleted = 1 THEN 0 ELSE 1 END,
+      retired_at = CASE WHEN deleted = 1 THEN ? ELSE NULL END
+    WHERE project_id = ? AND source_id = ? AND materialization_id = ?`).run(activation.updatedAt, ...scope);
+}
+function assertSourceRootCoverage(db, manifest) {
+  const invalid = db.query(`SELECT 1 FROM ontology_source_roots AS roots
+    WHERE project_id = ? AND source_id = ? AND materialization_id = ?
+      AND roots.deleted = EXISTS (
+        SELECT 1 FROM ontology_source_rows AS rows
+        WHERE rows.project_id = roots.project_id AND rows.source_id = roots.source_id
+          AND rows.materialization_id = roots.materialization_id AND rows.root_sort_key = roots.root_sort_key
+      ) LIMIT 1`).get(manifest.project_id, manifest.source_id, manifest.materialization_id);
+  if (invalid)
+    throw new MaterializationValidationError("Source roots must have complete assertions or an explicit deletion, never both.");
+}
+function activeSourceRows(db, projectId, refs) {
+  const keys = refs.flatMap((entity) => {
+    const entitySortKey = utf8SortKey(projectionEntityKey(entity));
+    const roots = entity.kind === "object" ? [entitySortKey] : [
+      entitySortKey,
+      utf8SortKey(projectionEntityKey({ kind: "object", ref: entity.ref.source }))
+    ];
+    return roots.map((rootSortKey) => ({ rootSortKey, entitySortKey }));
+  });
+  return db.query(`WITH requested AS (
+    SELECT DISTINCT json_extract(value, '$.rootSortKey') AS root_sort_key,
+      json_extract(value, '$.entitySortKey') AS entity_sort_key FROM json_each(?)
+  ) SELECT rows.* FROM requested
+    CROSS JOIN ontology_source_roots AS roots ON roots.project_id = ?
+      AND roots.active = 1 AND roots.root_sort_key = requested.root_sort_key
+    CROSS JOIN ontology_source_rows AS rows ON rows.project_id = roots.project_id AND rows.source_id = roots.source_id
+      AND rows.materialization_id = roots.materialization_id AND rows.entity_sort_key = requested.entity_sort_key
+      AND rows.root_sort_key = roots.root_sort_key`).all(canonicalJson(keys), projectId);
+}
+function replacementAssertionRows(db, input) {
+  const keys = input.refs.map((ref) => ({
+    entityKind: ref.kind,
+    entityKey: projectionEntityKey(ref),
+    rootKeys: ref.kind === "object" ? [utf8SortKey(projectionEntityKey(ref))] : [
+      utf8SortKey(projectionEntityKey(ref)),
+      utf8SortKey(projectionEntityKey({ kind: "object", ref: ref.ref.source }))
+    ]
+  }));
+  const previous = !input.includePrevious ? "" : `UNION ALL
+    SELECT rows.* FROM requested_entities AS requested
+    CROSS JOIN ontology_source_roots AS roots ON roots.project_id = ? AND roots.source_id = ?
+      AND roots.active = 1 AND roots.root_sort_key IN (SELECT value FROM json_each(requested.root_keys))
+    CROSS JOIN ontology_source_rows AS rows ON rows.project_id = roots.project_id AND rows.source_id = roots.source_id
+      AND rows.materialization_id = roots.materialization_id AND rows.root_sort_key = roots.root_sort_key
+      AND rows.entity_kind = requested.entity_kind AND rows.entity_key = requested.entity_key
+    ${!input.incremental ? "" : `WHERE EXISTS (SELECT 1 FROM ontology_source_roots AS changed
+      WHERE changed.project_id = roots.project_id AND changed.source_id = roots.source_id
+        AND changed.materialization_id = ? AND changed.root_sort_key = roots.root_sort_key)`}`;
+  return db.query(`WITH requested_entities AS (
+    SELECT DISTINCT json_extract(value, '$.entityKind') AS entity_kind,
+      json_extract(value, '$.entityKey') AS entity_key, json_extract(value, '$.rootKeys') AS root_keys FROM json_each(?)
+  ) SELECT rows.* FROM requested_entities AS requested
+    CROSS JOIN ontology_source_rows AS rows ON rows.project_id = ? AND rows.source_id = ?
+      AND rows.materialization_id = ? AND rows.entity_kind = requested.entity_kind AND rows.entity_key = requested.entity_key
+    ${previous}`).all(canonicalJson(keys), input.projectId, input.sourceId, input.materializationId, ...input.includePrevious ? [input.projectId, input.sourceId, ...input.incremental ? [input.materializationId] : []] : []);
+}
+
+// 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) {
@@ -11606,18 +11876,7 @@ class SqliteMaterializationStateReader {
            ON objects.project_id = ?
           AND objects.object_type_id = requested.object_type_id
           AND objects.primary_id = requested.primary_id`).all(requested, this.projectId);
-    const sourceRows = this.db.query(`WITH requested AS (${requestedObjects})
-         SELECT rows.* FROM requested
-         CROSS JOIN ontology_source_rows AS rows
-           ON rows.project_id = ?
-          AND rows.entity_kind = 'object'
-          AND rows.object_type_id = requested.object_type_id
-          AND rows.primary_id = requested.primary_id
-         JOIN ontology_sources AS sources
-           ON sources.project_id = rows.project_id
-          AND sources.source_id = rows.source_id
-          AND sources.materialization_id = rows.materialization_id
-         WHERE sources.status = 'active'`).all(requested, this.projectId);
+    const sourceRows = activeSourceRows(this.db, this.projectId, refs.map((ref) => ({ kind: "object", ref })));
     const overrideRows = this.db.query(`WITH requested AS (${requestedObjects})
          SELECT overrides.* FROM requested
          CROSS JOIN ontology_object_overrides AS overrides
@@ -11656,7 +11915,7 @@ class SqliteMaterializationStateReader {
       const effectiveRow = effective.get(key);
       return {
         ref: structuredClone(ref),
-        source: sourceObject(sources.get(projectionEntityKey({ kind: "object", ref }))),
+        source: sourceObject(sources.get(projectionEntityKey2({ kind: "object", ref }))),
         override: overrides.get(key) ?? null,
         effective: effectiveRow ? effectiveObjectSnapshot(effectiveRow) : null,
         latestTelemetry: telemetry.get(key) ?? []
@@ -11701,21 +11960,7 @@ class SqliteMaterializationStateReader {
           AND links.link_id = requested.link_id
           AND links.target_type_id = requested.target_type_id
           AND links.target_id = requested.target_id`).all(requested, this.projectId);
-    const sourceRows = this.db.query(`WITH requested AS (${sourceRequest})
-         SELECT rows.* FROM requested
-         CROSS JOIN ontology_source_rows AS rows
-           ON rows.project_id = ?
-          AND rows.entity_kind = 'link'
-          AND rows.source_type_id = requested.source_type_id
-          AND rows.source_primary_id = requested.source_primary_id
-          AND rows.link_id = requested.link_id
-          AND rows.target_type_id = requested.target_type_id
-          AND rows.target_primary_id = requested.target_primary_id
-         JOIN ontology_sources AS sources
-           ON sources.project_id = rows.project_id
-          AND sources.source_id = rows.source_id
-          AND sources.materialization_id = rows.materialization_id
-         WHERE sources.status = 'active'`).all(requested, this.projectId);
+    const sourceRows = activeSourceRows(this.db, this.projectId, refs.map((ref) => ({ kind: "link", ref })));
     const overrideRows = this.db.query(`WITH requested AS (${sourceRequest})
          SELECT overrides.* FROM requested
          CROSS JOIN ontology_link_overrides AS overrides
@@ -11746,7 +11991,7 @@ class SqliteMaterializationStateReader {
       const effectiveRow = effective.get(key);
       return {
         ref: structuredClone(ref),
-        source: sourceLink(sources.get(projectionEntityKey({ kind: "link", ref }))),
+        source: sourceLink(sources.get(projectionEntityKey2({ kind: "link", ref }))),
         override: overrides.get(key) ?? null,
         slotOverride: slotOverrides.get(linkScopeSortKey(ref.source, ref.linkId)) ?? null,
         effective: effectiveRow ? effectiveLinkSnapshot(effectiveRow) : null
@@ -11811,11 +12056,12 @@ class SqliteMaterializationStateReader {
           AND rows.source_type_id = requested.source_type_id
           AND rows.source_primary_id = requested.source_primary_id
           AND rows.link_id = requested.link_id
-         JOIN ontology_sources AS sources
+         JOIN ontology_source_roots AS sources
            ON sources.project_id = rows.project_id
           AND sources.source_id = rows.source_id
           AND sources.materialization_id = rows.materialization_id
-         WHERE sources.status = 'active'`).all(requestedJson, this.projectId);
+         AND sources.root_sort_key = rows.root_sort_key
+         WHERE sources.active = 1`).all(requestedJson, this.projectId);
     const slotOverrideRows = this.db.query(`WITH requested AS (
            SELECT DISTINCT
              json_extract(value, '$.sourceTypeId') AS source_type_id,
@@ -11871,13 +12117,13 @@ class SqliteMaterializationStateReader {
           ORDER BY requested.scope_sort_key, ${linkSortExpression("links")}
         `).iterate(requestedJson, this.projectId);
     for (const row of rows) {
-      const accumulator2 = accumulators.get(row.scope_sort_key);
-      if (!accumulator2) {
-        throw new MaterializationConflictError2("effective-state", `Unexpected link scope '${row.scope_sort_key}' returned by storage.`);
+      const accumulator = accumulators.get(row.scope_sort_key);
+      if (!accumulator) {
+        throw new MaterializationConflictError3("effective-state", `Unexpected link scope '${row.scope_sort_key}' returned by storage.`);
       }
       const snapshot = effectiveLinkSnapshot(row);
-      appendScopeSnapshot(accumulator2, snapshot);
-      effective.set(row.scope_sort_key, accumulator2.effectiveCount === 1 ? snapshot : null);
+      appendScopeSnapshot(accumulator, snapshot);
+      effective.set(row.scope_sort_key, accumulator.effectiveCount === 1 ? snapshot : null);
     }
     return {
       revisions: scopes.map(({ source, linkId }) => finishScopeAccumulator(accumulators.get(linkScopeSortKey(source, linkId)))),
@@ -11904,11 +12150,12 @@ class SqliteMaterializationStateReader {
               SELECT rows.source_type_id, rows.source_primary_id, rows.link_id,
                 rows.target_type_id, rows.target_primary_id
               FROM ontology_source_rows AS rows
-              JOIN ontology_sources AS sources
+              JOIN ontology_source_roots AS sources
                 ON sources.project_id = rows.project_id
                AND sources.source_id = rows.source_id
                AND sources.materialization_id = rows.materialization_id
-              WHERE rows.project_id = ? AND rows.entity_kind = 'link' AND sources.status = 'active'
+         AND sources.root_sort_key = rows.root_sort_key
+              WHERE rows.project_id = ? AND rows.entity_kind = 'link' AND sources.active = 1
             ), selected AS (
               SELECT DISTINCT links.*,
                 ${linkSortExpression("links")} AS sort_key
@@ -11951,19 +12198,19 @@ class SqliteMaterializationStateReader {
     const candidates = this.replacementSources(sourceId, [candidateMaterializationId], refs.map((ref) => ({ kind: "object", ref })));
     return base.map((state) => ({
       ref: state.ref,
-      candidateSource: sourceObject(candidates.byMaterialization.get(candidateMaterializationId)?.get(projectionEntityKey({ kind: "object", ref: state.ref }))),
+      candidateSource: sourceObject(candidates.byMaterialization.get(candidateMaterializationId)?.get(projectionEntityKey2({ kind: "object", ref: state.ref }))),
       override: state.override,
       effective: state.effective,
       latestTelemetry: state.latestTelemetry
     }));
   }
-  replacementLinkStates(sourceId, candidateMaterializationId, materializationIds, identities) {
+  replacementLinkStates(sourceId, candidateMaterializationId, materializationIds, identities, incremental = false) {
     const refs = identities.map((identity) => identity.ref);
     const base = this.linkStates(refs);
-    const replacements = this.replacementSources(sourceId, materializationIds, refs.map((ref) => ({ kind: "link", ref })));
+    const replacements = this.replacementSources(sourceId, materializationIds, refs.map((ref) => ({ kind: "link", ref })), incremental);
     const candidate = replacements.byMaterialization.get(candidateMaterializationId);
     return base.map((state, index) => {
-      const key = projectionEntityKey({ kind: "link", ref: state.ref });
+      const key = projectionEntityKey2({ kind: "link", ref: state.ref });
       return {
         ref: state.ref,
         candidateSource: replacements.owned.has(key) ? sourceLink(candidate?.get(key)) : state.source,
@@ -11987,32 +12234,23 @@ class SqliteMaterializationStateReader {
         `).get(this.projectId, ref.source.objectTypeId, ref.source.primaryId, ref.linkId, ref.target.objectTypeId, ref.target.primaryId);
     return row ? row.last_commit_id : undefined;
   }
-  replacementSources(sourceId, materializationIds, refs) {
+  replacementSources(sourceId, materializationIds, refs, incremental = false) {
     if (materializationIds.length === 0 || refs.length === 0) {
       return { owned: new Set, byMaterialization: new Map };
     }
-    const requestedEntities = canonicalJson(refs.map((ref) => ({ entityKind: ref.kind, entityKey: projectionEntityKey(ref) })));
-    const requestedMaterializations = canonicalJson([...new Set(materializationIds)]);
-    const rows = this.db.query(`WITH requested_entities AS (
-           SELECT DISTINCT json_extract(value, '$.entityKind') AS entity_kind,
-             json_extract(value, '$.entityKey') AS entity_key
-           FROM json_each(?)
-         ), requested_materializations AS (
-           SELECT value AS materialization_id FROM json_each(?)
-         )
-         SELECT rows.* FROM requested_materializations
-         CROSS JOIN requested_entities
-         CROSS JOIN ontology_source_rows AS rows
-           ON rows.project_id = ?
-          AND rows.source_id = ?
-          AND rows.materialization_id = requested_materializations.materialization_id
-          AND rows.entity_kind = requested_entities.entity_kind
-          AND rows.entity_key = requested_entities.entity_key`).all(requestedEntities, requestedMaterializations, this.projectId, sourceId);
+    const rows = replacementAssertionRows(this.db, {
+      projectId: this.projectId,
+      sourceId,
+      materializationId: materializationIds[0],
+      incremental,
+      includePrevious: materializationIds.length > 1,
+      refs
+    });
     const owned = new Set;
     const byMaterialization = new Map;
     for (const row of rows) {
       const source = storedSource(row);
-      const key = projectionEntityKey(source.assertion);
+      const key = projectionEntityKey2(source.assertion);
       owned.add(key);
       const materialization = byMaterialization.get(row.materialization_id) ?? new Map;
       materialization.set(key, source);
@@ -12028,19 +12266,30 @@ class SqliteMaterializationStateReader {
     this.prepareReplacementLinks(input);
   }
   prepareReplacementObjects(input) {
+    const rows = replacementSourceRows({
+      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),
             MIN(entity_sort_key), 1
-          FROM ontology_source_rows
-          WHERE project_id = ? AND source_id = ? AND entity_kind = 'object'
-            AND materialization_id IN (?, COALESCE(?, ''))
+          FROM (${rows.sql}) AS rows
+          WHERE entity_kind = 'object'
           GROUP BY object_type_id, primary_id
-        `).run(input.sessionId, this.projectId, input.sourceId, input.candidateMaterializationId, input.previousMaterializationId);
+        `).run(input.sessionId, ...rows.values);
   }
   prepareReplacementLinks(input) {
+    const rows = replacementSourceRows({
+      projectId: this.projectId,
+      sourceId: input.sourceId,
+      materializationId: input.candidateMaterializationId,
+      incremental: input.incremental ?? false
+    });
     this.db.query(`
           WITH incident_objects AS (
             SELECT DISTINCT
@@ -12051,9 +12300,8 @@ class SqliteMaterializationStateReader {
           ), 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 ontology_source_rows
-            WHERE project_id = ? AND source_id = ? AND entity_kind = 'link'
-              AND materialization_id IN (?, COALESCE(?, ''))
+            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
@@ -12094,28 +12342,30 @@ class SqliteMaterializationStateReader {
             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 ontology_source_rows AS rows
-            JOIN ontology_sources AS sources
+            JOIN ontology_source_roots AS sources
               ON sources.project_id = rows.project_id
              AND sources.source_id = rows.source_id
              AND sources.materialization_id = rows.materialization_id
+         AND sources.root_sort_key = rows.root_sort_key
             JOIN incident_objects
               ON incident_objects.object_type_id = rows.source_type_id
              AND incident_objects.primary_id = rows.source_primary_id
             WHERE rows.project_id = ? AND rows.entity_kind = 'link'
-              AND sources.status = 'active'
+              AND sources.active = 1
             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 ontology_source_rows AS rows
-            JOIN ontology_sources AS sources
+            JOIN ontology_source_roots AS sources
               ON sources.project_id = rows.project_id
              AND sources.source_id = rows.source_id
              AND sources.materialization_id = rows.materialization_id
+         AND sources.root_sort_key = rows.root_sort_key
             JOIN incident_objects
               ON incident_objects.object_type_id = rows.target_type_id
              AND incident_objects.primary_id = rows.target_primary_id
             WHERE rows.project_id = ? AND rows.entity_kind = 'link'
-              AND sources.status = 'active'
+              AND sources.active = 1
           ), diff_links AS (
             SELECT * FROM replacement_links
             UNION SELECT * FROM incident_links
@@ -12153,7 +12403,7 @@ class SqliteMaterializationStateReader {
             json_array(source_type_id, source_id, link_id, target_type_id, target_id),
             sort_key, diff_required
           FROM selected
-        `).run(input.sessionId, this.projectId, input.sourceId, input.candidateMaterializationId, input.previousMaterializationId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, input.sessionId);
+        `).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(`
@@ -12191,9 +12441,9 @@ function activeSourceMap(rows) {
   const result = new Map;
   for (const row of rows) {
     const source = storedSource(row);
-    const key = projectionEntityKey(source.assertion);
+    const key = projectionEntityKey2(source.assertion);
     if (result.has(key)) {
-      throw new MaterializationConflictError2("source-materialization", `Multiple active sources assert ${key}.`);
+      throw new MaterializationConflictError3("source-materialization", `Multiple active sources assert ${key}.`);
     }
     result.set(key, source);
   }
@@ -12208,7 +12458,7 @@ function activeScopeSourceMap(rows) {
     const ref = source.assertion.ref;
     const key = linkScopeSortKey(ref.source, ref.linkId);
     if (result.has(key)) {
-      throw new MaterializationConflictError2("source-materialization", `Multiple active sources assert cardinality-one link slot ${key}.`);
+      throw new MaterializationConflictError3("source-materialization", `Multiple active sources assert cardinality-one link slot ${key}.`);
     }
     result.set(key, source);
   }
@@ -12272,7 +12522,7 @@ function storedSource(row) {
 }
 function effectiveObjectSnapshot(row) {
   if (!row.last_commit_id) {
-    throw new MaterializationConflictError2("effective-state", `Effective object ${row.object_type_id}:${row.primary_id} lacks materializer provenance.`);
+    throw new MaterializationConflictError3("effective-state", `Effective object ${row.object_type_id}:${row.primary_id} lacks materializer provenance.`);
   }
   return {
     ref: objectRefFromColumns(row),
@@ -12285,7 +12535,7 @@ function effectiveObjectSnapshot(row) {
 }
 function effectiveLinkSnapshot(row) {
   if (!row.last_commit_id) {
-    throw new MaterializationConflictError2("effective-state", `Effective link ${linkRefKey(linkRefFromColumns(row))} lacks materializer provenance.`);
+    throw new MaterializationConflictError3("effective-state", `Effective link ${linkRefKey(linkRefFromColumns(row))} lacks materializer provenance.`);
   }
   return {
     ref: linkRefFromColumns(row),
@@ -12299,7 +12549,7 @@ function effectiveLinkSnapshot(row) {
 }
 function storedPoint(row) {
   if (!row.last_commit_id) {
-    throw new MaterializationConflictError2("timeseries-point", `Telemetry point ${telemetryPointSortKey({
+    throw new MaterializationConflictError3("timeseries-point", `Telemetry point ${telemetryPointSortKey({
       object: { objectTypeId: row.object_type_id, primaryId: row.object_id },
       propertyId: row.property_id
     }, row.at)} lacks materializer provenance.`);
@@ -12338,7 +12588,7 @@ class SqliteMaterializationSessions {
   }
   create(header) {
     if (!this.context?.active) {
-      throw new MaterializationConflictError3("effective-state", "Materialization sessions require an active storage transaction.");
+      throw new MaterializationConflictError4("effective-state", "Materialization sessions require an active storage transaction.");
     }
     this.ensureTables();
     const session = new SqliteMaterializationSessionState(structuredClone(header), this.context.id);
@@ -12350,7 +12600,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 MaterializationConflictError3("effective-state", "Materialization session is inactive.");
+      throw new MaterializationConflictError4("effective-state", "Materialization session is inactive.");
     }
     return value;
   }
@@ -12410,7 +12660,7 @@ class SqliteMaterializationSessions {
     const session = this.require(input.session);
     const stream = session.workStreams[input.order];
     if (stream.started) {
-      throw new MaterializationConflictError3("effective-state", `Materialization ${input.order} work may only be streamed once per session.`);
+      throw new MaterializationConflictError4("effective-state", `Materialization ${input.order} work may only be streamed once per session.`);
     }
     stream.started = true;
     session.workSealed = true;
@@ -12687,7 +12937,7 @@ function recordSummary(summary, record, columns) {
 // src/ontology-storage/materialization-writer.ts
 import {
   linkRefKey as linkRefKey2,
-  MaterializationConflictError as MaterializationConflictError4,
+  MaterializationConflictError as MaterializationConflictError5,
   objectRefKey as objectRefKey2,
   telemetryPointKey
 } from "@sixb/core/internal/materialization";
@@ -12859,7 +13109,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 MaterializationConflictError4("timeseries-point", `Telemetry point ${telemetryPointKey(point.series, point.at)} changed.`);
+            throw new MaterializationConflictError5("timeseries-point", `Telemetry point ${telemetryPointKey(point.series, point.at)} changed.`);
           }
           throw error;
         }
@@ -12921,13 +13171,13 @@ class SqliteOntologyMaterializationStorage {
       const linkScopeRevisions = reader.linkScopeRevisions(input.expected.linkScopes);
       for (const [index, expected] of input.expected.linkScopes.entries()) {
         if (linkScopeRevisions[index]?.fingerprint !== expected.fingerprint) {
-          throw new MaterializationConflictError5("effective-state", `Expected link scope changed for ${expected.source.objectTypeId}:${expected.source.primaryId}.${expected.linkId}.`);
+          throw new MaterializationConflictError6("effective-state", `Expected link scope changed for ${expected.source.objectTypeId}:${expected.source.primaryId}.${expected.linkId}.`);
         }
       }
       for (const expected of input.expected.points) {
         const point = reader.exactPoint(expected.series, expected.at);
         if ((point?.lastCommitId ?? null) !== expected.lastCommitId) {
-          throw new MaterializationConflictError5("timeseries-point", `Telemetry point ${telemetryPointKey2(expected.series, expected.at)} changed.`);
+          throw new MaterializationConflictError6("timeseries-point", `Telemetry point ${telemetryPointKey2(expected.series, expected.at)} changed.`);
         }
       }
       return session.publicSession();
@@ -12985,10 +13235,10 @@ class SqliteOntologyMaterializationStorage {
     const reader = new SqliteMaterializationStateReader(this.db, session.header.commit.projectId);
     if (input.entityKind === "object") {
       if (replacement.projectionKind !== "object") {
-        throw new MaterializationConflictError5("source-materialization", "Link projection replacement cannot stream object state.");
+        throw new MaterializationConflictError6("source-materialization", "Link projection replacement cannot stream object state.");
       }
       if (replacement.objectStreamStarted) {
-        throw new MaterializationConflictError5("effective-state", "Replacement object state may only be streamed once per session.");
+        throw new MaterializationConflictError6("effective-state", "Replacement object state may only be streamed once per session.");
       }
       replacement.objectStreamStarted = true;
       for (const identities of reader.replacementIdentities({
@@ -12996,6 +13246,7 @@ class SqliteOntologyMaterializationStorage {
         sourceId: replacement.sourceId,
         candidateMaterializationId: replacement.candidateMaterializationId,
         previousMaterializationId: replacement.previousMaterializationId,
+        incremental: replacement.incremental,
         kind: "object",
         pageRows: input.pageRows
       })) {
@@ -13014,10 +13265,10 @@ class SqliteOntologyMaterializationStorage {
       return;
     }
     if (replacement.projectionKind === "object" && !replacement.objectStreamCompleted) {
-      throw new MaterializationConflictError5("effective-state", "Object projection replacement must fully stream object state before link state.");
+      throw new MaterializationConflictError6("effective-state", "Object projection replacement must fully stream object state before link state.");
     }
     if (replacement.linkStreamStarted) {
-      throw new MaterializationConflictError5("effective-state", "Replacement link state may only be streamed once per session.");
+      throw new MaterializationConflictError6("effective-state", "Replacement link state may only be streamed once per session.");
     }
     replacement.linkStreamStarted = true;
     const materializationIds = [
@@ -13029,6 +13280,7 @@ class SqliteOntologyMaterializationStorage {
       sourceId: replacement.sourceId,
       candidateMaterializationId: replacement.candidateMaterializationId,
       previousMaterializationId: replacement.previousMaterializationId,
+      incremental: replacement.incremental,
       kind: "link",
       pageRows: input.pageRows
     })) {
@@ -13039,7 +13291,7 @@ class SqliteOntologyMaterializationStorage {
         }
         return identity;
       });
-      const links = reader.replacementLinkStates(replacement.sourceId, replacement.candidateMaterializationId, materializationIds, linkIdentities);
+      const links = reader.replacementLinkStates(replacement.sourceId, replacement.candidateMaterializationId, materializationIds, linkIdentities, replacement.incremental);
       yield { objects: [], links };
     }
     this.sessions.require(input.session);
@@ -13091,14 +13343,14 @@ class SqliteOntologyMaterializationStorage {
   requireReplacement(session, input) {
     if (session.replacement) {
       if (session.replacement.sourceId !== input.source.projectionId || session.replacement.candidateMaterializationId !== input.candidateMaterializationId) {
-        throw new MaterializationConflictError5("source-materialization", "Materialization session already owns another replacement union.");
+        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 MaterializationConflictError5("source-materialization", `Candidate source materialization '${input.candidateMaterializationId}' is missing or is not ready.`);
+      throw new MaterializationConflictError6("source-materialization", `Candidate source materialization '${input.candidateMaterializationId}' is missing or is not ready.`);
     }
     assertProjectionExecution(this.db, {
       projectId,
@@ -13108,12 +13360,13 @@ class SqliteOntologyMaterializationStorage {
     });
     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 MaterializationConflictError5("source-materialization", "Source replacement kind or protocol does not match its active materialization.");
+      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,
@@ -13142,38 +13395,38 @@ class SqliteOntologyMaterializationStorage {
     if (!duplicate)
       return;
     if (duplicate.duplicate === "origin") {
-      throw new MaterializationConflictError5("run-correlation", "Ontology commit origin already has an authoritative commit.");
+      throw new MaterializationConflictError6("run-correlation", "Ontology commit origin already has an authoritative commit.");
     }
-    throw new MaterializationConflictError5("idempotency", duplicate.duplicate === "id" ? `Ontology commit '${header.commit.id}' already exists.` : "Ontology idempotency key already exists.");
+    throw new MaterializationConflictError6("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 MaterializationConflictError5("projection-fence", `Source '${expected.source.projectionId}' changed.`);
+      throw new MaterializationConflictError6("projection-fence", `Source '${expected.source.projectionId}' changed.`);
     }
   }
   assertObject(reader, expected) {
     const row = reader.effectiveObjectRevision(expected.ref);
     if (!expected.exists) {
       if (row) {
-        throw new MaterializationConflictError5("effective-state", `Expected object ${objectRefKey3(expected.ref)} to be absent.`);
+        throw new MaterializationConflictError6("effective-state", `Expected object ${objectRefKey3(expected.ref)} to be absent.`);
       }
       return;
     }
     if (!row || row.version !== expected.version || row.lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError5("effective-state", `Expected object ${objectRefKey3(expected.ref)} changed.`);
+      throw new MaterializationConflictError6("effective-state", `Expected object ${objectRefKey3(expected.ref)} changed.`);
     }
   }
   assertLink(reader, expected) {
     const lastCommitId = reader.effectiveLinkLastCommit(expected.ref);
     if (!expected.exists) {
       if (lastCommitId !== undefined) {
-        throw new MaterializationConflictError5("effective-state", `Expected link ${linkRefKey3(expected.ref)} to be absent.`);
+        throw new MaterializationConflictError6("effective-state", `Expected link ${linkRefKey3(expected.ref)} to be absent.`);
       }
       return;
     }
     if (lastCommitId === undefined || lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError5("effective-state", `Expected link ${linkRefKey3(expected.ref)} changed.`);
+      throw new MaterializationConflictError6("effective-state", `Expected link ${linkRefKey3(expected.ref)} changed.`);
     }
   }
   async assertFinalization(session, input) {
@@ -13267,7 +13520,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 MaterializationConflictError5("source-materialization", "Source activation candidate is missing or is not ready.");
+      throw new MaterializationConflictError6("source-materialization", "Source activation candidate is missing or is not ready.");
     }
     assertProjectionExecution(this.db, {
       projectId: commit.projectId,
@@ -13279,6 +13532,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);
     const previous = this.getActiveSource(commit.projectId, activation.source.projectionId);
     if (previous) {
       assertPinnedDatasetWatermark({
@@ -13318,7 +13572,7 @@ class SqliteOntologyMaterializationStorage {
           `).run(commit.projectId, commit.id, commit.idempotencyKey, commit.requestHash, commit.executionId, origin.kind, origin.runId, origin.batchOrdinal, canonicalJson(commit.origin), commit.actor === undefined ? null : canonicalJson(commit.actor), commit.ontologyRevision, commit.projectionRevision ?? null, commit.ownershipHash ?? null, canonicalJson(commit.intent), canonicalJson(input.finalization.result), commit.committedAt);
     } catch (error) {
       if (isSqliteConstraintError(error)) {
-        throw new MaterializationConflictError5("idempotency", "Ontology commit identity already exists.");
+        throw new MaterializationConflictError6("idempotency", "Ontology commit identity already exists.");
       }
       throw error;
     }
@@ -13338,8 +13592,8 @@ class SqliteOntologyMaterializationStorage {
 // src/ontology-storage/outbox.ts
 import { serializeSixbFailure as serializeSixbFailure2 } from "@sixb/core/internal/errors";
 import {
-  MaterializationConflictError as MaterializationConflictError6,
-  MaterializationValidationError
+  MaterializationConflictError as MaterializationConflictError7,
+  MaterializationValidationError as MaterializationValidationError2
 } from "@sixb/core/internal/materialization";
 import { ONTOLOGY_OUTBOX_FAILURE_CODES as ONTOLOGY_OUTBOX_FAILURE_CODES2 } from "@sixb/core/storage";
 class SqliteOntologyOutboxStorage {
@@ -13357,7 +13611,7 @@ class SqliteOntologyOutboxStorage {
       const leaseExpiry = assertTimestamp(input.leaseExpiresAt, "Ontology outbox lease expiry");
       assertNonblank(input.leaseId, "Ontology outbox lease id");
       if (leaseExpiry <= now) {
-        throw new MaterializationValidationError("Ontology outbox lease expiry must be later than the claim time.");
+        throw new MaterializationValidationError2("Ontology outbox lease expiry must be later than the claim time.");
       }
       const rows = this.db.query(`
             UPDATE ontology_outbox
@@ -13375,7 +13629,7 @@ class SqliteOntologyOutboxStorage {
           `).all(input.leaseId, input.leaseExpiresAt, input.projectId, input.now, input.now, input.limit);
       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 MaterializationConflictError6("outbox-lease", "Ontology outbox claim returned an unpaired lease.");
+          throw new MaterializationConflictError7("outbox-lease", "Ontology outbox claim returned an unpaired lease.");
         }
         return { ...record, leaseId: record.leaseId, leaseExpiresAt: record.leaseExpiresAt };
       });
@@ -13474,7 +13728,7 @@ function validateLeaseIds(ids) {
   for (const id of ids) {
     assertNonblank(id, "Ontology outbox event id");
     if (seen.has(id)) {
-      throw new MaterializationValidationError(`Ontology outbox lease batch repeats event '${id}'.`);
+      throw new MaterializationValidationError2(`Ontology outbox lease batch repeats event '${id}'.`);
     }
     seen.add(id);
   }
@@ -13485,11 +13739,11 @@ function assertLeaseInput(input) {
   assertNonblank(input.leaseId, "Ontology outbox lease id");
 }
 function leaseConflict() {
-  return new MaterializationConflictError6("outbox-lease", "Ontology outbox lease does not match.");
+  return new MaterializationConflictError7("outbox-lease", "Ontology outbox lease does not match.");
 }
 
 // src/ontology-storage/sources.ts
-import { MaterializationValidationError as MaterializationValidationError2 } from "@sixb/core/internal/materialization";
+import { MaterializationValidationError as MaterializationValidationError3 } from "@sixb/core/internal/materialization";
 import {
   assertSourceBeginInput as assertBeginInput,
   assertSourceExecutionIdentity as assertExecutionIdentity,
@@ -13503,8 +13757,53 @@ import {
   sourceMaterializationIdentity,
   sourceStageRow,
   sourceStageRows,
-  utf8SortKey
+  utf8SortKey as utf8SortKey2
 } from "@sixb/core/internal/ontology-storage-provider";
+
+// src/ontology-storage/source-cleanup.ts
+function cleanupSourceVersions(db, input) {
+  let remaining = input.limit;
+  let rowsDeleted = db.query(`DELETE FROM ontology_source_rows WHERE rowid IN (
+    SELECT rows.rowid FROM ontology_source_roots AS roots
+    JOIN ontology_sources AS sources USING (project_id, source_id, materialization_id)
+    CROSS JOIN ontology_source_rows AS rows
+      ON rows.project_id = roots.project_id AND rows.source_id = roots.source_id
+      AND rows.materialization_id = roots.materialization_id AND rows.root_sort_key = roots.root_sort_key
+    WHERE roots.project_id = ? AND roots.active = 0 AND roots.retired_at < ?
+      AND sources.status IN ('superseded', 'abandoned')
+    ORDER BY roots.retired_at, roots.source_id, roots.materialization_id, roots.root_sort_key, rows.entity_sort_key
+    LIMIT ?
+  )`).run(input.projectId, input.terminalBefore, remaining).changes;
+  remaining -= rowsDeleted;
+  if (remaining > 0) {
+    const removed = db.query(`DELETE FROM ontology_source_roots WHERE rowid IN (
+      SELECT roots.rowid FROM ontology_source_roots AS roots
+      JOIN ontology_sources AS sources USING (project_id, source_id, materialization_id)
+      WHERE roots.project_id = ? AND roots.active = 0 AND roots.retired_at < ?
+        AND sources.status IN ('superseded', 'abandoned')
+        AND NOT EXISTS (SELECT 1 FROM ontology_source_rows AS rows
+          WHERE rows.project_id = roots.project_id AND rows.source_id = roots.source_id
+            AND rows.materialization_id = roots.materialization_id AND rows.root_sort_key = roots.root_sort_key)
+      ORDER BY roots.retired_at, roots.source_id, roots.materialization_id, roots.root_sort_key LIMIT ?
+    )`).run(input.projectId, input.terminalBefore, remaining).changes;
+    rowsDeleted += removed;
+    remaining -= removed;
+  }
+  const materializationsDeleted = remaining === 0 ? 0 : db.query(`DELETE FROM ontology_sources WHERE rowid IN (
+    SELECT sources.rowid FROM ontology_sources AS sources
+    WHERE project_id = ? AND status IN ('superseded', 'abandoned') AND terminal_at < ?
+      AND NOT EXISTS (SELECT 1 FROM ontology_source_roots AS roots
+        WHERE roots.project_id = sources.project_id AND roots.source_id = sources.source_id
+          AND roots.materialization_id = sources.materialization_id)
+      AND NOT EXISTS (SELECT 1 FROM ontology_source_rows AS rows
+        WHERE rows.project_id = sources.project_id AND rows.source_id = sources.source_id
+          AND rows.materialization_id = sources.materialization_id)
+    ORDER BY terminal_at, source_id, materialization_id LIMIT ?
+  )`).run(input.projectId, input.terminalBefore, remaining).changes;
+  return { rowsDeleted, materializationsDeleted };
+}
+
+// src/ontology-storage/sources.ts
 class SqliteOntologySourceStorage {
   db;
   runRootOperation;
@@ -13539,10 +13838,10 @@ class SqliteOntologySourceStorage {
               dataset_id, dataset_version_id, dataset_version_created_at,
               projection_revision, ownership_hash, ontology_revision,
               root_count, assertion_count, created_at, ready_at, activated_at,
-              terminal_at, last_commit_id, updated_at
+              terminal_at, last_commit_id, updated_at, base_materialization_id, base_commit_id
             ) VALUES (?, ?, ?, ?, ?, 'replacement', 'staging', ?, ?, ?, ?, ?, ?, ?,
-              NULL, NULL, ?, NULL, NULL, NULL, NULL, ?)
-          `).run(input.projectId, input.source.projectionId, input.materializationId, input.execution.projectionRunId, input.projectionKind, input.execution.executionToken, input.datasetVersion.datasetId, input.datasetVersion.versionId, input.datasetVersion.createdAt, input.projectionRevision, input.ownershipHash, input.ontologyRevision, input.createdAt, input.createdAt);
+              NULL, NULL, ?, NULL, NULL, NULL, NULL, ?, ?, ?)
+          `).run(input.projectId, input.source.projectionId, input.materializationId, input.execution.projectionRunId, input.projectionKind, input.execution.executionToken, input.datasetVersion.datasetId, input.datasetVersion.versionId, input.datasetVersion.createdAt, input.projectionRevision, input.ownershipHash, input.ontologyRevision, input.createdAt, input.createdAt, input.base?.materializationId ?? null, input.base?.lastCommitId ?? null);
       return sourceRecord(this.requireManifest(input.projectId, input.source.projectionId, input.materializationId));
     });
   }
@@ -13558,6 +13857,7 @@ class SqliteOntologySourceStorage {
       const rows = sourceStageRows(manifest.projection_kind, input.rows);
       const existing = this.findStageRows(input, rows);
       const { pending, unchanged } = reconcileSourceStageRows(rows, existing);
+      stageSourceRoots(this.db, manifest, input);
       this.insertStageRows(input, pending);
       return { inserted: pending.length, unchanged };
     });
@@ -13583,7 +13883,7 @@ class SqliteOntologySourceStorage {
         throw sourceConflict(`Source materialization '${input.materializationId}' cannot transition from '${manifest.status}' to 'ready'.`);
       }
       if (input.readyAt < manifest.created_at) {
-        throw new MaterializationValidationError2("Source readyAt cannot precede source createdAt.");
+        throw new MaterializationValidationError3("Source readyAt cannot precede source createdAt.");
       }
       this.assertReadyState(manifest, input.rootCount, input.assertionCount);
       const result = this.db.query(`
@@ -13622,55 +13922,7 @@ class SqliteOntologySourceStorage {
       assertNonblank(input.projectId, "Terminal source cleanup project id");
       assertTimestamp(input.terminalBefore, "Terminal source cleanup cutoff", true);
       assertPositiveInteger(input.limit, "Terminal source cleanup limit");
-      const manifests = this.db.query(`
-            SELECT * FROM ontology_sources
-            WHERE project_id = ? AND status IN ('superseded', 'abandoned')
-              AND terminal_at < ?
-            ORDER BY terminal_at, source_id, materialization_id
-            LIMIT ?
-          `).all(input.projectId, input.terminalBefore, input.limit);
-      let remaining = input.limit;
-      let rowsDeleted = 0;
-      let materializationsDeleted = 0;
-      for (const manifest of manifests) {
-        if (remaining === 0)
-          break;
-        const deleted = this.db.query(`
-              DELETE FROM ontology_source_rows
-              WHERE rowid IN (
-                SELECT rows.rowid
-                FROM ontology_source_rows AS rows
-                JOIN ontology_sources AS sources
-                  ON sources.project_id = rows.project_id
-                 AND sources.source_id = rows.source_id
-                 AND sources.materialization_id = rows.materialization_id
-                WHERE rows.project_id = ? AND rows.source_id = ? AND rows.materialization_id = ?
-                  AND sources.status IN ('superseded', 'abandoned')
-                  AND sources.terminal_at = ? AND sources.terminal_at < ?
-                ORDER BY rows.entity_sort_key
-                LIMIT ?
-              )
-            `).run(manifest.project_id, manifest.source_id, manifest.materialization_id, manifest.terminal_at, input.terminalBefore, remaining).changes;
-        rowsDeleted += deleted;
-        remaining -= deleted;
-        if (remaining === 0)
-          break;
-        const removed = this.db.query(`
-              DELETE FROM ontology_sources
-              WHERE project_id = ? AND source_id = ? AND materialization_id = ?
-                AND status IN ('superseded', 'abandoned')
-                AND terminal_at = ? AND terminal_at < ?
-                AND NOT EXISTS (
-                  SELECT 1 FROM ontology_source_rows AS rows
-                  WHERE rows.project_id = ontology_sources.project_id
-                    AND rows.source_id = ontology_sources.source_id
-                    AND rows.materialization_id = ontology_sources.materialization_id
-                )
-            `).run(manifest.project_id, manifest.source_id, manifest.materialization_id, manifest.terminal_at, input.terminalBefore).changes;
-        materializationsDeleted += removed;
-        remaining -= removed;
-      }
-      return { rowsDeleted, materializationsDeleted };
+      return cleanupSourceVersions(this.db, input);
     });
   }
   async summarizeTerminal(input) {
@@ -13714,7 +13966,7 @@ class SqliteOntologySourceStorage {
   }
   transitionToAbandoned(manifest, abandonedAt) {
     if (abandonedAt < manifest.created_at || manifest.ready_at !== null && abandonedAt < manifest.ready_at) {
-      throw new MaterializationValidationError2("Source abandonedAt cannot precede source creation or readiness.");
+      throw new MaterializationValidationError3("Source abandonedAt cannot precede source creation or readiness.");
     }
     const changed = this.db.query(`
           UPDATE ontology_sources
@@ -13725,19 +13977,23 @@ class SqliteOntologySourceStorage {
     if (changed !== 1) {
       throw sourceConflict(`Source materialization '${manifest.materialization_id}' cannot transition to 'abandoned'.`);
     }
+    this.db.query(`UPDATE ontology_source_roots SET retired_at = ?
+      WHERE project_id = ? AND source_id = ? AND materialization_id = ? AND active = 0`).run(abandonedAt, manifest.project_id, manifest.source_id, manifest.materialization_id);
     return sourceRecord(this.requireManifest(manifest.project_id, manifest.source_id, manifest.materialization_id));
   }
   assertReadyState(manifest, rootCount, assertionCount) {
     const counts = this.db.query(`
-          SELECT COUNT(*) AS assertions, COUNT(DISTINCT root_key) AS roots,
+          SELECT (SELECT COUNT(*) FROM ontology_source_rows
+            WHERE project_id = ? AND source_id = ? AND materialization_id = ?) AS assertions, COUNT(*) AS roots,
             COUNT(DISTINCT staging_ordinal) AS ordinals,
             MIN(staging_ordinal) AS min_ordinal, MAX(staging_ordinal) AS max_ordinal
-          FROM ontology_source_rows
+          FROM ontology_source_roots
           WHERE project_id = ? AND source_id = ? AND materialization_id = ?
-        `).get(manifest.project_id, manifest.source_id, manifest.materialization_id);
+        `).get(manifest.project_id, manifest.source_id, manifest.materialization_id, manifest.project_id, manifest.source_id, manifest.materialization_id);
     if (counts.assertions !== assertionCount || counts.roots !== rootCount || counts.ordinals !== rootCount || rootCount > 0 && (counts.min_ordinal !== 0 || counts.max_ordinal !== rootCount - 1)) {
-      throw new MaterializationValidationError2("Source ready counts do not match the staged roots and assertions.");
+      throw new MaterializationValidationError3("Source ready counts do not match the staged roots and assertions.");
     }
+    assertSourceRootCoverage(this.db, manifest);
     const invalid = this.db.query(manifest.projection_kind === "link" ? `
               SELECT root_key
               FROM ontology_source_rows
@@ -13763,15 +14019,15 @@ class SqliteOntologySourceStorage {
               LIMIT 1
             `).get(manifest.project_id, manifest.source_id, manifest.materialization_id);
     if (invalid) {
-      throw new MaterializationValidationError2(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 MaterializationValidationError3(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(input, rows) {
     if (rows.length === 0)
       return [];
-    const rootSortKeys = [...new Set(rows.map((row) => utf8SortKey(row.rootKey)))];
+    const rootSortKeys = [...new Set(rows.map((row) => utf8SortKey2(row.rootKey)))];
     const ordinals = [...new Set(rows.map((row) => row.row.stagingOrdinal))];
-    const entitySortKeys = [...new Set(rows.map((row) => utf8SortKey(row.entityKey)))];
+    const entitySortKeys = [...new Set(rows.map((row) => utf8SortKey2(row.entityKey)))];
     const existing = this.db.query(`
           SELECT * FROM ontology_source_rows
           WHERE project_id = ? AND source_id = ? AND materialization_id = ?
@@ -13792,10 +14048,10 @@ class SqliteOntologySourceStorage {
       return {
         entityKind: row.assertion.kind,
         entityKey,
-        entitySortKey: utf8SortKey(entityKey),
+        entitySortKey: utf8SortKey2(entityKey),
         rootKind: row.root.kind,
         rootKey,
-        rootSortKey: utf8SortKey(rootKey),
+        rootSortKey: utf8SortKey2(rootKey),
         stagingOrdinal: row.stagingOrdinal,
         root: row.root,
         assertion: row.assertion,
@@ -13889,11 +14145,8 @@ class SqliteOntologyStorage {
 // src/pipeline-run-storage.ts
 import { parseSixbFailure as parseSixbFailure3, serializeSixbFailure as serializeSixbFailure3 } from "@sixb/core/internal/errors";
 import { assertPipelineRunExecution } from "@sixb/core/internal/pipeline-run-storage-provider";
-import {
-  canRequeuePipelineRunAfterEnqueueFailure,
-  PIPELINE_RUN_FAILURE_CODES,
-  PipelineRunError
-} from "@sixb/core/storage";
+import { canRequeuePipelineRunAfterEnqueueFailure } from "@sixb/core/internal/storage";
+import { PIPELINE_RUN_FAILURE_CODES, PipelineRunError } from "@sixb/core/storage";
 
 // src/latest-run-query.ts
 function queryLatestRunsByOwnerId(input) {
@@ -14310,7 +14563,7 @@ class SqliteProjectionRunStorage {
                 input_exhausted = ?, missing_target_object_type_id = NULL,
                 missing_target_object_id = NULL, missing_target_batch_ordinal = NULL,
                 missing_target_first_seen_at = NULL, source_rows_read = 0,
-                source_rows_skipped = 0, error = NULL
+                source_rows_skipped = 0, source_changes_read = NULL, error = NULL
               WHERE project_id = ? AND id = ? AND status = 'failed'
                 AND json_extract(error, '$.code') = 'queue.enqueue_failed'
             `).run(queuedAt.toISOString(), input.fixedBatchSize === undefined ? null : 0, input.fixedBatchSize === undefined ? null : 0, input.fixedBatchSize === undefined ? null : 0, input.projectId, input.id);
@@ -14405,10 +14658,11 @@ class SqliteProjectionRunStorage {
             execution_token = NULL,
             source_rows_read = ?,
             source_rows_skipped = ?,
+            source_changes_read = ?,
             input_exhausted = ?,
             error = ?
           WHERE project_id = ? AND id = ? AND status = 'running' AND execution_token = ?
-        `).run(input.status, plan.finishedAt.toISOString(), plan.progress.sourceRowsRead, plan.progress.sourceRowsSkipped, plan.inputExhausted ? 1 : existingRow.input_exhausted, plan.error === undefined ? null : serializeSixbFailure4(plan.error, PROJECTION_RUN_FAILURE_CODES), input.projectId, input.id, input.executionToken);
+        `).run(input.status, plan.finishedAt.toISOString(), plan.progress.sourceRowsRead, plan.progress.sourceRowsSkipped, plan.progress.sourceChangesRead ?? null, plan.inputExhausted ? 1 : existingRow.input_exhausted, plan.error === undefined ? null : serializeSixbFailure4(plan.error, PROJECTION_RUN_FAILURE_CODES), input.projectId, input.id, input.executionToken);
       if (result.changes !== 1)
         throw staleProjectionRunExecution(input.id);
       return rowToProjectionRunRecord(this.requireRow(input.projectId, input.id));
@@ -14574,6 +14828,7 @@ class SqliteProjectionRunStorage {
     const args = [
       progress.sourceRowsRead,
       progress.sourceRowsSkipped,
+      progress.sourceChangesRead ?? null,
       existing.project_id,
       existing.id,
       executionToken
@@ -14582,7 +14837,8 @@ class SqliteProjectionRunStorage {
         UPDATE projection_runs
         SET
           source_rows_read = ?,
-          source_rows_skipped = ?
+          source_rows_skipped = ?,
+          source_changes_read = ?
         WHERE project_id = ? AND id = ? AND status = 'running'
           AND execution_token = ?
       `).run(...args);
@@ -14652,7 +14908,8 @@ function restoreProjectionRunRow(row) {
     missingTargetFirstSeenAt: row.missing_target_first_seen_at ? new Date(row.missing_target_first_seen_at) : undefined,
     progress: {
       sourceRowsRead: databaseSafeInteger(row.source_rows_read, "sourceRowsRead"),
-      sourceRowsSkipped: databaseSafeInteger(row.source_rows_skipped, "sourceRowsSkipped")
+      sourceRowsSkipped: databaseSafeInteger(row.source_rows_skipped, "sourceRowsSkipped"),
+      ...row.source_changes_read == null ? {} : { sourceChangesRead: databaseSafeInteger(row.source_changes_read, "sourceChangesRead") }
     },
     error: row.error ?? undefined
   };
@@ -15175,12 +15432,9 @@ function invalidRecord2(message) {
 
 // src/sync-run-storage.ts
 import { parseSixbFailure as parseSixbFailure4, serializeSixbFailure as serializeSixbFailure5 } from "@sixb/core/internal/errors";
+import { canRequeueSyncRunAfterEnqueueFailure } from "@sixb/core/internal/storage";
 import { assertSyncRunExecution } from "@sixb/core/internal/sync-run-storage-provider";
-import {
-  canRequeueSyncRunAfterEnqueueFailure,
-  SYNC_RUN_FAILURE_CODES,
-  SyncRunError
-} from "@sixb/core/storage";
+import { SYNC_RUN_FAILURE_CODES, SyncRunError } from "@sixb/core/storage";
 class SqliteSyncRunStorage {
   connection;
   db;
@@ -15896,7 +16150,6 @@ function assertNonNegativeInteger(value, fieldName) {
 }
 
 // src/workflow-run-storage.ts
-import { normalizeRequesterGroupIds as normalizeRequesterGroupIds2 } from "@sixb/core/internal/auth";
 import { parseSixbFailure as parseSixbFailure6, serializeSixbFailure as serializeSixbFailure7 } from "@sixb/core/internal/errors";
 import {
   assertWorkflowAgentNodeRunExecution,
@@ -15943,10 +16196,9 @@ class SqliteWorkflowRunStorage {
             input,
             queued_at,
             started_at,
-            requester_group_ids,
             attempt
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run(input.projectId, input.id, input.executionId, input.workflowId, "queued", serializeRecord2(input.input), queuedAt.toISOString(), queuedAt.toISOString(), JSON.stringify(normalizeRequesterGroupIds2(input.requesterGroupIds)), 0);
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(input.projectId, input.id, input.executionId, input.workflowId, "queued", serializeRecord2(input.input), queuedAt.toISOString(), queuedAt.toISOString(), 0);
     } catch (error) {
       if (isUniqueConstraintError2(error)) {
         throw new WorkflowRunError(`[SixbSqlite] Workflow run '${input.id}' or execution '${input.executionId}' is already linked for project '${input.projectId}'.`);
@@ -16457,7 +16709,6 @@ function rowToWorkflowRunRecord(row) {
     startedAt: new Date(row.started_at),
     finishedAt: row.finished_at ? new Date(row.finished_at) : undefined,
     error: row.error === null ? undefined : parseSixbFailure6(row.error, WORKFLOW_RUN_FAILURE_CODES),
-    requesterGroupIds: JSON.parse(row.requester_group_ids),
     attempt: row.attempt,
     ...row.execution_token && row.execution_queue_lease_expires_at ? {
       execution: {
@@ -16729,8 +16980,8 @@ function createSqliteStores(connection, options) {
   };
 }
 export {
-  migrateSqliteStorage,
-  SqliteStorage
+  SqliteStorage,
+  migrateSqliteStorage
 };
 
-//# debugId=5ACA9B909AAC301E64756E2164756E21
+//# debugId=B98ED3E1F74F05CB64756E2164756E21