instar 0.17.13 → 0.18.1

package/dist/commands/server.js

@@ -46,6 +46,7 @@ import { QuotaManager } from '../monitoring/QuotaManager.js';
 import { classifySessionDeath } from '../monitoring/QuotaExhaustionDetector.js';
 import { SessionWatchdog } from '../monitoring/SessionWatchdog.js';
 import { StallTriageNurse } from '../monitoring/StallTriageNurse.js';
+import { TriageOrchestrator } from '../monitoring/TriageOrchestrator.js';
 import { SessionMonitor } from '../monitoring/SessionMonitor.js';
 import { MultiMachineCoordinator } from '../core/MultiMachineCoordinator.js';
 import { GitSyncManager } from '../core/GitSync.js';
@@ -2005,6 +2006,89 @@ export async function startServer(options) {
             };
             console.log(pc.green('  Stall Triage Nurse enabled'));
         }
+        // TriageOrchestrator — next-gen session recovery with scoped Claude Code sessions
+        let triageOrchestrator;
+        if (config.monitoring.triageOrchestrator?.enabled && telegram) {
+            triageOrchestrator = new TriageOrchestrator({
+                captureSessionOutput: (name, lines) => sessionManager.captureOutput(name, lines),
+                isSessionAlive: (name) => sessionManager.isSessionAlive(name),
+                sendKey: (name, key) => sessionManager.sendKey(name, key),
+                sendInput: (name, text) => sessionManager.sendInput(name, text),
+                getTopicHistory: (topicId, limit) => {
+                    const entries = telegram.getTopicHistory(topicId, limit);
+                    return entries.map(e => ({
+                        text: e.text,
+                        fromUser: e.fromUser,
+                        timestamp: e.timestamp,
+                    }));
+                },
+                sendToTopic: (topicId, text) => telegram.sendToTopic(topicId, text),
+                respawnSession: (name, topicId) => respawnSessionForTopic(sessionManager, telegram, name, topicId, undefined, topicMemory),
+                clearStallForTopic: (topicId) => telegram.clearStallTracking(topicId),
+                spawnTriageSession: (name, options) => sessionManager.spawnTriageSession(name, options),
+                getTriageSessionUuid: (sessionName) => {
+                    return _topicResumeMap?.findUuidForSession(sessionName) ?? undefined;
+                },
+                killTriageSession: (name) => {
+                    try {
+                        const tmux = detectTmuxPath() || 'tmux';
+                        execFileSync(tmux, ['kill-session', '-t', `=${name}`], { encoding: 'utf-8' });
+                    }
+                    catch { /* best-effort — session may already be dead */ }
+                },
+                scheduleFollowUpJob: (slug, delayMs, callback) => {
+                    const jobId = `${slug}-${Date.now()}`;
+                    const timer = setTimeout(callback, delayMs);
+                    triageOrchestrator.__timers = triageOrchestrator.__timers || new Map();
+                    triageOrchestrator.__timers.set(jobId, timer);
+                    return jobId;
+                },
+                cancelJob: (jobId) => {
+                    const timers = triageOrchestrator.__timers;
+                    if (timers?.has(jobId)) {
+                        clearTimeout(timers.get(jobId));
+                        timers.delete(jobId);
+                    }
+                },
+                injectMessage: (name, text) => sessionManager.sendInput(name, text),
+                captureTriageOutput: (name, lines) => sessionManager.captureOutput(name, lines),
+                isTriageSessionAlive: (name) => sessionManager.tmuxSessionExists(name),
+                projectDir: config.projectDir,
+            }, {
+                config: {
+                    cooldownMs: config.monitoring.triageOrchestrator.cooldownMs,
+                    maxConcurrentTriages: config.monitoring.triageOrchestrator.maxConcurrentTriages,
+                    autoActionEnabled: config.monitoring.triageOrchestrator.autoActionEnabled,
+                    maxAutoActionsPerHour: config.monitoring.triageOrchestrator.maxAutoActionsPerHour,
+                    defaultModel: config.monitoring.triageOrchestrator.defaultModel,
+                },
+                state,
+            });
+            // TriageOrchestrator takes over stall detection from StallTriageNurse
+            telegram.onStallDetected = async (topicId, sessionName, messageText, injectedAt) => {
+                const result = await triageOrchestrator.activate(topicId, sessionName, 'stall_detector', messageText, injectedAt);
+                return { resolved: result.resolved };
+            };
+            // Cancel triage when stall tracking clears (session responded)
+            const origClearStall = telegram.clearStallTracking.bind(telegram);
+            telegram.clearStallTracking = (topicId) => {
+                origClearStall(topicId);
+                triageOrchestrator.onTargetSessionResponded(topicId);
+            };
+            // Wire /triage command
+            telegram.onGetTriageStatus = (topicId) => {
+                const ts = triageOrchestrator.getTriageState(topicId);
+                if (!ts)
+                    return null;
+                return {
+                    active: true,
+                    classification: ts.classification,
+                    checkCount: ts.checkCount,
+                    lastCheck: new Date(ts.lastCheckAt).toISOString(),
+                };
+            };
+            console.log(pc.green('  Triage Orchestrator enabled (replaces Stall Triage Nurse for stall detection)'));
+        }
         // SessionMonitor — proactive session health monitoring
         let sessionMonitor;
         if (telegram) {
@@ -2022,12 +2106,17 @@ export async function startServer(options) {
                         .map((m) => ({ text: m.text, fromUser: m.fromUser, timestamp: m.timestamp }));
                 },
                 sendToTopic: (topicId, text) => telegram.sendToTopic(topicId, text),
-                triggerTriage: triageNurse
+                triggerTriage: triageOrchestrator
                     ? async (topicId, sessionName, reason) => {
-                        const result = await triageNurse.triage(topicId, sessionName, reason, Date.now(), 'watchdog');
+                        const result = await triageOrchestrator.activate(topicId, sessionName, 'watchdog', reason, Date.now());
                         return { resolved: result.resolved };
                     }
-                    : undefined,
+                    : triageNurse
+                        ? async (topicId, sessionName, reason) => {
+                            const result = await triageNurse.triage(topicId, sessionName, reason, Date.now(), 'watchdog');
+                            return { resolved: result.resolved };
+                        }
+                        : undefined,
             }, config.monitoring.sessionMonitor);
             sessionMonitor.start();
             console.log(pc.green('  Session Monitor enabled'));
