looply-cli 0.0.0-stage → 0.2.0

package/dist/spend-ledger.js

@@ -0,0 +1,546 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADMISSION_HOLD_MS = void 0;
+exports.admissionHoldMs = admissionHoldMs;
+exports.spendLedgerPath = spendLedgerPath;
+exports.spendLockPath = spendLockPath;
+exports.recordSpend = recordSpend;
+exports.readSpend = readSpend;
+exports.spendInWindow = spendInWindow;
+exports.spentByRun = spentByRun;
+exports.peekEnvelope = peekEnvelope;
+exports.admitSpend = admitSpend;
+exports.recordingSpend = recordingSpend;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const core_1 = require("@looply/core");
+const exclusive_lock_1 = require("./exclusive-lock");
+/**
+ * How long an admission hold counts against the window.
+ *
+ * Long enough to cover the gap between admitting a run and that run's first
+ * recorded invocation — a spawn, a git clone, a queue load, a first model call.
+ * Short enough that a hold left behind by a crashed daemon costs one window's
+ * arithmetic rather than a night.
+ */
+exports.ADMISSION_HOLD_MS = 5 * 60 * 1000;
+/**
+ * How long a reservation actually counts for: THE WINDOW THE CEILING IS
+ * WRITTEN OVER, never less than the floor above.
+ *
+ * 🔴 A FIVE-MINUTE HOLD ON A FORTY-FIVE-MINUTE TURN IS NOT A CEILING.
+ *
+ * MEASURED: a $10 ceiling, a $2 estimate, and runs whose first invocation had
+ * not yet returned — the ordinary case, because an implementer turn takes
+ * tens of minutes and records its cost only at the end. Every hold expired at
+ * five minutes; every later start re-read a machine that had spent $0; TWENTY
+ * were admitted against a ceiling of five. The window was never wrong about
+ * completed work. It simply forgot the work in progress.
+ *
+ * The window is the right horizon because it is the one the operator wrote: a
+ * reservation counts until it settles, or until it falls out of the window it
+ * was made in — at which point it cannot affect that window's arithmetic
+ * anyway. A hold abandoned by a crashed daemon therefore costs one window, the
+ * tolerance the floor above was chosen for, and it errs toward REFUSING starts
+ * rather than admitting unbounded ones. For a budget that is the only
+ * survivable direction to be wrong in.
+ */
+function admissionHoldMs(windowMs) {
+    return Number.isFinite(windowMs) ? Math.max(exports.ADMISSION_HOLD_MS, windowMs) : exports.ADMISSION_HOLD_MS;
+}
+/**
+ * ⚠️ ONE PATH PER MACHINE, AND NOT DERIVED FROM `cwd`.
+ *
+ * The rails ledgers next door are keyed by repository identity, which is right
+ * for them and wrong here: the envelope bounds what this MACHINE may spend, and
+ * a per-project ledger would let ten projects each stay comfortably inside a
+ * ceiling that was written once. Deriving it from `process.cwd()` would have
+ * been worse still — the same machine would keep several ledgers depending on
+ * where the command was typed.
+ */
+function spendLedgerPath(home = (0, node_os_1.homedir)()) {
+    return (0, node_path_1.join)(home, '.looply', 'spend.jsonl');
+}
+/**
+ * The mutex that makes an admission decision authoritative.
+ *
+ * Machine-level, beside the ledger it serialises, because the ledger is what it
+ * protects and the ceiling is a machine's. See `exclusive-lock`.
+ */
+function spendLockPath(home = (0, node_os_1.homedir)()) {
+    return (0, node_path_1.join)(home, '.looply', '.spend.lock');
+}
+/**
+ * Append one invocation's cost.
+ *
+ * 🔴 THE RETURN VALUE IS NOT DECORATION. Unlike the schedule log, a spend
+ * record that fails to write makes the machine look CHEAPER than it is, and the
+ * next ceiling check passes on a number that is missing a term. The caller is
+ * told so it can record the invocation as unmeasured instead of as absent.
+ *
+ * ⚠️ LED BY A NEWLINE, for the reason `coordinator.recordActions` wrote down: a
+ * torn write must cost one record, not two.
+ */
+function recordSpend(record, home = (0, node_os_1.homedir)()) {
+    const path = spendLedgerPath(home);
+    try {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+        (0, node_fs_1.appendFileSync)(path, `\n${JSON.stringify(record)}\n`, 'utf8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Every parseable record, or why the ledger could not be read.
+ *
+ * 🔴 AN UNREADABLE LEDGER USED TO READ AS AN EMPTY ONE. Both answered `[]`, so
+ * a permissions change, a full disk or a corrupt file made a $250 night pass a
+ * $5 ceiling — the ceiling comparing against a number it had no basis for.
+ *
+ * ⚠️ ENOENT IS THE ONE ERROR THAT IS AN ANSWER. A ledger that does not exist is
+ * a machine that has spent nothing, which is true and is different from a
+ * machine that cannot say.
+ *
+ * ⚠️ AND A TORN FRAGMENT IS STILL SKIPPED ALONE rather than failing the read —
+ * that is what the leading newline buys, and a fragment is a record lost, not a
+ * total that cannot be trusted.
+ */
+function readSpend(home = (0, node_os_1.homedir)()) {
+    let raw;
+    try {
+        raw = (0, node_fs_1.readFileSync)(spendLedgerPath(home), 'utf8');
+    }
+    catch (e) {
+        const code = e.code;
+        if (code === 'ENOENT')
+            return { ok: true, records: [] };
+        return { ok: false, because: `the spend ledger could not be read: ${e.message}` };
+    }
+    const out = [];
+    for (const line of raw.split('\n')) {
+        const text = line.trim();
+        if (text === '')
+            continue;
+        try {
+            const parsed = JSON.parse(text);
+            /**
+             * 🔴 A ROW THAT PARSES BUT IS NOT A SPEND RECORD IS A REFUSAL, NOT A
+             * ROW TO SKIP.
+             *
+             * A torn write does not produce valid JSON — that is what the leading
+             * newline and the `JSON.parse` catch above are for. Valid JSON missing
+             * `at` or `ms` is a CORRUPT LEDGER, and dropping it silently makes the
+             * machine look cheaper than it is, which is the one direction a budget
+             * cannot be wrong in.
+             */
+            if (typeof parsed?.at !== 'string' || typeof parsed?.ms !== 'number') {
+                return {
+                    ok: false,
+                    because: 'the spend ledger contains a record with no timestamp or no duration, so what this ' +
+                        `machine has spent cannot be totalled: ${text.slice(0, 120)}`,
+                };
+            }
+            out.push(parsed);
+        }
+        catch {
+            // A fragment from a torn write. Skipped alone, which is what the leading
+            // newline buys.
+        }
+    }
+    return { ok: true, records: out };
+}
+function spendInWindow(now, windowMs, runsInFlight, home = (0, node_os_1.homedir)(), 
+/**
+ * What to charge an invocation that reported no cost.
+ *
+ * Absent keeps the strict reading — an unmeasured row makes the window
+ * unmeasurable — which is right for a caller that has no estimate to stand
+ * in with. See the charging loop.
+ */
+assumedUsd) {
+    const read = readSpend(home);
+    if (!read.ok)
+        return { ok: false, because: read.because };
+    const since = now - windowMs;
+    const all = read.records;
+    /**
+     * ⚠️ A RESERVATION IS CLOSED BY A LATER ROW NAMING IT, never by being
+     * rewritten. So the open ones are those with no settlement and no
+     * cancellation anywhere in the file — including rows OUTSIDE the window,
+     * because a reservation made an hour ago and settled a minute ago is closed
+     * however the window falls.
+     */
+    const closed = new Set(all.filter((r) => r.kind === 'settlement' || r.kind === 'cancellation').map((r) => r.id));
+    /** An expired hold counts as nothing. See `holdUntil`. */
+    const expired = (r) => {
+        const until = Date.parse(r.holdUntil ?? '');
+        return Number.isFinite(until) ? now >= until : false;
+    };
+    /**
+     * 🔴 NO UPPER BOUND, AND `at <= now` LET A CLAIMANT SPEND THE SAME
+     * ALLOWANCE TWICE.
+     *
+     * The window used to end at the reader's own clock, which reads as obviously
+     * right and is not: a row stamped LATER than this reader's `now` is money
+     * somebody is already holding, and excluding it makes the machine look
+     * cheaper than it is to precisely the process least able to tell.
+     *
+     * MEASURED, $3 ceiling and $2 estimates, with the schedule forced: B
+     * published at T+1000 and was admitted; A, whose key was T, then read a
+     * window ending at T — so B's row was in A's FUTURE and invisible — and was
+     * admitted too. The window held $4. Serialising the check-and-claim did not
+     * help, because the row was not merely sorted away, it was filtered out.
+     *
+     * ⚠️ A FUTURE-STAMPED ROW IS COUNTED, WHICH OVER-COUNTS RATHER THAN UNDER.
+     * Clock skew between two processes on one machine is small; a row an hour
+     * ahead would be counted now and again in an hour. That direction refuses a
+     * start that might have fitted. The other direction spends money nobody
+     * authorised, and a budget may only ever be wrong in the first.
+     */
+    const inWindow = all.filter((r) => {
+        const at = Date.parse(r.at);
+        return Number.isFinite(at) && at >= since;
+    });
+    /**
+     * WHAT COUNTS TOWARD THE MONEY CEILING:
+     *   - a completed invocation, at what it cost;
+     *   - a settlement, at what the run TURNED OUT to cost — INSTEAD of that
+     *     run's own rows, never on top of them;
+     *   - an OPEN reservation, at what it expects to cost.
+     * A cancellation counts as nothing, which is what it means.
+     *
+     * 🔴 A SETTLEMENT REPLACES ITS RUN'S ROWS. IT USED TO BE ADDED TO THEM.
+     *
+     * MEASURED: a run admitted at a $2 estimate records three real invocations of
+     * $1, then settles at `spentByRun` = $3 — and the window read $6. The
+     * settlement's own amount was summed on top of the very rows it was computed
+     * from, so every reconciled run counted twice, and the wall clock doubled
+     * with it. A ceiling fed a number twice its truth refuses at half its value.
+     */
+    const settledAt = new Map();
+    for (const r of inWindow) {
+        if (r.kind !== 'settlement' || r.runId === undefined)
+            continue;
+        // What it says it covers, and only if it does not say, when it was written.
+        const covers = r.coversUpTo ?? r.at;
+        const seen = settledAt.get(r.runId);
+        if (seen === undefined || covers > seen)
+            settledAt.set(r.runId, covers);
+    }
+    /**
+     * ⚠️ A SETTLEMENT REPLACES ONLY WHAT IT WAS COMPUTED FROM. It sums the
+     * run's rows AS OF THE MOMENT IT IS WRITTEN, so a row that lands afterwards
+     * — a straggling invocation, a second settlement — is money it never saw and
+     * is counted on top, exactly as any other spend would be.
+     */
+    const supersededBySettlement = (r) => {
+        if (r.kind === 'settlement' || r.runId === undefined)
+            return false;
+        const at = settledAt.get(r.runId);
+        return at !== undefined && r.at <= at;
+    };
+    const charged = inWindow.filter((r) => {
+        if (r.kind === 'cancellation')
+            return false;
+        if (r.kind === 'reservation')
+            return !closed.has(r.id) && !expired(r);
+        // A settled run is represented by its settlement and by nothing else.
+        if (supersededBySettlement(r))
+            return false;
+        return true;
+    });
+    /**
+     * 🔴 AN UNMEASURED INVOCATION IS CHARGED AT THE ESTIMATE, NOT TREATED AS
+     * UNKNOWABLE — AND THE OLD BEHAVIOUR SELF-LOCKED THE MACHINE AFTER ONE ROUND.
+     *
+     * MEASURED: the round runs its agent with `--output-format text` and receives
+     * no envelope, so its spend row carries no `usd` BY DESIGN. One such row made
+     * the whole window `null`, `withinEnvelope` refuses on null, and therefore
+     * the FIRST round turn of the FIRST run locked every later start out of the
+     * window — with a refusal telling the person to change provider for a
+     * suppression looply itself chose.
+     *
+     * ⚠️ SO THE GUARANTEE IS NAMED HONESTLY RATHER THAN OVERSTATED. This is an
+     * ADMISSION CEILING OVER ESTIMATED SPEND, reconciled to actual wherever the
+     * provider reports one. It is not a hard provider-dollar cap, and nothing
+     * here claims to be: an invocation already in flight can exceed its estimate,
+     * bounded only by the provider's own turn limit.
+     *
+     * ⚠️ AND `assumedUsd` IS ONLY EVER USED FOR ROWS THAT REPORT NOTHING. A
+     * provider that DOES report cost is believed, always.
+     */
+    let usd = 0;
+    for (const r of charged) {
+        if (usd === null)
+            break;
+        const amount = r.kind === 'reservation' ? r.estimateUsd : r.usd;
+        if (typeof amount === 'number' && Number.isFinite(amount)) {
+            usd += amount;
+            continue;
+        }
+        if (assumedUsd !== undefined && Number.isFinite(assumedUsd)) {
+            usd += assumedUsd;
+            continue;
+        }
+        usd = null;
+    }
+    /**
+     * ⚠️ A SETTLEMENT IS NOT A SECOND START. It closes a reservation that was
+     * already counted, so counting both would report twice the starts and twice
+     * the wall clock for one invocation.
+     */
+    const starts = charged.filter((r) => r.kind !== 'settlement');
+    return {
+        ok: true,
+        spend: {
+            runsInFlight,
+            startsInWindow: starts.length,
+            wallClockMs: charged.reduce((sum, r) => sum + (Number.isFinite(r.ms) ? r.ms : 0), 0),
+            usd,
+        },
+    };
+}
+/**
+ * What one run has ACTUALLY cost so far, from its own rows.
+ *
+ * 🔴 THIS IS THE OTHER HALF OF ADMISSION. A reservation is a promise; this is
+ * the receipt. Settling with it turns "we held $2.50 for this run" into "this
+ * run cost $1.87", which is what the next admission must compare against.
+ *
+ * ⚠️ NULL WHEN ANY OF ITS ROWS IS UNMEASURED, for the same reason the window
+ * total is: the round path reports no cost at all, so a run that did rounds has
+ * spent an amount nobody can state. Settling at a number would be inventing
+ * one; settling at `null` keeps the window unmeasurable, which the ceiling
+ * refuses on.
+ */
+function spentByRun(runId, home = (0, node_os_1.homedir)()) {
+    const read = readSpend(home);
+    if (!read.ok)
+        return null;
+    const mine = read.records.filter((r) => r.runId === runId && r.kind !== 'reservation');
+    if (mine.length === 0)
+        return 0;
+    let total = 0;
+    for (const r of mine) {
+        if (typeof r.usd === 'number' && Number.isFinite(r.usd))
+            total += r.usd;
+        else
+            return null;
+    }
+    return total;
+}
+/**
+ * WOULD ADMISSION REFUSE RIGHT NOW? — READ ONLY, RESERVING NOTHING.
+ *
+ * 🔴 A SECOND READER OF ONE POLICY, NEVER A SECOND POLICY. It calls exactly the
+ * same `withinEnvelope` over exactly the same window that `admitSpend` does; the
+ * only difference is that it writes nothing.
+ *
+ * ⚠️ AND IT IS ADVISORY, WHICH IS THE WHOLE POINT. The autonomy tick uses it so
+ * a start already obviously over the ceiling costs no spawn, no workspace and
+ * none of a small number of attempts. It must NOT reserve: the canonical
+ * admission is `runLoop`'s, and a reservation taken here would be held again
+ * there — one start holding twice its estimate, and a machine refusing itself
+ * at half its ceiling.
+ *
+ * ⚠️ A PASS HERE PROMISES NOTHING. The window moves between this and the run's
+ * own admission, and the run's is the one that decides. That is the correct
+ * direction for an optimisation: it can only ever refuse something the gate
+ * would also have refused.
+ */
+function peekEnvelope(env, runsInFlight, now, home = (0, node_os_1.homedir)(), 
+/** What an unmeasured invocation is assumed to have cost. See `spendInWindow`. */
+estimateUsd) {
+    const view = spendInWindow(now, env.windowMs, runsInFlight, home, estimateUsd);
+    if (!view.ok)
+        return { ok: false, because: view.because };
+    const verdict = (0, core_1.withinEnvelope)(env, view.spend);
+    return verdict.ok ? { ok: true } : { ok: false, because: `${verdict.because} (${verdict.ceiling})` };
+}
+function admitSpend(env, what, estimateUsd, runsInFlight, now = () => Date.now(), home = (0, node_os_1.homedir)(), 
+/**
+ * WHICH RUN THIS HOLD IS FOR, so its settlement can REPLACE that run's rows.
+ *
+ * 🔴 WITHOUT IT EVERY RECONCILED RUN WAS CHARGED TWICE. The settlement's
+ * amount is computed BY SUMMING the run's own rows — and with nothing tying
+ * it to them, `spendInWindow` added it to the very rows it came from.
+ * MEASURED: three real invocations of $1 settled at $3, and the window read
+ * $6. A ceiling fed twice its truth refuses at half its value.
+ */
+runId) {
+    const id = (0, node_crypto_1.randomUUID)();
+    const reservedAt = new Date(now()).toISOString();
+    /**
+     * 🔴 THE WHOLE CHECK-AND-CLAIM IS ONE CRITICAL SECTION, AND ORDERING ROWS
+     * INSTEAD OF SERIALISING THEM ADMITTED TWICE THE CEILING.
+     *
+     * The previous mechanism gave every claimant a key of `(at, id)` and had it
+     * count only intents sorting at or before its own. That resolves a herd —
+     * the k-th claimant sees exactly k — but only if everybody publishes before
+     * anybody decides.
+     *
+     * MEASURED, $3 ceiling and $2 estimates, with the schedule forced rather than
+     * raced: B took key T+1000, published, and was ADMITTED. A took key T —
+     * EARLIER — published afterwards, excluded B from its own view as "later",
+     * and was ALSO ADMITTED. The window held $4 against a $3 ceiling. A total
+     * order over rows says who is first; it does not say who has already been
+     * told yes.
+     *
+     * Inside this lock, publication and decision happen together, so there is no
+     * interval in which a claim has been decided but not published — which is
+     * precisely why a late publication cannot invalidate anybody's safety: there
+     * is no such thing. Every claimant sees every prior claim, whatever its clock
+     * says, and the herd is resolved by taking turns.
+     *
+     * ⚠️ AND A LOCK IT CANNOT TAKE IS A REFUSAL. The ceiling's whole purpose is
+     * that concurrent starts see each other; one that could not serialise itself
+     * has no idea what anybody else is holding, and admitting it would be
+     * admitting an unbounded number of them. Same rule as a reservation that will
+     * not write.
+     */
+    return (0, exclusive_lock_1.withExclusiveLock)(spendLockPath(home), () => {
+        /**
+         * ONE OPEN HOLD PER RUN, EVER.
+         *
+         * 🔴 A REPLAYED ADMISSION USED TO RESERVE TWICE. A run that is admitted
+         * again — a restart, a retried launch, a supervisor that calls the seam
+         * twice — wrote a second reservation while the first was still open, so ONE
+         * run held TWO estimates against the window and the machine refused itself at
+         * a fraction of its ceiling. Worse in the other direction too: neither hold
+         * could be settled by the other's rows.
+         *
+         * A run cannot be running twice, so an earlier open hold for the same run is
+         * superseded here — by appending a cancellation naming it, never by
+         * rewriting anything, which is the ledger's rule everywhere.
+         */
+        if (runId !== undefined) {
+            const prior = readSpend(home);
+            if (prior.ok) {
+                const closedAlready = new Set(prior.records.filter((r) => r.kind === 'settlement' || r.kind === 'cancellation').map((r) => r.id));
+                for (const r of prior.records) {
+                    if (r.kind !== 'reservation' || r.runId !== runId || r.id === undefined)
+                        continue;
+                    if (closedAlready.has(r.id))
+                        continue;
+                    recordSpend({ at: reservedAt, what, kind: 'cancellation', id: r.id, ms: 0, runId }, home);
+                }
+            }
+        }
+        const wrote = recordSpend({
+            at: reservedAt,
+            what,
+            kind: 'reservation',
+            id,
+            ms: 0,
+            holdUntil: new Date(now() + admissionHoldMs(env.windowMs)).toISOString(),
+            ...(runId === undefined ? {} : { runId }),
+            ...(estimateUsd === undefined ? {} : { estimateUsd }),
+        }, home);
+        /**
+         * 🔴 A RESERVATION THAT WILL NOT WRITE IS A REFUSAL, NOT A SHRUG. The whole
+         * mechanism is that concurrent starts see each other's intent; one that could
+         * not record its own is invisible to everybody else, and admitting it would
+         * be admitting an unbounded number of them.
+         */
+        if (!wrote) {
+            return {
+                ok: false,
+                because: 'this machine could not record what it is about to spend, so it cannot bound it',
+            };
+        }
+        const close = (kind, usd, ms) => {
+            /**
+             * The last row of this run that exists AS THIS SETTLEMENT IS WRITTEN — the
+             * exact set it replaces. See `SpendRecord.coversUpTo`.
+             */
+            let coversUpTo;
+            if (kind === 'settlement' && runId !== undefined) {
+                const seen = readSpend(home);
+                if (seen.ok) {
+                    for (const r of seen.records) {
+                        if (r.runId !== runId || r.kind === 'reservation')
+                            continue;
+                        if (coversUpTo === undefined || r.at > coversUpTo)
+                            coversUpTo = r.at;
+                    }
+                }
+            }
+            recordSpend({
+                at: new Date(now()).toISOString(),
+                what,
+                kind,
+                id,
+                ms,
+                ...(runId === undefined ? {} : { runId }),
+                ...(coversUpTo === undefined ? {} : { coversUpTo }),
+                ...(usd === undefined ? {} : { usd }),
+            }, home);
+        };
+        const view = spendInWindow(now(), env.windowMs, runsInFlight, home, estimateUsd);
+        if (!view.ok) {
+            close('cancellation', undefined, 0);
+            return { ok: false, because: view.because };
+        }
+        const verdict = (0, core_1.withinEnvelope)(env, view.spend);
+        if (!verdict.ok) {
+            close('cancellation', undefined, 0);
+            return { ok: false, because: `${verdict.because} (${verdict.ceiling})` };
+        }
+        let closed = false;
+        return {
+            ok: true,
+            admission: {
+                settle: (actualUsd, ms) => {
+                    if (closed)
+                        return;
+                    closed = true;
+                    close('settlement', actualUsd, ms);
+                },
+                cancel: () => {
+                    if (closed)
+                        return;
+                    closed = true;
+                    close('cancellation', undefined, 0);
+                },
+            },
+        };
+    }, (why) => ({
+        ok: false,
+        // Same sentence the unwritable-reservation path uses, because it is the
+        // same fact from the person's side: this machine could not record what it
+        // is about to spend, so it cannot show the start is inside the ceiling.
+        because: `this machine could not record what it is about to spend — it could not serialise its budget admission (${why})`,
+    }));
+}
+/**
+ * Wrap an agent invocation so its cost is recorded.
+ *
+ * ⚠️ AT THE INVOCATION, NOT AT THE PARSE. `unwrapEnvelope` is pure and stays
+ * pure — a parser that wrote a file would be impossible to use in a test and
+ * would record a cost every time somebody re-read a transcript. This wraps the
+ * one place where an invocation actually happens.
+ */
+function recordingSpend(what, now, home, 
+/** Which run this invocation belongs to, so its reservation can be settled. */
+runId) {
+    return (r) => {
+        recordSpend({
+            at: new Date(now()).toISOString(),
+            what,
+            ms: r.ms,
+            ...(runId === undefined ? {} : { runId }),
+            ...(r.cost?.usd === undefined ? {} : { usd: r.cost.usd }),
+            ...(r.cost?.turns === undefined ? {} : { turns: r.cost.turns }),
+            ...(r.cost?.sessionId === undefined ? {} : { sessionId: r.cost.sessionId }),
+            ...(r.cost?.inputTokens === undefined ? {} : { inputTokens: r.cost.inputTokens }),
+            ...(r.cost?.outputTokens === undefined ? {} : { outputTokens: r.cost.outputTokens }),
+            ...(r.cost?.cacheReadTokens === undefined ? {} : { cacheReadTokens: r.cost.cacheReadTokens }),
+            ...(r.cost?.cacheWriteTokens === undefined ? {} : { cacheWriteTokens: r.cost.cacheWriteTokens }),
+        }, home);
+    };
+}
+//# sourceMappingURL=spend-ledger.js.map

package/dist/spend-ledger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spend-ledger.js","sourceRoot":"","sources":["../src/spend-ledger.ts"],"names":[],"mappings":"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"}

package/dist/stale-run-sweep.d.ts

@@ -0,0 +1,79 @@
+import { type StartupRecovery } from './daemon-recovery';
+import { type ProbeFn } from './run-lease';
+/**
+ * THE STALE-RUN SWEEP, OVER EVERY CHECKOUT THIS PROJECT EXECUTES IN.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 IT SWEPT THE DAEMON'S OWN CHECKOUT AND NOTHING ELSE.
+ *
+ * `recoverStaleRunOnStartup` was built over `join(opts.cwd, STATE_DIR,
+ * 'state')` — one lease, one ledger, one git tree: the main checkout's. A run
+ * the coordinator PLACED in a linked worktree holds its lease and writes its
+ * ledger THERE, so when it was killed nothing ever looked: its lease stayed
+ * `dead`, its ledger never got a `run.ended`, and the controller waiting on
+ * that ending waited for ever. Combined with the daemon reading the wrong
+ * ledger in the first place, a crashed placed run was invisible twice over.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHICH CHECKOUTS, AND WHY NOT "EVERY DIRECTORY UNDER THE ROOT"
+ *
+ * The main checkout, always — exactly as before. Then each directory directly
+ * under THIS project's workspaces root (`workspacesRoot(cwd)`, keyed by the
+ * repository's identity) that
+ *
+ *   • carries a `.looply` directory — a workspace looply cut, not litter;
+ *   • is not QUARANTINED — a quarantine is a durable "looply must not touch
+ *     this", and a sweep is touching;
+ *   • is still a checkout of THIS repository — a directory somebody moved
+ *     another repository into would otherwise be swept as ours.
+ *
+ * Deduplicated by real path, so a root reached twice (a symlinked home, a
+ * junction) is swept once, and the main checkout is never swept a second time
+ * under another name. No recursion: a workspace is one level below the root by
+ * construction (`createWorkspace`), and a sweep that walked deeper would be
+ * deciding about directories nothing here created.
+ *
+ * ⚠️ EACH CHECKOUT IS SWEPT WITH ITS OWN STORES AND ITS OWN GIT. The lease, the
+ * ledger and the working tree are EXECUTION-scoped facts, and
+ * `recoverStaleRunOnStartup` is built for exactly one of each. Every guarantee
+ * that function makes — `free`/`active`/`ambiguous` leave it alone, a dirty tree
+ * blocks, a closed run is not closed twice, the queue is never touched — holds
+ * per checkout, unchanged. A live sibling in another workspace is not looked at
+ * by the sweep of this one, so nothing it holds can be affected.
+ *
+ * ⚠️ ONE CHECKOUT'S FAILURE DOES NOT STOP THE OTHERS. A workspace whose ledger
+ * will not open logs and is skipped, and the next is still swept; the daemon
+ * loop already treats a throw from the whole sweep the same way.
+ */
+export interface StaleRunSweepDeps {
+    /** The daemon's working directory: the project's main checkout. */
+    cwd: string;
+    projectId: string;
+    log(line: string): void;
+    now?: () => number;
+    home?: string;
+    /** Injected by tests that cannot own a real dead process. */
+    probe?: ProbeFn;
+}
+export interface SweptCheckout {
+    checkout: string;
+    outcome: StartupRecovery | {
+        kind: 'failed';
+        because: string;
+    } | {
+        kind: 'released';
+        runId: string;
+        because: string;
+    };
+}
+/**
+ * The checkouts a sweep of this project covers, in a deterministic order: the
+ * main checkout first, then the workspaces by name.
+ */
+export declare function sweepTargets(cwd: string, home?: string): string[];
+/**
+ * The daemon's `recoverStaleRun` dependency. ONE factory for the daemon and the
+ * end-to-end proof, so the proof sweeps with the sweep the daemon runs.
+ */
+export declare function makeStaleRunSweep(deps: StaleRunSweepDeps): () => Promise<SweptCheckout[]>;
+//# sourceMappingURL=stale-run-sweep.d.ts.map

package/dist/stale-run-sweep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stale-run-sweep.d.ts","sourceRoot":"","sources":["../src/stale-run-sweep.ts"],"names":[],"mappings":"AAGA,OAAO,EAA4B,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGnF,OAAO,EAA8B,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAKvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,MAAM,WAAW,iBAAiB;IAChC,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,eAAe,GAAG;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACvH;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,MAAkB,GAAG,MAAM,EAAE,CAgC5E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,OAAO,CAAC,aAAa,EAAE,CAAC,CAkDzF"}