@dsh-enhanced/assistant-delivery 0.1.47 → 0.1.49

package/lib/store.js

@@ -4,10 +4,26 @@ import { acceptanceCanonicalJson } from '@dsh-enhanced/task-acceptance-contract'
 import { ASSISTANT_GROWTH_CONTRACT_VERSION, WORKFLOW_TRACE_SOURCE_ID, growthObjectDigest, validateResolvedWorkflowAutomationTemplate, validateWorkflowAutomationTemplate, validateWorkflowAutomationTemplateContent, validateWorkflowTraceRevision, workflowAutomationTemplateContentDigest, workflowArgumentShapeDigest, workflowScopeKey, workflowTraceRevisionDigest, WORKFLOW_OWNER_ANCHORED_PLACEHOLDER_SCHEDULE, } from '@dsh-enhanced/assistant-growth-contract';
 import { bindingMatchesOwnerRoute, canonicalBackgroundSourceId, canonicalConversation, canonicalLocalOperatorId, canonicalOwnerRouteAuthority, canonicalPrincipal, canonicalTarget, externalPrincipalId, ownerRouteAuthorityHash, ownerRouteBindingSnapshot, } from './canonical.js';
 import { feedbackDispatchRecoveryCode, isFeedbackDeliveryCommand, isFeedbackDispatchRecoveryCode, isExactDeliveryCommand, isLearningDeliveryCommand, isLearningDispatchRecoveryCode, isLearningRetryableFailureCode, isPermissionDeliveryCommand, isWorkflowDeliveryCommand, isWorkflowDispatchRecoveryCode, learningDispatchRecoveryCode, parseDeliveryCommand, permissionDispatchRecoveryCode, permissionDispatchRecoveryFromFailureCode, workflowDispatchRecoveryCode, } from './session-commands.js';
-import { parseFeedbackCommand } from './feedback-command.js';
+import { parseFeedbackCommand, parseNaturalObjectiveFeedback } from './feedback-command.js';
 import { validateOwnerGoalOutcomeFeedbackLocator, validateOwnerGoalOutcomeFeedbackProof, } from './goal-wake-types.js';
 import { openDeliveryDatabase } from './sqlite.js';
 import { deriveDeterministicallyDeidentifiedWorkflowTemplate, getDeterministicallyDeidentifiedWorkflowTemplate, } from './workflow-auto-producer.js';
