@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/automations/publication.js

@@ -0,0 +1,97 @@
+import { requireUnarchivedAutomation } from "./archive-management.js";
+import { readAutomationCatalog } from "./catalog.js";
+import { currentAutomationGrant } from "./permission-grants.js";
+import { validateAutomationPublication } from "./publication-validation.js";
+import { fingerprintAutomationDependencies } from "./dependency-fingerprint.js";
+import { automationTriggerSchedule, publishedAutomationScheduleTiming } from "./trigger-schedule.js";
+export class AutomationPublicationError extends Error {
+    issues;
+    constructor(issues) {
+        super("automation_graph_invalid");
+        this.issues = issues;
+    }
+}
+function commitDefinition(state, automationId, expectedRevision, record) {
+    requireUnarchivedAutomation(state, automationId);
+    const current = state.drafts.find((item) => item.automationId === automationId);
+    if (!current || current.revision !== expectedRevision)
+        throw new Error("automation_revision_conflict");
+    if (state.definitions.some((item) => item.automationId === automationId && item.revision === expectedRevision))
+        throw new Error("automation_already_published");
+    state.definitions.push(record);
+}
+function requirePublicationGrantRevision(state, environmentId, automationId, expectedGrantRevision) {
+    const latest = currentAutomationGrant(state.grants, environmentId, automationId);
+    if ((latest?.grantRevision ?? null) !== expectedGrantRevision)
+        throw new Error("automation_grant_revision_conflict");
+}
+export function createAutomationPublicationService(options) {
+    const now = options.now ?? Date.now;
+    async function publish(automationId, expectedRevision) {
+        const draft = await options.drafts.get(automationId);
+        if (!draft || draft.revision !== expectedRevision)
+            throw new Error("automation_revision_conflict");
+        if (draft.archivedAt)
+            throw new Error("automation_archived");
+        const grant = await options.grants.get(automationId);
+        const catalog = await readAutomationCatalog({
+            automationId,
+            environmentId: options.config.runtimeId,
+            config: options.config,
+            tools: options.tools,
+            persistence: options.persistence,
+        });
+        const job = await options.scheduler.getAutomationJob(automationId);
+        const state = await options.persistence.read();
+        const issues = validateAutomationPublication({
+            definition: draft.definition,
+            config: options.config,
+            operations: catalog.operations,
+            grantMode: grant?.mode ?? "full_access",
+            now: now(),
+            timeZone: options.timeZone,
+            existingSchedule: publishedAutomationScheduleTiming(state, job, draft.definition.trigger),
+        });
+        if (issues.length > 0)
+            throw new AutomationPublicationError(issues);
+        const record = {
+            id: `definition:${automationId}:${draft.revision}`,
+            automationId,
+            revision: draft.revision,
+            definition: structuredClone(draft.definition),
+            publishedAt: new Date(now()).toISOString(),
+            dependencyFingerprint: fingerprintAutomationDependencies({
+                definition: draft.definition,
+                config: options.config,
+                operations: catalog.operations,
+            }),
+        };
+        const schedule = automationTriggerSchedule(record.definition.trigger);
+        const commit = (state, candidate) => {
+            requirePublicationGrantRevision(state, options.config.runtimeId, automationId, grant?.grantRevision ?? null);
+            commitDefinition(state, automationId, expectedRevision, record);
+            // This callback mutates only the transaction candidate; a conflict
+            // rejects both the definition and job before either is published.
+            const publicationJobChanged = job &&
+                (candidate.id !== job.id || candidate.revision !== job.revision + 1);
+            if (publicationJobChanged)
+                throw new Error("automation_revision_conflict");
+        };
+        const publishedJob = job
+            ? await options.scheduler.updateAutomationJob(job.id, {
+                definitionRevision: record.revision,
+                title: record.definition.title,
+                schedule,
+                timeZone: options.timeZone,
+            }, commit)
+            : await options.scheduler.createAutomationJob({
+                automationId,
+                definitionRevision: record.revision,
+                title: record.definition.title,
+                schedule,
+                timeZone: options.timeZone,
+            }, commit);
+        return { definition: record, job: publishedJob };
+    }
+    return { publish };
+}

