instar 1.2.31 → 1.2.33

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;AAkQH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAiqDD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAm9KtE;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;AAkQH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAiqDD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAyjLtE;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

@@ -3722,7 +3722,7 @@ export async function startServer(options) {
         // Creates mid-session mini-digests via LLM, and session syntheses on completion.
         let activitySentinel;
         if (sharedIntelligence) {
-            const { SessionActivitySentinel } = await import('../monitoring/SessionActivitySentinel.js');
+            const { SessionActivitySentinel, resolveSentinelScanIntervalMs } = await import('../monitoring/SessionActivitySentinel.js');
             activitySentinel = new SessionActivitySentinel({
                 stateDir: config.stateDir,
                 intelligence: sharedIntelligence,
@@ -3753,6 +3753,35 @@ export async function startServer(options) {
                     console.error(`[ActivitySentinel] Synthesis failed for ${session.name}: ${err instanceof Error ? err.message : err}`);
                 });
             });
+            // Periodic mid-session scan. Without this, the sentinel only digests on
+            // sessionComplete — so a long-running Telegram session that never cleanly
+            // ends (compaction, multi-day topic, machine restart) accumulates hours
+            // of activity that is never digested, and the entities within it never
+            // reach SemanticMemory. The periodic scan digests in-flight activity on a
+            // cadence so the knowledge graph grows throughout long sessions, not just
+            // at the end. scan() is internally idempotent (hash-keyed digests),
+            // skips dormant sessions, and enforces a minimum-activity threshold, so a
+            // frequent cadence is safe.
+            const scanIntervalMs = resolveSentinelScanIntervalMs(config.monitoring.episodicSentinel);
+            if (scanIntervalMs !== null) {
+                const scanMinutes = Math.round(scanIntervalMs / 60_000);
+                const activityScanTimer = setInterval(() => {
+                    // Only the awake machine scans — mirrors the scheduler gating so
+                    // standby machines in a multi-machine setup don't double-digest.
+                    if (coordinator.enabled && !coordinator.isAwake)
+                        return;
+                    activitySentinel.scan().then((report) => {
+                        if (report.digestsCreated > 0) {
+                            console.log(`[ActivitySentinel] Periodic scan: ${report.digestsCreated} digest(s) across ${report.sessionsScanned} session(s)`);
+                        }
+                    }).catch((err) => {
+                        console.error(`[ActivitySentinel] Periodic scan failed: ${err instanceof Error ? err.message : err}`);
+                    });
+                }, scanIntervalMs);
+                if (activityScanTimer.unref)
+                    activityScanTimer.unref();
+                console.log(pc.dim(`  Episodic memory sentinel: periodic scan every ${scanMinutes}min`));
+            }
             const semStatus = semanticMemory ? 'with entity extraction' : 'digests only (no SemanticMemory)';
             console.log(pc.green(`  Episodic memory sentinel enabled (LLM-powered digestion, ${semStatus})`));
         }
@@ -4552,7 +4581,68 @@ export async function startServer(options) {
         }, 
         // Defaults are production-sensible; override here only if needed.
         {});
-        sessionManager.setActiveRecoveryChecker(session => compactionSentinel.isRecoveryActive(session.tmuxSession));
+        // ── RateLimitSentinel ─────────────────────────────────────────────
+        // Rides out Anthropic's server-side capacity throttle ("Server is
+        // temporarily limiting requests · not your usage limit") with
+        // backoff-before-nudge + user check-ins, instead of the single immediate
+        // nudge (quota burn) → silence the session used to fall into. See
+        // docs/specs/rate-limit-sentinel.md.
+        const { RateLimitSentinel } = await import('../monitoring/RateLimitSentinel.js');
+        const getClaudeSessionIdForName = (sessionName) => sessionManager.listRunningSessions().find(s => s.tmuxSession === sessionName)?.claudeSessionId;
+        // Neutral "continue" nudge — NOT the compaction-resume payload (which would
+        // falsely tell the agent its memory was reset). Topic-tagged so InputGuard
+        // accepts it.
+        const rateLimitResume = async (sessionName) => {
+            if (!sessionManager.isSessionAlive(sessionName))
+                return false;
+            const topicId = telegram?.getTopicForSession(sessionName);
+            if (topicId == null)
+                return false;
+            const tagged = `[telegram:${topicId}] The temporary server throttle should have cleared — please continue where you left off.`;
+            return sessionManager.injectMessage(sessionName, tagged);
+        };
+        // Route a user-facing notice for the session's topic (Telegram).
+        const rateLimitNotify = async (sessionName, text) => {
+            const topicId = telegram?.getTopicForSession(sessionName);
+            if (topicId == null)
+                return;
+            const resp = await fetch(`http://localhost:${config.port}/telegram/reply/${topicId}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${config.authToken}` },
+                body: JSON.stringify({ text }),
+            });
+            if (!resp.ok)
+                throw new Error(`rate-limit notify failed: ${resp.status}`);
+        };
+        const rlsCfg = config.monitoring?.rateLimitSentinel ?? { enabled: true };
+        const rateLimitSentinel = new RateLimitSentinel({
+            resumeFn: rateLimitResume,
+            notifyFn: rateLimitNotify,
+            projectDir: config.projectDir,
+            getClaudeSessionId: getClaudeSessionIdForName,
+        }, rlsCfg);
+        // Zombie-kill veto: compose BOTH sentinels (editing the single-predicate
+        // checker — a second setActiveRecoveryChecker call would drop the
+        // compaction veto).
+        sessionManager.setActiveRecoveryChecker(session => compactionSentinel.isRecoveryActive(session.tmuxSession) ||
+            rateLimitSentinel.isRecoveryActive(session.tmuxSession));
+        // Bidirectional deferral — neither sentinel injects into a pane the other
+        // already owns.
+        rateLimitSentinel.setDeferIf(s => compactionSentinel.isRecoveryActive(s));
+        compactionSentinel.setDeferIf(s => rateLimitSentinel.isRecoveryActive(s));
+        // Triggers: watchdog poll + SessionManager idle-error emit. Both deduped by
+        // the sentinel.
+        if (watchdog) {
+            watchdog.on('rate-limited', (sessionName) => {
+                rateLimitSentinel.report(sessionName, 'watchdog-poll');
+            });
+        }
+        sessionManager.on('rateLimitedAtIdle', (sessionName) => {
+            rateLimitSentinel.report(sessionName, 'idle-error');
+        });
+        if (rlsCfg.enabled !== false) {
+            console.log(pc.green('  RateLimitSentinel enabled (server-throttle backoff + check-ins)'));
+        }
         console.log(pc.green('  CompactionSentinel enabled (verified recovery lifecycle)'));
         // Trigger 1: PreCompact hook event — report to sentinel.
         hookEventReceiver.on('PreCompact', () => {
@@ -4989,6 +5079,15 @@ export async function startServer(options) {
                     // BUILD-STALL-VISIBILITY-SPEC Fix 2 — suppress generic standby when
                     // a /build heartbeat landed recently on this topic.
                     hasRecentBuildHeartbeat: (topicId, windowMs) => proxyCoordinator.hasRecentBuildHeartbeat(topicId, windowMs),
+                    // Suppress ALL tiers while the RateLimitSentinel owns the voice for
+                    // this topic's session (server-throttle recovery).
+                    hasActiveRateLimitRecovery: (topicId) => {
+                        const slackChId = slackProxyChannelMap.get(topicId);
+                        const sessionName = (slackChId && _slackAdapter)
+                            ? _slackAdapter.getSessionForChannel(slackChId)
+                            : telegram.getSessionForTopic(topicId);
+                        return sessionName ? rateLimitSentinel.isRecoveryActive(sessionName) : false;
+                    },
                     // Shared LLM queue (interactive lane) — cross-monitor concurrency
                     // and daily-spend-cap with PromiseBeacon.
                     sharedLlmQueue,
@@ -6583,7 +6682,7 @@ export async function startServer(options) {
                 },
             });
         }
