wicked-crew 0.7.45 → 0.7.47

package/dist/watch/checks/ungated.js

@@ -0,0 +1,64 @@
+/**
+ * `deterministic:ungated` — entry `ungated` (DES-TRIGGER-REGISTRY-001 §4.3 row 2, TR-W5b).
+ *
+ * A projection of the engine's own `gateEvaluated.ungated` and `ungatedReason` (the entry's filter
+ * is empty, so every gate counts toward coverage; only `ungated === true` raises): it computes nothing, and a judge-verified PASS without a floor is gated and
+ * never flagged (S5). The engine says such a unit "must be rendered as UNGATED, never as pass", so
+ * the flag is a `problem`, never "Finished". `gateEvaluated` carries no attempt; the attempt comes
+ * from the unit's `unitOutputCaptured`, emitted before the gate runs (joined).
+ */
+import { z } from 'zod';
+const REASON_MAX = 200;
+export const ungatedCheck = {
+    name: 'deterministic:ungated',
+    lane: 'deterministic',
+    paramsSchema: z.object({}).strict(),
+    thresholdSchema: z.object({}).strict(),
+    evaluate(input, state) {
+        const bag = state.bag.get('ungated') ?? { attemptByOrd: new Map(), gates: 0, silent: 0 };
+        state.bag.set('ungated', bag);
+        const e = input.event;
+        const ord = typeof e['ord'] === 'number' ? e['ord'] : null;
+        if (ord === null)
+            return [];
+        if (input.type === 'unitOutputCaptured') {
+            if (typeof e['attempt'] === 'number')
+                bag.attemptByOrd.set(ord, e['attempt']);
+            return [];
+        }
+        if (input.type !== 'gateEvaluated')
+            return [];
+        if (typeof e['ungated'] !== 'boolean') {
+            bag.silent++;
+            return [];
+        }
+        bag.gates++;
+        if (e['ungated'] !== true)
+            return [];
+        const attempt = bag.attemptByOrd.get(ord) ?? null;
+        const raw = typeof e['ungatedReason'] === 'string' ? e['ungatedReason'].trim() : '';
+        const reason = raw.length > REASON_MAX ? `${raw.slice(0, REASON_MAX - 1)}…` : raw;
+        return [
+            {
+                op: 'raise',
+                subject: `${ord}:${attempt ?? '-'}:ungated`,
+                sentence: reason !== '' ? `Nothing checked this step: ${reason}` : 'Nothing checked this step.',
+                facts: { ungated_reason: reason },
+                ord,
+                attempt,
+                re: `gateEvaluated#${ord}`,
+            },
+        ];
+    },
+    coverage(state) {
+        const bag = state.bag.get('ungated');
+        if (bag !== undefined && bag.gates > 0)
+            return { state: 'checked' };
+        if (bag !== undefined && bag.silent > 0) {
+            return { state: 'not_checked', reason: 'the engine is too old to say whether a step was checked' };
+        }
+        return { state: 'not_checked', reason: 'no step has reached its gate yet' };
+    },
+    describe: () => 'When a step finishes with nothing checking it: no checks, no judge, no policy',
+};
+//# sourceMappingURL=ungated.js.map

package/dist/watch/checks/ungated.js.map

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

package/dist/watch/emit.d.ts

