instar 0.28.61 → 0.28.62

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;AA2PH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA81CD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA8+ItE;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;AA4PH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA81CD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAsjJtE;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

@@ -45,6 +45,7 @@ import { QuotaNotifier } from '../monitoring/QuotaNotifier.js';
 import { QuotaManager } from '../monitoring/QuotaManager.js';
 import { classifySessionDeath } from '../monitoring/QuotaExhaustionDetector.js';
 import { SessionWatchdog } from '../monitoring/SessionWatchdog.js';
+import { formatWatchdogUserMessage } from '../monitoring/watchdog-notifications.js';
 import { StallTriageNurse } from '../monitoring/StallTriageNurse.js';
 import { TriageOrchestrator } from '../monitoring/TriageOrchestrator.js';
 import { SessionMonitor } from '../monitoring/SessionMonitor.js';
@@ -3156,33 +3157,26 @@ export async function startServer(options) {
             watchdog = new SessionWatchdog(config, sessionManager, state);
             watchdog.intelligence = sharedIntelligence ?? null;
             watchdog.on('intervention', (event) => {
-                const levelNames = ['Monitoring', 'Ctrl+C', 'SIGTERM', 'SIGKILL', 'Kill Session'];
-                const levelName = levelNames[event.level] || `Level ${event.level}`;
-                const msg = `🔧 Watchdog [${levelName}]: ${event.action}\nStuck: \`${event.stuckCommand.slice(0, 60)}\``;
+                // Routine recovery (Ctrl+C, SIGTERM) stays as console diagnostics only.
+                // The user only hears when we had to force-kill (SIGKILL / session-kill) —
+                // that's the "actual issue" threshold. See watchdog-notifications.ts.
+                const userMsg = formatWatchdogUserMessage(event);
+                if (!userMsg)
+                    return;
                 if (telegram) {
                     const topicId = telegram.getTopicForSession(event.sessionName);
                     if (topicId)
-                        telegram.sendToTopic(topicId, msg).catch(() => { });
+                        telegram.sendToTopic(topicId, userMsg).catch(() => { });
                 }
                 if (_slackAdapter) {
                     const channelId = _slackAdapter.getChannelForSession(event.sessionName);
                     if (channelId)
-                        _slackAdapter.sendToChannel(channelId, msg).catch(() => { });
-                }
-            });
-            watchdog.on('recovery', (sessionName, fromLevel) => {
-                const msg = `✅ Watchdog: session recovered (was at escalation level ${fromLevel})`;
-                if (telegram) {
-                    const topicId = telegram.getTopicForSession(sessionName);
-                    if (topicId)
-                        telegram.sendToTopic(topicId, msg).catch(() => { });
-                }
-                if (_slackAdapter) {
-                    const channelId = _slackAdapter.getChannelForSession(sessionName);
-                    if (channelId)
-                        _slackAdapter.sendToChannel(channelId, msg).catch(() => { });
+                        _slackAdapter.sendToChannel(channelId, userMsg).catch(() => { });
                 }
             });
+            // Recovery events stay silent to the user. If we didn't announce the
+            // problem (Ctrl+C / SIGTERM are now silent), announcing recovery is
+            // noise. Intervention log still records it for diagnostics.
             watchdog.start();
             console.log(pc.green('  Session Watchdog enabled'));
         }
