@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/automations/storage-records.js

@@ -0,0 +1,286 @@
+export const AUTOMATION_COLLECTIONS = Object.freeze([
+    "drafts",
+    "definitions",
+    "savedAgents",
+    "grants",
+    "inputs",
+    "executions",
+    "attempts",
+    "results",
+]);
+export function emptyAutomationJournalState() {
+    return {
+        schemaVersion: 1,
+        drafts: [],
+        definitions: [],
+        savedAgents: [],
+        grants: [],
+        inputs: [],
+        executions: [],
+        attempts: [],
+        results: [],
+    };
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isIdentifier(value) {
+    return typeof value === "string" && value.length > 0 && value.length <= 512;
+}
+function isCanonicalPath(value) {
+    return typeof value === "string" && value.length > 0 &&
+        value.length <= 4_096 && !value.includes("\0");
+}
+function hasValidBaselineExclusions(value) {
+    const excluded = value.excludedInputIds;
+    if (excluded === undefined)
+        return true;
+    if (value.baselineMarker !== true)
+        return false;
+    if (!Array.isArray(excluded))
+        return false;
+    if (!excluded.every(isIdentifier))
+        return false;
+    return new Set(excluded).size === excluded.length;
+}
+function isPositiveInteger(value) {
+    return Number.isSafeInteger(value) && Number(value) > 0;
+}
+function isNonnegativeInteger(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0;
+}
+function isOptionalNonnegativeNumber(value) {
+    return value === undefined ||
+        (typeof value === "number" && Number.isFinite(value) && value >= 0);
+}
+function isInstant(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function isOptionalIdentifier(value) {
+    return value === undefined || isIdentifier(value);
+}
+function isOptionalInstant(value) {
+    return value === undefined || isInstant(value);
+}
+function isOperationRef(value) {
+    if (!isRecord(value))
+        return false;
+    if (!isIdentifier(value.toolName) || !isIdentifier(value.operationId))
+        return false;
+    return isPositiveInteger(value.contractVersion);
+}
+function isAttachmentReference(value) {
+    if (!isRecord(value))
+        return false;
+    if (!isIdentifier(value.id) || !isIdentifier(value.storageRef))
+        return false;
+    if (!isIdentifier(value.mimeType))
+        return false;
+    if (value.kind !== "file" && value.kind !== "image")
+        return false;
+    if (value.name !== undefined && typeof value.name !== "string")
+        return false;
+    return value.size === undefined || isNonnegativeInteger(value.size);
+}
+function isNodeState(value) {
+    if (!isRecord(value) || !isIdentifier(value.nodeId))
+        return false;
+    if (![
+        "pending",
+        "ready",
+        "running",
+        "succeeded",
+        "skipped",
+        "failed",
+        "cancelled",
+        "interrupted",
+    ].includes(String(value.status)))
+        return false;
+    return (isOptionalIdentifier(value.attemptId) &&
+        isOptionalIdentifier(value.resultRef) &&
+        isOptionalIdentifier(value.errorCode));
+}
+function hasValidRecordEnvelope(value) {
+    return isRecord(value) && isIdentifier(value.id);
+}
+export function parseAutomationStoredRecord(collection, value) {
+    if (!hasValidRecordEnvelope(value))
+        throw new Error("scheduler_store_corrupt");
+    switch (collection) {
+        case "drafts":
+        case "definitions": {
+            const definition = value.definition;
+            if (!isIdentifier(value.automationId) ||
+                !isPositiveInteger(value.revision))
+                break;
+            if (!isRecord(definition) || definition.schemaVersion !== 1)
+                break;
+            if (definition.automationId !== value.automationId)
+                break;
+            if (definition.revision !== value.revision)
+                break;
+            const timestamp = collection === "drafts" ? value.updatedAt : value.publishedAt;
+            if (!isInstant(timestamp))
+                break;
+            if (collection === "drafts") {
+                if (!isOptionalInstant(value.archivedAt))
+                    break;
+                if (value.storageRevision !== undefined &&
+                    (!isPositiveInteger(value.storageRevision) || value.storageRevision < value.revision))
+                    break;
+            }
+            if (collection === "definitions" && value.dependencyFingerprint !== undefined &&
+                !isIdentifier(value.dependencyFingerprint))
+                break;
+            return value;
+        }
+        case "savedAgents":
+            if (!isIdentifier(value.agentId) || !isPositiveInteger(value.revision))
+                break;
+            if (!isRecord(value.agent) || value.agent.kind !== "agent")
+                break;
+            if (!isInstant(value.updatedAt))
+                break;
+            return value;
+        case "grants": {
+            if (!isIdentifier(value.automationId) ||
+                !isIdentifier(value.environmentId))
+                break;
+            if (!isPositiveInteger(value.grantRevision))
+                break;
+            if (value.mode !== "full_access" && value.mode !== "full_plus")
+                break;
+            if (!Array.isArray(value.operations) ||
+                !value.operations.every(isOperationRef))
+                break;
+            if (!isRecord(value.evidence) ||
+                value.evidence.kind !== "authenticated_user_action")
+                break;
+            if (!isIdentifier(value.evidence.actionId) ||
+                !isInstant(value.evidence.at))
+                break;
+            return value;
+        }
+        case "inputs": {
+            if (!isIdentifier(value.automationId) || !isIdentifier(value.sourceId))
+                break;
+            if (!isCanonicalPath(value.canonicalPath) ||
+                !isIdentifier(value.contentVersion))
+                break;
+            if (!isInstant(value.observedAt))
+                break;
+            if (!isOptionalNonnegativeNumber(value.observedSizeBytes) ||
+                !isOptionalNonnegativeNumber(value.observedMtimeMs) ||
+                !isOptionalNonnegativeNumber(value.observedCtimeMs))
+                break;
+            if (!["baseline", "eligible", "held"].includes(String(value.eligibility)))
+                break;
+            if (value.baselineMarker !== undefined && value.baselineMarker !== true)
+                break;
+            if (value.baselineMarker && value.eligibility !== "baseline")
+                break;
+            if (!hasValidBaselineExclusions(value))
+                break;
+            if (value.eligibility === "baseline") {
+                if (value.snapshot !== undefined || value.claimRunId !== undefined ||
+                    value.outcomeRef !== undefined)
+                    break;
+            }
+            else {
+                if (value.snapshot === undefined) {
+                    // Keep consumed-version dedup metadata after runtime-owned bytes expire.
+                    if (!isIdentifier(value.claimRunId) || !isIdentifier(value.outcomeRef))
+                        break;
+                }
+                else {
+                    if (!isRecord(value.snapshot))
+                        break;
+                    if (!isAttachmentReference(value.snapshot.attachment))
+                        break;
+                    if (value.snapshot.contentVersion !== value.contentVersion)
+                        break;
+                    if (!isNonnegativeInteger(value.snapshot.sizeBytes))
+                        break;
+                }
+            }
+            if (!isOptionalIdentifier(value.claimRunId) ||
+                !isOptionalIdentifier(value.outcomeRef) ||
+                !isOptionalInstant(value.snapshotRetiredAt) ||
+                (value.snapshotRetiredAt !== undefined && value.snapshot === undefined))
+                break;
+            return value;
+        }
+        case "executions":
+            if (!isIdentifier(value.automationId) ||
+                !isPositiveInteger(value.definitionRevision))
+                break;
+            if (!isPositiveInteger(value.revision))
+                break;
+            if (!Array.isArray(value.inputIds) || !value.inputIds.every(isIdentifier))
+                break;
+            if (!Array.isArray(value.nodes) || !value.nodes.every(isNodeState))
+                break;
+            if (value.modelCalls !== undefined && !isNonnegativeInteger(value.modelCalls))
+                break;
+            if (!isOptionalInstant(value.stopRequestedAt) ||
+                !isOptionalIdentifier(value.reportRef) ||
+                !isOptionalInstant(value.terminalAt) ||
+                !isOptionalInstant(value.detailsExpiredAt) ||
+                !isOptionalInstant(value.reportExpiredAt))
+                break;
+            return value;
+        case "attempts":
+            if (!isIdentifier(value.runId) || !isIdentifier(value.nodeId))
+                break;
+            if (!isIdentifier(value.invocationId) || !isIdentifier(value.fingerprint))
+                break;
+            if (!["started", "settled", "uncertain"].includes(String(value.state)))
+                break;
+            if (!isInstant(value.startedAt) || !isOptionalInstant(value.settledAt))
+                break;
+            if (!isOptionalIdentifier(value.settlementRef))
+                break;
+            if (value.lateSettlement !== undefined) {
+                if (!isRecord(value.lateSettlement) || value.state !== "uncertain")
+                    break;
+                if (!isPositiveInteger(value.lateSettlement.revision) ||
+                    !isInstant(value.lateSettlement.observedAt))
+                    break;
+                if (!["succeeded", "failed", "rejected"].includes(String(value.lateSettlement.status)))
+                    break;
+                if (!isOptionalIdentifier(value.lateSettlement.errorCode))
+                    break;
+            }
+            return value;
+        case "results":
+            if (!isIdentifier(value.runId) || !isOptionalIdentifier(value.nodeId))
+                break;
+            if (!["node_output", "effect_receipt", "report", "artifact"].includes(String(value.kind)))
+                break;
+            if (!isIdentifier(value.storageRef) || !isIdentifier(value.digest))
+                break;
+            if (!isNonnegativeInteger(value.sizeBytes) || !isInstant(value.createdAt))
+                break;
+            return value;
+    }
+    throw new Error("scheduler_store_corrupt");
+}
+export function parseAutomationJournalState(value) {
+    if (!isRecord(value) || value.schemaVersion !== 1)
+        throw new Error("scheduler_store_corrupt");
+    const state = emptyAutomationJournalState();
+    for (const collection of AUTOMATION_COLLECTIONS) {
+        const records = value[collection];
+        if (!Array.isArray(records))
+            throw new Error("scheduler_store_corrupt");
+        const ids = new Set();
+        for (const record of records) {
+            const parsed = parseAutomationStoredRecord(collection, record);
+            if (ids.has(parsed.id))
+                throw new Error("scheduler_store_corrupt");
+            ids.add(parsed.id);
+            state[collection].push(parsed);
+        }
+    }
+    return state;
+}

package/dist/src/runtime/automations/terminal-admission-receipt.d.ts

@@ -0,0 +1,12 @@
+import type { AutomationExecutionRecord, AutomationJournalState, AutomationResultRecord } from "./storage-records.js";
+/** A deadline can interrupt admission before its definite no-dispatch receipt returns. */
+export declare function settleTerminalUndispatchedAdmission(input: {
+    state: AutomationJournalState;
+    execution: AutomationExecutionRecord;
+    nodeId: string;
+    invocationId: string | undefined;
+    result: AutomationResultRecord | undefined;
+    resultKind: "node_output" | "effect_receipt";
+    maxStoredArtifactBytes: number | undefined;
+    now: number;
+}): void;

package/dist/src/runtime/automations/terminal-admission-receipt.js

@@ -0,0 +1,39 @@
+import { requireAutomationResultCapacity } from "./result-capacity.js";
+/** A deadline can interrupt admission before its definite no-dispatch receipt returns. */
+export function settleTerminalUndispatchedAdmission(input) {
+    const { state, execution, result } = input;
+    const node = execution.nodes.find((item) => item.nodeId === input.nodeId);
+    const hasInterruptedAdmission = Boolean(execution.reportRef) && node?.status === "interrupted";
+    if (!hasInterruptedAdmission)
+        throw new Error("automation_run_locked");
+    const hasDirectAttemptMismatch = input.resultKind === "node_output" &&
+        node?.attemptId !== input.invocationId;
+    if (hasDirectAttemptMismatch)
+        throw new Error("automation_attempt_mismatch");
+    const attemptIndex = state.attempts.findIndex((item) => item.runId === execution.id &&
+        item.nodeId === input.nodeId && item.invocationId === input.invocationId);
+    const attempt = state.attempts[attemptIndex];
+    if (!attempt)
+        throw new Error("automation_attempt_mismatch");
+    if (attempt.state === "settled")
+        throw new Error("automation_attempt_mismatch");
+    if (attempt.lateSettlement)
+        throw new Error("automation_attempt_mismatch");
+    const hasBoundReceipt = result?.runId === execution.id && result.nodeId === input.nodeId &&
+        result.kind === input.resultKind;
+    if (!hasBoundReceipt)
+        throw new Error("automation_result_ref_invalid");
+    const usedBytes = state.results.filter((item) => item.runId === execution.id)
+        .reduce((total, item) => total + item.sizeBytes, result.sizeBytes);
+    const exceedsRunArtifactBudget = input.maxStoredArtifactBytes !== undefined &&
+        usedBytes > input.maxStoredArtifactBytes;
+    if (exceedsRunArtifactBudget)
+        throw new Error("automation_artifact_budget_exhausted");
+    requireAutomationResultCapacity(state, result.sizeBytes);
+    state.results.push(result);
+    state.attempts[attemptIndex] = { ...attempt, state: "settled",
+        settledAt: new Date(input.now).toISOString(), settlementRef: result.id };
+    // Preserve the historical terminal node/report; only its attempt evidence advances.
+    const executionIndex = state.executions.findIndex((item) => item.id === execution.id);
+    state.executions[executionIndex] = { ...execution, revision: execution.revision + 1 };
+}

package/dist/src/runtime/automations/tool-lifetimes.d.ts

@@ -0,0 +1,13 @@
+import type { ToolUnderlyingSettlement } from "../../capabilities/tool-types.js";
+export type AutomationObservedToolSettlement = Readonly<{
+    invocationId: string;
+    settlement: ToolUnderlyingSettlement;
+}>;
+export type AutomationToolLifetimes = Readonly<{
+    holdEffectAdmission(runId: string, signal: AbortSignal): () => void;
+    runInvocation<T>(runId: string, signal: AbortSignal, invoke: () => Promise<T>): Promise<T>;
+    observe(runId: string, invocationId: string, settled: Promise<ToolUnderlyingSettlement>): void;
+    whenSettled(runId: string): Promise<readonly AutomationObservedToolSettlement[]>;
+}>;
+/** Retains durable admissions and actual Tool promises beyond an abort-raced result. */
+export declare function createAutomationToolLifetimes(): AutomationToolLifetimes;

package/dist/src/runtime/automations/tool-lifetimes.js

@@ -0,0 +1,56 @@
+/** Retains durable admissions and actual Tool promises beyond an abort-raced result. */
+export function createAutomationToolLifetimes() {
+    const pending = new Map();
+    const observed = new Map();
+    function trackPending(runId, tracked) {
+        const held = pending.get(runId) ?? new Set();
+        held.add(tracked);
+        pending.set(runId, held);
+        void tracked.then(() => {
+            held.delete(tracked);
+            if (held.size === 0 && pending.get(runId) === held)
+                pending.delete(runId);
+        });
+    }
+    return {
+        holdEffectAdmission(runId, signal) {
+            signal.throwIfAborted();
+            let release;
+            const receipt = new Promise((resolve) => { release = resolve; });
+            // Register before durable admission can await; terminal draining must also
+            // retain an admitted operation that was cancelled before Tool dispatch.
+            trackPending(runId, receipt);
+            return release;
+        },
+        async runInvocation(runId, signal, invoke) {
+            // No await between the fence, dispatch, and registration: draining cannot
+            // miss a Tool that was admitted before a terminal deadline.
+            signal.throwIfAborted();
+            const result = invoke();
+            trackPending(runId, result.then(() => undefined, () => undefined));
+            return result;
+        },
+        observe(runId, invocationId, settled) {
+            const tracked = settled.then((settlement) => {
+                const records = observed.get(runId) ?? [];
+                records.push({ invocationId, settlement });
+                observed.set(runId, records);
+            }, () => {
+                const records = observed.get(runId) ?? [];
+                records.push({ invocationId, settlement: {
+                        status: "rejected", errorCode: "tool_execution_failed",
+                    } });
+                observed.set(runId, records);
+            });
+            trackPending(runId, tracked);
+        },
+        async whenSettled(runId) {
+            while (pending.get(runId)?.size) {
+                await Promise.all(pending.get(runId));
+            }
+            const records = observed.get(runId) ?? [];
+            observed.delete(runId);
+            return records;
+        },
+    };
+}

package/dist/src/runtime/automations/tool-step-executor.d.ts

@@ -0,0 +1,32 @@
+import type { ToolRequestAttachment, ToolUnderlyingSettlement } from "../../capabilities/tool-types.js";
+import type { ToolRegistry } from "../ports.js";
+import type { ToolNode } from "./definition-contracts.js";
+import type { AutomationGrantRecord } from "./storage-records.js";
+import { type AutomationToolStepOutcome } from "./tool-step-outcome.js";
+export type { AutomationToolStepOutcome } from "./tool-step-outcome.js";
+/** One normal-invocation operation; attempts and receipts are durable callbacks. */
+export declare function executeAutomationToolStep(input: {
+    node: ToolNode;
+    controls: Readonly<Record<string, unknown>>;
+    sourceAttachments?: readonly ToolRequestAttachment[];
+    payload?: string;
+    registry: ToolRegistry;
+    environmentId: string;
+    automationId: string;
+    capturedGrant: AutomationGrantRecord;
+    currentGrant(): Promise<AutomationGrantRecord | null>;
+    workingDirectory?: string;
+    requestId: string;
+    abortSignal: AbortSignal;
+    onUnderlyingSettlement?: (invocationId: string, settled: Promise<ToolUnderlyingSettlement>) => void;
+    invokeTool?: <T>(invoke: () => Promise<T>) => Promise<T>;
+    holdEffectAdmission?: () => () => void;
+    beforeEffect(attempt: Readonly<{
+        invocationId: string;
+        fingerprint: string;
+    }>): Promise<void>;
+    afterEffect(attempt: Readonly<{
+        invocationId: string;
+        fingerprint: string;
+    }>, outcome: AutomationToolStepOutcome, notDispatched: boolean): Promise<void>;
+}): Promise<AutomationToolStepOutcome>;

package/dist/src/runtime/automations/tool-step-executor.js

@@ -0,0 +1,136 @@
+import { randomUUID } from "node:crypto";
+import { createRegisteredToolNormalInvocationExecutor } from "../adapters/registered-tool-normal-invocations/executor.js";
+import { bindRequestToolRegistry } from "../capabilities/request-bound-tool-registry.js";
+import { restrictToolRegistryToRequestMode } from "../capabilities/request-permission-tool-registry.js";
+import { permitsAutomationOperation, sameOperation } from "./permission-grants.js";
+import { classifyAutomationToolDispatchFailure, projectAutomationToolStepOutcome, } from "./tool-step-outcome.js";
+function selectedRegistration(registrations, selected) {
+    const owner = registrations.find((registration) => registration.toolName === selected.toolName &&
+        registration.contract.version === selected.contractVersion &&
+        registration.contract.operations.some((operation) => operation.operationId === selected.operationId));
+    if (!owner)
+        return null;
+    const operation = owner.contract.operations.find((item) => item.operationId === selected.operationId);
+    return { ...owner, contract: { ...owner.contract, operations: [operation] } };
+}
+function rejectsModelContext() {
+    let requested = false;
+    return {
+        modelInvoker: {
+            async invokeText() {
+                requested = true;
+                throw new Error("automation_tool_model_context_missing");
+            },
+        },
+        wasRequested: () => requested,
+    };
+}
+function permittedByLatestGrant(latest, captured, environmentId, automationId, operation, requiredMode) {
+    if (!latest || latest.grantRevision !== captured.grantRevision)
+        return false;
+    return permitsAutomationOperation(latest, environmentId, automationId, operation, requiredMode);
+}
+/** One normal-invocation operation; attempts and receipts are durable callbacks. */
+export async function executeAutomationToolStep(input) {
+    const requested = input.node.operation;
+    if (!permitsAutomationOperation(input.capturedGrant, input.environmentId, input.automationId, requested, input.capturedGrant.mode))
+        return { kind: "rejected", code: "automation_operation_unavailable", message: "This operation is not granted to the automation." };
+    const preparedRegistry = await input.registry.prepareRequest?.() ?? input.registry;
+    const available = restrictToolRegistryToRequestMode(preparedRegistry, input.capturedGrant.mode);
+    const registered = selectedRegistration(available.listNormalInvocations?.() ?? [], requested);
+    if (!registered)
+        return { kind: "rejected", code: "automation_operation_unavailable", message: "The operation is no longer configured." };
+    const requiredMode = registered.definition.requiredPermissionMode ?? "full_access";
+    if (!permittedByLatestGrant(await input.currentGrant(), input.capturedGrant, input.environmentId, input.automationId, requested, requiredMode))
+        return { kind: "rejected", code: "automation_operation_unavailable", message: "The automation permission changed." };
+    const noModel = rejectsModelContext();
+    let activeInvocationId;
+    let dispatched = false;
+    const observedRegistry = {
+        ...available,
+        execute: (call, options) => {
+            const invoke = () => {
+                dispatched = true;
+                return available.execute(call, {
+                    ...options,
+                    onUnderlyingSettlement: (settled) => {
+                        if (activeInvocationId)
+                            input.onUnderlyingSettlement?.(activeInvocationId, settled);
+                    },
+                });
+            };
+            if (input.invokeTool)
+                return input.invokeTool(invoke);
+            input.abortSignal.throwIfAborted();
+            return invoke();
+        },
+    };
+    const boundRegistry = bindRequestToolRegistry({
+        registry: observedRegistry,
+        modelInvoker: noModel.modelInvoker,
+        ...(input.sourceAttachments?.length ? { requestAttachments: input.sourceAttachments } : {}),
+        ...(input.workingDirectory ? { requestWorkingDirectory: input.workingDirectory } : {}),
+    });
+    const executor = createRegisteredToolNormalInvocationExecutor({
+        registrations: [registered],
+        toolRegistry: boundRegistry,
+        requestId: input.requestId,
+        abortSignal: input.abortSignal,
+        toolPermissionMode: input.capturedGrant.mode,
+        nextApprovalId: randomUUID,
+        sharedState: boundRegistry.prepareSharedState?.(),
+    });
+    const selected = executor.operations.find((candidate) => sameOperation(requested, {
+        toolName: registered.toolName,
+        operationId: candidate.operation.operationId,
+        contractVersion: registered.contract.version,
+    }));
+    if (!selected)
+        return { kind: "rejected", code: "automation_operation_unavailable", message: "The selected operation could not be bound." };
+    const prepared = executor.prepare({
+        handle: selected.handle,
+        controls: input.controls,
+        ...(input.payload !== undefined ? { payload: input.payload } : {}),
+    });
+    if (prepared.status === "rejected")
+        return { kind: "rejected", code: prepared.code, message: prepared.message };
+    if (prepared.approvalRequest)
+        return { kind: "rejected", code: "automation_approval_required", message: "This operation needs an interactive approval." };
+    const attempt = { invocationId: randomUUID(), fingerprint: prepared.actionFingerprint };
+    const releaseAdmission = input.holdEffectAdmission?.();
+    try {
+        await input.beforeEffect(attempt);
+        const latestGrant = await input.currentGrant();
+        if (input.abortSignal.aborted) {
+            const rejected = {
+                kind: "rejected", code: "request_aborted",
+                message: "The operation was stopped before it began.",
+            };
+            await input.afterEffect(attempt, rejected, true);
+            return rejected;
+        }
+        if (!permittedByLatestGrant(latestGrant, input.capturedGrant, input.environmentId, input.automationId, requested, requiredMode)) {
+            const rejected = {
+                kind: "rejected", code: "automation_operation_unavailable",
+                message: "The operation was stopped before it began.",
+            };
+            await input.afterEffect(attempt, rejected, true);
+            return rejected;
+        }
+        let outcome;
+        try {
+            activeInvocationId = attempt.invocationId;
+            const settled = await prepared.execute(attempt.invocationId);
+            outcome = projectAutomationToolStepOutcome(settled, selected.operation.effect, noModel.wasRequested());
+        }
+        catch (error) {
+            outcome = classifyAutomationToolDispatchFailure(error, input.abortSignal, selected.operation.effect, dispatched);
+        }
+        const wasRejectedBeforeDispatch = !dispatched && outcome.kind === "rejected";
+        await input.afterEffect(attempt, outcome, wasRejectedBeforeDispatch);
+        return outcome;
+    }
+    finally {
+        releaseAdmission?.();
+    }
+}

package/dist/src/runtime/automations/tool-step-outcome.d.ts

@@ -0,0 +1,24 @@
+import type { ToolExecutionResult, ToolNormalInvocationEffect } from "../../capabilities/tool-types.js";
+import type { RegisteredToolNormalInvocationResult } from "../adapters/registered-tool-normal-invocations/shared/contracts.js";
+export type AutomationToolStepOutcome = Readonly<{
+    kind: "settled";
+    ok: boolean;
+    effect: ToolNormalInvocationEffect;
+    result: ToolExecutionResult;
+    completionActions: readonly {
+        type: string;
+        target?: string;
+        details?: string;
+    }[];
+    errorCode?: string;
+}> | Readonly<{
+    kind: "rejected";
+    code: string;
+    message: string;
+}> | Readonly<{
+    kind: "uncertain";
+    code: string;
+    message: string;
+}>;
+export declare function classifyAutomationToolDispatchFailure(error: unknown, signal: AbortSignal, effect: ToolNormalInvocationEffect, dispatched: boolean): AutomationToolStepOutcome;
+export declare function projectAutomationToolStepOutcome(settled: RegisteredToolNormalInvocationResult, effect: ToolNormalInvocationEffect, modelContextMissing: boolean): AutomationToolStepOutcome;

package/dist/src/runtime/automations/tool-step-outcome.js

@@ -0,0 +1,32 @@
+import { hasToolAbortReceipt } from "../../capabilities/tool-interruption.js";
+export function classifyAutomationToolDispatchFailure(error, signal, effect, dispatched) {
+    const abortedByRun = signal.aborted && error === signal.reason;
+    const uncertainEffect = dispatched && effect !== "read_only";
+    const hasDefiniteAbort = abortedByRun && !uncertainEffect;
+    if (hasDefiniteAbort)
+        return { kind: "rejected", code: "request_aborted", message: String(error) };
+    const mayHaveMutated = effect !== "read_only";
+    if (mayHaveMutated)
+        return { kind: "uncertain", code: "automation_effect_uncertain", message: String(error) };
+    return { kind: "rejected", code: "automation_tool_failed", message: String(error) };
+}
+export function projectAutomationToolStepOutcome(settled, effect, modelContextMissing) {
+    const isAbortedMutatingRejection = settled.status === "rejected" &&
+        settled.code === "request_aborted" && effect !== "read_only";
+    if (isAbortedMutatingRejection)
+        return { kind: "uncertain", code: "automation_effect_uncertain", message: settled.message };
+    if (settled.status === "rejected")
+        return { kind: "rejected", code: settled.code, message: settled.message };
+    const isAbortedMutatingExecution = hasToolAbortReceipt(settled.result) &&
+        effect !== "read_only";
+    if (isAbortedMutatingExecution)
+        return { kind: "uncertain", code: "automation_effect_uncertain", message: settled.result.output };
+    return {
+        kind: "settled",
+        ok: settled.result.ok && !modelContextMissing,
+        effect: settled.effect,
+        result: settled.result,
+        completionActions: settled.completionActions,
+        ...(modelContextMissing ? { errorCode: "automation_tool_model_context_missing" } : {}),
+    };
+}

package/dist/src/runtime/automations/trigger-schedule.d.ts

@@ -0,0 +1,7 @@
+import type { SchedulerAutomationJob, SchedulerAutomationScheduleInput } from "../scheduler/contracts.js";
+import type { AutomationScheduleTiming } from "../scheduler/automation-schedule.js";
+import type { AutomationTrigger } from "./definition-contracts.js";
+import type { AutomationJournalState } from "./storage-records.js";
+export declare function automationTriggerSchedule(trigger: AutomationTrigger): SchedulerAutomationScheduleInput;
+/** Only the exact retained publication can identify unchanged authored relative timing. */
+export declare function publishedAutomationScheduleTiming(state: AutomationJournalState, job: SchedulerAutomationJob | null | undefined, trigger: AutomationTrigger | undefined): AutomationScheduleTiming | undefined;

package/dist/src/runtime/automations/trigger-schedule.js

@@ -0,0 +1,19 @@
+export function automationTriggerSchedule(trigger) {
+    switch (trigger.kind) {
+        case "manual": return { kind: "manual" };
+        case "schedule": return trigger.schedule;
+        case "folder": return { kind: "interval", everyMs: trigger.checkEveryMs };
+    }
+}
+/** Only the exact retained publication can identify unchanged authored relative timing. */
+export function publishedAutomationScheduleTiming(state, job, trigger) {
+    if (!job)
+        return undefined;
+    const timing = { schedule: job.schedule, timeZone: job.timeZone };
+    const published = state.definitions.find((record) => record.automationId === job.target.automationId && record.revision === job.target.definitionRevision);
+    if (!published || !trigger)
+        return timing;
+    if (published.definition.trigger.kind !== trigger.kind)
+        return timing;
+    return { ...timing, authoredSchedule: automationTriggerSchedule(published.definition.trigger) };
+}