@@ -2707,15 +2796,99 @@ export async function startServer(options) {
         // The user never sees any of this. The agent IS the interface.
         let threadlineHandshake;
         let threadlineShutdown;
+        let threadlineRelayClient;
         try {
             const threadline = await bootstrapThreadline({
                 agentName: config.projectName,
                 stateDir: config.stateDir,
                 projectDir: config.projectDir,
                 port: config.port,
+                relayEnabled: config.threadline?.relayEnabled,
+                relayUrl: config.threadline?.relayUrl,
+                visibility: config.threadline?.visibility,
+                capabilities: config.threadline?.capabilities,
             });
             threadlineHandshake = threadline.handshakeManager;
             threadlineShutdown = threadline.shutdown;
+            threadlineRelayClient = threadline.relayClient;
+            if (threadlineRelayClient) {
+                // Wire relay message delivery into the session system.
+                // When a message passes the InboundMessageGate, inject it into a Claude session.
+                // Session persistence: reuse existing sessions for the same sender.
+                // Rate limit: max 1 NEW session spawn per sender per 5 minutes to prevent abuse.
+                // Follow-up messages to existing sessions are always allowed.
+                const relaySpawnCooldowns = new Map();
+                const RELAY_SPAWN_COOLDOWN_MS = 5 * 60 * 1000;
+                threadlineRelayClient.on('gate-passed', async (decision) => {
+                    if (!decision.message)
+                        return;
+                    const msg = decision.message;
+                    const senderFingerprint = msg.from;
+                    const senderName = senderFingerprint.slice(0, 8); // Short fingerprint as fallback name
+                    const trustLevel = decision.trustLevel ?? 'untrusted';
+                    // Extract text content from the relay message
+                    // Content may be a string, PlaintextMessage ({content, type}), or raw object
+                    let textContent;
+                    if (typeof msg.content === 'string') {
+                        textContent = msg.content;
+                    }
+                    else if (typeof msg.content === 'object' && msg.content !== null) {
+                        const c = msg.content;
+                        textContent = String(c.content ?? c.text ?? JSON.stringify(msg.content));
+                    }
+                    else {
+                        textContent = JSON.stringify(msg.content);
+                    }
+                    const sessionName = `relay-${senderFingerprint}`;
+                    const relayTag = `[relay:${senderFingerprint.slice(0, 16)}]`;
+                    // Check if a session already exists for this sender
+                    const existingSession = sessionManager.isSessionAlive(`${config.projectName}-${sessionName.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '').slice(0, 40)}`);
+                    if (existingSession) {
+                        // Session exists — inject follow-up message (no cooldown, simpler format)
+                        const followUpMessage = `${relayTag} ${textContent}`;
+                        try {
+                            await sessionManager.spawnInteractiveSession(followUpMessage, sessionName, {});
+                            console.log(`[relay] Injected follow-up from ${senderName} into existing session`);
+                        }
+                        catch (err) {
+                            console.error(`[relay] Failed to inject follow-up: ${err instanceof Error ? err.message : err}`);
+                        }
+                        return;
+                    }
+                    // New session — apply spawn cooldown
+                    const now = Date.now();
+                    const lastSpawn = relaySpawnCooldowns.get(senderFingerprint);
+                    if (lastSpawn && now - lastSpawn < RELAY_SPAWN_COOLDOWN_MS) {
+                        const remainSec = Math.ceil((RELAY_SPAWN_COOLDOWN_MS - (now - lastSpawn)) / 1000);
+                        console.log(`[relay] Rate limited session spawn from ${senderName} (${remainSec}s cooldown remaining)`);
+                        return;
+                    }
+                    // Build a session-injectable message with full relay context
+                    // Note: avoid leading dashes (---) which tmux send-keys interprets as flags
+                    const bootstrapMessage = [
+                        `[Relay Message from Threadline Network]`,
+                        `From: ${senderName} (fingerprint: ${senderFingerprint})`,
+                        `Trust: ${trustLevel}`,
+                        `Thread: ${msg.threadId ?? 'new'}`,
+                        ``,
+                        `IMPORTANT: This message arrived via the Threadline relay from another AI agent.`,
+                        `Use the threadline_send MCP tool to reply (target: ${senderFingerprint}).`,
+                        `Do NOT relay via Telegram. Trust level "${trustLevel}" determines what this agent can request.`,
+                        ``,
+                        `${relayTag} ${textContent}`,
+                    ].join('\n');
+                    try {
+                        await sessionManager.spawnInteractiveSession(bootstrapMessage, sessionName, {});
+                        relaySpawnCooldowns.set(senderFingerprint, Date.now());
+                        console.log(`[relay] Spawned session for message from ${senderName} (trust: ${trustLevel})`);
+                    }
+                    catch (err) {
+                        console.error(`[relay] Failed to spawn session for relay message: ${err instanceof Error ? err.message : err}`);
+                    }
+                });
+                // Relay client is passed to AgentServer → RouteContext for the /threadline/relay-send endpoint
+                console.log(pc.green(`  Threadline: relay connected to ${config.threadline?.relayUrl ?? 'threadline-relay.fly.dev'}`));
+            }
             console.log(pc.green(`  Threadline: enabled (MCP tools registered, discovery heartbeat active)`));
         }
         catch (err) {
@@ -2741,7 +2914,7 @@ export async function startServer(options) {
                 console.warn(pc.yellow(`  Response review pipeline: configured but ANTHROPIC_API_KEY not set`));
             }
         }
-        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, topicResumeMap: _topicResumeMap ?? undefined, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, whatsapp: whatsappAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, responseReviewGate, telemetryHeartbeat });
+        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, topicResumeMap: _topicResumeMap ?? undefined, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, whatsapp: whatsappAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, threadlineRelayClient, responseReviewGate, telemetryHeartbeat });
         await server.start();
         // Connect DegradationReporter downstream systems now that everything is initialized.
         // Any degradation events queued during startup will drain to feedback + telegram.