@forestadmin/workflow-executor 1.33.1 → 1.34.0

package/dist/automation/inbox-poll.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const read_failure_1 = require("./read-failure");
+const reconciliation_1 = require("./reconciliation");
+const errors_1 = require("../errors");
+function describeAgentFailure(error) {
+    return {
+        error: (0, errors_1.extractErrorMessage)(error),
+        httpStatus: error instanceof errors_1.SegmentReadError ? error.httpStatus : undefined,
+        agentError: error instanceof errors_1.SegmentReadError ? error.agentDetail : undefined,
+    };
+}
+function agentSort(inboxSort, sortsOnSeveralFields) {
+    return sortsOnSeveralFields ? inboxSort : inboxSort?.slice(0, 1);
+}
+// Offset pages only walk a total order, which only a single-column key can close as a tiebreak.
+function paddedOrder(inbox, wholeInboxSort, sortsOnSeveralFields) {
+    const [primaryKey] = inbox.primaryKeys;
+    const byKey = { field: primaryKey, ascending: true };
+    const inboxSort = agentSort(wholeInboxSort, sortsOnSeveralFields);
+    if (inbox.primaryKeys.length !== 1)
+        return { sort: inboxSort, pageable: false };
+    if (!inboxSort)
+        return { sort: [byKey], pageable: true };
+    if (inboxSort.some(({ field }) => field === primaryKey)) {
+        return { sort: inboxSort, pageable: true };
+    }
+    if (!sortsOnSeveralFields)
+        return { sort: inboxSort, pageable: false };
+    return { sort: [...inboxSort, byKey], pageable: true };
+}
+function activeInboxSort(inbox, attempt) {
+    return attempt.inboxSortDropped ? undefined : inbox.sort;
+}
+function segmentQuery(inbox) {
+    return {
+        collectionName: inbox.collectionName,
+        segment: inbox.segment,
+        primaryKeys: inbox.primaryKeys,
+        user: inbox.user,
+        timezone: inbox.timezone,
+    };
+}
+/**
+ * One sweep of one automated inbox: reconciles the records whose run is over, reads new candidates,
+ * and reports both to the orchestrator in a single sync.
+ */
+class InboxPoll {
+    constructor(params) {
+        this.automationPort = params.automationPort;
+        this.segmentReaderPort = params.segmentReaderPort;
+        this.logger = params.logger;
+    }
+    async poll(inbox) {
+        const logContext = {
+            inboxId: inbox.inboxId,
+            renderingId: inbox.renderingId,
+            workflowId: inbox.workflowId,
+            collectionName: inbox.collectionName,
+        };
+        try {
+            const assignments = await this.automationPort.listAssignments(inbox.inboxId);
+            // Read independently, and neither is allowed to cost the other. Losing the reconciliation
+            // because the candidate page timed out would leave those assignments open, which makes the
+            // next page larger, which makes the next timeout likelier.
+            const [closed, candidates] = await Promise.all([
+                this.tryRead(logContext, 'closed records', attempt => this.reconcileClosed(inbox, assignments, attempt)),
+                this.tryRead(logContext, 'new candidates', attempt => this.readCandidates(logContext, inbox, assignments, attempt)),
+            ]);
+            // The candidate read is the one that starts runs, so its failure is the one worth fixing.
+            const readFailure = candidates.failure ?? closed.failure;
+            // Sent even when both lists are empty or both reads failed: the orchestrator keeps the last
+            // read failure until a sync comes without one, so a skipped sync would leave the settings
+            // panel with a stale warning, or none at all.
+            const results = await this.automationPort.sync(inbox.inboxId, {
+                closed: closed.items,
+                candidates: candidates.items,
+                readFailure,
+            });
+            this.logger('Info', 'Automated inbox polled', {
+                ...logContext,
+                assignments: assignments.length,
+                reconciled: closed.items.length,
+                candidates: candidates.items.length,
+                candidatePageSize: candidates.requestedPageSize,
+                candidatePagesRead: candidates.pagesRead,
+                paddedPageReason: candidates.paddedPageReason,
+                readFailure: readFailure?.reason,
+                outcomes: results.reduce((counts, { outcome }) => ({ ...counts, [outcome]: (counts[outcome] ?? 0) + 1 }), {}),
+            });
+        }
+        catch (error) {
+            // Legitimate only if the inbox was disabled or degraded since this cycle's listing served it.
+            // Otherwise its route is missing behind a proxy, a path prefix or a version skew, and the inbox
+            // is never swept again.
+            if (error instanceof errors_1.AutomatedInboxGoneError) {
+                this.logger('Warn', 'Automated inbox listed this cycle but its route answered 404, dropping it for this cycle', { ...logContext, operation: error.operation, detail: error.detail });
+                return;
+            }
+            this.logger('Error', 'Automated inbox poll failed', {
+                ...logContext,
+                error: (0, errors_1.extractErrorMessage)(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+    }
+    /**
+     * A record whose run is over is only treated once it has left the segment. Reading the assignment
+     * state alone is not enough: a record reported still in the segment while its run is going would
+     * be judged untreated before the run had a chance to take it out.
+     */
+    async reconcileClosed(inbox, assignments, attempt) {
+        const logContext = { inboxId: inbox.inboxId, renderingId: inbox.renderingId };
+        for (const { state, recordId, workflowRunId } of (0, reconciliation_1.withUnknownState)(assignments)) {
+            this.logger('Warn', 'Unknown assignment state, leaving the record out of every sweep until this executor knows it', { ...logContext, state, recordId, workflowRunId });
+        }
+        const toReconcile = (0, reconciliation_1.reconcilable)(assignments);
+        for (const { runState, recordId, workflowRunId } of (0, reconciliation_1.withUnexpectedRunState)(toReconcile)) {
+            this.logger('Warn', 'Unexpected workflow run state, leaving the record out of every sweep until this executor knows it', { ...logContext, runState, recordId, workflowRunId });
+        }
+        // An unreadable id is dropped one by one rather than failing the chunk, which would end
+        // reconciliation for the whole inbox on every cycle, and left out of the report entirely:
+        // telling the orchestrator it is not in the segment would retire its assignment and let the
+        // record be launched again.
+        const readable = (0, reconciliation_1.recordsToCheck)(assignments, toReconcile).filter(recordId => {
+            if ((0, reconciliation_1.isReadableRecordId)(recordId, inbox.primaryKeys))
+                return true;
+            this.logger('Warn', 'Unreadable record id, leaving the record out of the reconciliation', {
+                ...logContext,
+                recordId,
+                primaryKeyCount: inbox.primaryKeys.length,
+            });
+            return false;
+        });
+        if (readable.length === 0)
+            return { items: [] };
+        const stillInSegment = new Set();
+        const batches = (0, reconciliation_1.chunk)(readable, reconciliation_1.MEMBERSHIP_CHUNK_SIZE);
+        for (const [index, batch] of batches.entries()) {
+            Object.assign(attempt, { membershipChunk: index + 1, membershipChunks: batches.length });
+            // eslint-disable-next-line no-await-in-loop
+            const found = await this.segmentReaderPort.listRecordIds({
+                ...segmentQuery(inbox),
+                recordIds: batch,
+                pageSize: batch.length,
+            });
+            found.forEach(recordId => stillInSegment.add(recordId));
+        }
+        return {
+            items: readable.map(recordId => ({
+                recordId,
+                stillInSegment: stillInSegment.has(recordId),
+            })),
+        };
+    }
+    /**
+     * Runs one of the two segment reads. A failure yields an empty list rather than ending the poll,
+     * so the other read and the sync still happen — but it is reported as a failure, because "read
+     * nothing" and "could not read" must not look alike to the caller.
+     */
+    async tryRead(logContext, what, read) {
+        const attempt = {};
+        try {
+            return await read(attempt);
+        }
+        catch (error) {
+            this.logger('Error', `Could not read ${what} of an automated inbox`, {
+                ...logContext,
+                ...attempt,
+                ...describeAgentFailure(error),
+            });
+            return { items: [], failure: (0, read_failure_1.toReadFailure)(error) };
+        }
+    }
+    /**
+     * Asks the agent for records the orchestrator has no assignment for. Excluding them in the query
+     * is what keeps the page at the run cap: a record already treated but still in the segment stays
+     * there for good, and left in the page it would take a slot on every poll from then on.
+     */
+    async readCandidates(logContext, inbox, assignments, attempt) {
+        const known = (0, reconciliation_1.knownRecordIds)(assignments);
+        const knownSet = new Set(known);
+        const paddedPageReason = await this.paddedPageReason(logContext, inbox, known);
+        const sortsOnSeveralFields = this.segmentReaderPort.sortsOnSeveralFields(inbox.liana, inbox.lianaVersion);
+        if (!paddedPageReason) {
+            Object.assign(attempt, {
+                requestedPageSize: inbox.maxConcurrentRuns,
+                notIn: known.length > 0,
+            });
+            let page;
+            try {
+                page = await this.readWithInboxSort(logContext, inbox, attempt, inboxSort => agentSort(inboxSort, sortsOnSeveralFields), sort => this.segmentReaderPort.listRecordIds({
+                    ...segmentQuery(inbox),
+                    ...(known.length ? { excludedRecordIds: known } : {}),
+                    pageSize: inbox.maxConcurrentRuns,
+                    sort,
+                }));
+            }
+            catch (error) {
+                if (!known.length || !(0, read_failure_1.mayBeOperatorRefusal)(error))
+                    throw error;
+                // Declared is not implemented: a datasource can list `not_in` and still refuse it.
+                this.logger('Warn', 'The not_in candidate read failed, padding the page instead', {
+                    ...logContext,
+                    ...attempt,
+                    ...describeAgentFailure(error),
+                });
+                return this.readPaddedCandidates(logContext, inbox, knownSet, 'not-in-refused', attempt);
+            }
+            const fresh = page.filter(recordId => !knownSet.has(recordId));
+            // An agent that ignores an operator it does not know hands known records back. A page of
+            // nothing else would starve the inbox on every sweep, so it is padded like a refused read.
+            if (page.length > 0 && fresh.length === 0) {
+                this.logger('Warn', 'The not_in candidate read returned only known records, padding the page instead', {
+                    ...logContext,
+                    ...attempt,
+                });
+                return this.readPaddedCandidates(logContext, inbox, knownSet, 'not-in-ignored', attempt);
+            }
+            return { items: fresh, requestedPageSize: inbox.maxConcurrentRuns };
+        }
+        return this.readPaddedCandidates(logContext, inbox, knownSet, paddedPageReason, attempt);
+    }
+    async readPaddedCandidates(logContext, inbox, knownSet, paddedPageReason, attempt) {
+        const requestedPageSize = (0, reconciliation_1.paddedPageSize)(inbox.maxConcurrentRuns, knownSet.size);
+        const sortsOnSeveralFields = this.segmentReaderPort.sortsOnSeveralFields(inbox.liana, inbox.lianaVersion);
+        const orderFor = (inboxSort) => paddedOrder(inbox, inboxSort, sortsOnSeveralFields);
+        const byKeyOrder = orderFor(undefined);
+        let order = orderFor(activeInboxSort(inbox, attempt));
+        let orderPagesRead = 0;
+        const candidates = new Set();
+        let pagesRead = 0;
+        let reachedEnd = false;
+        while (pagesRead < reconciliation_1.MAX_PADDED_PAGES &&
+            candidates.size < inbox.maxConcurrentRuns &&
+            !reachedEnd) {
+            // A page in an order that cannot be paged may hold nothing but treated records: the key order
+            // then walks past them, as it would without an inbox sort.
+            if (orderPagesRead > 0 && !order.pageable) {
+                if (!byKeyOrder.pageable)
+                    break;
+                order = byKeyOrder;
+                orderPagesRead = 0;
+            }
+            pagesRead += 1;
+            orderPagesRead += 1;
+            const pageNumber = orderPagesRead;
+            const pageSort = order.sort;
+            Object.assign(attempt, {
+                requestedPageSize,
+                pageNumber,
+                paddedPageReason,
+                notIn: false,
+            });
+            const readPage = (sort) => this.segmentReaderPort.listRecordIds({
+                ...segmentQuery(inbox),
+                pageSize: requestedPageSize,
+                pageNumber,
+                sort,
+            });
+            let page;
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                page = await (pagesRead === 1
+                    ? this.readWithInboxSort(logContext, inbox, attempt, inboxSort => orderFor(inboxSort).sort, readPage)
+                    : readPage(pageSort));
+                if (pagesRead === 1)
+                    order = orderFor(activeInboxSort(inbox, attempt));
+            }
+            catch (error) {
+                if (candidates.size === 0)
+                    throw error;
+                // The candidates the earlier pages found are still good: dropping them would send an empty
+                // sync on every sweep of a slow agent.
+                this.logger('Warn', 'A later padded candidate page failed, keeping what earlier pages found', {
+                    ...logContext,
+                    ...attempt,
+                    pagesRead,
+                    ...describeAgentFailure(error),
+                });
+                break;
+            }
+            (0, reconciliation_1.newCandidates)(page, knownSet, candidates, inbox.maxConcurrentRuns - candidates.size).forEach(id => candidates.add(id));
+            reachedEnd = page.length < requestedPageSize;
+        }
+        if (candidates.size === 0 && !reachedEnd) {
+            this.logger('Warn', 'The padded candidate read found no new record within its page cap', {
+                ...logContext,
+                known: knownSet.size,
+                pagesRead,
+                paddedPageReason,
+            });
+        }
+        return {
+            items: [...candidates],
+            paddedPageReason,
+            requestedPageSize,
+            pagesRead,
+        };
+    }
+    /**
+     * A sort field renamed or out of the service account's reach must not stop the inbox from
+     * dispatching. Used on the not_in read and the first padded page only: a refused sort is refused
+     * on the first page already. The order is dropped for the rest of the candidate read only once the
+     * read without it succeeds, since a read failing both ways says nothing against the sort.
+     */
+    async readWithInboxSort(logContext, inbox, attempt, toSort, read) {
+        const inboxSort = activeInboxSort(inbox, attempt);
+        const sort = toSort(inboxSort);
+        try {
+            return await read(sort);
+        }
+        catch (error) {
+            if (!inboxSort?.length || !(0, read_failure_1.mayBeSortRefusal)(error))
+                throw error;
+            let page;
+            try {
+                page = await read(toSort(undefined));
+            }
+            catch (unsortedError) {
+                Object.assign(attempt, { sortedReadFailure: { sort, ...describeAgentFailure(error) } });
+                throw unsortedError;
+            }
+            this.logger('Warn', 'The agent rejected the inbox sort, reading candidates without it', {
+                ...logContext,
+                ...attempt,
+                sort,
+                ...describeAgentFailure(error),
+            });
+            Object.assign(attempt, { inboxSortDropped: true });
+            return page;
+        }
+    }
+    async paddedPageReason(logContext, inbox, known) {
+        try {
+            return await this.segmentReaderPort.exclusionUnavailableReason({
+                collectionName: inbox.collectionName,
+                primaryKeys: inbox.primaryKeys,
+                user: inbox.user,
+                timezone: inbox.timezone,
+                liana: inbox.liana,
+                knownRecordCount: known.length,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof errors_1.SegmentReadError))
+                throw error;
+            this.logger('Warn', 'Could not read the agent capabilities, padding the page instead', {
+                ...logContext,
+                ...describeAgentFailure(error),
+            });
+            return 'capabilities-unreadable';
+        }
+    }
+}
+exports.default = InboxPoll;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inbox-poll.js","sourceRoot":"","sources":["../../src/automation/inbox-poll.ts"],"names":[],"mappings":"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"}

package/dist/automation/lease-keeper.d.ts

@@ -0,0 +1,12 @@
+export default class LeaseKeeper {
+    private holdsLease;
+    private leaseConfirmedAt;
+    recordBeat(held: boolean, now: number): {
+        roleChanged: boolean;
+    };
+    recordFailedBeat(now: number): {
+        trustLost: boolean;
+    };
+    isTrusted(now: number): boolean;
+}
+//# sourceMappingURL=lease-keeper.d.ts.map

package/dist/automation/lease-keeper.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Past this without a confirmed beat, the lease may have expired and gone to another instance.
+// Judged at each dispatch rather than when a beat fails: a timed-out beat only fails 5 s late, and
+// the next one 15 s after that, which would land past the 45 s lease.
+const LEASE_TRUSTED_FOR_MS = 30000;
+class LeaseKeeper {
+    constructor() {
+        this.leaseConfirmedAt = 0;
+    }
+    recordBeat(held, now) {
+        const roleChanged = held !== this.holdsLease;
+        this.holdsLease = held;
+        if (held)
+            this.leaseConfirmedAt = now;
+        return { roleChanged };
+    }
+    recordFailedBeat(now) {
+        if (!this.holdsLease || now - this.leaseConfirmedAt < LEASE_TRUSTED_FOR_MS) {
+            return { trustLost: false };
+        }
+        this.holdsLease = false;
+        return { trustLost: true };
+    }
+    isTrusted(now) {
+        return this.holdsLease === true && now - this.leaseConfirmedAt < LEASE_TRUSTED_FOR_MS;
+    }
+}
+exports.default = LeaseKeeper;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVhc2Uta2VlcGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2F1dG9tYXRpb24vbGVhc2Uta2VlcGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsK0ZBQStGO0FBQy9GLG1HQUFtRztBQUNuRyxzRUFBc0U7QUFDdEUsTUFBTSxvQkFBb0IsR0FBRyxLQUFNLENBQUM7QUFFcEMsTUFBcUIsV0FBVztJQUFoQztRQUVVLHFCQUFnQixHQUFHLENBQUMsQ0FBQztJQXdCL0IsQ0FBQztJQXRCQyxVQUFVLENBQUMsSUFBYSxFQUFFLEdBQVc7UUFDbkMsTUFBTSxXQUFXLEdBQUcsSUFBSSxLQUFLLElBQUksQ0FBQyxVQUFVLENBQUM7UUFDN0MsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUM7UUFFdkIsSUFBSSxJQUFJO1lBQUUsSUFBSSxDQUFDLGdCQUFnQixHQUFHLEdBQUcsQ0FBQztRQUV0QyxPQUFPLEVBQUUsV0FBVyxFQUFFLENBQUM7SUFDekIsQ0FBQztJQUVELGdCQUFnQixDQUFDLEdBQVc7UUFDMUIsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLElBQUksR0FBRyxHQUFHLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxvQkFBb0IsRUFBRSxDQUFDO1lBQzNFLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLENBQUM7UUFDOUIsQ0FBQztRQUVELElBQUksQ0FBQyxVQUFVLEdBQUcsS0FBSyxDQUFDO1FBRXhCLE9BQU8sRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLENBQUM7SUFDN0IsQ0FBQztJQUVELFNBQVMsQ0FBQyxHQUFXO1FBQ25CLE9BQU8sSUFBSSxDQUFDLFVBQVUsS0FBSyxJQUFJLElBQUksR0FBRyxHQUFHLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxvQkFBb0IsQ0FBQztJQUN4RixDQUFDO0NBQ0Y7QUExQkQsOEJBMEJDIn0=

package/dist/automation/read-failure.d.ts

@@ -0,0 +1,5 @@
+import type { SegmentReadFailure } from '../types/automation';
+export declare function toReadFailure(error: unknown): SegmentReadFailure;
+export declare function mayBeOperatorRefusal(error: unknown): boolean;
+export declare function mayBeSortRefusal(error: unknown): boolean;
+//# sourceMappingURL=read-failure.d.ts.map

package/dist/automation/read-failure.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toReadFailure = toReadFailure;
+exports.mayBeOperatorRefusal = mayBeOperatorRefusal;
+exports.mayBeSortRefusal = mayBeSortRefusal;
+const errors_1 = require("../errors");
+const READ_FAILURE_REASONS = {
+    forbidden: 'agent-forbidden',
+    unreachable: 'agent-unreachable',
+    overloaded: 'segment-read-failed',
+    failed: 'segment-read-failed',
+};
+function toReadFailure(error) {
+    if (!(error instanceof errors_1.SegmentReadError))
+        return { reason: 'segment-read-failed' };
+    const { failure, httpStatus } = error;
+    const reason = READ_FAILURE_REASONS[failure];
+    return httpStatus === undefined ? { reason } : { reason, httpStatus };
+}
+// Some agents refuse an undeclared operator with a plain failure rather than a refusal, so any
+// `failed` read may be one. An unreachable or overloaded agent rules it out, and padding then would
+// evaluate the segment again on top of the read the agent may still be running; a forbidden read
+// would refuse the padded one just the same.
+function mayBeOperatorRefusal(error) {
+    return !(error instanceof errors_1.SegmentReadError) || error.failure === 'failed';
+}
+// An agent rejects a sort on a field it does not know with a 4xx, and one on a relation the service
+// account cannot read with a refusal. Anything else says nothing about the sort, and a segment that
+// timed out its database would only be evaluated twice.
+function mayBeSortRefusal(error) {
+    if (!(error instanceof errors_1.SegmentReadError))
+        return false;
+    if (error.failure === 'forbidden')
+        return true;
+    return (error.failure === 'failed' &&
+        error.httpStatus !== undefined &&
+        error.httpStatus >= 400 &&
+        error.httpStatus < 500);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhZC1mYWlsdXJlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2F1dG9tYXRpb24vcmVhZC1mYWlsdXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBWUEsc0NBT0M7QUFNRCxvREFFQztBQUtELDRDQVVDO0FBdkNELHNDQUE2QztBQUU3QyxNQUFNLG9CQUFvQixHQUE2RDtJQUNyRixTQUFTLEVBQUUsaUJBQWlCO0lBQzVCLFdBQVcsRUFBRSxtQkFBbUI7SUFDaEMsVUFBVSxFQUFFLHFCQUFxQjtJQUNqQyxNQUFNLEVBQUUscUJBQXFCO0NBQzlCLENBQUM7QUFFRixTQUFnQixhQUFhLENBQUMsS0FBYztJQUMxQyxJQUFJLENBQUMsQ0FBQyxLQUFLLFlBQVkseUJBQWdCLENBQUM7UUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLHFCQUFxQixFQUFFLENBQUM7SUFFbkYsTUFBTSxFQUFFLE9BQU8sRUFBRSxVQUFVLEVBQUUsR0FBRyxLQUFLLENBQUM7SUFDdEMsTUFBTSxNQUFNLEdBQUcsb0JBQW9CLENBQUMsT0FBTyxDQUFDLENBQUM7SUFFN0MsT0FBTyxVQUFVLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsQ0FBQztBQUN4RSxDQUFDO0FBRUQsK0ZBQStGO0FBQy9GLG9HQUFvRztBQUNwRyxpR0FBaUc7QUFDakcsNkNBQTZDO0FBQzdDLFNBQWdCLG9CQUFvQixDQUFDLEtBQWM7SUFDakQsT0FBTyxDQUFDLENBQUMsS0FBSyxZQUFZLHlCQUFnQixDQUFDLElBQUksS0FBSyxDQUFDLE9BQU8sS0FBSyxRQUFRLENBQUM7QUFDNUUsQ0FBQztBQUVELG9HQUFvRztBQUNwRyxvR0FBb0c7QUFDcEcsd0RBQXdEO0FBQ3hELFNBQWdCLGdCQUFnQixDQUFDLEtBQWM7SUFDN0MsSUFBSSxDQUFDLENBQUMsS0FBSyxZQUFZLHlCQUFnQixDQUFDO1FBQUUsT0FBTyxLQUFLLENBQUM7SUFDdkQsSUFBSSxLQUFLLENBQUMsT0FBTyxLQUFLLFdBQVc7UUFBRSxPQUFPLElBQUksQ0FBQztJQUUvQyxPQUFPLENBQ0wsS0FBSyxDQUFDLE9BQU8sS0FBSyxRQUFRO1FBQzFCLEtBQUssQ0FBQyxVQUFVLEtBQUssU0FBUztRQUM5QixLQUFLLENBQUMsVUFBVSxJQUFJLEdBQUc7UUFDdkIsS0FBSyxDQUFDLFVBQVUsR0FBRyxHQUFHLENBQ3ZCLENBQUM7QUFDSixDQUFDIn0=

package/dist/automation/reconciliation.d.ts

@@ -0,0 +1,13 @@
+import type { InboxAssignment } from '../types/automation';
+export declare const MEMBERSHIP_CHUNK_SIZE = 50;
+export declare const MAX_PADDED_PAGES = 5;
+export declare function withUnknownState(assignments: InboxAssignment[]): InboxAssignment[];
+export declare function reconcilable(assignments: InboxAssignment[]): InboxAssignment[];
+export declare function withUnexpectedRunState(assignments: InboxAssignment[]): InboxAssignment[];
+export declare function recordsToCheck(assignments: InboxAssignment[], reconcilableAssignments: InboxAssignment[]): string[];
+export declare function isReadableRecordId(recordId: string, primaryKeys: string[]): boolean;
+export declare function knownRecordIds(assignments: InboxAssignment[]): string[];
+export declare function paddedPageSize(maxConcurrentRuns: number, knownRecordCount: number): number;
+export declare function newCandidates(page: string[], known: ReadonlySet<string>, found: ReadonlySet<string>, room: number): string[];
+export declare function chunk<T>(items: T[], size: number): T[][];
+//# sourceMappingURL=reconciliation.d.ts.map

package/dist/automation/reconciliation.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_PADDED_PAGES = exports.MEMBERSHIP_CHUNK_SIZE = void 0;
+exports.withUnknownState = withUnknownState;
+exports.reconcilable = reconcilable;
+exports.withUnexpectedRunState = withUnexpectedRunState;
+exports.recordsToCheck = recordsToCheck;
+exports.isReadableRecordId = isReadableRecordId;
+exports.knownRecordIds = knownRecordIds;
+exports.paddedPageSize = paddedPageSize;
+exports.newCandidates = newCandidates;
+exports.chunk = chunk;
+const record_id_1 = require("../record-id");
+// One membership question per chunk, small enough that a `pk In (...)` stays a query an agent will
+// accept whatever its datasource.
+exports.MEMBERSHIP_CHUNK_SIZE = 50;
+// Ceiling on the padded fallback page. The padding grows with the backlog while the agent read is
+// bounded by the client's ten-second timeout, so past some size the page stops being served at all —
+// worse than a partial page that finds fewer candidates.
+const MAX_CANDIDATE_PAGE_SIZE = 500;
+// Records waiting on a person stay known for as long as nobody handles them, so one padded page can
+// hold nothing but them. Bounds the reads a sweep makes on the customer's agent to walk past them.
+exports.MAX_PADDED_PAGES = 5;
+const RECONCILABLE_ASSIGNMENT_STATES = new Set([
+    'done',
+    'canceled',
+    'auto-canceled',
+]);
+const TERMINAL_RUN_STATES = new Set(['finished', 'aborted']);
+const LIVE_RUN_STATES = new Set(['started', 'pending', 'loading']);
+const OPEN_ASSIGNMENT_STATES = new Set(['todo', 'doing']);
+const isTerminalRun = (runState) => runState != null && TERMINAL_RUN_STATES.has(runState);
+const isLiveRun = (runState) => runState != null && LIVE_RUN_STATES.has(runState);
+function withUnknownState(assignments) {
+    return assignments.filter(({ state }) => !RECONCILABLE_ASSIGNMENT_STATES.has(state) && !OPEN_ASSIGNMENT_STATES.has(state));
+}
+// The orchestrator keeps the row of an ended run `doing` while its record is still in the
+// segment, so that record is only released once it is seen leaving. An assignment with no
+// workflowRunId was made by a person, not the orchestrator, which binds the run first: there is
+// nothing to reconcile, so it stays out of the report — the record stays known, and no automated
+// run is ever started over the human's work. Keyed on the run's presence, not its state: the
+// orchestrator binds a run before an automated assignment and its `runState` is NOT NULL, so a
+// bound run with a null state is a contract break, not a human assignment — it belongs here so
+// `withUnexpectedRunState` surfaces it instead of dropping it silently.
+function reconcilable(assignments) {
+    return assignments.filter(({ state, runState, workflowRunId }) => workflowRunId != null &&
+        (RECONCILABLE_ASSIGNMENT_STATES.has(state) || (state === 'doing' && isTerminalRun(runState))));
+}
+// A run state this executor cannot place: a non-null one it predates, or null on a bound run —
+// which the orchestrator's schema (NOT NULL runState behind a cascading FK) should never emit, so
+// it is a contract break worth surfacing until a fix lands. The human assignment never reaches
+// here — it has no workflowRunId, so warning forever would be noise it could never resolve.
+function withUnexpectedRunState(assignments) {
+    return assignments.filter(({ runState }) => !isTerminalRun(runState) && !isLiveRun(runState));
+}
+// A record whose run is still going is not judged yet, whatever its assignments say. Judged per
+// record rather than per assignment: nothing in the contract says a record holds only one, and one
+// terminal assignment must not speak for a sibling whose run is still alive.
+function recordsToCheck(assignments, reconcilableAssignments) {
+    const liveRecords = new Set(assignments.filter(({ runState }) => !isTerminalRun(runState)).map(a => a.recordId));
+    return [
+        ...new Set(reconcilableAssignments
+            .filter(({ recordId }) => !liveRecords.has(recordId))
+            .map(({ recordId }) => recordId)),
+    ];
+}
+// A packed id that does not split into as many parts as the key has columns cannot be asked about —
+// the agent has the same limitation in `IdUtils.packId`.
+function isReadableRecordId(recordId, primaryKeys) {
+    return primaryKeys.length === 1 || (0, record_id_1.deserializeRecordId)(recordId).length === primaryKeys.length;
+}
+function knownRecordIds(assignments) {
+    return [...new Set(assignments.map(({ recordId }) => recordId))];
+}
+function paddedPageSize(maxConcurrentRuns, knownRecordCount) {
+    return Math.min(maxConcurrentRuns + knownRecordCount, MAX_CANDIDATE_PAGE_SIZE);
+}
+function newCandidates(page, known, found, room) {
+    return page.filter(recordId => !known.has(recordId) && !found.has(recordId)).slice(0, room);
+}
+function chunk(items, size) {
+    const chunks = [];
+    for (let index = 0; index < items.length; index += size) {
+        chunks.push(items.slice(index, index + size));
+    }
+    return chunks;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjb25jaWxpYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXV0b21hdGlvbi9yZWNvbmNpbGlhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFtQ0EsNENBSUM7QUFVRCxvQ0FNQztBQU1ELHdEQUVDO0FBS0Qsd0NBZUM7QUFJRCxnREFFQztBQUVELHdDQUVDO0FBRUQsd0NBRUM7QUFFRCxzQ0FPQztBQUVELHNCQVFDO0FBbEhELDRDQUFtRDtBQUVuRCxtR0FBbUc7QUFDbkcsa0NBQWtDO0FBQ3JCLFFBQUEscUJBQXFCLEdBQUcsRUFBRSxDQUFDO0FBRXhDLGtHQUFrRztBQUNsRyxxR0FBcUc7QUFDckcseURBQXlEO0FBQ3pELE1BQU0sdUJBQXVCLEdBQUcsR0FBRyxDQUFDO0FBRXBDLG9HQUFvRztBQUNwRyxtR0FBbUc7QUFDdEYsUUFBQSxnQkFBZ0IsR0FBRyxDQUFDLENBQUM7QUFFbEMsTUFBTSw4QkFBOEIsR0FBd0IsSUFBSSxHQUFHLENBQUM7SUFDbEUsTUFBTTtJQUNOLFVBQVU7SUFDVixlQUFlO0NBQ2hCLENBQUMsQ0FBQztBQUVILE1BQU0sbUJBQW1CLEdBQXdCLElBQUksR0FBRyxDQUFDLENBQUMsVUFBVSxFQUFFLFNBQVMsQ0FBQyxDQUFDLENBQUM7QUFFbEYsTUFBTSxlQUFlLEdBQXdCLElBQUksR0FBRyxDQUFDLENBQUMsU0FBUyxFQUFFLFNBQVMsRUFBRSxTQUFTLENBQUMsQ0FBQyxDQUFDO0FBRXhGLE1BQU0sc0JBQXNCLEdBQXdCLElBQUksR0FBRyxDQUFDLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUM7QUFFL0UsTUFBTSxhQUFhLEdBQUcsQ0FBQyxRQUFtQyxFQUFXLEVBQUUsQ0FDckUsUUFBUSxJQUFJLElBQUksSUFBSSxtQkFBbUIsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUM7QUFFeEQsTUFBTSxTQUFTLEdBQUcsQ0FBQyxRQUFtQyxFQUFXLEVBQUUsQ0FDakUsUUFBUSxJQUFJLElBQUksSUFBSSxlQUFlLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO0FBRXBELFNBQWdCLGdCQUFnQixDQUFDLFdBQThCO0lBQzdELE9BQU8sV0FBVyxDQUFDLE1BQU0sQ0FDdkIsQ0FBQyxFQUFFLEtBQUssRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFDLDhCQUE4QixDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLHNCQUFzQixDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FDaEcsQ0FBQztBQUNKLENBQUM7QUFFRCwwRkFBMEY7QUFDMUYsMEZBQTBGO0FBQzFGLGdHQUFnRztBQUNoRyxpR0FBaUc7QUFDakcsNkZBQTZGO0FBQzdGLCtGQUErRjtBQUMvRiwrRkFBK0Y7QUFDL0Ysd0VBQXdFO0FBQ3hFLFNBQWdCLFlBQVksQ0FBQyxXQUE4QjtJQUN6RCxPQUFPLFdBQVcsQ0FBQyxNQUFNLENBQ3ZCLENBQUMsRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLGFBQWEsRUFBRSxFQUFFLEVBQUUsQ0FDckMsYUFBYSxJQUFJLElBQUk7UUFDckIsQ0FBQyw4QkFBOEIsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxLQUFLLEtBQUssT0FBTyxJQUFJLGFBQWEsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQ2hHLENBQUM7QUFDSixDQUFDO0FBRUQsK0ZBQStGO0FBQy9GLGtHQUFrRztBQUNsRywrRkFBK0Y7QUFDL0YsNEZBQTRGO0FBQzVGLFNBQWdCLHNCQUFzQixDQUFDLFdBQThCO0lBQ25FLE9BQU8sV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEVBQUUsUUFBUSxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7QUFDaEcsQ0FBQztBQUVELGdHQUFnRztBQUNoRyxtR0FBbUc7QUFDbkcsNkVBQTZFO0FBQzdFLFNBQWdCLGNBQWMsQ0FDNUIsV0FBOEIsRUFDOUIsdUJBQTBDO0lBRTFDLE1BQU0sV0FBVyxHQUFHLElBQUksR0FBRyxDQUN6QixXQUFXLENBQUMsTUFBTSxDQUFDLENBQUMsRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLENBQ3BGLENBQUM7SUFFRixPQUFPO1FBQ0wsR0FBRyxJQUFJLEdBQUcsQ0FDUix1QkFBdUI7YUFDcEIsTUFBTSxDQUFDLENBQUMsRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO2FBQ3BELEdBQUcsQ0FBQyxDQUFDLEVBQUUsUUFBUSxFQUFFLEVBQUUsRUFBRSxDQUFDLFFBQVEsQ0FBQyxDQUNuQztLQUNGLENBQUM7QUFDSixDQUFDO0FBRUQsb0dBQW9HO0FBQ3BHLHlEQUF5RDtBQUN6RCxTQUFnQixrQkFBa0IsQ0FBQyxRQUFnQixFQUFFLFdBQXFCO0lBQ3hFLE9BQU8sV0FBVyxDQUFDLE1BQU0sS0FBSyxDQUFDLElBQUksSUFBQSwrQkFBbUIsRUFBQyxRQUFRLENBQUMsQ0FBQyxNQUFNLEtBQUssV0FBVyxDQUFDLE1BQU0sQ0FBQztBQUNqRyxDQUFDO0FBRUQsU0FBZ0IsY0FBYyxDQUFDLFdBQThCO0lBQzNELE9BQU8sQ0FBQyxHQUFHLElBQUksR0FBRyxDQUFDLFdBQVcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLFFBQVEsRUFBRSxFQUFFLEVBQUUsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDbkUsQ0FBQztBQUVELFNBQWdCLGNBQWMsQ0FBQyxpQkFBeUIsRUFBRSxnQkFBd0I7SUFDaEYsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLGlCQUFpQixHQUFHLGdCQUFnQixFQUFFLHVCQUF1QixDQUFDLENBQUM7QUFDakYsQ0FBQztBQUVELFNBQWdCLGFBQWEsQ0FDM0IsSUFBYyxFQUNkLEtBQTBCLEVBQzFCLEtBQTBCLEVBQzFCLElBQVk7SUFFWixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxJQUFJLENBQUMsQ0FBQztBQUM5RixDQUFDO0FBRUQsU0FBZ0IsS0FBSyxDQUFJLEtBQVUsRUFBRSxJQUFZO0lBQy9DLE1BQU0sTUFBTSxHQUFVLEVBQUUsQ0FBQztJQUV6QixLQUFLLElBQUksS0FBSyxHQUFHLENBQUMsRUFBRSxLQUFLLEdBQUcsS0FBSyxDQUFDLE1BQU0sRUFBRSxLQUFLLElBQUksSUFBSSxFQUFFLENBQUM7UUFDeEQsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLEtBQUssRUFBRSxLQUFLLEdBQUcsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUNoRCxDQUFDO0lBRUQsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQyJ9

package/dist/build-workflow-executor.d.ts

@@ -10,6 +10,8 @@ export interface WorkflowExecutor {
 export interface WorkflowExecutorTuningOptions {
     /** Interval in seconds at which the executor polls the orchestrator for pending steps. */
     pollingIntervalS?: number;
+    /** Interval in seconds at which automated inboxes are swept. Defaults to 300. */
+    automationPollingIntervalS?: number;
     /** Per-step execution timeout in seconds. */
     stepTimeoutS?: number;
     /** Max duration in seconds of a single AI provider invocation. */