@cello-protocol/daemon 0.0.227 → 0.0.229

package/dist/line-lcs.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The line LCS, shared by the write path (DOD-DOC-WRITE-1) and the diff surfaces
+ * (DOD-DOC-NOTIFY-1).
+ *
+ * One implementation, deliberately. These two need to agree about what changed — the write path
+ * publishes hunks and the diff surfaces describe them to an operator — and two hand-rolled diffs
+ * that must agree are two things to keep in step, which is how they stop agreeing.
+ *
+ * ── WHY A REAL LCS AND NOT A PREFIX/SUFFIX TRIM ───────────────────────────────────────────────
+ *
+ * Measured twice, in two units, with the same result. A prefix/suffix trim is correct only when
+ * exactly one contiguous region changed; the moment a line is INSERTED or DELETED, everything after
+ * it shifts and a naive positional walk reports the whole remainder as rewritten:
+ *
+ *     inserting one line at the top of a 3-line file  ->  +4 -3, one range covering the file
+ *
+ * In the write path (WRITE-1) that published text the file did not contain — four of six ordinary
+ * markdown edits. In the diff surfaces (NOTIFY-1) it made the overlap flag permanently true, which
+ * is worse than useless: the flag exists so an agent can tell whether the peer touched what it
+ * touched, and one that always says yes trains the agent to ignore it.
+ *
+ * A real LCS is also what emits SEPARATE runs for separated edits. One span from the first change
+ * to the last would delete and re-insert everything between them as new operations, resurrecting
+ * text a peer concurrently deleted — and under publish-on-intent, multi-edit publishes are the
+ * modal case.
+ */
+/** Above this many lines the table is not worth building — the caller falls back and says so. */
+export declare const LCS_LINE_LIMIT = 4000;
+/**
+ * A contiguous run of changed lines, as HALF-OPEN index ranges into each side.
+ *
+ * `aStart === aEnd` is a pure insertion; `bStart === bEnd` is a pure deletion. Half-open because
+ * the empty range then has an unambiguous spelling, which a closed range does not.
+ */
+export interface LineRun {
+    aStart: number;
+    aEnd: number;
+    bStart: number;
+    bEnd: number;
+}
+/** Lines carrying their own trailing newline; the last line carries none. */
+export declare function toChunks(text: string): string[];
+/**
+ * The runs of changed lines between two chunk arrays.
+ *
+ * Returns `null` when either side exceeds `LCS_LINE_LIMIT` — the quadratic table on a document
+ * that large is the wrong kind of thorough, and a caller that silently degraded instead of being
+ * told would report a whole-file rewrite as if it were a measurement.
+ */
+export declare function lineRuns(a: readonly string[], b: readonly string[]): LineRun[] | null;
+//# sourceMappingURL=line-lcs.d.ts.map

package/dist/line-lcs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-lcs.d.ts","sourceRoot":"","sources":["../src/line-lcs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,iGAAiG;AACjG,eAAO,MAAM,cAAc,OAAO,CAAC;AAEnC;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,6EAA6E;AAC7E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAG/C;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,EAAE,GAAG,IAAI,CA8BrF"}

package/dist/line-lcs.js

