instar 0.24.13 → 0.24.14

package/dist/server/routes.js

@@ -2828,7 +2828,7 @@ export function createRoutes(ctx) {
             res.status(400).json({ error: 'topicId must be a number' });
             return;
         }
-        const { text } = req.body;
+        const { text, metadata } = req.body;
         if (!text || typeof text !== 'string') {
             res.status(400).json({ error: '"text" field required' });
             return;
@@ -2838,9 +2838,13 @@ export function createRoutes(ctx) {
             return;
         }
         try {
-            await ctx.telegram.sendToTopic(topicId, text);
-            // Clear injection tracker — the agent has responded to this topic
-            ctx.sessionManager.clearInjectionTracker(topicId);
+            const isProxy = metadata?.isProxy === true;
+            await ctx.telegram.sendToTopic(topicId, text, { skipStallClear: isProxy });
+            // Clear injection tracker — but NOT for proxy messages (PresenceProxy)
+            // Proxy messages should not reset stall detection timers
+            if (!isProxy) {
+                ctx.sessionManager.clearInjectionTracker(topicId);
+            }
             res.json({ ok: true, topicId });
         }
         catch (err) {
@@ -2890,6 +2894,91 @@ export function createRoutes(ctx) {
         }
         res.json(ctx.telegram.getLogStats());
     });
