@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/automations/starter-templates.d.ts

@@ -0,0 +1,20 @@
+import type { AutomationCatalogOperation } from "./catalog.js";
+import type { AutomationRevision } from "./definition-contracts.js";
+export declare function listAutomationStarters(operations: readonly AutomationCatalogOperation[]): {
+    id: string;
+    title: string;
+    category: string;
+    description: string;
+    setup: string;
+    toolNames: string[];
+    stepCount: number;
+    agentCount: number;
+    parallelGroupCount: number;
+    level: string;
+    highlights: readonly string[];
+    outputFiles: string[];
+}[];
+export declare function prepareAutomationStarter(id: string, operations: readonly AutomationCatalogOperation[]): {
+    title: string;
+    buildDefinition(base: AutomationRevision): AutomationRevision;
+};

package/dist/src/runtime/automations/starter-templates.js

@@ -0,0 +1,75 @@
+import { validateToolNormalInvocationInput } from "../../capabilities/normal-invocation/validator.js";
+import { automationRunFilePath } from "./run-file-binding.js";
+import { AUTOMATION_STARTERS } from "./starter-template-definitions.js";
+import { buildStarterDefinition } from "./starter-template-builder.js";
+import { isStarterToolStep, walkStarterSteps } from "./starter-template-structure.js";
+function hasCompatibleStarterControls(step, operation, starter) {
+    const controlInputs = Object.entries(step.controlInputs ?? {});
+    if (controlInputs.some(([, key]) => !Object.hasOwn(starter.inputs ?? {}, key)))
+        return false;
+    const values = { ...step.controls,
+        ...Object.fromEntries(controlInputs.map(([name, key]) => [name, starter.inputs[key]])),
+        ...(step.outputFile ? { path: automationRunFilePath("template-run", step.outputFile) } : {}) };
+    if (Object.keys(values).some((name) => !Object.hasOwn(operation.input.properties, name)))
+        return false;
+    const contract = {
+        operationId: operation.operationId, summary: operation.label,
+        input: { ...operation.input,
+            required: operation.input.required.filter((name) => Object.hasOwn(values, name)) },
+        effect: operation.effect, approval: operation.approval,
+        ...(operation.payload ? { payload: operation.payload } : {}),
+    };
+    return validateToolNormalInvocationInput(contract, values).ok;
+}
+function matchesStarterOperation(step, candidate, starter) {
+    if (candidate.toolName !== step.toolName)
+        return false;
+    if (candidate.operationId !== step.operationId)
+        return false;
+    if (candidate.effect !== (step.effect ?? "read_only"))
+        return false;
+    // A new draft cannot inherit or manufacture a FULL+ grant.
+    if (candidate.permissionMode === "full_plus")
+        return false;
+    if (candidate.approval !== "request_policy")
+        return false;
+    if (step.payloadFrom && candidate.payload?.kind !== "raw_text")
+        return false;
+    if (!step.payloadFrom && candidate.payload)
+        return false;
+    return hasCompatibleStarterControls(step, candidate, starter);
+}
+function findAvailableOperation(step, operations, starter) {
+    return operations.find((candidate) => matchesStarterOperation(step, candidate, starter));
+}
+function isStarterAvailable(starter, operations) {
+    return walkStarterSteps(starter.steps).filter(isStarterToolStep)
+        .every((step) => Boolean(findAvailableOperation(step, operations, starter)));
+}
+export function listAutomationStarters(operations) {
+    return AUTOMATION_STARTERS.filter((starter) => isStarterAvailable(starter, operations)).slice(0, 10).map((starter) => {
+        const steps = walkStarterSteps(starter.steps);
+        const tools = steps.filter(isStarterToolStep);
+        return {
+            id: starter.id, title: starter.title, category: starter.category,
+            description: starter.description, setup: starter.setup,
+            toolNames: [...new Set(tools.map((step) => step.toolName))],
+            stepCount: steps.filter((step) => step.kind !== "parallel").length,
+            agentCount: steps.filter((step) => step.kind === "agent").length,
+            parallelGroupCount: steps.filter((step) => step.kind === "parallel").length,
+            level: starter.level ?? "starter", highlights: starter.highlights ?? [],
+            outputFiles: tools.flatMap((step) => step.outputFile ? [step.outputFile] : []),
+        };
+    });
+}
+export function prepareAutomationStarter(id, operations) {
+    const starter = AUTOMATION_STARTERS.find((item) => item.id === id);
+    if (!starter || !isStarterAvailable(starter, operations))
+        throw new Error("automation_template_unavailable");
+    return {
+        title: starter.title,
+        buildDefinition(base) {
+            return buildStarterDefinition(starter, base, (step) => findAvailableOperation(step, operations, starter));
+        },
+    };
+}

