@dsh-enhanced/assistant-delivery 0.1.32 → 0.1.34

package/lib/store.js

@@ -1,7 +1,7 @@
 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 { 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';
@@ -16,6 +16,24 @@ export class DeliveryStoreError extends Error {
         this.name = 'DeliveryStoreError';
     }
 }
+/**
+ * The Goals orchestration primitives that are part of goal bookkeeping rather
+ * than owner-facing business/executive tools. A successful native Goal run is
+ * reducible to the single model-turn fingerprint Automations can run only when
+ * every settled call is one of these read/planning/control primitives; any
+ * other tool (Read/Glob/Grep/Bash/Edit/executive MCP tools, ...) means the
+ * learned automation would need a real tool plane that paused materialization
+ * does not provide, so the goal abstains fail-closed.
+ */
+const OWNER_ANCHORED_REDUCIBLE_GOAL_TOOLS = Object.freeze(new Set([
+    'goal_strategy',
+    'goal_schedule',
+    'goal_wait_event',
+    'goal_create',
+    'goal_context',
+    'goal_checkpoint',
+    'goal_control',
+]));
 function workflowTraceRevision(row) {
     let parsed;
     try {
@@ -3062,6 +3080,46 @@ export class DeliveryStore {
             throw new DeliveryStoreError('conflict', 'foreground acceptance binding is absent or its completion changed');
         }
     }
+    recordForegroundTaskModelSelection(input) {
+        this.assertOpen();
+        if (typeof input.contractId !== 'string' || input.contractId.length === 0 || input.contractId.length > 512
+            || typeof input.provider !== 'string' || typeof input.model !== 'string'
+            || (input.reasoningEffort !== undefined && typeof input.reasoningEffort !== 'string')) {
+            throw new DeliveryStoreError('invalid-binding', 'foreground model selection is invalid');
+        }
+        const provider = modelRoutePart(input.provider, 'provider');
+        const model = modelRoutePart(input.model, 'model');
+        const effort = input.reasoningEffort === undefined ? null : modelRoutePart(input.reasoningEffort, 'effort');
+        this.transaction(() => {
+            const current = this.database.prepare(`SELECT status, model_selection_state, model_provider, model_id, model_reasoning_effort
+        FROM delivery_task_acceptance_executions WHERE contract_id = ?`).get(input.contractId);
+            if (current === undefined)
+                throw new DeliveryStoreError('invalid-binding', 'foreground acceptance is absent');
+            if (current.status !== 'pending')
+                throw new DeliveryStoreError('conflict', 'foreground acceptance model selection is no longer writable');
+            if (current.model_selection_state === 'missing') {
+                const changed = this.database.prepare(`UPDATE delivery_task_acceptance_executions
+          SET model_selection_state = 'frozen', model_provider = ?, model_id = ?, model_reasoning_effort = ?
+          WHERE contract_id = ? AND status = 'pending' AND model_selection_state = 'missing'`).run(provider, model, effort, input.contractId);
+                if (changed.changes !== 1)
+                    throw new DeliveryStoreError('conflict', 'foreground acceptance model selection changed');
+                return;
+            }
+            if (current.model_selection_state === 'frozen') {
+                if (current.model_provider === provider && current.model_id === model && current.model_reasoning_effort === effort)
+                    return;
+                const changed = this.database.prepare(`UPDATE delivery_task_acceptance_executions
+          SET model_selection_state = 'inconsistent', model_provider = NULL, model_id = NULL, model_reasoning_effort = NULL
+          WHERE contract_id = ? AND status = 'pending' AND model_selection_state = 'frozen'`).run(input.contractId);
+                if (changed.changes !== 1)
+                    throw new DeliveryStoreError('conflict', 'foreground acceptance model selection changed');
+                return;
+            }
+            if (current.model_selection_state !== 'inconsistent') {
+                throw new DeliveryStoreError('conflict', 'foreground acceptance model selection state is invalid');
+            }
+        });
+    }
     inspectForegroundAcceptedExecution(contract) {
         const row = this.database.prepare(`SELECT * FROM delivery_task_acceptance_executions
       WHERE contract_id = ?`).get(contract.id);
@@ -3072,7 +3130,8 @@ export class DeliveryStore {
             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 });
+            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 }) }) } : {}) });
     }
     /**
      * Re-read the immutable acceptance fence for one exact owner reply target.
@@ -3080,7 +3139,7 @@ export class DeliveryStore {
      * 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
+        const row = this.database.prepare(`SELECT contract_id, contract_digest, dispatched_at, status, quiescent, completed_at, execution_ref, model_selection_state, model_provider, model_id, model_reasoning_effort
       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);
@@ -3088,7 +3147,120 @@ export class DeliveryStore {
             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 });
+            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 }) }) } : {}) });
+    }
+    /** Immutable pre-prompt receipt for an authenticated owner foreground turn. */
+    bindForegroundTaskExecution(input) {
+        this.assertOpen();
+        if (!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 execution 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 execution binding text is invalid');
+        }
+        this.transaction(() => {
+            if (this.database.prepare('SELECT 1 FROM delivery_foreground_executions WHERE inbox_id = ?').get(input.inboxId) !== undefined) {
+                throw new DeliveryStoreError('idempotency-conflict', '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 execution is not bound to the claimed owner inbox');
+            this.database.prepare(`INSERT INTO delivery_foreground_executions(
+        inbox_id, workspace, preset, principal_record_id, principal_version, binding_id, binding_version,
+        binding_generation, dispatched_at, status, quiescent
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', 0)`).run(input.inboxId, input.scope.workspace, input.scope.preset, input.owner.principalRecordId, input.owner.principalVersion, input.binding.id, input.binding.version, input.binding.generation, input.dispatchedAt);
+        });
+    }
+    finishForegroundTaskExecution(input) {
+        this.assertOpen();
+        if (typeof input.quiescent !== 'boolean'
+            || !['succeeded', 'failed', 'timed-out', 'cancelled', 'unknown'].includes(input.status)
+            || !Number.isSafeInteger(input.completedAt) || input.completedAt < 0) {
+            throw new DeliveryStoreError('invalid-binding', 'foreground execution 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_foreground_executions
+      SET status = ?, quiescent = ?, completed_at = ?, execution_ref = inbox_id
+      WHERE inbox_id = ? AND status = 'pending' AND dispatched_at <= ?`).run(status, quiescent, input.completedAt, input.inboxId, input.completedAt);
+        if (changed.changes !== 1) {
+            const current = this.database.prepare('SELECT status, quiescent, completed_at FROM delivery_foreground_executions WHERE inbox_id = ?')
+                .get(input.inboxId);
+            if (current?.status === status && current.quiescent === quiescent && current.completed_at === input.completedAt)
+                return;
+            throw new DeliveryStoreError('conflict', 'foreground execution is absent or its completion changed');
+        }
+    }
+    recordForegroundExecutionModelSelection(input) {
+        this.assertOpen();
+        if (typeof input.inboxId !== 'string' || input.inboxId.length === 0 || input.inboxId.length > 512
+            || typeof input.provider !== 'string' || typeof input.model !== 'string'
+            || (input.reasoningEffort !== undefined && typeof input.reasoningEffort !== 'string')) {
+            throw new DeliveryStoreError('invalid-binding', 'foreground execution model selection is invalid');
+        }
+        const provider = modelRoutePart(input.provider, 'provider');
+        const model = modelRoutePart(input.model, 'model');
+        const effort = input.reasoningEffort === undefined ? null : modelRoutePart(input.reasoningEffort, 'effort');
+        this.transaction(() => {
+            const current = this.database.prepare(`SELECT status, model_selection_state, model_provider, model_id, model_reasoning_effort
+        FROM delivery_foreground_executions WHERE inbox_id = ?`).get(input.inboxId);
+            if (current === undefined)
+                throw new DeliveryStoreError('invalid-binding', 'foreground execution is absent');
+            if (current.status !== 'pending')
+                throw new DeliveryStoreError('conflict', 'foreground execution model selection is no longer writable');
+            if (current.model_selection_state === 'missing') {
+                const changed = this.database.prepare(`UPDATE delivery_foreground_executions
+          SET model_selection_state = 'frozen', model_provider = ?, model_id = ?, model_reasoning_effort = ?
+          WHERE inbox_id = ? AND status = 'pending' AND model_selection_state = 'missing'`).run(provider, model, effort, input.inboxId);
+                if (changed.changes !== 1)
+                    throw new DeliveryStoreError('conflict', 'foreground execution model selection changed');
+                return;
+            }
+            if (current.model_selection_state === 'frozen') {
+                if (current.model_provider === provider && current.model_id === model && current.model_reasoning_effort === effort)
+                    return;
+                const changed = this.database.prepare(`UPDATE delivery_foreground_executions
+          SET model_selection_state = 'inconsistent', model_provider = NULL, model_id = NULL, model_reasoning_effort = NULL
+          WHERE inbox_id = ? AND status = 'pending' AND model_selection_state = 'frozen'`).run(input.inboxId);
+                if (changed.changes !== 1)
+                    throw new DeliveryStoreError('conflict', 'foreground execution model selection changed');
+                return;
+            }
+            if (current.model_selection_state !== 'inconsistent')
+                throw new DeliveryStoreError('conflict', 'foreground execution model selection state is invalid');
+        });
+    }
+    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,
+        execution.binding_version AS execution_binding_version,
+        binding.status AS current_binding_status, binding.version AS current_binding_version, binding.generation AS current_binding_generation
+      FROM delivery_foreground_executions AS execution
+      JOIN conversation_bindings AS binding ON binding.id = execution.binding_id
+      WHERE execution.inbox_id = ? AND execution.workspace = ? AND execution.preset = ? AND execution.principal_record_id = ? AND execution.principal_version = ?
+        AND execution.binding_id = ? AND execution.binding_generation = ?`).get(input.inboxId, input.scope.workspace, input.scope.preset, input.owner.principalRecordId, input.owner.principalVersion, input.bindingId, input.bindingGeneration);
+        if (row === undefined || row.current_binding_version !== input.bindingVersion || row.current_binding_generation !== input.bindingGeneration
+            || (row.execution_binding_version !== row.current_binding_version
+                && !(row.current_binding_status === 'revoked' && row.execution_binding_version + 1 === row.current_binding_version))
+            || row.completed_at === null || row.execution_ref !== input.inboxId)
+            return null;
+        return 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 }) }) } : {}) });
     }
     renewInboxClaim(input) {
         this.assertOpen();
@@ -3167,8 +3339,9 @@ export class DeliveryStore {
                     : existingPermissionRecovery === undefined
                         ? undefined
                         : permissionDispatchRecoveryCode(existingPermissionRecovery);
-                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'
+                const foregroundDispatch = this.database.prepare(`SELECT inbox_id FROM delivery_task_acceptance_executions WHERE inbox_id = ?
+          UNION ALL SELECT inbox_id FROM delivery_foreground_executions WHERE inbox_id = ? LIMIT 1`).get(row.id, row.id) !== undefined;
+                const ambiguous = foregroundDispatch || 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
@@ -5241,6 +5414,220 @@ export class DeliveryStore {
             throw committed;
         return committed;
     }
+    /**
+     * Record a workflow learned from one Delivery-reverified owner-root successful
+     * Goal run. Unlike the two conversation-fenced routes, there is no live
+     * Inbox/Outbox: the caller (the Host-only Delivery service method) must have
+     * independently re-fetched the verified Goals source and the owner-run-trace
+     * proof, so this method never accepts a caller-supplied prompt, template, or
+     * proof digest — all of them are rebuilt below from the verified source.
+     *
+     * The goal must be honestly reducible to the single built-in
+     * `assistant.agent-turn` step that paused Growth materialization can run
+     * (exactly one step, zero executable/business tools). Otherwise it abstains
+     * with zero writes. The raw objective is stored only in the new table's
+     * content_json and never enters the trace. Re-submitting the same verified
+     * run deterministically replays its prior revision.
+     */
+    commitOwnerAnchoredWorkflowTrace(input) {
+        this.assertOpen();
+        const digest64 = /^[a-f0-9]{64}$/u;
+        if (typeof input !== 'object' || input === null
+            || typeof input.ownerRouteId !== 'string' || input.ownerRouteId === ''
+            || typeof input.scope?.workspace !== 'string' || typeof input.scope?.preset !== 'string'
+            || typeof input.goal?.id !== 'string' || typeof input.goal?.nativeGoalId !== 'string'
+            || typeof input.goal?.sessionId !== 'string'
+            || !Number.isSafeInteger(input.goal?.definition?.version) || input.goal.definition.version < 1
+            || typeof input.goal?.definition?.digest !== 'string' || !digest64.test(input.goal.definition.digest)
+            || typeof input.goal?.definition?.objective !== 'string' || input.goal.definition.objective === ''
+            || Buffer.byteLength(input.goal?.definition?.objective ?? '', 'utf8') > 8192
+            || typeof input.runId !== 'string' || input.runId === ''
+            || !Number.isSafeInteger(input.turn) || input.turn < 0
+            || typeof input.acceptance?.contractId !== 'string' || input.acceptance.contractId === ''
+            || typeof input.acceptance?.receiptDigest !== 'string' || !digest64.test(input.acceptance.receiptDigest)
+            || !Number.isSafeInteger(input.acceptance?.verifiedAt) || input.acceptance.verifiedAt < 0
+            || !Number.isSafeInteger(input.acceptance?.validUntil) || input.acceptance.validUntil <= input.acceptance?.verifiedAt
+            || typeof input.ownerRunTraceDigest !== 'string' || !digest64.test(input.ownerRunTraceDigest)
+            || !Array.isArray(input.steps) || input.steps.length === 0) {
+            throw new DeliveryStoreError('conflict', 'owner-anchored workflow tuple is invalid');
+        }
+        // Fail-closed reduction gate, evaluated before any write. The learned
+        // automation is a single no-tool model turn, so every settled call in the
+        // successful run must be Goals bookkeeping, and even bounded failed read
+        // probes disqualify this slice rather than being silently dropped.
+        const reducible = input.steps.every(step => typeof step?.id === 'string' && step.id !== ''
+            && typeof step?.toolName === 'string'
+            && OWNER_ANCHORED_REDUCIBLE_GOAL_TOOLS.has(step.toolName))
+            && (input.failedObservations === undefined || input.failedObservations.length === 0);
+        if (!reducible) {
+            return Object.freeze({ outcome: 'abstained', reason: 'not-reducible', replayed: false });
+        }
+        return 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.version !== input.binding.version || binding.generation !== input.binding.generation
+                || JSON.stringify(binding.conversation) !== JSON.stringify(input.binding.conversation)
+                || JSON.stringify(binding.principal) !== JSON.stringify(input.binding.principal)
+                || binding.workspace !== input.binding.workspace || binding.agentPreset !== input.binding.agentPreset
+                || owner?.status !== 'active' || owner.role !== 'owner') {
+                throw new DeliveryStoreError('unauthorized-principal', 'owner-anchored workflow owner binding changed');
+            }
+            if (input.scope.workspace !== binding.workspace || input.scope.preset !== binding.agentPreset) {
+                throw new DeliveryStoreError('invalid-binding', 'owner-anchored workflow scope does not match the owner binding');
+            }
+            const anchor = Object.freeze({
+                scope: Object.freeze({ workspace: binding.workspace, preset: binding.agentPreset }),
+                bindingId: binding.id,
+                goalId: input.goal.id,
+                definitionVersion: input.goal.definition.version,
+                definitionDigest: input.goal.definition.digest,
+                sessionId: input.goal.sessionId,
+                nativeGoalId: input.goal.nativeGoalId,
+                runId: input.runId,
+                turn: input.turn,
+            });
+            const subjectRef = growthObjectDigest({
+                contract: 'assistant-delivery-owner-anchored-workflow-subject/v1',
+                ...anchor,
+            });
+            const taskRef = growthObjectDigest({
+                contract: 'assistant-delivery-owner-anchored-workflow-task-ref/v1',
+                ...anchor,
+                acceptanceContractId: input.acceptance.contractId,
+                acceptanceReceiptDigest: input.acceptance.receiptDigest,
+            });
+            const existing = this.database.prepare(`
+        SELECT * FROM workflow_owner_anchored_templates WHERE task_ref = ?
+      `).get(taskRef);
+            if (existing !== undefined) {
+                if (existing.goal_id !== input.goal.id || existing.run_id !== input.runId
+                    || existing.turn !== input.turn || existing.session_id !== input.goal.sessionId
+                    || existing.native_goal_id !== input.goal.nativeGoalId
+                    || existing.owner_route_id !== input.ownerRouteId
+                    || existing.acceptance_contract_id !== input.acceptance.contractId
+                    || existing.acceptance_receipt_digest !== input.acceptance.receiptDigest
+                    || existing.owner_run_trace_digest !== input.ownerRunTraceDigest) {
+                    throw new DeliveryStoreError('idempotency-conflict', 'owner-anchored task identity was reused with different evidence');
+                }
+                const currentRow = this.database.prepare(`
+          SELECT revision.* FROM workflow_trace_current AS current
+          JOIN workflow_trace_revisions AS revision
+            ON revision.subject_ref = current.subject_ref AND revision.version = current.version
+          WHERE current.subject_ref = ?
+        `).get(subjectRef);
+                if (currentRow === undefined) {
+                    throw new DeliveryStoreError('conflict', 'owner-anchored workflow replay is missing its trace');
+                }
+                const revision = workflowTraceRevision(currentRow);
+                const replayTemplate = revision.evidence?.template;
+                if (revision.disposition !== 'upsert' || replayTemplate === undefined
+                    || replayTemplate.templateRef !== existing.template_ref
+                    || replayTemplate.templateDigest !== existing.template_digest) {
+                    throw new DeliveryStoreError('conflict', 'owner-anchored workflow replay trace is inconsistent');
+                }
+                return Object.freeze({ outcome: 'trace-recorded', revision, template: replayTemplate, replayed: true });
+            }
+            const content = validateWorkflowAutomationTemplateContent({
+                scope: { workspace: binding.workspace, preset: binding.agentPreset },
+                ownerBindingId: binding.id,
+                principalId: externalPrincipalId(binding.principal),
+                name: 'Owner-anchored workflow',
+                prompt: input.goal.definition.objective,
+                schedule: WORKFLOW_OWNER_ANCHORED_PLACEHOLDER_SCHEDULE,
+                timeoutMs: 60_000,
+                toolCatalogIds: ['assistant.agent-turn'],
+                deliveryBindingId: binding.id,
+            });
+            const templateDigest = workflowAutomationTemplateContentDigest(content);
+            const reviewReceipt = Object.freeze({
+                contractVersion: 1,
+                kind: 'owner-anchored-template-review',
+                limitation: 'deidentification-unproven',
+                provenance: 'owner-goal-success',
+                scheduleUnconfirmed: true,
+                templateDigest,
+                bindingId: binding.id,
+                bindingVersion: binding.version,
+                bindingGeneration: binding.generation,
+                principalId: owner.id,
+                ownerRouteId: input.ownerRouteId,
+                goalId: input.goal.id,
+                nativeGoalId: input.goal.nativeGoalId,
+                sessionId: input.goal.sessionId,
+                runId: input.runId,
+                turn: input.turn,
+                acceptanceContractId: input.acceptance.contractId,
+                acceptanceReceiptDigest: input.acceptance.receiptDigest,
+                ownerRunTraceDigest: input.ownerRunTraceDigest,
+                taskRef,
+            });
+            const attestationDigest = growthObjectDigest({
+                contract: 'assistant-delivery-workflow-owner-anchored-template-review/v1',
+                receipt: reviewReceipt,
+            });
+            const templateRef = `workflow-template:${growthObjectDigest({
+                contract: 'assistant-delivery-workflow-template-ref/v3',
+                templateDigest,
+                goalId: input.goal.id,
+                runId: input.runId,
+            })}`;
+            const template = validateWorkflowAutomationTemplate({
+                templateRef,
+                templateDigest,
+                privacyAttestation: {
+                    kind: 'owner-anchored',
+                    limitation: 'deidentification-unproven',
+                    provenance: 'owner-goal-success',
+                    attestationId: `workflow-owner-anchored:${attestationDigest}`,
+                    attestationDigest,
+                },
+            });
+            const payload = Object.freeze({
+                source: this.workflowTraceSourceAttestation(),
+                scope: Object.freeze({ workspace: binding.workspace, preset: binding.agentPreset }),
+                subjectRef,
+                version: 1,
+                disposition: 'upsert',
+                evidence: Object.freeze({
+                    occurredAt: input.acceptance.verifiedAt,
+                    signal: 'owner-anchored',
+                    objectiveStatus: 'achieved',
+                    ownerBindingId: binding.id,
+                    taskRef,
+                    taskEvidenceDigest: input.ownerRunTraceDigest,
+                    template,
+                    steps: Object.freeze([Object.freeze({
+                            catalogId: 'assistant.agent-turn',
+                            argumentSchemaDigest: workflowArgumentShapeDigest({ prompt: content.prompt }),
+                        })]),
+                }),
+            });
+            const revision = validateWorkflowTraceRevision({
+                ...payload,
+                digest: workflowTraceRevisionDigest(payload),
+            });
+            const now = this.now();
+            this.database.prepare(`
+        INSERT INTO workflow_owner_anchored_templates(
+          template_ref, template_digest, scope_key, workspace, preset, owner_binding_id,
+          binding_version, binding_generation, principal_id, content_json, privacy_kind,
+          privacy_attestation_id, privacy_attestation_digest, review_receipt_json, status,
+          version, task_ref, owner_route_id, goal_id, native_goal_id, session_id, run_id, turn,
+          acceptance_contract_id, acceptance_receipt_digest, owner_run_trace_digest,
+          created_at, updated_at
+        ) VALUES (
+          ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'owner-anchored', ?, ?, ?, 'active', 1,
+          ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+        )
+      `).run(template.templateRef, template.templateDigest, workflowScopeKey(content.scope), content.scope.workspace, content.scope.preset, binding.id, binding.version, binding.generation, owner.id, JSON.stringify(content), template.privacyAttestation.attestationId, template.privacyAttestation.attestationDigest, JSON.stringify(reviewReceipt), taskRef, input.ownerRouteId, input.goal.id, input.goal.nativeGoalId, input.goal.sessionId, input.runId, input.turn, input.acceptance.contractId, input.acceptance.receiptDigest, input.ownerRunTraceDigest, now, now);
+            const recorded = this.insertWorkflowTraceRevisionInTransaction(revision);
+            if (recorded.replayed) {
+                throw new DeliveryStoreError('version-conflict', 'new owner-anchored workflow unexpectedly replayed a trace version');
+            }
+            return Object.freeze({ outcome: 'trace-recorded', revision, template, replayed: false });
+        });
+    }
     insertVerifiedWorkflowTaskFeedback(input) {
         if ((input.revision === undefined) !== (input.template === undefined)) {
             throw new DeliveryStoreError('conflict', 'verified workflow trace and template must agree');
@@ -5317,7 +5704,7 @@ export class DeliveryStore {
       SELECT * FROM workflow_template_registry WHERE template_ref = ?
     `).get(template.templateRef);
         if (row === undefined)
-            return undefined;
+            return this.getOwnerAnchoredWorkflowTemplate(template);
         let contentValue;
         let reviewValue;
         try {
@@ -5438,6 +5825,7 @@ export class DeliveryStore {
         return Object.freeze({
             resolved,
             review: Object.freeze({
+                kind: 'inbox-anchored',
                 bindingId: row.owner_binding_id,
                 bindingVersion: review['bindingVersion'],
                 bindingGeneration: review['bindingGeneration'],
@@ -5450,6 +5838,131 @@ export class DeliveryStore {
             version: row.version,
         });
     }
+    /**
+     * Rebuild a template learned from a Delivery-reverified owner-root Goal run.
+     * Every column and receipt field is re-derived and cross-checked; a mismatch
+     * fails closed rather than resolving attacker- or corruption-influenced data.
+     */
+    getOwnerAnchoredWorkflowTemplate(template) {
+        const row = this.database.prepare(`
+      SELECT * FROM workflow_owner_anchored_templates WHERE template_ref = ?
+    `).get(template.templateRef);
+        if (row === undefined)
+            return undefined;
+        let contentValue;
+        let reviewValue;
+        try {
+            contentValue = JSON.parse(row.content_json);
+            reviewValue = JSON.parse(row.review_receipt_json);
+        }
+        catch {
+            throw new DeliveryStoreError('conflict', 'owner-anchored workflow payload is corrupt');
+        }
+        if (typeof reviewValue !== 'object' || reviewValue === null || Array.isArray(reviewValue)) {
+            throw new DeliveryStoreError('conflict', 'owner-anchored workflow review receipt is corrupt');
+        }
+        const review = reviewValue;
+        const content = validateWorkflowAutomationTemplateContent(contentValue);
+        const exactReviewKeys = [
+            'contractVersion', 'kind', 'limitation', 'provenance', 'scheduleUnconfirmed', 'templateDigest',
+            'bindingId', 'bindingVersion', 'bindingGeneration', 'principalId',
+            'ownerRouteId', 'goalId', 'nativeGoalId', 'sessionId', 'runId', 'turn',
+            'acceptanceContractId', 'acceptanceReceiptDigest', 'ownerRunTraceDigest', 'taskRef',
+        ].sort();
+        const bindingVersion = review['bindingVersion'];
+        const bindingGeneration = review['bindingGeneration'];
+        const turn = review['turn'];
+        if (Object.keys(review).sort().some((key, index) => key !== exactReviewKeys[index])
+            || Object.keys(review).length !== exactReviewKeys.length
+            || review['contractVersion'] !== 1
+            || review['kind'] !== 'owner-anchored-template-review'
+            || review['limitation'] !== 'deidentification-unproven'
+            || review['provenance'] !== 'owner-goal-success'
+            || review['scheduleUnconfirmed'] !== true
+            || review['templateDigest'] !== row.template_digest
+            || review['bindingId'] !== row.owner_binding_id
+            || review['principalId'] !== row.principal_id
+            || typeof bindingVersion !== 'number' || !Number.isSafeInteger(bindingVersion) || bindingVersion < 1
+            || typeof bindingGeneration !== 'number' || !Number.isSafeInteger(bindingGeneration) || bindingGeneration < 1
+            || bindingVersion !== row.binding_version || bindingGeneration !== row.binding_generation
+            || review['ownerRouteId'] !== row.owner_route_id
+            || review['goalId'] !== row.goal_id
+            || review['nativeGoalId'] !== row.native_goal_id
+            || review['sessionId'] !== row.session_id
+            || review['runId'] !== row.run_id
+            || review['turn'] !== row.turn
+            || typeof turn !== 'number' || !Number.isSafeInteger(turn) || turn < 0
+            || review['acceptanceContractId'] !== row.acceptance_contract_id
+            || review['acceptanceReceiptDigest'] !== row.acceptance_receipt_digest
+            || review['ownerRunTraceDigest'] !== row.owner_run_trace_digest
+            || review['taskRef'] !== row.task_ref
+            || typeof review['goalId'] !== 'string' || typeof review['nativeGoalId'] !== 'string'
+            || typeof review['sessionId'] !== 'string' || typeof review['runId'] !== 'string'
+            || typeof review['ownerRouteId'] !== 'string'
+            || typeof review['acceptanceContractId'] !== 'string'
+            || typeof review['acceptanceReceiptDigest'] !== 'string'
+            || !/^[a-f0-9]{64}$/u.test(review['acceptanceReceiptDigest'])
+            || !/^[a-f0-9]{64}$/u.test(review['ownerRunTraceDigest'])
+            || !/^[a-f0-9]{64}$/u.test(review['taskRef'])) {
+            throw new DeliveryStoreError('conflict', 'owner-anchored workflow review receipt columns do not match');
+        }
+        const attestationDigest = growthObjectDigest({
+            contract: 'assistant-delivery-workflow-owner-anchored-template-review/v1',
+            receipt: review,
+        });
+        const storedTemplate = validateWorkflowAutomationTemplate({
+            templateRef: row.template_ref,
+            templateDigest: row.template_digest,
+            privacyAttestation: {
+                kind: 'owner-anchored',
+                limitation: 'deidentification-unproven',
+                provenance: 'owner-goal-success',
+                attestationId: row.privacy_attestation_id,
+                attestationDigest: row.privacy_attestation_digest,
+            },
+        });
+        if (JSON.stringify(storedTemplate) !== JSON.stringify(template)
+            || attestationDigest !== row.privacy_attestation_digest
+            || storedTemplate.privacyAttestation.attestationId !== `workflow-owner-anchored:${attestationDigest}`) {
+            throw new DeliveryStoreError('receipt-mismatch', 'owner-anchored workflow attestation is stale');
+        }
+        const contentBinding = this.getBinding(row.owner_binding_id);
+        const resolved = validateResolvedWorkflowAutomationTemplate({
+            contractVersion: 1,
+            template: storedTemplate,
+            ...content,
+        });
+        if (workflowScopeKey(content.scope) !== row.scope_key
+            || content.scope.workspace !== row.workspace || content.scope.preset !== row.preset
+            || content.ownerBindingId !== row.owner_binding_id || content.deliveryBindingId !== row.owner_binding_id
+            || contentBinding === undefined
+            || content.principalId !== externalPrincipalId(contentBinding.principal)
+            || workflowAutomationTemplateContentDigest(content) !== row.template_digest) {
+            throw new DeliveryStoreError('receipt-mismatch', 'owner-anchored workflow content columns do not match');
+        }
+        return Object.freeze({
+            resolved,
+            review: Object.freeze({
+                kind: 'goal-anchored',
+                bindingId: row.owner_binding_id,
+                bindingVersion: row.binding_version,
+                bindingGeneration: row.binding_generation,
+                principalId: row.principal_id,
+                ownerRouteId: row.owner_route_id,
+                goalId: row.goal_id,
+                nativeGoalId: row.native_goal_id,
+                sessionId: row.session_id,
+                runId: row.run_id,
+                turn: row.turn,
+                acceptanceContractId: row.acceptance_contract_id,
+                acceptanceReceiptDigest: row.acceptance_receipt_digest,
+                ownerRunTraceDigest: row.owner_run_trace_digest,
+                taskRef: row.task_ref,
+            }),
+            status: row.status,
+            version: row.version,
+        });
+    }
     requeueCurrentWorkflowTraces() {
         this.assertOpen();
         const now = this.now();