package/dist/src/runtime/automations/replay-preparation.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeAttachmentStore } from "../attachments/store.js";
+import type { PreparedAutomationOccurrence, SchedulerAutomationJob, SchedulerAutomationRun } from "../scheduler/contracts.js";
+import type { AutomationPersistence } from "./persistence.js";
+export declare function createAutomationReplayPreparer(options: {
+    persistence: AutomationPersistence;
+    attachments: RuntimeAttachmentStore;
+}): (job: SchedulerAutomationJob, previous: SchedulerAutomationRun, _candidateRunId: string) => Promise<PreparedAutomationOccurrence>;

package/dist/src/runtime/automations/replay-preparation.js

@@ -0,0 +1,59 @@
+function requireRetainedInput(state, inputId) {
+    const record = state.inputs.find((item) => item.id === inputId);
+    if (!record?.snapshot || record.snapshotRetiredAt || record.eligibility === "baseline" ||
+        record.snapshot.contentVersion !== record.contentVersion)
+        throw new Error("automation_replay_input_unavailable");
+    return {
+        id: record.id,
+        contentVersion: record.contentVersion,
+        storageRef: record.snapshot.attachment.storageRef,
+    };
+}
+export function createAutomationReplayPreparer(options) {
+    return async (job, previous, _candidateRunId) => {
+        const state = await options.persistence.read();
+        const definition = state.definitions.find((item) => item.automationId === previous.target.automationId &&
+            item.revision === previous.target.definitionRevision)?.definition;
+        if (!definition)
+            throw new Error("automation_definition_not_found");
+        const prior = state.executions.find((item) => item.id === previous.id);
+        if (!prior || prior.automationId !== previous.target.automationId ||
+            prior.definitionRevision !== previous.target.definitionRevision)
+            throw new Error("automation_replay_input_unavailable");
+        const inputIds = [...prior.inputIds];
+        if (definition.source && inputIds.length === 0)
+            throw new Error("automation_replay_input_unavailable");
+        const retained = inputIds.map((id) => requireRetainedInput(state, id));
+        for (const input of retained) {
+            const record = state.inputs.find((item) => item.id === input.id);
+            await options.attachments.resolveAttachment(record.snapshot.attachment);
+        }
+        return {
+            kind: "ready",
+            inputIds,
+            commit: (current, runId) => {
+                const liveDefinition = current.definitions.find((item) => item.automationId === previous.target.automationId &&
+                    item.revision === previous.target.definitionRevision);
+                const livePrior = current.executions.find((item) => item.id === previous.id);
+                if (!liveDefinition || !livePrior ||
+                    livePrior.inputIds.length !== inputIds.length ||
+                    livePrior.inputIds.some((id, index) => id !== inputIds[index]))
+                    throw new Error("automation_replay_input_changed");
+                for (const input of retained) {
+                    const live = requireRetainedInput(current, input.id);
+                    if (live.contentVersion !== input.contentVersion ||
+                        live.storageRef !== input.storageRef)
+                        throw new Error("automation_replay_input_changed");
+                }
+                current.executions.push({
+                    id: runId,
+                    automationId: job.target.automationId,
+                    definitionRevision: previous.target.definitionRevision,
+                    revision: 1,
+                    inputIds,
+                    nodes: [],
+                });
+            },
+        };
+    };
+}

package/dist/src/runtime/automations/result-capacity.d.ts

@@ -0,0 +1,5 @@
+import type { AutomationJournalState } from "./storage-records.js";
+/** Hard environment-wide bound while retained reports and replay inputs exist. */
+export declare const MAX_AUTOMATION_RESULT_BYTES: number;
+export declare function remainingAutomationResultBytes(state: AutomationJournalState): number;
+export declare function requireAutomationResultCapacity(state: AutomationJournalState, newBytes: number): void;

package/dist/src/runtime/automations/result-capacity.js

@@ -0,0 +1,9 @@
+/** Hard environment-wide bound while retained reports and replay inputs exist. */
+export const MAX_AUTOMATION_RESULT_BYTES = 256 * 1024 * 1024;
+export function remainingAutomationResultBytes(state) {
+    return MAX_AUTOMATION_RESULT_BYTES - state.results.reduce((bytes, item) => bytes + item.sizeBytes, 0);
+}
+export function requireAutomationResultCapacity(state, newBytes) {
+    if (newBytes > remainingAutomationResultBytes(state))
+        throw new Error("automation_artifact_budget_exhausted");
+}

package/dist/src/runtime/automations/result-publication.d.ts

@@ -0,0 +1,10 @@
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationResultStore } from "./result-store.js";
+import type { AutomationResultRecord } from "./storage-records.js";
+/** File cleanup requires a readable durable head, including after uncertain publication. */
+export declare function publishAutomationResult<T>(options: {
+    persistence: AutomationPersistence;
+    results: AutomationResultStore;
+    record: AutomationResultRecord;
+    publish(): Promise<T>;
+}): Promise<T>;

