cool-workflow 0.1.98 → 0.2.0

package/dist/{scheduler.js → shell/scheduler-io.js}

@@ -1,30 +1,75 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+// shell/scheduler-io.ts — Scheduler (cw schedule/loop), the daemon tick
+// (cw schedule daemon), and routine triggers (cw routine).
+//
+// MILESTONE 10 (v2/PLAN.md build order, step 10). Byte-exact port of the
+// old build's src/scheduler.ts + src/daemon.ts + src/triggers.ts. Reuses
+// shell/fs-atomic.ts's `withFileLock`/`readJson`/`writeJson`/`safeFileName`
+// directly (no reimplementation).
+//
+// Two separate systems, never merged (SPEC/scheduling-registry.md
+// "Rebuild risks" #4): `Scheduler`/`DesktopSchedulerDaemon`/
+// `RoutineTriggerBridge` here are WALL-CLOCK tasks under
+// `<cwd>/.cw/schedules/` and `<cwd>/.cw/routines/`; `cw sched` (leases
+// over `$CW_HOME/registry/queue.json`) is a completely different system
+// — see shell/scheduling-io.ts. `cw loop` is only sugar for
+// `schedule create --kind loop`.
+//
+// Evidence: SPEC/scheduling-registry.md sections A, B;
+// plugins/cool-workflow/src/scheduler.ts, src/daemon.ts, src/triggers.ts
+// (byte-exact source).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Scheduler = void 0;
-const node_crypto_1 = __importDefault(require("node:crypto"));
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const state_1 = require("./state");
+exports.RoutineTriggerBridge = exports.DesktopSchedulerDaemon = exports.Scheduler = void 0;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const fs_atomic_1 = require("./fs-atomic");
 const DEFAULT_TTL_DAYS = 7;
+// ---------------------------------------------------------------------------
+// Scheduler — cw schedule / cw loop
+// ---------------------------------------------------------------------------
 class Scheduler {
     cwd;
     storePath;
     constructor(cwd = process.cwd()) {
-        this.cwd = node_path_1.default.resolve(cwd);
-        this.storePath = node_path_1.default.join(this.cwd, ".cw", "schedules", "tasks.json");
-    }
-    // Every mutation is a cross-process read-modify-write of the one store file
-    // (the daemon polls `due` while CLI calls create/complete/delete concurrently).
-    // Without serialization two writers both load, both atomically rename their
-    // copy back, and the second silently clobbers the first's new task / status /
-    // history record. `locked` holds the same advisory lock the queue and
-    // reclamation stores already use. Reads (list/history) need no lock: the atomic
-    // rename means a reader always sees a whole old-or-new store.
+        this.cwd = path.resolve(cwd);
+        this.storePath = path.join(this.cwd, ".cw", "schedules", "tasks.json");
+    }
     locked(fn) {
-        return (0, state_1.withFileLock)(this.storePath, fn);
+        return (0, fs_atomic_1.withFileLock)(this.storePath, fn);
     }
     create(options) {
         const kind = normalizeKind(options.kind);
@@ -51,7 +96,7 @@ class Scheduler {
             cron,
             jitterSeconds,
             maxRuns: numberOption(options.maxRuns),
-            runCount: 0
+            runCount: 0,
         };
         return this.locked(() => {
             const store = this.load();
@@ -171,19 +216,17 @@ class Scheduler {
         });
     }
     load() {
-        if (!node_fs_1.default.existsSync(this.storePath))
+        if (!fs.existsSync(this.storePath))
             return { schemaVersion: 1, tasks: [], history: [] };
-        const value = (0, state_1.readJson)(this.storePath);
+        const value = (0, fs_atomic_1.readJson)(this.storePath);
         return {
             schemaVersion: 1,
             tasks: Array.isArray(value.tasks) ? value.tasks : [],
-            history: Array.isArray(value.history) ? value.history : []
+            history: Array.isArray(value.history) ? value.history : [],
         };
     }
     save(store) {
-        // Authoritative scheduler store — atomic + durable (v0.1.40). writeJson is now
-        // always atomic (temp → rename), so a crash mid-write can never truncate it.
-        (0, state_1.writeJson)(this.storePath, store, { durable: true });
+        (0, fs_atomic_1.writeJson)(this.storePath, store, { durable: true });
     }
 }
 exports.Scheduler = Scheduler;
