looply-cli 0.0.0-stage → 0.3.0

package/dist/daemon-recovery.d.ts

@@ -0,0 +1,78 @@
+import type { Status } from '@looply/core';
+import { type RecoveryGit } from './recovery';
+import { type LeaseState } from './run-lease';
+import type { AnyEventInput, LedgerFs } from './ledger-store';
+/**
+ * What a previous run left behind, settled when the daemon starts.
+ *
+ * The classifier and its applier already existed and are not duplicated here.
+ * What was missing was a *caller*: `looply run` was the only thing that ever ran
+ * recovery, so a crashed run was repaired only when somebody started another
+ * one. That is precisely the state a crash leaves a person in — the phone shows
+ * a run already in progress and offers no Start — so the repair was gated behind
+ * the action the unrepaired state discourages. Meanwhile the daemon sat there
+ * polling commands every three seconds and shipping the ledger every five,
+ * walking past the evidence on every tick.
+ *
+ * The user-visible half is `run.ended` never being emitted: `status.json` still
+ * says `live`, the server's `Run.endedAt` stays null, and the project answers
+ * 409 to a delete for ever. Nothing heals that on its own.
+ *
+ * **This process holds no lease, and three separate safety properties in this
+ * codebase are derived from holding one.** That is what makes this delicate, and
+ * it is why the scope is narrower than `run-cmd`'s:
+ *
+ * 1. The queue has no cross-process write protection at all. `QueueStore.update`
+ *    compares an in-memory version and `persist()` serialises the whole map, so
+ *    two writers do not lose one item to each other — the later rename reverts
+ *    the entire queue to its own snapshot. So this closes the run and never
+ *    touches the queue; see `runClosureOnly`.
+ * 2. The classifier will happily requeue a *live* run's `in_progress` item if it
+ *    is handed a null lease. `run-cmd` is saved from that only by ordering —
+ *    `acquire()` throws between its classify and its apply. There is no acquire
+ *    here, so the lease state is checked first and anything but `dead` stops.
+ * 3. Nothing removes the lease, which is the point of a lease that survives a
+ *    daemon restart. So without an idempotence check a supervised daemon
+ *    restarting five times would append five `run.ended` events and show the
+ *    phone five recovery alerts for one crash.
+ */
+export interface StartupRecoveryDeps {
+    leases: {
+        inspect(): Promise<LeaseState>;
+    };
+    /** Three read-only methods. The driver has ten, and two of them write. */
+    git: RecoveryGit;
+    /** `open()` both enables `append` and hands back the projection this needs. */
+    ledger: {
+        open(): Promise<Status>;
+        append(input: AnyEventInput): Promise<unknown>;
+    };
+    /**
+     * Where that ledger lives, and how to read it — for the one question the
+     * projection cannot answer: whether THIS run already has an ending. See the
+     * idempotence check below.
+     */
+    ledgerStateDir: string;
+    ledgerFs: Pick<LedgerFs, 'readFile'>;
+    projectId: string;
+    now(): number;
+    log(line: string): void;
+}
+export type StartupRecovery = 
+/** Nothing was done, and why. */
+{
+    kind: 'idle';
+    reason: 'no-lease' | 'run-live' | 'already-closed' | 'undecidable';
+}
+/** A dead run was given an ending on the ledger. */
+ | {
+    kind: 'closed';
+    runId: string;
+}
+/** Something is here that cannot be proven safe to touch. Nothing was changed. */
+ | {
+    kind: 'blocked';
+    reason: string;
+};
+export declare function recoverStaleRunOnStartup(d: StartupRecoveryDeps): Promise<StartupRecovery>;
+//# sourceMappingURL=daemon-recovery.d.ts.map

package/dist/daemon-recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-recovery.d.ts","sourceRoot":"","sources":["../src/daemon-recovery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAmD,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAG/F,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE;QAAE,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC,CAAA;KAAE,CAAC;IAC3C,0EAA0E;IAC1E,GAAG,EAAE,WAAW,CAAC;IACjB,+EAA+E;IAC/E,MAAM,EAAE;QAAE,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;QAAC,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC;IACpF;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,IAAI,MAAM,CAAC;IACd,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,MAAM,MAAM,eAAe;AACzB,iCAAiC;AAC/B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,GAAG,UAAU,GAAG,gBAAgB,GAAG,aAAa,CAAA;CAAE;AACtF,oDAAoD;GAClD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AACnC,kFAAkF;GAChF;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAExC,wBAAsB,wBAAwB,CAAC,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,eAAe,CAAC,CA0J/F"}