package/dist/src/runtime/automations/step-evidence-effects.d.ts

@@ -0,0 +1,46 @@
+import type { AutomationRevision, OperationRef, WorkflowNode } from "./definition-contracts.js";
+import type { AutomationResultStore } from "./result-store.js";
+import type { AutomationAttemptRecord, AutomationJournalState } from "./storage-records.js";
+export type AutomationStepNode = Extract<WorkflowNode, {
+    kind: "agent" | "tool";
+}>;
+export type AutomationEffectEvidence = Readonly<{
+    attemptId: string;
+    nodeId: string;
+    operation?: OperationRef;
+    outcome: "succeeded" | "failed" | "rejected" | "uncertain" | "pending";
+    effect?: "read_only" | "mutating" | "mixed";
+    errorCode?: string;
+    actions: readonly Readonly<{
+        type: string;
+        target?: string;
+    }>[];
+    omittedActions: number;
+    lateEvidence?: Readonly<{
+        status: "succeeded" | "failed" | "rejected";
+        observedAt: string;
+        errorCode?: string;
+    }>;
+}>;
+export type AutomationRunEffectSummary = Readonly<{
+    total: number;
+    omitted: number;
+    verifiedExecutions: number;
+    unresolvedAttempts: number;
+    entries: readonly AutomationEffectEvidence[];
+}>;
+export declare function findAutomationStep(root: AutomationRevision["body"], nodeId: string): AutomationStepNode | null;
+export declare function readAutomationStepEffects(input: {
+    state: AutomationJournalState;
+    results: AutomationResultStore;
+    runId: string;
+    node: AutomationStepNode;
+}): Promise<AutomationEffectEvidence[]>;
+export declare function readAutomationRunEffectSummary(input: {
+    state: AutomationJournalState;
+    results: AutomationResultStore;
+    runId: string;
+    definition: AutomationRevision;
+}): Promise<AutomationRunEffectSummary>;
+/** Overlay late evidence without changing the original attempt outcome or saved receipt actions. */
+export declare function withCurrentLateEvidence(summary: AutomationRunEffectSummary, attempts: readonly AutomationAttemptRecord[]): AutomationRunEffectSummary;

package/dist/src/runtime/automations/step-evidence-effects.js