package/dist/src/runtime/automations/result-publication.js

@@ -0,0 +1,21 @@
+/** File cleanup requires a readable durable head, including after uncertain publication. */
+export async function publishAutomationResult(options) {
+    try {
+        return await options.publish();
+    }
+    catch (error) {
+        const state = await options.persistence.read().catch(() => undefined);
+        // A visible manifest may contain this record even when its directory sync
+        // failed. The poisoned journal refuses reads until durable reacquisition.
+        const definitelyUncommitted = state &&
+            !state.results.some((record) => record.id === options.record.id);
+        if (definitelyUncommitted)
+            await options.results.discardUncommitted(options.record).catch(() => undefined);
+        throw error;
+    }
+    finally {
+        // An unreadable head leaves bytes on disk, but not permanently active in
+        // memory. Existing maintenance reconciles them after reacquisition.
+        await options.results.releasePublication(options.record);
+    }
+}

package/dist/src/runtime/automations/result-store.d.ts

@@ -0,0 +1,17 @@
+import type { AutomationResultRecord } from "./storage-records.js";
+import type { AutomationPersistence } from "./persistence.js";
+export declare function createAutomationResultStore(runtimeDir: string): {
+    save: (input: {
+        runId: string;
+        nodeId?: string;
+        kind: AutomationResultRecord["kind"];
+        value: unknown;
+        maxBytes: number;
+        at?: string;
+    }) => Promise<AutomationResultRecord>;
+    read: (record: AutomationResultRecord) => Promise<unknown>;
+    discardUncommitted: (record: AutomationResultRecord) => Promise<void>;
+    releasePublication: (record: AutomationResultRecord) => Promise<void>;
+    reconcileUncommitted: (persistence: AutomationPersistence) => Promise<void>;
+};
+export type AutomationResultStore = ReturnType<typeof createAutomationResultStore>;

package/dist/src/runtime/automations/result-store.js

@@ -0,0 +1,109 @@
+import { createHash, randomUUID } from "node:crypto";
+import { Buffer } from "node:buffer";
+import { mkdir, readFile, readdir, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { syncJournalDirectory, writeJournalJson } from "../scheduler/journal-durability.js";
+const OWNED_FILE = /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.json$/u;
+const MAX_UNCOMMITTED_CLEANUP = 64;
+export function createAutomationResultStore(runtimeDir) {
+    const directory = join(runtimeDir, "automation-results");
+    const activePublications = new Set();
+    let reconciliation;
+    function recordPath(record) {
+        const match = OWNED_FILE.exec(`${record.id}.json`);
+        if (!match || record.storageRef !== `automation-results/${record.id}.json`)
+            throw new Error("automation_result_ref_invalid");
+        return join(directory, `${record.id}.json`);
+    }
+    async function save(input) {
+        if (!Number.isSafeInteger(input.maxBytes) || input.maxBytes < 1)
+            throw new Error("automation_artifact_budget_exhausted");
+        let serialized;
+        try {
+            serialized = JSON.stringify(input.value);
+        }
+        catch {
+            throw new Error("automation_output_invalid");
+        }
+        if (typeof serialized !== "string")
+            throw new Error("automation_output_invalid");
+        const bytes = Buffer.byteLength(serialized, "utf8");
+        if (bytes > input.maxBytes)
+            throw new Error("automation_artifact_budget_exhausted");
+        const id = randomUUID();
+        const storageRef = `automation-results/${id}.json`;
+        const digest = createHash("sha256").update(serialized).digest("hex");
+        activePublications.add(id);
+        try {
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+            await syncJournalDirectory(dirname(directory));
+            await writeJournalJson(join(directory, `${id}.json`), input.value);
+        }
+        catch (error) {
+            activePublications.delete(id);
+            throw error;
+        }
+        return {
+            id,
+            runId: input.runId,
+            ...(input.nodeId ? { nodeId: input.nodeId } : {}),
+            kind: input.kind,
+            storageRef,
+            digest,
+            sizeBytes: bytes,
+            createdAt: input.at ?? new Date().toISOString(),
+        };
+    }
+    async function read(record) {
+        const content = await readFile(recordPath(record), "utf8");
+        const digest = createHash("sha256").update(content).digest("hex");
+        if (digest !== record.digest || Buffer.byteLength(content, "utf8") !== record.sizeBytes)
+            throw new Error("automation_result_corrupt");
+        return JSON.parse(content);
+    }
+    async function discardUncommitted(record) {
+        await rm(recordPath(record), { force: true });
+    }
+    async function releasePublication(record) {
+        recordPath(record);
+        // A scan may hold a pre-commit journal snapshot. Keep this ID protected
+        // until that scan finishes; subsequent scans observe the published head.
+        await reconciliation?.catch(() => undefined);
+        activePublications.delete(record.id);
+    }
+    async function reconcileFiles(persistence) {
+        const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        });
+        if (!entries.length)
+            return;
+        const state = await persistence.read();
+        const committed = new Set(state.results.map((record) => record.id));
+        let cleaned = 0;
+        for (const entry of entries) {
+            if (cleaned === MAX_UNCOMMITTED_CLEANUP)
+                break;
+            if (!entry.isFile())
+                continue;
+            const match = OWNED_FILE.exec(entry.name);
+            if (!match)
+                continue;
+            const id = match[1];
+            if (committed.has(id) || activePublications.has(id))
+                continue;
+            await rm(join(directory, entry.name), { force: true });
+            cleaned += 1;
+        }
+        if (cleaned)
+            await syncJournalDirectory(directory);
+    }
+    function reconcileUncommitted(persistence) {
+        if (reconciliation)
+            return reconciliation;
+        reconciliation = reconcileFiles(persistence).finally(() => { reconciliation = undefined; });
+        return reconciliation;
+    }
+    return { save, read, discardUncommitted, releasePublication, reconcileUncommitted };
+}