package/dist/daemon-recovery.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recoverStaleRunOnStartup = recoverStaleRunOnStartup;
+const recovery_1 = require("./recovery");
+const goal_met_target_1 = require("./goal-met-target");
+const recovery_io_1 = require("./recovery-io");
+const run_lease_1 = require("./run-lease");
+const run_ended_1 = require("./run-ended");
+async function recoverStaleRunOnStartup(d) {
+    // The gate, and the only one. `run-cmd` folds `active` and `ambiguous` into a
+    // null lease and is saved from the consequences by `acquire()` throwing a few
+    // lines later. There is no acquire here, and the consequence is specific: with
+    // a null lease and a live run's `in_progress` item, the classifier returns a
+    // *requeue* for the item that run is holding right now. So this asks one
+    // question before it has looked at git or the queue at all.
+    const state = await d.leases.inspect();
+    if (state.kind === 'free')
+        return { kind: 'idle', reason: 'no-lease' };
+    if (state.kind === 'active') {
+        d.log(`daemon  : ${(0, run_lease_1.describeLease)(state)} — leaving it alone.`);
+        return { kind: 'idle', reason: 'run-live' };
+    }
+    if (state.kind === 'ambiguous') {
+        // Fails closed, for the same reason `acquire` does: telling the phone that a
+        // healthy run crashed is worse than leaving a crashed one looking live.
+        d.log(`daemon  : ${(0, run_lease_1.describeLease)(state)} — not recovering it.`);
+        return { kind: 'idle', reason: 'undecidable' };
+    }
+    let status;
+    try {
+        status = await d.ledger.open();
+    }
+    catch (e) {
+        // A repair that cannot be performed must not stop the process that does the
+        // polling, the command dispatch and the shipping from starting at all. Every
+        // other store on this path is already total for the same reason — the cursor
+        // and the receipts both report "unreadable" rather than throwing — and an
+        // events.jsonl held open by an indexer or a scanner is an ordinary Windows
+        // condition, not a broken repository.
+        d.log(`daemon  : could not read the ledger to check for a stale run — ${e.message}`);
+        return { kind: 'idle', reason: 'undecidable' };
+    }
+    // Only the run the lease names, and only once.
+    //
+    // Idempotence across restarts is the reason for the check: nothing removes
+    // the lease — that is what makes it survive one — so without it a daemon
+    // under a supervisor would append a `run.ended` and a recovery alert every
+    // time it came back, and the phone would show one banner per restart for one
+    // crash.
+    //
+    // 🔴 THE CHECK USED TO BE `status.live`, AND THAT LEFT ONE SHAPE UN-ENDED FOR
+    // EVER. `run.started` is emitted after the compile pass and both verify
+    // passes, so a run killed while its agent is working — which is most of a
+    // run's early life — has taken its lease, registered, and written NOTHING to
+    // its ledger. `status.live` is false for it, so this returned
+    // `already-closed`, wrote no ending, and the reasoning recorded here was
+    // "nothing local reads `live`". That stopped being true when the autonomous
+    // controller began waiting on `run.ended` to close a Start: such a run held
+    // its ordinal until the grant expired, in a single checkout as much as in a
+    // placed one.
+    //
+    // So the question is asked of the ledger directly: has THIS run already been
+    // given an ending? `readRunEnded` is the same reader the controller uses,
+    // and it is keyed on the run id rather than on the projection, so a run that
+    // never reached `run.started` is closed exactly once and then found closed.
+    //
+    // ⚠️ A DIFFERENT RUN LIVE ON THIS LEDGER IS STILL LEFT ALONE. A dead lease
+    // beside a ledger whose live run is somebody else is not a state this can
+    // reason about, and the old answer — do nothing — stands.
+    if (status.live && status.runId !== state.lease.runId) {
+        return { kind: 'idle', reason: 'already-closed' };
+    }
+    const ending = await (0, run_ended_1.readRunEnded)(d.ledgerStateDir, d.ledgerFs, state.lease.runId);
+    if (!ending.ok) {
+        d.log(`daemon  : could not tell whether ${state.lease.runId} already ended — ${ending.because}`);
+        return { kind: 'idle', reason: 'undecidable' };
+    }
+    if (ending.ended)
+        return { kind: 'idle', reason: 'already-closed' };
+    let recovery;
+    try {
+        recovery = (0, recovery_1.classifyRecovery)({
+            lease: state.lease,
+            // Deliberately empty, and provably equivalent to reading queue.json here.
+            // `stranded` feeds exactly one thing in the classifier — the `items` list
+            // — and `runClosureOnly` discards that below; with a non-null lease the
+            // only other use, `nothingLeftBehind`, is false either way. So reading the
+            // queue would change no decision this function makes, while adding a
+            // failure mode (a zero-byte queue.json throws inside `JSON.parse`, and
+            // would abort a closure that never depended on it) and putting a
+            // QueueStore in a process that must never write one.
+            stranded: [],
+            changedPaths: await d.git.changedPaths(),
+            currentBranch: await d.git.currentBranch(),
+            headSubject: await d.git.messageOf('HEAD'),
+            // F33: a goal-met Start that moved HEAD and died left it here on purpose.
+            judging: (0, goal_met_target_1.readJudgingMarker)(d.ledgerStateDir),
+            ...(d.git.headSha === undefined ? {} : { headSha: await d.git.headSha() }),
+        });
+    }
+    catch (e) {
+        // A tree we could not read is not a clean tree. `changedPaths` is the one
+        // piece of evidence that throws, and reading its failure as "nothing
+        // changed" is exactly the guess the dirty-tree rule exists to refuse.
+        d.log(`daemon  : could not check what a previous run left behind — ${e.message}`);
+        return { kind: 'idle', reason: 'undecidable' };
+    }
+    if (recovery.kind === 'blocked') {
+        // Nothing is written — not the ledger, not the queue, not a ref. A person is
+        // told what was found and why it will not be guessed at. Deliberately not an
+        // alert on the phone: with nothing to dedupe on, a dirty tree would raise a
+        // fresh warning on every daemon start until somebody cleaned it up.
+        d.log(`recover : ${recovery.reason}`);
+        return { kind: 'blocked', reason: recovery.reason };
+    }
+    if (recovery.kind === 'none' || !recovery.closeRun) {
+        return { kind: 'idle', reason: 'no-lease' };
+    }
+    // Between the lease read at the top and here sit three git spawns, which is
+    // long enough for a `looply run` to have started, taken the lease, and run its
+    // own recovery on the same dead run. Re-read, and stop if anything moved.
+    //
+    // This narrows the window rather than closing it: two processes appending to
+    // one events.jsonl each hold their own in-memory seq counter, so a genuinely
+    // simultaneous close writes two lines with the same `(runId, seq)`. Ingest
+    // dedupes on exactly that pair, so the server keeps one — which is correct for
+    // the closure but means one of the two recovery *alerts* is discarded, and
+    // which one is decided by arrival order. Both describe the same crash; the
+    // run's is the more informative, because it can also say what it requeued.
+    // Recorded here rather than engineered around, because the alternative is a
+    // daemon-held lease and run-lease.ts explains at length why that is worse.
+    const now = await d.leases.inspect();
+    if (now.kind !== 'dead' || now.lease.token !== state.lease.token) {
+        return { kind: 'idle', reason: 'undecidable' };
+    }
+    // The closure half only, and the applier is given no queue — so if item
+    // repairs ever reached it, it would refuse rather than silently drop them.
+    await (0, recovery_io_1.applyRecovery)((0, recovery_1.runClosureOnly)(recovery), {
+        ledger: d.ledger,
+        // M5-5: read again at write time — the check above and this write are
+        // moments apart, and another process may close the same run between them.
+        alreadyEnded: async (runId) => {
+            const ended = await (0, run_ended_1.readRunEnded)(d.ledgerStateDir, d.ledgerFs, runId);
+            return ended.ok ? ended.ended : null;
+        },
+        projectId: d.projectId,
+        now: d.now,
+        log: d.log,
+    });
+    // The lease is left exactly where it is. Deleting it is sanctioned in
+    // principle — `acquire` does it — but it is this tree's ownership token and
+    // the only file a starting run and this process could ever contend over;
+    // leaving it alone is what makes "the daemon takes no ownership" literally
+    // true rather than approximately true. It is also `run-cmd`'s input to the
+    // branch-divergence check, which nothing here replaces. The cost is one
+    // duplicate `run.ended` if a run is later started by hand, and that is
+    // harmless at every reader: ingest guards its Run row on `endedAt: null`, and
+    // the local fold is idempotent assignment.
+    return { kind: 'closed', runId: recovery.closeRun };
+}
+//# sourceMappingURL=daemon-recovery.js.map

