@jungjaehoon/mama-os 0.53.0 → 0.57.0

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

@@ -1,827 +0,0 @@
-"use strict";
-/**
- * OperatorTriggerLoop - the live runtime of the trigger loop (M1-T3, extended for M2).
- *
- * A setInterval tick (NOT scheduler.addJob, which executes an agent prompt, not a callback;
- * precedent: connector-ingress-manual-memory-commit.ts:742) that:
- *   1. drains new deltas (at-least-once: commit only after processing),
- *   2. matches active triggers -> fires them (recall memoryQuery + surface) + recordFire,
- *   3. every authorEveryNTicks: the agent authors new triggers from the recent-events window,
- *   4. every reviewEveryNTicks: the agent reviews fired triggers (keep/refine/retire),
- *   5. every reportEveryNTicks: the agent composes a situational digest of the window (M2),
- *   6. at configured LOCAL hours: the agent composes a fuller scheduled report (M2).
- *
- * The loop itself performs only deterministic intake, trigger matching, recall, and reports.
- * Matched batches are handed durably to the MAMA owner-event agent for action.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperatorTriggerLoop = void 0;
-const trigger_matcher_js_1 = require("./trigger-matcher.js");
-const trigger_fire_js_1 = require("./trigger-fire.js");
-const trigger_author_js_1 = require("./trigger-author.js");
-const trigger_review_js_1 = require("./trigger-review.js");
-const situation_report_js_1 = require("./situation-report.js");
-const node_crypto_1 = require("node:crypto");
-const pending_report_store_js_1 = require("./pending-report-store.js");
-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;
-    pendingDelivery;
-    pendingRequest;
-    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;
-        // A report citation proves only that the trigger was discussed. Actual
-        // success/failure belongs to OwnerEventLoop and its durable effect receipt.
-        const recordTriggerUse = (ids) => {
-            for (const id of ids) {
-                deps.log(`[trigger-loop] report cited trigger=${id}; effect outcome owned by owner-event`);
-            }
-        };
-        this.digest = new situation_report_js_1.SituationReporter({ recordTriggerUse });
-        this.fullReporter = new situation_report_js_1.SituationReporter({
-            recordTriggerUse,
-            fullReportProvenance: deps.fullReportProvenance,
-            persistLastFullReport: deps.persistLastFullReport,
-        });
-        if (this.refreshPendingReportState() === 'quarantined') {
-            deps.log('[trigger-loop] owner-report work blocked until pending outbox quarantine is cleared');
-        }
-    }
-    /** Reloads one durable outcome so recovery can hydrate this live loop before report work. */
-    refreshPendingReportState() {
-        if (!this.hasReportSink()) {
-            return 'unavailable';
-        }
-        const store = this.deps.pendingReportStore;
-        if (!store?.loadOutcome) {
-            if (store?.loadStatus?.() === 'quarantined') {
-                return 'quarantined';
-            }
-            if (!this.pendingReportLegacyLoaded) {
-                const pending = store?.load() ?? null;
-                this.pendingReportLegacyLoaded = true;
-                if (pending) {
-                    this.digest.restore(pending.digest);
-                    this.fullReporter.restore(pending.full);
-                    this.pendingDelivery = pending.delivery;
-                    this.pendingRequest = pending.request;
-                    return 'ready';
-                }
-                this.pendingReportExpectation = { status: 'empty', revision: null };
-            }
-            return this.pendingDelivery || this.pendingRequest ? 'ready' : 'empty';
-        }
-        const outcome = store.loadOutcome();
-        if (outcome.status === 'quarantined') {
-            this.pendingReportExpectation = undefined;
-            return 'quarantined';
-        }
-        if (outcome.status === 'empty') {
-            this.pendingReportExpectation = outcome;
-            return 'empty';
-        }
-        if (this.pendingReportExpectation?.revision !== outcome.revision) {
-            this.digest.restore(outcome.state.digest);
-            this.fullReporter.restore(outcome.state.full);
-            this.pendingDelivery = outcome.state.delivery;
-            this.pendingRequest = outcome.state.request;
-            this.deps.log('[trigger-loop] refreshed durable pending owner-report buffer');
-        }
-        this.pendingReportExpectation = outcome;
-        return 'ready';
-    }
-    isPendingReportWorkBlocked() {
-        return this.refreshPendingReportState() === 'quarantined';
-    }
-    persistPendingReports() {
-        if (!this.hasReportSink())
-            return false;
-        if (this.refreshPendingReportState() === 'quarantined')
-            return false;
-        const state = {
-            version: 1,
-            digest: this.digest.snapshot(),
-            full: this.fullReporter.snapshot(),
-            ...(this.pendingDelivery ? { delivery: this.pendingDelivery } : {}),
-            ...(this.pendingRequest ? { request: this.pendingRequest } : {}),
-        };
-        try {
-            this.deps.pendingReportStore?.save(state, this.pendingReportExpectation);
-            this.refreshPendingReportState();
-            return true;
-        }
-        catch (error) {
-            this.refreshPendingReportState();
-            throw error;
-        }
-    }
-    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}`;
-        }
-        return `operator-report:${occurrence.kind}:${(0, node_crypto_1.randomUUID)()}`;
-    }
-    requireOutputTarget() {
-        const target = this.deps.reportTarget ?? this.deps.output?.target;
-        if (target?.source !== 'telegram' ||
-            target.channelId.length === 0 ||
-            target.channelId.trim() !== target.channelId) {
-            throw new Error('Owner-report output is missing its canonical Telegram target binding');
-        }
-        return target;
-    }
-    assertPendingTarget(target, phase) {
-        const configured = this.requireOutputTarget();
-        if (target.source !== configured.source || target.channelId !== configured.channelId) {
-            throw new Error(`Pending owner-report ${phase} target ${target.channelId} does not match configured target ${configured.channelId}`);
-        }
-    }
-    assertPendingDeliveryBinding(delivery) {
-        this.assertPendingTarget(delivery.target, 'delivery');
-        const expected = (0, pending_report_store_js_1.pendingReportDeliveryPayloadIdentity)(delivery);
-        if (delivery.payloadIdentity !== expected) {
-            throw new Error(`Pending owner-report delivery ${delivery.deliveryId} payload identity mismatch`);
-        }
-    }
-    assertPendingRequestBinding(request) {
-        this.assertPendingTarget(request.target, 'request');
-        const expected = (0, pending_report_store_js_1.pendingReportRequestPayloadIdentity)(request);
-        if (request.payloadIdentity !== expected) {
-            throw new Error(`Pending owner-report request ${request.deliveryId} payload identity mismatch`);
-        }
-    }
-    async deliverPendingReport(recovered) {
-        const pending = this.pendingDelivery;
-        if (!pending || !this.hasReportSink()) {
-            return null;
-        }
-        this.assertPendingDeliveryBinding(pending);
-        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 (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) {
-            this.deps.log(`[trigger-loop] recovered pending ${pending.mode} owner report delivery=${pending.deliveryId}`);
-        }
-        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(mode, occurrence) {
-        if (!this.hasReportSink() || this.isPendingReportWorkBlocked()) {
-            return false;
-        }
-        if (this.pendingDelivery) {
-            throw new Error('A pending owner report must be recovered before composing another report');
-        }
-        const target = this.requireOutputTarget();
-        const deliveryId = this.deliveryIdFor(occurrence);
-        const request = {
-            mode,
-            deliveryId,
-            occurrence,
-            acceptedAtIso: occurrence.firedAtIso ?? new Date().toISOString(),
-            target,
-        };
-        this.pendingRequest = {
-            ...request,
-            payloadIdentity: (0, pending_report_store_js_1.pendingReportRequestPayloadIdentity)(request),
-        };
-        if (!this.persistPendingReports())
-            return false;
-        return this.preparePendingRequest();
-    }
-    reportOutcomeLabel(delivered) {
-        return delivered ? 'SENT' : this.pendingDelivery ? 'pending delivery' : 'not delivered';
-    }
-    async preparePendingRequest() {
-        const request = this.pendingRequest;
-        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');
-        }
-        this.assertPendingRequestBinding(request);
-        const reportAsk = this.deps.reportAsk;
-        if (!reportAsk?.compose) {
-            throw new Error('Owner runtime report capability is unavailable');
-        }
-        const prepared = await this.reporterFor(request.mode).prepareReport((prompt) => reportAsk.compose({
-            prompt,
-            sourceMessageRef: `owner-report:${request.deliveryId}`,
-            requestKind: request.occurrence.kind,
-        }), request.mode, request.deliveryId);
-        if (!prepared) {
-            this.pendingRequest = undefined;
-            this.persistPendingReports();
-            return false;
-        }
-        const delivery = {
-            ...prepared,
-            deliveryId: request.deliveryId,
-            occurrence: request.occurrence,
-            target: request.target,
-        };
-        this.pendingDelivery = {
-            ...delivery,
-            payloadIdentity: (0, pending_report_store_js_1.pendingReportDeliveryPayloadIdentity)(delivery),
-        };
-        this.pendingRequest = undefined;
-        if (!this.persistPendingReports()) {
-            return false;
-        }
-        return (await this.deliverPendingReport(false)) !== null;
-    }
-    async recoverPendingReportWork() {
-        if (this.isPendingReportWorkBlocked())
-            return false;
-        const delivered = await this.deliverPendingReport(true);
-        let recovered = delivered !== null;
-        if (this.pendingRequest) {
-            // Capture the mode before preparePendingRequest() clears the pending request; a recovered
-            // digest request also reaches this path, so a hardcoded "full" would misreport it.
-            const mode = this.pendingRequest.mode;
-            const sent = await this.preparePendingRequest();
-            recovered = true;
-            this.deps.log(`[trigger-loop] recovered ${mode} report ${this.reportOutcomeLabel(sent)}`);
-        }
-        return recovered;
-    }
-    async tick(options = {}) {
-        const { delta, memory, registry, askAgent, review, config, log } = this.deps;
-        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 = reportSink
-            ? events.filter((event) => !this.digest.hasRecordedEvent(event))
-            : events;
-        if (events.length > 0) {
-            log(`[trigger-loop] tick ${tick}: drained ${events.length} events`);
-        }
-        const signalsByEvent = new Map();
-        for (const event of events) {
-            signalsByEvent.set(event, (0, trigger_matcher_js_1.matchTriggers)(event, registry));
-        }
-        // 2. Match + fire + recordFire, folding fire activity into the report accumulators.
-        for (const event of reportEvents) {
-            const signals = signalsByEvent.get(event) ?? [];
-            for (const signal of signals) {
-                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 (reportSink) {
-                    this.digest.recordFire({
-                        triggerId: signal.triggerId ?? signal.detector,
-                        kind: signal.kind,
-                        channelId: signal.channelId,
-                        recalled: fireResult.recalled,
-                    });
-                }
-                if (fullLegOn) {
-                    this.fullReporter.recordFire({
-                        triggerId: signal.triggerId ?? signal.detector,
-                        kind: signal.kind,
-                        channelId: signal.channelId,
-                        recalled: fireResult.recalled,
-                    });
-                }
-                log(`[trigger-loop] tick ${tick}: fire trigger=${signal.triggerId ?? signal.detector} ` +
-                    `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 (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 owner-event inbox
-        // persists each group pre-commit, and the same groups feed the post-commit
-        // reconcile callback.
-        const channelBatches = [];
-        if (events.length > 0 && this.deps.ownerEventInbox) {
-            const byChannel = new Map();
-            // Report dedupe and board reconciliation have different durability
-            // boundaries. A report snapshot may already contain a replayed event,
-            // while the board callback did not run before the prior crash. Always
-            // replay committed connector rows into reconciliation; that layer owns
-            // its own bounded coalescing/idempotency.
-            for (const event of events) {
-                const key = `${event.channel}:${event.channelId}`;
-                const bucket = byChannel.get(key) ?? [];
-                bucket.push(event);
-                byChannel.set(key, bucket);
-            }
-            for (const [channelKey, channelEvents] of byChannel) {
-                // The prompt shows the last 10; the CAUSE is the whole batch. Truncating both
-                // would silently drop events the run acted on from the record of why it acted.
-                // Embedded newlines are collapsed: a message body containing "\n[/UNTRUSTED..."
-                // must not be able to forge line or block framing downstream.
-                const shown = channelEvents.slice(-10);
-                const lines = shown.map((e) => `- [id:${e.eventIndexId ?? e.id}] ${e.userId}: ${e.content
-                    .trim()
-                    .replace(/[\r\n]+/g, ' ')
-                    .slice(0, 200)}`);
-                // Inbox identity must cover EVERY event or dedupe cannot absorb a
-                // redelivery. The fallback is NAMESPACED: bare delta row ids from two
-                // different channels (or after a VACUUM renumbering) must not collide
-                // in the global dedupe PK.
-                const inboxEventIds = channelEvents.map((e) => e.eventIndexId ?? `raw:${channelKey}:${e.id}`);
-                const activationsById = new Map();
-                for (const signal of channelEvents.flatMap((event) => signalsByEvent.get(event) ?? [])) {
-                    if (!signal.triggerId || activationsById.has(signal.triggerId))
-                        continue;
-                    activationsById.set(signal.triggerId, {
-                        triggerId: signal.triggerId,
-                        kind: signal.kind,
-                        memoryQuery: signal.memoryQuery,
-                        ...(signal.procedureRef ? { procedureRef: { ...signal.procedureRef } } : {}),
-                        procedure: signal.procedure.map((step) => ({ ...step })),
-                        requiredEvidence: [...signal.requiredEvidence],
-                    });
-                }
-                channelBatches.push({
-                    channelKey,
-                    lines,
-                    inboxEventIds,
-                    activations: [...activationsById.values()],
-                });
-            }
-        }
-        // S1: durable BEFORE the cursor advances. Deliberately NOT wrapped in
-        // try/catch - an inbox write failure must fail the tick before commit so
-        // the batch redelivers next drain. Fail loud, lose nothing.
-        if (this.deps.ownerEventInbox) {
-            for (const b of channelBatches) {
-                this.deps.ownerEventInbox.enqueue({
-                    channelKey: b.channelKey,
-                    eventIds: b.inboxEventIds,
-                    lines: b.lines,
-                    activations: b.activations,
-                });
-            }
-        }
-        delta.commit(events);
-        // 3. Agent authors new triggers from the recent window.
-        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)`);
-                }
-                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)}`);
-                }
-            }
-        }
-        // 4. Agent reviews triggers that have actually fired.
-        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) {
-                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, trigger.revision);
-                    if (action === 'kept') {
-                        registry.markReviewed(trigger.id, trigger.stats.fired, trigger.revision);
-                    }
-                    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.
-        if (this.stopping)
-            return result(events.length);
-        const reportEvery = config.reportEveryNTicks ?? 0;
-        if (!this.isPendingReportWorkBlocked() &&
-            !this.pendingDelivery &&
-            reportSink &&
-            reportEvery > 0 &&
-            tick % reportEvery === 0 &&
-            this.digest.hasActivity()) {
-            reported = await this.prepareAndDeliverReport('digest', { kind: 'digest' });
-            if (this.stopping)
-                return result(events.length);
-            log(`[trigger-loop] tick ${tick}: owner digest ${this.reportOutcomeLabel(reported)}`);
-        }
-        // 6. Scheduled full report (M2): fires at configured LOCAL hours - even on a completely
-        //    quiet window (M2.1 aliveness: the agent reports "quiet" instead of skipping; owners
-        //    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.
-        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
-                // report minutes before the scheduled hour makes the scheduled fire a
-                // near-empty duplicate. Skip-and-CONSUME (markFired) - the on-demand
-                // report WAS this hour's report; defer semantics would re-fire later
-                // ticks in the same hour.
-                const lastSuccess = reportScheduler.loadLastSuccess();
-                const minIntervalMs = config.fullReportMinIntervalMs ?? 30 * 60_000;
-                const sinceSuccessMs = lastSuccess ? Date.now() - Date.parse(lastSuccess) : Infinity;
-                if (Number.isFinite(sinceSuccessMs) && sinceSuccessMs < minIntervalMs) {
-                    reportScheduler.markFired(hourKey);
-                    log(`[trigger-loop] tick ${tick}: full report skipped - last success ${lastSuccess} ` +
-                        `within min interval (hour ${hourKey} consumed)`);
-                }
-                else {
-                    // Anchor = FIRE time, captured BEFORE the run: anchoring at completion would
-                    // leave a gap (messages arriving while the run executes fall after the gather
-                    // but before a completion-time anchor). Overlap is tolerable; gaps are not.
-                    const firedAtIso = new Date().toISOString();
-                    fullReported = await this.prepareAndDeliverReport('full', {
-                        kind: 'scheduled_full',
-                        hourKey,
-                        firedAtIso,
-                    });
-                    if (this.stopping)
-                        return result(events.length);
-                    log(`[trigger-loop] tick ${tick}: full report ${this.reportOutcomeLabel(fullReported)} (${hourKey})`);
-                }
-            }
-        }
-        return result(events.length);
-    }
-    /**
-     * M2.4 freshness nudge: wake the loop to tick ~nudgeDebounceMs from now instead of waiting for the
-     * next scheduled interval. The connector sink calls this (via a forwarder) whenever a poll batch
-     * indexes new rows.
-     *
-     * Debounced (Kagemusha fast-flush port, agent-awareness.ts:322-332 mechanism): the FIRST nudge in
-     * 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. 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
-     * report" intent routed to the SAME machinery as the scheduled leg - same
-     * reporter, same anchor semantics, same serial guard. Host-code entry
-     * (gateway forwarder hook); the run itself is fire-and-forget so the chat
-     * turn that triggered it is never blocked (and never nests lane runs).
-     *
-     * Consume semantics: success marks the current hourKey fired, so a
-     * scheduled fire in the same hour does not duplicate; markSuccess advances
-     * the delta anchor exactly like a scheduled run.
-     */
-    startFullReport() {
-        if (this.stopping)
-            return { accepted: false, reason: 'unavailable' };
-        const reportScheduler = this.deps.reportScheduler;
-        if (!this.hasReportSink() || this.isPendingReportWorkBlocked()) {
-            return { accepted: false, reason: 'unavailable' };
-        }
-        if (this.running || this.pendingDelivery || this.pendingRequest) {
-            return { accepted: false, reason: 'busy' };
-        }
-        const firedAtIso = new Date().toISOString();
-        const hourKey = reportScheduler?.shouldFire(new Date()).hourKey;
-        const occurrence = {
-            kind: 'on_demand_full',
-            ...(hourKey ? { hourKey } : {}),
-            firedAtIso,
-        };
-        let target;
-        try {
-            target = this.requireOutputTarget();
-        }
-        catch (error) {
-            this.deps.log(`[trigger-loop] on-demand full report target binding unavailable: ${error instanceof Error ? error.message : String(error)}`);
-            return { accepted: false, reason: 'unavailable' };
-        }
-        const request = {
-            mode: 'full',
-            deliveryId: this.deliveryIdFor(occurrence),
-            occurrence,
-            acceptedAtIso: firedAtIso,
-            target,
-        };
-        this.pendingRequest = {
-            ...request,
-            payloadIdentity: (0, pending_report_store_js_1.pendingReportRequestPayloadIdentity)(request),
-        };
-        try {
-            if (!this.persistPendingReports()) {
-                this.pendingRequest = undefined;
-                return { accepted: false, reason: 'unavailable' };
-            }
-        }
-        catch (error) {
-            this.pendingRequest = undefined;
-            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.launchRun(this.preparePendingRequest().then((sent) => {
-            this.deps.log(`[trigger-loop] on-demand full report ${this.reportOutcomeLabel(sent)}`);
-        }), '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;
-        const debounceMs = typeof configured === 'number' && Number.isFinite(configured) && configured >= 0
-            ? configured
-            : 15_000;
-        this.nudgeTimer = setTimeout(() => {
-            this.nudgeTimer = null;
-            if (this.running) {
-                this.deps.log('[trigger-loop] nudge: tick already running - skipped (deltas wait for next tick)');
-                return;
-            }
-            this.launchRun(this.tick({ advanceMaintenance: false }), 'nudge tick failed');
-        }, debounceMs);
-        this.nudgeTimer.unref?.();
-    }
-    /**
-     * Start ticking on the configured interval. Returns a stop function.
-     * The interval wrapper catches + logs tick errors so one bad tick does not kill the loop
-     * (the error is still surfaced loudly in the log - not swallowed).
-     */
-    start() {
-        const { config, log } = this.deps;
-        this.stopping = false;
-        this.schedulerActive = true;
-        if ((this.pendingDelivery || this.pendingRequest) && !this.running) {
-            this.launchRun(this.recoverPendingReportWork(), 'startup report recovery failed');
-        }
-        const handle = setInterval(() => {
-            // The INTERVAL is the leg: it beats even while a long tick (full
-            // report) is still running - same flap the workorder consumer paged
-            // 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.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;
-            }
-            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