+    // ── Slack ──────────────────────────────────────────────────────
+    router.post('/slack/reply/:channelId', async (req, res) => {
+        if (!ctx.slack) {
+            res.status(503).json({ error: 'Slack not configured' });
+            return;
+        }
+        const { channelId } = req.params;
+        const { text, thread_ts } = req.body;
+        if (!text || typeof text !== 'string') {
+            res.status(400).json({ error: '"text" field required' });
+            return;
+        }
+        try {
+            const ts = await ctx.slack.sendToChannel(channelId, text, { thread_ts });
+            res.json({ ok: true, topicId: channelId, ts });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    router.get('/slack/channels', async (req, res) => {
+        if (!ctx.slack) {
+            res.status(503).json({ error: 'Slack not configured' });
+            return;
+        }
+        try {
+            const channels = await ctx.slack.api.call('conversations.list', {
+                types: 'public_channel,private_channel',
+                exclude_archived: req.query.include_archived !== 'true',
+                limit: 200,
+            });
+            res.json({ ok: true, channels: channels.channels ?? [] });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    router.post('/slack/channels', async (req, res) => {
+        if (!ctx.slack) {
+            res.status(503).json({ error: 'Slack not configured' });
+            return;
+        }
+        const { name, is_private } = req.body;
+        if (!name || typeof name !== 'string') {
+            res.status(400).json({ error: '"name" field required' });
+            return;
+        }
+        try {
+            const channelId = await ctx.slack.createChannel(name, is_private);
+            res.json({ ok: true, channelId });
+        }
+        catch (err) {
+            res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    router.get('/slack/channels/:channelId/messages', (req, res) => {
+        if (!ctx.slack) {
+            res.status(503).json({ error: 'Slack not configured' });
+            return;
+        }
+        const { channelId } = req.params;
+        const limit = Math.min(parseInt(req.query.limit, 10) || 30, 100);
+        const messages = ctx.slack.getChannelMessages(channelId, limit);
+        res.json({ ok: true, messages, count: messages.length });
+    });
+    router.get('/slack/search', (req, res) => {
+        if (!ctx.slack) {
+            res.status(503).json({ error: 'Slack not configured' });
+            return;
+        }
+        const query = req.query.q;
+        const channelId = req.query.channelId;
+        const since = req.query.since ? new Date(req.query.since) : undefined;
+        const rawLimit = parseInt(req.query.limit, 10) || 50;
+        const limit = Math.min(Math.max(rawLimit, 1), 500);
+        const results = ctx.slack.searchLog({ query, channelId, since, limit });
+        res.json({ results, count: results.length });
+    });
+    router.get('/slack/log-stats', (req, res) => {
+        if (!ctx.slack) {
+            res.status(503).json({ error: 'Slack not configured' });
+            return;
+        }
+        res.json(ctx.slack.getLogStats());
+    });
     // ── Attention Queue ─────────────────────────────────────────────
     router.post('/attention', async (req, res) => {
         if (!ctx.telegram) {
@@ -4163,6 +4252,12 @@ export function createRoutes(ctx) {
             return;
         }
         const tunnelType = (ctx.config.tunnel?.type === 'named' ? 'named' : 'quick');
+        // Named tunnels have permanent URLs — skip periodic refresh calls since
+        // the URL never changes. The initial broadcast on server startup is sufficient.
+        if (tunnelType === 'named') {
+            res.json({ action: 'skipped', reason: 'named tunnel — URL is permanent', url: tunnelUrl, tunnelType });
+            return;
+        }
         try {
             await ctx.telegram.broadcastDashboardUrl(tunnelUrl, tunnelType);
             res.json({ action: 'refreshed', url: tunnelUrl, tunnelType });
@@ -5181,6 +5276,120 @@ export function createRoutes(ctx) {
             res.status(500).json({ error: err instanceof Error ? err.message : 'Triage failed' });
         }
     });
+    // ── Systems Status (aggregated subsystem overview) ────────────────
+    router.get('/systems/status', (_req, res) => {
+        const uptimeMs = Date.now() - ctx.startTime.getTime();
+        function proc(name, subsystem, statusFn) {
+            if (!subsystem)
+                return { name, enabled: false, status: 'not tracked' };
+            try {
+                const details = statusFn ? statusFn() : undefined;
+                return { name, enabled: true, status: 'running', details };
+            }
+            catch {
+                return { name, enabled: true, status: 'error' };
+            }
+        }
+        const categories = [
+            {
+                id: 'session-management',
+                name: 'Session Management & Recovery',
+                processes: [
+                    proc('SessionWatchdog', ctx.watchdog, () => ctx.watchdog?.getStatus()),
+                    proc('StallTriageNurse', ctx.triageNurse, () => ctx.triageNurse?.getStatus()),
+                    proc('SessionActivitySentinel', ctx.activitySentinel),
+                    proc('SessionSummarySentinel', ctx.summarySentinel),
+                    proc('SpawnRequestManager', ctx.spawnManager),
+                ],
+            },
+            {
+                id: 'coherence-integrity',
+                name: 'Coherence & Integrity',
+                processes: [
+                    proc('CoherenceMonitor', ctx.coherenceMonitor, () => ctx.coherenceMonitor?.getLastReport()),
+                    proc('CoherenceGate (Scope)', ctx.coherenceGate),
+                    proc('ResponseReviewGate', ctx.responseReviewGate),
+                    proc('CanonicalState', ctx.canonicalState),
+                    proc('InstructionsVerifier', ctx.instructionsVerifier),
+                ],
+            },
+            {
+                id: 'resource-monitoring',
+                name: 'Resource Monitoring',
+                processes: [
+                    proc('MemoryPressureMonitor', ctx.memoryMonitor, () => ctx.memoryMonitor?.getState()),
+                    proc('OrphanProcessReaper', ctx.orphanReaper, () => ctx.orphanReaper?.getLastReport()),
+                    proc('QuotaTracker', ctx.quotaTracker, () => ctx.quotaTracker?.getState()),
+                    proc('QuotaManager', ctx.quotaManager),
+                ],
+            },
+            {
+                id: 'scheduling-jobs',
+                name: 'Scheduling & Jobs',
+                processes: [
+                    proc('JobScheduler', ctx.scheduler),
+                    proc('CommitmentTracker', ctx.commitmentTracker, () => ({ active: ctx.commitmentTracker?.getActive().length ?? 0 })),
+                ],
+            },
+            {
+                id: 'messaging-communication',
+                name: 'Messaging & Communication',
+                processes: [
+                    proc('Telegram', ctx.telegram),
+                    proc('WhatsApp', ctx.whatsapp),
+                    proc('MessageBridge', ctx.messageBridge),
+                    proc('MessageRouter', ctx.messageRouter),
+                ],
+            },
+            {
+                id: 'knowledge-memory',
+                name: 'Knowledge & Memory',
+                processes: [
+                    proc('TopicMemory', ctx.topicMemory),
+                    proc('SemanticMemory', ctx.semanticMemory),
+                    proc('WorkingMemoryAssembler', ctx.workingMemory),
+                    proc('SelfKnowledgeTree', ctx.selfKnowledgeTree),
+                ],
+            },
+            {
+                id: 'safety-trust',
+                name: 'Safety & Trust',
+                processes: [
+                    proc('ExternalOperationGate', ctx.operationGate),
+                    proc('MessageSentinel', ctx.sentinel),
+                    proc('AdaptiveTrust', ctx.adaptiveTrust),
+                    proc('AutonomyManager', ctx.autonomyManager),
+                ],
+            },
+            {
+                id: 'evolution-discovery',
+                name: 'Evolution & Discovery',
+                processes: [
+                    proc('EvolutionManager', ctx.evolution),
+                    proc('AutonomousEvolution', ctx.autonomousEvolution),
+                    proc('CapabilityMapper', ctx.capabilityMapper),
+                    proc('CoverageAuditor', ctx.coverageAuditor),
+                ],
+            },
+            {
+                id: 'infrastructure',
+                name: 'Infrastructure & Networking',
+                processes: [
+                    proc('TunnelManager', ctx.tunnel),
+                    proc('WorktreeMonitor', ctx.worktreeMonitor),
+                    proc('ThreadlineRouter', ctx.threadlineRouter),
+                    proc('SystemReviewer', ctx.systemReviewer, () => ctx.systemReviewer?.getHealthStatus()),
+                ],
+            },
+        ];
+        // Recent degradation events
+        const allEvents = DegradationReporter.getInstance().getEvents();
+        const recentEvents = allEvents.slice(-20).reverse().map(e => ({
+            ...e,
+            narrative: DegradationReporter.narrativeFor(e),
+        }));
+        res.json({ uptime: uptimeMs, categories, recentEvents });
+    });
     // ── External Operation Safety ────────────────────────────────────
     // POST /operations/classify — classify an external operation
     router.post('/operations/classify', (req, res) => {