@indigoai-us/hq-cli 5.345.92 → 5.345.94

package/dist/lib/capacity/scheduler.js

@@ -0,0 +1,800 @@
+/**
+ * Resident capacity collector scheduler (US-008).
+ *
+ * Runs inside hq mesh daemon on the daemon's timer host. A disabled or
+ * missing collector mark does nothing except re-check every 60s. One
+ * in-flight run per source; a hung run is abandoned and recorded as a
+ * parser_failure. Sentry gets provider, source, and CLI version only.
+ */
+import { execFile } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { appendParserFailure, DIR_MODE, FILE_MODE, LedgerBusy, readCollectorMark, rebuildNow, } from "./ledger.js";
+import { ingestCodexResult, isCodexProcessRunning, latestCodexSessionWriteAt, mapCodexAppServerBody, readCodexAppServer, readInstalledCodexVersion, shouldReadAppServer, tailCodexSessions, } from "./collectors/codex.js";
+import { CLAUDE_SPOOL_DIR, consumeClaudeStatuslineSpool, parseStatuslinePayload, } from "./collectors/claude-statusline.js";
+import { mapClaudeOAuthUsage, readInstalledClaudeVersionAsync, collectClaudeOAuth, } from "./collectors/claude-oauth.js";
+import { collectGrok, mapGrokBillingBody, readInstalledGrokVersionAsync, } from "./collectors/grok.js";
+import { listCapacityAccounts } from "./accounts.js";
+export const ENABLE_TICK_MS = 60_000;
+export const REBUILD_TICK_MS = 60_000;
+export const POLL_TICK_MS = 5 * 60_000;
+export const CODEX_DIR_POLL_MS = 15_000;
+export const SPOOL_POLL_MS = 15_000;
+const RUN_TIMEOUT_MS = {
+    "codex-tail": 15_000,
+    "codex-app-server": 30_000,
+    "claude-statusline": 10_000,
+    "claude-oauth": 30_000,
+    grok: 30_000,
+    rebuild: 10_000,
+};
+const SOURCE_EVENT = {
+    "codex-tail": { provider: "codex", source: "codex-jsonl" },
+    "codex-app-server": { provider: "codex", source: "codex-app-server" },
+    "claude-statusline": { provider: "claude", source: "statusline" },
+    "claude-oauth": { provider: "claude", source: "oauth-usage" },
+    grok: { provider: "grok", source: "grok-billing" },
+};
+const TAIL_STATE_FILE = "codex-tail-state.json";
+const APP_SERVER_BACKOFF_FILE = "codex-app-server-backoff.json";
+const SEEN_VERSIONS_FILE = "seen-cli-versions.json";
+const SELF_TEST_AT = "2026-10-11T00:00:00.000Z";
+export function defaultCodexSessionsDir(home = os.homedir()) {
+    return path.join(home, ".codex", "sessions");
+}
+export function capacityFixtureDir() {
+    return fileURLToPath(new URL("../../../test/fixtures/capacity/", import.meta.url));
+}
+/** Parse the pinned fixtures once. Missing fixtures are a skip, not a failure. */
+export function runParserSelfTest(provider, version, fixturesDir = capacityFixtureDir()) {
+    const checks = [];
+    if (provider === "codex") {
+        checks.push(() => {
+            const body = readFixture(fixturesDir, "codex-app-server-rate-limits.json");
+            if (!body)
+                return { readings: [true], failures: [] };
+            const mapped = mapCodexAppServerBody(body, { cliVersion: version, now: new Date(SELF_TEST_AT) });
+            return { readings: mapped.readings, failures: mapped.failures };
+        });
+    }
+    else if (provider === "claude") {
+        checks.push(() => {
+            const body = readFixture(fixturesDir, "claude-statusline.json");
+            if (!body)
+                return { readings: [true], failures: [] };
+            const parsed = parseStatuslinePayload(body, { observedAt: SELF_TEST_AT, cliVersion: version });
+            return { readings: parsed.readings, failures: parsed.failures };
+        });
+        checks.push(() => {
+            const body = readFixture(fixturesDir, "claude-oauth-usage.json");
+            if (!body)
+                return { readings: [true], failures: [] };
+            const mapped = mapClaudeOAuthUsage(body, {
+                observedAt: SELF_TEST_AT,
+                cliVersion: version,
+                accountId: "acct_self_test",
+                planType: null,
+            });
+            return { readings: mapped.readings, failures: mapped.failures };
+        });
+    }
+    else if (provider === "grok") {
+        checks.push(() => {
+            const body = readFixture(fixturesDir, "grok-billing.json");
+            if (!body)
+                return { readings: [true], failures: [] };
+            const mapped = mapGrokBillingBody(body, {
+                observedAt: SELF_TEST_AT,
+                cliVersion: version,
+                accountId: "acct_self_test",
+            });
+            return { readings: mapped.readings, failures: mapped.failures };
+        });
+    }
+    if (checks.length === 0)
+        return { ok: true };
+    for (const check of checks) {
+        const result = check();
+        if (result.failures.length > 0 || result.readings.length === 0)
+            return { ok: false };
+    }
+    return { ok: true };
+}
+export function startCapacityScheduler(options) {
+    const timers = options.timers;
+    const root = options.root;
+    const now = options.now ?? (() => new Date());
+    const log = options.log ?? (() => undefined);
+    const home = options.home ?? os.homedir();
+    const sessionsDir = options.sessionsDir ?? defaultCodexSessionsDir(home);
+    const watchFn = options.watch ?? defaultWatch;
+    const recursive = options.recursive ?? (process.platform === "darwin" || process.platform === "win32");
+    const sentry = options.sentry ?? defaultSentry;
+    const selfTest = options.selfTest ?? ((provider, version) => runParserSelfTest(provider, version));
+    const enumerateAccounts = options.enumerateAccounts === true;
+    const collectors = {
+        tailCodexSessions,
+        ingestCodexResult,
+        shouldReadAppServer,
+        isCodexProcessRunning,
+        readCodexAppServer,
+        latestCodexSessionWriteAt,
+        readInstalledCodexVersion,
+        consumeClaudeStatuslineSpool,
+        collectClaudeOAuth,
+        collectGrok,
+        readInstalledClaudeVersion: readInstalledClaudeVersionAsync,
+        readInstalledGrokVersion: readInstalledGrokVersionAsync,
+        ...options.collectors,
+    };
+    const aborts = new Set();
+    const versionCache = new Map();
+    let backoffWrite = Promise.resolve();
+    const VERSION_TTL_MS = 60 * 60 * 1000;
+    let stopped = false;
+    let enabled = false;
+    let tickCount = 0;
+    let slowHandle = null;
+    const intervals = new Map();
+    const watches = [];
+    const inflight = new Map();
+    const pending = new Set();
+    const jobs = new Map();
+    const runTimeouts = new Map();
+    const seenVersions = new Map();
+    let generation = 0;
+    let codexWatching = false;
+    let spoolWatching = false;
+    const ledger = () => ({ root, now });
+    function armSlow() {
+        if (stopped)
+            return;
+        slowHandle = timers.setTimeout(() => {
+            slowHandle = null;
+            if (stopped)
+                return;
+            try {
+                syncEnabled();
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                log(`collector mark check failed: ${message.slice(0, 120)}`);
+            }
+            if (!stopped)
+                armSlow();
+        }, ENABLE_TICK_MS);
+    }
+    function every(name, ms, fn) {
+        if (stopped || !enabled)
+            return;
+        const tick = () => {
+            if (stopped || !enabled)
+                return;
+            fn();
+            if (stopped || !enabled)
+                return;
+            intervals.set(name, timers.setTimeout(tick, ms));
+        };
+        intervals.set(name, timers.setTimeout(tick, ms));
+    }
+    function clearFast() {
+        for (const handle of intervals.values())
+            timers.clearTimeout(handle);
+        intervals.clear();
+        for (const tracked of watches.splice(0)) {
+            try {
+                tracked.watcher.close();
+            }
+            catch {
+                // The watcher may already be closed.
+            }
+        }
+        codexWatching = false;
+        spoolWatching = false;
+    }
+    function syncEnabled() {
+        const on = readCollectorMark(ledger())?.enabled === true;
+        if (on && !enabled)
+            activate();
+        else if (!on && enabled)
+            deactivate();
+    }
+    function activate() {
+        enabled = true;
+        loadSeenVersions();
+        openWatches();
+        armFast();
+        kick("codex-tail", runCodexTail);
+        kick("codex-app-server", runCodexAppServer);
+        kick("claude-statusline", runStatusline);
+        kick("claude-oauth", runClaudeOAuth);
+        kick("grok", runGrok);
+        kick("rebuild", runRebuild);
+    }
+    function deactivate() {
+        enabled = false;
+        clearFast();
+    }
+    function armFast() {
+        every("rebuild", REBUILD_TICK_MS, () => kick("rebuild", runRebuild));
+        every("oauth", POLL_TICK_MS, () => kick("claude-oauth", runClaudeOAuth));
+        every("grok", POLL_TICK_MS, () => kick("grok", runGrok));
+        every("app-server", POLL_TICK_MS, () => kick("codex-app-server", runCodexAppServer));
+        if (!codexWatching || enumerateAccounts)
+            every("codex-poll", CODEX_DIR_POLL_MS, () => kick("codex-tail", runCodexTail));
+        if (!spoolWatching)
+            every("spool-poll", SPOOL_POLL_MS, () => kick("claude-statusline", runStatusline));
+    }
+    function openWatches() {
+        if (recursive && fs.existsSync(sessionsDir)) {
+            codexWatching = openWatch(sessionsDir, true, "codex", () => kick("codex-tail", runCodexTail));
+        }
+        const spoolDir = path.join(root, CLAUDE_SPOOL_DIR);
+        try {
+            fs.mkdirSync(spoolDir, { recursive: true, mode: DIR_MODE });
+        }
+        catch {
+            spoolWatching = false;
+        }
+        if (fs.existsSync(spoolDir)) {
+            spoolWatching = openWatch(spoolDir, false, "spool", () => kick("claude-statusline", runStatusline));
+        }
+    }
+    function openWatch(target, recursiveWatch, kind, onFire) {
+        try {
+            const watchOptions = { persistent: true };
+            if (recursiveWatch)
+                watchOptions.recursive = true;
+            const watcher = watchFn(target, watchOptions, () => onFire());
+            const tracked = { kind, watcher };
+            watches.push(tracked);
+            watcher.on?.("error", () => {
+                const index = watches.indexOf(tracked);
+                if (index >= 0)
+                    watches.splice(index, 1);
+                try {
+                    watcher.close();
+                }
+                catch {
+                    // Already closed.
+                }
+                if (kind === "codex") {
+                    codexWatching = false;
+                    if (!intervals.has("codex-poll")) {
+                        every("codex-poll", CODEX_DIR_POLL_MS, () => kick("codex-tail", runCodexTail));
+                    }
+                }
+                else {
+                    spoolWatching = false;
+                    if (!intervals.has("spool-poll")) {
+                        every("spool-poll", SPOOL_POLL_MS, () => kick("claude-statusline", runStatusline));
+                    }
+                }
+                log(`${kind} watch error`);
+            });
+            return true;
+        }
+        catch {
+            log(`${kind} watch unavailable`);
+            return false;
+        }
+    }
+    function kick(source, work) {
+        if (stopped || !enabled)
+            return;
+        jobs.set(source, work);
+        if (inflight.has(source)) {
+            pending.add(source);
+            return;
+        }
+        startJob(source);
+    }
+    function startJob(source) {
+        const work = jobs.get(source);
+        if (!work || stopped || !enabled || inflight.has(source))
+            return;
+        const token = ++generation;
+        inflight.set(source, token);
+        tickCount += 1;
+        const timeout = timers.setTimeout(() => {
+            if (inflight.get(source) !== token)
+                return;
+            inflight.delete(source);
+            runTimeouts.delete(source);
+            recordFailure(source, "collector run timed out");
+            resumePending(source);
+        }, RUN_TIMEOUT_MS[source]);
+        runTimeouts.set(source, timeout);
+        void Promise.resolve()
+            .then(work)
+            .catch(() => {
+            if (inflight.get(source) !== token)
+                return;
+            recordFailure(source, "collector run failed");
+        })
+            .finally(() => {
+            if (inflight.get(source) === token) {
+                inflight.delete(source);
+                clearRunTimeout(source);
+            }
+            resumePending(source);
+        });
+    }
+    function resumePending(source) {
+        if (inflight.has(source) || stopped || !enabled)
+            return;
+        if (!pending.has(source))
+            return;
+        pending.delete(source);
+        startJob(source);
+    }
+    function clearRunTimeout(source) {
+        const handle = runTimeouts.get(source);
+        if (handle === undefined)
+            return;
+        runTimeouts.delete(source);
+        timers.clearTimeout(handle);
+    }
+    function recordFailure(source, error) {
+        if (source === "rebuild") {
+            log(error === "collector run timed out" ? "rebuild timed out" : `rebuild skipped: ${error}`);
+            return;
+        }
+        const meta = SOURCE_EVENT[source];
+        const cliVersion = seenVersions.get(meta.provider) ?? "unknown";
+        const observedAt = now().toISOString();
+        const event = {
+            event: "parser_failure",
+            observedAt,
+            provider: meta.provider,
+            source: meta.source,
+            error,
+            cliVersion,
+            parserVersion: "capacity-scheduler.1",
+        };
+        try {
+            appendParserFailure(event, ledger());
+        }
+        catch {
+            log(`${source} failure was not recorded`);
+        }
+        reportFailures([event]);
+    }
+    function reportFailures(failures) {
+        for (const failure of failures) {
+            try {
+                sentry({
+                    provider: failure.provider,
+                    source: failure.source,
+                    cliVersion: failure.cliVersion ?? "unknown",
+                });
+            }
+            catch {
+                // Sentry must not stop collection.
+            }
+        }
+    }
+    function noteVersion(provider, version) {
+        if (!version || version === "unknown")
+            return;
+        if (seenVersions.get(provider) === version)
+            return;
+        seenVersions.set(provider, version);
+        saveSeenVersions();
+        log(`cli ${provider} ${version}`);
+        let ok = true;
+        try {
+            const result = selfTest(provider, version);
+            if (result && typeof result === "object" && result.ok === false)
+                ok = false;
+        }
+        catch {
+            ok = false;
+        }
+        log(`self-test ${provider} ${version} ${ok ? "pass" : "fail"}`);
+    }
+    function noteResultVersions(provider, readings, failures) {
+        const version = readings.find((row) => row.cliVersion)?.cliVersion
+            ?? failures.find((row) => row.cliVersion)?.cliVersion;
+        if (version)
+            noteVersion(provider, version);
+    }
+    function accountGroups(provider) {
+        let rows;
+        try {
+            rows = listCapacityAccounts({ home, hqRoot: options.hqRoot }).filter((account) => account.provider === provider);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log(`capacity accounts ${provider} failed: ${message.slice(0, 120)}`);
+            rows = [];
+        }
+        if (rows.length === 0) {
+            const dir = provider === "claude" ? ".claude" : provider === "codex" ? ".codex" : ".grok";
+            rows = [{ label: "default", home: path.join(home, dir) }];
+        }
+        const grouped = new Map();
+        for (const row of rows) {
+            const key = path.resolve(row.home);
+            const group = grouped.get(key) ?? { home: row.home, labels: [] };
+            if (!group.labels.includes(row.label))
+                group.labels.push(row.label);
+            grouped.set(key, group);
+        }
+        return [...grouped.values()].map((group) => ({
+            home: group.home,
+            labels: group.labels,
+            label: group.labels.find((label) => label !== "default") ?? group.labels[0] ?? "default",
+        }));
+    }
+    function flatAccounts(provider) {
+        return accountGroups(provider).flatMap((group) => group.labels.map((label) => ({ label, home: group.home })));
+    }
+    function codexHome() {
+        return path.join(home, ".codex");
+    }
+    function beginAbort() {
+        const controller = new AbortController();
+        aborts.add(controller);
+        return controller.signal;
+    }
+    async function processSnapshot() {
+        if (options.ps)
+            return options.ps();
+        return listProcesses();
+    }
+    async function cachedVersion(provider, read) {
+        const hit = versionCache.get(provider);
+        if (hit && Date.now() - hit.at < VERSION_TTL_MS)
+            return hit.version;
+        let version;
+        try {
+            version = await read();
+        }
+        catch {
+            version = "unknown";
+        }
+        versionCache.set(provider, { version, at: Date.now() });
+        return version;
+    }
+    function enqueueBackoff(apply) {
+        backoffWrite = backoffWrite.then(() => {
+            apply();
+        }).catch(() => undefined);
+    }
+    async function runCodexTail() {
+        const cliVersion = await cachedVersion("codex", () => collectors.readInstalledCodexVersion());
+        noteVersion("codex", cliVersion);
+        if (!enumerateAccounts) {
+            const accountHome = codexHome();
+            const result = collectors.tailCodexSessions({
+                sessionsDir,
+                state: readTailState(),
+                cliVersion,
+                now: now(),
+                recentDays: 2,
+                accountId: `home:${path.resolve(accountHome)}`,
+                accountHome,
+            });
+            writeTailState(result.state);
+            collectors.ingestCodexResult(result, ledger());
+            reportFailures(result.failures);
+            return;
+        }
+        let state = readTailState();
+        for (const group of accountGroups("codex")) {
+            const dir = path.join(group.home, "sessions");
+            const result = collectors.tailCodexSessions({
+                sessionsDir: dir,
+                state,
+                cliVersion,
+                now: now(),
+                recentDays: 2,
+                accountId: `home:${path.resolve(group.home)}`,
+                accountLabel: group.label,
+                accountLabels: group.labels,
+                accountHome: group.home,
+            });
+            const prefix = path.resolve(dir);
+            const kept = {};
+            for (const [file, cursor] of Object.entries(state.files)) {
+                const resolved = path.resolve(file);
+                if (resolved !== prefix && !resolved.startsWith(`${prefix}${path.sep}`))
+                    kept[file] = cursor;
+            }
+            state = { files: { ...kept, ...result.state.files } };
+            collectors.ingestCodexResult(result, ledger());
+            reportFailures(result.failures);
+        }
+        writeTailState(state);
+    }
+    async function runCodexAppServer() {
+        const clock = now();
+        const signal = beginAbort();
+        const processes = await processSnapshot();
+        const running = collectors.isCodexProcessRunning(processes);
+        if (!enumerateAccounts) {
+            if (backoffActive(clock.getTime()))
+                return;
+            const lastWrite = collectors.latestCodexSessionWriteAt(sessionsDir, 2);
+            if (!collectors.shouldReadAppServer({
+                lastSessionWriteAt: lastWrite,
+                codexProcessRunning: running,
+                now: clock.getTime(),
+            }))
+                return;
+            const cliVersion = await cachedVersion("codex", () => collectors.readInstalledCodexVersion());
+            noteVersion("codex", cliVersion);
+            const accountHome = codexHome();
+            const result = await collectors.readCodexAppServer({
+                cliVersion,
+                now: clock,
+                signal,
+                accountId: `home:${path.resolve(accountHome)}`,
+                accountHome,
+                timeoutMs: 20_000,
+            });
+            if (!result.ok && result.backoffMs)
+                enqueueBackoff(() => writeBackoff(clock.getTime() + (result.backoffMs ?? 0)));
+            if (result.ok)
+                enqueueBackoff(() => clearBackoff());
+            collectors.ingestCodexResult(result, ledger());
+            reportFailures(result.failures);
+            await backoffWrite;
+            return;
+        }
+        const cliVersion = await cachedVersion("codex", () => collectors.readInstalledCodexVersion());
+        noteVersion("codex", cliVersion);
+        await Promise.all(accountGroups("codex").map(async (group) => {
+            if (signal.aborted || backoffActiveFor(group.label, clock.getTime()))
+                return;
+            const dir = path.join(group.home, "sessions");
+            const lastWrite = collectors.latestCodexSessionWriteAt(dir, 2);
+            if (!collectors.shouldReadAppServer({
+                lastSessionWriteAt: lastWrite,
+                codexProcessRunning: running,
+                now: clock.getTime(),
+            }))
+                return;
+            const result = await collectors.readCodexAppServer({
+                cliVersion,
+                now: clock,
+                signal,
+                home: group.home,
+                accountId: `home:${path.resolve(group.home)}`,
+                accountLabel: group.label,
+                accountLabels: group.labels,
+                accountHome: group.home,
+                timeoutMs: 20_000,
+            });
+            if (!result.ok && result.backoffMs) {
+                enqueueBackoff(() => writeBackoffFor(group.label, clock.getTime() + (result.backoffMs ?? 0)));
+            }
+            if (result.ok)
+                enqueueBackoff(() => clearBackoffFor(group.label));
+            collectors.ingestCodexResult(result, ledger());
+            reportFailures(result.failures);
+        }));
+        await backoffWrite;
+    }
+    async function runStatusline() {
+        const installed = await cachedVersion("claude", () => collectors.readInstalledClaudeVersion());
+        noteVersion("claude", installed);
+        const result = collectors.consumeClaudeStatuslineSpool({
+            root,
+            now: now(),
+            ...(enumerateAccounts ? { accounts: flatAccounts("claude") } : {}),
+        });
+        noteResultVersions("claude", result.readings, result.failures);
+        reportFailures(result.failures);
+    }
+    async function runClaudeOAuth() {
+        const installed = await cachedVersion("claude", () => collectors.readInstalledClaudeVersion());
+        noteVersion("claude", installed);
+        const result = await collectors.collectClaudeOAuth({
+            ledger: ledger(),
+            now,
+            cliVersion: installed,
+            ...(enumerateAccounts ? { accounts: flatAccounts("claude") } : {}),
+        });
+        noteResultVersions("claude", result.readings, result.failures);
+        reportFailures(result.failures);
+    }
+    async function runGrok() {
+        const installed = await cachedVersion("grok", () => collectors.readInstalledGrokVersion());
+        noteVersion("grok", installed);
+        const result = await collectors.collectGrok({
+            ledger: ledger(),
+            now,
+            cliVersion: installed,
+            ...(enumerateAccounts ? { accounts: flatAccounts("grok") } : {}),
+        });
+        noteResultVersions("grok", result.readings, result.failures);
+        reportFailures(result.failures);
+    }
+    async function runRebuild() {
+        try {
+            rebuildNow(ledger());
+        }
+        catch (err) {
+            if (err instanceof LedgerBusy) {
+                log("rebuild skipped: ledger busy");
+                return;
+            }
+            throw err;
+        }
+    }
+    function loadSeenVersions() {
+        const parsed = readJson(path.join(root, SEEN_VERSIONS_FILE));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return;
+        for (const [key, value] of Object.entries(parsed)) {
+            if (typeof value === "string" && value)
+                seenVersions.set(key, value);
+        }
+    }
+    function saveSeenVersions() {
+        writeJson(path.join(root, SEEN_VERSIONS_FILE), Object.fromEntries(seenVersions));
+    }
+    function readTailState() {
+        const parsed = readJson(path.join(root, TAIL_STATE_FILE));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return { files: {} };
+        const files = parsed.files;
+        if (!files || typeof files !== "object" || Array.isArray(files))
+            return { files: {} };
+        return { files: files };
+    }
+    function writeTailState(state) {
+        writeJson(path.join(root, TAIL_STATE_FILE), state);
+    }
+    function backoffActive(nowMs) {
+        const parsed = readJson(path.join(root, APP_SERVER_BACKOFF_FILE));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return false;
+        const until = parsed.until;
+        return typeof until === "number" && until > nowMs;
+    }
+    function writeBackoff(until) {
+        writeJson(path.join(root, APP_SERVER_BACKOFF_FILE), { until });
+    }
+    function clearBackoff() {
+        const dest = path.join(root, APP_SERVER_BACKOFF_FILE);
+        try {
+            if (fs.existsSync(dest))
+                fs.rmSync(dest);
+        }
+        catch {
+            // The next read treats a bad file as no backoff.
+        }
+    }
+    function backoffRecord() {
+        const parsed = readJson(path.join(root, APP_SERVER_BACKOFF_FILE));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    function backoffActiveFor(label, nowMs) {
+        const record = backoffRecord();
+        if (!record)
+            return false;
+        if (label === "default" && typeof record.until === "number" && record.until > nowMs)
+            return true;
+        const accounts = record.accounts;
+        if (!accounts || typeof accounts !== "object" || Array.isArray(accounts))
+            return false;
+        const until = accounts[label];
+        return typeof until === "number" && until > nowMs;
+    }
+    function writeBackoffFor(label, until) {
+        const record = backoffRecord() ?? {};
+        const accounts = record.accounts && typeof record.accounts === "object" && !Array.isArray(record.accounts)
+            ? { ...record.accounts }
+            : {};
+        accounts[label] = until;
+        writeJson(path.join(root, APP_SERVER_BACKOFF_FILE), { ...record, accounts });
+    }
+    function clearBackoffFor(label) {
+        const record = backoffRecord();
+        if (!record)
+            return;
+        const next = { ...record };
+        if (label === "default")
+            delete next.until;
+        if (next.accounts && typeof next.accounts === "object" && !Array.isArray(next.accounts)) {
+            const accounts = { ...next.accounts };
+            delete accounts[label];
+            next.accounts = accounts;
+        }
+        writeJson(path.join(root, APP_SERVER_BACKOFF_FILE), next);
+    }
+    function stop() {
+        if (stopped)
+            return;
+        stopped = true;
+        enabled = false;
+        for (const controller of aborts)
+            controller.abort();
+        aborts.clear();
+        if (slowHandle !== null)
+            timers.clearTimeout(slowHandle);
+        slowHandle = null;
+        clearFast();
+        for (const handle of runTimeouts.values())
+            timers.clearTimeout(handle);
+        runTimeouts.clear();
+        pending.clear();
+    }
+    try {
+        syncEnabled();
+    }
+    catch {
+        enabled = false;
+    }
+    armSlow();
+    return { stop, ticks: () => tickCount };
+}
+function readFixture(dir, name) {
+    const dest = path.join(dir, name);
+    if (!fs.existsSync(dest))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(dest, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function readJson(dest) {
+    try {
+        return JSON.parse(fs.readFileSync(dest, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJson(dest, value) {
+    const tmp = `${dest}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        fs.mkdirSync(path.dirname(dest), { recursive: true, mode: DIR_MODE });
+        fs.writeFileSync(tmp, `${JSON.stringify(value)}\n`, { mode: FILE_MODE });
+        fs.renameSync(tmp, dest);
+    }
+    catch {
+        try {
+            if (fs.existsSync(tmp))
+                fs.rmSync(tmp);
+        }
+        catch {
+            // The next tick retries the state write.
+        }
+    }
+}
+function defaultWatch(target, options, listener) {
+    return fs.watch(target, options, listener);
+}
+function listProcesses() {
+    return new Promise((resolve) => {
+        execFile("ps", ["-ax", "-o", "command="], { timeout: 5_000, encoding: "utf8", windowsHide: true }, (error, stdout, stderr) => {
+            if (error && !stdout && !stderr) {
+                resolve("");
+                return;
+            }
+            resolve(`${stdout ?? ""}\n${stderr ?? ""}`);
+        });
+    });
+}
+function defaultSentry(event) {
+    void import("../../sentry.js").then(({ Sentry }) => {
+        Sentry.withScope((scope) => {
+            scope.setTag("provider", event.provider);
+            scope.setTag("source", event.source);
+            scope.setTag("cliVersion", event.cliVersion);
+            scope.setFingerprint(["capacity-parser-failure", event.provider, event.source, event.cliVersion]);
+            Sentry.captureMessage("capacity parser_failure");
+        });
+    }).catch(() => undefined);
+}
+//# sourceMappingURL=scheduler.js.map