package/dist/src/runtime/automations/retention.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeAttachmentStore } from "../attachments/store.js";
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationResultStore } from "./result-store.js";
+export declare const AUTOMATION_DETAIL_RETENTION_MS: number;
+export declare const AUTOMATION_REPORT_RETENTION_MS: number;
+/** Runs from the existing scheduler tick; marking survives a crash before file cleanup. */
+export declare function maintainAutomationRetention(input: {
+    persistence: AutomationPersistence;
+    results: AutomationResultStore;
+    attachments: RuntimeAttachmentStore;
+    now: number;
+}): Promise<void>;

package/dist/src/runtime/automations/retention.js

@@ -0,0 +1,134 @@
+export const AUTOMATION_DETAIL_RETENTION_MS = 30 * 24 * 60 * 60_000;
+export const AUTOMATION_REPORT_RETENTION_MS = 90 * 24 * 60 * 60_000;
+const MAX_RESULT_CLEANUP = 64;
+const MAX_SNAPSHOT_CLEANUP = 32;
+function hasUnresolvedEffect(state, runId) {
+    return state.attempts.some((attempt) => attempt.runId === runId &&
+        hasUnresolvedAttemptEffect(attempt));
+}
+function hasUnresolvedAttemptEffect(attempt) {
+    if (attempt.state === "started")
+        return true;
+    if (attempt.state !== "uncertain")
+        return false;
+    // Late evidence resolves resource uncertainty without rewriting the historical outcome.
+    if (attempt.lateSettlement?.status === "succeeded")
+        return false;
+    if (attempt.lateSettlement?.status === "failed")
+        return false;
+    return true;
+}
+function olderThan(terminalAt, now, ageMs) {
+    return terminalAt !== undefined && Date.parse(terminalAt) <= now - ageMs;
+}
+function updateExecution(state, current, patch) {
+    const next = { ...current, ...patch, revision: current.revision + 1 };
+    state.executions[state.executions.indexOf(current)] = next;
+    return next;
+}
+function markRunPayloads(state, now, at) {
+    for (const initial of [...state.executions]) {
+        if (!initial.terminalAt || hasUnresolvedEffect(state, initial.id))
+            continue;
+        let execution = initial;
+        if (olderThan(execution.terminalAt, now, AUTOMATION_DETAIL_RETENTION_MS) &&
+            !execution.detailsExpiredAt)
+            execution = updateExecution(state, execution, { detailsExpiredAt: at });
+        if (olderThan(execution.terminalAt, now, AUTOMATION_REPORT_RETENTION_MS) &&
+            !execution.reportExpiredAt)
+            updateExecution(state, execution, { reportExpiredAt: at });
+    }
+}
+function expiredResult(record, executions) {
+    const execution = executions.get(record.runId);
+    return record.kind === "report"
+        ? execution?.reportExpiredAt !== undefined
+        : execution?.detailsExpiredAt !== undefined;
+}
+function snapshotCanExpire(state, record) {
+    if (!record.snapshot)
+        return false;
+    if (!record.claimRunId)
+        return false;
+    const references = state.executions.filter((execution) => execution.inputIds.includes(record.id));
+    return references.length > 0 && references.every((execution) => execution.reportExpiredAt !== undefined && !hasUnresolvedEffect(state, execution.id));
+}
+function markSnapshots(state, at) {
+    let available = MAX_SNAPSHOT_CLEANUP;
+    for (const record of state.inputs) {
+        if (available === 0)
+            break;
+        if (record.snapshotRetiredAt || !snapshotCanExpire(state, record))
+            continue;
+        const outcomeRef = record.outcomeRef ?? inputClaimReport(state, record);
+        if (!outcomeRef)
+            continue;
+        state.inputs[state.inputs.indexOf(record)] = { ...record, outcomeRef, snapshotRetiredAt: at };
+        available -= 1;
+    }
+}
+function inputClaimReport(state, record) {
+    return state.executions.find((execution) => execution.id === record.claimRunId && execution.inputIds.includes(record.id))?.reportRef;
+}
+function ownedSnapshot(record) {
+    const parts = record.snapshot?.attachment.storageRef.split(/[\\/]/u);
+    return Boolean(record.claimRunId && parts?.[0] === record.claimRunId &&
+        parts[1] === record.id && parts.length === 3);
+}
+/** Runs from the existing scheduler tick; marking survives a crash before file cleanup. */
+export async function maintainAutomationRetention(input) {
+    await input.results.reconcileUncommitted(input.persistence);
+    const at = new Date(input.now).toISOString();
+    const pending = await input.persistence.update((state) => {
+        markRunPayloads(state, input.now, at);
+        markSnapshots(state, at);
+        const executions = new Map(state.executions.map((item) => [item.id, item]));
+        return {
+            results: state.results.filter((record) => expiredResult(record, executions))
+                .slice(0, MAX_RESULT_CLEANUP),
+            inputs: state.inputs.filter((record) => record.snapshotRetiredAt && record.snapshot)
+                .slice(0, MAX_SNAPSHOT_CLEANUP),
+        };
+    });
+    const removedResultIds = new Set();
+    const removedInputIds = new Set();
+    let failure;
+    for (const record of pending.results) {
+        try {
+            await input.results.discardUncommitted(record);
+            removedResultIds.add(record.id);
+        }
+        catch (error) {
+            failure ??= error;
+        }
+    }
+    for (const record of pending.inputs) {
+        try {
+            if (!ownedSnapshot(record))
+                throw new Error("automation_snapshot_owner_invalid");
+            if (!input.attachments.deleteAttachment)
+                throw new Error("automation_attachment_cleanup_unavailable");
+            await input.attachments.deleteAttachment(record.snapshot.attachment, {
+                sessionId: record.claimRunId,
+            });
+            removedInputIds.add(record.id);
+        }
+        catch (error) {
+            failure ??= error;
+        }
+    }
+    if (removedResultIds.size || removedInputIds.size) {
+        await input.persistence.update((state) => {
+            const executions = new Map(state.executions.map((item) => [item.id, item]));
+            state.results = state.results.filter((record) => !removedResultIds.has(record.id) || !expiredResult(record, executions));
+            state.inputs = state.inputs.map((record) => {
+                if (!removedInputIds.has(record.id) || !record.snapshotRetiredAt)
+                    return record;
+                const { snapshot: _snapshot, snapshotRetiredAt: _retired, ...metadata } = record;
+                return metadata;
+            });
+        });
+    }
+    if (failure)
+        throw failure;
+}