@@ -0,0 +1,122 @@
+/**
+ * The emitter and the feed fold (DES-TRIGGER-REGISTRY-001 §4.6-§4.8).
+ *
+ * EMIT. Outputs are micro-batched (every 2 s, or at 16 waiting) and each row goes to the bus through
+ * the engine (`emitOnBus`). A key already on the bus resolves to the existing row: success. A failed
+ * emit is retried at 1, 2 and 4 s, then DROPPED with an audit line `watch.emit.failed` and counted
+ * in `health.emit.failed` [D-3]: watch rows are advisory, so a lost one is disclosed, never retried
+ * forever and never blocking.
+ *
+ * FOLD. The bus is the one record. The feed is hydrated once at arm from the bus history, then
+ * updated only from rows this emitter saw acknowledged, so `GET /watch` never re-reads the bus.
+ *
+ * RATE. Past an entry's `emit.rate.per_run` rows on one run, a roll-up row stands for the rest: each
+ * further output raises the next roll-up row (`rolled_up` = how many it stands for) and clears the
+ * previous one with `reason: "rolled_up"`, `replaced_by` the new row (§4.7).
+ */
+import type { WatchFinding, WatchFindingCleared } from 'wicked-crew-api-types';
+import type { CheckOutput, LoadedEntry } from './types.js';
+/** Redacted, capped facts; an over-size object is replaced by a marker rather than cut mid-structure. */
+export declare function scrubFacts(facts: Record<string, unknown> | undefined): Record<string, unknown>;
+/** One feed row: the raised payload, and its clearing once one was acknowledged. */
+export interface FeedRow {
+    raised: WatchFinding;
+    cleared: WatchFindingCleared | null;
+}
+/**
+ * The in-memory feed, BOUNDED (the daemon's bus is never swept, so a lifetime fold would grow
+ * without limit): past `maxRows` the oldest cleared row goes first, then the oldest row. The bus
+ * stays the record; an evicted row re-raised by a replay resolves to its existing bus row.
+ */
+export declare class WatchFeed {
+    private readonly maxRows;
+    readonly rows: Map<string, FeedRow>;
+    private readonly orphanClears;
+    /** Cleared rows in clearing order: the first eviction candidates. */
+    private readonly clearedOrder;
+    constructor(maxRows?: number);
+    get orphanCount(): number;
+    private evict;
+    has(watchId: string): boolean;
+    get(watchId: string): FeedRow | undefined;
+    addRaised(f: WatchFinding): void;
+    addCleared(c: WatchFindingCleared): void;
+    /** Fold one bus row (the boot hydrate). */
+    foldBusRow(eventType: string, payload: unknown): void;
+    /** Rows of one (run, entry), roll-ups apart (the rate count, rebuilt after a restart). */
+    countFor(runId: string | null, entryId: string): {
+        plain: number;
+        rollups: WatchFinding[];
+    };
+}
+export interface EmitterDeps {
+    dbPath: string;
+    projectOf: (runId: string) => string | undefined;
+    /** `audit.record('watch.emit.failed', …)` in the daemon. */
+    auditEmitFailed: (detail: Record<string, unknown>) => void;
+    /** The proposals sink (§4.11): crew's existing review queue. Never self-applied. */
+    submitProposal?: (finding: WatchFinding) => Promise<void>;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+    /** Flush cadence, ms (tests pass 0 and call `flush`). */
+    flushMs?: number;
+    log?: (msg: string) => void;
+    /** Called once per acknowledged row (the registry folds nothing else). */
+    onAck?: (eventType: string, payload: WatchFinding | WatchFindingCleared) => void;
+}
+export declare class WatchEmitter {
+    private readonly deps;
+    readonly feed: WatchFeed;
+    failed: number;
+    proposalsFailed: number;
+    private pending;
+    private readonly queuedKeys;
+    /** Raised rows dropped after their retries (a clearing that depends on one is skipped). */
+    private readonly failedKeys;
+    /** Raised rows taken out of `pending` and on their way to the bus (a clearing can still find them). */
+    private readonly inflight;
+    private readonly rate;
+    /** The newest watch row on the bus at hydrate: an emit resolving to an id at or below it found an OLD row. */
+    private hydratedTail;
+    private timer;
+    private flushing;
+    private readonly now;
+    private readonly sleep;
+    constructor(deps: EmitterDeps);
+    /** Hydrate the feed once from the bus history (§4.8 step 1). */
+    hydrate(): Promise<number>;
+    start(): void;
+    stop(): Promise<void>;
+    get waiting(): number;
+    private rateOf;
+    private envelope;
+    /**
+     * Queue a raise for `out` (rate and roll-up applied). `replay`: the input came from the boot
+     * replay; over the rate such an output is DROPPED rather than rolled up, because the first life
+     * may already have counted it and a roll-up row cannot tell (the count may then read low after a
+     * restart, never high — a duplicate row is the failure G4 rules out).
+     */
+    raise(entry: LoadedEntry, runId: string | null, out: Extract<CheckOutput, {
+        op: 'raise';
+    }>, anchorAt: number, replay?: boolean): void;
+    /** Queue the clearing of the row `subject` names (no-op when it was never raised or is already cleared). */
+    clear(entry: LoadedEntry, runId: string | null, subject: string, how: {
+        reason: 'resolved';
+    } | {
+        reason: 'dismissed';
+        dismissed_by: string;
+    }, re?: string): boolean;
+    /** Queue the clearing of `watchId` (dismiss uses this directly). */
+    clearById(watchId: string, how: {
+        reason: 'resolved';
+    } | {
+        reason: 'dismissed';
+        dismissed_by: string;
+    }, re?: string): boolean;
+    private push;
+    /** Emit everything waiting, in order. Concurrent calls share one pass. */
+    flush(): Promise<void>;
+    private drain;
+    private emitOne;
+}
+//# sourceMappingURL=emit.d.ts.map

