ace-swarm 2.0.3 → 2.0.4

package/dist/job-scheduler.js

@@ -38,7 +38,7 @@ async function flushTransitionEvents(buf) {
     }
 }
 export const JOB_QUEUE_REL = "agent-state/job-queue.json";
-export const RESERVATION_TABLE_REL = "agent-state/job-reservations.json";
+export const JOB_LOCK_TABLE_REL = "agent-state/job-locks.json";
 export const SCHEDULER_LEASE_REL = "agent-state/scheduler-lease.json";
 export const SCHEDULER_LOCK_REL = "agent-state/job-scheduler.lock";
 export const PRIORITY_BANDS = ["P0", "P1", "P2", "P3"];
@@ -47,7 +47,6 @@ export const JOB_STATUS = [
     "accepted",
     "blocked",
     "ready",
-    "reserved",
     "running",
     "done",
     "failed",
@@ -55,9 +54,8 @@ export const JOB_STATUS = [
     "canceled",
     "unknown_recovery",
 ];
-export const RESERVATION_STATUS = [
-    "reserved",
-    "running",
+export const JOB_LOCK_STATUS = [
+    "active",
     "completed",
     "released",
     "failed",
@@ -104,14 +102,11 @@ function defaultQueueFile() {
         jobs: [],
     };
 }
-function defaultReservationFile() {
+function defaultJobLockFile() {
     return {
         version: 1,
         updated_at: nowIso(),
-        horizon_steps: 5,
-        horizon_minutes: 30,
-        time_slice_seconds: 300,
-        reservations: [],
+        locks: [],
     };
 }
 function defaultLease(owner = "scheduler") {
@@ -175,7 +170,6 @@ function parseQueueFile(raw) {
                 next_attempt_at: typeof job.next_attempt_at === "string" ? job.next_attempt_at : undefined,
                 created_at: typeof job.created_at === "string" ? job.created_at : nowIso(),
                 accepted_at: typeof job.accepted_at === "string" ? job.accepted_at : undefined,
-                reserved_at: typeof job.reserved_at === "string" ? job.reserved_at : undefined,
                 started_at: typeof job.started_at === "string" ? job.started_at : undefined,
                 completed_at: typeof job.completed_at === "string" ? job.completed_at : undefined,
                 evidence_ref: typeof job.evidence_ref === "string" ? job.evidence_ref : undefined,
@@ -193,57 +187,46 @@ function parseQueueFile(raw) {
         return undefined;
     }
 }
-function parseReservationFile(raw) {
+function parseJobLockFile(raw) {
     try {
         const parsed = JSON.parse(raw);
         if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
             return undefined;
         const candidate = parsed;
-        if (candidate.version !== 1 || !Array.isArray(candidate.reservations))
+        if (candidate.version !== 1 || !Array.isArray(candidate.locks))
             return undefined;
-        const reservations = [];
-        for (const row of candidate.reservations) {
+        const locks = [];
+        for (const row of candidate.locks) {
             if (!row || typeof row !== "object")
                 continue;
             const record = row;
-            if (typeof record.reservation_id !== "string" ||
+            if (typeof record.lock_id !== "string" ||
                 typeof record.job_id !== "string" ||
-                typeof record.resource !== "string" ||
-                typeof record.time_slice_start !== "string" ||
-                typeof record.time_slice_end !== "string") {
+                typeof record.resource !== "string") {
                 continue;
             }
-            const status = RESERVATION_STATUS.includes(record.status)
+            const status = JOB_LOCK_STATUS.includes(record.status)
                 ? record.status
-                : "reserved";
-            reservations.push({
-                reservation_id: record.reservation_id,
+                : "active";
+            locks.push({
+                lock_id: record.lock_id,
                 job_id: record.job_id,
                 phase: typeof record.phase === "string" ? record.phase : "dispatch",
                 resource: record.resource,
-                time_slice_start: record.time_slice_start,
-                time_slice_end: record.time_slice_end,
                 status,
                 priority: toPriority(record.priority),
                 lease_id: typeof record.lease_id === "string" ? record.lease_id : undefined,
-                overrun: typeof record.overrun === "boolean" ? record.overrun : undefined,
                 reason_code: typeof record.reason_code === "string" ? record.reason_code : undefined,
+                acquired_at: typeof record.acquired_at === "string" ? record.acquired_at : undefined,
+                heartbeat_at: typeof record.heartbeat_at === "string" ? record.heartbeat_at : undefined,
+                released_at: typeof record.released_at === "string" ? record.released_at : undefined,
                 created_at: typeof record.created_at === "string" ? record.created_at : nowIso(),
             });
         }
         return {
             version: 1,
             updated_at: typeof candidate.updated_at === "string" ? candidate.updated_at : nowIso(),
-            horizon_steps: typeof candidate.horizon_steps === "number" && candidate.horizon_steps > 0
-                ? Math.floor(candidate.horizon_steps)
-                : 5,
-            horizon_minutes: typeof candidate.horizon_minutes === "number" && candidate.horizon_minutes > 0
-                ? Math.floor(candidate.horizon_minutes)
-                : 30,
-            time_slice_seconds: typeof candidate.time_slice_seconds === "number" && candidate.time_slice_seconds > 0
-                ? Math.floor(candidate.time_slice_seconds)
-                : 300,
-            reservations,
+            locks,
         };
     }
     catch {
@@ -280,8 +263,8 @@ function parseLease(raw) {
 export function getJobQueuePath() {
     return wsPath(JOB_QUEUE_REL);
 }
-export function getReservationTablePath() {
-    return wsPath(RESERVATION_TABLE_REL);
+export function getJobLockTablePath() {
+    return wsPath(JOB_LOCK_TABLE_REL);
 }
 export function getSchedulerLeasePath() {
     return wsPath(SCHEDULER_LEASE_REL);
@@ -292,11 +275,11 @@ export function readJobQueue() {
         return defaultQueueFile();
     return parseQueueFile(raw) ?? defaultQueueFile();
 }
-export function readReservationTable() {
-    const raw = safeRead(RESERVATION_TABLE_REL);
+export function readJobLockTable() {
+    const raw = safeRead(JOB_LOCK_TABLE_REL);
     if (isReadError(raw))
-        return defaultReservationFile();
-    return parseReservationFile(raw) ?? defaultReservationFile();
+        return defaultJobLockFile();
+    return parseJobLockFile(raw) ?? defaultJobLockFile();
 }
 export function readSchedulerLease() {
     const raw = safeRead(SCHEDULER_LEASE_REL);
@@ -308,21 +291,13 @@ function writeQueue(queue) {
     queue.updated_at = nowIso();
     return safeWrite(JOB_QUEUE_REL, JSON.stringify(queue, null, 2));
 }
-function writeReservations(table) {
+function writeJobLocks(table) {
     table.updated_at = nowIso();
-    return safeWrite(RESERVATION_TABLE_REL, JSON.stringify(table, null, 2));
+    return safeWrite(JOB_LOCK_TABLE_REL, JSON.stringify(table, null, 2));
 }
 function writeLease(lease) {
     return safeWrite(SCHEDULER_LEASE_REL, JSON.stringify(lease, null, 2));
 }
-function roundUpToSlice(nowMs, sliceMs) {
-    if (sliceMs <= 0)
-        return nowMs;
-    const remainder = nowMs % sliceMs;
-    if (remainder === 0)
-        return nowMs;
-    return nowMs + (sliceMs - remainder);
-}
 function compareJobs(a, b) {
     const priorityCmp = PRIORITY_WEIGHT[a.priority] - PRIORITY_WEIGHT[b.priority];
     if (priorityCmp !== 0)
@@ -481,59 +456,15 @@ function computeBackoffMs(job) {
     const factor = Math.min(32, 2 ** exponent);
     return base * factor;
 }
-function isReservationActive(record, now) {
-    const end = parseDate(record.time_slice_end);
-    if (!end)
-        return false;
-    if (record.status === "running")
-        return true;
-    if (record.status !== "reserved")
-        return false;
-    return end.getTime() > now.getTime();
+function isJobLockActive(record) {
+    return record.status === "active";
 }
-function markRunningOverruns(queue, table, now, buf) {
-    let released = 0;
-    const byJob = new Map(queue.jobs.map((job) => [job.job_id, job]));
-    for (const reservation of table.reservations) {
-        if (reservation.status !== "running")
-            continue;
-        const end = parseDate(reservation.time_slice_end);
-        if (!end || end.getTime() >= now.getTime())
-            continue;
-        reservation.status = "released";
-        reservation.overrun = true;
-        reservation.reason_code = "overrun";
-        released += 1;
-        const job = byJob.get(reservation.job_id);
-        if (!job)
-            continue;
-        if (job.status === "running") {
-            job.status = "blocked";
-            job.reason_code = "overrun";
-            job.error = `Time-slice overrun at ${reservation.time_slice_end}`;
-            const nextAttempt = new Date(now.getTime() + computeBackoffMs(job));
-            job.next_attempt_at = nowIso(nextAttempt);
-            buf.status.push({
-                event_type: "SCHEDULER_OVERRUN",
-                status: "blocked",
-                summary: `Job ${job.job_id} overran slice ending ${reservation.time_slice_end}`,
-                payload: {
-                    job_id: job.job_id,
-                    reservation_id: reservation.reservation_id,
-                    slice_end: reservation.time_slice_end,
-                    next_attempt_at: job.next_attempt_at,
-                },
-            });
-        }
-    }
-    return released;
-}
-function buildOccupancy(reservations, now) {
+function buildOccupancy(locks) {
     const occupied = new Set();
-    for (const reservation of reservations) {
-        if (!isReservationActive(reservation, now))
+    for (const lock of locks) {
+        if (!isJobLockActive(lock))
             continue;
-        occupied.add(`${reservation.resource}::${reservation.time_slice_start}`);
+        occupied.add(lock.resource);
     }
     return occupied;
 }
@@ -543,14 +474,11 @@ function deriveOwner(input) {
         return trimmed;
     return "capability-ops";
 }
-function defaultLeaseTtlSeconds(horizonSteps, timeSliceSeconds) {
-    return Math.min(3600, Math.max(60, Math.max(2, horizonSteps) * timeSliceSeconds));
-}
-function defaultRunningLivenessSeconds(timeSliceSeconds) {
-    return Math.max(300, timeSliceSeconds * 2);
+function defaultLeaseTtlSeconds() {
+    return 1800;
 }
-function hasActiveReservationForJob(reservations, jobId, now) {
-    return reservations.some((reservation) => reservation.job_id === jobId && isReservationActive(reservation, now));
+function hasActiveLockForJob(locks, jobId) {
+    return locks.some((lock) => lock.job_id === jobId && isJobLockActive(lock));
 }
 function acquireLease(owner, ttlSeconds, now) {
     const existing = readSchedulerLease();
@@ -593,47 +521,124 @@ function hasActiveLeaseForOwner(lease, owner, now) {
         return false;
     return expires.getTime() > now.getTime();
 }
-function releaseReservationsForRecoveredJob(table, jobId, reasonCode) {
-    for (const reservation of table.reservations) {
-        if (reservation.job_id !== jobId)
+function ensureLeaseForOwner(owner, now, ttlSeconds = defaultLeaseTtlSeconds()) {
+    const leaseResult = acquireLease(owner, ttlSeconds, now);
+    if (!leaseResult.acquired) {
+        return leaseResult;
+    }
+    const refreshedLease = {
+        ...leaseResult.lease,
+        owner,
+        heartbeat_at: nowIso(now),
+        expires_at: nowIso(new Date(now.getTime() + ttlSeconds * 1000)),
+    };
+    writeLease(refreshedLease);
+    return {
+        ...leaseResult,
+        lease: refreshedLease,
+    };
+}
+function releaseLocksForRecoveredJob(table, jobId, reasonCode, now) {
+    for (const lock of table.locks) {
+        if (lock.job_id !== jobId)
             continue;
-        if (reservation.status !== "running" && reservation.status !== "reserved")
+        if (lock.status !== "active")
             continue;
-        reservation.status = "released";
-        reservation.reason_code = reasonCode;
+        lock.status = "released";
+        lock.reason_code = reasonCode;
+        lock.released_at = nowIso(now);
+        lock.heartbeat_at = nowIso(now);
     }
 }
-function reconcileRecoveryState(queue, table, now, timeSliceSeconds, recoveryMode, buf) {
+function heartbeatRunningLocks(table, leaseId, now) {
+    for (const lock of table.locks) {
+        if (lock.status !== "active")
+            continue;
+        lock.lease_id = leaseId;
+        lock.heartbeat_at = nowIso(now);
+    }
+}
+function startJobNow(job, table, lease, now, buf, sourceTool) {
+    const acquiredAt = nowIso(now);
+    const resources = normalizeResources(job.resource_requirements);
+    for (const lock of table.locks) {
+        if (lock.job_id !== job.job_id)
+            continue;
+        if (lock.status === "active") {
+            lock.heartbeat_at = acquiredAt;
+            lock.lease_id = lease.lease_id;
+        }
+    }
+    const existingResources = new Set(table.locks
+        .filter((row) => row.job_id === job.job_id && row.status === "active")
+        .map((row) => row.resource));
+    for (const resource of resources) {
+        if (existingResources.has(resource))
+            continue;
+        table.locks.push({
+            lock_id: `LOCK-${randomUUID().slice(0, 12)}`,
+            job_id: job.job_id,
+            phase: "dispatch",
+            resource,
+            status: "active",
+            priority: job.priority,
+            lease_id: lease.lease_id,
+            acquired_at: acquiredAt,
+            heartbeat_at: acquiredAt,
+            created_at: acquiredAt,
+        });
+    }
+    job.status = "running";
+    job.started_at = acquiredAt;
+    job.error = undefined;
+    job.reason_code = undefined;
+    buf.status.push({
+        event_type: "SCHEDULER_JOB_STARTED",
+        status: "in_progress",
+        summary: `Started job ${job.job_id}`,
+        payload: {
+            job_id: job.job_id,
+            acquired_at: acquiredAt,
+            resources,
+            source_tool: sourceTool,
+        },
+    });
+    buf.ledger.push({
+        tool: sourceTool,
+        category: "major_update",
+        message: `Started scheduler job ${job.job_id}`,
+        artifacts: ["agent-state/job-queue.json", "agent-state/job-locks.json"],
+        metadata: {
+            job_id: job.job_id,
+            acquired_at: acquiredAt,
+            resources,
+        },
+    });
+    return { acquired_at: acquiredAt, resources };
+}
+function reconcileRecoveryState(queue, table, now, recoveryMode, buf) {
     let recovered = 0;
-    const livenessCutoffMs = now.getTime() - defaultRunningLivenessSeconds(timeSliceSeconds) * 1000;
     for (const job of queue.jobs) {
         if (job.status === "unknown_recovery") {
-            releaseReservationsForRecoveredJob(table, job.job_id, "recovery_hold");
+            releaseLocksForRecoveredJob(table, job.job_id, "recovery_hold", now);
             continue;
         }
         if (job.status !== "running")
             continue;
-        const runningReservations = table.reservations.filter((reservation) => reservation.job_id === job.job_id && reservation.status === "running");
-        const missingReservationState = runningReservations.length === 0;
-        const allRunningSlicesExpired = runningReservations.length > 0 &&
-            runningReservations.every((reservation) => {
-                const end = parseDate(reservation.time_slice_end);
-                return !end || end.getTime() < now.getTime();
-            });
-        const started = parseDate(job.started_at);
-        const livenessExceeded = started ? started.getTime() <= livenessCutoffMs : false;
-        if (!missingReservationState && !(recoveryMode && (allRunningSlicesExpired || livenessExceeded))) {
+        const runningLocks = table.locks.filter((lock) => lock.job_id === job.job_id && lock.status === "active");
+        const missingLockState = runningLocks.length === 0;
+        if (!missingLockState && !recoveryMode) {
             continue;
         }
         const previousStatus = job.status;
-        const reasonCode = missingReservationState ? "recovery_missing_reservation" : "crash_recovery";
+        const reasonCode = missingLockState ? "recovery_missing_lock" : "lease_recovered";
         job.status = "unknown_recovery";
         job.reason_code = reasonCode;
-        job.error = missingReservationState
-            ? "Running job lost reservation state and requires manual recovery."
-            : `Running job exceeded recovery threshold at ${nowIso(now)}`;
+        job.error = missingLockState
+            ? "Running job lost its resource lock state and requires manual recovery."
+            : `Running job lease was recovered by another owner at ${nowIso(now)}`;
         job.next_attempt_at = undefined;
-        releaseReservationsForRecoveredJob(table, job.job_id, "crash_recovery");
+        releaseLocksForRecoveredJob(table, job.job_id, "crash_recovery", now);
         recovered += 1;
         buf.status.push({
             event_type: "SCHEDULER_RECOVERY",
@@ -786,7 +791,6 @@ export async function acknowledgeJob(input) {
                 job.next_attempt_at = undefined;
                 if (wasUnknownRecovery) {
                     job.started_at = undefined;
-                    job.reserved_at = undefined;
                 }
             }
         }
@@ -826,24 +830,15 @@ export async function acknowledgeJob(input) {
     await flushTransitionEvents(buf);
     return result;
 }
-export async function runSchedulerTick(input = {}) {
+export async function dispatchJobs(input = {}) {
     const buf = newEventBuffer();
     const result = await withFileLock(SCHEDULER_LOCK_REL, () => {
         const owner = deriveOwner(input.owner);
         const now = parseDate(input.now_iso) ?? new Date();
-        const table = readReservationTable();
-        const horizonSteps = typeof input.horizon_steps === "number" && input.horizon_steps > 0
-            ? Math.floor(input.horizon_steps)
-            : table.horizon_steps;
-        const horizonMinutes = typeof input.horizon_minutes === "number" && input.horizon_minutes > 0
-            ? Math.floor(input.horizon_minutes)
-            : table.horizon_minutes;
-        const timeSliceSeconds = typeof input.time_slice_seconds === "number" && input.time_slice_seconds > 0
-            ? Math.floor(input.time_slice_seconds)
-            : table.time_slice_seconds;
+        const table = readJobLockTable();
         const leaseTtl = typeof input.lease_ttl_seconds === "number" && input.lease_ttl_seconds > 0
             ? Math.floor(input.lease_ttl_seconds)
-            : defaultLeaseTtlSeconds(horizonSteps, timeSliceSeconds);
+            : defaultLeaseTtlSeconds();
         const leaseResult = acquireLease(owner, leaseTtl, now);
         if (!leaseResult.acquired) {
             const queue = readJobQueue();
@@ -853,18 +848,16 @@ export async function runSchedulerTick(input = {}) {
                 lease_acquired: false,
                 lease: leaseResult.lease,
                 queue_path: getJobQueuePath(),
-                reservation_path: getReservationTablePath(),
+                lock_path: getJobLockTablePath(),
                 queue,
-                reservations: table,
+                locks: table,
                 summary: {
                     total_jobs: queue.jobs.length,
                     blocked_jobs: queue.jobs.filter((job) => job.status === "blocked").length,
                     ready_jobs: queue.jobs.filter((job) => job.status === "ready").length,
-                    reserved_jobs: queue.jobs.filter((job) => job.status === "reserved").length,
                     running_jobs: queue.jobs.filter((job) => job.status === "running").length,
-                    planned_jobs: 0,
-                    replanned_reservations: 0,
-                    released_overruns: 0,
+                    started_jobs: 0,
+                    recovered_jobs: 0,
                 },
             };
         }
@@ -874,13 +867,8 @@ export async function runSchedulerTick(input = {}) {
             handoffState: readHandoffRegistry(),
             statusEvents: readStatusEvents(500),
         };
-        table.horizon_steps = horizonSteps;
-        table.horizon_minutes = horizonMinutes;
-        table.time_slice_seconds = timeSliceSeconds;
-        const recoveredJobs = reconcileRecoveryState(queue, table, now, timeSliceSeconds, leaseResult.recovery_mode, buf);
-        const releasedOverruns = leaseResult.recovery_mode
-            ? 0
-            : markRunningOverruns(queue, table, now, buf);
+        const recoveredJobs = reconcileRecoveryState(queue, table, now, leaseResult.recovery_mode, buf);
+        heartbeatRunningLocks(table, leaseResult.lease.lease_id, now);
         for (const job of queue.jobs) {
             if (TERMINAL_STATUSES.has(job.status))
                 continue;
@@ -896,75 +884,28 @@ export async function runSchedulerTick(input = {}) {
                 job.reason_code = blocks[0]?.reason_code;
                 job.error = blocks[0]?.detail;
             }
-            else if (job.status !== "reserved") {
+            else {
                 job.status = "ready";
                 job.reason_code = undefined;
                 job.error = undefined;
             }
         }
-        let replannedReservations = 0;
-        for (const reservation of table.reservations) {
-            if (reservation.status !== "reserved")
-                continue;
-            const start = parseDate(reservation.time_slice_start);
-            if (!start || start.getTime() <= now.getTime())
-                continue;
-            reservation.status = "released";
-            reservation.reason_code = "replanned";
-            replannedReservations += 1;
-        }
-        for (const job of queue.jobs) {
-            if (job.status !== "reserved")
-                continue;
-            if (!hasActiveReservationForJob(table.reservations, job.job_id, now)) {
-                job.status = "ready";
-            }
-        }
-        const occupancy = buildOccupancy(table.reservations, now);
+        const occupancy = buildOccupancy(table.locks);
         const readyJobs = queue.jobs
             .filter((job) => job.status === "ready")
             .sort(compareJobs);
-        const plannedJobs = new Set();
-        const sliceMs = timeSliceSeconds * 1000;
-        const startMs = roundUpToSlice(now.getTime(), sliceMs);
-        const horizonEndMs = Math.min(startMs + horizonMinutes * 60_000, startMs + Math.max(1, horizonSteps) * sliceMs);
+        let startedJobs = 0;
         for (const job of readyJobs) {
-            if (plannedJobs.size >= horizonSteps)
-                break;
             const resources = normalizeResources(job.resource_requirements);
-            let selectedMs;
-            for (let cursor = startMs; cursor < horizonEndMs; cursor += sliceMs) {
-                const startIso = new Date(cursor).toISOString();
-                const free = resources.every((resource) => !occupancy.has(`${resource}::${startIso}`));
-                if (free) {
-                    selectedMs = cursor;
-                    break;
-                }
-            }
-            if (selectedMs === undefined) {
-                job.status = "ready";
+            const free = resources.every((resource) => !occupancy.has(resource));
+            if (!free) {
                 continue;
             }
-            const startIso = new Date(selectedMs).toISOString();
-            const endIso = new Date(selectedMs + sliceMs).toISOString();
             for (const resource of resources) {
-                table.reservations.push({
-                    reservation_id: `RSV-${randomUUID().slice(0, 12)}`,
-                    job_id: job.job_id,
-                    phase: "dispatch",
-                    resource,
-                    time_slice_start: startIso,
-                    time_slice_end: endIso,
-                    status: "reserved",
-                    priority: job.priority,
-                    lease_id: leaseResult.lease.lease_id,
-                    created_at: nowIso(now),
-                });
-                occupancy.add(`${resource}::${startIso}`);
+                occupancy.add(resource);
             }
-            job.status = "reserved";
-            job.reserved_at = nowIso(now);
-            plannedJobs.add(job.job_id);
+            startJobNow(job, table, leaseResult.lease, now, buf, "dispatch_jobs");
+            startedJobs += 1;
         }
         const refreshedLease = {
             ...leaseResult.lease,
@@ -974,21 +915,19 @@ export async function runSchedulerTick(input = {}) {
         };
         writeLease(refreshedLease);
         const finalQueuePath = writeQueue(queue);
-        const finalReservationPath = writeReservations(table);
+        const finalLockPath = writeJobLocks(table);
         const summary = {
             total_jobs: queue.jobs.length,
             blocked_jobs: queue.jobs.filter((job) => job.status === "blocked").length,
             ready_jobs: queue.jobs.filter((job) => job.status === "ready").length,
-            reserved_jobs: queue.jobs.filter((job) => job.status === "reserved").length,
             running_jobs: queue.jobs.filter((job) => job.status === "running").length,
-            planned_jobs: plannedJobs.size,
-            replanned_reservations: replannedReservations,
-            released_overruns: releasedOverruns + recoveredJobs,
+            started_jobs: startedJobs,
+            recovered_jobs: recoveredJobs,
         };
         buf.status.push({
             event_type: "SCHEDULER_TICK",
             status: "pass",
-            summary: `Tick planned=${summary.planned_jobs} ready=${summary.ready_jobs} reserved=${summary.reserved_jobs} recovered=${recoveredJobs} overruns=${releasedOverruns}`,
+            summary: `Dispatch started=${summary.started_jobs} ready=${summary.ready_jobs} running=${summary.running_jobs} recovered=${recoveredJobs}`,
             payload: {
                 owner,
                 lease_acquired: true,
@@ -998,14 +937,10 @@ export async function runSchedulerTick(input = {}) {
             },
         });
         buf.ledger.push({
-            tool: "run_scheduler_tick",
-            category: summary.planned_jobs > 0 ||
-                summary.replanned_reservations > 0 ||
-                summary.released_overruns > 0
-                ? "major_update"
-                : "info",
-            message: `Scheduler tick complete (planned=${summary.planned_jobs}, reserved=${summary.reserved_jobs})`,
-            artifacts: ["agent-state/job-queue.json", "agent-state/job-reservations.json"],
+            tool: "dispatch_jobs",
+            category: summary.started_jobs > 0 || summary.recovered_jobs > 0 ? "major_update" : "info",
+            message: `Scheduler dispatch complete (started=${summary.started_jobs}, running=${summary.running_jobs})`,
+            artifacts: ["agent-state/job-queue.json", "agent-state/job-locks.json"],
             metadata: {
                 owner,
                 lease_id: refreshedLease.lease_id,
@@ -1020,117 +955,129 @@ export async function runSchedulerTick(input = {}) {
             lease_acquired: true,
             lease: refreshedLease,
             queue_path: finalQueuePath,
-            reservation_path: finalReservationPath,
+            lock_path: finalLockPath,
             queue,
-            reservations: table,
+            locks: table,
             summary,
         };
     });
     await flushTransitionEvents(buf);
     return result;
 }
-export async function startReservedJob(input) {
+export async function dispatchJobNow(input) {
     const buf = newEventBuffer();
     const result = await withFileLock(SCHEDULER_LOCK_REL, () => {
         const owner = deriveOwner(input.owner);
         const now = parseDate(input.now_iso) ?? new Date();
-        const lease = readSchedulerLease();
-        if (!hasActiveLeaseForOwner(lease, owner, now)) {
+        const leaseResult = ensureLeaseForOwner(owner, now);
+        if (!leaseResult.acquired) {
             return {
                 ok: false,
                 queue_path: getJobQueuePath(),
-                reservation_path: getReservationTablePath(),
+                lock_path: getJobLockTablePath(),
                 queue: readJobQueue(),
-                reservations: readReservationTable(),
+                locks: readJobLockTable(),
                 error: `Owner ${owner} does not hold an active scheduler lease.`,
             };
         }
         const queue = readJobQueue();
-        const table = readReservationTable();
+        const table = readJobLockTable();
         const job = queue.jobs.find((row) => row.job_id === input.job_id);
         if (!job) {
             return {
                 ok: false,
                 queue_path: getJobQueuePath(),
-                reservation_path: getReservationTablePath(),
+                lock_path: getJobLockTablePath(),
                 queue,
-                reservations: table,
+                locks: table,
                 error: `Unknown job_id: ${input.job_id}`,
             };
         }
-        const candidate = table.reservations
-            .filter((row) => row.job_id === input.job_id && row.status === "reserved")
-            .sort((a, b) => Date.parse(a.time_slice_start) - Date.parse(b.time_slice_start))[0];
-        if (!candidate) {
+        if (job.status === "unknown_recovery") {
             return {
                 ok: false,
                 queue_path: getJobQueuePath(),
-                reservation_path: getReservationTablePath(),
+                lock_path: getJobLockTablePath(),
                 queue,
-                reservations: table,
-                error: `No reserved slice found for ${input.job_id}`,
+                locks: table,
+                error: `Job ${input.job_id} is parked in unknown_recovery; resume it before dispatch.`,
             };
         }
-        const start = parseDate(candidate.time_slice_start);
-        const end = parseDate(candidate.time_slice_end);
-        if (!start || !end || now.getTime() < start.getTime() || now.getTime() > end.getTime()) {
+        if (TERMINAL_STATUSES.has(job.status)) {
             return {
                 ok: false,
                 queue_path: getJobQueuePath(),
-                reservation_path: getReservationTablePath(),
+                lock_path: getJobLockTablePath(),
                 queue,
-                reservations: table,
-                error: `Current time is outside reserved slice ${candidate.time_slice_start} - ${candidate.time_slice_end}`,
+                locks: table,
+                error: `Job ${input.job_id} is ${job.status} and cannot be started.`,
             };
         }
-        for (const row of table.reservations) {
-            if (row.job_id === input.job_id &&
-                row.status === "reserved" &&
-                row.time_slice_start === candidate.time_slice_start) {
-                row.status = "running";
-            }
+        if (job.status === "running") {
+            const runningResources = table.locks
+                .filter((row) => row.job_id === input.job_id && row.status === "active")
+                .map((row) => row.resource);
+            const acquiredAt = table.locks.find((row) => row.job_id === input.job_id && row.status === "active")
+                ?.acquired_at ??
+                job.started_at ??
+                nowIso(now);
+            heartbeatRunningLocks(table, leaseResult.lease.lease_id, now);
+            const queuePath = writeQueue(queue);
+            const lockPath = writeJobLocks(table);
+            return {
+                ok: true,
+                queue_path: queuePath,
+                lock_path: lockPath,
+                queue,
+                locks: table,
+                started_lock: {
+                    acquired_at: acquiredAt,
+                    resources: runningResources,
+                },
+            };
+        }
+        const dependencyContext = {
+            todoState: readTodoState(),
+            handoffState: readHandoffRegistry(),
+            statusEvents: readStatusEvents(500),
+        };
+        const blocks = evaluateDependencyBlocks(job, now, dependencyContext);
+        if (blocks.length > 0) {
+            return {
+                ok: false,
+                queue_path: getJobQueuePath(),
+                lock_path: getJobLockTablePath(),
+                queue,
+                locks: table,
+                error: blocks[0]?.detail ?? `Job ${input.job_id} is blocked.`,
+            };
+        }
+        const occupancy = buildOccupancy(table.locks);
+        const resources = normalizeResources(job.resource_requirements);
+        const busy = resources.find((resource) => table.locks.some((row) => row.job_id !== input.job_id && row.resource === resource && row.status === "active"));
+        if (busy) {
+            return {
+                ok: false,
+                queue_path: getJobQueuePath(),
+                lock_path: getJobLockTablePath(),
+                queue,
+                locks: table,
+                error: `Resource ${busy} is already held by another running job.`,
+            };
+        }
+        for (const resource of resources) {
+            occupancy.add(resource);
         }
-        job.status = "running";
-        job.started_at = nowIso(now);
-        job.error = undefined;
-        job.reason_code = undefined;
+        const startedLock = startJobNow(job, table, leaseResult.lease, now, buf, "dispatch_job_now");
         const queuePath = writeQueue(queue);
-        const reservationPath = writeReservations(table);
-        buf.status.push({
-            event_type: "SCHEDULER_JOB_STARTED",
-            status: "in_progress",
-            summary: `Started reserved job ${input.job_id}`,
-            payload: {
-                job_id: input.job_id,
-                started_slice: {
-                    start: candidate.time_slice_start,
-                    end: candidate.time_slice_end,
-                },
-            },
-        });
-        buf.ledger.push({
-            tool: "start_reserved_job",
-            category: "major_update",
-            message: `Started reserved job ${input.job_id}`,
-            artifacts: ["agent-state/job-queue.json", "agent-state/job-reservations.json"],
-            metadata: {
-                job_id: input.job_id,
-                started_slice: {
-                    start: candidate.time_slice_start,
-                    end: candidate.time_slice_end,
-                },
-            },
-        });
+        const lockPath = writeJobLocks(table);
         return {
             ok: true,
             queue_path: queuePath,
-            reservation_path: reservationPath,
+            lock_path: lockPath,
             queue,
-            reservations: table,
-            started_slice: {
-                start: candidate.time_slice_start,
-                end: candidate.time_slice_end,
-            },
+            locks: table,
+            started_lock: startedLock,
         };
     });
     await flushTransitionEvents(buf);
@@ -1141,27 +1088,27 @@ export async function completeJob(input) {
     const result = await withFileLock(SCHEDULER_LOCK_REL, () => {
         const owner = deriveOwner(input.owner);
         const now = parseDate(input.now_iso) ?? new Date();
-        const lease = readSchedulerLease();
-        if (!hasActiveLeaseForOwner(lease, owner, now)) {
+        const leaseResult = ensureLeaseForOwner(owner, now);
+        if (!leaseResult.acquired) {
             return {
                 ok: false,
                 queue_path: getJobQueuePath(),
-                reservation_path: getReservationTablePath(),
+                lock_path: getJobLockTablePath(),
                 queue: readJobQueue(),
-                reservations: readReservationTable(),
+                locks: readJobLockTable(),
                 error: `Owner ${owner} does not hold an active scheduler lease.`,
             };
         }
         const queue = readJobQueue();
-        const table = readReservationTable();
+        const table = readJobLockTable();
         const job = queue.jobs.find((row) => row.job_id === input.job_id);
         if (!job) {
             return {
                 ok: false,
                 queue_path: getJobQueuePath(),
-                reservation_path: getReservationTablePath(),
+                lock_path: getJobLockTablePath(),
                 queue,
-                reservations: table,
+                locks: table,
                 error: `Unknown job_id: ${input.job_id}`,
             };
         }
@@ -1169,34 +1116,32 @@ export async function completeJob(input) {
             return {
                 ok: false,
                 queue_path: getJobQueuePath(),
-                reservation_path: getReservationTablePath(),
+                lock_path: getJobLockTablePath(),
                 queue,
-                reservations: table,
+                locks: table,
                 error: `Job ${input.job_id} is ${job.status}; only running jobs can be completed.`,
             };
         }
-        const runningReservations = table.reservations.filter((reservation) => reservation.job_id === input.job_id && reservation.status === "running");
-        if (runningReservations.length === 0) {
+        const runningLocks = table.locks.filter((lock) => lock.job_id === input.job_id && lock.status === "active");
+        if (runningLocks.length === 0) {
             return {
                 ok: false,
                 queue_path: getJobQueuePath(),
-                reservation_path: getReservationTablePath(),
+                lock_path: getJobLockTablePath(),
                 queue,
-                reservations: table,
-                error: `Job ${input.job_id} has no running reservation slices.`,
+                locks: table,
+                error: `Job ${input.job_id} has no active resource locks.`,
             };
         }
         const success = input.success !== false;
-        for (const reservation of table.reservations) {
-            if (reservation.job_id !== input.job_id)
+        for (const lock of table.locks) {
+            if (lock.job_id !== input.job_id)
                 continue;
-            if (reservation.status === "running") {
-                reservation.status = success ? "completed" : "failed";
-                reservation.reason_code = success ? undefined : "execution_failed";
-            }
-            else if (reservation.status === "reserved") {
-                reservation.status = "released";
-                reservation.reason_code = success ? "job_completed" : "retry_scheduled";
+            if (lock.status === "active") {
+                lock.status = success ? "completed" : "failed";
+                lock.reason_code = success ? undefined : "execution_failed";
+                lock.released_at = nowIso(now);
+                lock.heartbeat_at = nowIso(now);
             }
         }
         if (success) {
@@ -1222,10 +1167,11 @@ export async function completeJob(input) {
                 job.status = "blocked";
                 job.reason_code = "retry_scheduled";
                 job.next_attempt_at = nowIso(retryAt);
+                job.started_at = undefined;
             }
         }
         const queuePath = writeQueue(queue);
-        const reservationPath = writeReservations(table);
+        const lockPath = writeJobLocks(table);
         const finalStatus = job.status;
         const isSuccess = finalStatus === "done";
         buf.status.push({
@@ -1248,7 +1194,7 @@ export async function completeJob(input) {
             message: isSuccess
                 ? `Completed scheduler job ${input.job_id}`
                 : `Scheduler job ${input.job_id} ended with ${finalStatus}`,
-            artifacts: ["agent-state/job-queue.json", "agent-state/job-reservations.json"],
+            artifacts: ["agent-state/job-queue.json", "agent-state/job-locks.json"],
             metadata: {
                 job_id: input.job_id,
                 final_status: finalStatus,
@@ -1258,9 +1204,9 @@ export async function completeJob(input) {
         return {
             ok: true,
             queue_path: queuePath,
-            reservation_path: reservationPath,
+            lock_path: lockPath,
             queue,
-            reservations: table,
+            locks: table,
             status: job.status,
             retry_scheduled_for: job.next_attempt_at,
         };