package/dist/src/runtime/automations/run-file-binding.d.ts

@@ -0,0 +1,3 @@
+/** A portable basename; the runtime owns the per-run directory, never the model. */
+export declare function isAutomationRunFileName(value: unknown): value is string;
+export declare function automationRunFilePath(runId: string | undefined, fileName: string): string | null;

package/dist/src/runtime/automations/run-file-binding.js

@@ -0,0 +1,19 @@
+/** A portable basename; the runtime owns the per-run directory, never the model. */
+export function isAutomationRunFileName(value) {
+    if (typeof value !== "string" || value.length === 0 || value.length > 120)
+        return false;
+    if (value !== value.trim() || value.endsWith("."))
+        return false;
+    if (value === "." || value === "..")
+        return false;
+    if (/[<>:"/\\|?*\u0000-\u001f]/u.test(value))
+        return false;
+    return !/^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/iu.test(value);
+}
+export function automationRunFilePath(runId, fileName) {
+    if (!runId || !/^[A-Za-z0-9_-]{1,128}$/u.test(runId))
+        return null;
+    if (!isAutomationRunFileName(fileName))
+        return null;
+    return `automation-output/${runId}/${fileName}`;
+}

package/dist/src/runtime/automations/run-output-summary.d.ts

@@ -0,0 +1,25 @@
+import type { AutomationRevision } from "./definition-contracts.js";
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationResultStore } from "./result-store.js";
+import { type AutomationSavedOutput } from "./step-evidence-output.js";
+import type { AutomationJournalState, AutomationNodeStateRecord } from "./storage-records.js";
+export type AutomationRunOutputEntry = Readonly<{
+    nodeId: string;
+    title: string;
+    stepStatus: AutomationNodeStateRecord["status"];
+    availability: "available" | "expired" | "unavailable";
+    output: AutomationSavedOutput | null;
+    errorCode?: string;
+}>;
+export type AutomationRunOutputSummary = Readonly<{
+    entries: readonly AutomationRunOutputEntry[];
+    omitted: number;
+}>;
+/** A transient preview of terminal producers, never another persisted report or outcome. */
+export declare function readAutomationRunOutputSummary(options: {
+    state: AutomationJournalState;
+    runId: string;
+    definition: AutomationRevision;
+    results: Pick<AutomationResultStore, "read">;
+    persistence: Pick<AutomationPersistence, "read">;
+}): Promise<AutomationRunOutputSummary>;

package/dist/src/runtime/automations/run-output-summary.js

@@ -0,0 +1,54 @@
+import { compileAutomationGraph } from "./graph-validation.js";
+import { projectAutomationSavedOutput } from "./step-evidence-output.js";
+const MAX_RUN_OUTPUTS = 4;
+function findOwnedExecution(state, runId, definition) {
+    return state.executions.find((item) => item.id === runId &&
+        item.automationId === definition.automationId &&
+        item.definitionRevision === definition.revision);
+}
+function terminalOutputSteps(definition) {
+    const compiled = compileAutomationGraph(definition);
+    if (!compiled.ok)
+        return [];
+    const predecessors = new Set(compiled.graph.steps.flatMap((step) => step.dependsOn));
+    return compiled.graph.steps.filter((step) => !predecessors.has(step.id));
+}
+/** A transient preview of terminal producers, never another persisted report or outcome. */
+export async function readAutomationRunOutputSummary(options) {
+    const { state, runId, definition } = options;
+    const execution = findOwnedExecution(state, runId, definition);
+    const terminalSteps = terminalOutputSteps(definition);
+    let expiryRead;
+    function detailsExpiredDuringRead() {
+        expiryRead ??= options.persistence.read().then((latest) => Boolean(findOwnedExecution(latest, runId, definition)?.detailsExpiredAt), () => false);
+        return expiryRead;
+    }
+    async function readEntry(step) {
+        const settled = execution?.nodes.find((item) => item.nodeId === step.id);
+        const base = {
+            nodeId: step.id, title: step.node.title, stepStatus: settled?.status ?? "pending",
+            ...(settled?.errorCode ? { errorCode: settled.errorCode } : {}),
+        };
+        if (execution?.detailsExpiredAt)
+            return { ...base, availability: "expired", output: null };
+        if (!settled?.resultRef)
+            return { ...base, availability: "unavailable", output: null };
+        const record = state.results.find((item) => item.id === settled.resultRef &&
+            item.runId === runId && item.nodeId === step.id && item.kind === "node_output");
+        if (!record)
+            return { ...base, availability: "unavailable", output: null };
+        try {
+            const saved = await options.results.read(record);
+            const output = projectAutomationSavedOutput(saved, false);
+            return { ...base, availability: "available", output };
+        }
+        catch {
+            // Retention publishes expiry before deleting bytes. Missing/corrupt output
+            // must not hide the independently retained compact report.
+            const expired = await detailsExpiredDuringRead();
+            return { ...base, availability: expired ? "expired" : "unavailable", output: null };
+        }
+    }
+    const entries = await Promise.all(terminalSteps.slice(0, MAX_RUN_OUTPUTS).map(readEntry));
+    return { entries, omitted: Math.max(0, terminalSteps.length - MAX_RUN_OUTPUTS) };
+}