@dsh-enhanced/assistant-automations 0.1.6 → 0.1.12

package/lib/coordinator.js

@@ -1,8 +1,20 @@
+import { HostAutomationExecutorRegistry } from './host-executors.js';
 import { AutomationStoreError } from './store.js';
+import { isHostAutomationDefinition, legacyAutomationExecutionDiagnostic } from './types.js';
 export class AutomationRunnerAmbiguousError extends Error {
+    diagnostic;
     constructor(message, options) {
         super(message, options);
         this.name = 'AutomationRunnerAmbiguousError';
+        this.diagnostic = options?.diagnostic ?? legacyAutomationExecutionDiagnostic;
+    }
+}
+export class AutomationRunnerFailureError extends Error {
+    diagnostic;
+    constructor(message, diagnostic, options) {
+        super(message, options);
+        this.diagnostic = diagnostic;
+        this.name = 'AutomationRunnerFailureError';
     }
 }
 function sessionId(task) {
@@ -22,7 +34,32 @@ function boundedText(value, maximumBytes) {
         return undefined;
     return normalized;
 }
+function incidentAlertText(incident) {
+    return [
+        `Automation incident ${incident.id}`,
+        `automation: ${incident.automationId}`,
+        `state: ${incident.state}`,
+        `stage: ${incident.stage}`,
+        `failure: ${incident.failureClass}/${incident.failurePhase}/${incident.failureCode}`,
+        `side effects: ${incident.sideEffectState}`,
+        `retryability: ${incident.retryability}`,
+    ].join('\n');
+}
 const exposureReceiptTimeoutMs = 2_000;
+const evaluationMaxAttempts = 8;
+const evaluationRetryBaseMs = 1_000;
+const evaluationRetryMaxMs = 3_600_000;
+const evaluationRecorderTimeoutMs = 2_000;
+function recorderErrorCode(error) {
+    if (typeof error === 'object' && error !== null && 'code' in error) {
+        const code = error.code;
+        if (typeof code === 'string' && /^[A-Za-z0-9._:-]{1,64}$/u.test(code))
+            return code;
+    }
+    if (error instanceof Error && /^[A-Za-z][A-Za-z0-9]{0,63}$/u.test(error.name))
+        return error.name;
+    return 'recorder-error';
+}
 export class AutomationCoordinator {
     store;
     artifacts;
@@ -35,9 +72,12 @@ export class AutomationCoordinator {
     maxCatchUp;
     maxConcurrency;
     tickIntervalMs;
+    hostExecutors;
     active = new Map();
+    activeEvaluations = new Map();
     delivery;
     outcomeRecorder;
+    evaluationRecorder;
     fencingToken;
     timer;
     stopped = false;
@@ -56,6 +96,7 @@ export class AutomationCoordinator {
         this.maxCatchUp = options.maxCatchUp;
         this.maxConcurrency = options.maxConcurrency;
         this.tickIntervalMs = options.tickIntervalMs ?? Math.max(1_000, Math.floor(options.dutyLeaseMs / 3));
+        this.hostExecutors = options.hostExecutors ?? new HostAutomationExecutorRegistry();
     }
     start() {
         if (this.stopped)
@@ -72,16 +113,27 @@ export class AutomationCoordinator {
         const now = this.now();
         if (!this.ensureDuty(now))
             return;
+        this.store.recoverExpiredCircuitProbes({ now });
+        this.store.recoverExpiredTasks({ now, limit: this.maxCatchUp });
+        this.dispatchPendingEvaluations();
         this.dispatchPendingEvidence();
         this.dispatchPendingDeliveries();
-        this.store.recoverExpiredTasks({ now, limit: this.maxCatchUp });
-        this.store.materializeDue({ now, misfireGraceMs: this.misfireGraceMs, maxCatchUp: this.maxCatchUp });
+        this.dispatchPendingIncidentAlerts();
+        const materializeAvailability = this.hostAvailability(this.store.listDueHostExecutionRequirements({ now }), 'materialize');
+        this.store.materializeDue({
+            now,
+            misfireGraceMs: this.misfireGraceMs,
+            maxCatchUp: this.maxCatchUp,
+            hostAvailability: materializeAvailability,
+        });
         while (this.active.size < this.maxConcurrency) {
+            const claimAvailability = this.hostAvailability(this.store.listClaimableHostExecutionRequirements(), 'claim');
             const claimed = this.store.claimNextTask({
                 ownerId: this.ownerId,
                 fencingToken: this.fencingToken,
                 now,
                 leaseMs: this.taskLeaseMs,
+                hostAvailability: claimAvailability,
             });
             if (claimed === undefined)
                 break;
@@ -90,6 +142,7 @@ export class AutomationCoordinator {
             this.abortRequestedActive();
             this.launch(claimed);
         }
+        this.dispatchPendingIncidentAlerts();
     }
     setDeliveryDispatcher(delivery) {
         this.delivery = delivery;
@@ -104,9 +157,18 @@ export class AutomationCoordinator {
     setOutcomeRecorder(recorder) {
         this.outcomeRecorder = recorder;
     }
+    /** Attach the optional unified Evaluation sink without coupling it to Evolution. */
+    setEvaluationRecorder(recorder) {
+        this.evaluationRecorder = recorder;
+        if (recorder !== undefined && !this.stopped)
+            this.dispatchPendingEvaluations();
+    }
     async whenIdle() {
-        while (this.active.size > 0) {
-            await Promise.all([...this.active.values()].map(value => value.promise));
+        while (this.active.size > 0 || this.activeEvaluations.size > 0) {
+            await Promise.allSettled([
+                ...[...this.active.values()].map(value => value.promise),
+                ...this.activeEvaluations.values(),
+            ]);
         }
     }
     async cancel(taskId) {
@@ -124,6 +186,32 @@ export class AutomationCoordinator {
         for (const value of this.active.values())
             value.controller.abort('coordinator-stop');
         await this.whenIdle();
+        if (this.fencingToken !== undefined) {
+            try {
+                this.store.releaseDuty({ ownerId: this.ownerId, fencingToken: this.fencingToken, now: this.now() });
+            }
+            catch (error) {
+                // A successor that already advanced the fence owns the row.  The
+                // stopped coordinator must not interfere with it.
+                if (!(error instanceof AutomationStoreError) || error.code !== 'stale-fence')
+                    throw error;
+            }
+            finally {
+                this.fencingToken = undefined;
+            }
+        }
+    }
+    hostAvailability(requirements, stage) {
+        return requirements.map(requirement => {
+            const proof = this.hostExecutors.prove(requirement.execution);
+            return Object.freeze({
+                automationId: requirement.automationId,
+                definitionHash: requirement.definitionHash,
+                stage,
+                available: proof.available,
+                reasonCode: proof.available ? 'host-executor-available' : proof.reasonCode,
+            });
+        });
     }
     ensureDuty(now) {
         if (this.fencingToken !== undefined) {
@@ -160,89 +248,221 @@ export class AutomationCoordinator {
         }
     }
     async execute(claimed, controller) {
-        const automation = this.store.get(claimed.automationId);
-        const occurrence = this.store.getOccurrence(claimed.occurrenceId);
-        if (automation === undefined || occurrence === undefined || this.fencingToken === undefined) {
-            throw new Error('assistant-automations: claimed task snapshot is missing');
-        }
+        if (this.fencingToken === undefined)
+            throw new Error('assistant-automations: duty fence is missing');
         const fence = this.fencingToken;
         const freshSessionId = sessionId(claimed);
-        const started = this.store.startTask({
-            taskId: claimed.id,
-            ownerId: this.ownerId,
-            fencingToken: fence,
-            now: this.now(),
-            leaseMs: this.taskLeaseMs,
-            sessionId: freshSessionId,
-        });
+        let timeout;
+        let heartbeat;
         let timedOut = false;
-        const timeout = setTimeout(() => {
-            timedOut = true;
-            controller.abort('timeout');
-        }, automation.definition.timeoutMs);
-        timeout.unref?.();
-        const heartbeat = setInterval(() => {
+        try {
+            const started = this.store.startTask({
+                taskId: claimed.id,
+                ownerId: this.ownerId,
+                fencingToken: fence,
+                now: this.now(),
+                leaseMs: this.taskLeaseMs,
+                sessionId: freshSessionId,
+            });
+            let automation;
+            let occurrence;
             try {
-                const now = this.now();
-                this.store.renewDuty({
+                automation = this.store.getTaskExecutionSnapshot(claimed.id);
+                occurrence = this.store.getOccurrence(claimed.occurrenceId);
+            }
+            catch {
+                this.store.quarantineInvalidExecutionSnapshot({
+                    taskId: started.id,
                     ownerId: this.ownerId,
                     fencingToken: fence,
-                    now,
-                    leaseMs: this.dutyLeaseMs,
+                    now: this.now(),
                 });
-                this.store.heartbeatTask({
+                return;
+            }
+            if (automation === undefined || occurrence === undefined) {
+                this.store.quarantineInvalidExecutionSnapshot({
                     taskId: started.id,
                     ownerId: this.ownerId,
                     fencingToken: fence,
-                    now,
-                    leaseMs: this.taskLeaseMs,
+                    now: this.now(),
+                });
+                return;
+            }
+            const hostExecution = isHostAutomationDefinition(automation.definition);
+            timeout = setTimeout(() => {
+                timedOut = true;
+                controller.abort('timeout');
+            }, automation.definition.timeoutMs);
+            timeout.unref?.();
+            heartbeat = setInterval(() => {
+                try {
+                    const now = this.now();
+                    this.store.renewDuty({
+                        ownerId: this.ownerId,
+                        fencingToken: fence,
+                        now,
+                        leaseMs: this.dutyLeaseMs,
+                    });
+                    this.store.heartbeatTask({
+                        taskId: started.id,
+                        ownerId: this.ownerId,
+                        fencingToken: fence,
+                        now,
+                        leaseMs: this.taskLeaseMs,
+                    });
+                }
+                catch {
+                    controller.abort('lease-lost');
+                }
+            }, Math.max(250, Math.floor(Math.min(this.dutyLeaseMs, this.taskLeaseMs) / 3)));
+            heartbeat.unref?.();
+            let result;
+            try {
+                const admission = this.store.acquireCircuitExecutionForTask({
+                    taskId: started.id,
+                    now: this.now(),
+                    leaseMs: Math.min(86_400_000, Math.max(this.taskLeaseMs, automation.definition.timeoutMs)),
                 });
+                if (admission.kind === 'blocked') {
+                    result = {
+                        outcome: 'failed',
+                        output: `execution circuit is ${admission.circuit.state} for immutable definition ${admission.circuit.definitionHash}`,
+                        usage: {},
+                        diagnostic: Object.freeze({
+                            schemaVersion: 1,
+                            failureClass: admission.circuit.failureClass,
+                            failurePhase: 'preflight',
+                            failureCode: 'circuit-open',
+                            promptSubmissionState: hostExecution ? 'not-applicable' : 'not-submitted',
+                            sideEffectState: 'none',
+                            retryability: 'after-intervention',
+                            budgetSettlementState: automation.definition.budgetId === undefined ? 'not-required' : 'not-reserved',
+                        }),
+                    };
+                }
+                else {
+                    const runnerPromise = Promise.resolve().then(() => this.runner.run({
+                        automation,
+                        occurrence,
+                        task: started,
+                        sessionId: freshSessionId,
+                        signal: controller.signal,
+                    }));
+                    // The runner owns Agent flush/disposal. It may violate cancellation,
+                    // so its late settlement is deliberately detached from terminal I/O.
+                    const settledRunner = runnerPromise.then(value => ({ kind: 'result', value }), error => ({ kind: 'error', error }));
+                    let removeAbort = () => { };
+                    const aborted = new Promise(resolve => {
+                        const finish = () => resolve({ kind: 'aborted' });
+                        if (controller.signal.aborted)
+                            finish();
+                        else {
+                            controller.signal.addEventListener('abort', finish, { once: true });
+                            removeAbort = () => controller.signal.removeEventListener('abort', finish);
+                        }
+                    });
+                    const settled = await Promise.race([settledRunner, aborted]);
+                    removeAbort();
+                    void settledRunner.then(() => { });
+                    if (settled.kind === 'aborted' || controller.signal.aborted) {
+                        const isTimeout = timedOut;
+                        result = {
+                            outcome: isTimeout ? 'timed_out' : 'cancelled',
+                            output: isTimeout ? 'automation execution timed out' : 'automation execution was cancelled',
+                            usage: {},
+                            diagnostic: Object.freeze({
+                                schemaVersion: 1,
+                                failureClass: isTimeout ? 'timeout' : 'cancelled',
+                                failurePhase: 'unknown',
+                                failureCode: isTimeout ? 'execution-timeout' : 'execution-cancelled',
+                                promptSubmissionState: hostExecution ? 'not-applicable' : 'unknown',
+                                sideEffectState: 'unknown',
+                                retryability: 'unsafe',
+                                budgetSettlementState: automation.definition.budgetId === undefined ? 'not-required' : 'unknown',
+                            }),
+                        };
+                    }
+                    else if (settled.kind === 'error') {
+                        const error = settled.error;
+                        const diagnostic = error instanceof AutomationRunnerFailureError
+                            || error instanceof AutomationRunnerAmbiguousError
+                            ? error.diagnostic
+                            : legacyAutomationExecutionDiagnostic;
+                        result = {
+                            outcome: error instanceof AutomationRunnerAmbiguousError ? 'unknown' : 'failed',
+                            output: error instanceof Error ? error.message : String(error),
+                            usage: {},
+                            diagnostic,
+                        };
+                    }
+                    else {
+                        result = settled.value;
+                    }
+                }
             }
             catch {
-                controller.abort('lease-lost');
+                result = {
+                    outcome: 'unknown',
+                    output: 'automation circuit admission could not be proven',
+                    usage: {},
+                    diagnostic: Object.freeze({
+                        schemaVersion: 1,
+                        failureClass: 'infrastructure',
+                        failurePhase: 'preflight',
+                        failureCode: 'circuit-admission-failed',
+                        promptSubmissionState: hostExecution ? 'not-applicable' : 'not-submitted',
+                        sideEffectState: 'none',
+                        retryability: 'after-intervention',
+                        budgetSettlementState: automation.definition.budgetId === undefined ? 'not-required' : 'not-reserved',
+                    }),
+                };
             }
-        }, Math.max(250, Math.floor(Math.min(this.dutyLeaseMs, this.taskLeaseMs) / 3)));
-        heartbeat.unref?.();
-        let result;
-        try {
-            result = await this.runner.run({
-                automation,
-                occurrence,
-                task: started,
-                sessionId: freshSessionId,
-                signal: controller.signal,
-            });
-        }
-        catch (error) {
-            result = {
-                outcome: controller.signal.aborted
-                    ? 'cancelled'
-                    : error instanceof AutomationRunnerAmbiguousError ? 'unknown' : 'failed',
-                output: error instanceof Error ? error.message : String(error),
-                usage: {},
-            };
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-        try {
-            const evidenceSessionId = result.sessionId === freshSessionId ? freshSessionId : undefined;
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+            const evidenceSessionId = occurrence.dryRun === false && result.sessionId === freshSessionId
+                ? freshSessionId
+                : undefined;
             const exposure = evidenceSessionId === undefined
                 ? undefined
                 : await this.getExposure(automation, evidenceSessionId);
-            const outcome = timedOut
-                ? 'timed_out'
-                : controller.signal.aborted ? 'cancelled' : result.outcome;
+            let outcome = result.outcome;
+            let diagnostic = result.diagnostic ?? legacyAutomationExecutionDiagnostic;
             const outputPreview = preview(result.output);
-            const artifactRef = this.artifacts.write(occurrence.id, {
-                occurrenceId: occurrence.id,
-                automationId: automation.id,
-                taskId: started.id,
-                outcome,
-                sessionId: result.sessionId ?? freshSessionId,
-                output: result.output,
-                usage: result.usage,
-            });
+            let artifactRef;
+            try {
+                artifactRef = this.artifacts.write(occurrence.id, {
+                    occurrenceId: occurrence.id,
+                    automationId: automation.id,
+                    taskId: started.id,
+                    outcome,
+                    sessionId: result.sessionId ?? freshSessionId,
+                    output: result.output,
+                    usage: result.usage,
+                    diagnostic,
+                });
+            }
+            catch {
+                // The execution may already have crossed prompt/tool boundaries. Commit
+                // a content-free unknown recovery receipt instead of waiting for lease
+                // expiry or pretending the missing artifact did not matter.
+                outcome = 'unknown';
+                diagnostic = Object.freeze({
+                    schemaVersion: 1,
+                    failureClass: 'infrastructure',
+                    failurePhase: 'artifact-write',
+                    failureCode: 'artifact-write-failed',
+                    promptSubmissionState: diagnostic.promptSubmissionState,
+                    sideEffectState: diagnostic.sideEffectState,
+                    retryability: diagnostic.promptSubmissionState === 'not-submitted'
+                        && diagnostic.sideEffectState === 'none'
+                        && (diagnostic.budgetSettlementState === 'not-required'
+                            || diagnostic.budgetSettlementState === 'not-reserved'
+                            || diagnostic.budgetSettlementState === 'released')
+                        ? 'safe'
+                        : 'unsafe',
+                    budgetSettlementState: diagnostic.budgetSettlementState,
+                });
+            }
             const run = this.store.completeTask({
                 taskId: started.id,
                 ownerId: this.ownerId,
@@ -250,10 +470,11 @@ export class AutomationCoordinator {
                 now: this.now(),
                 outcome,
                 sessionId: result.sessionId ?? freshSessionId,
-                artifactRef,
-                outputPreview,
-                usage: result.usage,
-                ...(evidenceSessionId === undefined
+                ...(artifactRef === undefined ? {} : { artifactRef }),
+                outputPreview: artifactRef === undefined ? 'artifact persistence failed' : outputPreview,
+                usage: artifactRef === undefined ? {} : result.usage,
+                diagnostic,
+                ...(artifactRef === undefined || evidenceSessionId === undefined
                     ? {}
                     : {
                         evidenceAttribution: {
@@ -264,9 +485,13 @@ export class AutomationCoordinator {
             });
             this.dispatchRunDelivery(run);
             this.dispatchRunEvidence(run);
+            this.dispatchRunEvaluation(run.id);
         }
         finally {
-            clearInterval(heartbeat);
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+            if (heartbeat !== undefined)
+                clearInterval(heartbeat);
         }
     }
     async getExposure(automation, actualSessionId) {
@@ -308,16 +533,36 @@ export class AutomationCoordinator {
     dispatchPendingEvidence() {
         if (this.outcomeRecorder === undefined)
             return;
-        for (const run of this.store.listPendingEvidence(100))
-            this.dispatchRunEvidence(run);
+        for (const run of this.store.listPendingEvidence(100)) {
+            try {
+                this.dispatchRunEvidence(run);
+            }
+            catch {
+                // One corrupt/concurrently-settled row must not starve its peers.
+            }
+        }
     }
     dispatchRunEvidence(run) {
         const recorder = this.outcomeRecorder;
         if (recorder === undefined || run.evidenceStatus !== 'pending' || run.evidence === undefined)
             return;
+        let proven;
         try {
-            recorder.recordAutomationOutcome(run.evidence);
-            this.store.completeRunEvidence({ runId: run.id, expectedStatus: 'pending', now: this.now() });
+            proven = this.store.getProvenProductionRun(run.id);
+        }
+        catch {
+            this.store.suppressRunEvidence({ runId: run.id, expectedStatus: 'pending', now: this.now() });
+            return;
+        }
+        if (proven === undefined
+            || (proven.run.status !== 'succeeded' && proven.run.status !== 'failed' && proven.run.status !== 'timed_out')
+            || proven.run.evidenceStatus !== 'pending' || proven.run.evidence === undefined) {
+            this.store.suppressRunEvidence({ runId: run.id, expectedStatus: 'pending', now: this.now() });
+            return;
+        }
+        try {
+            recorder.recordAutomationOutcome(proven.run.evidence);
+            this.store.completeRunEvidence({ runId: proven.run.id, expectedStatus: 'pending', now: this.now() });
         }
         catch {
             // Evidence is an outbox lane: the run remains terminal and a later leader
@@ -331,32 +576,207 @@ export class AutomationCoordinator {
             }
         }
     }
+    dispatchPendingEvaluations() {
+        if (this.evaluationRecorder === undefined)
+            return;
+        const now = this.now();
+        for (const entry of this.store.listPendingEvaluations(100, now))
+            this.dispatchEvaluation(entry);
+    }
+    dispatchRunEvaluation(runId) {
+        if (this.evaluationRecorder === undefined)
+            return;
+        const entry = this.store.getPendingEvaluationForRun(runId, this.now());
+        if (entry !== undefined)
+            this.dispatchEvaluation(entry);
+    }
+    dispatchEvaluation(entry) {
+        const recorder = this.evaluationRecorder;
+        if (recorder === undefined || entry.status !== 'pending' || this.activeEvaluations.has(entry.id))
+            return;
+        const authoritativeMode = this.store.getRunExecutionMode(entry.runId);
+        const payloadMode = entry.payload.executionMode;
+        if (authoritativeMode !== 'production' || (payloadMode !== undefined && payloadMode !== 'production')) {
+            // Repair old preview rows without ever presenting them to a trusted sink.
+            // `recorded` here means the durable outbox item was conclusively handled;
+            // no Evaluation outcome is invented.
+            this.store.completeEvaluation({ id: entry.id, expectedStatus: 'pending', now: this.now() });
+            return;
+        }
+        const normalizedEntry = payloadMode === 'production'
+            ? entry
+            : Object.freeze({ ...entry, payload: Object.freeze({ ...entry.payload, executionMode: 'production' }) });
+        const promise = this.recordEvaluation(recorder, normalizedEntry)
+            .finally(() => this.activeEvaluations.delete(entry.id));
+        this.activeEvaluations.set(entry.id, promise);
+        void promise.catch(() => { });
+    }
+    async recordEvaluation(recorder, entry) {
+        let timeout;
+        try {
+            await Promise.race([
+                Promise.resolve(recorder.append(entry.payload)),
+                new Promise((_resolve, reject) => {
+                    timeout = setTimeout(() => reject(Object.assign(new Error('evaluation recorder timed out'), {
+                        code: 'recorder-timeout',
+                    })), evaluationRecorderTimeoutMs);
+                    timeout.unref?.();
+                }),
+            ]);
+            this.store.completeEvaluation({ id: entry.id, expectedStatus: 'pending', now: this.now() });
+        }
+        catch (error) {
+            // The payload is immutable and has its own idempotency key. A crash after
+            // append but before settlement therefore replays safely without rerunning
+            // the Automation or coupling this lane to Evolution evidence.
+            try {
+                const now = this.now();
+                const delay = Math.min(evaluationRetryMaxMs, evaluationRetryBaseMs * 2 ** Math.min(entry.attemptCount, 12));
+                this.store.deferEvaluation({
+                    id: entry.id,
+                    expectedStatus: 'pending',
+                    now,
+                    retryAt: now + delay,
+                    maxAttempts: evaluationMaxAttempts,
+                    errorCode: recorderErrorCode(error),
+                });
+            }
+            catch {
+                // A concurrent settlement or shutdown already owns the next step.
+            }
+        }
+        finally {
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+        }
+    }
     dispatchPendingDeliveries() {
-        for (const run of this.store.listPendingDeliveries(100))
-            this.dispatchRunDelivery(run);
+        for (const run of this.store.listPendingDeliveries(100)) {
+            try {
+                this.dispatchRunDelivery(run);
+            }
+            catch {
+                // Per-row isolation: the next pending delivery remains dispatchable.
+            }
+        }
+    }
+    dispatchPendingIncidentAlerts() {
+        const delivery = this.delivery;
+        if (delivery === undefined)
+            return;
+        for (const incident of this.store.listPendingIncidentAlerts(100)) {
+            try {
+                const target = this.store.getIncidentNotificationTarget(incident.id);
+                if (target === undefined)
+                    continue;
+                const lifecycleKey = `automation-incident:${incident.id}:g${incident.lifecycleGeneration}`;
+                let outbox;
+                if (target.kind === 'owner-route') {
+                    const enqueue = delivery.enqueueBackgroundRoute;
+                    const publish = delivery.publishDeliveryPresentation;
+                    if (enqueue === undefined || publish === undefined)
+                        continue;
+                    outbox = incident.alertRef === undefined
+                        ? enqueue.call(delivery, {
+                            sourceId: 'assistant-automations-incidents',
+                            authorityId: target.authorityId,
+                            idempotencyKey: lifecycleKey,
+                            // Immutable bootstrap text. The typed presentation below owns all
+                            // mutable details and eventually replaces this exact message.
+                            text: `Automation incident ${incident.id}`,
+                            format: 'plain',
+                        })
+                        : { id: incident.alertRef, status: 'enqueued' };
+                    publish.call(delivery, {
+                        presentationKey: lifecycleKey,
+                        originalOutboxIdempotencyKey: lifecycleKey,
+                        revision: incident.presentationRevision,
+                        presentation: {
+                            kind: 'automation-incident',
+                            incidentId: incident.id,
+                            automationId: incident.automationId,
+                            definitionHash: incident.definitionHash,
+                            stage: incident.stage,
+                            state: incident.state,
+                            failureClass: incident.failureClass,
+                            failurePhase: incident.failurePhase,
+                            failureCode: incident.failureCode,
+                            sideEffectState: incident.sideEffectState,
+                            retryability: incident.retryability,
+                            lifecycleGeneration: incident.lifecycleGeneration,
+                            incidentRevision: incident.presentationRevision,
+                            openedAt: incident.openedAt,
+                            updatedAt: incident.updatedAt,
+                            ...(incident.resolvedAt === undefined ? {} : { resolvedAt: incident.resolvedAt }),
+                        },
+                    });
+                }
+                else {
+                    // Agent approval bindings are Conversation bindings, not Host owner-
+                    // route authorities. Emit one idempotent content-free update per
+                    // durable revision; Delivery intentionally reserves mutable incident
+                    // presentations for stable Host owner routes.
+                    outbox = delivery.enqueueBackground({
+                        sourceId: 'assistant-automations-incidents',
+                        workspace: target.workspace,
+                        bindingId: target.bindingId,
+                        idempotencyKey: `${lifecycleKey}:r${incident.presentationRevision}`,
+                        text: incidentAlertText(incident),
+                        format: 'plain',
+                    });
+                }
+                this.store.completeIncidentAlert({
+                    incidentId: incident.id,
+                    expectedStatus: 'pending',
+                    expectedLifecycleGeneration: incident.lifecycleGeneration,
+                    expectedPresentationRevision: incident.presentationRevision,
+                    expectedVersion: incident.version,
+                    alertRef: outbox.id,
+                    now: this.now(),
+                });
+            }
+            catch {
+                // Emergency stop / Policy refusal keeps the durable incident and its
+                // pending alert. A later authorized tick uses the same idempotency key.
+            }
+        }
     }
     dispatchRunDelivery(run) {
         if (run.deliveryStatus !== 'pending')
             return;
-        const automation = this.store.get(run.automationId);
+        let proof;
+        try {
+            proof = this.store.getProvenProductionRun(run.id);
+        }
+        catch {
+            this.store.suppressRunDelivery({ runId: run.id, expectedStatus: 'pending', now: this.now() });
+            return;
+        }
+        const automation = proof?.automation;
+        const evidence = proof?.run.evidence;
         const bindingId = automation?.definition.deliveryBindingId;
-        if (automation === undefined || bindingId === undefined)
+        if (proof === undefined || proof.run.status !== 'succeeded'
+            || evidence === undefined || automation === undefined || bindingId === undefined) {
+            // Unknown/legacy mode, missing immutable snapshot, hash mismatch, and a
+            // missing binding all reduce monotonically to a terminal no-send state.
+            this.store.suppressRunDelivery({ runId: run.id, expectedStatus: 'pending', now: this.now() });
             return;
+        }
+        run = proof.run;
         const normalizedOutput = run.outputPreview.normalize('NFC').trim();
         if (normalizedOutput === '' || automation.definition.deliverySuppressExact?.includes(normalizedOutput) === true) {
             this.store.suppressRunDelivery({ runId: run.id, expectedStatus: 'pending', now: this.now() });
             return;
         }
-        if (this.delivery === undefined)
+        if (this.delivery?.enqueueAutomationResult === undefined)
             return;
         try {
-            const outbox = this.delivery.enqueueBackground({
-                sourceId: automation.id,
+            const outbox = this.delivery.enqueueAutomationResult({
+                automationId: automation.id,
+                runId: run.id,
                 workspace: automation.definition.workspace,
                 bindingId,
-                idempotencyKey: `automation:${run.occurrenceId}:${bindingId}`,
-                text: run.outputPreview,
-                format: 'markdown',
+                outputPreview: run.outputPreview,
             });
             this.store.completeRunDelivery({
                 runId: run.id,