@zhin.js/agent 1.1.30 → 1.1.32

package/lib/workroom/workroom-scheduler.js

@@ -1,660 +0,0 @@
-import { canonicalWorkroomJson, compareCanonicalWorkroomText, deepFreezeWorkroomValue as deepFreeze, digestCanonicalWorkroomValue, } from './canonical-value.js';
-export function parseWorkroomDispatchTaskDecision(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error('Workroom Scheduler dispatch decision shape is invalid');
-    }
-    const input = value;
-    const actualKeys = Object.keys(input).sort();
-    const expectedKeys = [
-        'decisionId', 'digest', 'expectedSequence', 'policy', 'projectId', 'reason',
-        'role', 'runId', 'sponsorLane', 'taskKey', 'taskRevision', 'type', 'version',
-    ].sort();
-    if (actualKeys.length !== expectedKeys.length
-        || actualKeys.some((key, index) => key !== expectedKeys[index])) {
-        throw new Error('Workroom Scheduler dispatch decision keys are invalid');
-    }
-    if (input.version !== 1 || input.type !== 'dispatch_task') {
-        throw new Error('Workroom Scheduler dispatch decision version/type is invalid');
-    }
-    const body = deepFreeze({
-        version: 1,
-        type: 'dispatch_task',
-        projectId: text(input.projectId, 'Scheduler decision projectId'),
-        runId: text(input.runId, 'Scheduler decision runId'),
-        expectedSequence: nonNegativeInteger(input.expectedSequence, 'Scheduler decision expectedSequence'),
-        taskKey: text(input.taskKey, 'Scheduler decision taskKey'),
-        taskRevision: positiveInteger(input.taskRevision, 'Scheduler decision taskRevision'),
-        role: text(input.role, 'Scheduler decision role'),
-        sponsorLane: lane(input.sponsorLane),
-        reason: schedulerReason(input.reason),
-        policy: {
-            ref: text(input.policy?.ref, 'Scheduler decision policy ref'),
-            revision: positiveInteger(input.policy?.revision, 'Scheduler decision policy revision'),
-            digest: canonicalDigest(input.policy?.digest, 'Scheduler decision policy digest'),
-        },
-    });
-    const digest = digestCanonicalWorkroomValue(body);
-    const expectedId = `scheduler:${digest.slice('sha256:'.length)}`;
-    if (input.digest !== digest || input.decisionId !== expectedId) {
-        throw new Error('Workroom Scheduler dispatch decision digest/identity is invalid');
-    }
-    return deepFreeze({ ...body, digest, decisionId: expectedId });
-}
-export function parseWorkroomPreemptionPrepareDecision(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error('Workroom preemption prepare decision shape is invalid');
-    }
-    const input = value;
-    const actualKeys = Object.keys(input).sort();
-    const expectedKeys = [
-        'allowedSuccessors', 'assignmentAttempt', 'assignmentEnvelopeDigest', 'assignmentFence',
-        'assignmentId', 'deadline', 'decisionId', 'digest', 'expectedSequence', 'owner', 'policy',
-        'projectId', 'reason', 'requestedAt', 'reservedTaskKey', 'reservedTaskRevision', 'runId',
-        'takeoverFence', 'type', 'version', 'victimTaskKey', 'victimTaskRevision',
-    ].sort();
-    if (actualKeys.length !== expectedKeys.length
-        || actualKeys.some((key, index) => key !== expectedKeys[index])) {
-        throw new Error('Workroom preemption prepare decision keys are invalid');
-    }
-    const body = deepFreeze({
-        version: 1,
-        type: 'prepare_preemption',
-        projectId: text(input.projectId, 'Preemption projectId'),
-        runId: text(input.runId, 'Preemption runId'),
-        expectedSequence: nonNegativeInteger(input.expectedSequence, 'Preemption expectedSequence'),
-        victimTaskKey: text(input.victimTaskKey, 'Preemption victimTaskKey'),
-        victimTaskRevision: positiveInteger(input.victimTaskRevision, 'Preemption victimTaskRevision'),
-        reservedTaskKey: text(input.reservedTaskKey, 'Preemption reservedTaskKey'),
-        reservedTaskRevision: positiveInteger(input.reservedTaskRevision, 'Preemption reservedTaskRevision'),
-        assignmentId: text(input.assignmentId, 'Preemption assignmentId'),
-        assignmentAttempt: positiveInteger(input.assignmentAttempt, 'Preemption assignmentAttempt'),
-        assignmentFence: positiveInteger(input.assignmentFence, 'Preemption assignmentFence'),
-        assignmentEnvelopeDigest: canonicalDigest(input.assignmentEnvelopeDigest, 'Preemption Envelope digest'),
-        owner: text(input.owner, 'Preemption owner'),
-        requestedAt: finiteTime(input.requestedAt, 'Preemption requestedAt'),
-        deadline: finiteTime(input.deadline, 'Preemption deadline'),
-        takeoverFence: positiveInteger(input.takeoverFence, 'Preemption takeoverFence'),
-        reason: preemptionReason(input.reason),
-        allowedSuccessors: ['replan', 'cancel_run'],
-        policy: {
-            ref: text(input.policy?.ref, 'Preemption policy ref'),
-            revision: positiveInteger(input.policy?.revision, 'Preemption policy revision'),
-            digest: canonicalDigest(input.policy?.digest, 'Preemption policy digest'),
-        },
-    });
-    if (body.deadline <= body.requestedAt || body.takeoverFence !== body.assignmentFence + 1
-        || canonicalWorkroomJson(input.allowedSuccessors) !== canonicalWorkroomJson(body.allowedSuccessors)) {
-        throw new Error('Workroom preemption deadline/fence/successors are invalid');
-    }
-    const digest = digestCanonicalWorkroomValue(body);
-    const decisionId = `scheduler-preemption:${digest.slice('sha256:'.length)}`;
-    if (input.digest !== digest || input.decisionId !== decisionId) {
-        throw new Error('Workroom preemption prepare decision digest/identity is invalid');
-    }
-    return deepFreeze({ ...body, digest, decisionId });
-}
-const LANE_ORDER = Object.freeze({
-    urgent: 0,
-    high: 1,
-    normal: 2,
-    low: 3,
-});
-export function createWorkroomSchedulerPolicySnapshot(input) {
-    text(input.policyRef, 'Scheduler policyRef');
-    positiveInteger(input.revision, 'Scheduler policy revision');
-    nonNegativeInteger(input.pinnedAtSequence, 'Scheduler policy pinnedAtSequence');
-    positiveInteger(input.capacity, 'Scheduler capacity');
-    positiveInteger(input.agingStepMs, 'Scheduler agingStepMs');
-    positiveInteger(input.preemptionDeadlineMs, 'Scheduler preemptionDeadlineMs');
-    const starvationBoundMs = deepFreeze({
-        urgent: positiveInteger(input.starvationBoundMs?.urgent, 'Scheduler urgent starvation bound'),
-        high: positiveInteger(input.starvationBoundMs?.high, 'Scheduler high starvation bound'),
-        normal: positiveInteger(input.starvationBoundMs?.normal, 'Scheduler normal starvation bound'),
-        low: positiveInteger(input.starvationBoundMs?.low, 'Scheduler low starvation bound'),
-    });
-    const body = deepFreeze({
-        version: 1,
-        comparatorVersion: 1,
-        policyRef: input.policyRef,
-        revision: input.revision,
-        pinnedAtSequence: input.pinnedAtSequence,
-        capacity: input.capacity,
-        agingStepMs: input.agingStepMs,
-        starvationBoundMs,
-        preemptionDeadlineMs: input.preemptionDeadlineMs,
-    });
-    return deepFreeze({ ...body, digest: digestCanonicalWorkroomValue(body) });
-}
-export function assertWorkroomSchedulerPolicySnapshot(value, pinnedAtSequence) {
-    if (!value || value.version !== 1 || value.comparatorVersion !== 1) {
-        throw new Error('Workroom Scheduler Policy Snapshot shape is invalid');
-    }
-    const rebuilt = createWorkroomSchedulerPolicySnapshot(value);
-    if (rebuilt.digest !== value.digest) {
-        throw new Error('Workroom Scheduler Policy Snapshot digest does not match its canonical body');
-    }
-    if (pinnedAtSequence !== undefined && value.pinnedAtSequence !== pinnedAtSequence) {
-        throw new Error('Workroom Scheduler Policy Snapshot is pinned at another Journal sequence');
-    }
-}
-/** Pure `Journal facts + pinned policy -> one typed decision` boundary. */
-export function decideWorkroomSchedule(events) {
-    const state = projectScheduler(events);
-    if (state.cancelRequested || state.replanRequested)
-        return null;
-    assertWaitRecoveryMetadata(state.tasks);
-    const used = state.activeAssignments.size + state.pendingDispatches.size;
-    const candidates = [...state.tasks.values()].filter(task => task.status === 'ready'
-        && !state.pendingDispatches.has(task.key)
-        && task.dependsOn.every(key => state.tasks.get(key)?.status === 'accepted'));
-    const selected = candidates.sort((left, right) => compareTasks(state, left, right))[0];
-    if (!selected)
-        return null;
-    if (used >= state.policy.capacity) {
-        if (state.pendingPreemptionDecisionId)
-            return null;
-        const incomingStarved = isStarved(state, selected);
-        const victims = [...state.activeAssignments.entries()].flatMap(([assignmentId, assignment]) => {
-            const task = state.tasks.get(assignment.taskKey);
-            if (!task || assignment.status !== 'running' || task.preemptibility !== 'checkpointable')
-                return [];
-            if (!incomingStarved && LANE_ORDER[selected.sponsorLane] >= LANE_ORDER[task.sponsorLane])
-                return [];
-            return [{ assignmentId, assignment, task }];
-        }).sort((left, right) => {
-            const laneOrder = LANE_ORDER[right.task.sponsorLane] - LANE_ORDER[left.task.sponsorLane];
-            if (laneOrder !== 0)
-                return laneOrder;
-            return compareCanonicalWorkroomText(left.task.key, right.task.key);
-        });
-        const victim = victims[0];
-        if (!victim)
-            return null;
-        const body = deepFreeze({
-            version: 1,
-            type: 'prepare_preemption',
-            projectId: state.projectId,
-            runId: state.runId,
-            expectedSequence: state.sequence,
-            victimTaskKey: victim.task.key,
-            victimTaskRevision: victim.task.revision,
-            reservedTaskKey: selected.key,
-            reservedTaskRevision: selected.revision,
-            assignmentId: victim.assignmentId,
-            assignmentAttempt: victim.assignment.attempt,
-            assignmentFence: victim.assignment.fence,
-            assignmentEnvelopeDigest: victim.assignment.envelopeDigest,
-            owner: victim.assignment.owner,
-            requestedAt: state.now,
-            deadline: state.now + state.policy.preemptionDeadlineMs,
-            takeoverFence: victim.assignment.fence + 1,
-            reason: incomingStarved ? 'starvation_bound' : 'higher_priority',
-            allowedSuccessors: ['replan', 'cancel_run'],
-            policy: {
-                ref: state.policy.policyRef,
-                revision: state.policy.revision,
-                digest: state.policy.digest,
-            },
-        });
-        const digest = digestCanonicalWorkroomValue(body);
-        return deepFreeze({
-            ...body,
-            decisionId: `scheduler-preemption:${digest.slice('sha256:'.length)}`,
-            digest,
-        });
-    }
-    const reason = state.reservedTaskKey === selected.key
-        ? 'preemption_reservation'
-        : isStarved(state, selected) ? 'starvation_bound' : 'scheduler_order';
-    const body = deepFreeze({
-        version: 1,
-        type: 'dispatch_task',
-        projectId: state.projectId,
-        runId: state.runId,
-        expectedSequence: state.sequence,
-        taskKey: selected.key,
-        taskRevision: selected.revision,
-        role: selected.role,
-        sponsorLane: selected.sponsorLane,
-        reason,
-        policy: {
-            ref: state.policy.policyRef,
-            revision: state.policy.revision,
-            digest: state.policy.digest,
-        },
-    });
-    const digest = digestCanonicalWorkroomValue(body);
-    return deepFreeze({
-        ...body,
-        decisionId: `scheduler:${digest.slice('sha256:'.length)}`,
-        digest,
-    });
-}
-/**
- * Creates a typed proposal only. The Sponsor/Orchestrator principal and
- * authorityRef must be injected by a trusted role-scoped command port before
- * a Kernel CAS adapter may persist it.
- */
-export function proposeWorkroomPriorityChange(input) {
-    for (const [value, label] of [
-        [input.projectId, 'projectId'], [input.runId, 'runId'], [input.taskKey, 'taskKey'],
-        [input.principalId, 'principalId'], [input.authorityRef, 'authorityRef'],
-    ])
-        text(value, `Priority change ${label}`);
-    positiveInteger(input.taskRevision, 'Priority change taskRevision');
-    nonNegativeInteger(input.expectedSequence, 'Priority change expectedSequence');
-    nonNegativeInteger(input.localRank, 'Priority change localRank');
-    finiteTime(input.deadline, 'Priority change deadline');
-    lane(input.currentLane);
-    lane(input.requestedLane);
-    if (input.authority === 'orchestrator' && input.requestedLane !== input.currentLane) {
-        throw new Error('Orchestrator cannot move a Task across Sponsor lanes');
-    }
-    const body = deepFreeze({
-        version: 1,
-        type: 'priority_change',
-        ...structuredClone(input),
-        owner: input.principalId,
-        allowedSuccessors: ['restore', 'rebase', 'cancel_run'],
-    });
-    const digest = digestCanonicalWorkroomValue(body);
-    return deepFreeze({
-        ...body,
-        proposalId: `scheduler-priority:${digest.slice('sha256:'.length)}`,
-        digest,
-    });
-}
-export function parseWorkroomPriorityChangeProposal(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error('Workroom priority change proposal shape is invalid');
-    }
-    const input = value;
-    const rebuilt = proposeWorkroomPriorityChange({
-        projectId: input.projectId,
-        runId: input.runId,
-        taskKey: input.taskKey,
-        taskRevision: input.taskRevision,
-        expectedSequence: input.expectedSequence,
-        currentLane: input.currentLane,
-        requestedLane: input.requestedLane,
-        localRank: input.localRank,
-        principalId: input.principalId,
-        authority: input.authority,
-        authorityRef: input.authorityRef,
-        deadline: input.deadline,
-    });
-    if (canonicalWorkroomJson(rebuilt) !== canonicalWorkroomJson(input)) {
-        throw new Error('Workroom priority change proposal is not canonical');
-    }
-    return rebuilt;
-}
-export function getWorkroomScheduledTaskSnapshot(events, taskKey) {
-    const task = projectScheduler(events).tasks.get(text(taskKey, 'Scheduled Task key'));
-    if (!task)
-        throw new Error(`Scheduled Task ${taskKey} not found`);
-    return deepFreeze({
-        taskRevision: task.revision,
-        sponsorLane: task.sponsorLane,
-        localRank: task.localRank,
-    });
-}
-export function getWorkroomScheduledTaskCapacitySnapshot(events, taskKey) {
-    const task = projectScheduler(events).tasks.get(text(taskKey, 'Scheduled Task key'));
-    if (!task)
-        throw new Error(`Scheduled Task ${taskKey} not found`);
-    return deepFreeze({
-        taskKey: task.key,
-        taskRevision: task.revision,
-        role: task.role,
-        preemptibility: task.preemptibility,
-        status: task.status,
-    });
-}
-function projectScheduler(events) {
-    const created = events[0];
-    if (!created || created.sequence !== 0 || created.type !== 'run.created') {
-        throw new Error('Workroom Scheduler requires a Run Journal beginning at sequence 0');
-    }
-    const tasks = new Map();
-    const activeAssignments = new Map();
-    const pendingDispatches = new Set();
-    let policy;
-    let now = created.occurredAt;
-    let cancelRequested = false;
-    let replanRequested = false;
-    let reservedTaskKey;
-    let pendingPreemptionDecisionId;
-    for (const [index, event] of events.entries()) {
-        if (event.runId !== created.runId || event.sequence !== index) {
-            throw new Error('Workroom Scheduler Journal scope/sequence is not contiguous');
-        }
-        now = event.type === 'clock.advanced'
-            ? finiteTime(event.payload.now, 'Scheduler clock')
-            : Math.max(now, finiteTime(event.occurredAt, 'Scheduler event time'));
-        switch (event.type) {
-            case 'plan.admitted': {
-                if (policy)
-                    throw new Error('Workroom Scheduler Policy Snapshot is duplicated');
-                const plan = event.payload.plan && typeof event.payload.plan === 'object'
-                    ? event.payload.plan
-                    : undefined;
-                const candidate = (event.payload.schedulerPolicy ?? plan?.schedulerPolicy);
-                if (!candidate)
-                    throw new Error('Workroom Scheduler Policy Snapshot is not pinned');
-                assertWorkroomSchedulerPolicySnapshot(candidate, event.sequence);
-                policy = candidate;
-                break;
-            }
-            case 'run.cancel_requested':
-            case 'run.cancelled':
-                cancelRequested = true;
-                break;
-            case 'run.replan_requested':
-                replanRequested = true;
-                break;
-            case 'plan.revision_applied':
-                replanRequested = false;
-                break;
-            case 'task.planned': {
-                const key = text(event.payload.taskKey, 'Scheduled Task key');
-                if (tasks.has(key))
-                    throw new Error(`Scheduled Task ${key} is duplicated`);
-                tasks.set(key, Object.freeze({
-                    key,
-                    revision: 1,
-                    role: text(event.payload.role, `Scheduled Task ${key} role`),
-                    sponsorLane: lane(event.payload.sponsorLane),
-                    localRank: nonNegativeInteger(event.payload.localRank, `Scheduled Task ${key} localRank`),
-                    ...(event.payload.deadline === undefined
-                        ? {}
-                        : { deadline: finiteTime(event.payload.deadline, `Scheduled Task ${key} deadline`) }),
-                    enqueuedAt: finiteTime(event.payload.enqueuedAt, `Scheduled Task ${key} enqueuedAt`),
-                    enqueueSequence: event.sequence,
-                    dependsOn: stringList(event.payload.dependsOn, `Scheduled Task ${key} dependsOn`),
-                    preemptibility: preemptibility(event.payload.preemptibility),
-                    status: 'ready',
-                    blockers: new Map(),
-                }));
-                break;
-            }
-            case 'task.blocked': {
-                const task = requireTask(tasks, event.payload.taskKey);
-                const blockers = new Map(task.blockers);
-                blockers.set(text(event.payload.blockerId, 'Task Blocker id'), Object.freeze({
-                    owner: typeof event.payload.owner === 'string' ? event.payload.owner : '',
-                    deadline: typeof event.payload.deadline === 'number' ? event.payload.deadline : Number.NaN,
-                    allowedSuccessors: Array.isArray(event.payload.allowedActions)
-                        ? event.payload.allowedActions.map(String)
-                        : ['resolve', 'replan', 'cancel'],
-                }));
-                tasks.set(task.key, Object.freeze({ ...task, status: 'blocked', blockers }));
-                break;
-            }
-            case 'task.blocker_resolved': {
-                const task = requireTask(tasks, event.payload.taskKey);
-                const blockers = new Map(task.blockers);
-                blockers.delete(String(event.payload.blockerId));
-                tasks.set(task.key, Object.freeze({
-                    ...task,
-                    status: blockers.size === 0 ? 'ready' : 'blocked',
-                    enqueuedAt: blockers.size === 0 ? event.occurredAt : task.enqueuedAt,
-                    enqueueSequence: blockers.size === 0 ? event.sequence : task.enqueueSequence,
-                    blockers,
-                }));
-                break;
-            }
-            case 'assignment.claimed': {
-                const assignmentId = text(event.payload.assignmentId, 'Assignment id');
-                const task = requireTask(tasks, event.payload.taskKey);
-                activeAssignments.set(assignmentId, {
-                    taskKey: task.key,
-                    status: 'leased',
-                    attempt: positiveInteger(event.payload.attempt, 'Assignment attempt'),
-                    fence: positiveInteger(event.payload.fence, 'Assignment fence'),
-                    envelopeDigest: canonicalDigest(event.payload.envelopeDigest, 'Assignment Envelope digest'),
-                    owner: text(event.payload.owner, 'Assignment owner'),
-                });
-                pendingDispatches.delete(task.key);
-                tasks.set(task.key, Object.freeze({ ...task, status: 'executing' }));
-                break;
-            }
-            case 'assignment.started': {
-                const assignment = activeAssignments.get(String(event.payload.assignmentId));
-                if (assignment)
-                    activeAssignments.set(String(event.payload.assignmentId), { ...assignment, status: 'running' });
-                break;
-            }
-            case 'assignment.execution_completed': {
-                const assignment = activeAssignments.get(String(event.payload.assignmentId));
-                if (assignment) {
-                    activeAssignments.delete(String(event.payload.assignmentId));
-                    const task = requireTask(tasks, assignment.taskKey);
-                    tasks.set(task.key, Object.freeze({ ...task, status: 'awaiting_acceptance' }));
-                }
-                break;
-            }
-            case 'assignment.cancelled':
-            case 'assignment.preempted':
-            case 'assignment.lease_expired': {
-                const assignment = activeAssignments.get(String(event.payload.assignmentId));
-                if (assignment) {
-                    activeAssignments.delete(String(event.payload.assignmentId));
-                    const task = requireTask(tasks, assignment.taskKey);
-                    tasks.set(task.key, Object.freeze({
-                        ...task, status: 'ready', enqueuedAt: event.occurredAt, enqueueSequence: event.sequence,
-                    }));
-                }
-                break;
-            }
-            case 'task.accepted':
-                setTaskStatus(tasks, event.payload.taskKey, 'accepted');
-                break;
-            case 'task.failed':
-                setTaskStatus(tasks, event.payload.taskKey, 'failed');
-                break;
-            case 'task.cancelled':
-                setTaskStatus(tasks, event.payload.taskKey, 'cancelled');
-                break;
-            case 'task.rework_requested':
-            case 'task.revised': {
-                const task = requireTask(tasks, event.payload.taskKey);
-                tasks.set(task.key, Object.freeze({
-                    ...task,
-                    revision: task.revision + 1,
-                    status: 'ready',
-                    enqueuedAt: event.occurredAt,
-                    enqueueSequence: event.sequence,
-                }));
-                break;
-            }
-            case 'task.plan_revised': {
-                const task = requireTask(tasks, event.payload.taskKey);
-                if (Number(event.payload.expectedTaskRevision) !== task.revision
-                    || Number(event.payload.newTaskRevision) !== task.revision + 1) {
-                    throw new Error('Persisted Plan Revision targets another Task revision');
-                }
-                tasks.set(task.key, Object.freeze({
-                    ...task,
-                    revision: task.revision + 1,
-                    role: text(event.payload.role, `Scheduled Task ${task.key} role`),
-                    sponsorLane: lane(event.payload.sponsorLane),
-                    localRank: nonNegativeInteger(event.payload.localRank, `Scheduled Task ${task.key} localRank`),
-                    deadline: finiteTime(event.payload.deadline, `Scheduled Task ${task.key} deadline`),
-                    enqueuedAt: finiteTime(event.payload.enqueuedAt, `Scheduled Task ${task.key} enqueuedAt`),
-                    enqueueSequence: event.sequence,
-                    dependsOn: stringList(event.payload.dependsOn, `Scheduled Task ${task.key} dependsOn`),
-                    preemptibility: preemptibility(event.payload.preemptibility),
-                    status: 'ready',
-                    blockers: new Map(),
-                }));
-                break;
-            }
-            case 'scheduler.priority_changed': {
-                if (finiteTime(event.payload.deadline, 'Persisted priority deadline') <= now) {
-                    throw new Error('Workroom priority proposal is expired');
-                }
-                const task = requireTask(tasks, event.payload.taskKey);
-                if (Number(event.payload.taskRevision) !== task.revision) {
-                    throw new Error('Persisted Workroom priority change targets another Task revision');
-                }
-                tasks.set(task.key, Object.freeze({
-                    ...task,
-                    sponsorLane: lane(event.payload.requestedLane),
-                    localRank: nonNegativeInteger(event.payload.localRank, 'Persisted priority localRank'),
-                }));
-                break;
-            }
-            case 'scheduler.dispatch_requested':
-                pendingDispatches.add(text(event.payload.taskKey, 'Scheduler dispatch Task key'));
-                break;
-            case 'scheduler.preemption_requested':
-                reservedTaskKey = text(event.payload.reservedTaskKey, 'Scheduler reserved Task key');
-                pendingPreemptionDecisionId = text(event.payload.decisionId, 'Scheduler preemption decision id');
-                break;
-            case 'scheduler.preemption_checkpoint_acknowledged':
-                if (event.payload.decisionId === pendingPreemptionDecisionId) {
-                    pendingPreemptionDecisionId = undefined;
-                }
-                break;
-            case 'scheduler.preemption_timed_out':
-                if (event.payload.decisionId === pendingPreemptionDecisionId) {
-                    pendingPreemptionDecisionId = undefined;
-                    reservedTaskKey = undefined;
-                }
-                break;
-        }
-    }
-    if (!policy)
-        throw new Error('Workroom Scheduler Policy Snapshot is not pinned');
-    return Object.freeze({
-        runId: created.runId,
-        projectId: text(created.payload.projectId, 'Workroom Project id'),
-        sequence: events.at(-1).sequence,
-        now,
-        cancelRequested,
-        replanRequested,
-        policy,
-        tasks,
-        activeAssignments,
-        pendingDispatches,
-        ...(reservedTaskKey === undefined ? {} : { reservedTaskKey }),
-        ...(pendingPreemptionDecisionId === undefined ? {} : { pendingPreemptionDecisionId }),
-    });
-}
-function compareTasks(state, left, right) {
-    const leftReserved = left.key === state.reservedTaskKey;
-    const rightReserved = right.key === state.reservedTaskKey;
-    if (leftReserved !== rightReserved)
-        return leftReserved ? -1 : 1;
-    const leftStarved = isStarved(state, left);
-    const rightStarved = isStarved(state, right);
-    if (leftStarved !== rightStarved)
-        return leftStarved ? -1 : 1;
-    if (leftStarved && rightStarved) {
-        const leftAt = left.enqueuedAt + state.policy.starvationBoundMs[left.sponsorLane];
-        const rightAt = right.enqueuedAt + state.policy.starvationBoundMs[right.sponsorLane];
-        if (leftAt !== rightAt)
-            return leftAt - rightAt;
-    }
-    const laneOrder = LANE_ORDER[left.sponsorLane] - LANE_ORDER[right.sponsorLane];
-    if (laneOrder !== 0)
-        return laneOrder;
-    const leftDeadline = left.deadline ?? Number.POSITIVE_INFINITY;
-    const rightDeadline = right.deadline ?? Number.POSITIVE_INFINITY;
-    if (leftDeadline !== rightDeadline)
-        return leftDeadline - rightDeadline;
-    const rank = effectiveRank(state, right) - effectiveRank(state, left);
-    if (rank !== 0)
-        return rank;
-    if (left.enqueueSequence !== right.enqueueSequence) {
-        return left.enqueueSequence - right.enqueueSequence;
-    }
-    return compareCanonicalWorkroomText(left.key, right.key);
-}
-function effectiveRank(state, task) {
-    return task.localRank + Math.floor(Math.max(0, state.now - task.enqueuedAt) / state.policy.agingStepMs);
-}
-function isStarved(state, task) {
-    return state.now - task.enqueuedAt >= state.policy.starvationBoundMs[task.sponsorLane];
-}
-function assertWaitRecoveryMetadata(tasks) {
-    for (const task of tasks.values()) {
-        for (const blocker of task.blockers.values()) {
-            if (!blocker.owner.trim() || !Number.isFinite(blocker.deadline) || blocker.deadline < 0
-                || blocker.allowedSuccessors.length === 0
-                || !blocker.allowedSuccessors.includes('cancel')) {
-                throw new Error('Workroom wait requires owner, deadline and allowed successors including cancel');
-            }
-        }
-    }
-}
-function setTaskStatus(tasks, key, status) {
-    const task = requireTask(tasks, key);
-    tasks.set(task.key, Object.freeze({ ...task, status }));
-}
-function requireTask(tasks, key) {
-    const id = text(key, 'Scheduled Task key');
-    const task = tasks.get(id);
-    if (!task)
-        throw new Error(`Scheduled Task ${id} is absent from the admitted Plan`);
-    return task;
-}
-function lane(value) {
-    if (!['urgent', 'high', 'normal', 'low'].includes(String(value))) {
-        throw new Error('Workroom Sponsor lane is invalid');
-    }
-    return value;
-}
-function preemptibility(value) {
-    if (value !== 'checkpointable' && value !== 'atomic') {
-        throw new Error('Workroom Task preemptibility is invalid');
-    }
-    return value;
-}
-function schedulerReason(value) {
-    if (!['scheduler_order', 'starvation_bound', 'preemption_reservation'].includes(String(value))) {
-        throw new Error('Workroom Scheduler dispatch reason is invalid');
-    }
-    return value;
-}
-function preemptionReason(value) {
-    if (value !== 'higher_priority' && value !== 'starvation_bound') {
-        throw new Error('Workroom preemption reason is invalid');
-    }
-    return value;
-}
-function canonicalDigest(value, label) {
-    if (typeof value !== 'string' || !/^sha256:[a-f0-9]{64}$/u.test(value)) {
-        throw new Error(`${label} must be a canonical SHA-256 digest`);
-    }
-    return value;
-}
-function text(value, label) {
-    if (typeof value !== 'string' || !value.trim() || value !== value.trim()) {
-        throw new Error(`${label} is required`);
-    }
-    return value;
-}
-function stringList(value, label) {
-    if (!Array.isArray(value) || value.some(item => typeof item !== 'string' || !item.trim())) {
-        throw new Error(`${label} must be a string list`);
-    }
-    return Object.freeze([...new Set(value)].sort());
-}
-function positiveInteger(value, label) {
-    if (!Number.isSafeInteger(value) || Number(value) < 1)
-        throw new Error(`${label} must be a positive safe integer`);
-    return Number(value);
-}
-function nonNegativeInteger(value, label) {
-    if (!Number.isSafeInteger(value) || Number(value) < 0)
-        throw new Error(`${label} must be a non-negative safe integer`);
-    return Number(value);
-}
-function finiteTime(value, label) {
-    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
-        throw new Error(`${label} must be a non-negative finite timestamp`);
-    }
-    return value;
-}
-//# sourceMappingURL=workroom-scheduler.js.map