package/dist/watch/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/watch/emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAY/E,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AA+B3D,yGAAyG;AACzG,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAG9F;AAED,oFAAoF;AACpF,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAC;CACrC;AAQD;;;;GAIG;AACH,qBAAa,SAAS;IAMR,OAAO,CAAC,QAAQ,CAAC,OAAO;IALpC,QAAQ,CAAC,IAAI,uBAA8B;IAC3C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA0C;IACvE,qEAAqE;IACrE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;gBAErB,OAAO,SAAgB;IAEpD,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,OAAO,CAAC,KAAK;IASb,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI7B,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAIzC,SAAS,CAAC,CAAC,EAAE,YAAY,GAAG,IAAI;IAShC,UAAU,CAAC,CAAC,EAAE,mBAAmB,GAAG,IAAI;IAcxC,2CAA2C;IAC3C,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAMrD,0FAA0F;IAC1F,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,YAAY,EAAE,CAAA;KAAE;CAU5F;AAgBD,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACjD,4DAA4D;IAC5D,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAC3D,oFAAoF;IACpF,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,0EAA0E;IAC1E,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,mBAAmB,KAAK,IAAI,CAAC;CAClF;AAQD,qBAAa,YAAY;IAkBX,OAAO,CAAC,QAAQ,CAAC,IAAI;IAjBjC,QAAQ,CAAC,IAAI,YAAmB;IAChC,MAAM,SAAK;IACX,eAAe,SAAK;IACpB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;IAChD,2FAA2F;IAC3F,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;IAChD,uGAAuG;IACvG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmC;IAC5D,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgC;IACrD,8GAA8G;IAC9G,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,KAAK,CAA+B;IAC5C,OAAO,CAAC,QAAQ,CAA8B;IAC9C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;gBAEzB,IAAI,EAAE,WAAW;IAK9C,gEAAgE;IAC1D,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAShC,KAAK,IAAI,IAAI;IAOP,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,OAAO,CAAC,MAAM;IAsBd,OAAO,CAAC,QAAQ;IAehB;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,WAAW,EAAE;QAAE,EAAE,EAAE,OAAO,CAAA;KAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,UAAQ,GAAG,IAAI;IAsEnI,4GAA4G;IAC5G,KAAK,CACH,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE;QAAE,MAAM,EAAE,UAAU,CAAA;KAAE,GAAG;QAAE,MAAM,EAAE,WAAW,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,EAC3E,EAAE,SAAa,GACd,OAAO;IAKV,oEAAoE;IACpE,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE;QAAE,MAAM,EAAE,UAAU,CAAA;KAAE,GAAG;QAAE,MAAM,EAAE,WAAW,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,EAAE,EAAE,SAAa,GAAG,OAAO;IAwBjI,OAAO,CAAC,IAAI;IAaZ,0EAA0E;IAC1E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAQR,KAAK;YAcL,OAAO;CA6DtB"}