@@ -203,7 +246,7 @@ function createHistoryRecord(task, status, cwd, now) {
         prompt: task.prompt,
         cwd,
         workflowId: task.workflowId,
-        runId: task.runId
+        runId: task.runId,
     };
 }
 function normalizeKind(value) {
@@ -259,47 +302,38 @@ function matchesCron(value, expr, min, max) {
         return Number.isInteger(parsed) && parsed >= min && parsed <= max && parsed === value;
     });
 }
-// Deterministic jitter (replay-determinism self-audit): the jittered Date is NOT a
-// runtime-only sleep — it lands in persisted/replayed state (task.nextRunAt and,
-// transitively, the schedule store), so a Math.random() offset broke replay
-// determinism. The spread (0..jitterSeconds) is now derived from a content hash of
-// the base instant, so the same base time + jitter window always yields the same
-// offset; distinct base times still spread out across the window. The base Date is
-// itself an edge timestamp that is recorded once.
+/** Deterministic jitter: `sha256(baseMs) mod (jitterSeconds+1)` seconds —
+ *  a pure function of the base time, no randomness, so it stays replay-
+ *  determinstic even though it lands in persisted state. */
 function addJitter(date, jitterSeconds) {
     if (!jitterSeconds)
         return date;
-    const digest = node_crypto_1.default.createHash("sha256").update(`${date.getTime()}`).digest();
+    const digest = crypto.createHash("sha256").update(`${date.getTime()}`).digest();
     const seconds = digest.readUInt32BE(0) % (jitterSeconds + 1);
     return new Date(date.getTime() + seconds * 1000);
 }
-// Deterministic schedule id (replay-determinism self-audit): the stamp is an edge
-// timestamp (recorded once). Set CW_DETERMINISTIC_RUN_IDS=1 to use a
-// content-hash-based id without wall-clock, so re-deriving the id for a recorded
-// schedule yields the byte-identical value. Distinct instants still get distinct
-// ids via the monotonic counter.
 let scheduleIdSequence = 0;
 function createScheduleId(kind) {
     const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "Z");
     scheduleIdSequence += 1;
     const deterministic = /^(1|true|yes|on)$/i.test(process.env.CW_DETERMINISTIC_RUN_IDS || "");
-    const suffix = node_crypto_1.default.createHash("sha256")
+    const suffix = crypto
+        .createHash("sha256")
         .update(deterministic ? `${kind}:${process.pid}:${scheduleIdSequence}` : `${kind}:${stamp}:${process.pid}:${scheduleIdSequence}`)
-        .digest("hex").slice(0, 6);
+        .digest("hex")
+        .slice(0, 6);
     return deterministic ? `${kind}-${suffix}` : `${kind}-${stamp}-${suffix}`;
 }
-// Deterministic schedule-run (history) id — same rationale as createScheduleId. The
-// history record stamp differs from the owning schedule's, so the hashed identity
-// (kind + run stamp) stays distinct from the schedule id while remaining a pure
-// function of already-recorded state.
 let scheduleRunIdSequence = 0;
 function createScheduleRunId(kind) {
     const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "Z");
     scheduleRunIdSequence += 1;
     const deterministic = /^(1|true|yes|on)$/i.test(process.env.CW_DETERMINISTIC_RUN_IDS || "");
-    const suffix = node_crypto_1.default.createHash("sha256")
+    const suffix = crypto
+        .createHash("sha256")
         .update(deterministic ? `run:${kind}:${process.pid}:${scheduleRunIdSequence}` : `run:${kind}:${stamp}:${process.pid}:${scheduleRunIdSequence}`)
