@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/automations/graph-validation.js

@@ -0,0 +1,271 @@
+import { TOOL_NORMAL_INVOCATION_VERSION } from "../../capabilities/normal-invocation/contracts.js";
+import { parseToolNormalInvocationContract } from "../../capabilities/normal-invocation/validator.js";
+import { AUTOMATION_GRAPH_LIMITS, AUTOMATION_OUTPUT_SCHEMA_LIMITS, validateAutomationLimits } from "./limits.js";
+import { isAutomationRunFileName } from "./run-file-binding.js";
+const NODE_ID = /^[A-Za-z][A-Za-z0-9._-]{0,63}$/u;
+const OPERATION_ID = /^[\p{L}\p{N}][\p{L}\p{N}._:-]{0,63}$/u;
+const FORBIDDEN_POINTER_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+function issue(walk, code, path, message) {
+    walk.issues.push({ code, path, message });
+}
+function isValidNodeIdentity(walk, node, path) {
+    if (!NODE_ID.test(node.id)) {
+        issue(walk, "automation_node_id_invalid", path, "Node ID must be a bounded stable identifier.");
+        return false;
+    }
+    if (walk.seenIds.has(node.id)) {
+        issue(walk, "automation_node_id_duplicate", path, `Node ID ${node.id} is duplicated.`);
+        return false;
+    }
+    walk.seenIds.add(node.id);
+    return true;
+}
+function isValidResultPointer(pointer) {
+    if (!pointer.startsWith("/"))
+        return false;
+    for (const segment of pointer.slice(1).split("/")) {
+        if (/~(?![01])/u.test(segment))
+            return false;
+        const decoded = segment.replaceAll("~1", "/").replaceAll("~0", "~");
+        if (FORBIDDEN_POINTER_KEYS.has(decoded))
+            return false;
+    }
+    return true;
+}
+function validateOperationRef(walk, ref, path) {
+    if (!OPERATION_ID.test(ref.toolName) || !OPERATION_ID.test(ref.operationId)) {
+        issue(walk, "automation_operation_invalid", path, "Select a bounded tool and operation ID.");
+    }
+    if (ref.contractVersion !== TOOL_NORMAL_INVOCATION_VERSION) {
+        issue(walk, "automation_contract_changed", path, "The operation contract version is unsupported.");
+    }
+}
+function validateBinding(walk, binding, path, available, consumer) {
+    switch (binding.kind) {
+        case "literal":
+            return;
+        case "run_file":
+            if (!isAutomationRunFileName(binding.fileName))
+                issue(walk, "automation_run_file_invalid", path, "Use a portable file name without a directory path.");
+            return;
+        case "run_input":
+            if (!Object.hasOwn(walk.definition.inputs, binding.input)) {
+                issue(walk, "automation_dependency_missing", path, `Run input ${binding.input} is not defined.`);
+            }
+            return;
+        case "source_files":
+            if (consumer !== "agent" || !walk.definition.source) {
+                issue(walk, "automation_dependency_missing", path, "Source file groups require an Agent and a configured source.");
+            }
+            return;
+        case "source_file":
+            if (!walk.definition.source) {
+                issue(walk, "automation_dependency_missing", path, "A source file requires a configured source.");
+                return;
+            }
+            if (!Number.isSafeInteger(binding.index) || binding.index < 0 ||
+                binding.index >= walk.definition.source.maxBatchFiles ||
+                (walk.definition.source.mode === "per_file" && binding.index !== 0)) {
+                issue(walk, "automation_source_index_invalid", path, "Source index is outside the selected run input.");
+            }
+            return;
+        case "node_result": {
+            if (!available.nodeIds.has(binding.nodeId)) {
+                issue(walk, "automation_dependency_missing", path, `Node ${binding.nodeId} has not settled before this step.`);
+                return;
+            }
+            const producer = walk.nodesById.get(binding.nodeId);
+            if (binding.select === "data" && producer?.kind === "agent" && producer.result.kind !== "json") {
+                issue(walk, "automation_dependency_missing", path, "The selected Agent does not declare JSON output.");
+            }
+            if (binding.pointer !== undefined &&
+                (binding.select !== "data" || !isValidResultPointer(binding.pointer))) {
+                issue(walk, "automation_output_pointer_invalid", path, "Use a safe JSON pointer into declared data output.");
+            }
+            return;
+        }
+        case "branch_results":
+            if (consumer !== "agent" || !available.parallelIds.has(binding.parallelNodeId)) {
+                issue(walk, "automation_dependency_missing", path, "Branch results are available to an Agent only after their join.");
+            }
+            return;
+    }
+}
+function validateNodeBindings(walk, node, path, available) {
+    if (node.kind === "tool") {
+        validateOperationRef(walk, node.operation, `${path}.operation`);
+        for (const [name, binding] of Object.entries(node.controls)) {
+            validateBinding(walk, binding, `${path}.controls.${name}`, available, "tool");
+        }
+        if (node.payload)
+            validateBinding(walk, node.payload, `${path}.payload`, available, "tool");
+        return;
+    }
+    for (const [name, binding] of Object.entries(node.inputs)) {
+        validateBinding(walk, binding, `${path}.inputs.${name}`, available, "agent");
+    }
+    if (!node.modelProfileId.trim()) {
+        issue(walk, "automation_model_unavailable", `${path}.modelProfileId`, "Select a model for this Agent.");
+    }
+    for (const [index, selected] of node.tools.entries()) {
+        validateOperationRef(walk, selected.operation, `${path}.tools.${index}`);
+    }
+    validateAgentOutput(walk, node, path);
+}
+function validateAgentOutput(walk, node, path) {
+    if (node.result.kind !== "json") {
+        for (const [index] of (node.acceptance ?? []).entries()) {
+            issue(walk, "automation_acceptance_invalid", `${path}.acceptance.${index}`, "Acceptance requires declared JSON output.");
+        }
+        return;
+    }
+    try {
+        parseToolNormalInvocationContract("automation_result", {
+            version: TOOL_NORMAL_INVOCATION_VERSION,
+            operations: [{
+                    operationId: "result",
+                    summary: "Automation Agent result",
+                    input: node.result.schema,
+                    effect: "read_only",
+                    approval: "request_policy",
+                }],
+        });
+    }
+    catch (error) {
+        issue(walk, "automation_output_schema_invalid", `${path}.result.schema`, String(error));
+        return;
+    }
+    for (const [name, property] of Object.entries(node.result.schema.properties)) {
+        const scalar = property.type === "array" ? property.items : property;
+        if (!hasBoundedAutomationOutputScalar(scalar)) {
+            issue(walk, "automation_output_schema_invalid", `${path}.result.schema.${name}`, `String outputs must be bounded to at most ${AUTOMATION_OUTPUT_SCHEMA_LIMITS.maxStringLength} characters.`);
+        }
+    }
+    for (const [index, check] of (node.acceptance ?? []).entries()) {
+        if (!isDeclaredScalarAcceptance(node.result.schema, check)) {
+            issue(walk, "automation_acceptance_invalid", `${path}.acceptance.${index}`, "Acceptance must compare a required scalar JSON result field.");
+        }
+    }
+}
+function hasBoundedAutomationOutputScalar(scalar) {
+    if (scalar.type !== "string")
+        return true;
+    if (!("maxLength" in scalar))
+        return false;
+    return scalar.maxLength <= AUTOMATION_OUTPUT_SCHEMA_LIMITS.maxStringLength;
+}
+function isDeclaredScalarAcceptance(schema, check) {
+    const field = schema.properties[check.field];
+    if (!schema.required.includes(check.field) || !field)
+        return false;
+    if (field.type === "array")
+        return false;
+    if (field.type === "integer")
+        return typeof check.equals === "number" && Number.isSafeInteger(check.equals);
+    return field.type === typeof check.equals;
+}
+function visitSequence(walk, sequence, available, depth, path) {
+    isValidNodeIdentity(walk, sequence, path);
+    if (depth > AUTOMATION_GRAPH_LIMITS.nestingDepth) {
+        issue(walk, "automation_graph_too_deep", path, "The graph exceeds the nesting limit.");
+        return available;
+    }
+    let current = available;
+    for (const [index, child] of sequence.children.entries()) {
+        current = visitNode(walk, child, current, depth + 1, `${path}.children.${index}`);
+    }
+    return current;
+}
+function visitParallel(walk, parallel, available, depth, path) {
+    isValidNodeIdentity(walk, parallel, path);
+    if (parallel.branches.length < 2 || parallel.branches.length > AUTOMATION_GRAPH_LIMITS.branchesPerGroup) {
+        issue(walk, "automation_parallel_invalid", path, "A parallel group needs 2–8 branches.");
+    }
+    const mergedNodes = new Set(available.nodeIds);
+    const mergedGroups = new Set(available.parallelIds);
+    const mergedTails = new Set();
+    const branches = [];
+    for (const [index, branch] of parallel.branches.entries()) {
+        const before = walk.steps.length;
+        const settled = visitSequence(walk, branch, available, depth + 1, `${path}.branches.${index}`);
+        branches.push(walk.steps.slice(before).map((step) => step.id));
+        for (const id of settled.nodeIds)
+            mergedNodes.add(id);
+        for (const id of settled.parallelIds)
+            mergedGroups.add(id);
+        for (const id of settled.tailNodeIds)
+            mergedTails.add(id);
+    }
+    mergedGroups.add(parallel.id);
+    walk.parallelGroups.push({ id: parallel.id, branches, tailNodeIds: [...mergedTails] });
+    return { nodeIds: mergedNodes, parallelIds: mergedGroups, tailNodeIds: mergedTails };
+}
+function visitNode(walk, node, available, depth, path) {
+    if (node.kind === "sequence")
+        return visitSequence(walk, node, available, depth, path);
+    if (node.kind === "parallel")
+        return visitParallel(walk, node, available, depth, path);
+    isValidNodeIdentity(walk, node, path);
+    walk.executableCount += 1;
+    if (walk.executableCount > AUTOMATION_GRAPH_LIMITS.executableNodes) {
+        issue(walk, "automation_graph_too_large", path, "The graph exceeds the executable node limit.");
+    }
+    if (node.title.trim().length === 0 || node.title.length > 160) {
+        issue(walk, "automation_node_title_invalid", path, "Give the step a bounded title.");
+    }
+    validateNodeBindings(walk, node, path, available);
+    walk.nodesById.set(node.id, node);
+    walk.steps.push({ id: node.id, node, dependsOn: [...available.tailNodeIds] });
+    return {
+        nodeIds: new Set([...available.nodeIds, node.id]),
+        parallelIds: available.parallelIds,
+        tailNodeIds: new Set([node.id]),
+    };
+}
+function inspectAutomationGraph(definition) {
+    const walk = {
+        definition, issues: [], seenIds: new Set(), nodesById: new Map(), executableCount: 0,
+        steps: [], parallelGroups: [],
+    };
+    for (const message of validateAutomationLimits(definition.limits)) {
+        issue(walk, "automation_limits_invalid", "limits", message);
+    }
+    if (definition.trigger.kind === "folder" && !definition.source) {
+        issue(walk, "automation_source_unavailable", "source", "A folder trigger requires a source.");
+    }
+    if (definition.source) {
+        if (!Number.isSafeInteger(definition.source.maxBatchFiles) || definition.source.maxBatchFiles < 1 ||
+            definition.source.maxBatchFiles > AUTOMATION_GRAPH_LIMITS.sourceFilesPerBatch) {
+            issue(walk, "automation_source_limit_invalid", "source.maxBatchFiles", "Choose 1–100 files per captured run.");
+        }
+        if (definition.trigger.kind === "folder" &&
+            (!Number.isSafeInteger(definition.trigger.minimumEligibleFiles) ||
+                definition.trigger.minimumEligibleFiles < 1 ||
+                definition.trigger.minimumEligibleFiles > definition.source.maxBatchFiles)) {
+            issue(walk, "automation_source_threshold_invalid", "trigger.minimumEligibleFiles", "The threshold must fit the captured batch.");
+        }
+        if (definition.source.mode === "per_file" && definition.trigger.kind === "folder" &&
+            definition.trigger.minimumEligibleFiles !== 1) {
+            issue(walk, "automation_source_threshold_invalid", "trigger.minimumEligibleFiles", "Per-file workflows trigger for one eligible file at a time.");
+        }
+    }
+    visitSequence(walk, definition.body, {
+        nodeIds: new Set(), parallelIds: new Set(), tailNodeIds: new Set(),
+    }, 0, "body");
+    if (walk.executableCount === 0) {
+        issue(walk, "automation_graph_empty", "body", "Add at least one Tool or Agent step.");
+    }
+    return walk;
+}
+export function validateAutomationGraph(definition) {
+    return inspectAutomationGraph(definition).issues;
+}
+export function compileAutomationGraph(definition) {
+    const inspected = inspectAutomationGraph(definition);
+    if (inspected.issues.length > 0)
+        return { ok: false, issues: inspected.issues };
+    return {
+        ok: true,
+        graph: { steps: inspected.steps, parallelGroups: inspected.parallelGroups },
+    };
+}