@@ -0,0 +1,173 @@
+const MAX_REPORTED_EFFECTS = 24;
+const MAX_REPORTED_ACTIONS = 4;
+const MAX_ACTION_TYPE_CHARACTERS = 80;
+const MAX_ACTION_TARGET_CHARACTERS = 240;
+export function findAutomationStep(root, nodeId) {
+    const pending = [root];
+    while (pending.length > 0) {
+        const node = pending.pop();
+        if (node.id === nodeId && (node.kind === "agent" || node.kind === "tool"))
+            return node;
+        if (node.kind === "sequence")
+            pending.push(...node.children);
+        if (node.kind === "parallel")
+            pending.push(...node.branches);
+    }
+    return null;
+}
+function requireEffectResult(state, attempt, kind) {
+    const record = state.results.find((item) => item.id === attempt.settlementRef &&
+        item.runId === attempt.runId && item.nodeId === attempt.nodeId && item.kind === kind);
+    if (!record)
+        throw new Error("automation_result_ref_invalid");
+    return record;
+}
+function bounded(value, max) {
+    return value.length > max ? `${value.slice(0, max - 1)}…` : value;
+}
+function completionActions(value) {
+    if (!Array.isArray(value))
+        return { actions: [], omittedActions: 0 };
+    const actions = value.slice(0, MAX_REPORTED_ACTIONS).flatMap((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item) ||
+            typeof item.type !== "string")
+            return [];
+        const action = item;
+        return [{ type: bounded(action.type, MAX_ACTION_TYPE_CHARACTERS),
+                ...(typeof action.target === "string"
+                    ? { target: bounded(action.target, MAX_ACTION_TARGET_CHARACTERS) } : {}) }];
+    });
+    return { actions, omittedActions: Math.max(0, value.length - actions.length) };
+}
+function selectedOperationMatches(selected, candidate) {
+    return selected.toolName === candidate.toolName &&
+        selected.operationId === candidate.operationId &&
+        selected.contractVersion === candidate.contractVersion;
+}
+function requireSelectedAgentOperation(node, value) {
+    if (node.kind !== "agent" || !value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("automation_result_invalid");
+    const candidate = value;
+    const selected = node.tools.find((tool) => selectedOperationMatches(tool.operation, candidate));
+    if (!selected)
+        throw new Error("automation_result_invalid");
+    return selected.operation;
+}
+function supplementalLateEvidence(attempt) {
+    if (!attempt.lateSettlement)
+        return undefined;
+    const late = attempt.lateSettlement;
+    return { status: late.status, observedAt: late.observedAt,
+        ...(late.errorCode ? { errorCode: late.errorCode } : {}) };
+}
+function originalOutcome(attempt, execution) {
+    if (attempt.state === "uncertain")
+        return "uncertain";
+    return execution;
+}
+function directToolEffect(node, attempt, value) {
+    if (node.kind !== "tool" || !value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("automation_result_invalid");
+    const saved = value;
+    const lateEvidence = supplementalLateEvidence(attempt);
+    if (saved.kind === "rejected" || saved.kind === "uncertain") {
+        return { attemptId: attempt.id, nodeId: node.id, operation: node.operation,
+            outcome: originalOutcome(attempt, saved.kind), actions: [], omittedActions: 0,
+            ...(typeof saved.code === "string" ? { errorCode: saved.code } : {}),
+            ...(lateEvidence ? { lateEvidence } : {}) };
+    }
+    if (!saved.receipt || typeof saved.receipt !== "object" || Array.isArray(saved.receipt))
+        throw new Error("automation_result_invalid");
+    const receipt = saved.receipt;
+    if (typeof receipt.ok !== "boolean")
+        throw new Error("automation_result_invalid");
+    if (receipt.effect !== "read_only" && receipt.effect !== "mutating" && receipt.effect !== "mixed")
+        throw new Error("automation_result_invalid");
+    return { attemptId: attempt.id, nodeId: node.id, operation: node.operation,
+        outcome: originalOutcome(attempt, receipt.ok ? "succeeded" : "failed"),
+        effect: receipt.effect,
+        ...completionActions(receipt.completionActions),
+        ...(typeof receipt.errorCode === "string" ? { errorCode: receipt.errorCode } : {}),
+        ...(lateEvidence ? { lateEvidence } : {}) };
+}
+function agentEffect(node, attempt, value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("automation_result_invalid");
+    const saved = value;
+    const operation = requireSelectedAgentOperation(node, saved.operation);
+    if (!saved.outcome || typeof saved.outcome !== "object" || Array.isArray(saved.outcome))
+        throw new Error("automation_result_invalid");
+    const outcome = saved.outcome;
+    if (outcome.status !== "executed" && outcome.status !== "rejected" && outcome.status !== "uncertain")
+        throw new Error("automation_result_invalid");
+    let original = "rejected";
+    if (outcome.status === "uncertain")
+        original = "uncertain";
+    if (outcome.status === "executed")
+        original = outcome.result?.ok === true ? "succeeded" : "failed";
+    const effect = outcome.effect === "read_only" || outcome.effect === "mutating" || outcome.effect === "mixed"
+        ? outcome.effect : undefined;
+    let errorCode;
+    if (typeof outcome.result?.errorCode === "string")
+        errorCode = outcome.result.errorCode;
+    else if (typeof outcome.code === "string")
+        errorCode = outcome.code;
+    const lateEvidence = supplementalLateEvidence(attempt);
+    return { attemptId: attempt.id, nodeId: node.id, operation, outcome: originalOutcome(attempt, original),
+        ...(effect ? { effect } : {}),
+        ...completionActions(outcome.status === "executed" ? outcome.completionActions : []),
+        ...(errorCode ? { errorCode } : {}),
+        ...(lateEvidence ? { lateEvidence } : {}) };
+}
+async function readAttempt(input) {
+    const { state, results, node, attempt } = input;
+    if (!attempt.settlementRef) {
+        if (attempt.state === "settled")
+            throw new Error("automation_result_ref_invalid");
+        const lateEvidence = supplementalLateEvidence(attempt);
+        return { attemptId: attempt.id, nodeId: node.id,
+            ...(node.kind === "tool" ? { operation: node.operation } : {}),
+            outcome: attempt.state === "uncertain" ? "uncertain" : "pending",
+            actions: [], omittedActions: 0,
+            ...(lateEvidence ? { lateEvidence } : {}) };
+    }
+    const kind = node.kind === "tool" ? "node_output" : "effect_receipt";
+    const record = requireEffectResult(state, attempt, kind);
+    const value = await results.read(record);
+    if (node.kind === "tool")
+        return directToolEffect(node, attempt, value);
+    return agentEffect(node, attempt, value);
+}
+export async function readAutomationStepEffects(input) {
+    const attempts = input.state.attempts.filter((item) => item.runId === input.runId &&
+        item.nodeId === input.node.id);
+    return Promise.all(attempts.map((attempt) => readAttempt({
+        state: input.state, results: input.results, node: input.node, attempt,
+    })));
+}
+export async function readAutomationRunEffectSummary(input) {
+    const attempts = input.state.attempts.filter((item) => item.runId === input.runId);
+    const all = await Promise.all(attempts.map((attempt) => {
+        const node = findAutomationStep(input.definition.body, attempt.nodeId);
+        if (!node)
+            throw new Error("automation_node_not_found");
+        return readAttempt({ state: input.state, results: input.results, node, attempt });
+    }));
+    const entries = all.slice(0, MAX_REPORTED_EFFECTS);
+    return { total: attempts.length, omitted: attempts.length - entries.length,
+        verifiedExecutions: all.filter((item) => item.effect && (item.outcome === "succeeded" || item.outcome === "failed")).length,
+        unresolvedAttempts: all.filter((item) => item.outcome === "uncertain" || item.outcome === "pending").length,
+        entries };
+}
+/** Overlay late evidence without changing the original attempt outcome or saved receipt actions. */
+export function withCurrentLateEvidence(summary, attempts) {
+    const lateById = new Map(attempts.filter((item) => item.lateSettlement)
+        .map((item) => [item.id, supplementalLateEvidence(item)]));
+    return {
+        ...summary,
+        entries: summary.entries.map((entry) => {
+            const lateEvidence = lateById.get(entry.attemptId);
+            return lateEvidence ? { ...entry, lateEvidence } : entry;
+        }),
+    };
+}

package/dist/src/runtime/automations/step-evidence-inputs.d.ts

@@ -0,0 +1,22 @@
+import type { AutomationRevision } from "./definition-contracts.js";
+import type { AutomationResultStore } from "./result-store.js";
+import type { AutomationExecutionRecord, AutomationJournalState } from "./storage-records.js";
+import { type AutomationStepNode } from "./step-evidence-effects.js";
+export type AutomationStepInputEvidence = Readonly<{
+    name: string;
+    source: string;
+    status: "reconstructed" | "metadata" | "unavailable";
+    preview?: Readonly<{
+        value: string;
+        truncated: boolean;
+        totalCharacters: number;
+    }>;
+}>;
+export declare function readAutomationStepInputs(input: {
+    state: AutomationJournalState;
+    results: AutomationResultStore;
+    runId: string;
+    definition: AutomationRevision;
+    execution: AutomationExecutionRecord | undefined;
+    node: AutomationStepNode;
+}): Promise<AutomationStepInputEvidence[]>;

package/dist/src/runtime/automations/step-evidence-inputs.js

@@ -0,0 +1,105 @@
+import { resolveAutomationBinding } from "./binding-resolution.js";
+import { findAutomationStep } from "./step-evidence-effects.js";
+import { compileAutomationGraph } from "./graph-validation.js";
+import { projectAutomationBranchResults } from "./branch-result-projection.js";
+const INPUT_PREVIEW_CHARACTERS = 2_000;
+function preview(value) {
+    const serialized = typeof value === "string" ? value : JSON.stringify(value, null, 2);
+    return { value: serialized.slice(0, INPUT_PREVIEW_CHARACTERS),
+        truncated: serialized.length > INPUT_PREVIEW_CHARACTERS,
+        totalCharacters: serialized.length };
+}
+function sourceLabel(binding, definition) {
+    switch (binding.kind) {
+        case "literal": return "Configured value";
+        case "run_input": return `Run input · ${binding.input}`;
+        case "run_file": return `Run output file · ${binding.fileName}`;
+        case "source_files": return "Selected source files";
+        case "source_file": return `Selected file ${binding.index + 1} · ${binding.field.replaceAll("_", " ")}`;
+        case "node_result": {
+            const source = findAutomationStep(definition.body, binding.nodeId);
+            return `${source?.title || "Earlier step"} · ${binding.select}${binding.pointer || ""}`;
+        }
+        case "branch_results": return "Parallel branch results";
+    }
+}
+function bindingsFor(node) {
+    if (node.kind === "agent")
+        return Object.entries(node.inputs)
+            .map(([name, binding]) => [`Input · ${name}`, binding]);
+    return [
+        ...Object.entries(node.controls).map(([name, binding]) => [`Control · ${name}`, binding]),
+        ...(node.payload ? [["Payload", node.payload]] : []),
+    ];
+}
+function selectedInputMetadata(state, execution) {
+    return (execution?.inputIds ?? []).flatMap((id) => {
+        const record = state.inputs.find((item) => item.id === id &&
+            item.automationId === execution?.automationId);
+        if (!record)
+            return [];
+        return [{ originalPath: record.canonicalPath, version: record.contentVersion,
+                sizeBytes: record.snapshot?.sizeBytes ?? null }];
+    });
+}
+async function settledOutputs(input) {
+    const values = new Map();
+    for (const step of input.execution?.nodes ?? []) {
+        if (!input.neededIds.has(step.nodeId))
+            continue;
+        if (step.status === "pending" || step.status === "ready" || step.status === "running")
+            continue;
+        const record = input.state.results.find((item) => item.id === step.resultRef &&
+            item.runId === input.runId && item.nodeId === step.nodeId && item.kind === "node_output");
+        const saved = record ? await input.results.read(record) : null;
+        if (saved !== null && (typeof saved !== "object" || Array.isArray(saved)))
+            throw new Error("automation_result_invalid");
+        const value = saved;
+        values.set(step.nodeId, {
+            status: step.status,
+            ...(typeof value?.text === "string" ? { text: value.text } : {}),
+            ...(value?.data !== undefined ? { data: value.data } : {}),
+            ...(record ? { resultRef: record.id } : {}),
+        });
+    }
+    return values;
+}
+function sourceFileEvidence(binding, metadata) {
+    if (binding.kind === "source_files")
+        return { status: "metadata", preview: preview(metadata) };
+    const selected = metadata[binding.index];
+    if (!selected || binding.field === "snapshot_path")
+        return { status: "unavailable" };
+    return { status: "metadata", preview: preview(binding.field === "original_path"
+            ? selected.originalPath : selected.version) };
+}
+export async function readAutomationStepInputs(input) {
+    const bindings = bindingsFor(input.node);
+    if (bindings.length === 0)
+        return [];
+    const compiled = compileAutomationGraph(input.definition);
+    const groups = compiled.ok ? compiled.graph.parallelGroups : [];
+    const neededIds = new Set();
+    for (const [, binding] of bindings) {
+        if (binding.kind === "node_result")
+            neededIds.add(binding.nodeId);
+        if (binding.kind === "branch_results")
+            groups.find((group) => group.id === binding.parallelNodeId)?.tailNodeIds
+                .forEach((id) => neededIds.add(id));
+    }
+    const nodeResults = await settledOutputs({ ...input, neededIds });
+    const branchResults = projectAutomationBranchResults(groups, nodeResults);
+    const metadata = selectedInputMetadata(input.state, input.execution);
+    return bindings.map(([name, binding]) => {
+        const source = sourceLabel(binding, input.definition);
+        if (binding.kind === "source_file" || binding.kind === "source_files")
+            return { name, source, ...sourceFileEvidence(binding, metadata) };
+        const resolved = resolveAutomationBinding(binding, {
+            runId: input.runId, runInputs: input.definition.inputs,
+            sourceFiles: [], nodeResults, branchResults,
+        });
+        if (!resolved.ok)
+            return { name, source, status: "unavailable" };
+        return { name, source, status: "reconstructed", preview: preview(resolved.value) };
+    });
+}

package/dist/src/runtime/automations/step-evidence-output.d.ts

@@ -0,0 +1,17 @@
+export type AutomationOutputPart = Readonly<{
+    value: string;
+    truncated: boolean;
+    totalCharacters: number;
+}>;
+export type AutomationSavedOutput = Readonly<{
+    text?: AutomationOutputPart;
+    data?: AutomationOutputPart;
+    full: boolean;
+}>;
+export type AutomationSavedOutcome = Readonly<{
+    kind: "rejected" | "uncertain";
+    errorCode?: string;
+}>;
+/** Direct-tool rejections and uncertain results intentionally have no output text. */
+export declare function projectAutomationSavedOutput(value: unknown, full: boolean): AutomationSavedOutput | null;
+export declare function projectAutomationSavedOutcome(value: unknown): AutomationSavedOutcome | undefined;

package/dist/src/runtime/automations/step-evidence-output.js

@@ -0,0 +1,43 @@
+const OUTPUT_PREVIEW_CHARACTERS = 4_000;
+function projectPart(value, full) {
+    return {
+        value: full ? value : value.slice(0, OUTPUT_PREVIEW_CHARACTERS),
+        truncated: !full && value.length > OUTPUT_PREVIEW_CHARACTERS,
+        totalCharacters: value.length,
+    };
+}
+/** Direct-tool rejections and uncertain results intentionally have no output text. */
+export function projectAutomationSavedOutput(value, full) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("automation_result_invalid");
+    const saved = value;
+    if (saved.text === undefined && saved.data === undefined)
+        return null;
+    if (saved.text !== undefined && typeof saved.text !== "string")
+        throw new Error("automation_result_invalid");
+    let structured;
+    if (saved.data !== undefined) {
+        try {
+            structured = JSON.stringify(saved.data, null, 2);
+        }
+        catch {
+            throw new Error("automation_result_invalid");
+        }
+        if (typeof structured !== "string")
+            throw new Error("automation_result_invalid");
+    }
+    return {
+        ...(typeof saved.text === "string" ? { text: projectPart(saved.text, full) } : {}),
+        ...(structured !== undefined ? { data: projectPart(structured, full) } : {}),
+        full,
+    };
+}
+export function projectAutomationSavedOutcome(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const saved = value;
+    if (saved.kind !== "rejected" && saved.kind !== "uncertain")
+        return undefined;
+    return { kind: saved.kind,
+        ...(typeof saved.code === "string" ? { errorCode: saved.code } : {}) };
+}

package/dist/src/runtime/automations/step-evidence.d.ts

@@ -0,0 +1,24 @@
+import type { SchedulerService } from "../scheduler/contracts.js";
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationResultStore } from "./result-store.js";
+import { type AutomationEffectEvidence } from "./step-evidence-effects.js";
+import { type AutomationSavedOutcome, type AutomationSavedOutput } from "./step-evidence-output.js";
+import { type AutomationStepInputEvidence } from "./step-evidence-inputs.js";
+export type AutomationStepEvidence = Readonly<{
+    runId: string;
+    nodeId: string;
+    title: string;
+    availability: "available" | "expired";
+    stepStatus: string;
+    output: AutomationSavedOutput | null;
+    savedOutcome?: AutomationSavedOutcome;
+    inputs: readonly AutomationStepInputEvidence[];
+    effects: readonly AutomationEffectEvidence[];
+}>;
+export declare function createAutomationStepEvidenceReader(options: {
+    scheduler: Pick<SchedulerService, "getAutomationRun">;
+    persistence: AutomationPersistence;
+    results: AutomationResultStore;
+}): {
+    get: (runId: string, nodeId: string, full?: boolean) => Promise<AutomationStepEvidence>;
+};