-        .digest("hex").slice(0, 6);
+        .digest("hex")
+        .slice(0, 6);
     return deterministic ? `run-${kind}-${suffix}` : `run-${kind}-${stamp}-${suffix}`;
 }
 function requiredString(value, name) {
@@ -319,3 +353,169 @@ function numberOption(value) {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : undefined;
 }
+class DesktopSchedulerDaemon {
+    cwd;
+    intervalSeconds;
+    scheduler;
+    constructor(options = {}) {
+        this.cwd = path.resolve(String(options.cwd || process.cwd()));
+        this.intervalSeconds = Number(options.intervalSeconds || 60);
+        this.scheduler = new Scheduler(this.cwd);
+    }
+    tick() {
+        const due = this.scheduler.due();
+        const checkedAt = new Date().toISOString();
+        const inboxPath = path.join(this.cwd, ".cw", "schedules", "due-inbox.json");
+        (0, fs_atomic_1.writeJson)(inboxPath, { schemaVersion: 1, checkedAt, due });
+        return { checkedAt, dueCount: due.length, dueIds: due.map((task) => task.id), inboxPath };
+    }
+    async run() {
+        fs.mkdirSync(path.join(this.cwd, ".cw", "schedules"), { recursive: true });
+        process.stdout.write(`${JSON.stringify(this.tick())}\n`);
+        setInterval(() => {
+            process.stdout.write(`${JSON.stringify(this.tick())}\n`);
+        }, Math.max(1, this.intervalSeconds) * 1000);
+    }
+}
+exports.DesktopSchedulerDaemon = DesktopSchedulerDaemon;
+class RoutineTriggerBridge {
+    cwd;
+    storePath;
+    payloadsDir;
+    constructor(cwd = process.cwd()) {
+        this.cwd = path.resolve(cwd);
+        this.storePath = path.join(this.cwd, ".cw", "routines", "triggers.json");
+        this.payloadsDir = path.join(this.cwd, ".cw", "routines", "payloads");
+    }
+    create(options) {
+        const now = new Date().toISOString();
+        const store = this.load();
+        // Monotonic id, NOT triggers.length: delete shrinks the collection, so
+        // a length-based seq would reuse a live id after delete+create.
+        const seq = (store.nextTriggerSeq || 0) + 1;
+        store.nextTriggerSeq = seq;
+        const trigger = {
+            id: createTriggerId(normalizeTriggerKind(options.kind), seq),
+            kind: normalizeTriggerKind(options.kind),
+            createdAt: now,
+            updatedAt: now,
+            source: String(options.source || options.kind || "api"),
+            prompt: requiredString(options.prompt, "prompt"),
+            workflowId: stringOption(options.workflowId),
+            runId: stringOption(options.runId),
+            match: parseJsonObject(options.match),
+            metadata: parseJsonObject(options.metadata),
+        };
+        store.triggers.push(trigger);
+        this.save(store);
+        return trigger;
+    }
+    list(kind) {
+        const store = this.load();
+        return kind ? store.triggers.filter((trigger) => trigger.kind === kind) : store.triggers;
+    }
+    delete(id) {
+        const store = this.load();
+        const before = store.triggers.length;
+        store.triggers = store.triggers.filter((trigger) => trigger.id !== id);
+        this.save(store);
+        return { deleted: store.triggers.length !== before, id };
+    }
+    fire(kind, payload) {
+        const normalizedKind = normalizeTriggerKind(kind);
+        const store = this.load();
+        const now = new Date().toISOString();
+        const base = store.events.length;
+        const events = store.triggers
+            .filter((trigger) => trigger.kind === normalizedKind)
+            .map((trigger, index) => this.createEvent(trigger, payload, now, base + index + 1));
+        store.events.push(...events);
+        this.save(store);
+        return events;
+    }
+    events(triggerId) {
+        const store = this.load();
+        return triggerId ? store.events.filter((event) => event.triggerId === triggerId) : store.events;
+    }
+    createEvent(trigger, payload, receivedAt, seq) {
+        const matched = matchesTrigger(trigger.match, payload);
+        const eventId = createEventId(trigger.kind, seq);
+        const payloadPath = path.join(this.payloadsDir, `${(0, fs_atomic_1.safeFileName)(eventId)}.json`);
+        (0, fs_atomic_1.writeJson)(payloadPath, { schemaVersion: 1, trigger, receivedAt, matched, payload });
+        return {
+            id: eventId,
+            triggerId: trigger.id,
+            kind: trigger.kind,
+            receivedAt,
+            matched,
+            prompt: matched ? renderPrompt(trigger, payload) : undefined,
+            payloadPath,
+        };
+    }
+    load() {
+        if (!fs.existsSync(this.storePath))
+            return { schemaVersion: 1, triggers: [], events: [], nextTriggerSeq: 0 };
+        const value = (0, fs_atomic_1.readJson)(this.storePath);
+        const triggers = Array.isArray(value.triggers) ? value.triggers : [];
+        const maxExisting = triggers.reduce((max, trigger) => {
+            const n = Number((String(trigger.id).match(/(\d+)$/) || [])[1] || 0);
+            return Number.isFinite(n) && n > max ? n : max;
+        }, 0);
+        return {
+            schemaVersion: 1,
+            triggers,
+            events: Array.isArray(value.events) ? value.events : [],
+            nextTriggerSeq: Math.max(typeof value.nextTriggerSeq === "number" ? value.nextTriggerSeq : 0, maxExisting),
+        };
+    }
+    save(store) {
+        (0, fs_atomic_1.writeJson)(this.storePath, store);
+    }
+}
+exports.RoutineTriggerBridge = RoutineTriggerBridge;
+function normalizeTriggerKind(value) {
+    const kind = String(value || "api");
+    if (kind === "api" || kind === "github")
+        return kind;
+    throw new Error(`Unsupported routine trigger kind: ${kind}`);
+}
+function matchesTrigger(match, payload) {
+    if (!match || !Object.keys(match).length)
+        return true;
+    if (!payload || typeof payload !== "object")
+        return false;
+    return Object.entries(match).every(([key, expected]) => deepValue(payload, key) === expected);
+}
+function deepValue(value, key) {
+    return key.split(".").reduce((current, part) => {
+        if (!current || typeof current !== "object")
+            return undefined;
+        return current[part];
+    }, value);
+}
+function renderPrompt(trigger, payload) {
+    return `${trigger.prompt}\n\ncw:routine\n${JSON.stringify({ triggerId: trigger.id, kind: trigger.kind, source: trigger.source, workflowId: trigger.workflowId, runId: trigger.runId, payload }, null, 2)}`;
+}
+function parseJsonObject(value) {
+    if (!value || value === true)
+        return undefined;
+    if (typeof value === "object")
+        return value;
+    let parsed;
+    try {
+        parsed = JSON.parse(String(value));
+    }
+    catch {
+        throw new Error("Expected a JSON object, got invalid JSON");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("Expected JSON object");
+    }
+    return parsed;
+}
+function createTriggerId(kind, seq) {
+    return `${kind}-${String(seq).padStart(4, "0")}`;
+}
+function createEventId(kind, seq) {
+    return `event-${kind}-${String(seq).padStart(4, "0")}`;
+}

package/dist/shell/scheduling-io.js

@@ -0,0 +1,311 @@
+"use strict";
+// shell/scheduling-io.ts — Control-Plane Scheduling (`cw sched`): pure
+// lease-plan mechanism over the run-registry-io.ts queue store, plus the
+// policy file IO.
+//
+// MILESTONE 10 (v2/PLAN.md build order, step 10). Byte-exact port of the
+// old build's src/scheduling.ts + the sched-specific slice of
+// src/capability-core.ts. `sched` is a DIFFERENT system from `schedule`
+// (see scheduler-io.ts's file header) — this operates on
+// `$CW_HOME/registry/queue.json` leases, not wall-clock tasks.
+//
+// Evidence: SPEC/scheduling-registry.md section D;
+// plugins/cool-workflow/src/scheduling.ts (byte-exact source).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SCHEDULING_POLICY = exports.SCHEDULING_SCHEMA_VERSION = void 0;
+exports.normalizeSchedulingPolicy = normalizeSchedulingPolicy;
+exports.backoffMs = backoffMs;
+exports.planSchedule = planSchedule;
+exports.applyLease = applyLease;
+exports.retryOrPark = retryOrPark;
+exports.reclaimExpired = reclaimExpired;
+exports.leaseComplete = leaseComplete;
+exports.leaseRelease = leaseRelease;
+exports.resetEntry = resetEntry;
+exports.schedPlanCli = schedPlanCli;
+exports.schedLeaseCli = schedLeaseCli;
+exports.schedReleaseCli = schedReleaseCli;
+exports.schedCompleteCli = schedCompleteCli;
+exports.schedReclaimCli = schedReclaimCli;
+exports.schedResetCli = schedResetCli;
+exports.schedPolicyShowCli = schedPolicyShowCli;
+exports.schedPolicySetCli = schedPolicySetCli;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const fs_atomic_1 = require("./fs-atomic");
+const run_registry_io_1 = require("./run-registry-io");
+exports.SCHEDULING_SCHEMA_VERSION = 1;
+/** Conservative fail-closed defaults: serial, bounded retries, exponential backoff. */
+exports.DEFAULT_SCHEDULING_POLICY = {
+    schemaVersion: 1,
+    maxConcurrent: 1,
+    maxAttempts: 3,
+    leaseTtlMs: 300_000,
+    backoffBaseMs: 1_000,
+    backoffFactor: 2,
+    backoffCapMs: 60_000,
+};
+function normalizeSchedulingPolicy(input) {
+    const base = exports.DEFAULT_SCHEDULING_POLICY;
+    const num = (value, fallback, min) => (typeof value === "number" && Number.isFinite(value) && value >= min ? value : fallback);
+    return {
+        schemaVersion: 1,
+        maxConcurrent: num(input?.maxConcurrent, base.maxConcurrent, 1),
+        maxAttempts: num(input?.maxAttempts, base.maxAttempts, 1),
+        leaseTtlMs: num(input?.leaseTtlMs, base.leaseTtlMs, 1),
+        backoffBaseMs: num(input?.backoffBaseMs, base.backoffBaseMs, 0),
+        backoffFactor: num(input?.backoffFactor, base.backoffFactor, 1),
+        backoffCapMs: num(input?.backoffCapMs, base.backoffCapMs, 0),
+    };
+}
+/** Deterministic backoff: baseMs * factor^(attempts-1), capped. No jitter. */
+function backoffMs(policy, attempts) {
+    const raw = policy.backoffBaseMs * Math.pow(policy.backoffFactor, Math.max(0, attempts - 1));
+    return Math.min(Math.round(raw), policy.backoffCapMs);
+}
+function addMs(now, ms) {
+    return new Date(new Date(now).getTime() + ms).toISOString();
+}
+function leaseActive(entry, now) {
+    return entry.status === "leased" && Boolean(entry.leaseExpiresAt) && entry.leaseExpiresAt > now;
+}
+function leaseExpired(entry, now) {
+    return entry.status === "leased" && (!entry.leaseExpiresAt || entry.leaseExpiresAt <= now);
+}
+function eligible(entry, now) {
+    if (entry.status !== "pending" && entry.status !== "ready")
+        return false;
+    if (entry.nextEligibleAt && entry.nextEligibleAt > now)
+        return false;
+    return true;
+}
+/** Read-only lease plan for the current queue + policy + now. Pure: no mutation. */
+function planSchedule(entries, policy, now) {
+    const sorted = [...entries].sort(run_registry_io_1.compareQueue);
+    const inFlight = sorted.filter((entry) => leaseActive(entry, now)).length;
+    const available = Math.max(0, policy.maxConcurrent - inFlight);
+    const leases = [];
+    const skipped = [];
+    for (const entry of sorted) {
+        if (leaseActive(entry, now))
+            continue;
+        if (entry.status === "parked") {
+            skipped.push({ id: entry.id, reason: "parked" });
+            continue;
+        }
+        if (entry.status === "drained" || entry.status === "cancelled") {
+            skipped.push({ id: entry.id, reason: "terminal" });
+            continue;
+        }
+        if (!eligible(entry, now)) {
+            skipped.push({ id: entry.id, reason: leaseExpired(entry, now) ? "leased" : "backoff" });
+            continue;
+        }
+        if (leases.length >= available) {
+            skipped.push({ id: entry.id, reason: "concurrency-ceiling" });
+            continue;
+        }
+        leases.push({
+            id: entry.id,
+            leaseId: `lease-${entry.id}-${(entry.attempts || 0) + 1}-${now.replace(/[^0-9]/g, "")}`,
+            leaseExpiresAt: addMs(now, policy.leaseTtlMs),
+            attempts: entry.attempts || 0,
+            priority: entry.priority,
+        });
+    }
+    return { schemaVersion: 1, now, maxConcurrent: policy.maxConcurrent, inFlight, available, leases, skipped };
+}
+function applyLease(entries, policy, now, limit) {
+    const plan = planSchedule(entries, policy, now);
+    const granted = typeof limit === "number" ? plan.leases.slice(0, Math.max(0, limit)) : plan.leases;
+    const byId = new Map(granted.map((lease) => [lease.id, lease]));
+    const next = entries.map((entry) => {
+        const lease = byId.get(entry.id);
+        if (!lease)
+            return entry;
+        return { ...entry, status: "leased", leaseId: lease.leaseId, leaseExpiresAt: lease.leaseExpiresAt };
+    });
+    return { entries: next, leases: granted };
+}
+/** A failed/expired attempt: increment attempts, then park (at budget) or
+ *  set ready with backoff. Fail closed — parked is terminal until reset. */
+function retryOrPark(entry, policy, now, reason) {
+    const attempts = (entry.attempts || 0) + 1;
+    const cleared = { ...entry, attempts, leaseId: undefined, leaseExpiresAt: undefined };
+    if (attempts >= policy.maxAttempts) {
+        return { ...cleared, status: "parked", parkedReason: `${reason} (attempt ${attempts}/${policy.maxAttempts})` };
+    }
+    return { ...cleared, status: "ready", nextEligibleAt: addMs(now, backoffMs(policy, attempts)) };
+}
+function reclaimExpired(entries, policy, now) {
+    const reclaimed = [];
+    const next = entries.map((entry) => {
+        if (!leaseExpired(entry, now))
+            return entry;
+        reclaimed.push(entry.id);
+        return retryOrPark(entry, policy, now, "lease expired (host did not complete)");
+    });
+    return { entries: next, reclaimed };
+}
+function leaseComplete(entries, leaseId, now) {
+    let matched = false;
+    const next = entries.map((entry) => {
+        if (entry.leaseId !== leaseId || entry.status !== "leased")
+            return entry;
+        matched = true;
+        return { ...entry, status: "drained", drainedAt: now, leaseId: undefined, leaseExpiresAt: undefined };
+    });
+    return { entries: next, matched };
+}
+function leaseRelease(entries, leaseId, policy, now, options = {}) {
+    let matched = false;
+    const next = entries.map((entry) => {
+        if (entry.leaseId !== leaseId || entry.status !== "leased")
+            return entry;
+        matched = true;
+        if (options.failed)
+            return retryOrPark(entry, policy, now, options.reason || "released as failed");
+        return { ...entry, status: "ready", leaseId: undefined, leaseExpiresAt: undefined };
+    });
+    return { entries: next, matched };
+}
+function resetEntry(entries, id) {
+    let matched = false;
+    const next = entries.map((entry) => {
+        if (entry.id !== id || entry.status !== "parked")
+            return entry;
+        matched = true;
+        return { ...entry, status: "ready", attempts: 0, nextEligibleAt: undefined, parkedReason: undefined };
+    });
+    return { entries: next, matched };
+}
+// ---------------------------------------------------------------------------
+// Impure CLI-facing ops: policy file IO + the queue read-modify-write.
+// Byte-exact port of the `sched`-specific slice of src/capability-core.ts.
+// ---------------------------------------------------------------------------
+function resolveCwd(options) {
+    return path.resolve(String(options.cwd || process.cwd()));
+}
+function nowIso(options) {
+    return typeof options.now === "string" ? options.now : new Date().toISOString();
+}
+/** Loads the scheduling policy: absent = default; present-but-corrupt
+ *  FAILS CLOSED (SPEC "Rebuild risks" #1 — this store is authoritative). */
+function loadSchedulingPolicy(registry) {
+    const file = registry.schedulingPolicyPath();
+    if (!fs.existsSync(file))
+        return { schemaVersion: 1, policy: exports.DEFAULT_SCHEDULING_POLICY, source: "default" };
+    const parsed = (0, fs_atomic_1.readJson)(file);
+    return { schemaVersion: 1, policy: normalizeSchedulingPolicy(parsed), source: "file" };
+}
+function numericFlag(options, key) {
+    if (!(key in options))
+        return undefined;
+    const raw = options[key];
+    const n = Number(raw);
+    if (!Number.isFinite(n)) {
+        throw new Error(`Invalid --${key} "${raw}": expected a number (e.g. --${key} 4)`);
+    }
+    return n;
+}
+function schedPlanCli(options = {}) {
+    const registry = new run_registry_io_1.RunRegistry(resolveCwd(options));
+    const { policy } = loadSchedulingPolicy(registry);
+    return planSchedule(registry.loadQueueEntries(), policy, nowIso(options));
+}
+function schedLeaseCli(options = {}) {
+    const registry = new run_registry_io_1.RunRegistry(resolveCwd(options));
+    const now = nowIso(options);
+    const policy = loadSchedulingPolicy(registry).policy;
+    const limit = options.limit === undefined ? undefined : Number(options.limit);
+    const { entries, leases } = applyLease(registry.loadQueueEntries(), policy, now, limit);
+    registry.saveQueueEntries(entries);
+    return { schemaVersion: 1, now, granted: leases.length, leases };
+}
+function schedReleaseCli(leaseId, options = {}) {
+    const registry = new run_registry_io_1.RunRegistry(resolveCwd(options));
+    const now = nowIso(options);
+    const failed = isTrue(options.failed);
+    const reason = typeof options.reason === "string" ? options.reason : undefined;
+    const { entries, matched } = leaseRelease(registry.loadQueueEntries(), leaseId, loadSchedulingPolicy(registry).policy, now, { failed, reason });
+    if (!matched)
+        throw new Error(`No active lease to release: ${leaseId}`);
+    registry.saveQueueEntries(entries);
+    return { schemaVersion: 1, released: leaseId, failed };
+}
+function schedCompleteCli(leaseId, options = {}) {
+    const registry = new run_registry_io_1.RunRegistry(resolveCwd(options));
+    const { entries, matched } = leaseComplete(registry.loadQueueEntries(), leaseId, nowIso(options));
+    if (!matched)
+        throw new Error(`No active lease to complete: ${leaseId}`);
+    registry.saveQueueEntries(entries);
+    return { schemaVersion: 1, completed: leaseId };
+}
+function schedReclaimCli(options = {}) {
+    const registry = new run_registry_io_1.RunRegistry(resolveCwd(options));
+    const now = nowIso(options);
+    const { entries, reclaimed } = reclaimExpired(registry.loadQueueEntries(), loadSchedulingPolicy(registry).policy, now);
+    registry.saveQueueEntries(entries);
+    return { schemaVersion: 1, now, reclaimed };
+}
+function schedResetCli(id, options = {}) {
+    const registry = new run_registry_io_1.RunRegistry(resolveCwd(options));
+    const { entries, matched } = resetEntry(registry.loadQueueEntries(), id);
+    if (!matched)
+        throw new Error(`No parked entry to reset: ${id}`);
+    registry.saveQueueEntries(entries);
+    return { schemaVersion: 1, reset: id };
+}
+function schedPolicyShowCli(options = {}) {
+    const registry = new run_registry_io_1.RunRegistry(resolveCwd(options));
+    return loadSchedulingPolicy(registry);
+}
+function schedPolicySetCli(options = {}) {
+    const registry = new run_registry_io_1.RunRegistry(resolveCwd(options));
+    const current = loadSchedulingPolicy(registry).policy;
+    const patch = {};
+    for (const key of ["maxConcurrent", "maxAttempts", "leaseTtlMs", "backoffBaseMs", "backoffFactor", "backoffCapMs"]) {
+        const value = numericFlag(options, key);
+        if (value !== undefined)
+            patch[key] = value;
+    }
+    const policy = normalizeSchedulingPolicy({ ...current, ...patch });
+    (0, fs_atomic_1.writeJson)(registry.schedulingPolicyPath(), policy);
+    return { schemaVersion: 1, policy, source: "file" };
+}
+function isTrue(value) {
+    return value === true || value === "true" || value === "1";
+}