instar 0.28.1 → 0.28.3

package/README.md

@@ -113,7 +113,7 @@ Instar solves the six dimensions of agent coherence:
 | **Intent Alignment** | Decision journaling, drift detection, organizational constraints | [→](https://instar.sh/features/intent/) |
 | **Multi-Machine** | Ed25519/X25519 crypto identity, encrypted sync, automatic failover | [→](https://instar.sh/features/multi-machine/) |
 | **Serendipity Protocol** | Sub-agents capture out-of-scope discoveries without breaking focus. HMAC-signed, secret-scanned | [→](https://instar.sh/features/serendipity/) |
-| **Threadline Protocol** | Agent-to-agent conversations with canonical identity, three-layer trust model, authorization policy, Ed25519 invitations, Sybil protection, MoltBridge network discovery, rich agent profiles (auto-compiled from agent data with human review gate), discovery waterfall, message security, tamper-proof audit logging, and framework-agnostic interop. 2,324 tests across 99 test files | [→](https://instar.sh/features/threadline/) |
+| **Threadline Protocol** | Agent-to-agent conversations with canonical identity, three-layer trust model, authorization policy, Ed25519 invitations, Sybil protection, MoltBridge network discovery, rich agent profiles (auto-compiled from agent data with human review gate), discovery waterfall, message security, tamper-proof audit logging, framework-agnostic interop, and persistent listener daemon (always-on relay connection, pipe-mode sessions, sub-30s cross-machine failover). 2,324 tests across 104 test files | [→](https://instar.sh/features/threadline/) |
 | **Self-Healing** | LLM-powered stall detection, session recovery, promise tracking | [→](https://instar.sh/features/self-healing/) |
 | **AutoUpdater** | Built-in update engine. Checks npm, auto-applies, self-restarts | [→](https://instar.sh/features/autoupdater/) |
 | **Build Pipeline** | `/build` skill with worktree isolation, 6-phase pipeline, quality gates, stop-hook enforcement | |

package/dashboard/index.html

@@ -3067,7 +3067,7 @@
       document.getElementById('terminalView').style.display = 'flex';
       document.getElementById('terminalView').style.flexDirection = 'column';
       document.getElementById('terminalView').style.height = '100%';
-      document.getElementById('termSessionName').textContent = session.name;
+      document.getElementById('termSessionName').textContent = session.platformName || session.name;
 
       const badge = document.getElementById('termModelBadge');
       if (session.model) {

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;AAizCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA+9HtE;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;AA2PH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA6zCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAwhItE;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

@@ -493,7 +493,13 @@ async function respawnSessionForTopic(sessionManager, telegram, targetSession, t
             console.error(`[telegram→session] Failed to save resume UUID:`, err);
         }
     }
-    const storedName = telegram.getTopicName(topicId);
+    let storedName = telegram.getTopicName(topicId);
+    // If the name is unknown, try to resolve it from Telegram before falling back
+    if (!storedName || /^topic-\d+$/.test(storedName)) {
+        const resolved = await telegram.resolveTopicName(topicId);
+        if (resolved)
+            storedName = resolved;
+    }
     // Use topic name, not tmux session name — tmux names include the project prefix
     // which causes cascading names like ai-guy-ai-guy-ai-guy-topic-1 on each respawn.
     const topicName = storedName || `topic-${topicId}`;
@@ -773,7 +779,7 @@ function wireTelegramRouting(telegram, sessionManager, quotaTracker, topicMemory
     // Prevents duplicate concurrent spawns for the same topic when messages
     // arrive faster than the async spawn completes.
     const spawningTopics = new Set();
-    telegram.onTopicMessage = (msg) => {
+    telegram.onTopicMessage = async (msg) => {
         const topicId = msg.metadata?.messageThreadId ?? null;
         if (!topicId)
             return;
@@ -944,8 +950,16 @@ function wireTelegramRouting(telegram, sessionManager, quotaTracker, topicMemory
                 console.log(`[telegram→session] Spawn already in progress for topic ${topicId} — skipping duplicate`);
                 return;
             }
-            const spawnName = storedTopicName || `topic-${topicId}`;
             spawningTopics.add(topicId);
+            // Resolve topic name — try in-memory, then active probe, then fallback
+            let spawnName = storedTopicName;
+            if (!spawnName || /^topic-\d+$/.test(spawnName)) {
+                const resolved = await telegram.resolveTopicName(topicId);
+                if (resolved)
+                    spawnName = resolved;
+            }
+            if (!spawnName)
+                spawnName = `topic-${topicId}`;
             // Use the shared spawn helper that includes topic history + user context
             spawnSessionForTopic(sessionManager, telegram, spawnName, topicId, text, topicMemory, resolvedUser ?? undefined).then((newSessionName) => {
                 telegram.registerTopicSession(topicId, newSessionName, spawnName);
@@ -2023,6 +2037,10 @@ export async function startServer(options) {
             // Send-only mode: no polling, but sendToTopic() works for session replies
             telegram = new TelegramAdapter(telegramConfig.config, config.stateDir);
             console.log(pc.green(`  Telegram send-only mode (${isStandbyTelegram ? 'standby' : 'lifeline owns polling'})`));
+            // Resolve any topic names still using the fallback "topic-NNNN" pattern
+            telegram.resolveUnknownTopicNames().catch(err => {
+                console.warn(`[telegram] Topic name resolution failed: ${err}`);
+            });
             // Ensure topics exist even in send-only mode (createForumTopic is a simple API call)
             ensureAgentAttentionTopic(telegram, state).catch(err => {
                 console.error(`[server] Failed to ensure Agent Attention topic: ${err}`);
@@ -2487,40 +2505,49 @@ export async function startServer(options) {
                     else if (safeSenderName) {
                         prefix = `[slack:${channelId} from ${safeSenderName}]`;
                     }
-                    // Write context file for the session
+                    // Build context for the session — inject inline like Telegram does
+                    // Use async fallback to fetch from Slack API if ring buffer is empty
                     const tmpDir = '/tmp/instar-slack';
                     fs.mkdirSync(tmpDir, { recursive: true });
-                    const ctxPath = path.join(tmpDir, `ctx-${channelId}-${Date.now()}.txt`);
-                    const history = slackAdapter.getChannelMessages(channelId, 30);
+                    const history = await slackAdapter.getChannelMessagesWithFallback(channelId, 30);
                     const unansweredCount = slackAdapter.getUnansweredCount(channelId);
                     const botUserId = slackAdapter.getBotUserId?.() ?? null;
-                    // Build human-readable thread history (matches Telegram's context format)
-                    const lines = [];
-                    lines.push(`--- Thread History (last ${history.length} messages) ---`);
-                    lines.push('IMPORTANT: Read this history carefully before taking any action.');
-                    lines.push('Your task is to continue THIS conversation, not start something new.');
-                    lines.push(`Channel: ${channelId}`);
-                    lines.push('');
-                    for (const m of history) {
-                        const date = new Date(parseFloat(m.ts) * 1000);
-                        const time = date.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false });
-                        const isBot = botUserId && m.user === botUserId;
-                        const label = isBot ? 'Agent' : (senderName || m.user);
-                        lines.push(`[${time}] ${label}: ${m.text}`);
+                    // Build human-readable thread history (matches Telegram's inline context pattern)
+                    const contextLines = [];
+                    if (history.length > 0) {
+                        contextLines.push('CONTINUATION — You are resuming an EXISTING Slack conversation. Read the context below before responding. Do NOT ask what was being discussed.');
+                        contextLines.push('');
+                        contextLines.push(`--- Thread History (last ${history.length} messages) ---`);
+                        contextLines.push('IMPORTANT: Read this history carefully before taking any action.');
+                        contextLines.push('Your task is to continue THIS conversation, not start something new.');
+                        contextLines.push(`Channel: ${channelId}`);
+                        contextLines.push('');
+                        for (const m of history) {
+                            const date = new Date(parseFloat(m.ts) * 1000);
+                            const time = date.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false });
+                            const isBot = botUserId && m.user === botUserId;
+                            const label = isBot ? 'Agent' : (senderName || m.user);
+                            contextLines.push(`[${time}] ${label}: ${m.text}`);
+                        }
+                        contextLines.push('');
+                        contextLines.push('--- End Thread History ---');
                     }
-                    lines.push('');
-                    lines.push('--- End Thread History ---');
-                    lines.push('');
-                    lines.push('CRITICAL: You MUST relay your response back to Slack after responding.');
-                    lines.push('Use the relay script (write ONLY your reply text — do NOT pipe or cat this file into the script):');
-                    lines.push('');
-                    lines.push(`cat <<'EOF' | .claude/scripts/slack-reply.sh ${channelId}`);
-                    lines.push('Your response text here');
-                    lines.push('EOF');
-                    lines.push('');
-                    lines.push('Strip the [slack:] prefix before interpreting the message.');
-                    lines.push('Only relay conversational text — not tool output, file contents, or internal reasoning.');
-                    const contextData = lines.join('\n');
+                    else {
+                        console.warn(`[slack→context] No history available for channel ${channelId} — session starts without thread context`);
+                    }
+                    contextLines.push('');
+                    contextLines.push('CRITICAL: You MUST relay your response back to Slack after responding.');
+                    contextLines.push('Use the relay script (write ONLY your reply text — do NOT pipe or cat this file into the script):');
+                    contextLines.push('');
+                    contextLines.push(`cat <<'EOF' | .claude/scripts/slack-reply.sh ${channelId}`);
+                    contextLines.push('Your response text here');
+                    contextLines.push('EOF');
+                    contextLines.push('');
+                    contextLines.push('Strip the [slack:] prefix before interpreting the message.');
+                    contextLines.push('Only relay conversational text — not tool output, file contents, or internal reasoning.');
+                    const contextData = contextLines.join('\n');
+                    // Also write to file as backup reference
+                    const ctxPath = path.join(tmpDir, `ctx-${channelId}-${Date.now()}.txt`);
                     fs.writeFileSync(ctxPath, contextData);
                     // Transform [image:path] and [document:path] tags into explicit read instructions
                     let transformedContent = message.content.replace(/\[image:([^\]]+)\]/g, (_, imagePath) => {
@@ -2534,14 +2561,18 @@ export async function startServer(options) {
                         }
                         return `[User sent a file — it has been saved to ${docPath}. Read the file to view its contents]`;
                     });
-                    const FILE_THRESHOLD = 500;
+                    // Inject context INLINE in the bootstrap message (matches Telegram pattern).
+                    // This ensures the agent sees thread history immediately without needing to read a file.
                     const fullMessage = `${prefix} ${transformedContent} (IMPORTANT: Read ${ctxPath} for thread history and Slack relay instructions — you MUST relay your response back.)`;
-                    // Long messages: write to temp file and inject reference (matches Telegram pattern)
+                    // Large bootstrap messages: write to file with INLINE context included
+                    const FILE_THRESHOLD = 500;
                     let bootstrapMessage;
                     if (fullMessage.length > FILE_THRESHOLD) {
+                        // Write full message + inline context to the file so agent gets everything in one read
                         const msgFilePath = path.join(tmpDir, `msg-${channelId}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}.txt`);
-                        fs.writeFileSync(msgFilePath, fullMessage);
-                        bootstrapMessage = `${prefix} [Long message saved to ${msgFilePath} — read it to see the full message]`;
+                        const fullContent = `${fullMessage}\n\n${contextData}`;
+                        fs.writeFileSync(msgFilePath, fullContent);
+                        bootstrapMessage = `${prefix} [Long message saved to ${msgFilePath} — read it to see the full message and thread history]`;
                     }
                     else {
                         bootstrapMessage = fullMessage;
@@ -2594,7 +2625,7 @@ export async function startServer(options) {
                     // Route: DMs go to lifeline session, channels spawn new sessions
                     const targetSession = isDM ? 'lifeline' : undefined;
                     try {
-                        const newSessionName = await sessionManager.spawnInteractiveSession(bootstrapMessage, targetSession, { resumeSessionId });
+                        const newSessionName = await sessionManager.spawnInteractiveSession(bootstrapMessage, targetSession, { resumeSessionId, slackChannelId: channelId });
                         if (newSessionName) {
                             slackAdapter.registerChannelSession(channelId, newSessionName);
                             slackAdapter.trackMessageInjection(channelId, newSessionName, message.content);
@@ -3359,23 +3390,32 @@ export async function startServer(options) {
                         _slackAdapter.removeChannelResume(slackChId);
                         // Spawn a fresh session with recovery context
                         await new Promise(resolve => setTimeout(resolve, 2000));
-                        // Build a recovery bootstrap message with thread history
-                        const history = _slackAdapter.getChannelMessages(slackChId, 30);
+                        // Build a recovery bootstrap message with thread history (inline, matching Telegram pattern)
+                        // Use async fallback to fetch from Slack API if ring buffer is empty (race condition on restart)
+                        const history = await _slackAdapter.getChannelMessagesWithFallback(slackChId, 30);
                         const botUserId = _slackAdapter.getBotUserId?.() ?? null;
                         const lines = [];
+                        lines.push(`CONTINUATION — You are resuming an EXISTING Slack conversation after context exhaustion. Read the context below and pick up where you left off. Do NOT ask what was being discussed.`);
+                        lines.push('');
                         lines.push(`[RECOVERY] Previous session hit the context window limit. This is a FRESH restart with thread history.`);
                         if (recoveryPrompt)
                             lines.push(recoveryPrompt);
                         lines.push('');
-                        lines.push(`--- Thread History (last ${history.length} messages) ---`);
-                        for (const m of history) {
-                            const date = new Date(parseFloat(m.ts) * 1000);
-                            const time = date.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false });
-                            const isBot = botUserId && m.user === botUserId;
-                            const label = isBot ? 'Agent' : m.user;
-                            lines.push(`[${time}] ${label}: ${m.text}`);
+                        if (history.length > 0) {
+                            lines.push(`--- Thread History (last ${history.length} messages) ---`);
+                            for (const m of history) {
+                                const date = new Date(parseFloat(m.ts) * 1000);
+                                const time = date.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false });
+                                const isBot = botUserId && m.user === botUserId;
+                                const label = isBot ? 'Agent' : m.user;
+                                lines.push(`[${time}] ${label}: ${m.text}`);
+                            }
+                            lines.push('--- End Thread History ---');
+                        }
+                        else {
+                            console.warn(`[slack→recovery] WARNING: No history available for channel ${slackChId} — recovery context is empty. Ring buffer may not be populated yet.`);
+                            lines.push('[WARNING: Thread history unavailable — ring buffer may not be populated. Check Slack channel for recent messages before responding.]');
                         }
-                        lines.push('--- End Thread History ---');
                         lines.push('');
                         lines.push('CRITICAL: You MUST relay your response back to Slack.');
                         lines.push(`cat <<'EOF' | .claude/scripts/slack-reply.sh ${slackChId}`);
@@ -3386,9 +3426,9 @@ export async function startServer(options) {
                         const ctxPath = path.join(tmpDir, `recovery-${slackChId}-${Date.now()}.txt`);
                         const contextData = lines.join('\n');
                         fs.writeFileSync(ctxPath, contextData);
-                        const bootstrapMessage = `[slack:${slackChId}] [RECOVERY] Context exhaustion — session restarted fresh. (IMPORTANT: Read ${ctxPath} for thread history and Slack relay instructions — you MUST relay your response back.)`;
+                        const bootstrapMessage = `[slack:${slackChId}] ${contextData}`;
                         try {
-                            const newSessionName = await sessionManager.spawnInteractiveSession(bootstrapMessage);
+                            const newSessionName = await sessionManager.spawnInteractiveSession(bootstrapMessage, undefined, { slackChannelId: slackChId });
                             if (newSessionName) {
                                 _slackAdapter.registerChannelSession(slackChId, newSessionName);
                                 console.log(`[slack→recovery] Fresh session "${newSessionName}" spawned for channel ${slackChId} (context exhaustion recovery)`);
@@ -4631,6 +4671,8 @@ export async function startServer(options) {
         let threadlineShutdown;
         let threadlineRelayClient;
         let unifiedTrust;
+        /** Shared reply waiters for threadline waitForReply support */
+        const threadlineReplyWaiters = new Map();
         try {
             const threadline = await bootstrapThreadline({
                 agentName: config.projectName,
@@ -4711,6 +4753,37 @@ export async function startServer(options) {
                     else {
                         textContent = JSON.stringify(msg.content);
                     }
+                    // Check if this message resolves a pending waitForReply request.
+                    // Skip auto-ack messages (they're from us, not a real reply).
+                    // Try both fingerprint and agent name as keys — the waiter is keyed by
+                    // agent name (from relay-send), but gate-passed provides the fingerprint.
+                    const isAutoAck = textContent.startsWith('Message received.') || textContent.startsWith('Message received,');
+                    let waiter = threadlineReplyWaiters.get(senderFingerprint);
+                    if (!waiter) {
+                        // Resolve fingerprint → agent name via known-agents cache
+                        const resolvedName = (() => {
+                            try {
+                                const kaPath = path.join(config.stateDir, 'threadline', 'known-agents.json');
+                                const kaData = JSON.parse(fs.readFileSync(kaPath, 'utf-8'));
+                                const agents = kaData.agents ?? kaData;
+                                if (Array.isArray(agents)) {
+                                    // Check publicKey field for fingerprint match
+                                    const match = agents.find((a) => a.publicKey === senderFingerprint || a.publicKey?.startsWith(senderFingerprint));
+                                    return match?.name ?? null;
+                                }
+                                return null;
+                            }
+                            catch {
+                                return null;
+                            }
+                        })();
+                        if (resolvedName)
+                            waiter = threadlineReplyWaiters.get(resolvedName);
+                    }
+                    if (waiter && !isAutoAck) {
+                        waiter.resolve(textContent);
+                        // Don't return — still process the message normally for routing
+                    }
                     // Auto-ack (post-trust-verification, never ack status messages)
                     const msgType = typeof msg.content === 'object' && msg.content !== null ? msg.content.type : undefined;
                     if (trustLevel !== 'untrusted' && msgType !== 'status' && config.threadline?.autoAck !== false && !isAckRateLimited(senderFingerprint)) {
@@ -4881,7 +4954,7 @@ export async function startServer(options) {
                 return { content: lines.join('\n'), truncated: false, elapsedMs: Date.now() - start };
             }, { description: 'Feature discovery state and behavioral contract summary' });
         }
-        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, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, whatsapp: whatsappAdapter, slack: slackAdapter, imessage: imessageAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, threadlineRouter, threadlineRelayClient, listenerManager: listenerManager ?? undefined, responseReviewGate, telemetryHeartbeat, pasteManager, featureRegistry, discoveryEvaluator, unifiedTrust, liveConfig });
+        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, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, whatsapp: whatsappAdapter, slack: slackAdapter, imessage: imessageAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, threadlineRouter, threadlineRelayClient, threadlineReplyWaiters, listenerManager: listenerManager ?? undefined, responseReviewGate, telemetryHeartbeat, pasteManager, featureRegistry, discoveryEvaluator, unifiedTrust, liveConfig });
         await server.start();
         // Connect DegradationReporter downstream systems now that everything is initialized.
         // Any degradation events queued during startup will drain to feedback + telegram.
@@ -5169,8 +5242,14 @@ export async function startServer(options) {
                 await threadlineShutdown();
             wakeSocketServer?.stop();
             pipeSpawner?.killAll();
-            stopHeartbeat?.();
-            unregisterAgent(config.projectDir);
+            try {
+                stopHeartbeat?.();
+            }
+            catch { /* non-critical during shutdown */ }
+            try {
+                unregisterAgent(config.projectDir);
+            }
+            catch { /* ELOCKED is non-critical during shutdown */ }
             scheduler?.stop();
             if (telegram)
                 await telegram.stop();