package/dist/src/runtime/automations/input-batch-selection.d.ts

@@ -0,0 +1,7 @@
+type SizedInput = Readonly<{
+    file: Readonly<{
+        sizeBytes: number;
+    }>;
+}>;
+export declare function selectAutomationInputBatch<T extends SizedInput>(candidates: readonly T[], minimumFiles: number, maxFiles: number): T[];
+export {};

package/dist/src/runtime/automations/input-batch-selection.js

@@ -0,0 +1,42 @@
+const MAX_BATCH_BYTES = 32 * 1024 * 1024;
+export function selectAutomationInputBatch(candidates, minimumFiles, maxFiles) {
+    const waitingForMinimumInputs = candidates.length < minimumFiles;
+    if (waitingForMinimumInputs)
+        return [];
+    const minimumExceedsFileLimit = minimumFiles > maxFiles;
+    if (minimumExceedsFileLimit)
+        throw new Error("automation_source_capacity_exceeded");
+    const preferred = fillAvailableBatch(candidates, [], maxFiles);
+    const preferredMeetsMinimum = preferred.length >= minimumFiles;
+    if (preferredMeetsMinimum)
+        return preferred;
+    // The smallest minimumFiles prove whether any threshold-sized batch can fit.
+    // Preserve source order normally; only replace an infeasible preferred prefix.
+    const minimum = [...candidates].sort((left, right) => left.file.sizeBytes - right.file.sizeBytes).slice(0, minimumFiles);
+    const minimumExceedsByteLimit = batchBytes(minimum) > MAX_BATCH_BYTES;
+    if (minimumExceedsByteLimit)
+        throw new Error("automation_source_capacity_exceeded");
+    const selected = new Set(fillAvailableBatch(candidates, minimum, maxFiles));
+    return candidates.filter((candidate) => selected.has(candidate));
+}
+function batchBytes(candidates) {
+    return candidates.reduce((bytes, candidate) => bytes + candidate.file.sizeBytes, 0);
+}
+function fillAvailableBatch(candidates, selected, maxFiles) {
+    let bytes = batchBytes(selected);
+    const included = new Set(selected);
+    for (const candidate of candidates) {
+        const reachedFileLimit = selected.length >= maxFiles;
+        if (reachedFileLimit)
+            break;
+        if (included.has(candidate))
+            continue;
+        const fitsRemainingBytes = bytes + candidate.file.sizeBytes <= MAX_BATCH_BYTES;
+        if (!fitsRemainingBytes)
+            continue;
+        selected.push(candidate);
+        included.add(candidate);
+        bytes += candidate.file.sizeBytes;
+    }
+    return selected;
+}

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

