@sixb/sqlite 0.1.0 → 0.1.2

package/src/ontology-storage/materialization-writer.ts

@@ -5,11 +5,7 @@ import {
   objectRefKey,
   telemetryPointKey,
 } from "@sixb/core/internal/materialization"
-import {
-  effectiveConflict,
-  type OverrideEntity,
-  overrideEntityColumns as overrideColumns,
-} from "@sixb/core/internal/ontology-storage-provider"
+import { effectiveConflict } from "@sixb/core/internal/ontology-storage-provider"
 import type {
   ExactEffectiveLinkWrite,
   ExactEffectiveObjectWrite,
@@ -17,6 +13,16 @@ import type {
 } from "@sixb/core/storage"
 import { assertTimestamp, canonicalJson, isSqliteConstraintError, requireChanges } from "./shared"
 
+function linkOverrideConflictMessage(identityKind: "edge" | "slot"): string {
+  return identityKind === "edge"
+    ? "Expected link edge override changed."
+    : "Expected link slot override changed."
+}
+
+function linkOverrideConflict(identityKind: "edge" | "slot"): MaterializationConflictError {
+  return effectiveConflict(linkOverrideConflictMessage(identityKind))
+}
+
 /** Applies one already-validated exact plan chunk to SQLite authority tables. */
 export class SqliteMaterializationWriter {
   constructor(private readonly db: Database) {}
@@ -29,103 +35,172 @@ export class SqliteMaterializationWriter {
   }
 
   private applyOverrides(projectId: string, chunk: MaterializationPlanChunk): void {
-    const upsert = (
-      entity: OverrideEntity,
-      item:
-        | (typeof chunk.overrides.objectUpserts)[number]
-        | (typeof chunk.overrides.linkUpserts)[number]
-    ): void => {
-      const kind = entity.kind
-      const key = kind === "object" ? objectRefKey(entity.ref) : linkRefKey(entity.ref)
-      const columns = overrideColumns(entity)
+    for (const item of chunk.overrides.objects.upserts) {
       if (item.expectedLastCommitId === null) {
         try {
           this.db
             .query(
-              `
-                INSERT INTO ontology_overrides (
-                  project_id, entity_kind, entity_key, entity_sort_key,
-                  object_type_id, primary_id, source_type_id, source_primary_id,
-                  link_id, target_type_id, target_primary_id,
-                  value, last_commit_id, updated_at
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, json(?), ?, ?)
-              `
+              `INSERT INTO ontology_object_overrides (
+                 project_id, object_type_id, primary_id, value, last_commit_id, updated_at
+               ) VALUES (?, ?, ?, json(?), ?, ?)`
             )
             .run(
               projectId,
-              kind,
-              key,
-              columns.sortKey,
-              columns.objectTypeId,
-              columns.primaryId,
-              columns.sourceTypeId,
-              columns.sourcePrimaryId,
-              columns.linkId,
-              columns.targetTypeId,
-              columns.targetPrimaryId,
+              item.ref.objectTypeId,
+              item.ref.primaryId,
               canonicalJson(item.value),
               item.lastCommitId,
               item.updatedAt
             )
         } catch (error) {
           if (isSqliteConstraintError(error)) {
-            throw effectiveConflict(`Expected ${kind} override changed.`)
+            throw effectiveConflict("Expected object override changed.")
           }
           throw error
         }
-      } else {
-        requireChanges(
+        continue
+      }
+      requireChanges(
+        this.db
+          .query(
+            `UPDATE ontology_object_overrides
+             SET value = json(?), last_commit_id = ?, updated_at = ?
+             WHERE project_id = ? AND object_type_id = ? AND primary_id = ?
+               AND last_commit_id = ?`
+          )
+          .run(
+            canonicalJson(item.value),
+            item.lastCommitId,
+            item.updatedAt,
+            projectId,
+            item.ref.objectTypeId,
+            item.ref.primaryId,
+            item.expectedLastCommitId
+          ).changes,
+        "effective-state",
+        "Expected object override changed."
+      )
+    }
+    for (const item of chunk.overrides.objects.deletes) {
+      requireChanges(
+        this.db
+          .query(
+            `DELETE FROM ontology_object_overrides
+             WHERE project_id = ? AND object_type_id = ? AND primary_id = ?
+               AND last_commit_id = ?`
+          )
+          .run(projectId, item.ref.objectTypeId, item.ref.primaryId, item.expectedLastCommitId)
+          .changes,
+        "effective-state",
+        "Expected object override changed."
+      )
+    }
+
+    const upsertLink = (
+      identityKind: "edge" | "slot",
+      identityKey: string,
+      ref: {
+        readonly source: { readonly objectTypeId: string; readonly primaryId: string }
+        readonly linkId: string
+        readonly target: { readonly objectTypeId: string; readonly primaryId: string }
+      },
+      item:
+        | (typeof chunk.overrides.links.edges.upserts)[number]
+        | (typeof chunk.overrides.links.slots.upserts)[number]
+    ): void => {
+      if (item.expectedLastCommitId === null) {
+        try {
           this.db
             .query(
-              `
-                UPDATE ontology_overrides
-                SET value = json(?), last_commit_id = ?, updated_at = ?
-                WHERE project_id = ? AND entity_kind = ? AND entity_key = ?
-                  AND last_commit_id = ?
-              `
+              `INSERT INTO ontology_link_overrides (
+                 project_id, identity_kind, identity_key,
+                 source_type_id, source_primary_id, link_id,
+                 target_type_id, target_primary_id, value, last_commit_id, updated_at
+               ) VALUES (?, ?, json(?), ?, ?, ?, ?, ?, json(?), ?, ?)`
             )
             .run(
+              projectId,
+              identityKind,
+              identityKey,
+              ref.source.objectTypeId,
+              ref.source.primaryId,
+              ref.linkId,
+              ref.target.objectTypeId,
+              ref.target.primaryId,
               canonicalJson(item.value),
               item.lastCommitId,
-              item.updatedAt,
-              projectId,
-              kind,
-              key,
-              item.expectedLastCommitId
-            ).changes,
-          "effective-state",
-          `Expected ${kind} override changed.`
-        )
+              item.updatedAt
+            )
+        } catch (error) {
+          if (isSqliteConstraintError(error)) {
+            throw linkOverrideConflict(identityKind)
+          }
+          throw error
+        }
+        return
       }
-    }
-    for (const item of chunk.overrides.objectUpserts) {
-      upsert({ kind: "object", ref: item.ref }, item)
-    }
-    for (const item of chunk.overrides.objectDeletes) {
       requireChanges(
         this.db
           .query(
-            `DELETE FROM ontology_overrides
-             WHERE project_id = ? AND entity_kind = 'object' AND entity_key = ? AND last_commit_id = ?`
+            `UPDATE ontology_link_overrides
+             SET target_type_id = ?, target_primary_id = ?, value = json(?),
+               last_commit_id = ?, updated_at = ?
+             WHERE project_id = ? AND identity_kind = ? AND identity_key = json(?)
+               AND last_commit_id = ?`
           )
-          .run(projectId, objectRefKey(item.ref), item.expectedLastCommitId).changes,
+          .run(
+            ref.target.objectTypeId,
+            ref.target.primaryId,
+            canonicalJson(item.value),
+            item.lastCommitId,
+            item.updatedAt,
+            projectId,
+            identityKind,
+            identityKey,
+            item.expectedLastCommitId
+          ).changes,
         "effective-state",
-        "Expected object override changed."
+        linkOverrideConflictMessage(identityKind)
       )
     }
-    for (const item of chunk.overrides.linkUpserts) {
-      upsert({ kind: "link", ref: item.ref }, item)
+
+    for (const item of chunk.overrides.links.edges.upserts) {
+      upsertLink("edge", linkRefKey(item.ref), item.ref, item)
+    }
+    for (const item of chunk.overrides.links.slots.upserts) {
+      upsertLink(
+        "slot",
+        JSON.stringify([item.ref.source.objectTypeId, item.ref.source.primaryId, item.ref.linkId]),
+        { source: item.ref.source, linkId: item.ref.linkId, target: item.value.target },
+        item
+      )
     }
-    for (const item of chunk.overrides.linkDeletes) {
+
+    const deleteLink = (
+      identityKind: "edge" | "slot",
+      identityKey: string,
+      expectedLastCommitId: string
+    ): void => {
       requireChanges(
         this.db
           .query(
-            `DELETE FROM ontology_overrides
-             WHERE project_id = ? AND entity_kind = 'link' AND entity_key = ? AND last_commit_id = ?`
+            `DELETE FROM ontology_link_overrides
+             WHERE project_id = ? AND identity_kind = ? AND identity_key = json(?)
+               AND last_commit_id = ?`
           )
-          .run(projectId, linkRefKey(item.ref), item.expectedLastCommitId).changes,
+          .run(projectId, identityKind, identityKey, expectedLastCommitId).changes,
         "effective-state",
-        "Expected link override changed."
+        linkOverrideConflictMessage(identityKind)
+      )
+    }
+    for (const item of chunk.overrides.links.edges.deletes) {
+      deleteLink("edge", linkRefKey(item.ref), item.expectedLastCommitId)
+    }
+    for (const item of chunk.overrides.links.slots.deletes) {
+      deleteLink(
+        "slot",
+        JSON.stringify([item.ref.source.objectTypeId, item.ref.source.primaryId, item.ref.linkId]),
+        item.expectedLastCommitId
       )
     }
   }
@@ -366,7 +441,7 @@ export class SqliteMaterializationWriter {
         INSERT INTO ontology_outbox (
           project_id, id, commit_id, commit_ordinal, envelope,
           available_at, attempts, lease_id, lease_expires_at,
-          published_at, last_error, created_at
+          published_at, last_failure, created_at
         ) VALUES (?, ?, ?, ?, json(?), ?, 0, NULL, NULL, NULL, NULL, ?)
       `
     )

package/src/ontology-storage/materializations.ts

@@ -1,6 +1,5 @@
 import type { Database } from "bun:sqlite"
 import type {
-  EffectiveChangeCounts,
   ExpectedLinkRevision,
   ExpectedObjectRevision,
 } from "@sixb/core/internal/materialization"
@@ -30,11 +29,8 @@ import type {
   ApplyMaterializationChunkInput,
   ApplyMaterializationResult,
   FinalizeMaterializationInput,
-  MaterializationCardinalityOccupantWorkRecord,
-  MaterializationClassificationWorkRecord,
   MaterializationObjectExistence,
   MaterializationPlanHeader,
-  MaterializationPlanWorkRecord,
   MaterializationSession,
   MaterializationStatePage,
   MaterializationWorkPage,
@@ -48,14 +44,13 @@ import type {
   StreamMaterializationWorkInput,
   StreamSourceReplacementStateInput,
 } from "@sixb/core/storage"
-import { stableJsonStringify } from "@sixb/core/storage"
+import { yieldSqliteEventLoop } from "../transactions"
 import {
   type SqliteMaterializationSessionState,
   SqliteMaterializationSessions,
   type SqliteOntologyTransactionContext,
 } from "./materialization-session"
 import {
-  linkSortExpression,
   SQLITE_MATERIALIZATION_WORK_TABLE,
   SqliteMaterializationStateReader,
 } from "./materialization-state"
@@ -202,7 +197,6 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
         pageRows: input.pageRows,
       })) {
         this.sessions.require(input.session)
-        this.sessions.recordReplacementIdentities(session, identities)
         const refs = identities.map((identity) => {
           if (identity.kind !== "object") {
             invalidCorrelation("Object replacement returned a link identity.")
@@ -247,7 +241,6 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
       pageRows: input.pageRows,
     })) {
       this.sessions.require(input.session)
-      this.sessions.recordReplacementIdentities(session, identities)
       const linkIdentities = identities.map((identity) => {
         if (identity.kind !== "link") {
           invalidCorrelation("Link replacement returned an object identity.")
@@ -268,6 +261,7 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
 
   async stageWork(input: StageMaterializationWorkInput): Promise<void> {
     this.sessions.stage(input)
+    await yieldSqliteEventLoop()
   }
 
   streamWork(input: StreamMaterializationWorkInput): AsyncIterable<MaterializationWorkPage> {
@@ -286,26 +280,24 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
     const session = this.sessions.require(input.session)
     const { commit } = session.header
     assertPlanChunkCorrelations(input.chunk, commit)
-    const planCount = session.appliedPlanCount
-    const outboxCount = session.appliedOutboxCount
-    this.sessions.assertChunkSequence(session, input.chunk)
+    const sequence = this.sessions.prepareChunkSequence(session, input.chunk)
     this.db.run("SAVEPOINT sixb_ontology_apply_chunk")
     try {
       this.writer.apply(commit.projectId, commit.id, input.chunk)
       this.db.run("RELEASE SAVEPOINT sixb_ontology_apply_chunk")
+      this.sessions.commitChunkSequence(session, sequence)
     } catch (error) {
       this.db.run("ROLLBACK TO SAVEPOINT sixb_ontology_apply_chunk")
       this.db.run("RELEASE SAVEPOINT sixb_ontology_apply_chunk")
-      session.appliedPlanCount = planCount
-      session.appliedOutboxCount = outboxCount
       throw error
     }
+    await yieldSqliteEventLoop()
   }
 
   async finalize(input: FinalizeMaterializationInput): Promise<ApplyMaterializationResult> {
     const session = this.sessions.require(input.session)
     this.assertCommitAbsent(session.header)
-    this.assertFinalization(session, input)
+    await this.assertFinalization(session, input)
     for (const activation of input.finalization.sourceActivations) {
       this.activateSource(session, activation)
     }
@@ -484,16 +476,17 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
     }
   }
 
-  private assertFinalization(
+  private async assertFinalization(
     session: SqliteMaterializationSessionState,
     input: FinalizeMaterializationInput
-  ): void {
+  ): Promise<void> {
     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 outbox = this.db
       .query(
@@ -513,149 +506,85 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
     ) {
       invalidCorrelation("Outbox event ordinals must be contiguous from zero.")
     }
+    await yieldSqliteEventLoop()
 
     if (commit.intent.kind === "telemetry") {
-      const classifiedPoints = this.db
-        .query(
-          `
-            SELECT COUNT(*) AS count FROM ${SQLITE_MATERIALIZATION_WORK_TABLE}
-            WHERE session_id = ? AND kind = 'classification'
-              AND json_extract(payload, '$.entityKind') = 'point'
-          `
-        )
-        .get(session.id) as { readonly count: number }
-      if (classifiedPoints.count !== commit.intent.pointCount) {
+      const summary = this.sessions.telemetrySummary(session, commit.intent.pointCount)
+      await yieldSqliteEventLoop()
+      if (summary.classifiedPoints !== commit.intent.pointCount) {
         invalidCorrelation(
           "Telemetry point classification coverage does not match the commit intent."
         )
       }
-      if (
-        result.kind !== "telemetry" ||
-        !sameCounts(result, this.telemetryCounts(session, commit.intent.pointCount))
-      ) {
+      if (result.kind !== "telemetry" || !sameCounts(result, summary.counts)) {
         invalidCorrelation("Telemetry result counts do not correlate with finalized work.")
       }
     }
     if (commit.intent.kind === "projection") {
       if (result.kind !== "projection") return
       this.sessions.assertClassificationCoverage(session)
-      if (!sameCounts(result.counts, this.projectionCounts(session))) {
+      await yieldSqliteEventLoop()
+      const counts = this.sessions.projectionCounts(session)
+      await yieldSqliteEventLoop()
+      if (!sameCounts(result.counts, counts)) {
         invalidCorrelation("Projection result counts do not correlate with finalized work.")
       }
     }
   }
 
   private assertFinalCardinality(session: SqliteMaterializationSessionState): void {
-    const duplicate = this.db
+    const violation = this.db
       .query(
         `
-          SELECT json_extract(payload, '$.scopeSortKey') AS scope_key
-          FROM ${SQLITE_MATERIALIZATION_WORK_TABLE}
-          WHERE session_id = ? AND kind = 'cardinality'
-            AND json_extract(payload, '$.occupied') = 1
-          GROUP BY scope_key HAVING COUNT(*) > 1 LIMIT 1
+          WITH scopes AS (
+            SELECT sort_one AS scope_sort_key,
+              cardinality_source_type_id AS source_type_id,
+              cardinality_source_primary_id AS source_id,
+              cardinality_link_id AS link_id,
+              SUM(cardinality_occupied) AS expected_count,
+              MAX(CASE WHEN cardinality_occupied = 1
+                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'
+              AND cardinality_view = 'effective'
+            GROUP BY sort_one, cardinality_source_type_id,
+              cardinality_source_primary_id, cardinality_link_id
+          ), validated AS (
+            SELECT scopes.scope_sort_key, scopes.expected_count,
+              COUNT(links.source_id) AS actual_count,
+              COUNT(links.source_id) FILTER (
+                WHERE links.target_type_id = scopes.expected_target_type_id
+                  AND links.target_id = scopes.expected_target_id
+              ) AS matching_count
+            FROM scopes
+            LEFT JOIN links
+              ON links.project_id = ?
+             AND links.source_type_id = scopes.source_type_id
+             AND links.source_id = scopes.source_id
+             AND links.link_id = scopes.link_id
+            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
+          FROM validated
+          WHERE expected_count > 1
+            OR actual_count <> expected_count
+            OR matching_count <> expected_count
+          LIMIT 1
         `
       )
-      .get(session.id)
-    if (duplicate) {
+      .get(session.id, session.header.commit.projectId) as {
+      readonly reason: "duplicate" | "mismatch"
+    } | null
+    if (violation?.reason === "duplicate") {
       invalidCorrelation("Materialization cardinality work violates cardinality-one.")
     }
-    const records = this.sessions.records(
-      session,
-      "cardinality"
-    ) as MaterializationCardinalityOccupantWorkRecord[]
-    const scopes = new Map<string, MaterializationCardinalityOccupantWorkRecord>()
-    for (const record of records) scopes.set(record.scopeSortKey, record)
-    for (const record of scopes.values()) {
-      const effective = this.db
-        .query(
-          `
-            SELECT ${linkSortExpression()} AS sort_key FROM links
-            WHERE project_id = ? AND source_type_id = ? AND source_id = ? AND link_id = ?
-            ORDER BY sort_key
-          `
-        )
-        .all(
-          session.header.commit.projectId,
-          record.ref.source.objectTypeId,
-          record.ref.source.primaryId,
-          record.ref.linkId
-        ) as { readonly sort_key: string }[]
-      const occupied = records
-        .filter((candidate) => candidate.scopeSortKey === record.scopeSortKey && candidate.occupied)
-        .map((candidate) => candidate.linkSortKey)
-        .sort()
-      if (
-        stableJsonStringify(effective.map((row) => row.sort_key)) !== stableJsonStringify(occupied)
-      ) {
-        invalidCorrelation(
-          "Materialization cardinality work does not match the final effective link scope."
-        )
-      }
-    }
-  }
-
-  private projectionCounts(session: SqliteMaterializationSessionState): EffectiveChangeCounts {
-    const classifications = this.sessions.records(
-      session,
-      "classification"
-    ) as MaterializationClassificationWorkRecord[]
-    const plans = this.sessions.records(session, "plan") as MaterializationPlanWorkRecord[]
-    const counts: MutableEffectiveChangeCounts = {
-      objectsCreated: 0,
-      objectsUpdated: 0,
-      objectsDeleted: 0,
-      objectsUnchanged: classifications.filter((record) => record.entityKind === "object").length,
-      linksCreated: 0,
-      linksUpdated: 0,
-      linksDeleted: 0,
-      linksUnchanged: classifications.filter((record) => record.entityKind === "link").length,
-    }
-    for (const record of plans) {
-      switch (record.item.kind) {
-        case "object-upsert":
-          if (record.item.value.expected.exists) counts.objectsUpdated += 1
-          else counts.objectsCreated += 1
-          counts.objectsUnchanged -= 1
-          break
-        case "object-delete":
-          counts.objectsDeleted += 1
-          counts.objectsUnchanged -= 1
-          break
-        case "link-upsert":
-          if (record.item.value.expected.exists) counts.linksUpdated += 1
-          else counts.linksCreated += 1
-          counts.linksUnchanged -= 1
-          break
-        case "link-delete":
-          counts.linksDeleted += 1
-          counts.linksUnchanged -= 1
-          break
-      }
-    }
-    return counts
-  }
-
-  private telemetryCounts(session: SqliteMaterializationSessionState, pointCount: number) {
-    let pointsCreated = 0
-    let pointsUpdated = 0
-    let latestObjectsChanged = 0
-    for (const record of this.sessions.records(
-      session,
-      "plan"
-    ) as MaterializationPlanWorkRecord[]) {
-      if (record.item.kind === "point-upsert") {
-        if (record.item.value.expected.lastCommitId === null) pointsCreated += 1
-        else pointsUpdated += 1
-      } else if (record.item.kind === "object-upsert") {
-        latestObjectsChanged += 1
-      }
-    }
-    return {
-      pointsCreated,
-      pointsUpdated,
-      pointsUnchanged: pointCount - pointsCreated - pointsUpdated,
-      latestObjectsChanged,
+    if (violation) {
+      invalidCorrelation(
+        "Materialization cardinality work does not match the final effective link scope."
+      )
     }
   }
 
@@ -771,11 +700,11 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
         .query(
           `
             INSERT INTO ontology_commits (
-              project_id, id, idempotency_key, request_hash,
+              project_id, id, idempotency_key, request_hash, execution_id,
               origin_kind, origin_run_id, origin_batch_ordinal, origin, actor,
               ontology_revision, projection_revision, ownership_hash,
               intent, result, committed_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, json(?), json(?), ?, ?, ?, json(?), json(?), ?)
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, json(?), json(?), ?, ?, ?, json(?), json(?), ?)
           `
         )
         .run(
@@ -783,6 +712,7 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
           commit.id,
           commit.idempotencyKey,
           commit.requestHash,
+          commit.executionId,
           origin.kind,
           origin.runId,
           origin.batchOrdinal,
@@ -832,7 +762,3 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
       .get(projectId, sourceId, materializationId) as SqliteOntologySourceRow | null
   }
 }
-
-type MutableEffectiveChangeCounts = {
-  -readonly [TKey in keyof EffectiveChangeCounts]: EffectiveChangeCounts[TKey]
-}

package/src/ontology-storage/outbox.ts

@@ -1,4 +1,5 @@
 import type { Database } from "bun:sqlite"
+import { serializeSixbFailure } from "@sixb/core/internal/errors"
 import {
   MaterializationConflictError,
   MaterializationValidationError,
@@ -13,6 +14,7 @@ import type {
   RescheduleOntologyOutboxLeaseInput,
   SummarizeOntologyOutboxInput,
 } from "@sixb/core/storage"
+import { ONTOLOGY_OUTBOX_FAILURE_CODES } from "@sixb/core/storage"
 import {
   assertNonblank,
   assertPositiveInteger,
@@ -55,7 +57,7 @@ export class SqliteOntologyOutboxStorage implements OntologyOutboxStorage {
               LIMIT ?
             )
             RETURNING envelope, available_at, attempts, lease_id, lease_expires_at,
-              published_at, last_error, created_at
+              published_at, last_failure, created_at
           `
         )
         .all(
@@ -127,6 +129,10 @@ export class SqliteOntologyOutboxStorage implements OntologyOutboxStorage {
       assertLeaseInput(input)
       assertTimestamp(input.availableAt, "Ontology outbox availableAt")
       const ids = validateLeaseIds(input.ids)
+      const failure =
+        input.failure === undefined
+          ? null
+          : serializeSixbFailure(input.failure, ONTOLOGY_OUTBOX_FAILURE_CODES)
       const changed = this.db
         .query(
           `
@@ -141,7 +147,8 @@ export class SqliteOntologyOutboxStorage implements OntologyOutboxStorage {
               SELECT id FROM leased WHERE (SELECT COUNT(*) FROM leased) = ?
             )
             UPDATE ontology_outbox
-            SET available_at = ?, last_error = ?, lease_id = NULL, lease_expires_at = NULL
+            SET available_at = ?, last_failure = COALESCE(?, last_failure),
+              lease_id = NULL, lease_expires_at = NULL
             WHERE project_id = ? AND id IN (SELECT id FROM eligible)
               AND lease_id = ? AND lease_expires_at IS NOT NULL
           `
@@ -152,7 +159,7 @@ export class SqliteOntologyOutboxStorage implements OntologyOutboxStorage {
           input.leaseId,
           ids.length,
           input.availableAt,
-          input.error,
+          failure,
           input.projectId,
           input.leaseId
         ).changes