@askdkc/kiokuko 0.1.17 → 0.1.19

package/dist/context/delivery.js

@@ -1,19 +1,25 @@
 import { withImmediateTransaction } from '../db/transaction.js';
 import { KiokukoError } from '../errors.js';
-import { CONTEXT_RANKING_COMPONENTS, CONTEXT_RANKING_COMPONENTS_V2, CONTEXT_SELECTION_REASON_ORDER, } from './ranking.js';
-import { sanitizeJson } from '../security/sanitize.js';
-import { canonicalJson } from '../serialization/validate.js';
+import { CONTEXT_RANKING_VERSION, CONTEXT_RANKING_COMPONENTS, CONTEXT_RANKING_COMPONENTS_V2, CONTEXT_SELECTION_REASON_ORDER, } from './ranking.js';
+import { canonicalContentHash, canonicalJson } from '../serialization/validate.js';
+import { effectiveRetrievalScope, hasExplicitApplicability, } from '../memory/structured-memory.js';
+import { readEntry } from '../memory/entries.js';
+import { isRetrievableEntry } from '../memory/hybrid-retrieval.js';
 import { entryOriginMatchesWorkspace, isContextEntryOrigin } from './origin.js';
+import { RUN_STATUSES } from '../ledger/types.js';
+import { RECOMMENDATION_POLICY_VERSION } from './recommendations.js';
+import { readContextRunProfileBinding } from './run-state.js';
 const MAX_IDENTIFIER_BYTES = 256;
 const MAX_ITEMS = 100;
 const MAX_SCORE_COMPONENT = 1_000_000;
 const MAX_CHAR_BUDGET = 100_000;
-const MAX_EXTERNAL_SUMMARY_BYTES = 16 * 1024;
-const MAX_EXTERNAL_ERROR_BYTES = 1024;
-const MAX_SOURCES = 16;
 const MAX_LIMIT = 100;
 const DEFAULT_LIMIT = 100;
 const DELIVERY_CURSOR_VERSION = 1;
+// The persisted score schema is the mode discriminant: v1 is the generic
+// broker contract and v2 is the scoped broker contract.
+const GENERIC_DELIVERY_POLICY_VERSION = `${CONTEXT_RANKING_VERSION}+${RECOMMENDATION_POLICY_VERSION}`;
+const SCOPED_DELIVERY_POLICY_VERSION = 'context-ranking-v4';
 const VALIDATION_MESSAGE = 'Context delivery input is invalid';
 const NOT_FOUND_MESSAGE = 'Context delivery target was not found';
 const CONFLICT_MESSAGE = 'Context delivery conflicts with existing record';