+function foregroundSourceByteLimit(value) {
+    if (value === undefined)
+        return 16_384;
+    if (!Number.isSafeInteger(value) || value < 1 || value > 16_384) {
+        throw new DeliveryStoreError('invalid-binding', 'foreground source byte limit must be between 1 and 16384');
+    }
+    return value;
+}
+function foregroundSourceText(text, limit) {
+    const bytes = Buffer.from(text, 'utf8');
+    let end = Math.min(bytes.length, limit);
+    while (end > 0 && end < bytes.length && (bytes[end] & 0xc0) === 0x80)
+        end--;
+    return Object.freeze({ text: bytes.subarray(0, end).toString('utf8'), fullTextDigest: createHash('sha256').update(bytes).digest('hex'),
+        returnedBytes: end, fullBytes: bytes.length, truncated: end < bytes.length });
+}
 export class DeliveryStoreError extends Error {
     code;
     constructor(code, message) {
@@ -1355,6 +1371,7 @@ export class DeliveryStore {
     codeGenerator;
     maxTextBytes;
     closed = false;
+    writerTransactionActive = false;
     constructor(options) {
         this.database = openDeliveryDatabase(options.path);
         this.now = options.now ?? Date.now;
@@ -3150,6 +3167,32 @@ export class DeliveryStore {
             completedAt: row.completed_at, executionRef: row.execution_ref, modelSelectionState: row.model_selection_state,
             ...(row.model_selection_state === 'frozen' && row.model_provider && row.model_id ? { modelSelection: Object.freeze({ provider: row.model_provider, model: row.model_id, ...(row.model_reasoning_effort === null ? {} : { reasoningEffort: row.model_reasoning_effort }) }) } : {}) });
     }
+    /** One SQL snapshot binds a pending execution to its still claimed Inbox and current owner. */
+    inspectPendingForegroundToolTask(input) {
+        this.assertOpen();
+        const row = this.database.prepare(`SELECT execution.dispatched_at AS dispatched_at
+      FROM delivery_foreground_executions AS execution
+      JOIN inbox_messages AS inbox ON inbox.id = execution.inbox_id
+      JOIN conversation_bindings AS binding ON binding.id = execution.binding_id
+      JOIN delivery_principals AS principal ON principal.id = binding.principal_id
+      WHERE execution.inbox_id = ? AND execution.status = 'pending' AND execution.completed_at IS NULL
+        AND inbox.status = 'claimed' AND inbox.binding_id = execution.binding_id
+        AND binding.status = 'active' AND binding.session_id = ?
+        AND binding.id = ? AND binding.version = ? AND binding.generation = ?
+        AND binding.workspace = ? AND binding.agent_preset = ?
+        AND principal.status = 'active' AND principal.role = 'owner'
+        AND principal.id = ? AND principal.version = ?
+        AND execution.workspace = binding.workspace AND execution.preset = binding.agent_preset
+        AND execution.principal_record_id = principal.id AND execution.principal_version = principal.version
+        AND execution.binding_version = binding.version AND execution.binding_generation = binding.generation
+      LIMIT 1`).get(input.inboxId, input.sessionId, input.binding.id, input.binding.version, input.binding.generation, input.scope.workspace, input.scope.preset, input.owner.principalRecordId, input.owner.principalVersion);
+        if (row === undefined)
+            return undefined;
+        return Object.freeze({ protocol: 'assistant-delivery/foreground-task/v1',
+            inboxId: input.inboxId, sessionId: input.sessionId,
+            scope: Object.freeze({ ...input.scope }), owner: Object.freeze({ ...input.owner }),
+            binding: Object.freeze({ ...input.binding }), dispatchedAt: row.dispatched_at });
+    }
     /** Immutable pre-prompt receipt for an authenticated owner foreground turn. */
     bindForegroundTaskExecution(input) {
         this.assertOpen();
@@ -3244,6 +3287,216 @@ export class DeliveryStore {
                 throw new DeliveryStoreError('conflict', 'foreground execution model selection state is invalid');
         });
     }
+    foregroundSourceFence(input, authorityInput) {
+        const authority = canonicalOwnerRouteAuthority(authorityInput);
+        const binding = this.getActiveBinding(authority.conversation);
+        const owner = binding === undefined ? undefined : this.getPrincipal(binding.principal);
+        const authorityHash = ownerRouteAuthorityHash(authority);
+        if (input.authorityId !== authority.id || input.principalId !== externalPrincipalId(authority.principal)
+            || input.workspace !== authority.workspace || input.agentPreset !== authority.agentPreset
+            || input.expectedOwner?.authorityHash !== authorityHash
+            || input.expectedOwner.principalRecordId !== owner?.id || input.expectedOwner.principalVersion !== owner?.version
+            || binding?.status !== 'active' || !bindingMatchesOwnerRoute(binding, authority)
+            || owner?.role !== 'owner' || owner.status !== 'active') {
+            throw new DeliveryStoreError('unauthorized-principal', 'foreground source owner authority changed');
+        }
+        // The current binding generation intentionally does not enter this key: /new
+        // retires a Session, not the stable owner's completion cursor.
+        const scopeKey = digest(acceptanceCanonicalJson({ authorityId: authority.id, authorityHash,
+            principalId: input.principalId, principalRecordId: owner.id, principalVersion: owner.version,
+            workspace: authority.workspace, preset: authority.agentPreset }));
+        return { authority, authorityHash, scopeKey };
+    }
+    foregroundSource(row, input, fence) {
+        const inbox = this.getInbox(row.inbox_id);
+        const binding = this.getBinding(row.binding_id);
+        if (!inbox || !binding || inbox.bindingId !== row.binding_id
+            || row.workspace !== input.workspace || row.preset !== input.agentPreset
+            || row.principal_record_id !== input.expectedOwner.principalRecordId
+            || row.principal_version !== input.expectedOwner.principalVersion
+            || !bindingMatchesOwnerRoute(binding, fence.authority)
+            || binding.generation !== row.binding_generation
+            || !(binding.status === 'active' && binding.version === row.binding_version
+                || binding.status === 'revoked' && binding.version === row.binding_version + 1)
+            || inbox.admissionCursor.epoch !== this.databaseInstanceId
+            || row.completed_at === null || row.execution_ref !== inbox.id
+            || !Number.isSafeInteger(row.completion_sequence) || row.completion_sequence < 1)
+            return undefined;
+        try {
+            const envelope = canonicalEnvelope(inbox.envelope, this.maxTextBytes);
+            if (digest(JSON.stringify(envelope)) !== inbox.envelopeHash
+                || envelope.kind !== 'text' || parseDeliveryCommand({ ...envelope, kind: 'command' }) !== undefined
+                || JSON.stringify(envelope.principal) !== JSON.stringify(binding.principal)
+                || JSON.stringify(envelope.conversation) !== JSON.stringify(binding.conversation))
+                return undefined;
+        }
+        catch {
+            return undefined;
+        }
+        const execution = Object.freeze({ dispatchedAt: row.dispatched_at,
+            status: row.status, quiescent: row.quiescent === 1, completedAt: row.completed_at,
+            executionRef: row.execution_ref, modelSelectionState: row.model_selection_state,
+            ...(row.model_selection_state === 'frozen' && row.model_provider && row.model_id ? {
+                modelSelection: Object.freeze({ provider: row.model_provider, model: row.model_id,
+                    ...(row.model_reasoning_effort === null ? {} : { reasoningEffort: row.model_reasoning_effort }) }),
+            } : {}) });
+        const content = { protocol: 'assistant-delivery/owner-foreground-source/v1', inboxId: inbox.id,
+            completionSequence: row.completion_sequence, admissionCursor: Object.freeze({ ...inbox.admissionCursor }),
+            authorityId: fence.authority.id, authorityHash: fence.authorityHash, principalId: input.principalId,
+            owner: Object.freeze({ principalRecordId: row.principal_record_id, principalVersion: row.principal_version }),
+            scope: Object.freeze({ workspace: row.workspace, preset: row.preset }),
+            binding: Object.freeze({ id: row.binding_id, version: row.binding_version,
+                generation: row.binding_generation, sessionId: binding.sessionId }), execution };
+        return Object.freeze({ ...content, sourceDigest: digest(acceptanceCanonicalJson({ ...content, envelopeHash: inbox.envelopeHash })) });
+    }
+    /** Host-only durable completion feed. Mutable delivery state never hides a completion. */
+    listOwnerForegroundTaskSources(input, authority) {
+        this.assertOpen();
+        const limit = input.limit ?? 50;
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) {
+            throw new DeliveryStoreError('invalid-binding', 'foreground source page limit must be between 1 and 100');
+        }
+        return this.transaction(() => {
+            const fence = this.foregroundSourceFence(input, authority);
+            const watermark = this.database.prepare('SELECT current_sequence FROM delivery_foreground_completion_clock WHERE singleton = 1')
+                .get().current_sequence;
+            const after = input.after;
+            if (after !== undefined && (after.protocol !== 'assistant-delivery/owner-foreground-source-cursor/v1'
+                || after.epoch !== this.databaseInstanceId || after.scopeKey !== fence.scopeKey
+                || !Number.isSafeInteger(after.sequence) || after.sequence < 0 || after.sequence > watermark)) {
+                throw new DeliveryStoreError('invalid-binding', 'foreground source cursor is not bound to this owner and watermark');
+            }
+            const rows = this.database.prepare(`SELECT * FROM delivery_foreground_executions
+        WHERE principal_record_id = ? AND principal_version = ? AND workspace = ? AND preset = ?
+          AND status != 'pending' AND completion_sequence > ? AND completion_sequence <= ?
+        ORDER BY completion_sequence LIMIT ?`).all(input.expectedOwner.principalRecordId, input.expectedOwner.principalVersion, input.workspace, input.agentPreset, after?.sequence ?? 0, watermark, limit + 1);
+            const hasMore = rows.length > limit;
+            const scanned = rows.slice(0, limit);
+            const items = scanned.flatMap(row => {
+                const source = this.foregroundSource(row, input, fence);
+                return source === undefined ? [] : [source];
+            });
+            const nextCursor = Object.freeze({ protocol: 'assistant-delivery/owner-foreground-source-cursor/v1',
+                epoch: this.databaseInstanceId, scopeKey: fence.scopeKey,
+                sequence: hasMore ? scanned[scanned.length - 1].completion_sequence : watermark });
+            return Object.freeze({ items: Object.freeze(items), nextCursor, watermark, hasMore });
+        });
+    }
+    /** Host-only exact inbox metadata under the same owner writer fence as the feed. */
+    inspectOwnerForegroundTaskSource(input, authority) {
+        this.assertOpen();
+        if (typeof input.inboxId !== 'string' || input.inboxId === '') {
+            throw new DeliveryStoreError('invalid-binding', 'foreground source inbox ID is invalid');
+        }
+        const inspect = () => {
+            const fence = this.foregroundSourceFence(input, authority);
+            const row = this.database.prepare(`SELECT * FROM delivery_foreground_executions
+        WHERE inbox_id = ? AND status != 'pending'`).get(input.inboxId);
+            return row === undefined ? undefined : this.foregroundSource(row, input, fence);
+        };
+        // A route writer fence may inspect the same source while holding this
+        // connection's transaction. Reuse that atomic snapshot and its write lock.
+        return this.writerTransactionActive ? inspect() : this.transaction(inspect);
+    }
+    /** Content comes from the canonical Inbox/Outbox, with no alternate text ledger. */
+    readOwnerForegroundTaskSource(input, authority) {
+        this.assertOpen();
+        const inputLimit = foregroundSourceByteLimit(input.maxInputBytes);
+        const replyLimit = foregroundSourceByteLimit(input.maxReplyBytes);
+        const read = () => {
+            const fence = this.foregroundSourceFence(input, authority);
+            return this.foregroundSourceContent(input, fence, inputLimit, replyLimit);
+        };
+        // A source fence already holds this connection's writer transaction. Reuse
+        // its owner check and snapshot without starting a nested BEGIN.
+        return this.writerTransactionActive ? read() : this.transaction(read);
+    }
+    /** Lock order: Delivery, then downstream Evaluation/Memory writer fences. */
+    withOwnerForegroundTaskSourceFence(input, authority, callback) {
+        if (typeof callback !== 'function')
+            throw new DeliveryStoreError('invalid-binding', 'foreground source callback is invalid');
+        return this.withForegroundSourceRead(input, authority, source => {
+            if (source === undefined)
+                throw new DeliveryStoreError('conflict', 'foreground source is unavailable or changed');
+            const result = callback(source);
+            this.assertForegroundSourceSyncResult(result);
+            return result;
+        });
+    }
+    /** One owner check and one Delivery writer transaction for an ordered set of exact sources. */
+    withOwnerForegroundTaskSourcesFence(input, authority, callback) {
+        this.assertOpen();
+        if (typeof callback !== 'function')
+            throw new DeliveryStoreError('invalid-binding', 'foreground source callback is invalid');
+        if (!Array.isArray(input.sources) || input.sources.length > 1_000) {
+            throw new DeliveryStoreError('invalid-binding', 'foreground source batch must contain at most 1000 sources');
+        }
+        const inboxIds = new Set();
+        for (const source of input.sources) {
+            if (source === null || typeof source !== 'object' || typeof source.inboxId !== 'string'
+                || source.inboxId === '' || typeof source.expectedSourceDigest !== 'string'
+                || inboxIds.has(source.inboxId)) {
+                throw new DeliveryStoreError('invalid-binding', 'foreground source batch requires unique inbox IDs and digests');
+            }
+            inboxIds.add(source.inboxId);
+        }
+        return this.transaction(() => {
+            const fence = this.foregroundSourceFence(input, authority);
+            const sources = Object.freeze(input.sources.map(source => this.foregroundSourceContent({ ...input, inboxId: source.inboxId, expectedSourceDigest: source.expectedSourceDigest }, fence, 16_384, 16_384)));
+            const result = callback(sources);
+            this.assertForegroundSourceSyncResult(result);
+            return result;
+        });
+    }
+    assertForegroundSourceSyncResult(result) {
+        if (result !== null && (typeof result === 'object' || typeof result === 'function') && 'then' in result) {
+            // The native method consumes a real rejected Promise without invoking an
+            // arbitrary thenable's getter or callback. The transaction then rolls back.
+            try {
+                Promise.prototype.then.call(result, undefined, () => undefined);
+            }
+            catch { /* Not a native Promise. */ }
+            throw new DeliveryStoreError('invalid-binding', 'foreground source callback must be synchronous');
+        }
+    }
+    withForegroundSourceRead(input, authority, callback) {
+        this.assertOpen();
+        const inputLimit = foregroundSourceByteLimit(input.maxInputBytes);
+        const replyLimit = foregroundSourceByteLimit(input.maxReplyBytes);
+        return this.transaction(() => {
+            const fence = this.foregroundSourceFence(input, authority);
+            return callback(this.foregroundSourceContent(input, fence, inputLimit, replyLimit));
+        });
+    }
+    foregroundSourceContent(input, fence, inputLimit, replyLimit) {
+        const row = this.database.prepare(`SELECT * FROM delivery_foreground_executions
+      WHERE inbox_id = ? AND status != 'pending'`).get(input.inboxId);
+        const source = row === undefined ? undefined : this.foregroundSource(row, input, fence);
+        if (!source || source.sourceDigest !== input.expectedSourceDigest || source.execution.status !== 'succeeded'
+            || !source.execution.quiescent || source.execution.modelSelectionState !== 'frozen'
+            || source.execution.modelSelection === undefined)
+            return undefined;
+        const inbox = this.getInbox(source.inboxId);
+        const binding = this.getBinding(source.binding.id);
+        const outbox = this.getOutboxByIdempotencyKey(`inbound:${inbox.id}:reply`);
+        if (!outbox || outbox.intentHash !== digest(JSON.stringify(outbox.intent)))
+            return undefined;
+        const intent = outbox.intent;
+        if (intent.bindingId !== binding.id || intent.replyToEventId !== inbox.envelope.eventId
+            || intent.idempotencyKey !== `inbound:${inbox.id}:reply`
+            || JSON.stringify(intent.target.principal) !== JSON.stringify(binding.principal)
+            || JSON.stringify(intent.target.conversation) !== JSON.stringify(binding.conversation)
+            || ![undefined, 'plain', 'markdown'].includes(intent.format)
+            || intent.approval !== undefined || intent.modelPicker !== undefined || intent.permissionPicker !== undefined
+            || Object.keys(intent.metadata ?? {}).length !== 0)
+            return undefined;
+        const inputText = foregroundSourceText(inbox.envelope.text, inputLimit);
+        const reply = Object.freeze({ ...foregroundSourceText(intent.text, replyLimit), outboxId: outbox.id, intentDigest: outbox.intentHash });
+        const contentDigest = digest(acceptanceCanonicalJson({ protocol: 'assistant-delivery/owner-foreground-source-content/v1',
+            sourceDigest: source.sourceDigest, inputDigest: inputText.fullTextDigest,
+            replyDigest: reply.fullTextDigest, outboxId: reply.outboxId, intentDigest: reply.intentDigest }));
+        return Object.freeze({ source, sourceDigest: source.sourceDigest, contentDigest, input: inputText, reply });
+    }
     inspectForegroundExecutionForOwner(input) {
         const row = this.database.prepare(`SELECT execution.dispatched_at, execution.status, execution.quiescent, execution.completed_at, execution.execution_ref,
         execution.model_selection_state, execution.model_provider, execution.model_id, execution.model_reasoning_effort,
@@ -5095,16 +5348,220 @@ export class DeliveryStore {
             return Object.freeze({ revision, ...(template === undefined ? {} : { template }), replayed: false });
         });
     }
-    /**
-     * Atomically record an authenticated owner objective judgement about one
-     * ordinary completed Agent turn and, only when a closed deterministic
-     * deidentification catalog recognizes the source, emit its verified trace.
-     *
-     * The caller may not supply a prompt, task reference, template, or proof:
-     * all of them are rebuilt below from the exact durable Inbox/Outbox fence.
-     * A normal durable reply alone is intentionally insufficient; the owner
-     * must have replied `/feedback achieved` to that exact provider message.
-     */
+    getNaturalObjectiveIntent(inboxId) {
+        this.assertOpen();
+        const row = this.database.prepare('SELECT * FROM delivery_natural_objective_intents WHERE inbox_id = ?')
+            .get(inboxId);
+        if (row === undefined)
+            return undefined;
+        return Object.freeze({
+            inboxId: String(row['inbox_id']), envelopeHash: String(row['envelope_hash']),
+            sourceInboxId: String(row['source_inbox_id']), sourceOutboxId: String(row['source_outbox_id']),
+            bindingId: String(row['binding_id']), bindingVersion: Number(row['binding_version']),
+            bindingGeneration: Number(row['binding_generation']), principalRecordId: String(row['principal_record_id']),
+            principalVersion: Number(row['principal_version']), admissionSequence: Number(row['admission_sequence']),
+            admissionEpoch: String(row['admission_epoch']),
+            occurredAt: Number(row['occurred_at']), selection: row['selection'],
+            status: row['intent_status'],
+            ...(row['command_json'] === null ? {} : { command: JSON.parse(String(row['command_json'])) }),
+            ...(row['canonical_json'] === null ? {} : { canonical: JSON.parse(String(row['canonical_json'])) }),
+        });
+    }
+    listPendingNaturalObjectiveIntents(limit = 100, afterAdmissionSequence = 0) {
+        this.assertOpen();
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
+            throw new DeliveryStoreError('conflict', 'invalid natural feedback limit');
+        if (!Number.isSafeInteger(afterAdmissionSequence) || afterAdmissionSequence < 0)
+            throw new DeliveryStoreError('conflict', 'invalid natural feedback cursor');
+        const ids = this.database.prepare(`SELECT inbox_id FROM delivery_natural_objective_intents
+      WHERE intent_status IN ('awaiting-evaluation', 'frozen') AND admission_sequence > ?
+      ORDER BY admission_sequence LIMIT ?`)
+            .all(afterAdmissionSequence, limit);
+        return ids.map(row => this.getNaturalObjectiveIntent(row.inbox_id));
+    }
+    hasEarlierPendingNaturalObjectiveIntent(sourceOutboxId, admissionSequence) {
+        this.assertOpen();
+        return this.database.prepare(`SELECT 1 FROM delivery_natural_objective_intents
+      WHERE source_outbox_id = ? AND admission_sequence < ?
+        AND intent_status IN ('awaiting-evaluation', 'frozen') LIMIT 1`)
+            .get(sourceOutboxId, admissionSequence) !== undefined;
+    }
+    /** Same source proof required by the local workflow commit, before Evaluation append. */
+    isVerifiedForegroundObjectiveTarget(binding, sourceInboxId, sourceOutboxId) {
+        this.assertOpen();
+        const source = this.getInbox(sourceInboxId);
+        const outbox = this.getOutbox(sourceOutboxId);
+        return source?.status === 'processed' && source.bindingId === binding.id
+            && source.envelope.kind === 'text' && (source.envelope.attachments?.length ?? 0) === 0
+            && outbox !== undefined && outbox.intent.bindingId === binding.id
+            && outbox.intent.idempotencyKey === `inbound:${source.id}:reply`
+            && outbox.intent.replyToEventId === source.eventId
+            && ['accepted', 'delivered', 'read'].includes(outbox.status)
+            && outbox.providerMessageId !== undefined
+            && (outbox.intent.format === 'markdown' || outbox.intent.format === 'plain')
+            && outbox.intent.metadata === undefined && outbox.intent.modelPicker === undefined
+            && outbox.intent.permissionPicker === undefined && outbox.intent.approval === undefined
+            && this.getGoalOutcomeTarget(outbox.id) === undefined
+            && JSON.stringify(source.envelope.conversation) === JSON.stringify(binding.conversation)
+            && JSON.stringify(source.envelope.principal) === JSON.stringify(binding.principal)
+            && JSON.stringify(outbox.intent.target.conversation) === JSON.stringify(binding.conversation)
+            && JSON.stringify(outbox.intent.target.principal) === JSON.stringify(binding.principal);
+    }
+    /** Freeze the immutable owner wording and exact completed result before any Evaluation I/O. */
+    prepareNaturalObjectiveIntent(input) {
+        this.assertOpen();
+        return this.transaction(() => {
+            const binding = this.getBinding(input.binding.id);
+            const owner = binding === undefined ? undefined : this.getPrincipal(binding.principal);
+            const inbox = this.getInbox(input.feedbackInboxId);
+            const source = this.getInbox(input.sourceInboxId);
+            const outbox = this.getOutbox(input.sourceOutboxId);
+            const existing = this.getNaturalObjectiveIntent(input.feedbackInboxId);
+            if (binding?.status !== 'active' || binding.version !== input.binding.version
+                || binding.generation !== input.binding.generation || binding.sessionId !== input.binding.sessionId
+                || binding.conversation.kind !== 'dm' || owner?.status !== 'active' || owner.role !== 'owner'
+                || inbox?.status !== 'claimed' || inbox.bindingId !== binding.id || inbox.envelope.kind !== 'text'
+                || (inbox.envelope.attachments?.length ?? 0) !== 0
+                || parseNaturalObjectiveFeedback(inbox.envelope.text) !== input.selection
+                || !this.isVerifiedForegroundObjectiveTarget(binding, input.sourceInboxId, input.sourceOutboxId)
+                || source === undefined || outbox === undefined
+                || inbox.envelope.metadata?.replyToProviderMessageId !== outbox.providerMessageId
+                || JSON.stringify(inbox.envelope.conversation) !== JSON.stringify(binding.conversation)
+                || JSON.stringify(inbox.envelope.principal) !== JSON.stringify(binding.principal)) {
+                throw new DeliveryStoreError('conflict', 'natural feedback does not target one completed owner turn');
+            }
+            if (existing !== undefined) {
+                if (existing.envelopeHash !== inbox.envelopeHash || existing.sourceInboxId !== source.id
+                    || existing.sourceOutboxId !== outbox.id || existing.selection !== input.selection
+                    || existing.principalRecordId !== owner.id || existing.principalVersion !== owner.version
+                    || existing.bindingVersion !== binding.version || existing.bindingGeneration !== binding.generation
+                    || existing.admissionEpoch !== inbox.admissionCursor.epoch
+                    || existing.admissionSequence !== inbox.admissionCursor.sequence) {
+                    throw new DeliveryStoreError('idempotency-conflict', 'natural feedback identity changed');
+                }
+                return existing;
+            }
+            const now = this.now();
+            this.database.prepare(`INSERT INTO delivery_natural_objective_intents(
+        inbox_id, envelope_hash, source_inbox_id, source_outbox_id, binding_id, binding_version,
+        binding_generation, principal_record_id, principal_version, admission_epoch, admission_sequence,
+        occurred_at, parser_version, intent_status, selection, command_json, canonical_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, 'awaiting-evaluation', ?, NULL, NULL, ?, ?)`).run(inbox.id, inbox.envelopeHash, source.id, outbox.id, binding.id, binding.version, binding.generation, owner.id, owner.version, inbox.admissionCursor.epoch, inbox.admissionCursor.sequence, inbox.envelope.occurredAt, input.selection, now, now);
+            return this.getNaturalObjectiveIntent(inbox.id);
+        });
+    }
+    /** A CAS command is fixed once; retries may never inspect a newer version and rebase it. */
+    freezeNaturalObjectiveIntent(inboxId, current) {
+        this.assertOpen();
+        return this.transaction(() => {
+            const intent = this.getNaturalObjectiveIntent(inboxId);
+            if (intent === undefined)
+                return undefined;
+            if (intent.status !== 'awaiting-evaluation')
+                return intent;
+            const earlier = this.database.prepare(`SELECT 1 FROM delivery_natural_objective_intents
+        WHERE source_outbox_id = ? AND admission_sequence < ?
+          AND intent_status IN ('awaiting-evaluation', 'frozen') LIMIT 1`)
+                .get(intent.sourceOutboxId, intent.admissionSequence);
+            if (earlier !== undefined)
+                return undefined;
+            const later = this.database.prepare(`SELECT 1 FROM delivery_natural_objective_intents
+        WHERE source_outbox_id = ? AND admission_sequence > ?
+          AND intent_status = 'projected' LIMIT 1`)
+                .get(intent.sourceOutboxId, intent.admissionSequence);
+            if (later !== undefined) {
+                this.database.prepare(`UPDATE delivery_natural_objective_intents SET intent_status = 'conflict', updated_at = ? WHERE inbox_id = ?`)
+                    .run(this.now(), inboxId);
+                return this.getNaturalObjectiveIntent(inboxId);
+            }
+            const latest = this.database.prepare(`SELECT inbox.envelope_json, admission.admission_sequence
+        FROM delivery_owner_objective_commands AS command
+        JOIN inbox_messages AS inbox ON inbox.id = command.inbox_id
+        JOIN delivery_inbox_admissions AS admission ON admission.inbox_id = inbox.id
+        WHERE command.source_outbox_id = ? AND json_extract(command.result_json, '$.error') IS NULL
+        ORDER BY command.version DESC, admission.admission_sequence DESC LIMIT 1`)
+                .get(intent.sourceOutboxId);
+            if (latest !== undefined) {
+                const previous = JSON.parse(latest.envelope_json);
+                if (latest.admission_sequence >= intent.admissionSequence
+                    || previous.occurredAt >= intent.occurredAt) {
+                    this.database.prepare(`UPDATE delivery_natural_objective_intents SET intent_status = 'conflict', updated_at = ? WHERE inbox_id = ?`)
+                        .run(this.now(), inboxId);
+                    return this.getNaturalObjectiveIntent(inboxId);
+                }
+            }
+            const projected = this.database.prepare(`SELECT MAX(occurred_at) AS occurred_at
+        FROM delivery_natural_objective_intents WHERE source_outbox_id = ?
+          AND admission_sequence < ? AND intent_status = 'projected'`)
+                .get(intent.sourceOutboxId, intent.admissionSequence);
+            if (projected.occurred_at !== null && projected.occurred_at >= intent.occurredAt) {
+                this.database.prepare(`UPDATE delivery_natural_objective_intents SET intent_status = 'conflict', updated_at = ? WHERE inbox_id = ?`)
+                    .run(this.now(), inboxId);
+                return this.getNaturalObjectiveIntent(inboxId);
+            }
+            const local = this.verifiedWorkflowObjectiveState(intent.sourceOutboxId, { principalRecordId: intent.principalRecordId, principalVersion: intent.principalVersion });
+            if (local !== undefined && (current === undefined || local.version !== current.version
+                || local.objectiveStatus !== current.objectiveStatus))
+                return undefined;
+            if (current !== undefined && local === undefined)
+                return undefined;
+            if (intent.selection === 'withdraw' && (current === undefined || current.objectiveStatus === 'unknown')) {
+                this.database.prepare(`UPDATE delivery_natural_objective_intents SET intent_status = 'conflict', updated_at = ? WHERE inbox_id = ?`)
+                    .run(this.now(), inboxId);
+                return this.getNaturalObjectiveIntent(inboxId);
+            }
+            if (current !== undefined && current.objectiveStatus === intent.selection) {
+                this.database.prepare(`UPDATE delivery_natural_objective_intents SET intent_status = 'projected', updated_at = ? WHERE inbox_id = ?`)
+                    .run(this.now(), inboxId);
+                return this.getNaturalObjectiveIntent(inboxId);
+            }
+            const command = current === undefined
+                ? { kind: 'objective', objectiveStatus: intent.selection }
+                : { kind: 'objective-revision', action: intent.selection === 'withdraw' ? 'withdraw' : 'correct',
+                    expectedVersion: current.version, previousStatus: current.objectiveStatus,
+                    objectiveStatus: intent.selection === 'withdraw' ? 'unknown' : intent.selection };
+            this.database.prepare(`UPDATE delivery_natural_objective_intents
+        SET intent_status = 'frozen', command_json = ?, updated_at = ? WHERE inbox_id = ?`)
+                .run(JSON.stringify(command), this.now(), inboxId);
+            return this.getNaturalObjectiveIntent(inboxId);
+        });
+    }
+    settleNaturalObjectiveIntent(inboxId, status, canonical) {
+        this.assertOpen();
+        this.transaction(() => {
+            const intent = this.getNaturalObjectiveIntent(inboxId);
+            if (intent?.status !== 'frozen' && intent?.status !== status
+                && !(intent?.status === 'awaiting-evaluation' && status === 'conflict')) {
+                throw new DeliveryStoreError('conflict', 'natural intent was not frozen');
+            }
+            if (intent.status === 'projected' && status !== 'projected')
+                throw new DeliveryStoreError('conflict', 'projected natural feedback cannot regress');
+            this.database.prepare(`UPDATE delivery_natural_objective_intents
+        SET intent_status = ?, canonical_json = COALESCE(canonical_json, ?), updated_at = ? WHERE inbox_id = ?`)
+                .run(status, canonical === undefined ? null : JSON.stringify(canonical), this.now(), inboxId);
+        });
+    }
+    findNaturalObjectiveFeedbackByOperation(sourceOutboxId, operationId, lineage) {
+        this.assertOpen();
+        const row = this.database.prepare(`SELECT intent.inbox_id, intent.envelope_hash, intent.principal_record_id,
+        intent.principal_version, inbox.envelope_json, inbox.envelope_hash AS current_hash
+      FROM delivery_natural_objective_intents AS intent JOIN inbox_messages AS inbox ON inbox.id = intent.inbox_id
+      WHERE intent.source_outbox_id = ? AND intent.principal_record_id = ? AND intent.principal_version = ?
+        AND intent.command_json IS NOT NULL
+        AND intent.intent_status IN ('frozen', 'projected')`).all(sourceOutboxId, lineage.principalRecordId, lineage.principalVersion);
+        for (const candidate of row) {
+            if (candidate.envelope_hash !== candidate.current_hash)
+                continue;
+            const derived = `owner-feedback:${createHash('sha256').update(JSON.stringify([candidate.inbox_id, candidate.envelope_hash])).digest('hex')}`;
+            if (derived !== operationId)
+                continue;
+            const envelope = JSON.parse(candidate.envelope_json);
+            if (envelope.kind !== 'text' || parseNaturalObjectiveFeedback(envelope.text) === undefined)
+                continue;
+            return Object.freeze({ inboxId: candidate.inbox_id, text: envelope.text.slice(0, 4096), truncated: envelope.text.length > 4096 });
+        }
+        return undefined;
+    }
     verifiedWorkflowObjectiveState(sourceOutboxId, lineage) {
         const row = this.database.prepare(`SELECT version, objective_status, principal_record_id, principal_version FROM delivery_owner_objective_commands
       WHERE source_outbox_id = ? AND json_extract(result_json, '$.error') IS NULL ORDER BY version DESC LIMIT 1`).get(sourceOutboxId);
@@ -5121,6 +5578,7 @@ export class DeliveryStore {
             return undefined;
         return initial === undefined ? undefined : { version: 1, objectiveStatus: initial.objective_status };
     }
+    /** Commit exact owner feedback (typed command or frozen natural intent) and closed-set workflow evidence. */
     commitVerifiedWorkflowTraceFeedback(input) {
         this.assertOpen();
         if (typeof input !== 'object' || input === null
@@ -5147,13 +5605,28 @@ export class DeliveryStore {
             const feedbackInbox = this.getInbox(feedbackInboxId);
             const sourceInbox = this.getInbox(sourceInboxId);
             const sourceOutbox = this.getOutbox(sourceOutboxId);
+            const naturalIntent = this.getNaturalObjectiveIntent(feedbackInboxId);
             const feedbackCommand = feedbackInbox === undefined || feedbackInbox.envelope.kind !== 'command'
                 ? undefined
                 : parseDeliveryCommand(feedbackInbox.envelope);
-            const feedback = feedbackCommand?.name !== 'feedback'
+            const typedFeedback = feedbackCommand?.name !== 'feedback'
                 ? undefined
                 : parseFeedbackCommand(feedbackCommand.rawInput);
-            if (feedbackInbox?.status !== 'claimed' || feedbackInbox.bindingId !== binding.id
+            const feedback = naturalIntent?.command ?? typedFeedback;
+            const naturalMatches = naturalIntent === undefined || (feedbackInbox !== undefined
+                && feedbackInbox.envelope.kind === 'text'
+                && naturalIntent.status !== 'awaiting-evaluation' && naturalIntent.status !== 'conflict'
+                && naturalIntent.envelopeHash === feedbackInbox.envelopeHash
+                && naturalIntent.sourceInboxId === sourceInboxId && naturalIntent.sourceOutboxId === sourceOutboxId
+                && naturalIntent.bindingId === binding.id
+                && naturalIntent.bindingVersion === binding.version && naturalIntent.bindingGeneration === binding.generation
+                && naturalIntent.principalRecordId === owner.id && naturalIntent.principalVersion === owner.version
+                && naturalIntent.admissionEpoch === feedbackInbox.admissionCursor.epoch
+                && naturalIntent.admissionSequence === feedbackInbox.admissionCursor.sequence
+                && parseNaturalObjectiveFeedback(feedbackInbox.envelope.text) === naturalIntent.selection);
+            if ((feedbackInbox?.status !== 'claimed' && !(naturalIntent !== undefined
+                && (feedbackInbox?.status === 'processed' || feedbackInbox?.status === 'dead_letter')))
+                || feedbackInbox?.bindingId !== binding.id || !naturalMatches
                 || (feedbackInbox.envelope.attachments?.length ?? 0) !== 0
                 || (feedback?.kind !== 'objective' && feedback?.kind !== 'objective-revision')
                 || feedback.objectiveStatus !== input.objectiveStatus
@@ -6757,6 +7230,7 @@ export class DeliveryStore {
     }
     transaction(operation) {
         this.database.exec('BEGIN IMMEDIATE');
+        this.writerTransactionActive = true;
         try {
             const result = operation();
             this.database.exec('COMMIT');
@@ -6766,6 +7240,9 @@ export class DeliveryStore {
             this.database.exec('ROLLBACK');
             throw error;
         }
+        finally {
+            this.writerTransactionActive = false;
+        }
     }
     advanceModelCommandEpoch(conversation) {
         const hash = conversationHash(conversation);