@@ -0,0 +1,71 @@
+/**
+ * The line LCS, shared by the write path (DOD-DOC-WRITE-1) and the diff surfaces
+ * (DOD-DOC-NOTIFY-1).
+ *
+ * One implementation, deliberately. These two need to agree about what changed — the write path
+ * publishes hunks and the diff surfaces describe them to an operator — and two hand-rolled diffs
+ * that must agree are two things to keep in step, which is how they stop agreeing.
+ *
+ * ── WHY A REAL LCS AND NOT A PREFIX/SUFFIX TRIM ───────────────────────────────────────────────
+ *
+ * Measured twice, in two units, with the same result. A prefix/suffix trim is correct only when
+ * exactly one contiguous region changed; the moment a line is INSERTED or DELETED, everything after
+ * it shifts and a naive positional walk reports the whole remainder as rewritten:
+ *
+ *     inserting one line at the top of a 3-line file  ->  +4 -3, one range covering the file
+ *
+ * In the write path (WRITE-1) that published text the file did not contain — four of six ordinary
+ * markdown edits. In the diff surfaces (NOTIFY-1) it made the overlap flag permanently true, which
+ * is worse than useless: the flag exists so an agent can tell whether the peer touched what it
+ * touched, and one that always says yes trains the agent to ignore it.
+ *
+ * A real LCS is also what emits SEPARATE runs for separated edits. One span from the first change
+ * to the last would delete and re-insert everything between them as new operations, resurrecting
+ * text a peer concurrently deleted — and under publish-on-intent, multi-edit publishes are the
+ * modal case.
+ */
+/** Above this many lines the table is not worth building — the caller falls back and says so. */
+export const LCS_LINE_LIMIT = 4000;
+/** Lines carrying their own trailing newline; the last line carries none. */
+export function toChunks(text) {
+    const lines = text.split("\n");
+    return lines.map((line, index) => (index < lines.length - 1 ? `${line}\n` : line));
+}
+/**
+ * The runs of changed lines between two chunk arrays.
+ *
+ * Returns `null` when either side exceeds `LCS_LINE_LIMIT` — the quadratic table on a document
+ * that large is the wrong kind of thorough, and a caller that silently degraded instead of being
+ * told would report a whole-file rewrite as if it were a measurement.
+ */
+export function lineRuns(a, b) {
+    if (a.length > LCS_LINE_LIMIT || b.length > LCS_LINE_LIMIT)
+        return null;
+    const lcs = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+    for (let i = a.length - 1; i >= 0; i--) {
+        for (let j = b.length - 1; j >= 0; j--) {
+            lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    const runs = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length || j < b.length) {
+        if (i < a.length && j < b.length && a[i] === b[j]) {
+            i++;
+            j++;
+            continue;
+        }
+        const aStart = i;
+        const bStart = j;
+        while ((i < a.length || j < b.length) && !(i < a.length && j < b.length && a[i] === b[j])) {
+            if (j < b.length && (i === a.length || lcs[i][j + 1] >= lcs[i + 1][j]))
+                j++;
+            else
+                i++;
+        }
+        runs.push({ aStart, aEnd: i, bStart, bEnd: j });
+    }
+    return runs;
+}
+//# sourceMappingURL=line-lcs.js.map

package/dist/line-lcs.js.map

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

package/dist/lock-file.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Lock file management for the CELLO daemon.
+ *
+ * Pseudocode:
+ * 1. acquireLock(path, content):
+ *    - Write JSON content to path.tmp atomically
+ *    - Rename path.tmp → path (atomic on POSIX)
+ *    - Return true on success
+ *
+ * 2. readLock(path):
+ *    - Read file, parse JSON
+ *    - Validate shape: {pid: number, socketPath: string, version: string}
+ *    - Return parsed content or null if missing/invalid
+ *
+ * 3. isProcessAlive(pid):
+ *    - process.kill(pid, 0) — signal 0 checks existence without killing
+ *    - Return true if no error thrown
+ *
+ * 4. removeLock(path):
+ *    - Unlink the file, ignoring ENOENT
+ */
+import type { LockFileContent, Logger } from "./types.js";
+export declare function readLock(lockPath: string): Promise<LockFileContent | null>;
+export declare function acquireLock(lockPath: string, content: LockFileContent): Promise<void>;
+export declare function removeLock(lockPath: string, logger: Logger): Promise<void>;
+/**
+ * DOD-DAEMON-CLEANUP-1 (AC1) — remove the lock ONLY if it is still ours.
+ *
+ * An exiting daemon must not disarm a daemon it does not own. By the time we shut down, a DIFFERENT
+ * daemon may have written this lock; deleting it would leave that healthy daemon unreachable
+ * (`cello logout` reports "No daemon running") and the next `cello login` would spawn a third beside
+ * it. That is the cascade — the obvious recovery action, killing the orphan, propagates the bug.
+ *
+ * `removeLock` (unconditional) is still correct for the CLI's stale-lock cleanup, where the lock
+ * belongs to a process that is provably gone. It is NOT correct on the way out of a live daemon.
+ */
+export declare function removeLockIfOwned(lockPath: string, ownPid: number, logger: Logger): Promise<void>;
+export declare function isProcessAlive(pid: number): boolean;
+//# sourceMappingURL=lock-file.d.ts.map

package/dist/lock-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-file.d.ts","sourceRoot":"","sources":["../src/lock-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAG1D,wBAAsB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAwBhF;AAED,wBAAsB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAU3F;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAWhF;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAwBf;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOnD"}

package/dist/lock-file.js

@@ -0,0 +1,120 @@
+/**
+ * Lock file management for the CELLO daemon.
+ *
+ * Pseudocode:
+ * 1. acquireLock(path, content):
+ *    - Write JSON content to path.tmp atomically
+ *    - Rename path.tmp → path (atomic on POSIX)
+ *    - Return true on success
+ *
+ * 2. readLock(path):
+ *    - Read file, parse JSON
+ *    - Validate shape: {pid: number, socketPath: string, version: string}
+ *    - Return parsed content or null if missing/invalid
+ *
+ * 3. isProcessAlive(pid):
+ *    - process.kill(pid, 0) — signal 0 checks existence without killing
+ *    - Return true if no error thrown
+ *
+ * 4. removeLock(path):
+ *    - Unlink the file, ignoring ENOENT
+ */
+import { readFile, writeFile, rename, stat, unlink } from "node:fs/promises";
+import { extractErrorMessage } from "./error-message.js";
+export async function readLock(lockPath) {
+    let raw;
+    try {
+        raw = await readFile(lockPath, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return null;
+        }
+        throw err;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.pid !== "number" ||
+            typeof parsed.socketPath !== "string" ||
+            typeof parsed.version !== "string") {
+            return null;
+        }
+        return { pid: parsed.pid, socketPath: parsed.socketPath, version: parsed.version };
+    }
+    catch {
+        return null;
+    }
+}
+export async function acquireLock(lockPath, content) {
+    const tmpPath = lockPath + ".tmp";
+    const json = JSON.stringify(content, null, 2) + "\n";
+    await writeFile(tmpPath, json, { mode: 0o600 });
+    try {
+        await rename(tmpPath, lockPath);
+    }
+    catch (err) {
+        try {
+            await unlink(tmpPath);
+        }
+        catch { /* best-effort cleanup */ }
+        throw err;
+    }
+}
+export async function removeLock(lockPath, logger) {
+    try {
+        await unlink(lockPath);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            logger.warn("daemon.lock.remove.failed", {
+                lockPath,
+                error: extractErrorMessage(err),
+            });
+        }
+    }
+}
+/**
+ * DOD-DAEMON-CLEANUP-1 (AC1) — remove the lock ONLY if it is still ours.
+ *
+ * An exiting daemon must not disarm a daemon it does not own. By the time we shut down, a DIFFERENT
+ * daemon may have written this lock; deleting it would leave that healthy daemon unreachable
+ * (`cello logout` reports "No daemon running") and the next `cello login` would spawn a third beside
+ * it. That is the cascade — the obvious recovery action, killing the orphan, propagates the bug.
+ *
+ * `removeLock` (unconditional) is still correct for the CLI's stale-lock cleanup, where the lock
+ * belongs to a process that is provably gone. It is NOT correct on the way out of a live daemon.
+ */
+export async function removeLockIfOwned(lockPath, ownPid, logger) {
+    const lock = await readLock(lockPath);
+    if (lock === null) {
+        // readLock returns null for BOTH "absent" and "unparseable" — so this is the one place that
+        // cannot tell "nothing to do" from "something is wrong". Distinguish them: a lock file that
+        // exists but cannot be read (truncated by a full disk, a partial write) is left alone, because we
+        // cannot prove it is ours — but it is said out loud rather than passed over in silence.
+        try {
+            await stat(lockPath);
+            logger.warn("daemon.lock.unreadable", { ownPid, lockPath });
+        }
+        catch {
+            // Genuinely absent. Nothing to remove, nothing to report.
+        }
+        return;
+    }
+    if (lock.pid !== ownPid) {
+        // SI: a daemon that declines to remove a lock says so. Silence here is what made the live
+        // incident so hard to see.
+        logger.info("daemon.lock.not_ours", { ownPid, lockPid: lock.pid, lockPath });
+        return;
+    }
+    await removeLock(lockPath, logger);
+}
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=lock-file.js.map

