instar 0.28.88 → 0.28.90

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;AAiQH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAg4CD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAi5JtE;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;AAiQH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAw4CD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA68JtE;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

@@ -270,6 +270,11 @@ let _projectDir = process.cwd();
 let _sharedIntelligence = null;
 let _selfKnowledgeTree = null;
 let _slackAdapter = null;
+// SessionRefresh — agent-initiated respawn. Module-scope so onRestartSession
+// (defined outside startServer) can delegate to it once startServer wires it.
+// Null until startServer constructs it; the Telegram /restart handler falls
+// back to the inline kill+respawn path when null (e.g. early in boot).
+let _sessionRefresh = null;
 async function spawnSessionForTopic(sessionManager, telegram, sessionName, topicId, latestMessage, topicMemory, userProfile) {
     const msg = latestMessage || 'Session started — send a message to continue.';
     // If memory is elevated/critical and we have the reaper, try to free memory
@@ -538,25 +543,28 @@ function wireTelegramCallbacks(telegram, sessionManager, state, quotaTracker, ac
             return false;
         }
     };
-    // /restart — kill session and respawn
+    // /restart — kill session and respawn. Delegates to SessionRefresh, the
+    // consolidated lifecycle owner: it routes the kill through
+    // sessionManager.killSession (which fires the kill hook so the UUID
+    // listener persists session.claudeSessionId), then spawns a fresh tmux
+    // running `claude --resume <uuid>`. Includes the rate guard against
+    // infinite-respawn loops.
+    //
+    // If SessionRefresh isn't wired yet (very narrow early-boot window
+    // before startServer reaches the construction point), we no-op with a
+    // warning instead of falling back to a broken inline path — the
+    // pre-PR inline kill bypassed sessionManager.killSession and so the
+    // kill hook never fired, meaning resume UUIDs were silently dropped.
+    // Routing exclusively through SessionRefresh fixes that latent issue.
     telegram.onRestartSession = async (sessionName, topicId) => {
-        // Save resume UUID before killing so the new session can --resume
-        if (_topicResumeMap) {
-            try {
-                const uuid = _topicResumeMap.findUuidForSession(sessionName);
-                if (uuid) {
-                    _topicResumeMap.save(topicId, uuid, sessionName);
-                }
-            }
-            catch { /* best effort */ }
+        if (!_sessionRefresh) {
+            console.warn(`[telegram /restart] SessionRefresh not yet wired; deferring restart for sessionName=${sessionName} topicId=${topicId}`);
+            return;
         }
-        // Kill existing session
-        try {
-            execFileSync(detectTmuxPath(), ['kill-session', '-t', `=${sessionName}`], { stdio: 'ignore' });
+        const result = await _sessionRefresh.refreshSession({ sessionName, reason: 'telegram-/restart' });
+        if (!result.ok) {
+            console.warn(`[telegram /restart] SessionRefresh refused sessionName=${sessionName} code=${result.code}`);
         }
-        catch { /* may already be dead */ }
-        // Respawn with thread history
-        await respawnSessionForTopic(sessionManager, telegram, sessionName, topicId, undefined, topicMemory);
     };
     // /sessions — list running sessions
     telegram.onListSessions = () => {
@@ -5132,6 +5140,50 @@ export async function startServer(options) {
         // 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);
+        // Topic linkage handler — Per THREAD-TOPIC-LINKAGE-SPEC.md.
+        // Ties threadline conversations to the originating Telegram topic so
+        // replies route back to the topic session instead of a sibling worker.
+        // commitmentTracker + telegram are constructed earlier in this file and
+        // are guaranteed in scope by this point; the handler is wired into the
+        // router immediately.
+        const { SalienceGate } = await import('../threadline/SalienceGate.js');
+        const { TopicLinkageHandler } = await import('../threadline/TopicLinkageHandler.js');
+        const salienceGate = new SalienceGate(); // fallback-only for v1; spec §5.4
+        let topicLinkageHandler = null;
+        if (commitmentTracker) {
+            topicLinkageHandler = new TopicLinkageHandler({
+                topicResumeMap: _topicResumeMap,
+                threadResumeMap,
+                commitmentTracker,
+                salienceGate,
+                messageStore,
+                localAgent: config.projectName,
+                injectIntoSession: (sessionName, text) => {
+                    try {
+                        sessionManager.injectPasteNotification(sessionName, text);
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                isSessionAlive: (sessionName) => {
+                    try {
+                        return sessionManager.isSessionAlive(sessionName);
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                sendTelegramToTopic: telegram
+                    ? (topicId, text) => telegram.sendToTopic(topicId, text)
+                    : null,
+                getSessionForTopic: telegram
+                    ? (topicId) => telegram.getSessionForTopic(topicId)
+                    : undefined,
+            });
+            threadlineRouter.setTopicLinkageHandler(topicLinkageHandler);
+        }
         // Listener Session Manager — warm session for fast relay responses (Phase 2)
         const listenerManager = config.threadline?.relayEnabled
             ? new ListenerSessionManager(config.stateDir, config.authToken ?? '', config.threadline)
@@ -5809,7 +5861,29 @@ export async function startServer(options) {
                 divergenceChecker = undefined;
             }
         }
-        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, messagingToneGate, outboundDedupGate, telemetryHeartbeat, pasteManager, featureRegistry, discoveryEvaluator, unifiedTrust, liveConfig, sharedStateLedger, ledgerSessionRegistry, worktreeManager, oidcEnrolledRepos: parallelDevConfig?.oidcEnrolledRepos, initiativeTracker, proxyCoordinator, telegramBridgeConfig, telegramBridge: telegramBridge ?? undefined, threadlineObservability, workingMemory, taskFlowRegistry, threadlineFlowBridge });
+        // SessionRefresh — agent-initiated session respawn. Requires a Telegram
+        // adapter (v1 scope: Telegram-bound sessions only). The respawner closure
+        // captures `topicMemory` by reference, so even if topicMemory is wired up
+        // after this point it will be resolved at refresh-time.
+        if (telegram) {
+            const { SessionRefresh } = await import('../core/SessionRefresh.js');
+            const telegramRef = telegram; // narrow for closure
+            _sessionRefresh = new SessionRefresh({
+                sessionManager,
+                state,
+                telegram: telegramRef,
+                topicResumeMap: _topicResumeMap,
+                respawner: async (sessionName, topicId, followUpPrompt) => {
+                    // killSession (called inside SessionRefresh) has already fired
+                    // beforeSessionKill (UUID persisted) and destroyed the tmux
+                    // session. respawnSessionForTopic spawns the new tmux running
+                    // `claude --resume <uuid>` and registers the topic mapping.
+                    await respawnSessionForTopic(sessionManager, telegramRef, sessionName, topicId, followUpPrompt, topicMemory);
+                    return telegramRef.getSessionForTopic(topicId) ?? sessionName;
+                },
+            });
+        }
+        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, proxyCoordinator, telegramBridgeConfig, telegramBridge: telegramBridge ?? undefined, threadlineObservability, workingMemory, taskFlowRegistry, threadlineFlowBridge });
         await server.start();
         void taskFlowSweeper;
         void taskFlowDueWaker;