@@ -0,0 +1,9 @@
+import type { AutomationInputRecord } from "./storage-records.js";
+export declare const MAX_INPUT_SNAPSHOT_BYTES: number;
+/**
+ * Baselines and consumed-version tombstones preserve exclusion and dedup history.
+ * Retained snapshots share an environment budget. Complete history has a separate
+ * per-automation budget, so one exhausted owner cannot stop unrelated intake.
+ */
+export declare function requireRetainedInputCapacity(records: readonly AutomationInputRecord[]): void;
+export declare function requireObservedInputCapacity(records: readonly AutomationInputRecord[], observedRecordIds: ReadonlySet<string>): void;

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

@@ -0,0 +1,38 @@
+const MAX_RETAINED_INPUT_RECORDS = 1_000;
+const MAX_RETAINED_INPUT_METADATA_BYTES = 32 * 1024 * 1024;
+const MAX_AUTOMATION_INPUT_METADATA_BYTES = 32 * 1024 * 1024;
+export const MAX_INPUT_SNAPSHOT_BYTES = 256 * 1024 * 1024;
+/**
+ * Baselines and consumed-version tombstones preserve exclusion and dedup history.
+ * Retained snapshots share an environment budget. Complete history has a separate
+ * per-automation budget, so one exhausted owner cannot stop unrelated intake.
+ */
+export function requireRetainedInputCapacity(records) {
+    const retained = records.filter(hasRetainedInputSnapshot);
+    const tooManyRetainedInputs = retained.length > MAX_RETAINED_INPUT_RECORDS;
+    if (tooManyRetainedInputs)
+        throw new Error("automation_source_capacity_exceeded");
+    const retainedMetadataBytes = Buffer.byteLength(JSON.stringify(retained), "utf8");
+    const retainedMetadataExceedsBudget = retainedMetadataBytes > MAX_RETAINED_INPUT_METADATA_BYTES;
+    if (retainedMetadataExceedsBudget)
+        throw new Error("automation_source_capacity_exceeded");
+    const retainedSnapshotBytes = retained.reduce((bytes, record) => bytes + (record.snapshot?.sizeBytes ?? 0), 0);
+    const retainedSnapshotsExceedBudget = retainedSnapshotBytes > MAX_INPUT_SNAPSHOT_BYTES;
+    if (retainedSnapshotsExceedBudget)
+        throw new Error("automation_source_capacity_exceeded");
+}
+export function requireObservedInputCapacity(records, observedRecordIds) {
+    requireRetainedInputCapacity(records);
+    const observedOwners = new Set(records.filter((record) => observedRecordIds.has(record.id))
+        .map((record) => record.automationId));
+    for (const automationId of observedOwners) {
+        const owned = records.filter((record) => record.automationId === automationId);
+        const historyExceedsBudget = Buffer.byteLength(JSON.stringify(owned), "utf8") >
+            MAX_AUTOMATION_INPUT_METADATA_BYTES;
+        if (historyExceedsBudget)
+            throw new Error("automation_source_capacity_exceeded");
+    }
+}
+function hasRetainedInputSnapshot(record) {
+    return record.snapshot !== undefined;
+}