package/dist/watch/emit.js

@@ -0,0 +1,443 @@
+/**
+ * The emitter and the feed fold (DES-TRIGGER-REGISTRY-001 §4.6-§4.8).
+ *
+ * EMIT. Outputs are micro-batched (every 2 s, or at 16 waiting) and each row goes to the bus through
+ * the engine (`emitOnBus`). A key already on the bus resolves to the existing row: success. A failed
+ * emit is retried at 1, 2 and 4 s, then DROPPED with an audit line `watch.emit.failed` and counted
+ * in `health.emit.failed` [D-3]: watch rows are advisory, so a lost one is disclosed, never retried
+ * forever and never blocking.
+ *
+ * FOLD. The bus is the one record. The feed is hydrated once at arm from the bus history, then
+ * updated only from rows this emitter saw acknowledged, so `GET /watch` never re-reads the bus.
+ *
+ * RATE. Past an entry's `emit.rate.per_run` rows on one run, a roll-up row stands for the rest: each
+ * further output raises the next roll-up row (`rolled_up` = how many it stands for) and clears the
+ * previous one with `reason: "rolled_up"`, `replaced_by` the new row (§4.7).
+ */
+import { emitOnBus, readBus } from '../core/bus.js';
+import { redactString } from '../mcp/redact.js';
+import { WATCH_BUS_DOMAIN, WATCH_BUS_SUBDOMAIN, WATCH_FINDING_CLEARED, WATCH_FINDING_PREFIX, WATCH_FINDING_RAISED, WATCH_PRODUCER, } from './events.js';
+import { clearedKey, watchIdOf } from './keys.js';
+/** Facts are capped (§4.5): each string redacted and ≤ 200 chars, the whole object ≤ 4 KB. */
+const FACT_STRING_MAX = 200;
+const FACTS_MAX_BYTES = 4096;
+const SENTENCE_MAX = 300;
+const BATCH = 16;
+const RETRY_MS = [1_000, 2_000, 4_000];
+function capString(s, max) {
+    const r = redactString(s);
+    return r.length > max ? `${r.slice(0, max - 1)}…` : r;
+}
+const FACT_DEPTH_MAX = 6;
+/** Every string redacted and capped at any depth; deeper than the cap, or a cycle, becomes a marker. */
+function scrub(value, depth = 0, seen = new WeakSet()) {
+    if (typeof value === 'string')
+        return capString(value, FACT_STRING_MAX);
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (value === null || typeof value !== 'object')
+        return typeof value === 'function' || typeof value === 'symbol' ? undefined : value;
+    if (seen.has(value))
+        return '[cycle]';
+    if (depth >= FACT_DEPTH_MAX)
+        return '[too deep]';
+    seen.add(value);
+    const out = Array.isArray(value)
+        ? value.slice(0, 50).map((v) => scrub(v, depth + 1, seen))
+        : Object.fromEntries(Object.entries(value).map(([k, v]) => [k, scrub(v, depth + 1, seen)]));
+    seen.delete(value);
+    return out;
+}
+/** Redacted, capped facts; an over-size object is replaced by a marker rather than cut mid-structure. */
+export function scrubFacts(facts) {
+    const out = scrub(facts ?? {});
+    return Buffer.byteLength(JSON.stringify(out), 'utf8') <= FACTS_MAX_BYTES ? out : { truncated: true };
+}
+/** The in-memory feed: keyed by `watch_id`, plus the (run, entry, subject) → `watch_id` index. */
+/** Rows the feed holds (the routes serve at most 500): the bus stays the full record. */
+const FEED_MAX_ROWS = 20_000;
+/** Rate states held, one per (run, entry); an evicted one is rebuilt from the feed if it recurs. */
+const RATE_MAX = 5_000;
+/**
+ * The in-memory feed, BOUNDED (the daemon's bus is never swept, so a lifetime fold would grow
+ * without limit): past `maxRows` the oldest cleared row goes first, then the oldest row. The bus
+ * stays the record; an evicted row re-raised by a replay resolves to its existing bus row.
+ */
+export class WatchFeed {
+    maxRows;
+    rows = new Map();
+    orphanClears = new Map();
+    /** Cleared rows in clearing order: the first eviction candidates. */
+    clearedOrder = new Set();
+    constructor(maxRows = FEED_MAX_ROWS) {
+        this.maxRows = maxRows;
+    }
+    get orphanCount() {
+        return this.orphanClears.size;
+    }
+    evict() {
+        while (this.rows.size > this.maxRows) {
+            const victim = this.clearedOrder.values().next().value ?? this.rows.keys().next().value;
+            if (victim === undefined)
+                return;
+            this.rows.delete(victim);
+            this.clearedOrder.delete(victim);
+        }
+    }
+    has(watchId) {
+        return this.rows.has(watchId);
+    }
+    get(watchId) {
+        return this.rows.get(watchId);
+    }
+    addRaised(f) {
+        if (this.rows.has(f.watch_id))
+            return;
+        const orphan = this.orphanClears.get(f.watch_id) ?? null;
+        this.orphanClears.delete(f.watch_id);
+        this.rows.set(f.watch_id, { raised: f, cleared: orphan });
+        if (orphan !== null)
+            this.clearedOrder.add(f.watch_id);
+        this.evict();
+    }
+    addCleared(c) {
+        const row = this.rows.get(c.watch_id);
+        if (row === undefined) {
+            this.orphanClears.set(c.watch_id, c);
+            if (this.orphanClears.size > this.maxRows) {
+                const oldest = this.orphanClears.keys().next().value;
+                if (oldest !== undefined)
+                    this.orphanClears.delete(oldest);
+            }
+        }
+        else if (row.cleared === null) {
+            row.cleared = c;
+            this.clearedOrder.add(c.watch_id);
+        }
+    }
+    /** Fold one bus row (the boot hydrate). */
+    foldBusRow(eventType, payload) {
+        if (payload === null || typeof payload !== 'object')
+            return;
+        if (eventType === WATCH_FINDING_RAISED)
+            this.addRaised(payload);
+        else if (eventType === WATCH_FINDING_CLEARED)
+            this.addCleared(payload);
+    }
+    /** Rows of one (run, entry), roll-ups apart (the rate count, rebuilt after a restart). */
+    countFor(runId, entryId) {
+        let plain = 0;
+        const rollups = [];
+        for (const { raised } of this.rows.values()) {
+            if (raised.run_id !== runId || raised.entry_id !== entryId)
+                continue;
+            if (raised.rolled_up > 0)
+                rollups.push(raised);
+            else
+                plain++;
+        }
+        return { plain, rollups };
+    }
+}
+export class WatchEmitter {
+    deps;
+    feed = new WatchFeed();
+    failed = 0;
+    proposalsFailed = 0;
+    pending = [];
+    queuedKeys = new Set();
+    /** Raised rows dropped after their retries (a clearing that depends on one is skipped). */
+    failedKeys = new Set();
+    /** Raised rows taken out of `pending` and on their way to the bus (a clearing can still find them). */
+    inflight = new Map();
+    rate = new Map();
+    /** The newest watch row on the bus at hydrate: an emit resolving to an id at or below it found an OLD row. */
+    hydratedTail = 0;
+    timer = null;
+    flushing = null;
+    now;
+    sleep;
+    constructor(deps) {
+        this.deps = deps;
+        this.now = deps.now ?? Date.now;
+        this.sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms).unref()));
+    }
+    /** Hydrate the feed once from the bus history (§4.8 step 1). */
+    async hydrate() {
+        const rows = await readBus(this.deps.dbPath, WATCH_FINDING_PREFIX, { history: true });
+        for (const r of rows) {
+            this.feed.foldBusRow(r.event_type, r.payload);
+            if (r.event_id > this.hydratedTail)
+                this.hydratedTail = r.event_id;
+        }
+        return rows.length;
+    }
+    start() {
+        const ms = this.deps.flushMs ?? 2_000;
+        if (ms <= 0 || this.timer !== null)
+            return;
+        this.timer = setInterval(() => void this.flush(), ms);
+        this.timer.unref();
+    }
+    async stop() {
+        if (this.timer !== null)
+            clearInterval(this.timer);
+        this.timer = null;
+        await this.flush();
+    }
+    get waiting() {
+        return this.pending.length;
+    }
+    rateOf(runId, entryId) {
+        const k = `${runId ?? '-'}\u0000${entryId}`;
+        let s = this.rate.get(k);
+        if (s === undefined) {
+            // Rebuilt from the feed after a restart, so the count and the roll-up chain carry on.
+            const { plain, rollups } = this.feed.countFor(runId, entryId);
+            const rollup = new Map();
+            for (const r of rollups) {
+                const att = String(r.attempt ?? '-');
+                const prev = rollup.get(att);
+                if (prev === undefined || r.rolled_up > prev.n)
+                    rollup.set(att, { n: r.rolled_up, watchId: r.watch_id });
+            }
+            s = { plain, rollup };
+            this.rate.set(k, s);
+            if (this.rate.size > RATE_MAX) {
+                const oldest = this.rate.keys().next().value;
+                if (oldest !== undefined && oldest !== k)
+                    this.rate.delete(oldest);
+            }
+        }
+        return s;
+    }
+    envelope(entry, runId, ord, attempt, re) {
+        const projectId = runId !== null ? this.deps.projectOf(runId) : undefined;
+        return {
+            run_id: runId,
+            ord,
+            attempt,
+            by: `watch:${entry.id}@${entry.version}`,
+            at: this.now(),
+            re,
+            entry_id: entry.id,
+            entry_version: entry.version,
+            ...(projectId !== undefined ? { project_id: projectId } : {}),
+        };
+    }
+    /**
+     * Queue a raise for `out` (rate and roll-up applied). `replay`: the input came from the boot
+     * replay; over the rate such an output is DROPPED rather than rolled up, because the first life
+     * may already have counted it and a roll-up row cannot tell (the count may then read low after a
+     * restart, never high — a duplicate row is the failure G4 rules out).
+     */
+    raise(entry, runId, out, anchorAt, replay = false) {
+        const watchId = watchIdOf(runId, entry.id, entry.version, out.subject);
+        if (this.feed.has(watchId) || this.queuedKeys.has(watchId))
+            return; // a replay: already the record
+        const rate = this.rateOf(runId, entry.id);
+        const ord = out.ord ?? null;
+        const attempt = out.attempt ?? null;
+        const base = (subject, rolledUp, sentence) => ({
+            ...this.envelope(entry, runId, ord, attempt, out.re),
+            watch_id: watchIdOf(runId, entry.id, entry.version, subject),
+            check: entry.check,
+            kind: out.kind ?? entry.emit.as,
+            severity: out.severity ?? entry.emit.severity,
+            watch_kind: entry.emit.watch_kind,
+            attach: entry.emit.attach,
+            sentence: capString(sentence, SENTENCE_MAX),
+            facts: scrubFacts(out.facts),
+            anchor: runId !== null ? { run_id: runId, ord, attempt, at: anchorAt } : null,
+            evidence: out.evidence ?? [],
+            model: null,
+            rolled_up: rolledUp,
+        });
+        if (rate.plain < entry.emit.rate.per_run) {
+            rate.plain++;
+            this.push(WATCH_FINDING_RAISED, base(out.subject, 0, out.sentence), entry.emit.as === 'proposal', { plainOf: rate });
+            return;
+        }
+        if (replay)
+            return;
+        // Over the rate: the next roll-up row for this attempt replaces the previous one.
+        const att = String(attempt ?? '-');
+        const prev = rate.rollup.get(att);
+        const n = (prev?.n ?? 0) + 1;
+        const row = base(`rollup:${att}#${n}`, n, `${n} more like this on this run (latest: ${out.sentence})`);
+        rate.rollup.set(att, { n, watchId: row.watch_id });
+        // Coalesce a burst: while the previous roll-up row has not reached the bus yet, it is REPLACED
+        // in the batch (its clearing would only name a row nobody ever saw), and a waiting clearing
+        // that pointed at it now points at the new row.
+        const waiting = prev === undefined ? -1 : this.pending.findIndex((p) => p.eventType === WATCH_FINDING_RAISED && p.key === prev.watchId);
+        if (prev !== undefined && waiting !== -1) {
+            const replaced = this.pending[waiting];
+            this.queuedKeys.delete(prev.watchId);
+            this.queuedKeys.add(row.watch_id);
+            this.failedKeys.delete(row.watch_id);
+            // The chain falls back to where the REPLACED row would have restored it.
+            this.pending[waiting] = {
+                eventType: WATCH_FINDING_RAISED,
+                key: row.watch_id,
+                payload: row,
+                proposal: false,
+                restore: { rate, att, to: replaced.restore?.to },
+            };
+            for (const p of this.pending) {
+                const c = p.payload;
+                if (p.eventType === WATCH_FINDING_CLEARED && c.reason === 'rolled_up' && c.replaced_by === prev.watchId) {
+                    c.replaced_by = row.watch_id;
+                    p.dependsOn = row.watch_id;
+                }
+            }
+            return;
+        }
+        this.push(WATCH_FINDING_RAISED, row, false, { restore: { rate, att, to: prev } });
+        if (prev !== undefined) {
+            this.push(WATCH_FINDING_CLEARED, {
+                ...this.envelope(entry, runId, ord, attempt, out.re),
+                watch_id: prev.watchId,
+                reason: 'rolled_up',
+                replaced_by: row.watch_id,
+            }, false, { dependsOn: row.watch_id });
+        }
+    }
+    /** Queue the clearing of the row `subject` names (no-op when it was never raised or is already cleared). */
+    clear(entry, runId, subject, how, re = 'resolved') {
+        const watchId = watchIdOf(runId, entry.id, entry.version, subject);
+        return this.clearById(watchId, how, re);
+    }
+    /** Queue the clearing of `watchId` (dismiss uses this directly). */
+    clearById(watchId, how, re = 'resolved') {
+        const row = this.feed.get(watchId);
+        const queuedRaise = this.pending.find((p) => p.eventType === WATCH_FINDING_RAISED && p.payload.watch_id === watchId);
+        const unacked = queuedRaise?.payload ?? this.inflight.get(watchId);
+        const raised = row?.raised ?? unacked;
+        if (raised === undefined || (row !== undefined && row.cleared !== null) || this.queuedKeys.has(clearedKey(watchId)))
+            return false;
+        const payload = {
+            run_id: raised.run_id,
+            ord: raised.ord,
+            attempt: raised.attempt,
+            by: raised.by,
+            at: this.now(),
+            re,
+            watch_id: watchId,
+            entry_id: raised.entry_id,
+            entry_version: raised.entry_version,
+            ...(raised.project_id !== undefined ? { project_id: raised.project_id } : {}),
+            ...how,
+        };
+        // Not yet acknowledged: the clearing waits on its raise, and is skipped if that raise is dropped.
+        this.push(WATCH_FINDING_CLEARED, payload, false, row === undefined ? { dependsOn: watchId } : {});
+        return true;
+    }
+    push(eventType, payload, proposal, extra = {}) {
+        const key = eventType === WATCH_FINDING_RAISED ? payload.watch_id : clearedKey(payload.watch_id);
+        this.queuedKeys.add(key);
+        if (eventType === WATCH_FINDING_RAISED)
+            this.failedKeys.delete(key);
+        this.pending.push({ eventType, key, payload, proposal, ...extra });
+        if (this.pending.length >= BATCH)
+            void this.flush();
+    }
+    /** Emit everything waiting, in order. Concurrent calls share one pass. */
+    flush() {
+        if (this.flushing !== null)
+            return this.flushing.then(() => (this.pending.length > 0 ? this.flush() : undefined));
+        this.flushing = this.drain().finally(() => {
+            this.flushing = null;
+        });
+        return this.flushing;
+    }
+    async drain() {
+        while (this.pending.length > 0) {
+            const batch = this.pending.splice(0, BATCH);
+            for (const p of batch)
+                if (p.eventType === WATCH_FINDING_RAISED)
+                    this.inflight.set(p.key, p.payload);
+            for (const p of batch) {
+                try {
+                    await this.emitOne(p);
+                }
+                finally {
+                    this.inflight.delete(p.key);
+                }
+            }
+        }
+    }
+    async emitOne(p) {
+        if (p.dependsOn !== undefined && this.failedKeys.has(p.dependsOn)) {
+            // Its raised row never reached the bus: a clearing pointing at it would name nothing.
+            this.queuedKeys.delete(p.key);
+            return;
+        }
+        const idempotency = p.eventType === WATCH_FINDING_RAISED ? raisedKeyOf(p.payload) : clearedKey(p.payload.watch_id);
+        const wasNew = p.eventType === WATCH_FINDING_RAISED && !this.feed.has(p.payload.watch_id);
+        let lastErr = null;
+        let eventId = 0;
+        for (let i = 0; i <= RETRY_MS.length; i++) {
+            try {
+                eventId = await emitOnBus(this.deps.dbPath, {
+                    event_type: p.eventType,
+                    domain: WATCH_BUS_DOMAIN,
+                    subdomain: WATCH_BUS_SUBDOMAIN,
+                    payload: p.payload,
+                    producer_id: WATCH_PRODUCER,
+                    idempotency_key: idempotency,
+                });
+                lastErr = null;
+                break;
+            }
+            catch (err) {
+                lastErr = err;
+                if (i < RETRY_MS.length)
+                    await this.sleep(RETRY_MS[i]);
+            }
+        }
+        this.queuedKeys.delete(p.key);
+        if (lastErr !== null) {
+            this.failed++;
+            if (p.eventType === WATCH_FINDING_RAISED) {
+                this.failedKeys.add(p.key);
+                // Give back what the dropped row took: its rate slot, or its place at the head of the chain.
+                if (p.plainOf !== undefined)
+                    p.plainOf.plain = Math.max(0, p.plainOf.plain - 1);
+                if (p.restore !== undefined && p.restore.rate.rollup.get(p.restore.att)?.watchId === p.key) {
+                    if (p.restore.to === undefined)
+                        p.restore.rate.rollup.delete(p.restore.att);
+                    else
+                        p.restore.rate.rollup.set(p.restore.att, p.restore.to);
+                }
+            }
+            this.deps.auditEmitFailed({
+                event_type: p.eventType,
+                watch_id: p.payload.watch_id,
+                entry_id: p.payload.entry_id,
+                error: lastErr instanceof Error ? lastErr.message : String(lastErr),
+            });
+            return;
+        }
+        if (p.eventType === WATCH_FINDING_RAISED)
+            this.feed.addRaised(p.payload);
+        else
+            this.feed.addCleared(p.payload);
+        this.deps.onAck?.(p.eventType, p.payload);
+        // An emit that resolved to a row older than this boot's hydrate (one the bounded feed had
+        // evicted) is not new: its proposal was filed when it was first raised.
+        if (p.proposal && wasNew && eventId > this.hydratedTail && this.deps.submitProposal !== undefined) {
+            try {
+                await this.deps.submitProposal(p.payload);
+            }
+            catch (err) {
+                this.proposalsFailed++;
+                this.deps.log?.(`[watch] proposal for ${p.payload.watch_id} not filed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+}
+/** The raised row's idempotency key: `watch_id` is `"w-"` + the key (keys.ts `watchIdOf`). */
+function raisedKeyOf(f) {
+    return f.watch_id.slice(2);
+}
+//# sourceMappingURL=emit.js.map