@@ -4850,7 +4844,14 @@ export async function startServer(options) {
         summarySentinel.start();
         messageRouter.setSummarySentinel(summarySentinel);
         // On-demand session spawning for message delivery (Phase 5)
-        const spawnManager = new SpawnRequestManager({
+        // §4.4: spawn knobs are read from config.threadline.spawn — see
+        // ThreadlineSpawnConfig in core/types.ts. All fields are optional and
+        // fall through to manager-level defaults if absent.
+        const spawnConfig = config.threadline?.spawn;
+        // Forward-declared `let` so the onDrainReady callback can reference the
+        // manager it belongs to (for re-entrant evaluate() calls during drain).
+        let spawnManager;
+        spawnManager = new SpawnRequestManager({
             maxSessions: config.sessions.maxSessions ?? 5,
             getActiveSessions: () => sessionManager.listRunningSessions(),
             spawnSession: async (prompt, opts) => {
@@ -4859,7 +4860,9 @@ export async function startServer(options) {
                     prompt,
                     model: opts?.model,
                     maxDurationMinutes: opts?.maxDurationMinutes,
-                    triggeredBy: 'spawn-request',
+                    // §4.5: honor SpawnRequestManager's provenance tag so drain-spawned
+                    // sessions are distinguishable from inline-spawned ones in logs/stream.
+                    triggeredBy: opts?.triggeredBy ?? 'spawn-request',
                 });
                 return session.id;
             },
@@ -4872,7 +4875,74 @@ export async function startServer(options) {
             onEscalate: (request, reason) => {
                 notify('IMMEDIATE', 'messaging', `Spawn escalation: ${reason}\n  Requester: ${request.requester.agent}\n  Target: ${request.target.agent}`);
             },
+            // §4.5: emit degradation breadcrumbs on edge transitions.
+            onDegradation: (event) => {
+                try {
+                    const reporter = DegradationReporter.getInstance();
+                    if (event.kind === 'spawn-penalty-tripped') {
+                        reporter.report({
+                            feature: 'Threadline.SpawnPenalty',
+                            primary: `Open spawn slot for peer "${event.agent}"`,
+                            fallback: `Spawn blocked for ${Math.round(event.penaltyMs / 1000)}s after ${event.consecutiveFailures} consecutive agent-attributable failures`,
+                            reason: `Peer "${event.agent}" tripped the consecutive-failure penalty (3 strikes)`,
+                            impact: 'Peer cannot spawn sessions until penalty clears. Successful inbound spawn from a different peer is unaffected.',
+                        });
+                    }
+                    else if (event.kind === 'spawn-infra-degraded') {
+                        reporter.report({
+                            feature: 'Threadline.SpawnInfraDegraded',
+                            primary: `Full queue admission (cap 10) for peer "${event.agent}"`,
+                            fallback: `Degraded admission (cap ${spawnConfig?.degradedMaxQueuedPerAgent ?? 1}) for ${Math.round(event.degradationMs / 60_000)}min`,
+                            reason: `Peer "${event.agent}" tripped the infra-failure soft limiter (${event.failureCount} non-attributable failures in 10min)`,
+                            impact: 'Peer\'s queue depth is capped; older messages are dropped. No blame attribution.',
+                        });
+                    }
+                }
+                catch (err) {
+                    console.warn(`[spawn-manager] degradation reporter failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            },
+            // §4.4: optional knobs from config.
+            cooldownMs: spawnConfig?.cooldownMs,
+            maxDrainsPerTick: spawnConfig?.maxDrainsPerTick,
+            maxEnvelopeBytes: spawnConfig?.maxEnvelopeBytes,
+            maxGlobalQueued: spawnConfig?.maxGlobalQueued,
+            degradedMaxQueuedPerAgent: spawnConfig?.degradedMaxQueuedPerAgent,
+            // §4.4 commit 2 + §4.5: drain-loop consumer wiring.
+            // When the drain loop finds an agent ready (cooldown cleared + queued
+            // messages present), this callback re-invokes evaluate() with a
+            // synthetic SpawnRequest tagged `triggeredBy: 'spawn-request-drain'`.
+            // The real queued context is reattached by SpawnRequestManager.evaluate
+            // via its internal drainQueue() call. Stub session/machine values:
+            // requester.session/machine isn't preserved per-message — those fields
+            // are only used in the spawn prompt template for display.
+            onDrainReady: async (agent) => {
+                try {
+                    const result = await spawnManager.evaluate({
+                        requester: { agent, session: 'drain', machine: 'drain' },
+                        target: { agent: config.projectName, machine: os.hostname() },
+                        reason: `Drain re-attempt for queued messages from ${agent}`,
+                        priority: 'medium',
+                        triggeredBy: 'spawn-request-drain',
+                    });
+                    if (!result.approved) {
+                        console.log(`[spawn-manager] drain re-attempt for ${agent} not approved: ${result.reason}`);
+                    }
+                }
+                catch (err) {
+                    console.warn(`[spawn-manager] drain re-attempt for ${agent} threw: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            },
         });
+        // §4.4 kill switch: drain loop runs unless explicitly disabled in config.
+        // Wired here so emergency rollback is a config flip, not a code change.
+        if (spawnConfig?.drainEnabled !== false) {
+            spawnManager.start();
+            console.log(`[spawn-manager] drain loop started (tick=${spawnManager.getDrainTickMs()}ms)`);
+        }
+        else {
+            console.log('[spawn-manager] drain loop disabled by config.threadline.spawn.drainEnabled=false');
+        }
         // Threadline Router — handles threaded cross-agent conversations via relay
         const threadlineRouter = new ThreadlineRouter(messageRouter, spawnManager, threadResumeMap, messageStore, { localAgent: config.projectName, localMachine: os.hostname() }, null, // autonomyGate
         messageDelivery);
@@ -5178,7 +5248,12 @@ export async function startServer(options) {
                         transport: { protocol: 'relay', origin: { agent: senderFingerprint, machine: 'relay' }, nonce: `${crypto.randomUUID()}:${new Date().toISOString()}`, timestamp: new Date().toISOString() },
                         delivery: { status: 'delivered', attempts: 1, lastAttempt: new Date().toISOString() },
                     };
-                    const relayContext = { senderFingerprint, senderName, trustLevel };
+                    const relayContext = {
+                        trust: { kind: 'plaintext-tofu', senderFingerprint },
+                        senderFingerprint,
+                        senderName,
+                        trustLevel,
+                    };
                     let result = await threadlineRouter.handleInboundMessage(envelope, relayContext);
                     // Fallback for threadId-less messages
                     if (!result.handled && !msg.threadId) {
@@ -5687,6 +5762,7 @@ export async function startServer(options) {
             await notificationBatcher.flushAll(); // Drain pending notifications before exit
             notificationBatcher.stop();
             retryManager.stop();
+            spawnManager.dispose(); // §4.4: stop drain loop + clear DRR state
             summarySentinel.stop();
             memoryMonitor.stop();
             caffeinateManager.stop();