package/dist/lock-file.js.map

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

package/dist/log-collapse.d.ts

@@ -0,0 +1,66 @@
+import type { Logger } from "./types.js";
+/**
+ * DOD-M15-LOGBOUND-1 part A — write a repeating log line ONCE, then count it.
+ *
+ * The file that produced this order was 180 MB and 469,065 lines. 168 MB of it — 95% — was a
+ * single `session.key.announce.failed` line repeated 413,590 times, byte-identical apart from its
+ * timestamp, from a retry that never gave up.
+ *
+ * **The disk was the smaller half.** That loop hid behind its own output for eleven hours. A file
+ * that is 95% one sentence is not a diagnostic surface; it is a haystack the daemon builds around
+ * its own needle, faster than anyone can read it.
+ *
+ * **This is the rule `045-REFUSALSTORM` applies to the operator's inbox, one layer down.** Same
+ * idea in two places, not two mechanisms.
+ *
+ * ⚠️ **This makes a storm cheap. It does not make a storm correct.** The loops themselves are
+ * fixed by `045-REFUSALSTORM` and `DOD-M15-KEYANNOUNCE-LOOP-1`; this unit must not be cited as
+ * covering either.
+ *
+ * ## The gate is a RATE, not a count — and the first build got this wrong
+ *
+ * The obvious design suppresses everything after the first occurrence and re-reports at the 10th,
+ * 100th, 1,000th. It was built that way, and review found two defects in it that matter more than
+ * the bytes it saved:
+ *
+ * 1. **A bounded retry that failed three times printed one line.** Three is not a power of ten, so
+ *    attempts two and three were dropped and nothing anywhere ever said they happened. An operator
+ *    whose standing receiver cannot bind then reads one `session.node.create.failed` followed by
+ *    `session.standing_receiver.dead`, and cannot tell a retry that ran from a retry that never
+ *    fired — which is the first thing they would go and check.
+ * 2. **A chronic failure went permanently silent.** A run never expired, so something failing once
+ *    an hour reached its 10th occurrence on day one and was next written on day four. The daemon
+ *    stopped reporting an ongoing failure precisely because it had been failing for a long time.
+ *
+ * So nothing is suppressed until a key is genuinely FLOODING: more than {@link STORM_BURST}
+ * occurrences inside {@link STORM_WINDOW_MS}. Below that rate every line is written exactly as it
+ * was before this unit existed. The measured storm ran at 4–17 lines/second and trips the gate on
+ * its 21st line; an ordinary two-to-nine repeat never trips it at all, and neither does a slow
+ * chronic failure — which is how both defects above stay fixed rather than traded against each
+ * other.
+ */
+/** Occurrences of one key inside one window that mean "this is a flood, not a repeat". */
+export declare const STORM_BURST = 20;
+/** The window the burst is measured over. Also the idle period that ENDS a storm. */
+export declare const STORM_WINDOW_MS = 10000;
+/**
+ * Bound on the table. Without one, the thing that removes an unbounded log would itself be an
+ * unbounded map — the same defect one layer further in.
+ *
+ * Eviction is least-recently-USED, and that is load-bearing rather than tidy. Plenty of events
+ * carry a value unique to the occurrence — a fresh root hash, a content hash, a peer id — so in
+ * ordinary operation the table is mostly keys that will never be seen again. Under
+ * insertion-order eviction the one key the table exists to hold, the one being hit thousands of
+ * times a second, is evicted on the same schedule as keys that are read once; the count resets and
+ * the single number that made the storm diagnosable is destroyed. Under LRU a never-repeating key
+ * is always the oldest and is always the first to go.
+ */
+export declare const LOG_COLLAPSE_MAX_KEYS = 2048;
+/**
+ * Wrap a logger so a FLOODING line is written once and then counted.
+ *
+ * Wrapping the composition root covers every call site at once, which is what makes this a
+ * property of the daemon's logging rather than a discipline each call site has to remember.
+ */
+export declare function createCollapsingLogger(sink: Logger, now?: () => number): Logger;
+//# sourceMappingURL=log-collapse.d.ts.map