package/dist/src/runtime/automations/input-ledger.d.ts

@@ -0,0 +1,45 @@
+import type { AutomationInputRecord, AutomationJournalState } from "./storage-records.js";
+import type { CapturedSourceFile, DiscoveredSourceFile } from "./source-discovery.js";
+export { MAX_INPUT_SNAPSHOT_BYTES } from "./input-capacity.js";
+export declare function recordsForSource(state: AutomationJournalState, automationId: string, sourceId: string): AutomationInputRecord[];
+export declare function hasSourceBaseline(records: readonly AutomationInputRecord[], root: string): boolean;
+export declare function cachedContentVersion(file: DiscoveredSourceFile, records: readonly AutomationInputRecord[]): string | undefined;
+export declare function findSourceVersion(records: readonly AutomationInputRecord[], canonicalPath: string, contentVersion: string): AutomationInputRecord | undefined;
+export declare function sourceBaselineMarker(input: {
+    automationId: string;
+    sourceId: string;
+    root: string;
+    observedAt: string;
+    excludedInputIds?: readonly string[];
+}): AutomationInputRecord;
+export declare function isReusableSourceInput(record: AutomationInputRecord, records: readonly AutomationInputRecord[], root: string): boolean;
+export declare function baselineFileRecord(input: {
+    automationId: string;
+    sourceId: string;
+    file: CapturedSourceFile;
+    observedAt: string;
+}): AutomationInputRecord;
+export declare function eligibleFileRecord(input: {
+    id?: string;
+    automationId: string;
+    sourceId: string;
+    file: CapturedSourceFile;
+    observedAt: string;
+    attachment: NonNullable<AutomationInputRecord["snapshot"]>["attachment"];
+}): AutomationInputRecord;
+export type ObservationRefresh = Readonly<{
+    recordId: string;
+    file: DiscoveredSourceFile;
+    observedAt: string;
+}>;
+export declare function commitInputObservation(input: {
+    state: AutomationJournalState;
+    marker?: AutomationInputRecord;
+    baselineFiles?: readonly AutomationInputRecord[];
+    newFiles?: readonly AutomationInputRecord[];
+    selectedExistingIds?: readonly string[];
+    refresh?: readonly ObservationRefresh[];
+    runId?: string;
+}): void;
+export declare function releaseNeverDispatchedInputs(state: AutomationJournalState, runId: string): void;
+export declare function holdInterruptedInputs(state: AutomationJournalState, runId: string): void;

