@zhin.js/agent 1.1.31 → 1.1.32

package/lib/workroom/kernel-state.js

@@ -1,885 +0,0 @@
-import { assertAcceptanceContract, assertPinnedAcceptanceContract } from './acceptance-policy.js';
-import { assertReviewerVerdictBindings, assertWaitBinding, reviewerVerdictRequiresRework, } from './acceptance-control.js';
-import { replayWorkroomPreemptions } from './workroom-preemption.js';
-const TERMINAL_TASKS = new Set(['accepted', 'failed', 'cancelled']);
-const ACTIVE_ASSIGNMENTS = new Set(['leased', 'running', 'cancel_requested']);
-export function replayWorkroom(events) {
-    const first = events[0];
-    if (!first || first.type !== 'run.created' || first.sequence !== 0) {
-        throw new Error('Workroom journal must begin with run.created at sequence 0');
-    }
-    let state = {
-        runId: first.runId,
-        projectId: String(first.payload.projectId ?? ''),
-        title: String(first.payload.title ?? ''),
-        status: 'active',
-        sequence: -1,
-        now: first.occurredAt,
-        cancelRequested: false,
-        replanRequested: false,
-        tasks: {},
-        assignments: {},
-        reviewerAssignments: {},
-        sponsorGates: {},
-    };
-    for (const event of events) {
-        if (event.runId !== state.runId)
-            throw new Error('Workroom journal contains another run');
-        if (event.sequence !== state.sequence + 1)
-            throw new Error('Workroom journal sequence is not contiguous');
-        if (event.type === 'run.control_decided')
-            validateRunControlSuccessor(events, event);
-        state = evolveWorkroom(state, event);
-    }
-    replayWorkroomPreemptions(events);
-    return deriveRunStatus(state);
-}
-function validateRunControlSuccessor(events, audit) {
-    const next = events[audit.sequence + 1];
-    const expectedSequence = Number(audit.payload.expectedSequence);
-    if (!Number.isSafeInteger(expectedSequence) || expectedSequence !== audit.sequence - 1) {
-        throw new Error('Persisted Workroom Run control expectedSequence is not exact');
-    }
-    if (audit.payload.action === 'request_replan') {
-        if (!next || next.type !== 'run.replan_requested'
-            || next.payload.operationId !== audit.payload.operationId
-            || next.payload.reasonCode !== audit.payload.reasonCode
-            || next.payload.requestDigest !== audit.payload.requestDigest) {
-            throw new Error('Persisted Workroom replan request is not bound to its control audit');
-        }
-        return;
-    }
-    if (audit.payload.action !== 'cancel' || !next || next.type !== 'run.cancel_requested'
-        || next.payload.reason !== audit.payload.reasonCode) {
-        throw new Error('Persisted Workroom cancellation is not bound to its control audit');
-    }
-}
-export function decideWorkroom(state, command, event) {
-    if (state.status === 'completed' || state.status === 'cancelled') {
-        throw new Error(`Workroom run is terminal: ${state.status}`);
-    }
-    switch (command.type) {
-        case 'plan_task':
-            if (state.cancelRequested)
-                throw new Error('Cannot plan while run cancellation is active');
-            if (state.tasks[command.taskKey])
-                throw new Error(`Task ${command.taskKey} already exists`);
-            if (!Number.isInteger(command.maxAttempts) || command.maxAttempts < 1) {
-                throw new Error('Task maxAttempts must be a positive integer');
-            }
-            return [event('task.planned', { ...command })];
-        case 'block_task': {
-            const task = requireTask(state, command.taskKey, ['ready']);
-            return [event('task.blocked', { ...command, taskKey: task.key })];
-        }
-        case 'resolve_blocker': {
-            const task = requireTask(state, command.taskKey, ['blocked']);
-            const blocker = task.blockers.find(item => item.id === command.blockerId);
-            if (!blocker) {
-                throw new Error(`Blocker ${command.blockerId} not found`);
-            }
-            if (blocker.kind === 'approval') {
-                throw new Error('Approval Blocker requires a typed Sponsor authority decision');
-            }
-            return [event('task.blocker_resolved', { ...command })];
-        }
-        case 'claim_task': {
-            const task = requireTask(state, command.taskKey, ['ready']);
-            if (!task.acceptanceContract)
-                throw new Error(`Task ${task.key} Acceptance Contract is not pinned`);
-            if (state.assignments[command.assignmentId])
-                throw new Error('Assignment already exists');
-            if (!Number.isSafeInteger(command.assignmentRevision) || command.assignmentRevision < 1) {
-                throw new Error('Assignment revision must be a positive safe integer');
-            }
-            if (!Number.isSafeInteger(command.fence) || command.fence < 1) {
-                throw new Error('Assignment fence must be a positive safe integer');
-            }
-            const priorFence = Object.values(state.assignments)
-                .filter(assignment => assignment.taskKey === task.key)
-                .reduce((highest, assignment) => Math.max(highest, assignment.fence), 0);
-            if (command.fence <= priorFence) {
-                throw new Error('Assignment fence must advance beyond every prior Task Assignment');
-            }
-            if (!/^sha256:[a-f0-9]{64}$/u.test(command.envelopeDigest)) {
-                throw new Error('Assignment Envelope digest must be a canonical sha256 digest');
-            }
-            return [event('assignment.claimed', {
-                    ...command,
-                    taskRevision: task.revision,
-                    attempt: task.attempt + 1,
-                })];
-        }
-        case 'start_assignment':
-            requireAssignment(state, command.assignmentId, ['leased']);
-            return [event('assignment.started', { assignmentId: command.assignmentId })];
-        case 'request_rework':
-            requireTask(state, command.taskKey, ['awaiting_acceptance']);
-            return [event('task.rework_requested', { ...command })];
-        case 'revise_task': {
-            requireTask(state, command.taskKey, ['failed']);
-            if (!Number.isInteger(command.maxAttempts) || command.maxAttempts < 1) {
-                throw new Error('Task maxAttempts must be a positive integer');
-            }
-            return [event('task.revised', { ...command })];
-        }
-        case 'cancel_run': {
-            if (state.cancelRequested)
-                return [];
-            const events = [event('run.cancel_requested', { reason: command.reason })];
-            let waiting = 0;
-            for (const task of Object.values(state.tasks)) {
-                if (TERMINAL_TASKS.has(task.status))
-                    continue;
-                events.push(event('task.cancel_requested', { taskKey: task.key, reason: command.reason }));
-                const assignment = task.currentAssignmentId
-                    ? state.assignments[task.currentAssignmentId]
-                    : undefined;
-                if (assignment && ACTIVE_ASSIGNMENTS.has(assignment.status)) {
-                    waiting += 1;
-                    events.push(event('assignment.cancel_requested', {
-                        assignmentId: assignment.id,
-                        controlDeadline: command.controlDeadline,
-                    }));
-                }
-                else {
-                    events.push(event('task.cancelled', { taskKey: task.key, reason: command.reason }));
-                }
-            }
-            if (waiting === 0)
-                events.push(event('run.cancelled', { reason: command.reason }));
-            return events;
-        }
-        case 'advance_clock':
-            if (!Number.isFinite(command.now) || command.now <= state.now)
-                throw new Error('Clock must advance');
-            return decideClock(state, command.now, event);
-    }
-}
-export function evolveWorkroom(state, event) {
-    let tasks = state.tasks;
-    let assignments = state.assignments;
-    let reviewerAssignments = state.reviewerAssignments;
-    let sponsorGates = state.sponsorGates;
-    let cancelRequested = state.cancelRequested;
-    let replanRequested = state.replanRequested === true;
-    let status = state.status;
-    const payload = event.payload;
-    switch (event.type) {
-        case 'run.created': break;
-        case 'plan.admitted': break;
-        case 'plan.revision_applied':
-            replanRequested = false;
-            break;
-        case 'plan_gate.decided': {
-            const task = requireTask(state, String(payload.taskKey));
-            const gate = task.blockers.find(blocker => blocker.id === payload.gateId && blocker.kind === 'approval');
-            if (task.revision !== payload.taskRevision || !gate) {
-                throw new Error('Plan Sponsor Gate decision targets an absent or stale gate');
-            }
-            const now = Math.max(state.now, event.occurredAt);
-            if (!Number.isFinite(now) || !Number.isFinite(gate.deadline) || gate.deadline <= now) {
-                throw new Error('Plan Sponsor Gate deadline has expired');
-            }
-            break;
-        }
-        case 'run.control_decided': break;
-        case 'run.replan_requested':
-            replanRequested = true;
-            status = 'needs_replan';
-            break;
-        case 'local_execution.requested': break;
-        case 'remote_dispatch.requested': break;
-        case 'scheduler.dispatch_requested': break;
-        case 'scheduler.priority_changed': {
-            const now = Math.max(state.now, event.occurredAt);
-            if (!Number.isFinite(now) || typeof payload.deadline !== 'number'
-                || !Number.isFinite(payload.deadline) || payload.deadline <= now) {
-                throw new Error('Workroom priority proposal is expired');
-            }
-            break;
-        }
-        case 'scheduler.preemption_requested': break;
-        case 'scheduler.preemption_checkpoint_acknowledged': break;
-        case 'scheduler.preemption_timed_out': break;
-        case 'assignment.checkpoint_requested': break;
-        case 'run.cancel_requested':
-            cancelRequested = true;
-            status = 'cancelling';
-            break;
-        case 'run.cancelled':
-            status = 'cancelled';
-            break;
-        case 'task.planned': {
-            const key = String(payload.taskKey);
-            tasks = { ...tasks, [key]: {
-                    key,
-                    title: String(payload.title),
-                    status: 'ready',
-                    revision: 1,
-                    attempt: 0,
-                    maxAttempts: Number(payload.maxAttempts),
-                    required: payload.required === true,
-                    blockers: [],
-                } };
-            break;
-        }
-        case 'task.blocked': {
-            const task = requireTask(state, String(payload.taskKey));
-            tasks = replaceTask(tasks, task.key, {
-                ...task,
-                status: 'blocked',
-                blockers: [...task.blockers, {
-                        id: String(payload.blockerId),
-                        kind: payload.kind,
-                        owner: String(payload.owner),
-                        reason: String(payload.reason),
-                        deadline: Number(payload.deadline),
-                        allowedActions: ['resolve', 'replan', 'cancel'],
-                    }],
-            });
-            break;
-        }
-        case 'task.blocker_resolved': {
-            const task = requireTask(state, String(payload.taskKey));
-            const blockers = task.blockers.filter(blocker => blocker.id !== payload.blockerId);
-            tasks = replaceTask(tasks, task.key, { ...task, blockers, status: blockers.length ? 'blocked' : 'ready' });
-            break;
-        }
-        case 'assignment.claimed': {
-            const task = requireTask(state, String(payload.taskKey));
-            if (task.status !== 'ready'
-                || Number(payload.taskRevision) !== task.revision
-                || Number(payload.attempt) !== task.attempt + 1
-                || state.assignments[String(payload.assignmentId)]) {
-                throw new Error('Persisted Assignment claim is stale or targets another Task revision');
-            }
-            const priorFence = Object.values(state.assignments)
-                .filter(assignment => assignment.taskKey === task.key)
-                .reduce((highest, assignment) => Math.max(highest, assignment.fence), 0);
-            if (Number(payload.fence) <= priorFence) {
-                throw new Error('Persisted Assignment claim fence does not advance');
-            }
-            const assignment = {
-                id: String(payload.assignmentId),
-                taskKey: task.key,
-                taskRevision: Number(payload.taskRevision),
-                revision: Number(payload.assignmentRevision),
-                attempt: Number(payload.attempt),
-                fence: Number(payload.fence),
-                envelopeDigest: String(payload.envelopeDigest),
-                role: payload.role,
-                status: 'leased',
-                owner: String(payload.owner),
-                leaseExpiresAt: Number(payload.leaseExpiresAt),
-                observationDigests: {},
-            };
-            assignments = { ...assignments, [assignment.id]: assignment };
-            tasks = replaceTask(tasks, task.key, {
-                ...task,
-                status: 'executing',
-                attempt: assignment.attempt,
-                currentAssignmentId: assignment.id,
-            });
-            break;
-        }
-        case 'assignment.started':
-        case 'assignment.progress':
-        case 'assignment.heartbeat':
-        case 'assignment.checkpointed':
-        case 'assignment.preempted':
-        case 'assignment.execution_completed':
-        case 'assignment.cancel_requested':
-        case 'assignment.cancelled':
-        case 'assignment.lease_expired': {
-            const assignment = requireAssignment(state, String(payload.assignmentId));
-            const next = evolveAssignment(assignment, event);
-            assignments = { ...assignments, [assignment.id]: next };
-            const task = requireTask(state, assignment.taskKey);
-            tasks = replaceTask(tasks, task.key, evolveTaskFromAssignment(task, next, event));
-            break;
-        }
-        case 'task.accepted': {
-            const task = requireTask(state, String(payload.taskKey));
-            const record = payload.record;
-            if (!task.acceptanceContract)
-                throw new Error(`Task ${task.key} Acceptance Contract is not pinned`);
-            assertPinnedAcceptanceContract(record.contract, task.acceptanceContract);
-            assertAcceptanceRecordControlBindings(state, task, record);
-            ({ reviewerAssignments, sponsorGates } = settleAcceptanceWaits(task, reviewerAssignments, sponsorGates, 'satisfied'));
-            tasks = replaceTask(tasks, task.key, {
-                ...task,
-                status: 'accepted',
-                acceptanceRecord: record,
-                currentReviewerAssignmentId: undefined,
-                currentSponsorGateId: undefined,
-                acceptanceBlockReason: undefined,
-            });
-            break;
-        }
-        case 'task.acceptance_pinned': {
-            const task = requireTask(state, String(payload.taskKey));
-            if (task.status !== 'ready')
-                throw new Error(`Task ${task.key} is ${task.status}`);
-            if (task.acceptanceContract)
-                throw new Error(`Task ${task.key} Acceptance Contract is already pinned`);
-            const contract = payload.contract;
-            assertAcceptanceContract(contract, task.key, task.revision);
-            tasks = replaceTask(tasks, task.key, {
-                ...task,
-                acceptanceContract: contract,
-            });
-            break;
-        }
-        case 'task.acceptance_blocked': {
-            const task = requireTask(state, String(payload.taskKey));
-            tasks = replaceTask(tasks, task.key, {
-                ...task,
-                acceptanceBlockReason: String(payload.reason),
-            });
-            break;
-        }
-        case 'reviewer.assigned': {
-            const task = requireTask(state, String(payload.taskKey), ['awaiting_acceptance']);
-            const assignment = payload.assignment;
-            if (reviewerAssignments[assignment.id])
-                throw new Error(`Reviewer Assignment ${assignment.id} already exists`);
-            if (assignment.owner === assignment.producerPrincipalId) {
-                throw new Error('Producer and Reviewer Assignment owner must be different principals');
-            }
-            assertAcceptanceWaitBinding(task, assignment);
-            assertNoOpenAcceptanceWait(state, task);
-            reviewerAssignments = { ...reviewerAssignments, [assignment.id]: assignment };
-            tasks = replaceTask(tasks, task.key, {
-                ...task,
-                currentReviewerAssignmentId: assignment.id,
-                currentSponsorGateId: undefined,
-                acceptanceBlockReason: String(payload.reason),
-            });
-            break;
-        }
-        case 'reviewer.expired': {
-            const assignment = requireReviewerAssignment(state, String(payload.assignmentId), ['open', 'claimed']);
-            if (payload.taskKey !== assignment.taskKey)
-                throw new Error('Reviewer expiry targets another Task');
-            reviewerAssignments = {
-                ...reviewerAssignments,
-                [assignment.id]: { ...assignment, status: 'expired' },
-            };
-            const task = requireTask(state, assignment.taskKey, ['awaiting_acceptance']);
-            tasks = replaceTask(tasks, task.key, {
-                ...task,
-                acceptanceBlockReason: 'Reviewer deadline expired; reassign, replan or cancel',
-            });
-            break;
-        }
-        case 'reviewer.claimed': {
-            const assignment = requireReviewerAssignment(state, String(payload.assignmentId), ['open']);
-            if (payload.taskKey !== assignment.taskKey)
-                throw new Error('Reviewer claim targets another Task');
-            assertWaitBinding({ ...state, now: Math.max(state.now, event.occurredAt) }, assignment);
-            if (state.tasks[assignment.taskKey]?.currentReviewerAssignmentId !== assignment.id) {
-                throw new Error('Reviewer control is not the current Task target');
-            }
-            assertPersistedAcceptanceAuthorization(state, payload, {
-                action: 'claim_review', role: 'reviewer', principalKey: 'reviewerPrincipalId', targetId: assignment.id,
-            });
-            if (payload.reviewerPrincipalId === assignment.producerPrincipalId) {
-                throw new Error('Producer cannot review its own Candidate');
-            }
-            reviewerAssignments = {
-                ...reviewerAssignments,
-                [assignment.id]: {
-                    ...assignment,
-                    status: 'claimed',
-                    reviewerPrincipalId: String(payload.reviewerPrincipalId),
-                    authorizationRef: String(payload.authorizedBy),
-                },
-            };
-            break;
-        }
-        case 'reviewer.verdict_recorded': {
-            const assignment = requireReviewerAssignment(state, String(payload.assignmentId), ['claimed']);
-            if (payload.taskKey !== assignment.taskKey)
-                throw new Error('Reviewer verdict targets another Task');
-            assertWaitBinding({ ...state, now: Math.max(state.now, event.occurredAt) }, assignment);
-            if (state.tasks[assignment.taskKey]?.currentReviewerAssignmentId !== assignment.id) {
-                throw new Error('Reviewer control is not the current Task target');
-            }
-            assertPersistedAcceptanceAuthorization(state, payload, {
-                action: 'submit_review', role: 'reviewer', principalKey: 'reviewerPrincipalId', targetId: assignment.id,
-            });
-            if (payload.reviewerPrincipalId !== assignment.reviewerPrincipalId) {
-                throw new Error('Reviewer verdict principal does not match the claimed Assignment');
-            }
-            assertReviewerVerdictBindings(assignment.evaluation, payload.verdict);
-            const verdict = payload.verdict;
-            const expectedOutcome = reviewerVerdictRequiresRework(verdict) ? 'rework' : 'passed';
-            if (payload.outcome !== expectedOutcome) {
-                throw new Error('Reviewer verdict outcome does not match its criterion disposition');
-            }
-            reviewerAssignments = {
-                ...reviewerAssignments,
-                [assignment.id]: {
-                    ...assignment,
-                    status: payload.outcome === 'passed' ? 'passed' : 'rework',
-                    verdict: verdict,
-                },
-            };
-            break;
-        }
-        case 'sponsor_gate.opened': {
-            const task = requireTask(state, String(payload.taskKey), ['awaiting_acceptance']);
-            const gate = payload.gate;
-            if (sponsorGates[gate.id])
-                throw new Error(`Sponsor Gate ${gate.id} already exists`);
-            assertAcceptanceWaitBinding(task, gate);
-            assertNoOpenAcceptanceWait(state, task);
-            sponsorGates = { ...sponsorGates, [gate.id]: gate };
-            tasks = replaceTask(tasks, task.key, {
-                ...task,
-                currentReviewerAssignmentId: undefined,
-                currentSponsorGateId: gate.id,
-                acceptanceBlockReason: String(payload.reason),
-            });
-            break;
-        }
-        case 'sponsor_gate.expired': {
-            const gate = requireSponsorGate(state, String(payload.gateId), ['open']);
-            if (payload.taskKey !== gate.taskKey)
-                throw new Error('Sponsor Gate expiry targets another Task');
-            sponsorGates = { ...sponsorGates, [gate.id]: { ...gate, status: 'expired' } };
-            const task = requireTask(state, gate.taskKey, ['awaiting_acceptance']);
-            tasks = replaceTask(tasks, task.key, {
-                ...task,
-                acceptanceBlockReason: 'Sponsor Gate expired; reopen, rebase, replan or cancel',
-            });
-            break;
-        }
-        case 'sponsor_gate.decided': {
-            const gate = requireSponsorGate(state, String(payload.gateId), ['open']);
-            if (payload.taskKey !== gate.taskKey)
-                throw new Error('Sponsor decision targets another Task');
-            assertWaitBinding({ ...state, now: Math.max(state.now, event.occurredAt) }, gate);
-            if (state.tasks[gate.taskKey]?.currentSponsorGateId !== gate.id) {
-                throw new Error('Sponsor control is not the current Task target');
-            }
-            assertPersistedAcceptanceAuthorization(state, payload, {
-                action: 'decide_sponsor', role: 'sponsor', principalKey: 'sponsorPrincipalId', targetId: gate.id,
-            });
-            if (payload.candidateHash !== gate.candidateHash) {
-                throw new Error('Sponsor decision is stale for the current Candidate hash');
-            }
-            const decision = payload.decision;
-            if (!gate.allowedActions.includes(decision))
-                throw new Error(`Sponsor Gate does not allow ${decision}`);
-            sponsorGates = {
-                ...sponsorGates,
-                [gate.id]: {
-                    ...gate,
-                    status: decision === 'approve'
-                        ? 'approved'
-                        : decision === 'request_changes'
-                            ? 'changes_requested'
-                            : decision === 'reject' ? 'rejected' : 'cancelled',
-                    sponsorPrincipalId: String(payload.sponsorPrincipalId),
-                    authorizationRef: String(payload.authorizedBy),
-                    decisionReason: String(payload.reason),
-                },
-            };
-            break;
-        }
-        case 'task.rework_requested': {
-            const task = requireTask(state, String(payload.taskKey));
-            ({ reviewerAssignments, sponsorGates } = settleAcceptanceWaits(task, reviewerAssignments, sponsorGates, 'cancelled'));
-            tasks = replaceTask(tasks, task.key, {
-                ...task,
-                status: 'ready',
-                revision: task.revision + 1,
-                attempt: 0,
-                currentAssignmentId: undefined,
-                reportRef: undefined,
-                reportDigest: undefined,
-                candidateRef: undefined,
-                candidateHash: undefined,
-                completionReceiptDigest: undefined,
-                acceptanceContract: undefined,
-                acceptanceRecord: undefined,
-                currentReviewerAssignmentId: undefined,
-                currentSponsorGateId: undefined,
-                acceptanceBlockReason: undefined,
-                terminalReason: String(payload.reason),
-            });
-            break;
-        }
-        case 'task.revised': {
-            const task = requireTask(state, String(payload.taskKey));
-            tasks = replaceTask(tasks, task.key, {
-                ...task,
-                title: String(payload.title),
-                status: 'ready',
-                revision: task.revision + 1,
-                attempt: 0,
-                maxAttempts: Number(payload.maxAttempts),
-                currentAssignmentId: undefined,
-                reportRef: undefined,
-                reportDigest: undefined,
-                candidateRef: undefined,
-                candidateHash: undefined,
-                completionReceiptDigest: undefined,
-                acceptanceContract: undefined,
-                acceptanceRecord: undefined,
-                currentReviewerAssignmentId: undefined,
-                currentSponsorGateId: undefined,
-                acceptanceBlockReason: undefined,
-                terminalReason: String(payload.reason),
-            });
-            break;
-        }
-        case 'task.plan_revised': {
-            const task = requireTask(state, String(payload.taskKey));
-            if (task.revision !== Number(payload.expectedTaskRevision)
-                || Number(payload.newTaskRevision) !== task.revision + 1) {
-                throw new Error(`Task ${task.key} Plan Revision targets another revision`);
-            }
-            tasks = replaceTask(tasks, task.key, {
-                ...task,
-                title: String(payload.title),
-                required: payload.required === true,
-                status: 'ready',
-                revision: task.revision + 1,
-                attempt: 0,
-                maxAttempts: Number(payload.maxAttempts),
-                blockers: [],
-                currentAssignmentId: undefined,
-                reportRef: undefined,
-                reportDigest: undefined,
-                candidateRef: undefined,
-                candidateHash: undefined,
-                completionReceiptDigest: undefined,
-                acceptanceContract: undefined,
-                acceptanceRecord: undefined,
-                currentReviewerAssignmentId: undefined,
-                currentSponsorGateId: undefined,
-                acceptanceBlockReason: undefined,
-                terminalReason: String(payload.reason),
-            });
-            break;
-        }
-        case 'task.cancel_requested': {
-            const task = requireTask(state, String(payload.taskKey));
-            tasks = replaceTask(tasks, task.key, { ...task, status: 'cancelling' });
-            break;
-        }
-        case 'task.cancelled':
-        case 'task.failed': {
-            const task = requireTask(state, String(payload.taskKey));
-            ({ reviewerAssignments, sponsorGates } = settleAcceptanceWaits(task, reviewerAssignments, sponsorGates, 'cancelled'));
-            tasks = replaceTask(tasks, task.key, {
-                ...task,
-                status: event.type === 'task.cancelled' ? 'cancelled' : 'failed',
-                terminalReason: String(payload.reason ?? ''),
-            });
-            break;
-        }
-        case 'clock.advanced': break;
-    }
-    return deriveRunStatus({
-        ...state,
-        status,
-        sequence: event.sequence,
-        now: event.type === 'clock.advanced' ? Number(payload.now) : Math.max(state.now, event.occurredAt),
-        cancelRequested,
-        replanRequested,
-        tasks,
-        assignments,
-        reviewerAssignments,
-        sponsorGates,
-    });
-}
-function decideClock(state, now, event) {
-    const events = [event('clock.advanced', { now })];
-    const newlyTerminal = new Set();
-    for (const assignment of Object.values(state.assignments)) {
-        if (assignment.status === 'cancel_requested' && (assignment.controlDeadline ?? Infinity) <= now) {
-            events.push(event('assignment.cancelled', { assignmentId: assignment.id, outcome: 'outcome_unknown' }));
-            events.push(event('task.cancelled', { taskKey: assignment.taskKey, reason: 'control deadline expired' }));
-            newlyTerminal.add(assignment.taskKey);
-        }
-        else if ((assignment.status === 'leased' || assignment.status === 'running')
-            && assignment.leaseExpiresAt <= now) {
-            const task = state.tasks[assignment.taskKey];
-            events.push(event('assignment.lease_expired', { assignmentId: assignment.id }));
-            if (assignment.attempt >= task.maxAttempts) {
-                events.push(event('task.failed', { taskKey: task.key, reason: 'assignment attempts exhausted' }));
-                newlyTerminal.add(task.key);
-            }
-        }
-    }
-    for (const assignment of Object.values(state.reviewerAssignments)) {
-        if ((assignment.status === 'open' || assignment.status === 'claimed') && assignment.deadline <= now) {
-            events.push(event('reviewer.expired', {
-                taskKey: assignment.taskKey,
-                assignmentId: assignment.id,
-            }));
-        }
-    }
-    for (const gate of Object.values(state.sponsorGates)) {
-        if (gate.status === 'open' && gate.deadline <= now) {
-            events.push(event('sponsor_gate.expired', { taskKey: gate.taskKey, gateId: gate.id }));
-        }
-    }
-    if (state.cancelRequested && Object.values(state.tasks).every(task => TERMINAL_TASKS.has(task.status) || newlyTerminal.has(task.key))) {
-        events.push(event('run.cancelled', { reason: 'all task cancellation controls settled' }));
-    }
-    return events;
-}
-function evolveAssignment(assignment, event) {
-    switch (event.type) {
-        case 'assignment.started': return { ...assignment, status: 'running' };
-        case 'assignment.progress':
-            requireAssignmentStatusForReplay(assignment, ['running'], event.type);
-            return withObservation(assignment, event, {
-                latestProgress: event.payload.progress,
-            });
-        case 'assignment.heartbeat':
-            requireAssignmentStatusForReplay(assignment, ['leased', 'running'], event.type);
-            return withObservation(assignment, event, {
-                leaseExpiresAt: Number(event.payload.leaseExpiresAt),
-            });
-        case 'assignment.checkpointed':
-            requireAssignmentStatusForReplay(assignment, ['running'], event.type);
-            return withObservation(assignment, event, {
-                checkpointRef: String(event.payload.checkpointRef),
-                checkpointDigest: String(event.payload.checkpointDigest),
-            });
-        case 'assignment.preempted':
-            requireAssignmentStatusForReplay(assignment, ['running'], event.type);
-            if (assignment.checkpointRef !== event.payload.checkpointRef
-                || assignment.checkpointDigest !== event.payload.checkpointDigest) {
-                throw new Error('Persisted Assignment preemption is not bound to its checkpoint');
-            }
-            return { ...assignment, status: 'cancelled', outcome: 'interrupted' };
-        case 'assignment.execution_completed':
-            requireAssignmentStatusForReplay(assignment, ['running'], event.type);
-            return {
-                ...withObservation(assignment, event),
-                status: 'execution_completed',
-                reportRef: String(event.payload.reportRef),
-                reportDigest: String(event.payload.reportDigest),
-                candidateRef: String(event.payload.candidateRef),
-                candidateHash: String(event.payload.candidateHash),
-                completionReceiptDigest: event.payload.completionReceiptDigest === undefined
-                    ? undefined
-                    : String(event.payload.completionReceiptDigest),
-            };
-        case 'assignment.cancel_requested': return {
-            ...assignment,
-            status: 'cancel_requested',
-            controlDeadline: Number(event.payload.controlDeadline),
-        };
-        case 'assignment.cancelled': return {
-            ...assignment,
-            status: 'cancelled',
-            outcome: event.payload.outcome,
-        };
-        case 'assignment.lease_expired': return { ...assignment, status: 'lost', outcome: 'outcome_unknown' };
-        default: return assignment;
-    }
-}
-function evolveTaskFromAssignment(task, assignment, event) {
-    if (event.type === 'assignment.execution_completed') {
-        return {
-            ...task,
-            status: 'awaiting_acceptance',
-            reportRef: assignment.reportRef,
-            reportDigest: assignment.reportDigest,
-            candidateRef: assignment.candidateRef,
-            candidateHash: assignment.candidateHash,
-            completionReceiptDigest: assignment.completionReceiptDigest,
-        };
-    }
-    if (event.type === 'assignment.cancel_requested')
-        return { ...task, status: 'cancelling' };
-    if (event.type === 'assignment.preempted') {
-        return { ...task, status: 'ready', currentAssignmentId: undefined };
-    }
-    if (event.type === 'assignment.cancelled')
-        return { ...task, status: 'cancelled' };
-    if (event.type === 'assignment.lease_expired') {
-        return task.attempt >= task.maxAttempts
-            ? { ...task, status: 'failed', terminalReason: 'assignment attempts exhausted' }
-            : { ...task, status: 'ready', currentAssignmentId: undefined };
-    }
-    return task;
-}
-function withObservation(assignment, event, patch = {}) {
-    if (event.payload.envelopeDigest !== assignment.envelopeDigest) {
-        throw new Error('Persisted Assignment observation targets another Envelope');
-    }
-    const observationId = String(event.payload.observationId);
-    const observationDigest = String(event.payload.observationDigest);
-    if (assignment.observationDigests[observationId]) {
-        throw new Error(`Persisted Assignment observationId is duplicated: ${observationId}`);
-    }
-    return {
-        ...assignment,
-        ...patch,
-        observationDigests: {
-            ...assignment.observationDigests,
-            [observationId]: observationDigest,
-        },
-    };
-}
-function requireAssignmentStatusForReplay(assignment, allowed, eventType) {
-    if (!allowed.includes(assignment.status)) {
-        throw new Error(`Persisted ${eventType} is invalid while Assignment is ${assignment.status}`);
-    }
-}
-function deriveRunStatus(state) {
-    if (state.status === 'cancelled')
-        return state;
-    const tasks = Object.values(state.tasks);
-    if (state.cancelRequested)
-        return { ...state, status: 'cancelling' };
-    if (state.replanRequested)
-        return { ...state, status: 'needs_replan' };
-    if (tasks.length > 0 && tasks.every(task => task.status === 'accepted' || (!task.required && TERMINAL_TASKS.has(task.status)))) {
-        return { ...state, status: 'completed' };
-    }
-    if (tasks.some(task => task.required && (task.status === 'failed' || task.status === 'cancelled'))) {
-        return { ...state, status: 'needs_replan' };
-    }
-    if (tasks.some(task => (task.currentReviewerAssignmentId
-        && state.reviewerAssignments[task.currentReviewerAssignmentId]?.status === 'expired')
-        || (task.currentSponsorGateId
-            && state.sponsorGates[task.currentSponsorGateId]?.status === 'expired'))) {
-        return { ...state, status: 'blocked' };
-    }
-    if (tasks.some(task => task.status === 'blocked'))
-        return { ...state, status: 'blocked' };
-    return { ...state, status: 'active' };
-}
-function replaceTask(tasks, key, task) {
-    return { ...tasks, [key]: task };
-}
-function requireTask(state, key, statuses) {
-    const task = state.tasks[key];
-    if (!task)
-        throw new Error(`Task ${key} not found`);
-    if (statuses && !statuses.includes(task.status))
-        throw new Error(`Task ${key} is ${task.status}`);
-    return task;
-}
-function requireAssignment(state, id, statuses) {
-    const assignment = state.assignments[id];
-    if (!assignment)
-        throw new Error(`Assignment ${id} not found`);
-    if (statuses && !statuses.includes(assignment.status))
-        throw new Error(`Assignment ${id} is ${assignment.status}`);
-    return assignment;
-}
-function requireReviewerAssignment(state, id, statuses) {
-    const assignment = state.reviewerAssignments[id];
-    if (!assignment)
-        throw new Error(`Reviewer Assignment ${id} not found`);
-    if (statuses && !statuses.includes(assignment.status)) {
-        throw new Error(`Reviewer Assignment ${id} is ${assignment.status}`);
-    }
-    return assignment;
-}
-function requireSponsorGate(state, id, statuses) {
-    const gate = state.sponsorGates[id];
-    if (!gate)
-        throw new Error(`Sponsor Gate ${id} not found`);
-    if (statuses && !statuses.includes(gate.status))
-        throw new Error(`Sponsor Gate ${id} is ${gate.status}`);
-    return gate;
-}
-function assertAcceptanceWaitBinding(task, wait) {
-    const contract = task.acceptanceContract;
-    if (!contract
-        || wait.taskKey !== task.key
-        || wait.taskRevision !== task.revision
-        || wait.contractId !== contract.id
-        || wait.policy.id !== contract.policy.id
-        || wait.policy.revision !== contract.policy.revision
-        || wait.policy.digest !== contract.policy.digest) {
-        throw new Error('Acceptance wait does not match the pinned Task, Contract and Policy snapshot');
-    }
-}
-function assertNoOpenAcceptanceWait(state, task) {
-    const review = task.currentReviewerAssignmentId
-        ? state.reviewerAssignments[task.currentReviewerAssignmentId]
-        : undefined;
-    const gate = task.currentSponsorGateId ? state.sponsorGates[task.currentSponsorGateId] : undefined;
-    if (review?.status === 'open' || review?.status === 'claimed' || gate?.status === 'open') {
-        throw new Error(`Task ${task.key} already has an open Acceptance wait`);
-    }
-}
-function assertAcceptanceRecordControlBindings(state, task, record) {
-    if (record.route === 'auto_accept') {
-        if (record.reviewerAssignmentId || record.sponsorGateId) {
-            throw new Error('Automatic Acceptance Record cannot reference Reviewer or Sponsor proof');
-        }
-        return;
-    }
-    if (record.route === 'reviewer_required' || record.route === 'reviewer_then_sponsor') {
-        const reviewId = record.reviewerAssignmentId;
-        const review = reviewId ? state.reviewerAssignments[reviewId] : undefined;
-        if (!review
-            || (record.route === 'reviewer_required' && task.currentReviewerAssignmentId !== review.id)
-            || review.status !== 'passed'
-            || review.reviewerPrincipalId !== record.reviewerPrincipalId
-            || review.candidateHash !== record.candidateHash) {
-            throw new Error('Acceptance Record is not bound to a passed Reviewer verdict');
-        }
-    }
-    if (record.route === 'sponsor_required' || record.route === 'reviewer_then_sponsor') {
-        const gateId = record.sponsorGateId;
-        const gate = gateId ? state.sponsorGates[gateId] : undefined;
-        if (!gate
-            || task.currentSponsorGateId !== gate.id
-            || gate.status !== 'approved'
-            || gate.sponsorPrincipalId !== record.sponsorPrincipalId
-            || gate.candidateHash !== record.candidateHash
-            || (record.route === 'reviewer_then_sponsor'
-                && gate.reviewerAssignmentId !== record.reviewerAssignmentId)) {
-            throw new Error('Acceptance Record is not bound to an approved Sponsor Gate');
-        }
-    }
-}
-function assertPersistedAcceptanceAuthorization(state, payload, expected) {
-    const authorization = payload.authorization;
-    if (!authorization || typeof authorization !== 'object' || Array.isArray(authorization)) {
-        throw new Error('Acceptance control event is missing its authorization decision');
-    }
-    const value = authorization;
-    if (value.authorized !== true
-        || value.action !== expected.action
-        || value.role !== expected.role
-        || value.principalId !== payload[expected.principalKey]
-        || value.projectId !== state.projectId
-        || value.runId !== state.runId
-        || value.taskKey !== payload.taskKey
-        || value.targetId !== expected.targetId
-        || value.expectedSequence !== state.sequence
-        || value.authorizedBy !== payload.authorizedBy) {
-        throw new Error('Acceptance control event authorization is stale or targets another scope');
-    }
-}
-function settleAcceptanceWaits(task, reviewerAssignments, sponsorGates, status) {
-    const reviewId = task.currentReviewerAssignmentId;
-    const review = reviewId ? reviewerAssignments[reviewId] : undefined;
-    const gateId = task.currentSponsorGateId;
-    const gate = gateId ? sponsorGates[gateId] : undefined;
-    return {
-        reviewerAssignments: review?.status === 'open' || review?.status === 'claimed'
-            ? { ...reviewerAssignments, [review.id]: { ...review, status } }
-            : reviewerAssignments,
-        sponsorGates: gate?.status === 'open'
-            ? { ...sponsorGates, [gate.id]: { ...gate, status } }
-            : sponsorGates,
-    };
-}
-//# sourceMappingURL=kernel-state.js.map