instar 1.3.245 → 1.3.247

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;AA0SH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAgxDD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAyqQtE;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;AA2SH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAgxDD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAmzQtE;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

@@ -122,7 +122,8 @@ import { pickupDroppedMessages } from '../messaging/DropPickup.js';
 import { pickupGitSyncMessages } from '../messaging/GitSyncTransport.js';
 import { DeliveryRetryManager } from '../messaging/DeliveryRetryManager.js';
 import { SpawnRequestManager } from '../messaging/SpawnRequestManager.js';
-import { ThreadlineRouter } from '../threadline/ThreadlineRouter.js';
+import { ThreadlineRouter, trustMeetsFloor } from '../threadline/ThreadlineRouter.js';
+import { WarmSessionPool } from '../threadline/WarmSessionPool.js';
 import { resolveThreadlineMcpEntry } from '../threadline/mcpEntry.js';
 import { ThreadResumeMap } from '../threadline/ThreadResumeMap.js';
 import { ConversationStore } from '../threadline/ConversationStore.js';
@@ -7116,6 +7117,42 @@ export async function startServer(options) {
                 ?? 5,
             getActiveSessions: () => sessionManager.listRunningSessions(),
             spawnSession: async (prompt, opts) => {
+                // Warm-session A2A (Arch Y): when the SpawnRequest is flagged interactive,
+                // launch a PERSISTENT (keep-alive) interactive worker instead of the
+                // headless one-shot `claude -p`. The grounded prompt is delivered as the
+                // worker's FIRST turn (after-ready inject), and the worker stays alive so
+                // follow-ups inject into the same session. The MCP/permission flag set
+                // matches the `-p` path: claude interactive keeps the PROJECT MCP (where
+                // threadline_send lives) under --dangerously-skip-permissions, and codex
+                // interactive launches with --dangerously-bypass-approvals-and-sandbox +
+                // the per-agent threadline MCP (the bypass the `-p` codexAllowMcpTools
+                // selects) — so threadline_send is available either way.
+                if (opts?.interactive) {
+                    const warmName = `msg-warm-${Date.now()}`;
+                    // Framework-GENERAL: the warm worker runs in the LOCAL agent's
+                    // framework (claude-code / codex-cli / gemini-cli), NOT hardcoded
+                    // Claude. spawnInteractiveSession + frameworkSessionLaunch compose the
+                    // right argv + MCP/permission flags per framework (claude keeps PROJECT
+                    // MCP under --dangerously-skip-permissions; codex launches under
+                    // --dangerously-bypass-approvals-and-sandbox with its per-agent
+                    // threadline MCP) so threadline_send works regardless of framework.
+                    // A2A reply threads have no topic, so the agent default framework
+                    // applies (mirrors resolveTopicFramework's own fallback).
+                    const tmuxSession = await sessionManager.spawnInteractiveSession(prompt, warmName, {
+                        framework: _defaultFramework,
+                        // Deterministic conversation id for lossless eviction→resume (#746).
+                        // frameworkSessionLaunch maps this per framework: claude-code pins
+                        // `--session-id`; codex/gemini ignore it (they resume by their own
+                        // mechanism). NOT a Claude assumption — it's the abstraction's job.
+                        sessionId: opts?.sessionId,
+                    });
+                    // spawnInteractiveSession returns the tmux name; resolve the instar
+                    // session id from the running set so the warm callback returns the
+                    // slice-2 {sessionId, tmuxSession} shape spawnWarmThread expects.
+                    const running = sessionManager.listRunningSessions();
+                    const rec = running.find(s => s.tmuxSession === tmuxSession);
+                    return { sessionId: rec?.id ?? tmuxSession, tmuxSession };
+                }
                 const session = await sessionManager.spawnSession({
                     name: `msg-spawn-${Date.now()}`,
                     prompt,
@@ -7222,9 +7259,66 @@ export async function startServer(options) {
         else {
             console.log('[spawn-manager] drain loop disabled by config.threadline.spawn.drainEnabled=false');
         }
+        // Warm-Session A2A (Arch Y, dark-ship) — keep each A2A reply thread's session
+        // alive between messages so follow-ups inject into the live worker instead of
+        // cold-spawning. Resolved via the developmentAgent gate: `enabled ?? !!dev` →
+        // LIVE on Echo, DARK on the fleet. The pool is null when disabled, so the
+        // ThreadlineRouter falls back to the proven cold-spawn path byte-for-byte.
+        const warmCfg = config.threadline?.warmSessionA2A;
+        const warmEnabled = warmCfg?.enabled ?? !!config.developmentAgent;
+        const warmSessionPool = warmEnabled
+            ? new WarmSessionPool({
+                globalCap: warmCfg?.globalCap ?? 3,
+                perPeerCap: warmCfg?.perPeerCap ?? 1,
+                ttlMs: warmCfg?.ttlMs ?? 600000,
+            })
+            : null;
+        const warmTrustFloor = warmCfg?.trustFloor ?? 'verified';
+        // Server-owned kill primitive: resolve the tmux NAME → instar session id →
+        // killSession (sessions are filed by id, not tmux name). Used for cap-eviction
+        // on admit and the periodic reap tick. Never throws to the caller.
+        const killWarmSessionByName = (sessionName) => {
+            try {
+                const rec = sessionManager.listRunningSessions().find(s => s.tmuxSession === sessionName);
+                if (rec)
+                    sessionManager.killSession(rec.id);
+                else
+                    console.log(`[warm-session] kill requested for ${sessionName} but no running session matched (already gone?)`);
+            }
+            catch (err) {
+                console.warn(`[warm-session] kill ${sessionName} failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        };
+        if (warmEnabled) {
+            console.log(`[warm-session] A2A keep-alive ENABLED (globalCap=${warmCfg?.globalCap ?? 3}, perPeerCap=${warmCfg?.perPeerCap ?? 1}, ttlMs=${warmCfg?.ttlMs ?? 600000}, trustFloor=${warmTrustFloor})`);
+        }
         // 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);
+        messageDelivery, // PR-4: live-session injection path
+        undefined, // onLedgerEvent (wired below via registerLedgerEmitters if present)
+        undefined, // nowFn
+        warmSessionPool, // Warm-Session A2A (null when disabled)
+        warmEnabled, warmTrustFloor, warmEnabled ? killWarmSessionByName : null);
+        // Warm-Session A2A reap tick — kill warm sessions idle past their TTL so a
+        // flood can't pin processes. Gated on warmEnabled; .unref() so it never holds
+        // the process open; cleared on shutdown. Eviction is lossless (the next
+        // message resumes via #746).
+        let warmReapTimer = null;
+        if (warmEnabled && warmSessionPool) {
+            warmReapTimer = setInterval(() => {
+                try {
+                    const expired = warmSessionPool.reapExpired();
+                    for (const rec of expired) {
+                        console.log(`[warm-session] reaping idle warm session ${rec.sessionName} (thread ${rec.threadId})`);
+                        killWarmSessionByName(rec.sessionName);
+                    }
+                }
+                catch (err) {
+                    console.warn(`[warm-session] reap tick failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }, 60_000);
+            warmReapTimer.unref();
+        }
         sessionManager.on('sessionComplete', (session) => {
             const sessionName = session.tmuxSession || session.name;
             if (!sessionName)
@@ -7784,11 +7878,19 @@ 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() },
                     };
+                    // Warm-Session A2A (Arch Y, dark-ship): mark this inbound as eligible for
+                    // a keep-alive interactive worker when the feature is on, it's NOT a
+                    // topic-bound reply (those go to TopicLinkageHandler), and the peer meets
+                    // the trust floor. Trust compare via the explicit ordering array
+                    // (trustMeetsFloor), NEVER string `>=`. When false (or feature off), the
+                    // router takes the proven cold-spawn path byte-for-byte.
+                    const preferWarmSession = warmEnabled && !isTopicBoundReply && trustMeetsFloor(trustLevel, warmTrustFloor);
                     const relayContext = {
                         trust: { kind: 'plaintext-tofu', senderFingerprint },
                         senderFingerprint,
                         senderName,
                         trustLevel,
+                        preferWarmSession,
                     };
                     let result = await threadlineRouter.handleInboundMessage(envelope, relayContext);
                     // Fallback for threadId-less messages
@@ -9246,17 +9348,50 @@ export async function startServer(options) {
                     const nickMod = await import('../core/NicknameCommand.js');
                     const transferMod = await import('../core/TransferByNickname.js');
                     const pinMod = await import('../core/TopicPlacementPinStore.js');
+                    const relocSetMod = await import('../core/RelocationNicknameSet.js');
+                    const nickAssignMod = await import('../core/NicknameAssigner.js');
                     _topicPinStore = new pinMod.TopicPlacementPinStore({
                         filePath: path.join(config.stateDir, 'session-pool', 'topic-pins.json'),
                     });
+                    // Authoritative resolver for THIS machine's OWN nickname. Guarantees a topic
+                    // can always be moved BACK to the machine currently handling it, even when the
+                    // capacities view omits the self nickname (the back-transfer bug: the lifeline
+                    // forwards inbound to the holder, so the relocation check runs on the very
+                    // machine the user is moving back to). Priority: capacities self-entry →
+                    // identity registry self-entry → deterministic derive (reconstructs the
+                    // auto-assigned nickname; a manual rename is persisted on the identity entry).
+                    const resolveSelfNickname = (caps) => {
+                        const fromCaps = caps.find((c) => c.machineId === meshSelfId)?.nickname;
+                        if (fromCaps)
+                            return fromCaps;
+                        try {
+                            const selfEntry = meshIdMgr
+                                .getActiveMachines()
+                                .find((m) => m.machineId === meshSelfId)?.entry;
+                            if (selfEntry?.nickname)
+                                return selfEntry.nickname;
+                            const id = meshIdMgr.hasIdentity()
+                                ? meshIdMgr.loadIdentity()
+                                : null;
+                            const derived = nickAssignMod.deriveBaseNickname(id?.name, selfEntry?.hardware?.platform);
+                            if (derived)
+                                return derived;
+                        }
+                        catch {
+                            /* @silent-fallback-ok — best-effort self-nickname resolution; on any failure we
+                               return undefined and the recognizer simply falls back to the capacities-derived
+                               set (the pre-existing behavior), so this can only ever ADD a nickname, never break. */
+                        }
+                        return undefined;
+                    };
                     _tryNicknameRelocation = async (topicId, text) => {
                         const sessionKey = String(topicId);
                         const caps = machinePoolRegistry?.getCapacities() ?? [];
-                        const nickToMachine = new Map();
-                        for (const c of caps)
-                            if (c.nickname)
-                                nickToMachine.set(c.nickname.toLowerCase(), c.machineId);
-                        const knownNicknames = caps.map((c) => c.nickname).filter((n) => !!n);
+                        const { knownNicknames, nickToMachine } = relocSetMod.buildRelocationNicknameSet({
+                            capacities: caps,
+                            selfMachineId: meshSelfId,
+                            selfNickname: resolveSelfNickname(caps),
+                        });
                         const cmd = nickMod.recognizeNicknameCommand(text, knownNicknames);
                         if (!cmd)
                             return { handled: false };
@@ -9372,7 +9507,7 @@ export async function startServer(options) {
         catch (err) {
             console.log(pc.dim(`  [session-pool] rollout gate not wired: ${err instanceof Error ? err.message : String(err)}`));
         }
-        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, rateLimitSentinel, releaseReadinessSentinel: releaseReadinessSentinel ?? undefined, messageRouter, summarySentinel, spawnManager, systemReviewer, capabilityMapper, selfKnowledgeTree, coverageAuditor, topicResumeMap: _topicResumeMap ?? undefined, sessionRefresh: _sessionRefresh ?? undefined, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, leaseTransport, onLeasePullRequest: () => leaseCoordinatorRef?.currentLease() ?? null, liveTailReceiver, handoffWireTransport, onHandoffBegin, onHandoffInitiate: handoffInitiate, handoffInProgress: handoffSentinelInProgress, messageLedger, currentInboundByTopic, replyMarkerTransport, onReplyMarker: messageLedger ? (marker) => { const m = marker; messageLedger.applyRemoteReplyMarker(m.dedupeKey, { platform: m.platform, replyIdempotencyKey: m.replyIdempotencyKey, epoch: m.epoch, topic: m.topic ?? null }); } : undefined, whatsapp: whatsappAdapter, slack: slackAdapter, imessage: imessageAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, threadlineRouter, conversationStore, warrantsReplyGate, collaborationSurfacer, threadResumeMap, topicLinkageHandler: topicLinkageHandler ?? undefined, threadlineRelayClient, threadlineReplyWaiters, listenerManager: listenerManager ?? undefined, responseReviewGate, messagingToneGate, outboundDedupGate, telemetryHeartbeat, pasteManager, featureRegistry, discoveryEvaluator, completionEvaluator, unifiedTrust, liveConfig, sharedStateLedger, ledgerSessionRegistry, worktreeManager, oidcEnrolledRepos: parallelDevConfig?.oidcEnrolledRepos, initiativeTracker, projectRoundRunner, projectDriftChecker, machineHeartbeat, machinePoolRegistry, meshRpcDispatcher, sessionOwnershipRegistry, sessionPoolE2EResultStore, proxyCoordinator, topicIntentStore, topicIntentArcCheck, usherSignalStore, intelligence: sharedIntelligence ?? undefined, telegramBridgeConfig, telegramBridge: telegramBridge ?? undefined, threadlineObservability, briefDeps, workingMemory, taskFlowRegistry, threadlineFlowBridge, sessionReaper, agentWorktreeReaper, mcpProcessReaper, geminiLoopRunner, sleepController, agentActivityState, reapLog, sleepWakeDetector, unjustifiedStopGate, stopGateDb, stopNotifier });
+        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, rateLimitSentinel, releaseReadinessSentinel: releaseReadinessSentinel ?? undefined, messageRouter, summarySentinel, spawnManager, systemReviewer, capabilityMapper, selfKnowledgeTree, coverageAuditor, topicResumeMap: _topicResumeMap ?? undefined, sessionRefresh: _sessionRefresh ?? undefined, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, leaseTransport, onLeasePullRequest: () => leaseCoordinatorRef?.currentLease() ?? null, liveTailReceiver, handoffWireTransport, onHandoffBegin, onHandoffInitiate: handoffInitiate, handoffInProgress: handoffSentinelInProgress, messageLedger, currentInboundByTopic, replyMarkerTransport, onReplyMarker: messageLedger ? (marker) => { const m = marker; messageLedger.applyRemoteReplyMarker(m.dedupeKey, { platform: m.platform, replyIdempotencyKey: m.replyIdempotencyKey, epoch: m.epoch, topic: m.topic ?? null }); } : undefined, whatsapp: whatsappAdapter, slack: slackAdapter, imessage: imessageAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, threadlineRouter, conversationStore, warrantsReplyGate, collaborationSurfacer, threadResumeMap, topicLinkageHandler: topicLinkageHandler ?? undefined, threadlineRelayClient, threadlineReplyWaiters, listenerManager: listenerManager ?? undefined, responseReviewGate, messagingToneGate, outboundDedupGate, telemetryHeartbeat, pasteManager, featureRegistry, discoveryEvaluator, completionEvaluator, unifiedTrust, liveConfig, sharedStateLedger, ledgerSessionRegistry, worktreeManager, oidcEnrolledRepos: parallelDevConfig?.oidcEnrolledRepos, initiativeTracker, projectRoundRunner, projectDriftChecker, machineHeartbeat, machinePoolRegistry, meshRpcDispatcher, sessionOwnershipRegistry, topicPinStore: _topicPinStore ?? undefined, meshSelfId: _meshSelfId ?? undefined, resolveRouterUrl: _resolveRouterUrl ?? undefined, sessionPoolE2EResultStore, proxyCoordinator, topicIntentStore, topicIntentArcCheck, usherSignalStore, intelligence: sharedIntelligence ?? undefined, telegramBridgeConfig, telegramBridge: telegramBridge ?? undefined, threadlineObservability, briefDeps, workingMemory, taskFlowRegistry, threadlineFlowBridge, sessionReaper, agentWorktreeReaper, mcpProcessReaper, geminiLoopRunner, sleepController, agentActivityState, reapLog, sleepWakeDetector, unjustifiedStopGate, stopGateDb, stopNotifier });
         // Boot-recovery (tunnel-failure-resilience spec Part 6): if the agent
         // died mid-relay-episode, the persisted tunnel.json carries
         // rotationPending=true. Rotate the dashboard PIN + authToken BEFORE
@@ -9738,6 +9873,10 @@ export async function startServer(options) {
             await notificationBatcher.flushAll(); // Drain pending notifications before exit
             notificationBatcher.stop();
             retryManager.stop();
+            if (warmReapTimer) {
+                clearInterval(warmReapTimer);
+                warmReapTimer = null;
+            } // Warm-Session A2A reap tick
             spawnManager.dispose(); // §4.4: stop drain loop + clear DRR state
             summarySentinel.stop();
             memoryMonitor.stop();