@dsh-enhanced/assistant-delivery 0.1.24 → 0.1.31

package/lib/store.js

@@ -1,9 +1,11 @@
 import { createHash, randomBytes, randomUUID, scryptSync, timingSafeEqual } from 'node:crypto';
 import { isAbsolute } from 'node:path';
+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, } 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 { validateOwnerGoalOutcomeFeedbackLocator, validateOwnerGoalOutcomeFeedbackProof, } from './goal-wake-types.js';
 import { openDeliveryDatabase } from './sqlite.js';
 import { deriveDeterministicallyDeidentifiedWorkflowTemplate, getDeterministicallyDeidentifiedWorkflowTemplate, } from './workflow-auto-producer.js';
 export class DeliveryStoreError extends Error {
@@ -366,7 +368,7 @@ function canonicalImageRef(input) {
     const value = input;
     const required = ['attachmentId', 'mediaType', 'bytes', 'width', 'height'];
     if (required.some(key => !Object.hasOwn(value, key))
-        || Object.keys(value).some(key => ![...required, 'name'].includes(key))
+        || Object.keys(value).some(key => ![...required, 'name', 'originalDimensions'].includes(key))
         || typeof value.attachmentId !== 'string'
         || value.attachmentId.length < 1 || value.attachmentId.length > 512
         || /\p{Cc}/u.test(value.attachmentId)
@@ -375,6 +377,15 @@ function canonicalImageRef(input) {
         || !Number.isSafeInteger(value.bytes) || value.bytes < 1
         || !Number.isSafeInteger(value.width) || value.width < 1
         || !Number.isSafeInteger(value.height) || value.height < 1
+        || (value.originalDimensions !== undefined
+            && (value.originalDimensions === null
+                || typeof value.originalDimensions !== 'object'
+                || Array.isArray(value.originalDimensions)
+                || Object.keys(value.originalDimensions).some(key => key !== 'width' && key !== 'height')
+                || !Number.isSafeInteger(value.originalDimensions.width)
+                || value.originalDimensions.width < 1
+                || !Number.isSafeInteger(value.originalDimensions.height)
+                || value.originalDimensions.height < 1))
         || (value.name !== undefined && (typeof value.name !== 'string' || value.name.length < 1
             || value.name.length > 255 || value.name === '.' || value.name === '..' || /[\\/\p{Cc}]/u.test(value.name)))) {
         invalidImageRef();
@@ -386,6 +397,12 @@ function canonicalImageRef(input) {
         width: value.width,
         height: value.height,
         ...(value.name === undefined ? {} : { name: value.name }),
+        ...(value.originalDimensions === undefined ? {} : {
+            originalDimensions: {
+                width: value.originalDimensions.width,
+                height: value.originalDimensions.height,
+            },
+        }),
     };
 }
 function persistedImageRef(row) {
@@ -409,7 +426,9 @@ function sameImageRef(left, right) {
         && left.bytes === right.bytes
         && left.width === right.width
         && left.height === right.height
-        && left.name === right.name;
+        && left.name === right.name
+        && left.originalDimensions?.width === right.originalDimensions?.width
+        && left.originalDimensions?.height === right.originalDimensions?.height;
 }
 function attachmentFromRow(row) {
     const imageRef = row.status === 'ready' && row.resource_kind === 'image'
@@ -630,6 +649,32 @@ function approvalRouteFromRow(row) {
         principalVersion: row.principal_version,
     });
 }
+function goalOutcomeTargetFromRow(row) {
+    let locator;
+    let proof;
+    try {
+        locator = validateOwnerGoalOutcomeFeedbackLocator(JSON.parse(row.locator_json));
+        proof = validateOwnerGoalOutcomeFeedbackProof(JSON.parse(row.proof_json));
+    }
+    catch {
+        throw new DeliveryStoreError('invalid-intent', 'stored goal outcome target is invalid');
+    }
+    if (acceptanceCanonicalJson(proof.locator) !== acceptanceCanonicalJson(locator)
+        || proof.proofDigest !== row.proof_digest || locator.ownerRouteId !== row.owner_route_id
+        || locator.principalId !== row.principal_id || locator.principalRecordId !== row.principal_record_id
+        || locator.principalVersion !== row.principal_version || locator.workspace !== row.workspace
+        || locator.preset !== row.preset || locator.bindingId !== row.binding_id
+        || locator.bindingVersion !== row.binding_version || locator.bindingGeneration !== row.binding_generation
+        || locator.sessionId !== row.session_id || locator.goalId !== row.goal_id
+        || locator.assessmentId !== row.assessment_id) {
+        throw new DeliveryStoreError('invalid-intent', 'stored goal outcome target columns do not match its proof');
+    }
+    return Object.freeze({ outboxId: row.outbox_id, locator, proof });
+}
+function sameGoalOutcomeTarget(left, locator, proof) {
+    return acceptanceCanonicalJson(left.locator) === acceptanceCanonicalJson(locator)
+        && acceptanceCanonicalJson(left.proof) === acceptanceCanonicalJson(proof);
+}
 function sameApprovalRoute(left, right) {
     return left.routeVersion === right.routeVersion
         && left.sourceId === right.sourceId
@@ -1263,6 +1308,28 @@ function getPairingStatement(database) {
     FROM pairing_challenges WHERE id = ?
   `);
 }
+function sameLeaseBinding(left, right) {
+    return left.id === right.id && left.sessionId === right.sessionId && left.generation === right.generation
+        && left.version === right.version && left.status === 'active' && right.status === 'active'
+        && left.workspace === right.workspace && left.agentPreset === right.agentPreset
+        && JSON.stringify(canonicalConversation(left.conversation)) === JSON.stringify(canonicalConversation(right.conversation))
+        && JSON.stringify(canonicalPrincipal(left.principal)) === JSON.stringify(canonicalPrincipal(right.principal));
+}
+function leaseSessionIdentity(target) {
+    const value = target.kind === 'bound' ? target.binding : target;
+    return JSON.stringify({ sessionId: value.sessionId, conversation: canonicalConversation(value.conversation),
+        principal: canonicalPrincipal(value.principal), workspace: value.workspace,
+        agentPreset: value.agentPreset, generation: value.generation });
+}
+function leaseTargetJson(target) {
+    if (target?.kind !== 'bound' && target?.kind !== 'construction')
+        throw new DeliveryStoreError('invalid-binding', 'invalid session lease target');
+    if (target.kind === 'bound') {
+        const binding = target.binding;
+        return JSON.stringify({ kind: 'bound', binding: { id: binding.id, conversation: canonicalConversation(binding.conversation), principal: canonicalPrincipal(binding.principal), workspace: binding.workspace, agentPreset: binding.agentPreset, sessionId: binding.sessionId, generation: binding.generation, version: binding.version, status: 'active' } });
+    }
+    return JSON.stringify({ kind: 'construction', sessionId: target.sessionId, conversation: canonicalConversation(target.conversation), principal: canonicalPrincipal(target.principal), workspace: target.workspace, agentPreset: target.agentPreset, generation: target.generation, ...(target.previous === undefined ? {} : { previous: { id: target.previous.id, conversation: canonicalConversation(target.previous.conversation), principal: canonicalPrincipal(target.previous.principal), workspace: target.previous.workspace, agentPreset: target.previous.agentPreset, sessionId: target.previous.sessionId, generation: target.previous.generation, version: target.previous.version, status: 'active' } }) });
+}
 export class DeliveryStore {
     database;
     databaseInstanceId;
@@ -1564,6 +1631,47 @@ export class DeliveryStore {
             return principalFromRow(result);
         });
     }
+    /**
+     * Bootstrap one empty Delivery database for a fixed local operator.  This is
+     * deliberately narrower than handoffOwner(): once any principal history
+     * exists it can only return the exact, sole active owner without changing a
+     * row, its bindings, or any linked authority.
+     */
+    ensureOwner(input) {
+        this.assertOpen();
+        const principal = canonicalPrincipal(input);
+        const json = principalJson(principal);
+        const hash = digest(json);
+        const now = this.now();
+        return this.transaction(() => {
+            const total = this.database.prepare('SELECT COUNT(*) AS count FROM delivery_principals')
+                .get().count;
+            if (total === 0) {
+                const id = `principal_${randomUUID()}`;
+                this.database.prepare(`
+          INSERT INTO delivery_principals (
+            id, key_hash, principal_json, role, status, linked_to_id, created_at, updated_at, version
+          ) VALUES (?, ?, ?, 'owner', 'active', NULL, ?, ?, 1)
+        `).run(id, hash, json, now, now);
+                return principalFromRow(this.database.prepare(`
+          SELECT id, principal_json, role, status, linked_to_id, created_at, updated_at, version
+          FROM delivery_principals WHERE id = ?
+        `).get(id));
+            }
+            const exact = this.database.prepare(`
+        SELECT id, principal_json, role, status, linked_to_id, created_at, updated_at, version
+        FROM delivery_principals WHERE key_hash = ? AND principal_json = ?
+      `).get(hash, json);
+            const activeOwners = this.database.prepare(`
+        SELECT id FROM delivery_principals WHERE role = 'owner' AND status = 'active'
+      `).all();
+            if (exact === undefined || exact.role !== 'owner' || exact.status !== 'active'
+                || exact.linked_to_id !== null || activeOwners.length !== 1 || activeOwners[0]?.id !== exact.id) {
+                throw new DeliveryStoreError('unauthorized-principal', 'local owner initialization cannot alter existing authority');
+            }
+            return principalFromRow(exact);
+        });
+    }
     isAuthorizedPrincipal(input) {
         this.assertOpen();
         const row = this.database.prepare('SELECT status FROM delivery_principals WHERE key_hash = ?')
@@ -1608,6 +1716,17 @@ export class DeliveryStore {
         const now = this.now();
         const id = `binding_${randomUUID()}`;
         return this.transaction(() => {
+            const construction = input.constructionLease === undefined ? undefined : this.sessionLeaseCurrent(input.constructionLease, true);
+            if (input.constructionLease !== undefined) {
+                const candidate = construction === undefined ? undefined : JSON.parse(construction.target_json);
+                const expected = { kind: 'construction', sessionId, conversation: target.conversation,
+                    principal: target.principal, workspace, agentPreset, generation: input.expectedGeneration ?? 1 };
+                if (construction === undefined || candidate?.kind !== 'construction' || candidate.previous !== undefined
+                    || !['prepared', 'dispatched'].includes(construction.state)
+                    || leaseSessionIdentity(candidate) !== leaseSessionIdentity(expected)) {
+                    throw new DeliveryStoreError('stale-fence', 'binding construction lease is no longer exact');
+                }
+            }
             const principalRow = this.database.prepare(`
         SELECT id, principal_json, role, status, linked_to_id, created_at, updated_at, version
         FROM delivery_principals
@@ -1622,6 +1741,8 @@ export class DeliveryStore {
         WHERE conversation_hash = ? AND conversation_json = ? AND status = 'active'
       `).get(hash, canonicalConversationJson);
             if (existingRow !== undefined) {
+                if (construction !== undefined)
+                    throw new DeliveryStoreError('conflict', 'construction already has a binding');
                 const existing = bindingFromRow(existingRow);
                 if (principalHash(existing.principal) !== canonicalPrincipalHash) {
                     throw new DeliveryStoreError('conflict', 'conversation is already bound to another principal');
@@ -1641,7 +1762,15 @@ export class DeliveryStore {
           session_id, generation, policy_ref, status, created_at, updated_at, version
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, 1)
       `).run(id, hash, canonicalConversationJson, principal.id, canonicalPrincipalJson, workspace, agentPreset, sessionId, generation, policyRef, now, now);
-            return this.getBinding(id);
+            const binding = this.getBinding(id);
+            if (construction !== undefined) {
+                const promoted = this.database.prepare(`UPDATE delivery_session_leases SET target_json = ?
+          WHERE session_id = ? AND holder_id = ? AND fencing_token = ? AND state IN ('prepared', 'dispatched')`)
+                    .run(leaseTargetJson({ kind: 'bound', binding }), construction.session_id, construction.holder_id, construction.fencing_token);
+                if (Number(promoted.changes) !== 1)
+                    throw new DeliveryStoreError('stale-fence', 'construction binding promotion lost its lease');
+            }
+            return binding;
         });
     }
     /**
@@ -2054,6 +2183,123 @@ export class DeliveryStore {
         }
         return { duplicate: false, record: this.getInbox(id) };
     }
+    /**
+     * Admit and claim one exact Host-native input under one SQLite write fence.
+     *
+     * The normal Delivery scheduler can only claim queued work.  Publishing a
+     * fresh native input directly as `claimed` therefore prevents it from
+     * observing a moment where the input is in the ordinary queue.  Replays are
+     * read-only: a duplicate never renews, reclaims, or otherwise re-executes
+     * its existing Inbox.
+     */
+    claimNativeInbox(input) {
+        this.assertOpen();
+        const envelope = canonicalEnvelope(input.envelope, this.maxTextBytes);
+        const json = JSON.stringify(envelope);
+        const hash = digest(json);
+        const ownerId = validateBindingText(input.ownerId, 'ownerId', 256);
+        if (!Number.isSafeInteger(input.leaseMs) || input.leaseMs < 1) {
+            throw new DeliveryStoreError('conflict', 'invalid inbox lease');
+        }
+        let bindingId;
+        let sessionId;
+        let bindingConversationJson;
+        let bindingPrincipalJson;
+        try {
+            bindingId = validateBindingText(input.binding.id, 'binding.id', 256);
+            sessionId = validateBindingText(input.binding.sessionId, 'binding.sessionId', 512);
+            bindingConversationJson = conversationJson(input.binding.conversation);
+            bindingPrincipalJson = principalJson(input.binding.principal);
+        }
+        catch {
+            throw new DeliveryStoreError('invalid-binding', 'native Inbox binding snapshot is invalid');
+        }
+        if (!Number.isSafeInteger(input.binding.version) || input.binding.version < 1
+            || !Number.isSafeInteger(input.binding.generation) || input.binding.generation < 1) {
+            throw new DeliveryStoreError('invalid-binding', 'native Inbox binding snapshot is invalid');
+        }
+        if (conversationJson(envelope.conversation) !== bindingConversationJson
+            || principalJson(envelope.principal) !== bindingPrincipalJson) {
+            throw new DeliveryStoreError('invalid-binding', 'native Inbox envelope does not belong to its binding');
+        }
+        const now = this.now();
+        const id = `inbox_${randomUUID()}`;
+        return this.transaction(() => {
+            const existing = this.database.prepare(`${inboxSelect} WHERE channel = ? AND account = ? AND event_id = ?`)
+                .get(envelope.channel, envelope.account, envelope.eventId);
+            if (existing !== undefined) {
+                if (existing.envelope_hash !== hash) {
+                    throw new DeliveryStoreError('idempotency-conflict', 'provider event id was reused with a different envelope');
+                }
+                return { duplicate: true, record: inboxFromRow(existing) };
+            }
+            const binding = this.database.prepare(`${bindingSelect} WHERE id = ?`).get(bindingId);
+            const bindingPrincipal = this.database.prepare('SELECT principal_id FROM conversation_bindings WHERE id = ?').get(bindingId);
+            const principal = this.database.prepare(`
+        SELECT id, principal_json, role, status, linked_to_id, created_at, updated_at, version
+        FROM delivery_principals WHERE key_hash = ? AND principal_json = ?
+      `).get(principalHash(input.binding.principal), bindingPrincipalJson);
+            if (binding === undefined || binding.status !== 'active'
+                || binding.version !== input.binding.version || binding.generation !== input.binding.generation
+                || binding.session_id !== sessionId || binding.conversation_json !== bindingConversationJson
+                || binding.principal_json !== bindingPrincipalJson
+                || principal === undefined || principal.id !== bindingPrincipal?.principal_id
+                || principal.id !== input.ownerLineage.principalRecordId || principal.version !== input.ownerLineage.principalVersion
+                || principal.status !== 'active' || principal.role !== 'owner') {
+                throw new DeliveryStoreError('invalid-binding', 'native Inbox binding is no longer an active owner binding');
+            }
+            this.database.prepare(`
+        INSERT INTO inbox_messages (
+          id, channel, account, event_id, envelope_hash, envelope_json, status, binding_id,
+          attempt_count, claimed_by, fencing_token, lease_until, received_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, 'received', ?, 0, NULL, NULL, NULL, ?, ?)
+      `).run(id, envelope.channel, envelope.account, envelope.eventId, hash, json, bindingId, now, now);
+            for (const [ordinal, attachment] of (envelope.attachments ?? []).entries()) {
+                const descriptorHash = digest(JSON.stringify(attachment));
+                this.database.prepare(`
+          INSERT INTO delivery_attachments (
+            id, owner_kind, owner_id, ordinal, media_type, size_bytes, sha256, spool_ref,
+            resource_kind, provider_ref, file_name, status, expires_at, created_at
+          ) VALUES (?, 'inbox', ?, ?, ?, ?, ?, NULL, ?, ?, ?, 'metadata', NULL, ?)
+        `).run(`attachment_${digest(`${id}:${ordinal}:${attachment.providerRef}`).slice(0, 40)}`, id, ordinal, attachment.mediaType ?? '', attachment.sizeBytes ?? 0, descriptorHash, attachment.resourceType, attachment.providerRef, attachment.fileName ?? null, now);
+            }
+            const blocked = this.database.prepare(`
+        SELECT 1 FROM inbox_messages AS earlier
+        LEFT JOIN conversation_bindings AS earlier_binding ON earlier_binding.id = earlier.binding_id
+        JOIN delivery_inbox_admissions AS earlier_admission ON earlier_admission.inbox_id = earlier.id
+        JOIN delivery_inbox_admissions AS admitted ON admitted.inbox_id = ?
+        WHERE earlier.id <> ? AND earlier.status NOT IN ('processed', 'dead_letter')
+          AND (
+            (earlier_binding.workspace = ? AND earlier_binding.agent_preset = ?
+              AND earlier_binding.principal_id = ?)
+            OR (earlier.binding_id IS NULL
+              AND json_extract(earlier.envelope_json, '$.conversation') = json(?)
+              AND json_extract(earlier.envelope_json, '$.principal') = json(?))
+          )
+          AND (earlier_admission.admission_sequence < admitted.admission_sequence
+            OR earlier.status = 'claimed')
+        LIMIT 1
+      `).get(id, id, binding.workspace, binding.agent_preset, principal.id, bindingConversationJson, bindingPrincipalJson);
+            if (blocked !== undefined) {
+                throw new DeliveryStoreError('conflict', 'native Inbox lane has unfinished earlier or active work');
+            }
+            const previousFence = this.database.prepare('SELECT COALESCE(MAX(fencing_token), 0) AS maximum FROM inbox_attempts WHERE inbox_id = ?').get(id);
+            const fencingToken = previousFence.maximum + 1;
+            const claimed = this.database.prepare(`
+        UPDATE inbox_messages SET status = 'claimed', claimed_by = ?, fencing_token = ?, lease_until = ?,
+          attempt_count = 1, failure_code = 'native-admission', updated_at = ?
+        WHERE id = ? AND status = 'received' AND binding_id = ?
+      `).run(ownerId, fencingToken, now + input.leaseMs, now, id, bindingId);
+            if (claimed.changes !== 1) {
+                throw new DeliveryStoreError('conflict', 'native Inbox claim lost its admission fence');
+            }
+            this.database.prepare(`
+        INSERT INTO inbox_attempts (id, inbox_id, attempt_number, owner_id, fencing_token, status, created_at)
+        VALUES (?, ?, 1, ?, ?, 'claimed', ?)
+      `).run(`inbox_attempt_${randomUUID()}`, id, ownerId, fencingToken, now);
+            return { duplicate: false, record: this.getInbox(id), fencingToken };
+        });
+    }
     listAttachments(input) {
         this.assertOpen();
         const rows = this.database.prepare(`
@@ -2175,6 +2421,16 @@ export class DeliveryStore {
         }
         const now = this.now();
         this.transaction(() => {
+            const current = this.getActiveBinding(record.envelope.conversation);
+            const principal = this.getBindingPrincipal(binding.id);
+            if (current?.id !== binding.id || current.version !== binding.version
+                || current.generation !== binding.generation || current.sessionId !== binding.sessionId) {
+                throw new DeliveryStoreError('invalid-binding', 'inbox binding is no longer the exact active generation');
+            }
+            if (principal?.status !== 'active'
+                || JSON.stringify(principal.principal) !== JSON.stringify(binding.principal)) {
+                throw new DeliveryStoreError('unauthorized-principal', 'inbox binding principal is not active');
+            }
             if (record.status === 'received') {
                 this.database.prepare(`
           UPDATE inbox_messages SET status = 'authorized', binding_id = ?, updated_at = ?
@@ -2337,6 +2593,27 @@ export class DeliveryStore {
     `).get(boundary.admission_sequence, conversationJson(target.conversation), principalJson(target.principal));
         return row === undefined ? undefined : inboxFromRow(row);
     }
+    /**
+     * List a bounded page of persisted admissions that have not reached the
+     * worker queue yet. The admission cursor, rather than timestamps or rowid,
+     * preserves the global order across restarts and database maintenance.
+     */
+    listRecoverableInboundAdmissions(input = {}) {
+        this.assertOpen();
+        const afterSequence = input.afterSequence ?? 0;
+        if (!Number.isSafeInteger(afterSequence) || afterSequence < 0) {
+            throw new DeliveryStoreError('conflict', 'invalid inbound admission recovery cursor');
+        }
+        const limit = boundedMaintenanceLimit(input.limit, 100, 'inbound admission recovery');
+        const rows = this.database.prepare(`${inboxSelect}
+      JOIN delivery_inbox_admissions AS pending_admission
+        ON pending_admission.inbox_id = inbox_messages.id
+      WHERE inbox_messages.status IN ('received', 'authorized')
+        AND pending_admission.admission_sequence > ?
+      ORDER BY pending_admission.admission_sequence LIMIT ?
+    `).all(afterSequence, limit);
+        return rows.map(inboxFromRow);
+    }
     listInbox(input = {}) {
         this.assertOpen();
         const limit = Math.max(1, Math.min(100, input.limit ?? 20));
@@ -2569,7 +2846,9 @@ export class DeliveryStore {
       `).all(now, input.maxAttempts, input.limit);
             for (const candidate of candidates) {
                 const current = this.getInbox(candidate.id);
-                const fencingToken = current.attemptCount + 1;
+                const previousFence = this.database.prepare('SELECT COALESCE(MAX(fencing_token), 0) AS maximum FROM inbox_attempts WHERE inbox_id = ?')
+                    .get(current.id);
+                const fencingToken = previousFence.maximum + 1;
                 const changed = this.database.prepare(`
           UPDATE inbox_messages SET status = 'claimed', claimed_by = ?, fencing_token = ?, lease_until = ?,
             attempt_count = attempt_count + 1, next_attempt_at = NULL,
@@ -2616,6 +2895,49 @@ export class DeliveryStore {
         });
         return this.getInbox(input.inboxId);
     }
+    /** Return an undispatched Inbox to its queue while another live session holds the lane. */
+    deferInboxForSessionLease(input) {
+        this.assertOpen();
+        let inboxId;
+        let ownerId;
+        try {
+            inboxId = validateBindingText(input.inboxId, 'inboxId', 256);
+            ownerId = validateBindingText(input.ownerId, 'ownerId', 256);
+        }
+        catch {
+            return false;
+        }
+        const now = this.now();
+        if (!Number.isSafeInteger(input.fencingToken) || input.fencingToken < 1
+            || !Number.isSafeInteger(input.retryAt) || input.retryAt < now)
+            return false;
+        return this.transaction(() => {
+            const changed = this.database.prepare(`
+        UPDATE inbox_messages AS inbox
+        SET status = 'retry_wait', next_attempt_at = ?, attempt_count = attempt_count - 1,
+          claimed_by = NULL, lease_until = NULL, failure_code = 'session-lease-busy', updated_at = ?
+        WHERE inbox.id = ? AND inbox.status = 'claimed' AND inbox.claimed_by = ?
+          AND inbox.fencing_token = ? AND inbox.lease_until > ? AND inbox.attempt_count >= 1
+          AND inbox.failure_code IS NULL
+          AND EXISTS (
+            SELECT 1 FROM conversation_bindings AS binding
+            JOIN delivery_session_leases AS lease ON lease.session_id = binding.session_id
+            WHERE binding.id = inbox.binding_id AND lease.state IN ('prepared', 'dispatched')
+              AND lease.lease_until > ?
+          )
+      `).run(input.retryAt, now, inboxId, ownerId, input.fencingToken, now, now);
+            if (Number(changed.changes) !== 1)
+                return false;
+            const settled = this.database.prepare(`
+        UPDATE inbox_attempts SET status = 'retry_wait', failure_code = 'session-lease-busy', finished_at = ?
+        WHERE inbox_id = ? AND owner_id = ? AND fencing_token = ? AND status = 'claimed'
+      `).run(now, inboxId, ownerId, input.fencingToken);
+            if (Number(settled.changes) !== 1) {
+                throw new DeliveryStoreError('conflict', 'session lease defer attempt settlement is missing');
+            }
+            return true;
+        });
+    }
     markInboxDispatching(input) {
         this.assertOpen();
         let bindingId;
@@ -2638,7 +2960,7 @@ export class DeliveryStore {
         const now = this.now();
         return this.transaction(() => {
             const changed = this.database.prepare(`
-        UPDATE inbox_messages AS inbox SET failure_code = CASE WHEN failure_code IN (
+        UPDATE inbox_messages AS inbox SET failure_code = CASE WHEN failure_code = 'native-admission' THEN 'native-dispatch-started' WHEN failure_code IN (
           'permission-dispatch-recovery',
           'permission-cancelled-recovery',
           'permission-failure-notice-recovery',
@@ -2675,6 +2997,99 @@ export class DeliveryStore {
             throw new DeliveryStoreError('invalid-binding', 'inbox dispatch binding snapshot is no longer active');
         });
     }
+    /** Immutable pre-prompt binding for a foreground acceptance contract. */
+    bindForegroundTaskAcceptance(input) {
+        this.assertOpen();
+        if (!/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/u.test(input.contractId)
+            || !/^[a-f0-9]{64}$/u.test(input.contractDigest)
+            || !Number.isSafeInteger(input.dispatchedAt) || input.dispatchedAt < 0
+            || !Number.isSafeInteger(input.owner.principalVersion) || input.owner.principalVersion < 1
+            || !Number.isSafeInteger(input.binding.version) || input.binding.version < 1
+            || !Number.isSafeInteger(input.binding.generation) || input.binding.generation < 1) {
+            throw new DeliveryStoreError('invalid-binding', 'foreground acceptance binding is invalid');
+        }
+        const text = [input.inboxId, input.scope.workspace, input.scope.preset, input.owner.principalRecordId, input.binding.id];
+        if (text.some(value => typeof value !== 'string' || value.trim() === '' || Buffer.byteLength(value, 'utf8') > 4_096)) {
+            throw new DeliveryStoreError('invalid-binding', 'foreground acceptance binding text is invalid');
+        }
+        this.transaction(() => {
+            const existing = this.database.prepare('SELECT * FROM delivery_task_acceptance_executions WHERE inbox_id = ?')
+                .get(input.inboxId);
+            if (existing !== undefined) {
+                if (existing.contract_id !== input.contractId || existing.contract_digest !== input.contractDigest
+                    || existing.workspace !== input.scope.workspace || existing.preset !== input.scope.preset
+                    || existing.principal_record_id !== input.owner.principalRecordId || existing.principal_version !== input.owner.principalVersion
+                    || existing.binding_id !== input.binding.id || existing.binding_version !== input.binding.version
+                    || existing.binding_generation !== input.binding.generation) {
+                    throw new DeliveryStoreError('idempotency-conflict', 'foreground acceptance binding changed');
+                }
+                throw new DeliveryStoreError('idempotency-conflict', 'accepted foreground task has already crossed its dispatch boundary');
+            }
+            const admitted = this.database.prepare(`
+        SELECT inbox.id FROM inbox_messages AS inbox
+        JOIN conversation_bindings AS binding ON binding.id = inbox.binding_id
+        JOIN delivery_principals AS principal ON principal.id = binding.principal_id
+        WHERE inbox.id = ? AND inbox.status = 'claimed' AND inbox.binding_id = ?
+          AND binding.status = 'active' AND binding.version = ? AND binding.generation = ?
+          AND principal.status = 'active' AND principal.role = 'owner'
+          AND principal.id = ? AND principal.version = ?
+          AND binding.workspace = ? AND binding.agent_preset = ?
+      `).get(input.inboxId, input.binding.id, input.binding.version, input.binding.generation, input.owner.principalRecordId, input.owner.principalVersion, input.scope.workspace, input.scope.preset);
+            if (admitted === undefined)
+                throw new DeliveryStoreError('invalid-binding', 'foreground acceptance is not bound to the claimed owner inbox');
+            this.database.prepare(`INSERT INTO delivery_task_acceptance_executions(
+        inbox_id, contract_id, contract_digest, workspace, preset, principal_record_id, principal_version,
+        binding_id, binding_version, binding_generation, dispatched_at, status, quiescent
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', 0)`).run(input.inboxId, input.contractId, input.contractDigest, input.scope.workspace, input.scope.preset, input.owner.principalRecordId, input.owner.principalVersion, input.binding.id, input.binding.version, input.binding.generation, input.dispatchedAt);
+        });
+    }
+    finishForegroundTaskAcceptance(input) {
+        this.assertOpen();
+        if (!['succeeded', 'failed', 'timed-out', 'cancelled', 'unknown'].includes(input.status)
+            || !Number.isSafeInteger(input.completedAt) || input.completedAt < 0) {
+            throw new DeliveryStoreError('invalid-binding', 'foreground acceptance completion is invalid');
+        }
+        const status = input.quiescent && input.status === 'succeeded' ? 'succeeded' : 'unknown';
+        const quiescent = status === 'succeeded' ? 1 : 0;
+        const changed = this.database.prepare(`UPDATE delivery_task_acceptance_executions
+      SET status = ?, quiescent = ?, completed_at = ?, execution_ref = inbox_id
+      WHERE contract_id = ? AND status = 'pending' AND dispatched_at <= ?`).run(status, quiescent, input.completedAt, input.contractId, input.completedAt);
+        if (changed.changes !== 1) {
+            const current = this.database.prepare('SELECT status, quiescent, completed_at FROM delivery_task_acceptance_executions WHERE contract_id = ?')
+                .get(input.contractId);
+            if (current?.status === status && current.quiescent === quiescent && current.completed_at === input.completedAt)
+                return;
+            throw new DeliveryStoreError('conflict', 'foreground acceptance binding is absent or its completion changed');
+        }
+    }
+    inspectForegroundAcceptedExecution(contract) {
+        const row = this.database.prepare(`SELECT * FROM delivery_task_acceptance_executions
+      WHERE contract_id = ?`).get(contract.id);
+        if (row === undefined || row.contract_digest !== contract.digest || contract.task.kind !== 'foreground-turn'
+            || contract.task.ref !== row.inbox_id || row.workspace !== contract.scope.workspace || row.preset !== contract.scope.preset
+            || row.principal_record_id !== contract.owner.principalRecordId || row.principal_version !== contract.owner.principalVersion
+            || row.completed_at === null || row.execution_ref === null)
+            return null;
+        return Object.freeze({ contractId: row.contract_id, contractDigest: row.contract_digest,
+            dispatchedAt: row.dispatched_at, status: row.status, quiescent: row.quiescent === 1,
+            completedAt: row.completed_at, executionRef: row.execution_ref });
+    }
+    /**
+     * Re-read the immutable acceptance fence for one exact owner reply target.
+     * This deliberately exposes only the completed execution receipt: callers
+     * cannot manufacture a foreground subject by naming an arbitrary Inbox.
+     */
+    inspectForegroundAcceptedExecutionForOwner(input) {
+        const row = this.database.prepare(`SELECT contract_id, contract_digest, dispatched_at, status, quiescent, completed_at, execution_ref
+      FROM delivery_task_acceptance_executions
+      WHERE inbox_id = ? AND workspace = ? AND preset = ? AND principal_record_id = ?
+        AND principal_version = ? AND binding_id = ?`).get(input.inboxId, input.scope.workspace, input.scope.preset, input.owner.principalRecordId, input.owner.principalVersion, input.bindingId);
+        if (row === undefined || row.completed_at === null || row.execution_ref !== input.inboxId)
+            return null;
+        return Object.freeze({ contractId: row.contract_id, contractDigest: row.contract_digest,
+            dispatchedAt: row.dispatched_at, status: row.status, quiescent: row.quiescent === 1,
+            completedAt: row.completed_at, executionRef: row.execution_ref });
+    }
     renewInboxClaim(input) {
         this.assertOpen();
         const ownerId = validateBindingText(input.ownerId, 'ownerId', 256);
@@ -2752,8 +3167,10 @@ export class DeliveryStore {
                     : existingPermissionRecovery === undefined
                         ? undefined
                         : permissionDispatchRecoveryCode(existingPermissionRecovery);
-                const ambiguous = row.failure_code === 'dispatch-started'
-                    && permissionRecovery === undefined && !feedbackRecovery && !learningRecovery && !workflowRecovery;
+                const acceptedDispatch = this.database.prepare('SELECT inbox_id FROM delivery_task_acceptance_executions WHERE inbox_id = ?').get(row.id) !== undefined;
+                const ambiguous = acceptedDispatch || row.failure_code === 'native-admission' || row.failure_code === 'native-dispatch-started'
+                    || (row.failure_code === 'dispatch-started'
+                        && permissionRecovery === undefined && !feedbackRecovery && !learningRecovery && !workflowRecovery);
                 const exhausted = row.attempt_count >= input.maxAttempts
                     && permissionRecovery === undefined && !feedbackRecovery && !learningRecovery && !workflowRecovery;
                 const changed = this.database.prepare(`
@@ -2891,6 +3308,65 @@ export class DeliveryStore {
             return outbox;
         });
     }
+    /** Atomically insert a typed whole-goal result and its immutable authority sidecar. */
+    enqueueGoalOutcomeTarget(input) {
+        this.assertOpen();
+        let locator;
+        let proof;
+        try {
+            locator = validateOwnerGoalOutcomeFeedbackLocator(input.locator);
+            proof = validateOwnerGoalOutcomeFeedbackProof(input.proof);
+        }
+        catch {
+            throw new DeliveryStoreError('invalid-intent', 'goal outcome target is invalid');
+        }
+        if (acceptanceCanonicalJson(locator) !== acceptanceCanonicalJson(proof.locator)) {
+            throw new DeliveryStoreError('invalid-intent', 'goal outcome locator does not match its proof');
+        }
+        return this.transaction(() => {
+            const binding = this.getBinding(locator.bindingId);
+            const owner = binding === undefined ? undefined : this.getBindingPrincipal(binding.id);
+            if (binding === undefined || binding.status !== 'active'
+                || binding.version !== locator.bindingVersion || binding.generation !== locator.bindingGeneration
+                || binding.sessionId !== locator.sessionId || binding.workspace !== locator.workspace
+                || binding.agentPreset !== locator.preset || externalPrincipalId(binding.principal) !== locator.principalId
+                || owner?.status !== 'active' || owner.role !== 'owner' || owner.id !== locator.principalRecordId
+                || owner.version !== locator.principalVersion || externalPrincipalId(owner.principal) !== locator.principalId) {
+                throw new DeliveryStoreError('invalid-binding', 'goal outcome target exact owner fence changed');
+            }
+            const intent = canonicalIntent(input.intent, binding, this.maxTextBytes);
+            const intentHash = digest(JSON.stringify(intent));
+            const winnerRow = this.database.prepare(`${outboxSelect} WHERE idempotency_key = ?`)
+                .get(intent.idempotencyKey);
+            if (winnerRow !== undefined) {
+                const sidecar = this.getGoalOutcomeTarget(winnerRow.id);
+                if (winnerRow.intent_hash !== intentHash || sidecar === undefined
+                    || !sameGoalOutcomeTarget(sidecar, locator, proof)) {
+                    throw new DeliveryStoreError('idempotency-conflict', 'goal outcome Outbox winner does not match the exact immutable target and intent');
+                }
+                return outboxFromRow(winnerRow);
+            }
+            const outbox = this.enqueueIntent(intent, false);
+            this.database.prepare(`
+        INSERT INTO delivery_goal_outcome_targets(
+          outbox_id, locator_json, proof_json, proof_digest, owner_route_id, principal_id,
+          principal_record_id, principal_version, workspace, preset, binding_id, binding_version,
+          binding_generation, session_id, goal_id, assessment_id
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(outbox.id, acceptanceCanonicalJson(locator), acceptanceCanonicalJson(proof), proof.proofDigest, locator.ownerRouteId, locator.principalId, locator.principalRecordId, locator.principalVersion, locator.workspace, locator.preset, locator.bindingId, locator.bindingVersion, locator.bindingGeneration, locator.sessionId, locator.goalId, locator.assessmentId);
+            return outbox;
+        });
+    }
+    getGoalOutcomeTarget(outboxId) {
+        this.assertOpen();
+        const row = this.database.prepare(`
+      SELECT outbox_id, locator_json, proof_json, proof_digest, owner_route_id, principal_id,
+        principal_record_id, principal_version, workspace, preset, binding_id, binding_version,
+        binding_generation, session_id, goal_id, assessment_id
+      FROM delivery_goal_outcome_targets WHERE outbox_id = ?
+    `).get(outboxId);
+        return row === undefined ? undefined : goalOutcomeTargetFromRow(row);
+    }
     /**
      * Resolve and enqueue one Host-owned stable owner route under the same
      * `BEGIN IMMEDIATE` fence as Outbox insertion.
@@ -4456,10 +4932,26 @@ export class DeliveryStore {
      * A normal durable reply alone is intentionally insufficient; the owner
      * must have replied `/feedback achieved` to that exact provider message.
      */
+    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);
+        if (row !== undefined) {
+            if (lineage !== undefined && (row.principal_record_id !== lineage.principalRecordId || row.principal_version !== lineage.principalVersion))
+                return undefined;
+            return { version: row.version, objectiveStatus: row.objective_status };
+        }
+        const initial = this.database.prepare(`SELECT objective_status, principal_record_id FROM workflow_verified_task_feedback WHERE source_outbox_id = ?`)
+            .get(sourceOutboxId);
+        // Legacy receipts predate principal-version audit. Only an unchanged first
+        // principal incarnation can prove that no authority turnover occurred.
+        if (lineage !== undefined && (lineage.principalVersion !== 1 || initial?.principal_record_id !== lineage.principalRecordId))
+            return undefined;
+        return initial === undefined ? undefined : { version: 1, objectiveStatus: initial.objective_status };
+    }
     commitVerifiedWorkflowTraceFeedback(input) {
         this.assertOpen();
         if (typeof input !== 'object' || input === null
-            || !['achieved', 'partial', 'not-achieved'].includes(input.objectiveStatus)
+            || !['achieved', 'partial', 'not-achieved', 'unknown'].includes(input.objectiveStatus)
             || typeof input.feedbackInboxId !== 'string' || typeof input.sourceInboxId !== 'string'
             || typeof input.sourceOutboxId !== 'string') {
             throw new DeliveryStoreError('conflict', 'verified workflow feedback tuple is invalid');
@@ -4467,7 +4959,7 @@ export class DeliveryStore {
         const feedbackInboxId = validateBindingText(input.feedbackInboxId, 'workflow feedback inbox id', 256);
         const sourceInboxId = validateBindingText(input.sourceInboxId, 'workflow source inbox id', 256);
         const sourceOutboxId = validateBindingText(input.sourceOutboxId, 'workflow source outbox id', 256);
-        return this.transaction(() => {
+        const committed = this.transaction(() => {
             const binding = this.getBinding(input.binding.id);
             const owner = binding === undefined ? undefined : this.getPrincipal(binding.principal);
             if (binding === undefined || binding.status !== 'active' || binding.conversation.kind !== 'dm'
@@ -4490,7 +4982,9 @@ export class DeliveryStore {
                 : parseFeedbackCommand(feedbackCommand.rawInput);
             if (feedbackInbox?.status !== 'claimed' || feedbackInbox.bindingId !== binding.id
                 || (feedbackInbox.envelope.attachments?.length ?? 0) !== 0
-                || feedback?.kind !== 'objective' || feedback.objectiveStatus !== input.objectiveStatus
+                || (feedback?.kind !== 'objective' && feedback?.kind !== 'objective-revision')
+                || feedback.objectiveStatus !== input.objectiveStatus
+                || JSON.stringify(feedback.kind === 'objective-revision' ? feedback : undefined) !== JSON.stringify(input.command)
                 || sourceInbox?.status !== 'processed' || sourceInbox.bindingId !== binding.id
                 || sourceInbox.envelope.kind !== 'text' || (sourceInbox.envelope.attachments?.length ?? 0) !== 0
                 || sourceOutbox === undefined || sourceOutbox.intent.bindingId !== binding.id
@@ -4512,6 +5006,58 @@ export class DeliveryStore {
                 || JSON.stringify(sourceOutbox.intent.target.principal) !== JSON.stringify(binding.principal)) {
                 throw new DeliveryStoreError('conflict', 'verified workflow feedback does not target one completed owner turn');
             }
+            const replay = this.database.prepare(`SELECT result_json, principal_record_id, principal_version FROM delivery_owner_objective_commands WHERE inbox_id = ?`)
+                .get(feedbackInbox.id);
+            if (replay !== undefined) {
+                if (replay.principal_record_id !== owner.id || replay.principal_version !== owner.version) {
+                    throw new DeliveryStoreError('unauthorized-principal', 'owner command lineage changed');
+                }
+                const receipt = JSON.parse(replay.result_json);
+                if (receipt.error === 'version-conflict' || receipt.error === 'idempotency-conflict')
+                    return new DeliveryStoreError(receipt.error, 'feedback version changed; reply /feedback status and retry');
+                return { ...receipt, replayed: true };
+            }
+            const currentState = this.verifiedWorkflowObjectiveState(sourceOutbox.id, { principalRecordId: owner.id, principalVersion: owner.version });
+            const currentOwner = this.database.prepare(`SELECT 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(sourceOutbox.id);
+            if (currentOwner !== undefined && (currentOwner.principal_record_id !== owner.id || currentOwner.principal_version !== owner.version)) {
+                throw new DeliveryStoreError('unauthorized-principal', 'owner lineage changed');
+            }
+            if (input.command !== undefined && (currentState === undefined
+                || currentState.version !== input.command.expectedVersion
+                || currentState.objectiveStatus !== input.command.previousStatus)) {
+                this.database.prepare(`INSERT INTO delivery_owner_objective_commands VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+                    .run(feedbackInbox.id, sourceOutbox.id, owner.id, owner.version, currentState?.version ?? 0, currentState?.objectiveStatus ?? 'unknown', JSON.stringify(feedback), JSON.stringify({ error: 'version-conflict' }));
+                return new DeliveryStoreError('version-conflict', 'feedback version changed; reply /feedback status and retry');
+            }
+            const nextVersion = currentState === undefined ? 1 : currentState.objectiveStatus === input.objectiveStatus
+                ? currentState.version : currentState.version + 1;
+            const finish = (result) => {
+                const response = { ...result, ownerFeedbackState: { version: nextVersion, objectiveStatus: input.objectiveStatus } };
+                this.database.prepare(`INSERT INTO delivery_owner_objective_commands VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+                    .run(feedbackInbox.id, sourceOutbox.id, owner.id, owner.version, nextVersion, input.objectiveStatus, JSON.stringify(feedback), JSON.stringify(response));
+                return response;
+            };
+            if (currentState !== undefined && (input.command !== undefined || currentState.version >= 1)
+                && (input.command === undefined || currentState.objectiveStatus === input.objectiveStatus)) {
+                if (currentState.objectiveStatus !== input.objectiveStatus) {
+                    this.database.prepare(`INSERT INTO delivery_owner_objective_commands VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+                        .run(feedbackInbox.id, sourceOutbox.id, owner.id, owner.version, currentState.version, currentState.objectiveStatus, JSON.stringify(feedback), JSON.stringify({ error: 'idempotency-conflict' }));
+                    return new DeliveryStoreError('idempotency-conflict', 'current owner judgement differs; use explicit correction');
+                }
+                const currentReceipt = this.database.prepare(`SELECT result_json FROM delivery_owner_objective_commands
+          WHERE source_outbox_id = ? AND version = ? AND json_extract(result_json, '$.error') IS NULL LIMIT 1`)
+                    .get(sourceOutbox.id, currentState.version);
+                if (currentReceipt !== undefined)
+                    return finish({ ...JSON.parse(currentReceipt.result_json), replayed: true });
+            }
+            const subjectRef = growthObjectDigest({
+                contract: 'assistant-delivery-verified-workflow-subject/v1',
+                bindingId: binding.id, sourceInboxId: sourceInbox.id, sourceOutboxId: sourceOutbox.id,
+            });
+            const traceHead = this.database.prepare(`SELECT version FROM workflow_trace_current WHERE subject_ref = ?`)
+                .get(subjectRef);
+            const traceVersion = (traceHead?.version ?? 0) + 1;
             const taskRef = growthObjectDigest({
                 contract: 'assistant-delivery-verified-workflow-task-ref/v1',
                 bindingId: binding.id,
@@ -4546,7 +5092,7 @@ export class DeliveryStore {
             const prior = this.database.prepare(`
         SELECT * FROM workflow_verified_task_feedback WHERE source_outbox_id = ?
       `).get(sourceOutbox.id);
-            if (prior !== undefined) {
+            if (prior !== undefined && input.command === undefined) {
                 return this.replayVerifiedWorkflowTraceFeedback({
                     row: prior,
                     binding,
@@ -4563,21 +5109,28 @@ export class DeliveryStore {
                 ? deriveDeterministicallyDeidentifiedWorkflowTemplate(sourceInbox.envelope.text)
                 : undefined;
             if (descriptor === undefined) {
-                this.insertVerifiedWorkflowTaskFeedback({
-                    sourceOutboxId: sourceOutbox.id,
-                    sourceInboxId: sourceInbox.id,
-                    feedbackInboxId: feedbackInbox.id,
-                    binding,
-                    ownerId: owner.id,
-                    objectiveStatus: input.objectiveStatus,
-                    taskRef,
-                    taskEvidenceDigest,
-                });
-                return Object.freeze({
+                if (input.command !== undefined && traceHead !== undefined) {
+                    const payload = { source: this.workflowTraceSourceAttestation(),
+                        scope: { workspace: binding.workspace, preset: binding.agentPreset },
+                        subjectRef, version: traceVersion, disposition: 'retract' };
+                    this.insertWorkflowTraceRevisionInTransaction({ ...payload, digest: workflowTraceRevisionDigest(payload) });
+                }
+                if (input.command === undefined)
+                    this.insertVerifiedWorkflowTaskFeedback({
+                        sourceOutboxId: sourceOutbox.id,
+                        sourceInboxId: sourceInbox.id,
+                        feedbackInboxId: feedbackInbox.id,
+                        binding,
+                        ownerId: owner.id,
+                        objectiveStatus: input.objectiveStatus,
+                        taskRef,
+                        taskEvidenceDigest,
+                    });
+                return finish(Object.freeze({
                     outcome: 'no-trace',
                     reason: input.objectiveStatus === 'achieved' ? 'privacy-abstained' : 'objective-not-achieved',
                     replayed: false,
-                });
+                }));
             }
             const content = validateWorkflowAutomationTemplateContent({
                 scope: { workspace: binding.workspace, preset: binding.agentPreset },
@@ -4641,17 +5194,11 @@ export class DeliveryStore {
             'active', ?, ?, ?, ?, ?, 1)
         `).run(template.templateRef, template.templateDigest, workflowScopeKey(content.scope), content.scope.workspace, content.scope.preset, binding.id, JSON.stringify(content), template.privacyAttestation.attestationId, template.privacyAttestation.attestationDigest, JSON.stringify(privacyReceipt), feedbackInbox.id, sourceInbox.id, sourceOutbox.id, now, now);
             }
-            const subjectRef = growthObjectDigest({
-                contract: 'assistant-delivery-verified-workflow-subject/v1',
-                bindingId: binding.id,
-                sourceInboxId: sourceInbox.id,
-                sourceOutboxId: sourceOutbox.id,
-            });
             const payload = Object.freeze({
                 source: this.workflowTraceSourceAttestation(),
                 scope: Object.freeze({ workspace: binding.workspace, preset: binding.agentPreset }),
                 subjectRef,
-                version: 1,
+                version: traceVersion,
                 disposition: 'upsert',
                 evidence: Object.freeze({
                     occurredAt: feedbackInbox.receivedAt,
@@ -4675,20 +5222,24 @@ export class DeliveryStore {
             if (recorded.replayed) {
                 throw new DeliveryStoreError('version-conflict', 'new verified workflow feedback unexpectedly replayed');
             }
-            this.insertVerifiedWorkflowTaskFeedback({
-                sourceOutboxId: sourceOutbox.id,
-                sourceInboxId: sourceInbox.id,
-                feedbackInboxId: feedbackInbox.id,
-                binding,
-                ownerId: owner.id,
-                objectiveStatus: input.objectiveStatus,
-                taskRef,
-                taskEvidenceDigest,
-                revision,
-                template,
-            });
-            return Object.freeze({ outcome: 'trace-recorded', revision, template, replayed: false });
+            if (input.command === undefined)
+                this.insertVerifiedWorkflowTaskFeedback({
+                    sourceOutboxId: sourceOutbox.id,
+                    sourceInboxId: sourceInbox.id,
+                    feedbackInboxId: feedbackInbox.id,
+                    binding,
+                    ownerId: owner.id,
+                    objectiveStatus: 'achieved',
+                    taskRef,
+                    taskEvidenceDigest,
+                    revision,
+                    template,
+                });
+            return finish(Object.freeze({ outcome: 'trace-recorded', revision, template, replayed: false }));
         });
+        if (committed instanceof DeliveryStoreError)
+            throw committed;
+        return committed;
     }
     insertVerifiedWorkflowTaskFeedback(input) {
         if ((input.revision === undefined) !== (input.template === undefined)) {
@@ -5508,6 +6059,183 @@ export class DeliveryStore {
             throw new DeliveryStoreError('version-conflict', 'workflow template revocation lost its exact version');
         }
     }
+    /** Ownership survives release, revocation and restart; it is not an active-lease query. */
+    requiresSessionLease(sessionId) {
+        this.assertOpen();
+        sessionId = validateBindingText(sessionId, 'sessionId', 512);
+        const row = this.database.prepare(`
+      SELECT (EXISTS (SELECT 1 FROM conversation_bindings WHERE session_id = ?)
+        OR EXISTS (SELECT 1 FROM delivery_session_leases WHERE session_id = ?)) AS managed
+    `).get(sessionId, sessionId);
+        return row.managed === 1;
+    }
+    claimSessionLease(target, holderId, leaseMs) {
+        this.assertOpen();
+        if (!Number.isSafeInteger(leaseMs) || leaseMs < 1 || leaseMs > 300_000)
+            return { kind: 'denied' };
+        let targetJson;
+        let sessionId;
+        try {
+            targetJson = leaseTargetJson(target);
+            sessionId = validateBindingText(target.kind === 'bound' ? target.binding.sessionId : target.sessionId, 'sessionId', 512);
+            holderId = validateBindingText(holderId, 'holderId', 256);
+        }
+        catch {
+            return { kind: 'denied' };
+        }
+        const now = this.now();
+        const leaseUntil = now + leaseMs;
+        if (!Number.isSafeInteger(now) || now < 0 || !Number.isSafeInteger(leaseUntil))
+            return { kind: 'denied' };
+        return this.transaction(() => {
+            const authority = this.sessionLeaseAuthority(target);
+            if (authority === undefined)
+                return { kind: 'denied' };
+            const row = this.database.prepare('SELECT session_id, holder_id, fencing_token, lease_until, state, target_json, principal_record_id, principal_version FROM delivery_session_leases WHERE session_id = ?').get(sessionId);
+            if (row === undefined) {
+                this.database.prepare("INSERT INTO delivery_session_leases(session_id, holder_id, fencing_token, lease_until, state, target_json, principal_record_id, principal_version) VALUES (?, ?, 1, ?, 'prepared', ?, ?, ?)")
+                    .run(sessionId, holderId, leaseUntil, targetJson, authority.id, authority.version);
+                return { kind: 'claimed', lease: Object.freeze({ sessionId, holderId, fencingToken: 1, leaseUntil }) };
+            }
+            // A released construction can outlive a crash before createBinding. Its Session
+            // remains owned by the original identity, even though no binding exists yet.
+            try {
+                if (row.principal_record_id !== authority.id
+                    || leaseSessionIdentity(JSON.parse(row.target_json)) !== leaseSessionIdentity(target))
+                    return { kind: 'denied' };
+            }
+            catch {
+                return { kind: 'denied' };
+            }
+            if (row.state === 'unknown')
+                return { kind: 'unknown' };
+            if (row.state === 'dispatched') {
+                if (row.lease_until > now)
+                    return { kind: 'busy' };
+                this.database.prepare("UPDATE delivery_session_leases SET state = 'unknown' WHERE session_id = ? AND fencing_token = ? AND state = 'dispatched'")
+                    .run(sessionId, row.fencing_token);
+                return { kind: 'unknown' };
+            }
+            if (row.state !== 'prepared' && row.state !== 'released')
+                return { kind: 'unknown' };
+            if (row.state === 'prepared' && row.lease_until > now)
+                return { kind: 'busy' };
+            const token = row.fencing_token + 1;
+            if (!Number.isSafeInteger(token))
+                return { kind: 'denied' };
+            this.database.prepare("UPDATE delivery_session_leases SET holder_id = ?, fencing_token = ?, lease_until = ?, state = 'prepared', target_json = ?, principal_record_id = ?, principal_version = ? WHERE session_id = ? AND fencing_token = ?")
+                .run(holderId, token, leaseUntil, targetJson, authority.id, authority.version, sessionId, row.fencing_token);
+            return { kind: 'claimed', lease: Object.freeze({ sessionId, holderId, fencingToken: token, leaseUntil }) };
+        });
+    }
+    markSessionLeaseDispatched(lease) {
+        this.assertOpen();
+        return this.transaction(() => {
+            const row = this.sessionLeaseCurrent(lease, true);
+            if (row === undefined || row.state !== 'prepared')
+                return false;
+            return Number(this.database.prepare("UPDATE delivery_session_leases SET state = 'dispatched' WHERE session_id = ? AND holder_id = ? AND fencing_token = ? AND state = 'prepared'")
+                .run(lease.sessionId, lease.holderId, lease.fencingToken).changes) === 1;
+        });
+    }
+    hasSessionLease(lease) {
+        this.assertOpen();
+        return this.transaction(() => {
+            const row = this.sessionLeaseCurrent(lease, true);
+            return row !== undefined && (row.state === 'prepared' || row.state === 'dispatched');
+        });
+    }
+    renewSessionLease(lease, leaseMs) {
+        this.assertOpen();
+        if (!Number.isSafeInteger(leaseMs) || leaseMs < 1 || leaseMs > 300_000)
+            return false;
+        return this.transaction(() => {
+            const row = this.sessionLeaseCurrent(lease, true);
+            if (row === undefined || (row.state !== 'prepared' && row.state !== 'dispatched'))
+                return false;
+            const until = this.now() + leaseMs;
+            if (!Number.isSafeInteger(until))
+                return false;
+            return Number(this.database.prepare("UPDATE delivery_session_leases SET lease_until = ? WHERE session_id = ? AND holder_id = ? AND fencing_token = ? AND state IN ('prepared', 'dispatched')")
+                .run(until, lease.sessionId, lease.holderId, lease.fencingToken).changes) === 1;
+        });
+    }
+    finishSessionLease(lease, result) {
+        this.assertOpen();
+        if (!lease || typeof result?.quiescent !== 'boolean' || !this.sessionLeaseShape(lease))
+            return false;
+        return Number(this.database.prepare("UPDATE delivery_session_leases SET state = ? WHERE session_id = ? AND holder_id = ? AND fencing_token = ? AND state IN ('prepared', 'dispatched', 'unknown')")
+            .run(result.quiescent ? 'released' : 'unknown', lease.sessionId, lease.holderId, lease.fencingToken).changes) === 1;
+    }
+    sessionLeaseShape(lease) {
+        return lease !== null && typeof lease === 'object'
+            && typeof lease.sessionId === 'string' && typeof lease.holderId === 'string'
+            && Number.isSafeInteger(lease.fencingToken) && lease.fencingToken >= 1
+            && Number.isSafeInteger(lease.leaseUntil) && lease.leaseUntil >= 0;
+    }
+    /** Re-reads target authority; no runtime-supplied binding is trusted after claim. */
+    sessionLeaseAuthority(target) {
+        try {
+            if (target?.kind !== 'bound' && target?.kind !== 'construction')
+                return undefined;
+            if (target.kind === 'bound') {
+                const current = this.getBinding(target.binding.id);
+                if (current === undefined || !sameLeaseBinding(current, target.binding))
+                    return undefined;
+                const principal = this.getPrincipal(current.principal);
+                return principal?.status === 'active' ? principal : undefined;
+            }
+            const conversation = canonicalConversation(target.conversation);
+            const principalKey = canonicalPrincipal(target.principal);
+            const sessionId = validateBindingText(target.sessionId, 'sessionId', 512);
+            const workspace = validateBindingText(target.workspace, 'workspace', 4_096);
+            const preset = validateBindingText(target.agentPreset, 'agentPreset', 128);
+            if (!isAbsolute(workspace) || !Number.isSafeInteger(target.generation) || target.generation < 1)
+                return undefined;
+            const principal = this.getPrincipal(principalKey);
+            if (principal?.status !== 'active')
+                return undefined;
+            const existingSession = this.database.prepare('SELECT id FROM conversation_bindings WHERE session_id = ?').get(sessionId);
+            if (existingSession !== undefined)
+                return undefined;
+            const existing = this.getActiveBinding(conversation);
+            if (target.previous !== undefined) {
+                const previous = this.getBinding(target.previous.id);
+                if (previous === undefined || !sameLeaseBinding(previous, target.previous)
+                    || previous.generation + 1 !== target.generation
+                    || JSON.stringify(canonicalConversation(previous.conversation)) !== JSON.stringify(conversation)
+                    || JSON.stringify(canonicalPrincipal(previous.principal)) !== JSON.stringify(principalKey)
+                    || previous.workspace !== workspace || previous.agentPreset !== preset
+                    || existing === undefined || !sameLeaseBinding(existing, target.previous))
+                    return undefined;
+            }
+            else if (existing !== undefined || this.nextBindingGenerationByHash(conversationHash(conversation)) !== target.generation)
+                return undefined;
+            return principal;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    sessionLeaseCurrent(lease, requireLiveAuthority) {
+        if (!this.sessionLeaseShape(lease))
+            return undefined;
+        const row = this.database.prepare('SELECT session_id, holder_id, fencing_token, lease_until, state, target_json, principal_record_id, principal_version FROM delivery_session_leases WHERE session_id = ? AND holder_id = ? AND fencing_token = ?')
+            .get(lease.sessionId, lease.holderId, lease.fencingToken);
+        if (row === undefined || row.lease_until <= this.now())
+            return undefined;
+        if (!requireLiveAuthority)
+            return row;
+        let target;
+        try {
+            target = JSON.parse(row.target_json);
+        }
+        catch {
+            return undefined;
+        }
+        const principal = this.sessionLeaseAuthority(target);
+        return principal !== undefined && principal.id === row.principal_record_id && principal.version === row.principal_version ? row : undefined;
+    }
     close() {
         if (this.closed)
             return;