package/dist/log-collapse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-collapse.d.ts","sourceRoot":"","sources":["../src/log-collapse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,0FAA0F;AAC1F,eAAO,MAAM,WAAW,KAAK,CAAC;AAE9B,qFAAqF;AACrF,eAAO,MAAM,eAAe,QAAS,CAAC;AAEtC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAC;AA0E1C;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,MAAiB,GAAG,MAAM,CAyIzF"}

package/dist/log-collapse.js

@@ -0,0 +1,244 @@
+/**
+ * DOD-M15-LOGBOUND-1 part A — write a repeating log line ONCE, then count it.
+ *
+ * The file that produced this order was 180 MB and 469,065 lines. 168 MB of it — 95% — was a
+ * single `session.key.announce.failed` line repeated 413,590 times, byte-identical apart from its
+ * timestamp, from a retry that never gave up.
+ *
+ * **The disk was the smaller half.** That loop hid behind its own output for eleven hours. A file
+ * that is 95% one sentence is not a diagnostic surface; it is a haystack the daemon builds around
+ * its own needle, faster than anyone can read it.
+ *
+ * **This is the rule `045-REFUSALSTORM` applies to the operator's inbox, one layer down.** Same
+ * idea in two places, not two mechanisms.
+ *
+ * ⚠️ **This makes a storm cheap. It does not make a storm correct.** The loops themselves are
+ * fixed by `045-REFUSALSTORM` and `DOD-M15-KEYANNOUNCE-LOOP-1`; this unit must not be cited as
+ * covering either.
+ *
+ * ## The gate is a RATE, not a count — and the first build got this wrong
+ *
+ * The obvious design suppresses everything after the first occurrence and re-reports at the 10th,
+ * 100th, 1,000th. It was built that way, and review found two defects in it that matter more than
+ * the bytes it saved:
+ *
+ * 1. **A bounded retry that failed three times printed one line.** Three is not a power of ten, so
+ *    attempts two and three were dropped and nothing anywhere ever said they happened. An operator
+ *    whose standing receiver cannot bind then reads one `session.node.create.failed` followed by
+ *    `session.standing_receiver.dead`, and cannot tell a retry that ran from a retry that never
+ *    fired — which is the first thing they would go and check.
+ * 2. **A chronic failure went permanently silent.** A run never expired, so something failing once
+ *    an hour reached its 10th occurrence on day one and was next written on day four. The daemon
+ *    stopped reporting an ongoing failure precisely because it had been failing for a long time.
+ *
+ * So nothing is suppressed until a key is genuinely FLOODING: more than {@link STORM_BURST}
+ * occurrences inside {@link STORM_WINDOW_MS}. Below that rate every line is written exactly as it
+ * was before this unit existed. The measured storm ran at 4–17 lines/second and trips the gate on
+ * its 21st line; an ordinary two-to-nine repeat never trips it at all, and neither does a slow
+ * chronic failure — which is how both defects above stay fixed rather than traded against each
+ * other.
+ */
+/** Occurrences of one key inside one window that mean "this is a flood, not a repeat". */
+export const STORM_BURST = 20;
+/** The window the burst is measured over. Also the idle period that ENDS a storm. */
+export const STORM_WINDOW_MS = 10_000;
+/**
+ * Bound on the table. Without one, the thing that removes an unbounded log would itself be an
+ * unbounded map — the same defect one layer further in.
+ *
+ * Eviction is least-recently-USED, and that is load-bearing rather than tidy. Plenty of events
+ * carry a value unique to the occurrence — a fresh root hash, a content hash, a peer id — so in
+ * ordinary operation the table is mostly keys that will never be seen again. Under
+ * insertion-order eviction the one key the table exists to hold, the one being hit thousands of
+ * times a second, is evicted on the same schedule as keys that are read once; the count resets and
+ * the single number that made the storm diagnosable is destroyed. Under LRU a never-repeating key
+ * is always the oldest and is always the first to go.
+ */
+export const LOG_COLLAPSE_MAX_KEYS = 2048;
+/** Separator for key parts. A control character cannot appear in an event name or a field value. */
+const SEP = String.fromCharCode(31);
+/**
+ * The collapse key.
+ *
+ * ⚠️ **IT MUST NOT BE LOOSER THAN event + session + reason**, and it is exactly that. Keying on the
+ * event name alone would merge a hundred sessions failing once each into one line reading "x100" —
+ * strictly worse than the noise this removes, because a fan-out is the shape you most need to see
+ * and it would be reported as a repeat. The level is in the key too: the same event at `warn` and
+ * at `error` is two facts.
+ *
+ * **And it is deliberately NOT the whole payload**, which is the second thing the first build got
+ * wrong. Keying on every field looked tighter and therefore safer, and it is neither:
+ *
+ * - `session.key.announce.failed` — the very event this unit was written for — carries an `attempt`
+ *   counter. Every attempt is a different payload, so a full-payload key collapses NOTHING on the
+ *   one path that produced 168 MB. The historical storm only collapsed because the pre-fix bug
+ *   pinned `attempt` at 1; the fix that made the retry chain correct is what would have defeated it.
+ * - A loop minting a fresh key per iteration also churns the whole table at the rate it runs,
+ *   evicting every other run in it.
+ *
+ * The cost of the looser key is paid elsewhere rather than ignored: because suppression is gated on
+ * a RATE, a payload field that changes between occurrences is written in full at any ordinary rate,
+ * and is only folded once the key is genuinely flooding — at which point a count and a rate are
+ * more use than ten thousand individual values. Milestones republish the most recent payload, so
+ * the newest values stay on the record.
+ *
+ * Returns `null` when the key cannot be built from what the call site passed. **Such a line does
+ * not collapse at all** — losing the saving is correct where losing the distinction is not.
+ */
+function collapseKey(level, event, ctx) {
+    const sessionId = ctx["sessionId"];
+    const reason = ctx["reason"];
+    if (typeof sessionId !== "string" && typeof reason !== "string")
+        return null;
+    return [level, event, String(sessionId ?? ""), String(reason ?? "")].join(SEP);
+}
+/** First occurrence, then the 10th, 100th, 1,000th — a power of ten. */
+function isMilestone(count) {
+    if (count === 1)
+        return true;
+    let n = count;
+    while (n % 10 === 0)
+        n /= 10;
+    return n === 1;
+}
+/**
+ * Wrap a logger so a FLOODING line is written once and then counted.
+ *
+ * Wrapping the composition root covers every call site at once, which is what makes this a
+ * property of the daemon's logging rather than a discipline each call site has to remember.
+ */
+export function createCollapsingLogger(sink, now = Date.now) {
+    const runs = new Map();
+    /**
+     * Report a fold that has ended: how many lines it swallowed, and over how long.
+     *
+     * ⚠️ **THE WINDOW IS MEASURED TO THE LAST OCCURRENCE, NOT TO NOW**, and getting that wrong made
+     * this line state the opposite of what happened. A flood of 479 lines over 25 seconds — 19 a
+     * second — was reported as `repeatWindowMs: 21623950`, six hours, because the idle gap that
+     * proved the flood was over had already been folded into the elapsed time. An operator dividing
+     * those two numbers reads 1.3 an hour: a trickle, when it was the storm.
+     */
+    function closeRun(run) {
+        sink[run.level](run.event, {
+            ...run.lastCtx,
+            repeatedCount: run.suppressedCount,
+            repeatWindowMs: Math.max(0, run.lastAtMs - run.suppressStartMs),
+            repeatEnded: true,
+        });
+        run.suppressing = false;
+        run.suppressedCount = 0;
+    }
+    /**
+     * One amortised look at the oldest run per line written.
+     *
+     * Without it a fold that simply STOPS is never reported: the closing line is emitted by the
+     * key's own next occurrence, and a storm whose cause is fixed — or whose daemon is shut down —
+     * has no next occurrence. The measured 413,590-line storm would have ended on
+     * `repeatedCount: 100000`, understating itself fourfold, with nothing saying it had finished.
+     */
+    function sweepOldest(at, currentKey) {
+        const oldest = runs.entries().next();
+        if (oldest.done)
+            return;
+        const [key, run] = oldest.value;
+        if (key === currentKey)
+            return;
+        if (at - run.lastAtMs < STORM_WINDOW_MS)
+            return;
+        if (run.suppressing)
+            closeRun(run);
+        runs.delete(key);
+    }
+    function emit(level, event, ctx) {
+        const key = collapseKey(level, event, ctx);
+        if (key === null) {
+            sink[level](event, ctx);
+            return;
+        }
+        const at = now();
+        sweepOldest(at, key);
+        const existing = runs.get(key);
+        if (existing === undefined) {
+            if (runs.size >= LOG_COLLAPSE_MAX_KEYS) {
+                const oldest = runs.entries().next();
+                if (!oldest.done) {
+                    // Evicting a run mid-fold would take its total with it and restart the next occurrence
+                    // from one. Over-reporting is the safe direction; losing the count is not.
+                    if (oldest.value[1].suppressing)
+                        closeRun(oldest.value[1]);
+                    runs.delete(oldest.value[0]);
+                }
+            }
+            runs.set(key, {
+                level, event, windowStartMs: at, lastAtMs: at, windowCount: 1,
+                suppressing: false, suppressStartMs: 0, suppressedCount: 0, lastCtx: ctx,
+            });
+            sink[level](event, ctx);
+            return;
+        }
+        // Least-recently-USED: re-inserting moves this key to the young end of the eviction order.
+        runs.delete(key);
+        runs.set(key, existing);
+        /**
+         * A gap longer than a window means the flood has stopped — measured from the PREVIOUS
+         * occurrence, never from the window's own tally. Reading the tally was the first version of
+         * this and it could never end a storm: during one, the count carried over from the last
+         * window is high by definition, so the "has it died down" test was never true.
+         */
+        const idle = at - existing.lastAtMs >= STORM_WINDOW_MS;
+        if (idle) {
+            if (existing.suppressing)
+                closeRun(existing);
+            existing.windowStartMs = at;
+            existing.windowCount = 0;
+        }
+        else if (at - existing.windowStartMs >= STORM_WINDOW_MS) {
+            /**
+             * ⚠️ A FULL WINDOW PASSED WITH TRAFFIC — so re-test the RATE, do not just roll the window.
+             * Without this, `suppressing` latches: the only exit is a ten-second silence, so a retry
+             * that starts fast and backs off to anything under one line per ten seconds stays folded
+             * forever. Measured on the built module: 30 lines in 3 seconds trips the gate, and the next
+             * 1,200 occurrences spread over three hours produce three lines. That is the chronic-failure
+             * silence this redesign was written to remove, re-entered through a different door.
+             */
+            if (existing.suppressing && existing.windowCount <= STORM_BURST)
+                closeRun(existing);
+            existing.windowStartMs = at;
+            existing.windowCount = 0;
+        }
+        existing.lastAtMs = at;
+        existing.windowCount += 1;
+        if (existing.suppressing) {
+            existing.lastCtx = ctx;
+            existing.suppressedCount += 1;
+            // The 1st suppressed occurrence is not a milestone worth printing — the line that tripped
+            // the gate, immediately above it, already said the fold had started.
+            if (existing.suppressedCount === 1 || !isMilestone(existing.suppressedCount))
+                return;
+            sink[level](event, {
+                ...ctx,
+                repeatedCount: existing.suppressedCount,
+                repeatWindowMs: Math.max(0, at - existing.suppressStartMs),
+            });
+            return;
+        }
+        if (existing.windowCount > STORM_BURST) {
+            // The gate trips. This line is still written in full, and says that the ones behind it
+            // will not be — an operator should never have to infer that lines are being dropped.
+            existing.suppressing = true;
+            existing.suppressStartMs = at;
+            existing.suppressedCount = 0;
+            existing.lastCtx = ctx;
+            sink[level](event, { ...ctx, repeatsCollapsing: true, repeatRatePerWindow: existing.windowCount });
+            return;
+        }
+        sink[level](event, ctx);
+    }
+    return {
+        debug: (event, ctx) => { emit("debug", event, ctx); },
+        info: (event, ctx) => { emit("info", event, ctx); },
+        warn: (event, ctx) => { emit("warn", event, ctx); },
+        error: (event, ctx) => { emit("error", event, ctx); },
+    };
+}
+//# sourceMappingURL=log-collapse.js.map

