@dsh-enhanced/assistant-automations 0.1.5 → 0.1.7

package/lib/store.js

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { isAbsolute } from 'node:path';
+import { isAbsolute, resolve } from 'node:path';
 import { dueOccurrences, nextOccurrence, previousOccurrence, validateSchedule, } from './schedule.js';
 import { AutomationDatabaseError, openAutomationDatabase } from './sqlite.js';
 export class AutomationStoreError extends Error {
@@ -13,6 +13,9 @@ export class AutomationStoreError extends Error {
 function hash(value) {
     return createHash('sha256').update(JSON.stringify(value)).digest('hex');
 }
+function hashText(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
 function text(value, field, maximum = 1_000) {
     if (typeof value !== 'string' || value.trim() === '') {
         throw new AutomationStoreError('invalid-definition', `${field} must be a non-empty string`);
@@ -125,6 +128,68 @@ export function normalizeAutomationDefinition(value, maxPromptBytes = 16_384, ma
         ...(deliverySuppressExact === undefined ? {} : { deliverySuppressExact }),
     });
 }
+function freezeAutomationSnapshot(value, expectedId) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new AutomationStoreError('invalid-state', 'automation execution snapshot must be an object');
+    }
+    const input = value;
+    if (typeof input['id'] !== 'string' || (expectedId !== undefined && input['id'] !== expectedId)) {
+        throw new AutomationStoreError('invalid-state', 'automation execution snapshot id does not match its task');
+    }
+    if (input['status'] !== 'active' || !Number.isSafeInteger(input['version']) || input['version'] < 1
+        || !Number.isSafeInteger(input['createdAt']) || !Number.isSafeInteger(input['updatedAt'])) {
+        throw new AutomationStoreError('invalid-state', 'automation execution snapshot metadata is invalid');
+    }
+    const nextRunAt = input['nextRunAt'];
+    if (nextRunAt !== undefined && !Number.isSafeInteger(nextRunAt)) {
+        throw new AutomationStoreError('invalid-state', 'automation execution snapshot nextRunAt is invalid');
+    }
+    const owner = input['owner'];
+    if (owner !== undefined && typeof owner !== 'string') {
+        throw new AutomationStoreError('invalid-state', 'automation execution snapshot owner is invalid');
+    }
+    const definition = normalizeAutomationDefinition(input['definition'], 16 * 1024 * 1024, 10_000);
+    return Object.freeze({
+        id: input['id'],
+        ...(owner === undefined ? {} : { owner }),
+        definition,
+        status: 'active',
+        nextRunAt: nextRunAt,
+        createdAt: input['createdAt'],
+        updatedAt: input['updatedAt'],
+        version: input['version'],
+    });
+}
+function encodeAutomationSnapshot(value) {
+    const json = JSON.stringify(value);
+    if (Buffer.byteLength(json, 'utf8') > 16 * 1024 * 1024) {
+        throw new AutomationStoreError('invalid-definition', 'automation execution snapshot exceeds 16777216 bytes');
+    }
+    return { hash: hashText(json), json };
+}
+function decodeAutomationSnapshot(snapshotHash, snapshotJson, expectedId) {
+    if (snapshotHash === null || snapshotJson === null)
+        return undefined;
+    if (Buffer.byteLength(snapshotJson, 'utf8') > 16 * 1024 * 1024
+        || hashText(snapshotJson) !== snapshotHash) {
+        throw new AutomationStoreError('invalid-state', 'automation execution snapshot integrity check failed');
+    }
+    try {
+        return freezeAutomationSnapshot(JSON.parse(snapshotJson), expectedId);
+    }
+    catch (error) {
+        if (error instanceof AutomationStoreError)
+            throw error;
+        throw new AutomationStoreError('invalid-state', 'automation execution snapshot contains invalid JSON');
+    }
+}
+function automationSnapshot(row, expectedId) {
+    return decodeAutomationSnapshot(row.automation_snapshot_hash, row.automation_snapshot_json, expectedId);
+}
+function executionScopeMatches(snapshot, scope) {
+    return resolve(snapshot.definition.workspace.normalize('NFC')) === resolve(scope.workspace.normalize('NFC'))
+        && snapshot.definition.agentPreset.normalize('NFC').trim() === scope.agentPreset.normalize('NFC').trim();
+}
 function record(row) {
     return Object.freeze({
         id: row.id,
@@ -214,6 +279,44 @@ function run(row) {
         updatedAt: row.updated_at,
     });
 }
+function deepFreezeJson(value) {
+    if (typeof value !== 'object' || value === null || Object.isFrozen(value))
+        return value;
+    for (const child of Object.values(value))
+        deepFreezeJson(child);
+    return Object.freeze(value);
+}
+function evaluationOutboxEntry(row) {
+    if (row.observation_kind !== 'terminal'
+        || (row.status !== 'pending' && row.status !== 'recorded' && row.status !== 'dead-letter')
+        || !Number.isSafeInteger(row.attempt_count) || row.attempt_count < 0
+        || !Number.isSafeInteger(row.next_attempt_at)) {
+        throw new AutomationStoreError('invalid-state', 'automation evaluation outbox row has an invalid state');
+    }
+    if (Buffer.byteLength(row.payload_json, 'utf8') > 32_768) {
+        throw new AutomationStoreError('invalid-state', 'automation evaluation payload exceeds 32768 bytes');
+    }
+    let payload;
+    try {
+        payload = deepFreezeJson(JSON.parse(row.payload_json));
+    }
+    catch {
+        throw new AutomationStoreError('invalid-state', 'automation evaluation payload contains invalid JSON');
+    }
+    return Object.freeze({
+        id: row.id,
+        runId: row.run_id,
+        kind: row.observation_kind,
+        status: row.status,
+        payload,
+        attemptCount: row.attempt_count,
+        nextAttemptAt: row.next_attempt_at,
+        ...(row.last_failure_at === null ? {} : { lastFailureAt: row.last_failure_at }),
+        ...(row.last_error_code === null ? {} : { lastErrorCode: row.last_error_code }),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    });
+}
 function duty(row, acquired) {
     return Object.freeze({
         acquired,
@@ -260,6 +363,48 @@ function buildOutcomeEvidence(input) {
     }
     return { status: 'pending', json };
 }
+function evaluationExecutionStatus(status) {
+    return status === 'timed_out' ? 'timed-out' : status;
+}
+function nonNegativeUsageMetric(usage, key) {
+    const value = usage[key];
+    return Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function buildTerminalEvaluation(input) {
+    const inputTokens = nonNegativeUsageMetric(input.usage, 'inputTokens');
+    const outputTokens = nonNegativeUsageMetric(input.usage, 'outputTokens');
+    const toolCalls = nonNegativeUsageMetric(input.usage, 'toolCalls');
+    const latencyMs = input.startedAt === null ? undefined : Math.max(0, input.occurredAt - input.startedAt);
+    const retries = Math.max(0, input.attemptNumber - 1);
+    const metrics = Object.freeze({
+        ...(inputTokens === undefined ? {} : { inputTokens }),
+        ...(outputTokens === undefined ? {} : { outputTokens }),
+        ...(toolCalls === undefined ? {} : { toolCalls }),
+        ...(latencyMs === undefined ? {} : { latencyMs }),
+        ...(retries === 0 ? {} : { retries }),
+    });
+    const rawSituation = `automation:${input.automation.id}`;
+    const situation = Buffer.byteLength(rawSituation, 'utf8') <= 200
+        ? rawSituation
+        : `automation:${createHash('sha256').update(input.automation.id).digest('hex')}`;
+    return Object.freeze({
+        scope: Object.freeze({
+            workspace: input.automation.definition.workspace,
+            preset: input.automation.definition.agentPreset,
+        }),
+        situation,
+        executionStatus: evaluationExecutionStatus(input.outcome),
+        objectiveStatus: 'unknown',
+        deliveryStatus: input.deliveryStatus,
+        source: Object.freeze({ kind: 'automation', id: 'assistant-automations' }),
+        trust: 'trusted',
+        evidence: Object.freeze([{ kind: 'automation-run', ref: input.runId }]),
+        metrics,
+        occurredAt: input.occurredAt,
+        idempotencyKey: `assistant-automations:terminal:${input.runId}:v1`,
+        evaluator: Object.freeze({ id: 'assistant-automations', version: 'terminal-v1' }),
+    });
+}
 export function stableOccurrenceId(automationId, triggerKind, triggerKey) {
     return `occ-${createHash('sha256').update(`${automationId}\0${triggerKind}\0${triggerKey}`).digest('hex')}`;
 }
@@ -400,6 +545,13 @@ export class AutomationStore {
             runningTasks: scalar("SELECT COUNT(*) AS count FROM automation_tasks WHERE status = 'running'"),
             failedRuns: scalar("SELECT COUNT(*) AS count FROM automation_runs WHERE status IN ('failed', 'timed_out', 'cancelled')"),
             unknownRuns: scalar("SELECT COUNT(*) AS count FROM automation_runs WHERE status = 'unknown'"),
+            pendingEvaluations: scalar("SELECT COUNT(*) AS count FROM automation_evaluation_outbox WHERE status = 'pending'"),
+            retryingEvaluations: scalar("SELECT COUNT(*) AS count FROM automation_evaluation_outbox WHERE status = 'pending' AND attempt_count > 0"),
+            // This is an append-only lifetime counter. It supports rate/delta
+            // monitoring but does not by itself describe current health.
+            failedEvaluationAttempts: scalar('SELECT COALESCE(SUM(attempt_count), 0) AS count FROM automation_evaluation_outbox'),
+            deadLetterEvaluations: scalar("SELECT COUNT(*) AS count FROM automation_evaluation_outbox WHERE status = 'dead-letter'"),
+            oldestPendingEvaluationAt: scalar("SELECT COALESCE(MIN(created_at), 0) AS count FROM automation_evaluation_outbox WHERE status = 'pending'"),
         };
     }
     changeApproved(input) {
@@ -593,6 +745,30 @@ export class AutomationStore {
     getTaskRecord(id) {
         return this.getTask(id);
     }
+    /** Immutable definition captured by the winning claim, never the mutable current row. */
+    getTaskExecutionSnapshot(taskId) {
+        const taskRow = this.database.prepare('SELECT * FROM automation_tasks WHERE id = ?').get(taskId);
+        if (taskRow === undefined || taskRow.attempt_count < 1)
+            return undefined;
+        const attempt = this.database.prepare(`
+      SELECT * FROM automation_attempts WHERE task_id = ? AND attempt_number = ?
+    `).get(taskId, taskRow.attempt_count);
+        return attempt === undefined ? undefined : automationSnapshot(attempt, taskRow.automation_id);
+    }
+    /** Immutable definition associated with a durable terminal run. */
+    getRunExecutionSnapshot(runId) {
+        const row = this.database.prepare(`
+      SELECT attempt.*, run.automation_id AS expected_automation_id
+      FROM automation_runs AS run
+      JOIN automation_attempts AS attempt ON attempt.id = run.attempt_id
+      WHERE run.id = ?
+    `).get(runId);
+        return row === undefined ? undefined : automationSnapshot(row, row.expected_automation_id);
+    }
+    getRun(runId) {
+        const row = this.database.prepare('SELECT * FROM automation_runs WHERE id = ?').get(runId);
+        return row === undefined ? undefined : run(row);
+    }
     acquireDuty(input) {
         const ownerId = text(input.ownerId, 'ownerId', 500);
         this.validateLease(input.now, input.leaseMs);
@@ -740,9 +916,10 @@ export class AutomationStore {
             if (attempt === undefined)
                 throw new AutomationStoreError('stale-fence', 'winning attempt was not found');
             const runId = `run-${row.id}`;
-            const automation = this.get(row.automation_id);
-            if (automation === undefined)
-                throw new AutomationStoreError('invalid-state', 'automation definition was not found');
+            const automation = automationSnapshot(attempt, row.automation_id);
+            if (automation === undefined) {
+                throw new AutomationStoreError('invalid-state', 'winning attempt has no immutable automation snapshot');
+            }
             const evidence = buildOutcomeEvidence({
                 automation,
                 runId,
@@ -750,17 +927,40 @@ export class AutomationStore {
                 occurredAt: input.now,
                 attribution: evidenceAttribution,
             });
-            const deliveryStatus = input.outcome === 'succeeded'
+            const normalizedOutput = preview.normalize('NFC').trim();
+            const runDeliveryStatus = input.outcome === 'succeeded'
                 && automation.definition.deliveryBindingId !== undefined
-                ? 'pending'
+                ? normalizedOutput === '' || automation.definition.deliverySuppressExact?.includes(normalizedOutput) === true
+                    ? 'suppressed'
+                    : 'pending'
                 : null;
+            const evaluation = buildTerminalEvaluation({
+                automation,
+                runId,
+                outcome: input.outcome,
+                occurredAt: input.now,
+                usage: input.usage,
+                startedAt: attempt.started_at,
+                attemptNumber: attempt.attempt_number,
+                deliveryStatus: runDeliveryStatus === 'pending' ? 'unknown' : 'not-required',
+            });
+            const evaluationJson = JSON.stringify(evaluation);
+            if (Buffer.byteLength(evaluationJson, 'utf8') > 32_768) {
+                throw new AutomationStoreError('invalid-definition', 'automation evaluation payload exceeds 32768 bytes');
+            }
             this.database.prepare(`
         INSERT INTO automation_runs(
           id, occurrence_id, automation_id, task_id, attempt_id, status, session_id, artifact_ref,
           output_preview, usage_json, delivery_status, delivery_ref, evidence_status, evidence_json,
           created_at, updated_at
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?)
-      `).run(runId, row.occurrence_id, row.automation_id, row.id, attempt.id, input.outcome, input.sessionId ?? null, input.artifactRef ?? null, preview, usageJson, deliveryStatus, evidence.status, evidence.json, input.now, input.now);
+      `).run(runId, row.occurrence_id, row.automation_id, row.id, attempt.id, input.outcome, input.sessionId ?? null, input.artifactRef ?? null, preview, usageJson, runDeliveryStatus, evidence.status, evidence.json, input.now, input.now);
+            this.database.prepare(`
+        INSERT INTO automation_evaluation_outbox(
+          id, run_id, observation_kind, status, payload_json, attempt_count,
+          next_attempt_at, last_failure_at, last_error_code, created_at, updated_at
+        ) VALUES (?, ?, 'terminal', 'pending', ?, 0, ?, NULL, NULL, ?, ?)
+      `).run(`evaluation-terminal:${runId}`, runId, evaluationJson, input.now, input.now, input.now);
             this.database.prepare(`
         UPDATE automation_attempts
         SET status = ?, failure_code = ?, finished_at = ?, updated_at = ? WHERE id = ?
@@ -812,6 +1012,101 @@ export class AutomationStore {
         }
         return run(this.database.prepare('SELECT * FROM automation_runs WHERE id = ?').get(input.runId));
     }
+    listPendingEvaluations(limit, now = Number.MAX_SAFE_INTEGER) {
+        if (!Number.isSafeInteger(limit) || limit <= 0 || limit > 1_000) {
+            throw new AutomationStoreError('invalid-definition', 'evaluation limit must be between 1 and 1000');
+        }
+        if (!Number.isSafeInteger(now))
+            throw new AutomationStoreError('invalid-definition', 'now must be a safe integer');
+        const rows = this.database.prepare(`
+      SELECT * FROM automation_evaluation_outbox
+      WHERE status = 'pending' AND next_attempt_at <= ? ORDER BY next_attempt_at, id LIMIT ?
+    `).all(now, limit);
+        const output = [];
+        for (const row of rows) {
+            try {
+                output.push(evaluationOutboxEntry(row));
+            }
+            catch {
+                // A repaired or legacy poison row must not abort scheduler recovery or
+                // starve valid observations behind it. Quarantine it without exposing
+                // payload contents or exception text.
+                this.database.prepare(`
+          UPDATE automation_evaluation_outbox
+          SET status = 'dead-letter', attempt_count = attempt_count + 1,
+              last_failure_at = ?, last_error_code = 'invalid-outbox-payload', updated_at = ?
+          WHERE id = ? AND status = 'pending'
+        `).run(now, now, row.id);
+            }
+        }
+        return output;
+    }
+    getPendingEvaluationForRun(runId, now = Number.MAX_SAFE_INTEGER) {
+        if (!Number.isSafeInteger(now))
+            throw new AutomationStoreError('invalid-definition', 'now must be a safe integer');
+        const row = this.database.prepare(`
+      SELECT * FROM automation_evaluation_outbox
+      WHERE run_id = ? AND observation_kind = 'terminal' AND status = 'pending' AND next_attempt_at <= ?
+      ORDER BY id LIMIT 1
+    `).get(runId, now);
+        if (row === undefined)
+            return undefined;
+        try {
+            return evaluationOutboxEntry(row);
+        }
+        catch {
+            this.database.prepare(`
+        UPDATE automation_evaluation_outbox
+        SET status = 'dead-letter', attempt_count = attempt_count + 1,
+            last_failure_at = ?, last_error_code = 'invalid-outbox-payload', updated_at = ?
+        WHERE id = ? AND status = 'pending'
+      `).run(now, now, row.id);
+            return undefined;
+        }
+    }
+    deferEvaluation(input) {
+        if (!Number.isSafeInteger(input.now))
+            throw new AutomationStoreError('invalid-definition', 'now must be a safe integer');
+        if (!Number.isSafeInteger(input.retryAt) || input.retryAt < input.now
+            || !Number.isSafeInteger(input.maxAttempts) || input.maxAttempts < 1 || input.maxAttempts > 100) {
+            throw new AutomationStoreError('invalid-definition', 'evaluation retry bounds are invalid');
+        }
+        const errorCode = text(input.errorCode, 'evaluation errorCode', 64);
+        const changed = this.database.prepare(`
+      UPDATE automation_evaluation_outbox
+      SET attempt_count = attempt_count + 1,
+          status = CASE WHEN attempt_count + 1 >= ? THEN 'dead-letter' ELSE 'pending' END,
+          next_attempt_at = CASE WHEN attempt_count + 1 >= ? THEN next_attempt_at ELSE ? END,
+          last_failure_at = ?, last_error_code = ?, updated_at = ?
+      WHERE id = ? AND status = ?
+    `).run(input.maxAttempts, input.maxAttempts, input.retryAt, input.now, errorCode, input.now, input.id, input.expectedStatus);
+        if (changed.changes !== 1) {
+            const current = this.database.prepare('SELECT * FROM automation_evaluation_outbox WHERE id = ?')
+                .get(input.id);
+            if (current?.status === 'recorded')
+                return evaluationOutboxEntry(current);
+            throw new AutomationStoreError('version-conflict', 'evaluation outbox state changed before deferral');
+        }
+        return evaluationOutboxEntry(this.database.prepare('SELECT * FROM automation_evaluation_outbox WHERE id = ?')
+            .get(input.id));
+    }
+    completeEvaluation(input) {
+        if (!Number.isSafeInteger(input.now))
+            throw new AutomationStoreError('invalid-definition', 'now must be a safe integer');
+        const changed = this.database.prepare(`
+      UPDATE automation_evaluation_outbox SET status = 'recorded', updated_at = ?
+      WHERE id = ? AND status = ?
+    `).run(input.now, input.id, input.expectedStatus);
+        if (changed.changes !== 1) {
+            const current = this.database.prepare('SELECT * FROM automation_evaluation_outbox WHERE id = ?')
+                .get(input.id);
+            if (current?.status === 'recorded')
+                return evaluationOutboxEntry(current);
+            throw new AutomationStoreError('version-conflict', 'evaluation outbox state changed before completion');
+        }
+        return evaluationOutboxEntry(this.database.prepare('SELECT * FROM automation_evaluation_outbox WHERE id = ?')
+            .get(input.id));
+    }
     listPendingDeliveries(limit) {
         if (!Number.isSafeInteger(limit) || limit <= 0 || limit > 1_000) {
             throw new AutomationStoreError('invalid-definition', 'delivery limit must be between 1 and 1000');
@@ -861,6 +1156,56 @@ export class AutomationStore {
                 .all(input.automationId, input.limit);
         return rows.map(run);
     }
+    /**
+     * Newest-first terminal history whose immutable claim snapshot belongs to one
+     * exact Agent scope.  Legacy rows without a verifiable snapshot are omitted;
+     * the current mutable definition is never used to guess historical scope.
+     */
+    listRunsForExecutionScope(input) {
+        if (!isAbsolute(input.workspace) || input.agentPreset.normalize('NFC').trim() === '') {
+            throw new AutomationStoreError('invalid-definition', 'run history requires an absolute workspace and preset');
+        }
+        if (!Number.isSafeInteger(input.limit) || input.limit <= 0 || input.limit > 1_000) {
+            throw new AutomationStoreError('invalid-definition', 'run limit must be between 1 and 1000');
+        }
+        const output = [];
+        let cursor;
+        while (output.length < input.limit) {
+            const pageSize = Math.min(1_000, Math.max(100, (input.limit - output.length) * 4));
+            const automationClause = input.automationId === undefined ? '' : 'AND run.automation_id = ?';
+            const cursorClause = cursor === undefined
+                ? ''
+                : 'AND (run.created_at < ? OR (run.created_at = ? AND run.id < ?))';
+            const parameters = [];
+            if (input.automationId !== undefined)
+                parameters.push(input.automationId);
+            if (cursor !== undefined)
+                parameters.push(cursor.createdAt, cursor.createdAt, cursor.id);
+            parameters.push(pageSize);
+            const rows = this.database.prepare(`
+        SELECT run.*,
+          attempt.automation_snapshot_hash AS scope_snapshot_hash,
+          attempt.automation_snapshot_json AS scope_snapshot_json
+        FROM automation_runs AS run
+        JOIN automation_attempts AS attempt ON attempt.id = run.attempt_id
+        WHERE 1 = 1 ${automationClause} ${cursorClause}
+        ORDER BY run.created_at DESC, run.id DESC
+        LIMIT ?
+      `).all(...parameters);
+            for (const row of rows) {
+                const snapshot = decodeAutomationSnapshot(row.scope_snapshot_hash, row.scope_snapshot_json, row.automation_id);
+                if (snapshot !== undefined && executionScopeMatches(snapshot, input))
+                    output.push(run(row));
+                if (output.length === input.limit)
+                    break;
+            }
+            const last = rows.at(-1);
+            if (last === undefined || rows.length < pageSize)
+                break;
+            cursor = { createdAt: last.created_at, id: last.id };
+        }
+        return Object.freeze(output);
+    }
     recoverExpiredTasks(input) {
         if (!Number.isSafeInteger(input.now))
             throw new AutomationStoreError('invalid-definition', 'now must be a safe integer');
@@ -876,10 +1221,17 @@ export class AutomationStore {
       `).all(input.now, limit);
             const recovered = [];
             for (const row of rows) {
-                const definition = this.get(row.automation_id).definition;
+                const attempt = this.database.prepare(`
+          SELECT * FROM automation_attempts
+          WHERE task_id = ? AND attempt_number = ? AND fencing_token = ?
+        `).get(row.id, row.attempt_count, row.fencing_token);
+                if (attempt === undefined) {
+                    throw new AutomationStoreError('invalid-state', 'expired task has no matching execution attempt');
+                }
+                const snapshot = automationSnapshot(attempt, row.automation_id);
                 const retry = row.status === 'running'
-                    && definition.retrySafety === 'idempotent'
-                    && row.attempt_count <= definition.maxRetries;
+                    && snapshot?.definition.retrySafety === 'idempotent'
+                    && row.attempt_count <= snapshot.definition.maxRetries;
                 const target = row.status === 'claimed' || retry ? 'scheduled' : 'unknown';
                 const attemptStatus = row.status === 'claimed' ? 'lost' : 'unknown';
                 this.database.prepare(`
@@ -893,6 +1245,36 @@ export class AutomationStore {
           WHERE id = ?
         `).run(target, input.now, row.id);
                 if (target === 'unknown') {
+                    if (snapshot !== undefined) {
+                        const runId = `run-${row.id}`;
+                        const evaluation = buildTerminalEvaluation({
+                            automation: snapshot,
+                            runId,
+                            outcome: 'unknown',
+                            occurredAt: input.now,
+                            usage: {},
+                            startedAt: attempt.started_at,
+                            attemptNumber: attempt.attempt_number,
+                            deliveryStatus: 'not-required',
+                        });
+                        const evaluationJson = JSON.stringify(evaluation);
+                        if (Buffer.byteLength(evaluationJson, 'utf8') > 32_768) {
+                            throw new AutomationStoreError('invalid-state', 'recovered automation evaluation payload is oversized');
+                        }
+                        this.database.prepare(`
+              INSERT INTO automation_runs(
+                id, occurrence_id, automation_id, task_id, attempt_id, status, session_id, artifact_ref,
+                output_preview, usage_json, delivery_status, delivery_ref, evidence_status, evidence_json,
+                created_at, updated_at
+              ) VALUES (?, ?, ?, ?, ?, 'unknown', ?, NULL, ?, '{}', NULL, NULL, 'suppressed', NULL, ?, ?)
+            `).run(runId, row.occurrence_id, row.automation_id, row.id, attempt.id, attempt.session_id, 'runner lease expired before terminal receipt', input.now, input.now);
+                        this.database.prepare(`
+              INSERT INTO automation_evaluation_outbox(
+                id, run_id, observation_kind, status, payload_json, attempt_count,
+                next_attempt_at, last_failure_at, last_error_code, created_at, updated_at
+              ) VALUES (?, ?, 'terminal', 'pending', ?, 0, ?, NULL, NULL, ?, ?)
+            `).run(`evaluation-terminal:${runId}`, runId, evaluationJson, input.now, input.now, input.now);
+                    }
                     this.database.prepare(`
             UPDATE automation_occurrences SET status = 'unknown', reason = 'runner-lease-expired', updated_at = ? WHERE id = ?
           `).run(input.now, row.occurrence_id);
@@ -960,6 +1342,7 @@ export class AutomationStore {
         }
         const attemptNumber = row.attempt_count + 1;
         const attemptId = `attempt-${row.id}-${attemptNumber}`;
+        const snapshot = encodeAutomationSnapshot(automation);
         const leaseUntil = input.now + input.leaseMs;
         this.database.prepare(`
       UPDATE automation_tasks
@@ -969,9 +1352,10 @@ export class AutomationStore {
         this.database.prepare(`
       INSERT INTO automation_attempts(
         id, task_id, attempt_number, owner_id, fencing_token, status, session_id,
-        failure_code, started_at, finished_at, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, 'claimed', NULL, NULL, NULL, NULL, ?, ?)
-    `).run(attemptId, row.id, attemptNumber, input.ownerId, input.fencingToken, input.now, input.now);
+        failure_code, started_at, finished_at, automation_snapshot_hash,
+        automation_snapshot_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, 'claimed', NULL, NULL, NULL, NULL, ?, ?, ?, ?)
+    `).run(attemptId, row.id, attemptNumber, input.ownerId, input.fencingToken, snapshot.hash, snapshot.json, input.now, input.now);
         return this.getTask(row.id);
     }
     insertOccurrence(input) {