package/dist/daemon-recovery.js.map

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

package/dist/daemon.d.ts

@@ -0,0 +1,368 @@
+import type { AnyEvent, Goal } from '@looply/core';
+import { type ServerClient, type ServerCommand } from './server-client';
+/**
+ * The daemon.
+ *
+ * Long-lived and idle-but-connected, because pairing happens before any run
+ * exists and runs are started from a phone. That is the departure from the
+ * harness this replaces, which was a script that existed only while it worked.
+ *
+ * Two jobs, one loop: prove the machine is alive, and ship the ledger. Both are
+ * best-effort by design — the server being unreachable degrades looply to a loop
+ * that works locally and reports late, which is exactly what it should degrade
+ * to and never worse.
+ */
+/**
+ * What became of a command the daemon was handed.
+ *
+ * - `done` — carried out. Acked; never handed over again.
+ * - `refused` — this build will never carry this verb out. Also terminal, and
+ *   that is the point: leaving it unacked would have the server offer it again
+ *   every three seconds for the life of the machine.
+ * - `retry` — could not be carried out *now* (no launcher, a spawn that failed,
+ *   a control file that would not write). Left unacked deliberately, so the
+ *   next poll offers it again.
+ *
+ * This used to be a boolean, and the false branch was documented as "comes back
+ * on the next poll". It did not: delivery was a destructive pop with nothing
+ * putting ids back, so anything not acked was lost outright.
+ */
+export type CommandDisposition = 'done' | 'refused' | 'retry';
+/**
+ * What a handler decided, and — for a refusal — why.
+ *
+ * The reason rides ONLY on the refused shape, deliberately. A `done` command
+ * has nothing to explain and a `retry` is not an answer yet, so making either
+ * of them carry a reason would be making an unreachable state representable —
+ * and the one bug this shape exists to prevent is a stale explanation arriving
+ * attached to a success.
+ *
+ * A bare disposition still means what it always did, so every handler that has
+ * nothing to add keeps returning one.
+ */
+export type CommandDecision = CommandDisposition | {
+    disposition: 'refused';
+    reason: string;
+};
+export type CommandHandler = (command: ServerCommand) => Promise<boolean | CommandDecision>;
+/** What the loop acts on: one disposition, and a reason only a refusal may have. */
+export interface DecidedCommand {
+    disposition: CommandDisposition;
+    reason?: string;
+}
+export interface DaemonDeps {
+    client: ServerClient;
+    machineId: string;
+    projectId: string;
+    cliVersion: string;
+    /** Omit and commands are left on the server for a daemon that can act on them. */
+    onCommand?: CommandHandler;
+    /** How often to ask for commands the phone has queued. */
+    commandPollMs?: number;
+    /** Refresh presence at a third of the TTL, so one missed beat is survivable. */
+    heartbeatMs?: number;
+    /** How often the buffered ledger is shipped. */
+    flushMs?: number;
+    /** Ceiling on events held for an absent server; see `DEFAULT_BUFFER_LIMIT`. */
+    bufferLimit?: number;
+    /**
+     * Where the confirmed-delivery cursor lives, when this process owns one.
+     *
+     * Only the standalone daemon passes it. A run's own attached sync daemon
+     * deliberately does not: two processes advancing one cursor file would each
+     * overwrite the other's view of a run they cannot see, and the run's own
+     * events are replayed by the daemon anyway if the run dies before shipping.
+     */
+    cursors?: {
+        all(): Record<string, number>;
+        advance(next: Record<string, number>): Promise<void>;
+    };
+    /** Reads the ledger and hands the uploader whatever the cursor does not cover. */
+    replay?(sink: {
+        enqueue(e: AnyEvent): void;
+        durableHead(runId: string): number;
+    }): Promise<{
+        replayed: number;
+        damaged: number;
+        /**
+         * Lines that are events this build has no name for. Declared here as well
+         * as on `ReplayResult` because THIS type is what the daemon actually reads,
+         * and a field a structural type does not name is a field the daemon cannot
+         * say — which is how a counted fact goes unsaid (§5 item 41).
+         */
+        fromNewerBuild?: number;
+    }>;
+    /**
+     * Where the server's goals are mirrored, when this process owns the mirror.
+     *
+     * Only the standalone daemon passes it. These stores rewrite the whole file
+     * from their own in-memory map, so a second writer does not race a row — it
+     * reverts the file to its own snapshot. One writer, and this is it.
+     */
+    goals?: {
+        replace(goals: readonly Goal[]): Promise<void>;
+    };
+    /** How often the goal mirror is refreshed. */
+    goalPollMs?: number;
+    /**
+     * Close out a run that died without writing its own ending.
+     *
+     * Supplied only by the standalone daemon, and IN THE LOOP rather than only at
+     * startup — which is where it used to live, and only there.
+     *
+     * That was sufficient while nothing waited on a run: a person taps Start,
+     * and if the last run had been killed the next daemon start tidied it up. It
+     * stops being sufficient the moment anything waits for `run.ended`, because a
+     * SIGKILLed run never writes one. A daemon that stays up for a week would
+     * leave that run un-ended for a week, and anything waiting on it would wait
+     * for ever.
+     *
+     * Idempotent by its own contract: it inspects the lease, and answers `idle`
+     * when there is nothing to do, when the run is live, or when the ending is
+     * already written. Calling it on a tick is therefore free in the common case.
+     */
+    recoverStaleRun?(): Promise<void>;
+    /**
+     * One autonomy transition for at most one controller.
+     *
+     * Optional like every other job here: a daemon with no autonomy wiring simply
+     * never continues a goal by itself, which is the safe absence rather than a
+     * failure. See autonomy-tick.ts.
+     */
+    autonomyTick?(): Promise<void>;
+    /**
+     * The coordinator's turn, when a project has one.
+     *
+     * ⚠️ AN ENTRY, NOT A PROCESS. This loop is already deterministic and
+     * single-threaded with pluggable jobs and `tick = min(all cadences)`; the
+     * coordinator is one more of them. Its errors are caught exactly like every
+     * other job's, so a coordinator that throws cannot reject the loop — which is
+     * the property that lets a scheduler be added to a daemon people rely on.
+     *
+     * ⚠️ AND IT IS OPTIONAL, so a machine that has never configured capacity has
+     * no coordinator at all and behaves exactly as it does today.
+     */
+    coordinatorTick?(): Promise<void>;
+    /** How often to give the controller a turn. */
+    autonomyPollMs?: number;
+    /** How often that check runs. Slow: it exists for a rare, durable condition. */
+    stalePollMs?: number;
+    log(line: string): void;
+    sleep(ms: number): Promise<void>;
+    now(): number;
+    /** Polled between ticks; true once a stop was requested. */
+    stopRequested?(): boolean;
+}
+export declare const DEFAULT_HEARTBEAT_MS = 15000;
+/**
+ * Bounds on a cadence the SERVER proposes.
+ *
+ * The floor stops a malformed or hostile `refreshS` turning the loop into a
+ * spin — `tick` is the MINIMUM of every cadence, so a zero here would busy-wait
+ * the whole daemon, not just the heartbeat. The ceiling is a sanity limit; a
+ * server that wants an hour between beats has almost certainly sent nonsense.
+ */
+export declare const MIN_HEARTBEAT_MS = 2000;
+export declare const MAX_HEARTBEAT_MS = 300000;
+/**
+ * How often to beat: what the operator configured, else what the server asked
+ * for, else the built-in default.
+ *
+ * 🔴 THE SERVER PUBLISHES THIS CADENCE ON PURPOSE AND NOTHING WAS READING IT.
+ * `MachinesService.heartbeat` returns `{ ttlS, refreshS }` and says why in its
+ * own words: "the cadence is server-owned, so tuning the TTL never requires
+ * shipping a new CLI." That property was FALSE. The daemon paced on
+ * `DEFAULT_HEARTBEAT_MS` and discarded the response — it could not have used
+ * `refreshS`, because `ServerClient` typed the reply `{ ok, nextBeatS? }` and
+ * BOTH of those fields were invented. Found by driving the real client against
+ * a real server (`daemon-client-flagship.e2e.spec.ts`).
+ *
+ * ⚠️ TODAY THIS CHANGES NOTHING, AND THAT IS THE UNCOMFORTABLE PART. The server
+ * says `PRESENCE_REFRESH_S = 15` and this file said `15_000`, so the two agreed
+ * — by coincidence, as two hardcoded constants written independently in two
+ * trees. The failure was asymmetric and waiting: RAISING the server's TTL is
+ * harmless, but LOWERING it (say to 21s, refresh 7s) leaves a CLI beating every
+ * 15s against a 21s window, and every machine in the fleet flickers offline for
+ * a reason nothing in the CLI could explain.
+ *
+ * The operator's own `--heartbeat-ms` still wins: a person who pinned a cadence
+ * on this machine outranks a suggestion from the other end of the wire.
+ */
+export declare function heartbeatCadenceMs(configured: number | undefined, serverRefreshS: number | null | undefined): number;
+export declare const DEFAULT_FLUSH_MS = 5000;
+/** Fast enough that a tap on a phone feels immediate, slow enough to be free. */
+export declare const DEFAULT_COMMAND_POLL_MS = 3000;
+/**
+ * Goal intent changes when a person types, not when the loop runs, so this is
+ * slow on purpose. Nothing reads the mirror in this phase; refreshing it faster
+ * would spend requests on a file with no consumer.
+ */
+export declare const DEFAULT_GOAL_POLL_MS = 30000;
+/**
+ * How often a dead run is looked for.
+ *
+ * Slow on purpose. It reads a lease file and, at most, writes one ending for a
+ * process that is already gone — there is nothing to be gained by asking often,
+ * and a run that ends normally writes its own ending within milliseconds. The
+ * cost of being late is that something waiting on a CRASHED run waits up to
+ * this long, which is a minute, once, for a case that should be rare.
+ */
+export declare const DEFAULT_STALE_POLL_MS = 60000;
+/**
+ * How often a controller gets a turn.
+ *
+ * Ten seconds, chosen against the cadences already here rather than picked: the
+ * command poll is 3s because a person is waiting for their tap to land, the
+ * heartbeat 15s, the goal pull 30s, the stale sweep 60s. Nobody is waiting on
+ * an autonomous Start — the person authorized it and went to bed — so it sits
+ * between the ones that serve a live tap and the ones that sweep.
+ *
+ * It also bounds the cost of the one thing a tick can do that is not free. A
+ * tick that launches a Start waits for the child's settle window (750ms) before
+ * returning, so at this cadence the controller can occupy at most about seven
+ * per cent of one daemon's time, and only on the ticks that actually launch.
+ */
+export declare const DEFAULT_AUTONOMY_POLL_MS = 10000;
+export interface DaemonStatus {
+    online: boolean;
+    lastBeatAt: number | null;
+    /** Consecutive failures. Reported so a long outage is visible, not guessed at. */
+    missedBeats: number;
+    buffered: number;
+    delivered: number;
+    /** Events the buffer cap threw away. Non-zero means the mirror has a gap. */
+    dropped: number;
+    /** Events the server took without accounting for. Non-zero means it kept fewer than it was sent. */
+    unacked: number;
+}
+export declare class Daemon {
+    private readonly deps;
+    private readonly uploader;
+    private running;
+    private online;
+    private lastBeatAt;
+    private missedBeats;
+    private delivered;
+    /** Whether the server-kept-fewer-than-it-was-sent line has been said. */
+    private unackedReported;
+    /** Commands already reported as left-queued, so a retry loop says so once. */
+    private readonly retried;
+    /**
+     * Whether the current outage has been mentioned.
+     *
+     * Not `online`, which starts false: keying the message off a true→false
+     * transition means a daemon that never connects in the first place says
+     * nothing at all, which is the one case where the user most needs telling.
+     */
+    private outageReported;
+    /**
+     * The refresh interval the server last asked for, in seconds; null until a
+     * heartbeat has succeeded. Read through `heartbeatCadenceMs`, never directly.
+     */
+    private serverRefreshS;
+    /** Set when the server refuses the credential; retrying cannot fix that. */
+    private revoked;
+    /** Whether the buffer overflow has been mentioned; see `enqueue`. */
+    private overflowReported;
+    /** Whether the catching-up line has been said for the current backlog. */
+    private replayReported;
+    /** Whether the ledger-unreadable line has been said for the current outage. */
+    private replayFailureReported;
+    private goalFailureReported;
+    constructor(deps: DaemonDeps);
+    /** Queue an event for the next flush. Called from the ledger append path. */
+    enqueue(event: AnyEvent): void;
+    /**
+     * Hand the uploader whatever the ledger holds and the cursor does not cover.
+     *
+     * Asked on every flush tick, not once. This used to latch itself off the
+     * first time a pass found nothing to send — and the ordinary case is that the
+     * very first pass finds nothing, because the daemon is started before any run
+     * exists. So it replayed zero on its first tick, closed the latch, and never
+     * looked at the ledger again for the rest of its life. A run that died an
+     * hour later left its tail on disk with nothing that would ever look at it:
+     * exactly the failure replay was written to close, put back by the
+     * optimisation meant to make replay cheap.
+     *
+     * **"Nothing to send now" and "nothing will ever need sending again" are not
+     * the same statement, and only the first is something a pass can prove.**
+     *
+     * Being cheap is the supplier's job, not this method's — `makeLedgerReplay`
+     * skips the read entirely while the ledger cannot have grown, which costs a
+     * stat rather than a parse of the whole file.
+     */
+    private replayOnce;
+    /** Revocation is terminal: retrying a revoked token cannot ever succeed. */
+    private markRevoked;
+    status(): DaemonStatus;
+    /**
+     * One heartbeat.
+     *
+     * Presence is a TTL key on the server, so missing a beat is what makes a
+     * machine read as offline. A failure here is logged once on the transition
+     * rather than every tick — an hour offline should not be an hour of identical
+     * log lines nobody reads.
+     */
+    beat(): Promise<boolean>;
+    /**
+     * Give a dead run its ending, if one is owed.
+     *
+     * Never throws into the loop. A recovery that failed will be tried again on
+     * the next sweep, and a daemon that died over a lease file it could not read
+     * would have turned a recoverable condition into an outage.
+     */
+    /**
+     * Give the controller one turn.
+     *
+     * Errors are logged and swallowed, exactly as the stale sweep's are: this
+     * would otherwise be the first job in the loop capable of rejecting
+     * `Daemon.run()`, and a daemon that dies because one grant's record was
+     * briefly unreadable would take the heartbeat, the command poll and every
+     * other project's work down with it.
+     *
+     * There is no retry here. The next cadence is the retry, and a tight catch
+     * loop would turn a server outage into a spin.
+     */
+    private runAutonomyTick;
+    /** See {@link DaemonDeps.coordinatorTick}. Caught like every other job. */
+    private runCoordinatorTick;
+    private sweepStaleRun;
+    /**
+     * Refresh the local copy of the server's goals.
+     *
+     * Strictly a mirror: read the server's answer, write it down, and nothing
+     * else. It does not touch the queue, it does not start a run, and it does not
+     * call an agent — a goal is not read to decide what to do until a later phase,
+     * and this method existing is not that phase beginning.
+     *
+     * A failure keeps whatever the mirror already holds. Erasing a good copy
+     * because the server is briefly away would make an outage worse than it is,
+     * and the file's whole purpose is to be the answer when the server is not
+     * there to give one. Offline is already reported by the heartbeat, so this
+     * says nothing per tick.
+     */
+    pullGoals(): Promise<number | null>;
+    /** Report a goal-refresh failure once per outage, not once per tick. */
+    private reportGoalFailure;
+    /**
+     * Collect and carry out whatever the phone queued.
+     *
+     * A command is acked only once the handler says it was carried out. Acking on
+     * receipt would mean a command lost to a crash between pop and execution is
+     * gone forever, and the person who tapped Stop would never learn it did not
+     * happen.
+     */
+    pollCommands(): Promise<number>;
+    /** Ship whatever is buffered. Retained on failure; never dropped. */
+    flush(): Promise<void>;
+    /**
+     * Run until stopped.
+     *
+     * Heartbeat and flush share one clock rather than running two timers, so a
+     * slow server cannot let them drift into overlapping and doubling the load on
+     * a machine that is already struggling to reach it.
+     */
+    run(): Promise<DaemonStatus>;
+    stop(): void;
+}
+//# sourceMappingURL=daemon.d.ts.map

package/dist/daemon.d.ts.map

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