package/dist/src/runtime/automations/step-evidence.js

@@ -0,0 +1,53 @@
+import { findAutomationStep, readAutomationStepEffects, } from "./step-evidence-effects.js";
+import { projectAutomationSavedOutcome, projectAutomationSavedOutput, } from "./step-evidence-output.js";
+import { readAutomationStepInputs } from "./step-evidence-inputs.js";
+function requireOutput(state, runId, nodeId, resultId) {
+    const record = state.results.find((item) => item.id === resultId && item.runId === runId &&
+        item.nodeId === nodeId && item.kind === "node_output");
+    if (!record)
+        throw new Error("automation_result_ref_invalid");
+    return record;
+}
+export function createAutomationStepEvidenceReader(options) {
+    async function get(runId, nodeId, full = false) {
+        const run = await options.scheduler.getAutomationRun(runId);
+        if (!run)
+            throw new Error("automation_run_not_found");
+        const state = await options.persistence.read();
+        const definition = state.definitions.find((item) => item.automationId === run.target.automationId &&
+            item.revision === run.target.definitionRevision)?.definition;
+        if (!definition)
+            throw new Error("automation_definition_not_found");
+        const node = findAutomationStep(definition.body, nodeId);
+        if (!node)
+            throw new Error("automation_node_not_found");
+        const execution = state.executions.find((item) => item.id === runId &&
+            item.automationId === run.target.automationId &&
+            item.definitionRevision === run.target.definitionRevision);
+        const step = execution?.nodes.find((item) => item.nodeId === nodeId);
+        const base = { runId, nodeId, title: node.title, stepStatus: step?.status ?? "pending" };
+        if (execution?.detailsExpiredAt)
+            return { ...base, availability: "expired", output: null, inputs: [], effects: [] };
+        try {
+            const saved = step?.resultRef
+                ? await options.results.read(requireOutput(state, runId, nodeId, step.resultRef)) : null;
+            const output = saved === null ? null : projectAutomationSavedOutput(saved, full);
+            const savedOutcome = node.kind === "tool" ? projectAutomationSavedOutcome(saved) : undefined;
+            const [effects, inputs] = await Promise.all([
+                readAutomationStepEffects({ state, results: options.results, runId, node }),
+                readAutomationStepInputs({ state, results: options.results, runId, definition, execution,
+                    node }),
+            ]);
+            return { ...base, availability: "available", output, inputs, effects,
+                ...(savedOutcome ? { savedOutcome } : {}) };
+        }
+        catch (error) {
+            // Retention marks expiry before deleting the corresponding bytes.
+            const latest = await options.persistence.read();
+            if (latest.executions.some((item) => item.id === runId && item.detailsExpiredAt))
+                return { ...base, availability: "expired", output: null, inputs: [], effects: [] };
+            throw error;
+        }
+    }
+    return { get };
+}