-        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, feedbackAnomalyDetector, dispatches, updateChecker, autoUpdater, autoDispatcher, quotaTracker, quotaManager, publisher, viewer, tunnel, evolution, watchdog, topicMemory, triageNurse, projectMapper, coherenceGate: scopeVerifier, contextHierarchy, canonicalState, operationGate, sentinel, adaptiveTrust, memoryMonitor, orphanReaper, coherenceMonitor, commitmentTracker, semanticMemory, activitySentinel, messageRouter, summarySentinel, spawnManager, systemReviewer, capabilityMapper, selfKnowledgeTree, coverageAuditor, topicResumeMap: _topicResumeMap ?? undefined, sessionRefresh: _sessionRefresh ?? undefined, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, whatsapp: whatsappAdapter, slack: slackAdapter, imessage: imessageAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, threadlineRouter, threadResumeMap, topicLinkageHandler: topicLinkageHandler ?? undefined, threadlineRelayClient, threadlineReplyWaiters, listenerManager: listenerManager ?? undefined, responseReviewGate, messagingToneGate, outboundDedupGate, telemetryHeartbeat, pasteManager, featureRegistry, discoveryEvaluator, unifiedTrust, liveConfig, sharedStateLedger, ledgerSessionRegistry, worktreeManager, oidcEnrolledRepos: parallelDevConfig?.oidcEnrolledRepos, initiativeTracker, projectRoundRunner, projectDriftChecker, machineHeartbeat, proxyCoordinator, telegramBridgeConfig, telegramBridge: telegramBridge ?? undefined, threadlineObservability, workingMemory, taskFlowRegistry, threadlineFlowBridge });
+        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, feedbackAnomalyDetector, dispatches, updateChecker, autoUpdater, autoDispatcher, quotaTracker, quotaManager, publisher, viewer, tunnel, evolution, watchdog, topicMemory, triageNurse, projectMapper, coherenceGate: scopeVerifier, contextHierarchy, canonicalState, operationGate, sentinel, adaptiveTrust, memoryMonitor, orphanReaper, coherenceMonitor, commitmentTracker, semanticMemory, activitySentinel, rateLimitSentinel, messageRouter, summarySentinel, spawnManager, systemReviewer, capabilityMapper, selfKnowledgeTree, coverageAuditor, topicResumeMap: _topicResumeMap ?? undefined, sessionRefresh: _sessionRefresh ?? undefined, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, whatsapp: whatsappAdapter, slack: slackAdapter, imessage: imessageAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, threadlineRouter, threadResumeMap, topicLinkageHandler: topicLinkageHandler ?? undefined, threadlineRelayClient, threadlineReplyWaiters, listenerManager: listenerManager ?? undefined, responseReviewGate, messagingToneGate, outboundDedupGate, telemetryHeartbeat, pasteManager, featureRegistry, discoveryEvaluator, unifiedTrust, liveConfig, sharedStateLedger, ledgerSessionRegistry, worktreeManager, oidcEnrolledRepos: parallelDevConfig?.oidcEnrolledRepos, initiativeTracker, projectRoundRunner, projectDriftChecker, machineHeartbeat, proxyCoordinator, telegramBridgeConfig, telegramBridge: telegramBridge ?? undefined, threadlineObservability, workingMemory, taskFlowRegistry, threadlineFlowBridge });
         await server.start();
         void taskFlowSweeper;
         void taskFlowDueWaker;