@@ -37,15 +43,47 @@ function databaseFailure() {
 function integrity() {
     return fail('INTEGRITY_ERROR', INTEGRITY_MESSAGE);
 }
+function scopedIdentityIntegrity() {
+    return fail('INTEGRITY_ERROR', 'Stored scoped context character accounting is invalid');
+}
 function isKiokukoError(error) {
     return error instanceof KiokukoError;
 }
-function normalizeDatabaseError(error) {
+const SQLITE_CONSTRAINT_PRIMARY_KEY = 1_555;
+const SQLITE_CONSTRAINT_UNIQUE = 2_067;
+const NO_UNIQUENESS_FAILURES = new Set();
+const SQLITE_OPERATIONAL_PRIMARY_CODES = new Set([5, 6, 7, 8, 9, 10, 13, 14, 15, 22, 23]);
+const SQLITE_INTEGRITY_PRIMARY_CODES = new Set([11, 24, 26]);
+const DELIVERY_UNIQUENESS_FAILURES = new Set([
+    'UNIQUE constraint failed: context_deliveries.delivery_id',
+    'UNIQUE constraint failed: context_delivery_entries.delivery_id, context_delivery_entries.entry_id',
+]);
+function nodeSqliteFailure(error) {
+    if (!(error instanceof Error))
+        return null;
+    const failure = error;
+    if (failure.code !== 'ERR_SQLITE_ERROR'
+        || typeof failure.errcode !== 'number'
+        || !Number.isSafeInteger(failure.errcode)
+        || failure.errcode < 0)
+        return null;
+    return failure;
+}
+function normalizeDatabaseError(error, uniquenessFailures = NO_UNIQUENESS_FAILURES) {
     if (isKiokukoError(error))
         throw error;
-    if (error instanceof Error && /unique|constraint/i.test(error.message))
+    const failure = nodeSqliteFailure(error);
+    if (failure === null)
+        throw error;
+    if ((failure.errcode === SQLITE_CONSTRAINT_PRIMARY_KEY || failure.errcode === SQLITE_CONSTRAINT_UNIQUE)
+        && uniquenessFailures.has(failure.message))
         conflict();
-    databaseFailure();
+    const primaryResultCode = failure.errcode & 0xff;
+    if (SQLITE_INTEGRITY_PRIMARY_CODES.has(primaryResultCode))
+        integrity();
+    if (SQLITE_OPERATIONAL_PRIMARY_CODES.has(primaryResultCode))
+        databaseFailure();
+    throw error;
 }
 function isPlainObject(value) {
     try {
@@ -157,6 +195,14 @@ function positiveSafeInteger(value) {
         validation();
     return value;
 }
+function validatedScoreSchemaVersion(value, onInvalid) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || (value !== 1 && value !== 2))
+        onInvalid();
+    return value;
+}
+function deliveryPolicyVersion(version) {
+    return version === 1 ? GENERIC_DELIVERY_POLICY_VERSION : SCOPED_DELIVERY_POLICY_VERSION;
+}
 function storedNonNegativeSafeInteger(value) {
     if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0)
         integrity();
@@ -277,74 +323,14 @@ function validateDeliveryItems(value, scoreSchemaVersion) {
         };
     });
 }