package/dist/src/runtime/automations/input-ledger.js

@@ -0,0 +1,147 @@
+import { randomUUID } from "node:crypto";
+import { requireObservedInputCapacity } from "./input-capacity.js";
+export { MAX_INPUT_SNAPSHOT_BYTES } from "./input-capacity.js";
+export function recordsForSource(state, automationId, sourceId) {
+    return state.inputs.filter((record) => record.automationId === automationId && record.sourceId === sourceId);
+}
+export function hasSourceBaseline(records, root) {
+    return records.some((record) => record.baselineMarker === true && record.canonicalPath === root);
+}
+export function cachedContentVersion(file, records) {
+    const cached = records.find((record) => !record.baselineMarker && record.canonicalPath === file.canonicalPath &&
+        record.observedSizeBytes === file.sizeBytes &&
+        record.observedMtimeMs === file.mtimeMs &&
+        record.observedCtimeMs === file.ctimeMs);
+    return cached?.contentVersion;
+}
+export function findSourceVersion(records, canonicalPath, contentVersion) {
+    return records.find((record) => !record.baselineMarker && record.canonicalPath === canonicalPath &&
+        record.contentVersion === contentVersion);
+}
+export function sourceBaselineMarker(input) {
+    return {
+        id: randomUUID(),
+        automationId: input.automationId,
+        sourceId: input.sourceId,
+        canonicalPath: input.root,
+        contentVersion: "source-baseline-marker-v1",
+        observedAt: input.observedAt,
+        eligibility: "baseline",
+        baselineMarker: true,
+        ...(input.excludedInputIds?.length ? { excludedInputIds: input.excludedInputIds } : {}),
+    };
+}
+export function isReusableSourceInput(record, records, root) {
+    if (record.eligibility !== "eligible")
+        return false;
+    if (record.claimRunId)
+        return false;
+    if (record.outcomeRef)
+        return false;
+    if (!record.snapshot)
+        return false;
+    const baseline = records.find((candidate) => candidate.baselineMarker === true && candidate.canonicalPath === root);
+    return !baseline?.excludedInputIds?.includes(record.id);
+}
+function observedMetadata(file) {
+    return {
+        observedSizeBytes: file.sizeBytes,
+        observedMtimeMs: file.mtimeMs,
+        observedCtimeMs: file.ctimeMs,
+    };
+}
+export function baselineFileRecord(input) {
+    return {
+        id: randomUUID(),
+        automationId: input.automationId,
+        sourceId: input.sourceId,
+        canonicalPath: input.file.canonicalPath,
+        contentVersion: input.file.contentVersion,
+        observedAt: input.observedAt,
+        eligibility: "baseline",
+        ...observedMetadata(input.file),
+    };
+}
+export function eligibleFileRecord(input) {
+    return {
+        id: input.id ?? randomUUID(),
+        automationId: input.automationId,
+        sourceId: input.sourceId,
+        canonicalPath: input.file.canonicalPath,
+        contentVersion: input.file.contentVersion,
+        observedAt: input.observedAt,
+        eligibility: "eligible",
+        ...observedMetadata(input.file),
+        snapshot: {
+            attachment: input.attachment,
+            contentVersion: input.file.contentVersion,
+            sizeBytes: input.file.sizeBytes,
+        },
+    };
+}
+export function commitInputObservation(input) {
+    const additions = [
+        ...(input.marker ? [input.marker] : []),
+        ...(input.baselineFiles ?? []),
+        ...(input.newFiles ?? []),
+    ];
+    for (const candidate of additions) {
+        if (input.state.inputs.some((record) => record.automationId === candidate.automationId &&
+            record.sourceId === candidate.sourceId &&
+            record.baselineMarker === candidate.baselineMarker &&
+            record.canonicalPath === candidate.canonicalPath &&
+            record.contentVersion === candidate.contentVersion))
+            throw new Error("automation_source_changed");
+    }
+    for (const id of input.selectedExistingIds ?? []) {
+        const existing = input.state.inputs.find((record) => record.id === id);
+        if (!existing || existing.eligibility !== "eligible" ||
+            existing.claimRunId || existing.outcomeRef || !existing.snapshot)
+            throw new Error("automation_source_changed");
+    }
+    if (input.runId) {
+        for (const record of input.newFiles ?? []) {
+            input.state.inputs.push({ ...record, claimRunId: input.runId });
+        }
+        for (const id of input.selectedExistingIds ?? []) {
+            replaceInput(input.state, id, (record) => ({ ...record, claimRunId: input.runId }));
+        }
+    }
+    else {
+        input.state.inputs.push(...(input.newFiles ?? []));
+    }
+    input.state.inputs.push(...(input.marker ? [input.marker] : []));
+    input.state.inputs.push(...(input.baselineFiles ?? []));
+    for (const update of input.refresh ?? []) {
+        replaceInput(input.state, update.recordId, (record) => ({
+            ...record,
+            observedAt: update.observedAt,
+            ...observedMetadata(update.file),
+        }));
+    }
+    requireObservedInputCapacity(input.state.inputs, new Set([
+        ...additions.map((record) => record.id),
+        ...(input.selectedExistingIds ?? []),
+        ...(input.refresh ?? []).map((record) => record.recordId),
+    ]));
+}
+function replaceInput(state, id, update) {
+    const index = state.inputs.findIndex((record) => record.id === id);
+    if (index < 0)
+        throw new Error("automation_source_changed");
+    state.inputs[index] = update(state.inputs[index]);
+}
+export function releaseNeverDispatchedInputs(state, runId) {
+    for (const record of state.inputs.filter((item) => item.claimRunId === runId)) {
+        if (record.outcomeRef)
+            continue;
+        replaceInput(state, record.id, ({ claimRunId: _claim, ...rest }) => rest);
+    }
+}
+export function holdInterruptedInputs(state, runId) {
+    for (const record of state.inputs.filter((item) => item.claimRunId === runId)) {
+        if (record.outcomeRef)
+            continue;
+        replaceInput(state, record.id, (existing) => ({ ...existing, eligibility: "held" }));
+    }
+}

