looply-cli 0.0.0-stage → 0.2.0

package/dist/daemon.js

@@ -0,0 +1,601 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Daemon = exports.DEFAULT_AUTONOMY_POLL_MS = exports.DEFAULT_STALE_POLL_MS = exports.DEFAULT_GOAL_POLL_MS = exports.DEFAULT_COMMAND_POLL_MS = exports.DEFAULT_FLUSH_MS = exports.MAX_HEARTBEAT_MS = exports.MIN_HEARTBEAT_MS = exports.DEFAULT_HEARTBEAT_MS = void 0;
+exports.heartbeatCadenceMs = heartbeatCadenceMs;
+const uploader_1 = require("./uploader");
+const server_client_1 = require("./server-client");
+/** Boolean handlers predate dispositions; true was "done" and false was "leave it". */
+function decisionOf(result) {
+    if (result === true)
+        return { disposition: 'done' };
+    if (result === false)
+        return { disposition: 'retry' };
+    if (typeof result === 'string')
+        return { disposition: result };
+    return { disposition: 'refused', reason: result.reason };
+}
+exports.DEFAULT_HEARTBEAT_MS = 15_000;
+/**
+ * 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.
+ */
+exports.MIN_HEARTBEAT_MS = 2_000;
+exports.MAX_HEARTBEAT_MS = 300_000;
+/**
+ * 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.
+ */
+function heartbeatCadenceMs(configured, serverRefreshS) {
+    if (configured !== undefined)
+        return configured;
+    if (typeof serverRefreshS !== 'number' || !Number.isFinite(serverRefreshS)) {
+        return exports.DEFAULT_HEARTBEAT_MS;
+    }
+    const ms = Math.round(serverRefreshS * 1000);
+    if (ms <= 0)
+        return exports.DEFAULT_HEARTBEAT_MS;
+    return Math.min(exports.MAX_HEARTBEAT_MS, Math.max(exports.MIN_HEARTBEAT_MS, ms));
+}
+exports.DEFAULT_FLUSH_MS = 5_000;
+/** Fast enough that a tap on a phone feels immediate, slow enough to be free. */
+exports.DEFAULT_COMMAND_POLL_MS = 3_000;
+/**
+ * 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.
+ */
+exports.DEFAULT_GOAL_POLL_MS = 30_000;
+/**
+ * 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.
+ */
+exports.DEFAULT_STALE_POLL_MS = 60_000;
+/**
+ * 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.
+ */
+exports.DEFAULT_AUTONOMY_POLL_MS = 10_000;
+class Daemon {
+    deps;
+    uploader;
+    running = false;
+    online = false;
+    lastBeatAt = null;
+    missedBeats = 0;
+    delivered = 0;
+    /** Whether the server-kept-fewer-than-it-was-sent line has been said. */
+    unackedReported = false;
+    /** Commands already reported as left-queued, so a retry loop says so once. */
+    retried = new Set();
+    /**
+     * 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.
+     */
+    outageReported = false;
+    /**
+     * The refresh interval the server last asked for, in seconds; null until a
+     * heartbeat has succeeded. Read through `heartbeatCadenceMs`, never directly.
+     */
+    serverRefreshS = null;
+    /** Set when the server refuses the credential; retrying cannot fix that. */
+    revoked = false;
+    /** Whether the buffer overflow has been mentioned; see `enqueue`. */
+    overflowReported = false;
+    /** Whether the catching-up line has been said for the current backlog. */
+    replayReported = false;
+    /** Whether the ledger-unreadable line has been said for the current outage. */
+    replayFailureReported = false;
+    goalFailureReported = false;
+    constructor(deps) {
+        this.deps = deps;
+        const transport = {
+            post: (projectId, events) => deps.client.postEvents(projectId, events),
+        };
+        this.uploader = new uploader_1.EventUploader(deps.projectId, transport, undefined, deps.bufferLimit ?? uploader_1.DEFAULT_BUFFER_LIMIT);
+    }
+    /** Queue an event for the next flush. Called from the ledger append path. */
+    enqueue(event) {
+        this.uploader.enqueue(event);
+        // Said once, on the transition into overflow. This is the append path of a
+        // run that may last hours: a line per dropped event would be a second,
+        // louder way of running out of resources.
+        if (!this.overflowReported && this.uploader.dropped() > 0) {
+            this.overflowReported = true;
+            this.deps.log('daemon  : the upload buffer is full — the oldest events are being dropped.');
+            this.deps.log('          Your phone will show a gap; the ledger on this machine is complete.');
+        }
+    }
+    /**
+     * 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.
+     */
+    async replayOnce() {
+        if (this.revoked || !this.deps.replay)
+            return;
+        // Not while a previous batch is still unsent. The skip filter is driven by
+        // the *durable* head, and that cannot advance until a flush succeeds — so
+        // every event this pass found last time is still above it and would be
+        // handed over again, and again. Five minutes offline is sixty copies of the
+        // same backlog, and the buffer sheds its oldest to make room for them: it
+        // would throw away the beginning of the history it is restoring in order to
+        // store duplicates of the middle. On the healthy path the flush below
+        // empties the buffer every tick, so this costs nothing.
+        if (this.uploader.pending() > 0)
+            return;
+        try {
+            const r = await this.deps.replay({
+                enqueue: (e) => this.enqueue(e),
+                durableHead: (runId) => this.uploader.durableHead(runId),
+            });
+            if (r.replayed === 0) {
+                // A catch-up that finished. Re-arm the notice so the *next* backlog —
+                // the run that dies in an hour — announces itself too, instead of going
+                // out in silence because an earlier one used the line up.
+                this.replayReported = false;
+                return;
+            }
+            if (!this.replayReported) {
+                this.replayReported = true;
+                this.deps.log(`daemon  : sending ${r.replayed} event(s) a previous run never delivered.`);
+            }
+            if (r.damaged > 0) {
+                this.deps.log(`daemon  : ${r.damaged} ledger line(s) were too damaged to send.`);
+            }
+            // Said apart from damage: nothing is torn, and the answer is a newer
+            // looply rather than a repair.
+            if ((r.fromNewerBuild ?? 0) > 0) {
+                this.deps.log(`daemon  : ${r.fromNewerBuild} ledger line(s) were written by a newer build and cannot be sent from here.`);
+            }
+        }
+        catch (e) {
+            // Replay is a repair, not a duty: a ledger that cannot be read must not
+            // stop the daemon doing everything else it is for. But it must not stop
+            // replay either. A file that could not be read this second — a lock, an
+            // exhausted fd table, a scanner holding it open — is very often readable
+            // the next, and latching off on one transient error is the same permanent
+            // blindness this method was just fixed for, wearing a different hat.
+            // Said once per outage, like every other repeating condition here.
+            if (!this.replayFailureReported) {
+                this.replayFailureReported = true;
+                this.deps.log(`daemon  : could not replay the ledger — ${e.message}`);
+            }
+        }
+    }
+    /** Revocation is terminal: retrying a revoked token cannot ever succeed. */
+    markRevoked() {
+        if (this.revoked)
+            return;
+        this.revoked = true;
+        this.online = false;
+        this.deps.log("daemon  : this machine's access was revoked. The run continues locally,");
+        this.deps.log('          but nothing will reach your phone until you run `looply pair`.');
+    }
+    status() {
+        return {
+            online: this.online,
+            lastBeatAt: this.lastBeatAt,
+            missedBeats: this.missedBeats,
+            buffered: this.uploader.pending(),
+            delivered: this.delivered,
+            dropped: this.uploader.dropped(),
+            unacked: this.uploader.unacked(),
+        };
+    }
+    /**
+     * 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.
+     */
+    async beat() {
+        if (this.revoked)
+            return false;
+        try {
+            const reply = await this.deps.client.heartbeat(this.deps.machineId, this.deps.cliVersion);
+            // ⚠️ GUARDED, NOT DESTRUCTURED. Several test doubles predate the corrected
+            // type and answer `true` or `{ ok: true }`; a daemon that threw on an
+            // unexpected heartbeat reply would turn a cosmetic mismatch into an
+            // outage. An absent cadence simply leaves the previous one standing.
+            const refreshS = reply?.refreshS;
+            if (typeof refreshS === 'number' && Number.isFinite(refreshS)) {
+                this.serverRefreshS = refreshS;
+            }
+            if (this.outageReported)
+                this.deps.log('daemon  : back online');
+            this.online = true;
+            this.outageReported = false;
+            this.lastBeatAt = this.deps.now();
+            this.missedBeats = 0;
+            return true;
+        }
+        catch (e) {
+            if (e instanceof server_client_1.ServerError && e.isAuth) {
+                this.markRevoked();
+                return false;
+            }
+            this.missedBeats += 1;
+            if (!this.outageReported) {
+                this.deps.log('daemon  : lost the server — buffering locally, will catch up');
+                this.outageReported = true;
+            }
+            this.online = false;
+            return false;
+        }
+    }
+    /**
+     * 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.
+     */
+    async runAutonomyTick() {
+        if (this.revoked)
+            return;
+        try {
+            await this.deps.autonomyTick?.();
+        }
+        catch (e) {
+            this.deps.log(`autonomy: could not take a turn (${e.message})`);
+        }
+    }
+    /** See {@link DaemonDeps.coordinatorTick}. Caught like every other job. */
+    async runCoordinatorTick() {
+        if (this.revoked)
+            return;
+        try {
+            await this.deps.coordinatorTick?.();
+        }
+        catch (e) {
+            this.deps.log(`coord   : could not take a turn (${e.message})`);
+        }
+    }
+    async sweepStaleRun() {
+        if (this.revoked)
+            return;
+        try {
+            await this.deps.recoverStaleRun?.();
+        }
+        catch (e) {
+            this.deps.log(`recover: could not check for a dead run (${e.message})`);
+        }
+    }
+    /**
+     * 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.
+     */
+    async pullGoals() {
+        const store = this.deps.goals;
+        if (this.revoked || !store)
+            return null;
+        let goals;
+        try {
+            const r = await this.deps.client.projectGoals(this.deps.projectId);
+            // A 200 is not an answer. `ServerClient.request` returns the raw text when
+            // a body is not JSON and returns any parsed JSON unchecked, so a captive
+            // portal, a proxy interstitial or a CDN error page all arrive here as a
+            // successful response — and `r.goals ?? []` would turn every one of them
+            // into a wholesale erase of the mirror. That is the precise moment the
+            // file exists for. `pollCommands` uses the same `?? []` idiom safely
+            // because an empty command list is inert; here the value REPLACES durable
+            // state, so the envelope has to be checked before it is allowed to.
+            const body = r;
+            if (typeof body !== 'object' || body === null || !Array.isArray(body.goals)) {
+                this.reportGoalFailure('the server answered with something that is not a goal list');
+                return null;
+            }
+            goals = body.goals;
+        }
+        catch (e) {
+            if (e instanceof server_client_1.ServerError && e.isAuth) {
+                this.markRevoked();
+                return null;
+            }
+            // Offline is already reported by the heartbeat. Everything else is NOT:
+            // the heartbeat is a different endpoint with a different authorization
+            // path, so a project deleted out from under this daemon, or a 500 on this
+            // route alone, would otherwise retry every thirty seconds in total silence
+            // for the machine's whole life. Said once, like `beat` and `replayOnce`.
+            if (!(e instanceof server_client_1.ServerError && e.isOffline)) {
+                this.reportGoalFailure(e.message);
+            }
+            return null;
+        }
+        try {
+            await store.replace(goals);
+        }
+        catch (e) {
+            // A mirror that cannot be written is a degraded cache, never a stopped
+            // daemon: the goals are safe on the server either way.
+            this.deps.log(`goals   : could not write the mirror (${e.message})`);
+            return null;
+        }
+        this.goalFailureReported = false;
+        return goals.length;
+    }
+    /** Report a goal-refresh failure once per outage, not once per tick. */
+    reportGoalFailure(message) {
+        if (this.goalFailureReported)
+            return;
+        this.goalFailureReported = true;
+        this.deps.log(`goals   : could not refresh the mirror — ${message}`);
+    }
+    /**
+     * 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.
+     */
+    async pollCommands() {
+        if (this.revoked || !this.deps.onCommand)
+            return 0;
+        let commands;
+        try {
+            const r = await this.deps.client.popCommands(this.deps.machineId);
+            commands = r.commands ?? [];
+        }
+        catch (e) {
+            if (e instanceof server_client_1.ServerError && e.isAuth) {
+                this.markRevoked();
+                return 0;
+            }
+            // Offline is already reported by the heartbeat; saying it twice per tick
+            // would bury everything else in the log.
+            return 0;
+        }
+        let done = 0;
+        for (const command of commands) {
+            let decided = { disposition: 'retry' };
+            try {
+                decided = decisionOf(await this.deps.onCommand(command));
+            }
+            catch (e) {
+                // Left as `retry`, and deliberately WITHOUT the thrown message as a
+                // reason: a handler that threw did not decide anything, and turning an
+                // exception into a client-visible terminal refusal is how a transient
+                // fault becomes a permanent-looking answer.
+                this.deps.log(`daemon  : ${command.kind} failed — ${e.message}`);
+            }
+            const { disposition } = decided;
+            if (disposition === 'retry') {
+                // Left unacked on purpose so the next poll offers it again. Said once
+                // per command rather than per poll: a command that cannot be carried
+                // out is now genuinely retried every three seconds, and logging each
+                // attempt would turn one stuck instruction into a wall of text.
+                if (!this.retried.has(command.id)) {
+                    this.retried.add(command.id);
+                    this.deps.log(`daemon  : ${command.kind} could not be carried out — leaving it queued`);
+                }
+                continue;
+            }
+            try {
+                // The reason travels with the ack, or not at all — and a `done` cannot
+                // carry one, because `decided.reason` is only ever set on a refusal.
+                // Passed as a third argument only when there IS one, so an ack with
+                // nothing to explain is the same call it has always been rather than
+                // one trailing an explicit `undefined`.
+                await (decided.reason === undefined
+                    ? this.deps.client.ackCommand(command.id, disposition)
+                    : this.deps.client.ackCommand(command.id, disposition, decided.reason));
+                if (disposition === 'done')
+                    done += 1;
+            }
+            catch {
+                // Carried out but unacked: it will be handed over again. Handlers are
+                // expected to be idempotent for exactly this reason.
+                this.deps.log(`daemon  : ${command.kind} done but not acknowledged — it may repeat`);
+            }
+        }
+        return done;
+    }
+    /** Ship whatever is buffered. Retained on failure; never dropped. */
+    async flush() {
+        if (this.revoked)
+            return;
+        const r = await this.uploader.flush();
+        this.delivered += r.delivered;
+        // Written after the ack, never before: a cursor ahead of what the server
+        // holds is the one failure mode worse than no cursor, because replay then
+        // skips events nothing will ever send again. `durableCursors` is a gapless
+        // prefix, not the server's max-seq — see the field it comes from.
+        await this.deps.cursors?.advance(this.uploader.durableCursors()).catch(() => undefined);
+        if (r.error && this.online) {
+            this.deps.log(`daemon  : upload failed (${r.error}) — ${r.buffered} events kept for the next try`);
+        }
+        // Said once, like the overflow above. A server that accepts a batch and
+        // stores none of it answers 200, so without this the only symptom is a
+        // phone that never moves — which reads as "looply is broken" rather than
+        // "these two are disagreeing about what this project is called".
+        if (!this.unackedReported && r.unacked) {
+            this.unackedReported = true;
+            this.deps.log(`daemon  : the server kept fewer events than it was sent (${r.unacked} unaccounted).`);
+            this.deps.log('          Your phone will show a gap; the ledger on this machine is complete.');
+        }
+    }
+    /**
+     * 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.
+     */
+    async run() {
+        let heartbeatMs = heartbeatCadenceMs(this.deps.heartbeatMs, this.serverRefreshS);
+        const flushMs = this.deps.flushMs ?? exports.DEFAULT_FLUSH_MS;
+        const commandMs = this.deps.commandPollMs ?? exports.DEFAULT_COMMAND_POLL_MS;
+        const goalMs = this.deps.goalPollMs ?? exports.DEFAULT_GOAL_POLL_MS;
+        const staleMs = this.deps.stalePollMs ?? exports.DEFAULT_STALE_POLL_MS;
+        const autonomyMs = this.deps.autonomyPollMs ?? exports.DEFAULT_AUTONOMY_POLL_MS;
+        // Every cadence is in the min. Left out, a cadence smaller than the others
+        // would silently never be honoured — the loop would sleep past it every
+        // time and the dep would be a lie.
+        let tick = Math.min(heartbeatMs, flushMs, commandMs, goalMs, staleMs, autonomyMs);
+        this.running = true;
+        let lastHeartbeat = 0;
+        let lastFlush = 0;
+        let lastCommand = 0;
+        let lastGoals = 0;
+        let lastStale = 0;
+        let lastAutonomy = 0;
+        let lastCoordinator = 0;
+        // What a previous process already got through, so replay does not re-send
+        // a night's ledger every time the daemon starts.
+        const known = this.deps.cursors?.all();
+        if (known)
+            this.uploader.prime(known);
+        while (this.running && !this.deps.stopRequested?.()) {
+            const now = this.deps.now();
+            if (now - lastHeartbeat >= heartbeatMs) {
+                lastHeartbeat = now;
+                await this.beat();
+                // 🔴 `tick` IS RECOMPUTED WITH IT, AND LEAVING THAT OUT WOULD BE THE
+                // EXACT BUG THE COMMENT ABOVE WARNS OF. `tick` is the minimum of every
+                // cadence; a heartbeat that became FASTER than the old minimum would be
+                // slept straight past, every time, and the new cadence would be a lie.
+                const proposed = heartbeatCadenceMs(this.deps.heartbeatMs, this.serverRefreshS);
+                if (proposed !== heartbeatMs) {
+                    this.deps.log(`daemon  : heartbeat cadence now ${Math.round(proposed / 1000)}s (server)`);
+                    heartbeatMs = proposed;
+                    tick = Math.min(heartbeatMs, flushMs, commandMs, goalMs, staleMs, autonomyMs);
+                }
+            }
+            if (now - lastCommand >= commandMs) {
+                lastCommand = now;
+                await this.pollCommands();
+            }
+            if (this.deps.goals && now - lastGoals >= goalMs) {
+                lastGoals = now;
+                await this.pullGoals();
+            }
+            if (this.deps.recoverStaleRun && now - lastStale >= staleMs) {
+                lastStale = now;
+                await this.sweepStaleRun();
+            }
+            // AFTER the stale sweep, on purpose. A run killed outright never writes
+            // its own ending; recovery writes it on the run's behalf. Ticking first
+            // would ask "has this run ended?" of a ledger that has not been repaired
+            // yet, and the honest answer then is "no" — so the controller would wait
+            // a whole cadence for a fact that was already available.
+            if (this.deps.autonomyTick && now - lastAutonomy >= autonomyMs) {
+                lastAutonomy = now;
+                await this.runAutonomyTick();
+            }
+            /**
+             * ⚠️ AFTER THE AUTONOMY TICK, ON THE SAME CADENCE, AND FOR THE SAME
+             * REASON THE AUTONOMY TICK SITS AFTER THE STALE SWEEP: a scheduler asked
+             * "what is running?" of a ledger that has not been repaired yet gets a
+             * stale answer, and the honest one was already available.
+             */
+            if (this.deps.coordinatorTick && now - lastCoordinator >= autonomyMs) {
+                lastCoordinator = now;
+                await this.runCoordinatorTick();
+            }
+            if (now - lastFlush >= flushMs) {
+                lastFlush = now;
+                // Before the flush, so anything a dead process left behind goes out in
+                // the same pass as whatever is live. Bounded per pass: a machine that
+                // was offline all night has a very long ledger, and pouring it in at
+                // once would overflow the buffer and shed the beginning of the very
+                // history being restored. The next tick continues where this stopped.
+                await this.replayOnce();
+                await this.flush();
+            }
+            if (this.revoked)
+                break;
+            await this.deps.sleep(tick);
+        }
+        // One last flush on the way out: a graceful stop should not strand the
+        // events from the round that just finished.
+        await this.flush();
+        this.running = false;
+        return this.status();
+    }
+    stop() {
+        this.running = false;
+    }
+}
+exports.Daemon = Daemon;
+//# sourceMappingURL=daemon.js.map

package/dist/daemon.js.map

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