-function sanitizeExternalError(value, workspace) {
-    if (typeof value !== 'string' || value.length === 0)
-        validation();
-    let sanitized;
-    try {
-        sanitized = sanitizeJson({ error: value }, { workspace }).value;
-    }
-    catch {
-        validation();
-    }
-    if (!isPlainObject(sanitized))
-        validation();
-    const error = readField(sanitized, 'error');
-    if (typeof error !== 'string' || error.length === 0 || Buffer.byteLength(error, 'utf8') > MAX_EXTERNAL_ERROR_BYTES)
-        validation();
-    return error;
-}
-function validateExternalSummary(value, workspace) {
-    const object = objectInput(value, ['attempted', 'imported', 'sources'], true);
-    const attempted = booleanValue(readField(object, 'attempted'));
-    const imported = nonNegativeSafeInteger(readField(object, 'imported'));
-    const sourceArray = arrayInput(readField(object, 'sources'));
-    if (sourceArray.length > MAX_SOURCES)
-        validation();
-    const sourceIds = new Set();
-    const sources = sourceArray.map((source) => {
-        const sourceObject = objectInput(source, ['sourceId', 'commit', 'documents', 'imported', 'error'], false);
-        for (const field of ['sourceId', 'commit', 'documents', 'imported']) {
-            if (!hasOwn(sourceObject, field))
-                validation();
-        }
-        const sourceId = boundedIdentifier(readField(sourceObject, 'sourceId'));
-        if (sourceIds.has(sourceId))
-            validation();
-        sourceIds.add(sourceId);
-        const rawCommit = readField(sourceObject, 'commit');
-        const commit = rawCommit === null
-            ? null
-            : typeof rawCommit === 'string' && rawCommit.length > 0 && /^[0-9a-f]+$/u.test(rawCommit) && Buffer.byteLength(rawCommit, 'utf8') <= MAX_IDENTIFIER_BYTES
-                ? rawCommit
-                : validation();
-        const documents = nonNegativeSafeInteger(readField(sourceObject, 'documents'));
-        const sourceImported = nonNegativeSafeInteger(readField(sourceObject, 'imported'));
-        if (sourceImported > documents)
-            validation();
-        const result = { sourceId, commit, documents, imported: sourceImported };
-        if (hasOwn(sourceObject, 'error'))
-            result.error = sanitizeExternalError(readField(sourceObject, 'error'), workspace);
-        return result;
-    });
-    if (!attempted && (imported !== 0 || sources.length !== 0))
-        validation();
-    const sourceTotal = sources.reduce((total, source) => total + source.imported, 0);
-    if (imported !== sourceTotal)
-        validation();
-    const summary = { attempted, imported, sources };
-    if (Buffer.byteLength(canonicalJson(summary), 'utf8') > MAX_EXTERNAL_SUMMARY_BYTES)
-        validation();
-    return summary;
-}
 function validateContextDeliveryInput(value) {
     try {
         const object = objectInput(value, [
             'workspace', 'deliveryId', 'runId', 'throughSequence', 'intakeSessionId', 'taskProfileHash',
-            'queryHash', 'policyVersion', 'externalSyncSummary', 'charBudget', 'charCount', 'truncated',
+            'queryHash', 'policyVersion', 'charBudget', 'charCount', 'truncated',
             'createdAt', 'items', 'scoreSchemaVersion',
         ], false);
-        for (const field of ['workspace', 'deliveryId', 'runId', 'throughSequence', 'intakeSessionId', 'taskProfileHash', 'queryHash', 'policyVersion', 'externalSyncSummary', 'charBudget', 'charCount', 'truncated', 'createdAt', 'items']) {
+        for (const field of ['workspace', 'deliveryId', 'runId', 'throughSequence', 'intakeSessionId', 'taskProfileHash', 'queryHash', 'policyVersion', 'charBudget', 'charCount', 'truncated', 'createdAt', 'items']) {
             if (!hasOwn(object, field))
                 validation();
         }
@@ -357,7 +343,6 @@ function validateContextDeliveryInput(value) {
         const taskProfileHash = hash(readField(object, 'taskProfileHash'));
         const queryHash = hash(readField(object, 'queryHash'));
         const policyVersion = boundedIdentifier(readField(object, 'policyVersion'));
-        const externalSyncSummary = validateExternalSummary(readField(object, 'externalSyncSummary'), workspace);
         const charBudget = readField(object, 'charBudget');
         if (typeof charBudget !== 'number' || !Number.isSafeInteger(charBudget) || charBudget < 1 || charBudget > MAX_CHAR_BUDGET)
             validation();
@@ -366,8 +351,10 @@ function validateContextDeliveryInput(value) {
             validation();
         const truncated = booleanValue(readField(object, 'truncated'));
         const createdAt = timestamp(readField(object, 'createdAt'));
-        const scoreSchemaVersion = object.scoreSchemaVersion === undefined ? undefined : positiveSafeInteger(object.scoreSchemaVersion);
-        const items = validateDeliveryItems(readField(object, 'items'), scoreSchemaVersion ?? 1);
+        const parsedScoreSchemaVersion = validatedScoreSchemaVersion(object.scoreSchemaVersion === undefined ? 1 : object.scoreSchemaVersion, validation);
+        if (policyVersion !== deliveryPolicyVersion(parsedScoreSchemaVersion))
+            validation();
+        const items = validateDeliveryItems(readField(object, 'items'), parsedScoreSchemaVersion);
         return {
             workspace,
             deliveryId,
@@ -377,13 +364,12 @@ function validateContextDeliveryInput(value) {
             taskProfileHash,
             queryHash,
             policyVersion,
-            externalSyncSummary,
             charBudget,
             charCount,
             truncated,
             createdAt,
             items,
-            ...(scoreSchemaVersion === undefined ? {} : { scoreSchemaVersion }),
+            ...(object.scoreSchemaVersion === undefined ? {} : { scoreSchemaVersion: parsedScoreSchemaVersion }),
         };
     }
     catch {
@@ -461,7 +447,6 @@ function canonicalDeliveryBody(input) {
         taskProfileHash: input.taskProfileHash,
         queryHash: input.queryHash,
         policyVersion: input.policyVersion,
-        externalSyncSummary: input.externalSyncSummary,
         charBudget: input.charBudget,
         charCount: input.charCount,
         truncated: input.truncated,
@@ -477,56 +462,111 @@ function canonicalDeliveryBody(input) {
         scoreSchemaVersion: input.scoreSchemaVersion ?? 1,
     });
 }
+function scopedDeliveryId(input) {
+    return `context-${canonicalContentHash({
+        kind: 'scoped-context-delivery-v1',
+        workspace: input.workspace,
+        runId: input.runId,
+        throughSequence: input.throughSequence,
+        intakeSessionId: input.intakeSessionId,
+        taskProfileHash: input.taskProfileHash,
+        queryHash: input.queryHash,
+        policyVersion: input.policyVersion,
+        charBudget: input.charBudget,
+        charCount: input.charCount,
+        truncated: input.truncated,
+        createdAt: input.createdAt,
+        scoreSchemaVersion: input.scoreSchemaVersion ?? 1,
+        items: input.items.map((item) => ({
+            entryId: item.entryId,
+            entryRevision: item.entryRevision,
+            rank: item.rank,
+            scoreComponents: item.scoreComponents,
+            selectionReasons: item.selectionReasons,
+            ...(item.origin === undefined ? {} : { origin: item.origin }),
+        })),
+    })}`;
+}
 function selectHeaderByDeliveryId(database, deliveryId) {
     return database.prepare(`
     SELECT cd.delivery_id, cd.run_id, cd.through_sequence, cd.intake_session_id,
            cd.task_profile_hash, cd.query_hash, cd.policy_version,
-           cd.external_sync_summary_json, cd.char_budget, cd.char_count,
-           cd.truncated, cd.created_at, cd.score_schema_version,
+           cd.char_budget, cd.char_count, cd.truncated, cd.created_at, cd.score_schema_version,
            lr.workspace AS run_workspace, lr.last_sequence AS run_last_sequence
       FROM context_deliveries AS cd
       LEFT JOIN ledger_runs AS lr ON lr.run_id = cd.run_id
      WHERE cd.delivery_id = ?
   `).get(deliveryId);
 }
+function strictCurrentEntry(database, workspace, entryId, requireStructuredScope) {
+    try {
+        return readEntry(database, { workspace, entryId }, { requireStructuredScope });
+    }
+    catch (error) {
+        if (isKiokukoError(error) && error.code === 'INTEGRITY_ERROR')
+            integrity();
+        throw error;
+    }
+}
 function assertRunForWrite(database, input) {
-    const run = database.prepare('SELECT run_id, last_sequence FROM ledger_runs WHERE run_id = ? AND workspace = ?').get(input.runId, input.workspace);
+    const run = database.prepare('SELECT run_id, status, last_sequence FROM ledger_runs WHERE run_id = ? AND workspace = ?')
+        .get(input.runId, input.workspace);
     if (!run)
         notFound();
     if (typeof run.run_id !== 'string')
         integrity();
+    if (typeof run.status !== 'string' || !RUN_STATUSES.includes(run.status))
+        integrity();
     const lastSequence = storedNonNegativeSafeInteger(run.last_sequence);
-    if (input.throughSequence > lastSequence)
+    if (run.status !== 'active' || input.throughSequence !== lastSequence)
         conflict();
-    if (input.intakeSessionId !== null) {
-        const intake = database.prepare(`
-      SELECT ri.session_id, s.id AS session_id_join, s.workspace AS session_workspace
-        FROM run_intakes AS ri
-        LEFT JOIN akinator_sessions AS s ON s.id = ri.session_id
-       WHERE ri.run_id = ?
-    `).get(input.runId);
-        if (!intake || intake.session_id !== input.intakeSessionId || intake.session_id_join !== input.intakeSessionId || intake.session_workspace !== input.workspace)
-            notFound();
+    let binding;
+    try {
+        binding = readContextRunProfileBinding(database, input.runId, input.throughSequence);
     }
+    catch (error) {
+        if (isKiokukoError(error) && (error.code === 'NOT_FOUND' || error.code === 'INTEGRITY_ERROR'))
+            integrity();
+        throw error;
+    }
+    if (binding.workspace !== input.workspace)
+        integrity();
+    if (input.intakeSessionId !== binding.intakeSessionId)
+        notFound();
+    if (input.taskProfileHash !== binding.profileHash)
+        conflict();
     for (const item of input.items) {
-        const entry = database.prepare(`
-      SELECT e.id, e.workspace, r.workspace AS revision_workspace, r.scope_json
+        const candidate = database.prepare(`
+      SELECT e.id, e.workspace, r.workspace AS revision_workspace
         FROM entry_revisions AS r
         JOIN entries AS e ON e.id = r.entry_id
        WHERE r.entry_id = ? AND r.revision = ?
     `).get(item.entryId, item.entryRevision);
-        if (!entry || entry.id !== item.entryId)
+        if (!candidate || candidate.id !== item.entryId)
             notFound();
-        const entryWorkspace = typeof entry.workspace === 'string' ? entry.workspace : notFound();
+        if (typeof candidate.workspace !== 'string' || candidate.workspace.length === 0)
+            integrity();
+        const entryWorkspace = candidate.workspace;
         const origin = item.origin ?? 'project';
-        if (entry.revision_workspace !== entryWorkspace || !entryOriginMatchesWorkspace({ origin, runWorkspace: input.workspace, entryWorkspace }))
+        if (candidate.revision_workspace !== entryWorkspace)
+            integrity();
+        const entry = strictCurrentEntry(database, entryWorkspace, item.entryId, origin !== 'project');
+        if (entry.revision !== item.entryRevision)
+            conflict();
+        if (!isRetrievableEntry(database, entry) || entry.status === 'superseded')
+            conflict();
+        if (!entryOriginMatchesWorkspace({ origin, runWorkspace: input.workspace, entryWorkspace: entry.workspace }))
             notFound();
         if (origin === 'global') {
-            if (entry.workspace !== 'global' || typeof entry.scope_json !== 'string' || !/"visibility"\s*:\s*"global"/u.test(entry.scope_json))
+            if (entry.workspace !== 'global' || entry.scope.visibility !== 'global' || effectiveRetrievalScope(entry.scope) !== 'global')
+                notFound();
+        }
+        else if (origin === 'ecosystem') {
+            if (!hasOwn(entry.scope, 'retrievalScope')
+                || effectiveRetrievalScope(entry.scope) !== 'ecosystem'
+                || !hasExplicitApplicability(entry.scope))
                 notFound();
         }
-        else if (origin === 'ecosystem' && (typeof entry.scope_json !== 'string' || (!/"retrievalScope"\s*:\s*"ecosystem"/u.test(entry.scope_json) && !/"applicability"\s*:/u.test(entry.scope_json))))
-            notFound();
     }
 }
 function validateStoredJson(value) {
@@ -536,31 +576,24 @@ function validateStoredJson(value) {
     try {
         parsed = JSON.parse(value);
     }
-    catch {
-        integrity();
-    }
-    try {
-        if (canonicalJson(parsed) !== value)
+    catch (error) {
+        if (error instanceof SyntaxError || error instanceof RangeError)
             integrity();
+        throw error;
     }
-    catch {
-        integrity();
-    }
-    return parsed;
-}
-function validateStoredExternalSummary(value, workspace) {
+    let canonical;
     try {
-        const parsed = validateStoredJson(value);
-        const normalized = validateExternalSummary(parsed, workspace);
-        if (canonicalJson(normalized) !== value)
-            integrity();
-        return normalized;
+        canonical = canonicalJson(parsed);
     }
     catch (error) {
-        if (isKiokukoError(error) && error.code === 'INTEGRITY_ERROR')
-            throw error;
-        integrity();
+        if (error instanceof RangeError
+            || (error instanceof KiokukoError && error.code === 'VALIDATION_ERROR'))
+            integrity();
+        throw error;
     }
+    if (canonical !== value)
+        integrity();
+    return parsed;
 }
 function validateStoredHeader(row, workspace) {
     const deliveryId = boundedStoredIdentifier(row.delivery_id);
@@ -577,8 +610,9 @@ function validateStoredHeader(row, workspace) {
     const taskProfileHash = storedHash(row.task_profile_hash);
     const queryHash = storedHash(row.query_hash);
     const policyVersion = boundedStoredIdentifier(row.policy_version);
-    const scoreSchemaVersion = storedPositiveSafeInteger(row.score_schema_version);
-    const externalSyncSummary = validateStoredExternalSummary(row.external_sync_summary_json, workspace);
+    const scoreSchemaVersion = validatedScoreSchemaVersion(row.score_schema_version, integrity);
+    if (policyVersion !== deliveryPolicyVersion(scoreSchemaVersion))
+        integrity();
     const charBudget = storedPositiveSafeInteger(row.char_budget);
     if (charBudget > MAX_CHAR_BUDGET)
         integrity();
@@ -596,7 +630,6 @@ function validateStoredHeader(row, workspace) {
         taskProfileHash,
         queryHash,
         policyVersion,
-        externalSyncSummary,
         charBudget,
         charCount,
         truncated,
@@ -651,16 +684,19 @@ function validateStoredEntries(database, header) {
         return { entryId, entryRevision, rank, scoreComponents: score, selectionReasons: reasons, ...(origin === 'project' ? {} : { origin }) };
     });
 }
-function assertStoredIntakeLink(database, header) {
-    if (header.intakeSessionId === null)
-        return;
-    const intake = database.prepare(`
-    SELECT ri.run_id, ri.session_id, s.id AS session_id_join, s.workspace AS session_workspace
-      FROM run_intakes AS ri
-      LEFT JOIN akinator_sessions AS s ON s.id = ri.session_id
-     WHERE ri.run_id = ?
-  `).get(header.runId);
-    if (!intake || intake.run_id !== header.runId || intake.session_id !== header.intakeSessionId || intake.session_id_join !== header.intakeSessionId || intake.session_workspace !== header.workspace)
+function assertStoredProfileBinding(database, header) {
+    let binding;
+    try {
+        binding = readContextRunProfileBinding(database, header.runId, header.throughSequence);
+    }
+    catch (error) {
+        if (isKiokukoError(error) && (error.code === 'NOT_FOUND' || error.code === 'INTEGRITY_ERROR'))
+            integrity();
+        throw error;
+    }
+    if (binding.workspace !== header.workspace
+        || header.intakeSessionId !== binding.intakeSessionId
+        || header.taskProfileHash !== binding.profileHash)
         integrity();
 }
 function readStoredDelivery(database, workspace, deliveryId) {
@@ -672,33 +708,40 @@ function readStoredDelivery(database, workspace, deliveryId) {
     if (row.run_workspace !== workspace)
         notFound();
     const header = validateStoredHeader(row, workspace);
-    assertStoredIntakeLink(database, header);
+    assertStoredProfileBinding(database, header);
     const items = validateStoredEntries(database, header);
+    const complete = { ...header, items };
+    if ((header.scoreSchemaVersion ?? 1) === 2 && header.deliveryId !== scopedDeliveryId(complete))
+        scopedIdentityIntegrity();
     const view = {
-        ...header,
+        ...complete,
         items: items.map((item) => ({ ...item, scoreComponents: { ...item.scoreComponents }, selectionReasons: [...item.selectionReasons], untrusted: true })),
         untrusted: true,
     };
     return view;
 }
-function writeContextDelivery(database, input) {
+function writeContextDelivery(database, input, options = {}) {
+    if ((input.scoreSchemaVersion ?? 1) === 2 && input.deliveryId !== scopedDeliveryId(input))
+        validation();
+    assertRunForWrite(database, input);
     const existing = selectHeaderByDeliveryId(database, input.deliveryId);
     if (existing) {
         if (existing.run_workspace !== input.workspace)
             conflict();
         const stored = readStoredDelivery(database, input.workspace, input.deliveryId);
-        if (canonicalDeliveryBody(stored) === canonicalDeliveryBody(input))
+        if (canonicalDeliveryBody(stored) === canonicalDeliveryBody(input)) {
+            options.assertBeforePersist?.();
             return stored;
+        }
         conflict();
     }
-    assertRunForWrite(database, input);
-    const summaryJson = canonicalJson(input.externalSyncSummary);
+    options.assertBeforePersist?.();
     database.prepare(`
     INSERT INTO context_deliveries (
       delivery_id, run_id, through_sequence, intake_session_id, task_profile_hash, query_hash,
       policy_version, external_sync_summary_json, char_budget, char_count, truncated, created_at, score_schema_version
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(input.deliveryId, input.runId, input.throughSequence, input.intakeSessionId, input.taskProfileHash, input.queryHash, input.policyVersion, summaryJson, input.charBudget, input.charCount, input.truncated ? 1 : 0, input.createdAt, input.scoreSchemaVersion ?? 1);
+  `).run(input.deliveryId, input.runId, input.throughSequence, input.intakeSessionId, input.taskProfileHash, input.queryHash, input.policyVersion, '{}', input.charBudget, input.charCount, input.truncated ? 1 : 0, input.createdAt, input.scoreSchemaVersion ?? 1);
     for (const item of input.items) {
         database.prepare(`
       INSERT INTO context_delivery_entries (
@@ -708,22 +751,26 @@ function writeContextDelivery(database, input) {
     }
     return readStoredDelivery(database, input.workspace, input.deliveryId);
 }
-export function recordContextDeliveryInTransaction(database, input) {
+export function recordContextDeliveryInTransaction(database, input, options = {}) {
     const validated = validateContextDeliveryInput(input);
+    if (options.assertBeforePersist !== undefined && typeof options.assertBeforePersist !== 'function')
+        validation();
     try {
-        return writeContextDelivery(database, validated);
+        return writeContextDelivery(database, validated, options);
     }
     catch (error) {
-        normalizeDatabaseError(error);
+        normalizeDatabaseError(error, DELIVERY_UNIQUENESS_FAILURES);
     }
 }
-export function recordContextDelivery(database, input) {
+export function recordContextDelivery(database, input, options = {}) {
     const validated = validateContextDeliveryInput(input);
+    if (options.assertBeforePersist !== undefined && typeof options.assertBeforePersist !== 'function')
+        validation();
     try {
-        return withImmediateTransaction(database, () => writeContextDelivery(database, validated));
+        return withImmediateTransaction(database, () => writeContextDelivery(database, validated, options));
     }
     catch (error) {
-        normalizeDatabaseError(error);
+        normalizeDatabaseError(error, DELIVERY_UNIQUENESS_FAILURES);
     }
 }
 export function readContextDelivery(database, input) {
@@ -754,8 +801,7 @@ export function listContextDeliveries(database, input) {
         const rows = database.prepare(`
       SELECT cd.delivery_id, cd.run_id, cd.through_sequence, cd.intake_session_id,
              cd.task_profile_hash, cd.query_hash, cd.policy_version,
-             cd.external_sync_summary_json, cd.char_budget, cd.char_count,
-             cd.truncated, cd.created_at, cd.score_schema_version,
+             cd.char_budget, cd.char_count, cd.truncated, cd.created_at, cd.score_schema_version,
              lr.workspace AS run_workspace, lr.last_sequence AS run_last_sequence
         FROM context_deliveries AS cd
         LEFT JOIN ledger_runs AS lr ON lr.run_id = cd.run_id
@@ -766,10 +812,13 @@ export function listContextDeliveries(database, input) {
         const pageRows = rows.slice(0, validated.limit);
         const items = pageRows.map((row) => {
             const header = validateStoredHeader(row, validated.workspace);
-            assertStoredIntakeLink(database, header);
+            assertStoredProfileBinding(database, header);
             const storedItems = validateStoredEntries(database, header);
+            const complete = { ...header, items: storedItems };
+            if ((header.scoreSchemaVersion ?? 1) === 2 && header.deliveryId !== scopedDeliveryId(complete))
+                scopedIdentityIntegrity();
             return {
-                ...header,
+                ...complete,
                 items: storedItems.map((item) => ({ ...item, scoreComponents: { ...item.scoreComponents }, selectionReasons: [...item.selectionReasons], untrusted: true })),
                 untrusted: true,
             };