package/dist/src/runtime/automations/step-interruption.d.ts

@@ -0,0 +1,3 @@
+import type { AutomationStepCompletion } from "./graph-executor.js";
+/** Normalize definite abort receipts before their durable node settlement. */
+export declare function normalizeAutomationStepInterruption(completion: AutomationStepCompletion, signal: AbortSignal): AutomationStepCompletion;

package/dist/src/runtime/automations/step-interruption.js

@@ -0,0 +1,26 @@
+/** Normalize definite abort receipts before their durable node settlement. */
+export function normalizeAutomationStepInterruption(completion, signal) {
+    if (completion.uncertain)
+        return completion;
+    if (!signal.aborted)
+        return completion;
+    const durationFailureCode = automationDurationFailureCode(signal.reason);
+    if (durationFailureCode && completion.status === "cancelled")
+        return { status: "failed", errorCode: durationFailureCode };
+    if (durationFailureCode)
+        return completion;
+    if (completion.status !== "failed" && completion.status !== "skipped")
+        return completion;
+    if (completion.errorCode !== "request_aborted")
+        return completion;
+    return { status: "cancelled", errorCode: "automation_run_stopped" };
+}
+function automationDurationFailureCode(reason) {
+    if (!(reason instanceof Error))
+        return undefined;
+    if (reason.message === "automation_run_duration_exceeded")
+        return reason.message;
+    if (reason.message === "automation_budget_exhausted")
+        return reason.message;
+    return undefined;
+}