package/dist/src/runtime/automations/late-settlement.d.ts

@@ -0,0 +1,9 @@
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationObservedToolSettlement } from "./tool-lifetimes.js";
+/** Append evidence for effects that completed after their attempt became uncertain. */
+export declare function recordAutomationLateSettlements(input: {
+    persistence: AutomationPersistence;
+    runId: string;
+    observed: readonly AutomationObservedToolSettlement[];
+    now?: () => number;
+}): Promise<void>;

package/dist/src/runtime/automations/late-settlement.js

@@ -0,0 +1,42 @@
+/** Append evidence for effects that completed after their attempt became uncertain. */
+export async function recordAutomationLateSettlements(input) {
+    if (input.observed.length === 0)
+        return;
+    const now = input.now ?? Date.now;
+    await input.persistence.update((state) => {
+        const executionIndex = state.executions.findIndex((item) => item.id === input.runId);
+        if (executionIndex < 0)
+            throw new Error("automation_run_not_found");
+        const execution = state.executions[executionIndex];
+        const nextRevision = execution.revision + 1;
+        const observedAt = new Date(now()).toISOString();
+        let changed = false;
+        for (const item of input.observed) {
+            const attemptIndex = state.attempts.findIndex((attempt) => attempt.runId === input.runId && attempt.invocationId === item.invocationId);
+            if (attemptIndex < 0)
+                continue;
+            const attempt = state.attempts[attemptIndex];
+            if (attempt.state === "settled" || attempt.lateSettlement)
+                continue;
+            const settlement = item.settlement;
+            state.attempts[attemptIndex] = {
+                ...attempt,
+                state: "uncertain",
+                lateSettlement: {
+                    revision: nextRevision,
+                    observedAt,
+                    status: settlement.status === "rejected"
+                        ? "rejected"
+                        : settlement.ok ? "succeeded" : "failed",
+                    ...(settlement.errorCode ? { errorCode: settlement.errorCode } : {}),
+                },
+            };
+            changed = true;
+        }
+        if (changed)
+            state.executions[executionIndex] = {
+                ...execution,
+                revision: nextRevision,
+            };
+    });
+}

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

@@ -0,0 +1,25 @@
+export type AutomationLimits = Readonly<{
+    maxConcurrentNodes: number;
+    maxModelCallsPerRun: number;
+    maxToolCallsPerRun: number;
+    maxRunDurationMs: number;
+    maxRunsPerDay: number;
+    maxStoredArtifactBytes: number;
+    stopReportDeadlineMs: number;
+}>;
+export declare const AUTOMATION_GRAPH_LIMITS: Readonly<{
+    executableNodes: 64;
+    branchesPerGroup: 8;
+    nestingDepth: 4;
+    sourceFilesPerBatch: 100;
+    sourceBatchBytes: number;
+    eligibleInputRecords: 1000;
+    inputMetadataBytes: number;
+}>;
+export declare const AUTOMATION_OUTPUT_SCHEMA_LIMITS: Readonly<{
+    maxProperties: 16;
+    maxStringLength: 4096;
+    maxArrayItems: 64;
+}>;
+export declare const DEFAULT_AUTOMATION_LIMITS: AutomationLimits;
+export declare function validateAutomationLimits(limits: AutomationLimits): string[];