@jungjaehoon/mama-os 0.32.2 → 0.33.0

package/dist/operator/operator-trigger-loop.js

@@ -27,8 +27,15 @@ const leg_cadence_js_1 = require("./leg-cadence.js");
 class OperatorTriggerLoop {
     deps;
     tickCount = 0;
+    maintenanceTickCount = 0;
+    authorWindowGeneration = 0;
+    authoredWindowGeneration = 0;
     recentEvents = [];
     running = false;
+    maintenancePending = false;
+    schedulerActive = false;
+    stopping = false;
+    activeRunPromise = null;
     nudgeTimer = null;
     digest;
     fullReporter;
@@ -37,6 +44,14 @@ class OperatorTriggerLoop {
     pendingReportExpectation;
     pendingReportLegacyLoaded = false;
     constructor(deps) {
+        // Design Decision 1: exactly one delivery executor. The legacy OutputSink
+        // report path cannot run beside the coordinator port.
+        if (deps.reportDelivery && deps.output) {
+            throw new Error('OperatorTriggerLoop: legacy report output cannot run beside ReportDeliveryPort');
+        }
+        if (deps.reportDelivery && !deps.reportTarget) {
+            throw new Error('OperatorTriggerLoop: reportDelivery requires reportTarget');
+        }
         this.deps = deps;
         // G2 success signal: when a sent report cites fired triggers (USED_TRIGGERS
         // trailer, window-validated), record 'succeeded' on each. Uncited fires stay
@@ -75,7 +90,7 @@ class OperatorTriggerLoop {
     }
     /** Reloads one durable outcome so recovery can hydrate this live loop before report work. */
     refreshPendingReportState() {
-        if (!this.deps.output) {
+        if (!this.hasReportSink()) {
             return 'unavailable';
         }
         const store = this.deps.pendingReportStore;
@@ -120,7 +135,7 @@ class OperatorTriggerLoop {
         return this.refreshPendingReportState() === 'quarantined';
     }
     persistPendingReports() {
-        if (!this.deps.output)
+        if (!this.hasReportSink())
             return false;
         if (this.refreshPendingReportState() === 'quarantined')
             return false;
@@ -144,6 +159,10 @@ class OperatorTriggerLoop {
     reporterFor(mode) {
         return mode === 'full' ? this.fullReporter : this.digest;
     }
+    /** A report sink exists: either the coordinator port or the legacy test sink. */
+    hasReportSink() {
+        return Boolean(this.deps.reportDelivery ?? this.deps.output);
+    }
     deliveryIdFor(occurrence) {
         if (occurrence.kind === 'scheduled_full' && occurrence.hourKey) {
             return `operator-report:scheduled:${occurrence.hourKey}`;
@@ -151,7 +170,7 @@ class OperatorTriggerLoop {
         return `operator-report:${occurrence.kind}:${(0, node_crypto_1.randomUUID)()}`;
     }
     requireOutputTarget() {
-        const target = this.deps.output?.target;
+        const target = this.deps.reportTarget ?? this.deps.output?.target;
         if (target?.source !== 'telegram' ||
             target.channelId.length === 0 ||
             target.channelId.trim() !== target.channelId) {
@@ -181,20 +200,56 @@ class OperatorTriggerLoop {
     }
     async deliverPendingReport(recovered) {
         const pending = this.pendingDelivery;
-        const output = this.deps.output;
-        if (!pending || !output) {
+        if (!pending || !this.hasReportSink()) {
             return null;
         }
         this.assertPendingDeliveryBinding(pending);
-        await this.reporterFor(pending.mode).deliverPrepared(pending, output);
-        if (pending.mode === 'full' && this.deps.reportScheduler) {
-            if (pending.occurrence.hourKey) {
-                this.deps.reportScheduler.markFired(pending.occurrence.hourKey);
+        const port = this.deps.reportDelivery;
+        if (port) {
+            // TG-05/TG-06: submit the persisted artifact and observe the typed
+            // outcome. Only `delivered` advances scheduler success, trigger credit,
+            // and pending-file cleanup; retry/rejection retain the artifact for the
+            // coordinator to drive to terminal; cancellation cleans up with an
+            // audit record and no credit.
+            const outcome = await port.deliverPrepared(pending);
+            if (outcome.status === 'delivered') {
+                this.reporterFor(pending.mode).markDeliveredOutcome(pending.citedTriggerIds);
+                this.markScheduledFullOutcome(pending);
+                this.pendingDelivery = undefined;
+                this.persistPendingReports();
+                if (recovered) {
+                    this.deps.log(`[trigger-loop] recovered pending ${pending.mode} owner report delivery=${pending.deliveryId}`);
+                }
+                return pending;
             }
-            if (pending.occurrence.firedAtIso) {
-                this.deps.reportScheduler.markSuccess(pending.occurrence.firedAtIso);
+            if (outcome.status === 'cancelled') {
+                this.pendingDelivery = undefined;
+                this.persistPendingReports();
+                this.deps.log(`[trigger-loop] owner report delivery=${pending.deliveryId} cancelled without credit: ${outcome.reason}`);
+                return null;
             }
+            if (outcome.status === 'capacity_full') {
+                // Loud degradation, never a wedge: the durable artifact is retained,
+                // the tick continues, and recovery only needs consumption or an
+                // explicit operator archive to reopen capacity.
+                this.persistPendingReports();
+                this.deps.log(`[trigger-loop] owner report delivery=${pending.deliveryId} BLOCKED by report-context capacity: ${outcome.reason}`);
+                return null;
+            }
+            this.persistPendingReports();
+            this.deps.log(outcome.status === 'retry_scheduled'
+                ? `[trigger-loop] owner report delivery=${pending.deliveryId} retry scheduled at ${outcome.nextAttemptAt}`
+                : `[trigger-loop] owner report delivery=${pending.deliveryId} definitively rejected: ${outcome.reason}`);
+            return null;
+        }
+        // LEGACY OutputSink path - V2 compatibility tests only; the constructor
+        // guard keeps it out of any assembly that wires the coordinator port.
+        const output = this.deps.output;
+        if (!output) {
+            return null;
         }
+        await this.reporterFor(pending.mode).deliverPrepared(pending, output);
+        this.markScheduledFullOutcome(pending);
         this.pendingDelivery = undefined;
         this.persistPendingReports();
         if (recovered) {
@@ -202,8 +257,19 @@ class OperatorTriggerLoop {
         }
         return pending;
     }
+    markScheduledFullOutcome(pending) {
+        if (pending.mode !== 'full' || !this.deps.reportScheduler) {
+            return;
+        }
+        if (pending.occurrence.hourKey) {
+            this.deps.reportScheduler.markFired(pending.occurrence.hourKey);
+        }
+        if (pending.occurrence.firedAtIso) {
+            this.deps.reportScheduler.markSuccess(pending.occurrence.firedAtIso);
+        }
+    }
     async prepareAndDeliverReport(askAgent, mode, occurrence) {
-        if (!this.deps.output || this.isPendingReportWorkBlocked()) {
+        if (!this.hasReportSink() || this.isPendingReportWorkBlocked()) {
             return false;
         }
         if (this.pendingDelivery) {
@@ -236,7 +302,7 @@ class OperatorTriggerLoop {
     }
     async preparePendingRequest() {
         const request = this.pendingRequest;
-        if (!request || !this.deps.output || this.isPendingReportWorkBlocked())
+        if (!request || !this.hasReportSink() || this.isPendingReportWorkBlocked())
             return false;
         if (this.pendingDelivery) {
             throw new Error('A pending owner report delivery must be recovered before its request');
@@ -278,42 +344,61 @@ class OperatorTriggerLoop {
         }
         return recovered;
     }
-    async tick() {
+    async tick(options = {}) {
         const { delta, memory, registry, askAgent, review, config, log } = this.deps;
-        const { output, reportScheduler } = this.deps;
-        const fullLegOn = Boolean(output && reportScheduler);
+        const { reportScheduler } = this.deps;
+        const reportSink = this.hasReportSink();
+        const fullLegOn = Boolean(reportSink && reportScheduler);
         this.tickCount += 1;
         const tick = this.tickCount;
+        const maintenanceTick = options.advanceMaintenance === false ? null : (this.maintenanceTickCount += 1);
+        let fires = 0;
+        let authored = 0;
+        let reviewed = 0;
+        let reported = false;
+        let fullReported = false;
+        const result = (drained = 0) => ({
+            tick,
+            drained,
+            fires,
+            authored,
+            reviewed,
+            reported,
+            fullReported,
+        });
         // Outbox recovery is the first effect in a tick. It reuses the persisted
         // delivery id, allowing Telegram's confirmed-chunk ledger to suppress a
         // send that was accepted just before the prior daemon stopped.
         this.refreshPendingReportState();
         const recoveredPendingWork = await this.recoverPendingReportWork();
+        if (this.stopping)
+            return result();
         // 1. Drain new deltas (commit AFTER processing - at-least-once).
         const events = delta.drainNew(config.drainLimit);
-        const reportEvents = output
+        const reportEvents = reportSink
             ? events.filter((event) => !this.digest.hasRecordedEvent(event))
             : events;
         if (events.length > 0) {
             log(`[trigger-loop] tick ${tick}: drained ${events.length} events`);
         }
         // 2. Match + fire + recordFire, folding fire activity into the report accumulators.
-        let fires = 0;
         for (const event of reportEvents) {
             const signals = (0, trigger_matcher_js_1.matchTriggers)(event, registry);
             for (const signal of signals) {
-                const result = await (0, trigger_fire_js_1.fireTrigger)(signal, memory);
+                const fireResult = await (0, trigger_fire_js_1.fireTrigger)(signal, memory);
+                if (this.stopping)
+                    return result(events.length);
                 fires += 1;
                 if (signal.triggerId) {
                     registry.recordFire(signal.triggerId);
                 }
                 // Carry the recalled {topic, content} (agent-authored memoryQuery drove it) into the report.
-                if (output) {
+                if (reportSink) {
                     this.digest.recordFire({
                         triggerId: signal.triggerId ?? signal.detector,
                         kind: signal.kind,
                         channelId: signal.channelId,
-                        recalled: result.recalled,
+                        recalled: fireResult.recalled,
                     });
                 }
                 if (fullLegOn) {
@@ -321,23 +406,24 @@ class OperatorTriggerLoop {
                         triggerId: signal.triggerId ?? signal.detector,
                         kind: signal.kind,
                         channelId: signal.channelId,
-                        recalled: result.recalled,
+                        recalled: fireResult.recalled,
                     });
                 }
                 log(`[trigger-loop] tick ${tick}: fire trigger=${signal.triggerId ?? signal.detector} ` +
-                    `recalled=${result.recalled.length} channel=${signal.channelId}`);
+                    `recalled=${fireResult.recalled.length} channel=${signal.channelId}`);
             }
         }
         // Persist the report window BEFORE advancing the connector cursor. A daemon
         // crash may repeat an event, but it cannot silently lose an owner update.
         if (reportEvents.length > 0) {
-            if (output) {
+            if (reportSink) {
                 this.digest.recordWindow(reportEvents);
                 if (fullLegOn) {
                     this.fullReporter.recordWindow(reportEvents);
                 }
             }
             this.recentEvents = [...this.recentEvents, ...reportEvents].slice(-config.authorWindowSize);
+            this.authorWindowGeneration += 1;
             this.persistPendingReports();
         }
         // Group per channel ONCE, before the cursor moves: the conductor inbox
@@ -404,46 +490,96 @@ class OperatorTriggerLoop {
             }
         }
         // 3. Agent authors new triggers from the recent window.
-        let authored = 0;
-        if (tick % config.authorEveryNTicks === 0 && this.recentEvents.length > 0) {
-            const created = await (0, trigger_author_js_1.authorTriggers)(this.recentEvents, registry, askAgent, {
-                note: `authored at tick ${tick}`,
-            });
-            authored = created.length;
-            if (authored > 0) {
-                if (output) {
-                    this.digest.recordAuthored(authored);
+        if (maintenanceTick !== null &&
+            maintenanceTick % config.authorEveryNTicks === 0 &&
+            this.recentEvents.length > 0 &&
+            this.authorWindowGeneration > this.authoredWindowGeneration) {
+            if (registry.canAttemptAuthor()) {
+                try {
+                    const created = await (0, trigger_author_js_1.authorTriggers)(this.recentEvents, registry, askAgent, {
+                        note: `authored at tick ${tick}`,
+                    });
+                    if (this.stopping)
+                        return result(events.length);
+                    authored = created.length;
+                    registry.clearAuthorFailure();
+                    this.authoredWindowGeneration = this.authorWindowGeneration;
+                    if (authored > 0) {
+                        if (reportSink) {
+                            this.digest.recordAuthored(authored);
+                        }
+                        if (fullLegOn) {
+                            this.fullReporter.recordAuthored(authored);
+                        }
+                        this.persistPendingReports();
+                    }
+                    log(`[trigger-loop] tick ${tick}: author pass created ${authored} trigger(s)`);
                 }
-                if (fullLegOn) {
-                    this.fullReporter.recordAuthored(authored);
+                catch (error) {
+                    if (this.stopping) {
+                        log(`[trigger-loop] tick ${tick}: author pass cancelled by shutdown`);
+                        return result(events.length);
+                    }
+                    registry.recordAuthorFailure(authorWindowFingerprint(this.recentEvents));
+                    log(`[trigger-loop] tick ${tick}: author pass FAILED; backed off: ${error instanceof Error ? error.message : String(error)}`);
                 }
-                this.persistPendingReports();
             }
-            log(`[trigger-loop] tick ${tick}: author pass created ${authored} trigger(s)`);
         }
         // 4. Agent reviews triggers that have actually fired.
-        let reviewed = 0;
-        if (tick % config.reviewEveryNTicks === 0) {
-            const firedTriggers = registry.listActive().filter((t) => t.stats.fired > 0);
-            const context = this.recentEvents.map((e) => `[${e.channelId}] ${e.content}`);
+        if (this.stopping)
+            return result(events.length);
+        if (maintenanceTick !== null && maintenanceTick % config.reviewEveryNTicks === 0) {
+            const configuredReviewLimit = config.reviewBatchLimit;
+            const reviewBatchLimit = typeof configuredReviewLimit === 'number' &&
+                Number.isInteger(configuredReviewLimit) &&
+                configuredReviewLimit > 0
+                ? configuredReviewLimit
+                : 1;
+            const firedTriggers = registry.listReviewCandidates(reviewBatchLimit);
+            const context = boundedReviewContext(this.recentEvents);
             for (const trigger of firedTriggers) {
-                const decision = await review(trigger, context);
-                const action = (0, trigger_review_js_1.applyReview)(decision, trigger.id, registry);
-                reviewed += 1;
-                log(`[trigger-loop] tick ${tick}: review trigger=${trigger.id} -> ${action}`);
+                try {
+                    const decision = await review(trigger, context);
+                    if (this.stopping)
+                        return result(events.length);
+                    const action = (0, trigger_review_js_1.applyReview)(decision, trigger.id, registry);
+                    if (action === 'kept') {
+                        registry.markReviewed(trigger.id, trigger.stats.fired);
+                    }
+                    reviewed += 1;
+                    log(`[trigger-loop] tick ${tick}: review trigger=${trigger.id} -> ${action}`);
+                }
+                catch (error) {
+                    if (this.stopping) {
+                        log(`[trigger-loop] tick ${tick}: review trigger=${trigger.id} cancelled by shutdown`);
+                        return result(events.length);
+                    }
+                    let backoffNote = 'backed off';
+                    try {
+                        registry.recordReviewFailure(trigger.id);
+                    }
+                    catch (stateError) {
+                        backoffNote = `state changed before backoff: ${stateError instanceof Error ? stateError.message : String(stateError)}`;
+                    }
+                    log(`[trigger-loop] tick ${tick}: review trigger=${trigger.id} FAILED; ${backoffNote}: ${error instanceof Error ? error.message : String(error)}`);
+                }
             }
         }
         // 5. Situational digest (M1.5 cadence, M2 window-aware): the agent composes it from the
         //    window + fire activity + recalled memory; the sink delivers it. Agent may reply NOTHING.
-        let reported = false;
+        if (this.stopping)
+            return result(events.length);
         const reportAsk = this.deps.reportAsk ?? askAgent;
         const reportEvery = config.reportEveryNTicks ?? 0;
         if (!this.isPendingReportWorkBlocked() &&
-            output &&
+            !this.pendingDelivery &&
+            reportSink &&
             reportEvery > 0 &&
             tick % reportEvery === 0 &&
             this.digest.hasActivity()) {
             reported = await this.prepareAndDeliverReport(reportAsk, 'digest', { kind: 'digest' });
+            if (this.stopping)
+                return result(events.length);
             log(`[trigger-loop] tick ${tick}: owner digest ${reported ? 'SENT' : 'suppressed by agent'}`);
         }
         // 6. Scheduled full report (M2): fires at configured LOCAL hours - even on a completely
@@ -451,8 +587,15 @@ class OperatorTriggerLoop {
         //    rely on the scheduled report arriving). Fires once per hour (markFired persists the
         //    hour key -> restart-safe). Send failure throws (no-fallback) WITHOUT marking the hour,
         //    so the next tick retries with the buffer intact.
-        let fullReported = false;
-        if (!recoveredPendingWork && !this.isPendingReportWorkBlocked() && output && reportScheduler) {
+        if (!this.stopping &&
+            !recoveredPendingWork &&
+            !this.isPendingReportWorkBlocked() &&
+            // An outstanding delivery (retry backoff or definite rejection) parks
+            // the scheduled leg WITHOUT consuming the hour: the coordinator drives
+            // the pending artifact to terminal, then the next due tick fires.
+            !this.pendingDelivery &&
+            reportSink &&
+            reportScheduler) {
             const { fire, hourKey } = reportScheduler.shouldFire(new Date());
             if (fire) {
                 // On-demand merge suppression (plan v6 S1-T3): an owner-requested full
@@ -478,11 +621,13 @@ class OperatorTriggerLoop {
                         hourKey,
                         firedAtIso,
                     });
+                    if (this.stopping)
+                        return result(events.length);
                     log(`[trigger-loop] tick ${tick}: full report ${fullReported ? 'SENT' : 'suppressed by agent'} (${hourKey})`);
                 }
             }
         }
-        return { tick, drained: events.length, fires, authored, reviewed, reported, fullReported };
+        return result(events.length);
     }
     /**
      * M2.4 freshness nudge: wake the loop to tick ~nudgeDebounceMs from now instead of waiting for the
@@ -493,8 +638,8 @@ class OperatorTriggerLoop {
      * a quiet window arms one timer; further nudges while it is armed are ignored, so a burst of poll
      * batches collapses to a single extra tick. Busy-safe (agent-awareness.ts:343-346 mechanism): if a
      * tick is in flight when the timer fires, the nudge is skipped - never concurrent ticks; the
-     * uncommitted deltas simply wait for the next tick. Pure timing assist: it only changes WHEN an
-     * existing tick runs, never WHAT it does.
+     * uncommitted deltas simply wait for the next tick. The extra tick drains and reports, but does
+     * not advance author/review maintenance cadence.
      */
     /**
      * On-demand full report (plan v6 S1-T3): the owner's "give me the full
@@ -508,9 +653,10 @@ class OperatorTriggerLoop {
      * the delta anchor exactly like a scheduled run.
      */
     startFullReport() {
-        const output = this.deps.output;
+        if (this.stopping)
+            return { accepted: false, reason: 'unavailable' };
         const reportScheduler = this.deps.reportScheduler;
-        if (!output || this.isPendingReportWorkBlocked()) {
+        if (!this.hasReportSink() || this.isPendingReportWorkBlocked()) {
             return { accepted: false, reason: 'unavailable' };
         }
         if (this.running || this.pendingDelivery || this.pendingRequest) {
@@ -553,20 +699,14 @@ class OperatorTriggerLoop {
             this.deps.log(`[trigger-loop] on-demand full report could not be accepted durably: ${error instanceof Error ? error.message : String(error)}`);
             return { accepted: false, reason: 'unavailable' };
         }
-        this.running = true;
-        void this.preparePendingRequest()
-            .then((sent) => {
+        this.launchRun(this.preparePendingRequest().then((sent) => {
             this.deps.log(`[trigger-loop] on-demand full report ${sent ? 'SENT' : 'suppressed by agent'}`);
-        })
-            .catch((error) => {
-            this.deps.log(`[trigger-loop] on-demand full report FAILED: ${error instanceof Error ? error.message : String(error)}`);
-        })
-            .finally(() => {
-            this.running = false;
-        });
+        }), 'on-demand full report FAILED');
         return { accepted: true };
     }
     nudge() {
+        if (this.stopping)
+            return;
         if (this.nudgeTimer)
             return; // already armed - debounce collapses the burst
         const configured = this.deps.config.nudgeDebounceMs;
@@ -579,14 +719,7 @@ class OperatorTriggerLoop {
                 this.deps.log('[trigger-loop] nudge: tick already running - skipped (deltas wait for next tick)');
                 return;
             }
-            this.running = true;
-            void this.tick()
-                .catch((error) => {
-                this.deps.log(`[trigger-loop] nudge tick failed: ${error instanceof Error ? error.message : String(error)}`);
-            })
-                .finally(() => {
-                this.running = false;
-            });
+            this.launchRun(this.tick({ advanceMaintenance: false }), 'nudge tick failed');
         }, debounceMs);
         this.nudgeTimer.unref?.();
     }
@@ -597,15 +730,10 @@ class OperatorTriggerLoop {
      */
     start() {
         const { config, log } = this.deps;
+        this.stopping = false;
+        this.schedulerActive = true;
         if ((this.pendingDelivery || this.pendingRequest) && !this.running) {
-            this.running = true;
-            void this.recoverPendingReportWork()
-                .catch((error) => {
-                log(`[trigger-loop] startup report recovery failed: ${error instanceof Error ? error.message : String(error)}`);
-            })
-                .finally(() => {
-                this.running = false;
-            });
+            this.launchRun(this.recoverPendingReportWork(), 'startup report recovery failed');
         }
         const handle = setInterval(() => {
             // The INTERVAL is the leg: it beats even while a long tick (full
@@ -613,29 +741,94 @@ class OperatorTriggerLoop {
             // on live. A loop mid-tick is alive, not silent.
             (0, leg_cadence_js_1.getLegCadence)()?.beat('trigger-loop');
             if (this.running) {
+                this.maintenancePending = true;
                 log('[trigger-loop] tick skipped: previous tick still running');
                 return;
             }
-            this.running = true;
-            void this.tick()
-                .catch((error) => {
-                log(`[trigger-loop] tick failed: ${error instanceof Error ? error.message : String(error)}`);
-            })
-                .finally(() => {
-                this.running = false;
-            });
+            this.launchRun(this.tick(), 'tick failed');
         }, config.tickMs);
         handle.unref?.();
         log(`[trigger-loop] started (tick every ${config.tickMs}ms)`);
+        let stopPromise;
         return () => {
+            if (stopPromise)
+                return stopPromise;
+            this.stopping = true;
+            this.schedulerActive = false;
+            this.maintenancePending = false;
             clearInterval(handle);
             if (this.nudgeTimer) {
                 clearTimeout(this.nudgeTimer);
                 this.nudgeTimer = null;
             }
-            log('[trigger-loop] stopped');
+            stopPromise = (async () => {
+                const activeRun = this.activeRunPromise;
+                if (activeRun)
+                    await activeRun;
+                log('[trigger-loop] stopped');
+            })();
+            return stopPromise;
         };
     }
+    launchRun(work, failureLabel) {
+        this.running = true;
+        const tracked = work
+            .then(() => undefined)
+            .catch((error) => {
+            this.deps.log(`[trigger-loop] ${failureLabel}: ${error instanceof Error ? error.message : String(error)}`);
+        })
+            .finally(() => {
+            if (this.activeRunPromise === tracked)
+                this.activeRunPromise = null;
+            this.finishRun();
+        });
+        this.activeRunPromise = tracked;
+    }
+    finishRun() {
+        this.running = false;
+        if (!this.schedulerActive || !this.maintenancePending)
+            return;
+        this.maintenancePending = false;
+        this.launchRun(this.tick(), 'deferred maintenance tick failed');
+    }
 }
 exports.OperatorTriggerLoop = OperatorTriggerLoop;
+const REVIEW_CONTEXT_EVENT_CHARS = 500;
+const REVIEW_CONTEXT_TOTAL_CHARS = 8_000;
+function boundedReviewContext(events) {
+    const lines = [];
+    let used = 0;
+    for (const event of [...events].reverse()) {
+        const content = event.content
+            .trim()
+            .replace(/[\r\n]+/g, ' ')
+            .slice(0, REVIEW_CONTEXT_EVENT_CHARS);
+        const line = `[${event.channelId}] ${content}`;
+        if (used + line.length + 1 > REVIEW_CONTEXT_TOTAL_CHARS)
+            break;
+        lines.push(line);
+        used += line.length + 1;
+    }
+    const omitted = events.length - lines.length;
+    lines.reverse();
+    if (omitted > 0)
+        lines.unshift(`[... ${omitted} event(s) omitted by review input budget]`);
+    return lines;
+}
+function authorWindowFingerprint(events) {
+    const hash = (0, node_crypto_1.createHash)('sha256');
+    for (const event of events) {
+        hash.update(event.channel);
+        hash.update('\0');
+        hash.update(event.channelId);
+        hash.update('\0');
+        hash.update(String(event.eventIndexId ?? event.id));
+        hash.update('\0');
+        hash.update(String(event.createdAt));
+        hash.update('\0');
+        hash.update(event.content);
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
 //# sourceMappingURL=operator-trigger-loop.js.map