instar 1.3.232 → 1.3.233

package/dist/commands/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA0SH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA+wDD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAwgQtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA0SH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA+wDD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA6kQtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}

package/dist/commands/server.js

@@ -6252,7 +6252,8 @@ export async function startServer(options) {
                         const cl = config.monitoring.correctionLearning;
                         const { CorrectionLedger } = await import('../monitoring/CorrectionLedger.js');
                         const { LlmQueue } = await import('../monitoring/LlmQueue.js');
-                        const { CaptureRing, captureAndDistill, makeCaptureRateState, } = await import('../monitoring/CorrectionCaptureLoop.js');
+                        const { CaptureRing, captureAndDistill, drainBacklog, makeCaptureRateState, } = await import('../monitoring/CorrectionCaptureLoop.js');
+                        const { llmCircuitAvailable } = await import('../core/LlmCircuitBreaker.js');
                         const correctionLedger = new CorrectionLedger({
                             dbPath: path.join(config.stateDir, 'correction-ledger.db'),
                         });
@@ -6283,6 +6284,22 @@ export async function startServer(options) {
                             topicTtlMs: (cl.captureTopicTtlMinutes ?? 60) * 60_000,
                         });
                         const rateState = makeCaptureRateState();
+                        // Durable capture-backlog with retry (resilience extension). When the
+                        // Tier-1 distill is rate-limited/capacity-throttled, the pre-scrubbed
+                        // capture is PERSISTED here instead of dropped, then drained into the
+                        // ledger in a later LLM headroom window — so corrections survive
+                        // sustained throttling. ON when the feature is enabled; maxEntries:0
+                        // disables it (preserves the old drop-on-throttle behavior).
+                        const backlogMaxEntries = cl.captureBacklogMaxEntries ?? 200;
+                        const captureBacklog = backlogMaxEntries > 0
+                            ? new (await import('../monitoring/CorrectionCaptureBacklog.js')).CorrectionCaptureBacklog({
+                                dbPath: path.join(config.stateDir, 'correction-capture-backlog.db'),
+                                maxEntries: backlogMaxEntries,
+                                maxRetries: cl.captureBacklogMaxRetries ?? 3,
+                            })
+                            : null;
+                        const backlogTtlMs = (cl.captureBacklogTtlHours ?? 24) * 3_600_000;
+                        const backlogDrainPerTick = cl.captureBacklogDrainPerTick ?? 5;
                         // Audit sink — one structured line per capture decision. The rollout
                         // evidence filter keys on `correction-loop` in this file.
                         const correctionAuditPath = path.join(config.stateDir, 'logs', 'correction-learning-audit.jsonl');
@@ -6293,6 +6310,38 @@ export async function startServer(options) {
                             }
                             catch { /* @silent-fallback-ok — audit is best-effort */ }
                         };
+                        // Shared distill fn — used by BOTH the hot-path capture and the
+                        // off-hot-path backlog drainer (same per-sentinel LlmQueue + cap).
+                        const correctionDistill = (prompt) => correctionLlmQueue.enqueue('background', () => sharedIntelligence.evaluate(prompt, { model: 'fast', maxTokens: 400, temperature: 0, attribution: { component: 'server:correction-learning' } }), // attribution for /metrics/features
+                        0.3);
+                        // Off-hot-path drainer. Single-flight (a `draining` guard prevents an
+                        // overlapping drain from a near-simultaneous trigger) and fail-open
+                        // (drainBacklog itself never throws). Skips internally when the LLM
+                        // circuit is open / shedding (it would just re-fail every entry).
+                        let draining = false;
+                        const maybeDrainBacklog = () => {
+                            if (!captureBacklog || draining)
+                                return;
+                            if (!llmCircuitAvailable())
+                                return; // breaker open — don't even claim.
+                            draining = true;
+                            // void: NEVER awaited on any seam — fully detached.
+                            void (async () => {
+                                try {
+                                    await drainBacklog({
+                                        backlog: captureBacklog,
+                                        ledger: correctionLedger,
+                                        distill: correctionDistill,
+                                        llmAvailable: () => llmCircuitAvailable(),
+                                        ttlMs: backlogTtlMs,
+                                        audit: (e) => correctionAudit({ decision: e.decision, topicId: e.topicId, detail: e.detail }),
+                                    }, backlogDrainPerTick);
+                                }
+                                finally {
+                                    draining = false;
+                                }
+                            })();
+                        };
                         const beforeCorrectionCb = telegram.onMessageLogged;
                         telegram.onMessageLogged = (entry) => {
                             if (beforeCorrectionCb)
@@ -6307,13 +6356,13 @@ export async function startServer(options) {
                             void captureAndDistill({
                                 ring,
                                 ledger: correctionLedger,
-                                distill: (prompt) => correctionLlmQueue.enqueue('background', () => sharedIntelligence.evaluate(prompt, { model: 'fast', maxTokens: 400, temperature: 0, attribution: { component: 'server:correction-learning' } }), // attribution for /metrics/features
-                                0.3),
+                                distill: correctionDistill,
                                 shouldShed: () => {
                                     const r = quotaTracker?.getRecommendation();
                                     return r === 'critical' || r === 'stop';
                                 },
                                 rateCeiling: { maxPerWindow: cl.distillPerTopicRatePerMinute ?? 8, windowMs: 60_000 },
+                                backlog: captureBacklog,
                                 audit: correctionAudit,
                             }, {
                                 topicId: entry.topicId ?? null,
@@ -6322,9 +6371,27 @@ export async function startServer(options) {
                                 sessionId: entry.sessionName ?? null,
                                 deterministicWeight: verdict?.deterministicWeight ?? 0,
                                 isLearningSignal: verdict?.learningKind != null,
-                            }, rateState);
+                            }, rateState).then((decision) => {
+                                // DRAIN TRIGGER (off-hot-path): a real distill just succeeded →
+                                // the LLM has headroom RIGHT NOW, so opportunistically work down
+                                // the backlog. .then runs AFTER the fire-and-forget capture
+                                // resolves — it never blocks delivery. Skips internally if the
+                                // breaker is open.
+                                if (decision === 'recorded' || decision === 'noise')
+                                    maybeDrainBacklog();
+                            }).catch(() => { });
                         };
+                        // Belt-and-suspenders periodic tick: even with no live captures, a
+                        // throttle that has since lifted gets drained. Bounded + off-hot-path
+                        // + skipped while the breaker is open. unref()'d so it never holds the
+                        // process open. Only armed when the backlog is active.
+                        if (captureBacklog) {
+                            const backlogTimer = setInterval(() => maybeDrainBacklog(), 5 * 60_000);
+                            if (typeof backlogTimer.unref === 'function')
+                                backlogTimer.unref();
+                        }
                         globalThis.__instarCorrectionLearningWired = true;
+                        globalThis.__instarCorrectionCaptureBacklogWired = !!captureBacklog;
                         console.log(pc.green('  Correction & Preference Learning Sentinel wired (capture → distill → ledger; dark by default)'));
                     }
                     catch (err) {