looply-cli 0.0.0-stage → 0.2.0

package/dist/spend-ledger.d.ts

@@ -0,0 +1,350 @@
+import { type Envelope, type Spend } from '@looply/core';
+import type { InvocationCost } from './gate';
+/**
+ * WHAT THE MACHINE HAS ACTUALLY SPENT, WRITTEN DOWN.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 `withinEnvelope` HAD NO SOURCE OF TRUTH, so a dollar ceiling was a number
+ * in a config file with nothing on the other side of the comparison.
+ *
+ * `envelope.ts` opens by saying a budget over numbers nobody counts is theatre,
+ * and it was right about its own tree: `parseAgentEnvelope` read
+ * `total_cost_usd`, `unwrapEnvelope` dropped it, and nothing anywhere appended
+ * a spend record. This is the missing half — the counter the ceiling reads.
+ *
+ * ⚠️ MACHINE-LEVEL, NOT PROJECT-LEVEL. The envelope bounds what THIS MACHINE
+ * may spend, and a per-project ledger would let ten projects each stay inside a
+ * ceiling that was written once. It lives beside the rails ledgers, which are
+ * machine-level for the same reason.
+ *
+ * ⚠️ AND IT IS HONEST ABOUT WHAT IT CANNOT SEE. The round runs its agent with
+ * `--output-format text` and receives no envelope, so the most expensive path
+ * in the system reports NO cost. That is recorded as an unmeasured invocation
+ * rather than a free one, and `spendInWindow` reports `usd: null` the moment
+ * one is in the window — which `withinEnvelope` refuses on. A ceiling that
+ * silently ignored the rounds would be the same theatre by a shorter route.
+ */
+export interface SpendRecord {
+    /** ISO 8601. */
+    readonly at: string;
+    /** What ran: `scan`, `compile`, `gap`, `round`. A label, not a key. */
+    readonly what: string;
+    /** Dollars, when the provider said. ABSENT MEANS UNMEASURED. */
+    readonly usd?: number;
+    readonly turns?: number;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    /**
+     * Context served from the provider's cache, and context written into it.
+     * ABSENT MEANS UNMEASURED, like every figure here. See `AgentEnvelope.cost`.
+     */
+    readonly cacheReadTokens?: number;
+    readonly cacheWriteTokens?: number;
+    /**
+     * The provider's own session identifier for the invocation, when it said.
+     * Metadata, not money: it is what ties a ledger row back to the provider's
+     * record of the same turn, and it is kept apart from the model's text.
+     */
+    readonly sessionId?: string;
+    /** Wall clock of the invocation, which is always measurable. */
+    readonly ms: number;
+    /**
+     * WHAT KIND OF ROW THIS IS.
+     *
+     * 🔴 A LEDGER OF WHAT WAS ALREADY SPENT CANNOT BOUND WHAT IS ABOUT TO BE.
+     *
+     * The cost of a Run is not known until it ends, which is hours after the
+     * decision to start it. A ceiling checked against completed rows alone
+     * therefore admits every concurrent start at once: ten daemons on one machine
+     * each read $0 spent, each decide they are under a $25 ceiling, and each
+     * launch. The ceiling was never wrong about the past; it simply had nothing
+     * to say about the future, which is the only thing an admission check is
+     * about.
+     *
+     * So a start writes a RESERVATION before it launches, and settles it to the
+     * real cost when the provider reports one. `spendInWindow` counts an open
+     * reservation at its estimate, so the second daemon reads the first one's
+     * intent rather than its silence.
+     *
+     * ⚠️ ABSENT MEANS `spend`, so every row an older build wrote still counts as
+     * exactly what it was.
+     */
+    readonly kind?: 'spend' | 'reservation' | 'settlement' | 'cancellation';
+    /**
+     * Ties a settlement or a cancellation to its reservation.
+     *
+     * ⚠️ APPEND-ONLY, LIKE EVERY LEDGER HERE. A reservation is never rewritten or
+     * removed — closing one appends a row that names it. A torn write then costs
+     * one record rather than corrupting a running total.
+     */
+    readonly id?: string;
+    /** What a reservation expects to cost. Absent means "cannot estimate". */
+    readonly estimateUsd?: number;
+    /**
+     * WHEN A RESERVATION STOPS COUNTING, AND WHY IT HAS TO.
+     *
+     * 🔴 THE PROCESS THAT ADMITS A RUN NEVER SEES IT END. The daemon spawns a
+     * detached child and returns; the run lives for hours in another process. So
+     * there is nobody to settle a reservation at the real number, and a
+     * reservation held open for ever would charge an estimate against the window
+     * long after the run it described had finished and recorded its own costs.
+     *
+     * A hold is therefore short and it EXPIRES. What it buys is the only thing an
+     * admission check needs and the only thing the ledger could not otherwise
+     * provide: concurrent starts SEE EACH OTHER, instead of each reading a
+     * machine that has spent nothing yet and all launching at once. Once the run
+     * is genuinely under way its own invocations are being recorded by the
+     * transport, and those are the real number — so the hold has done its job and
+     * gets out of the way rather than double-counting itself.
+     *
+     * ⚠️ IT IS NOT A BUDGET FOR THE RUN. Nothing here claims to know what a Run
+     * will cost, and this deliberately does not pretend to: it bounds the RATE at
+     * which runs may be admitted, and `maxWallClockMs` and `maxConcurrentRuns`
+     * bound the rest.
+     */
+    readonly holdUntil?: string;
+    /**
+     * WHICH RUN SPENT THIS.
+     *
+     * 🔴 WITHOUT IT A RESERVATION CAN NEVER BE RECONCILED. Admission holds an
+     * ESTIMATE; what the run actually costs is written by the transport, row by
+     * row, over hours. Tying those rows to the run is the only way to settle the
+     * reservation at the real number instead of letting the hold silently expire
+     * and hoping the rows land before the ceiling is next consulted.
+     *
+     * Absent on rows written outside a run — a `scan`, a `verify` — which are
+     * charged as themselves and settle nothing.
+     */
+    readonly runId?: string;
+    /**
+     * ON A SETTLEMENT: THE LAST OF ITS RUN'S ROWS THAT IT ACTUALLY SUMMED.
+     *
+     * 🔴 A SETTLEMENT REPLACES ROWS, SO WHICH ROWS MUST NOT BE A GUESS. The
+     * pairing was inferred from wall clock — "rows written before the settlement"
+     * — which is true of production and NOT true of anything with a fixed clock,
+     * and is one skewed timestamp away from being untrue in production too.
+     * MEASURED under a frozen clock: three real $1 invocations settled at $3, and
+     * the window read $6, because not one of the three sorted before the
+     * settlement that was computed from them.
+     *
+     * This is written from the rows the settlement actually saw, so the set it
+     * replaces is exact and needs no clock to agree with it. A straggler landing
+     * afterwards sorts past this mark and is charged on top, which is right: it
+     * is money the settlement never counted.
+     */
+    readonly coversUpTo?: string;
+}
+/**
+ * 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.
+ */
+export declare const ADMISSION_HOLD_MS: number;
+/**
+ * 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.
+ */
+export declare function admissionHoldMs(windowMs: number): number;
+/**
+ * ⚠️ 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.
+ */
+export declare function spendLedgerPath(home?: string): string;
+/**
+ * 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`.
+ */
+export declare function spendLockPath(home?: string): string;
+/**
+ * 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.
+ */
+export declare function recordSpend(record: SpendRecord, home?: string): boolean;
+export type SpendRead = {
+    readonly ok: true;
+    readonly records: SpendRecord[];
+} | {
+    readonly ok: false;
+    readonly because: string;
+};
+/**
+ * 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.
+ */
+export declare function readSpend(home?: string): SpendRead;
+/**
+ * The `Spend` the envelope compares against, for the window ending now.
+ *
+ * 🔴 ONE UNMEASURED INVOCATION IN THE WINDOW MAKES THE WHOLE SUM UNMEASURED.
+ *
+ * The alternative is to add up the ones that reported and call it the total,
+ * which is a number that looks like a measurement and is not one. Against a
+ * ceiling it fails in the one direction that spends somebody's money: a night
+ * of rounds — none of which report a cost — would total $0.00 and sail under
+ * any limit. `null` means "cannot say", and `withinEnvelope` refuses on it.
+ */
+export type SpendView = {
+    readonly ok: true;
+    readonly spend: Spend;
+} | {
+    readonly ok: false;
+    readonly because: string;
+};
+export declare function spendInWindow(now: number, windowMs: number, runsInFlight: number, home?: string, 
+/**
+ * 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?: number): SpendView;
+/**
+ * ADMISSION: MAY ONE MORE CONSEQUENTIAL INVOCATION START?
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 RESERVE FIRST, THEN VERIFY — CHECKING FIRST IS THE RACE.
+ *
+ * `withinEnvelope` is a pure comparison against a moment. Two machines, or two
+ * projects' daemons on one machine, both read the same moment and both admit:
+ * the ceiling is not wrong, it is simply answering a question about the past
+ * while the caller is asking one about the future.
+ *
+ * So this writes its intent BEFORE it decides, then re-reads and checks whether
+ * it is still inside. If somebody else's reservation got there first, the total
+ * now includes theirs and this one refuses and withdraws. It is the same
+ * compare-after-claim the surface lease and the queue-write lock both settled
+ * on, applied to a number instead of a directory.
+ *
+ * ⚠️ AND THE ESTIMATE IS AN ESTIMATE, WHICH IS SAID RATHER THAN HIDDEN. Nothing
+ * can know what a Run will cost before it runs. What a reservation buys is that
+ * concurrent starts SEE EACH OTHER; the settlement is what makes the number
+ * true afterwards. An estimate that is absent makes the window unmeasurable —
+ * which refuses — rather than free.
+ */
+export interface Admission {
+    /** Call when the invocation ends, with what it actually cost. */
+    settle(actualUsd: number | undefined, ms: number): void;
+    /** Call when it never happened. */
+    cancel(): void;
+}
+export type AdmissionResult = {
+    readonly ok: true;
+    readonly admission: Admission;
+} | {
+    readonly ok: false;
+    readonly because: string;
+};
+/**
+ * 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.
+ */
+export declare function spentByRun(runId: string, home?: string): number | null;
+/**
+ * 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.
+ */
+export declare function peekEnvelope(env: Envelope, runsInFlight: number, now: number, home?: string, 
+/** What an unmeasured invocation is assumed to have cost. See `spendInWindow`. */
+estimateUsd?: number): {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly because: string;
+};
+export declare function admitSpend(env: Envelope, what: string, estimateUsd: number | undefined, runsInFlight: number, now?: () => number, home?: string, 
+/**
+ * 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?: string): AdmissionResult;
+/**
+ * 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.
+ */
+export declare function recordingSpend(what: string, now: () => number, home?: string, 
+/** Which run this invocation belongs to, so its reservation can be settled. */
+runId?: string): (r: {
+    ms: number;
+    cost?: InvocationCost;
+}) => void;
+//# sourceMappingURL=spend-ledger.d.ts.map

package/dist/spend-ledger.d.ts.map

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