package/dist/log-collapse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-collapse.js","sourceRoot":"","sources":["../src/log-collapse.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,0FAA0F;AAC1F,MAAM,CAAC,MAAM,WAAW,GAAG,EAAE,CAAC;AAE9B,qFAAqF;AACrF,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC;AAEtC;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAE1C,oGAAoG;AACpG,MAAM,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;AA4BpC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,SAAS,WAAW,CAAC,KAAa,EAAE,KAAa,EAAE,GAA4B;IAC7E,MAAM,SAAS,GAAG,GAAG,CAAC,WAAW,CAAC,CAAC;IACnC,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC7B,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC7E,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,SAAS,IAAI,EAAE,CAAC,EAAE,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACjF,CAAC;AAED,wEAAwE;AACxE,SAAS,WAAW,CAAC,KAAa;IAChC,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7B,IAAI,CAAC,GAAG,KAAK,CAAC;IACd,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC;QAAE,CAAC,IAAI,EAAE,CAAC;IAC7B,OAAO,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CAAC,IAAY,EAAE,MAAoB,IAAI,CAAC,GAAG;IAC/E,MAAM,IAAI,GAAG,IAAI,GAAG,EAAe,CAAC;IAEpC;;;;;;;;OAQG;IACH,SAAS,QAAQ,CAAC,GAAQ;QACxB,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE;YACzB,GAAG,GAAG,CAAC,OAAO;YACd,aAAa,EAAE,GAAG,CAAC,eAAe;YAClC,cAAc,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,QAAQ,GAAG,GAAG,CAAC,eAAe,CAAC;YAC/D,WAAW,EAAE,IAAI;SAClB,CAAC,CAAC;QACH,GAAG,CAAC,WAAW,GAAG,KAAK,CAAC;QACxB,GAAG,CAAC,eAAe,GAAG,CAAC,CAAC;IAC1B,CAAC;IAED;;;;;;;OAOG;IACH,SAAS,WAAW,CAAC,EAAU,EAAE,UAAkB;QACjD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC;QACrC,IAAI,MAAM,CAAC,IAAI;YAAE,OAAO;QACxB,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;QAChC,IAAI,GAAG,KAAK,UAAU;YAAE,OAAO;QAC/B,IAAI,EAAE,GAAG,GAAG,CAAC,QAAQ,GAAG,eAAe;YAAE,OAAO;QAChD,IAAI,GAAG,CAAC,WAAW;YAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACnC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACnB,CAAC;IAED,SAAS,IAAI,CAAC,KAA0C,EAAE,KAAa,EAAE,GAA4B;QACnG,MAAM,GAAG,GAAG,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;QAC3C,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;YACjB,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACxB,OAAO;QACT,CAAC;QAED,MAAM,EAAE,GAAG,GAAG,EAAE,CAAC;QACjB,WAAW,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;QAErB,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,IAAI,IAAI,CAAC,IAAI,IAAI,qBAAqB,EAAE,CAAC;gBACvC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC;gBACrC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;oBACjB,uFAAuF;oBACvF,2EAA2E;oBAC3E,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW;wBAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC3D,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC/B,CAAC;YACH,CAAC;YACD,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE;gBACZ,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;gBAC7D,WAAW,EAAE,KAAK,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG;aACzE,CAAC,CAAC;YACH,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACxB,OAAO;QACT,CAAC;QAED,2FAA2F;QAC3F,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACjB,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QAExB;;;;;WAKG;QACH,MAAM,IAAI,GAAG,EAAE,GAAG,QAAQ,CAAC,QAAQ,IAAI,eAAe,CAAC;QAEvD,IAAI,IAAI,EAAE,CAAC;YACT,IAAI,QAAQ,CAAC,WAAW;gBAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;YAC7C,QAAQ,CAAC,aAAa,GAAG,EAAE,CAAC;YAC5B,QAAQ,CAAC,WAAW,GAAG,CAAC,CAAC;QAC3B,CAAC;aAAM,IAAI,EAAE,GAAG,QAAQ,CAAC,aAAa,IAAI,eAAe,EAAE,CAAC;YAC1D;;;;;;;eAOG;YACH,IAAI,QAAQ,CAAC,WAAW,IAAI,QAAQ,CAAC,WAAW,IAAI,WAAW;gBAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;YACpF,QAAQ,CAAC,aAAa,GAAG,EAAE,CAAC;YAC5B,QAAQ,CAAC,WAAW,GAAG,CAAC,CAAC;QAC3B,CAAC;QAED,QAAQ,CAAC,QAAQ,GAAG,EAAE,CAAC;QACvB,QAAQ,CAAC,WAAW,IAAI,CAAC,CAAC;QAE1B,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;YACzB,QAAQ,CAAC,OAAO,GAAG,GAAG,CAAC;YACvB,QAAQ,CAAC,eAAe,IAAI,CAAC,CAAC;YAC9B,0FAA0F;YAC1F,qEAAqE;YACrE,IAAI,QAAQ,CAAC,eAAe,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,eAAe,CAAC;gBAAE,OAAO;YACrF,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE;gBACjB,GAAG,GAAG;gBACN,aAAa,EAAE,QAAQ,CAAC,eAAe;gBACvC,cAAc,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,GAAG,QAAQ,CAAC,eAAe,CAAC;aAC3D,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,IAAI,QAAQ,CAAC,WAAW,GAAG,WAAW,EAAE,CAAC;YACvC,uFAAuF;YACvF,qFAAqF;YACrF,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC;YAC5B,QAAQ,CAAC,eAAe,GAAG,EAAE,CAAC;YAC9B,QAAQ,CAAC,eAAe,GAAG,CAAC,CAAC;YAC7B,QAAQ,CAAC,OAAO,GAAG,GAAG,CAAC;YACvB,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,GAAG,GAAG,EAAE,iBAAiB,EAAE,IAAI,EAAE,mBAAmB,EAAE,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC;YACnG,OAAO;QACT,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAC1B,CAAC;IAED,OAAO;QACL,KAAK,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;QACrD,IAAI,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;QACnD,IAAI,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;QACnD,KAAK,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;KACtD,CAAC;AACJ,CAAC"}