instar 1.3.92 → 1.3.93

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;AAkSH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAksDD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAqtOtE;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;AAkSH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAquDD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA8yOtE;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

@@ -298,6 +298,15 @@ let _fixDeps = null;
 // Module-level reference for session resume mapping.
 // Set once in startServer() and used by spawnSessionForTopic/respawnSessionForTopic.
 let _topicResumeMap = null;
+// ── Multi-Machine Session Pool (§L4) activation refs ──────────────────────
+// The SessionRouter is constructed in startServer()'s mesh block, but the inbound
+// dispatch handler that consults it is defined ABOVE startServer — so the router is
+// shared via this module-level ref (the same pattern as _orphanReaper/_topicResumeMap).
+// `_sessionPoolStage()` reads the live rollout stage; the inbound interception only
+// routes through the pool when it returns a non-'dark' stage, so DARK (the default)
+// is byte-identical to today's always-local dispatch. Set once in startServer().
+let _sessionRouter = null;
+let _sessionPoolStage = () => 'dark';
 /** Per-topic framework override (claude-code | codex-cli). Populated from
  *  `config.topicFrameworks` at server boot. Boot-immutable; runtime
  *  mutations go through `_topicFrameworksStore` instead so they persist
@@ -1156,6 +1165,31 @@ getHubDeps) {
         const pipeline = messageToPipeline(msg, storedTopicName);
         // Route message to corresponding session
         const targetSession = telegram.getSessionForTopic(topicId);
+        // ── Multi-Machine Session Pool (§L4): route through the pool when active ──
+        // When the rollout stage is past 'dark', consult the SessionRouter: it may
+        // forward this topic's message to the machine that OWNS the session (over the
+        // mesh) instead of handling it locally. DARK (the default) skips this block
+        // entirely → byte-identical to single-machine dispatch. Any error falls back
+        // to the local path below (fail-safe). The live-transfer behavior is gated by
+        // the staged rollout (StageAdvancer); shadow records ownership but stays local.
+        if (_sessionRouter && _sessionPoolStage() !== 'dark') {
+            try {
+                const outcome = await _sessionRouter.route({
+                    sessionKey: String(topicId),
+                    messageId: String(msg.id),
+                    payload: text,
+                });
+                if (outcome.action === 'forwarded' || outcome.action === 'duplicate') {
+                    console.log(`[session-pool] topic ${topicId} handled by owner ${outcome.owner ?? '?'} (${outcome.action}) — not dispatching locally`);
+                    return;
+                }
+                // 'handled-locally' / 'spawned'(self) / 'owner-dead-replaced' / 'queued' /
+                // 'placement-blocked' → fall through to the existing local dispatch below.
+            }
+            catch (err) {
+                console.warn(`[session-pool] route error for topic ${topicId} — falling back to local dispatch: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
         if (targetSession) {
             // Session is mapped — check if it's alive, inject or respawn
             if (sessionManager.isSessionAlive(targetSession)) {
@@ -8283,6 +8317,32 @@ export async function startServer(options) {
                         deliverSeenFallback.add(messageId);
                         return true;
                     },
+                    // Owner-side bridge (§L4 handoff): a forwarded message landed → spawn/resume
+                    // the local session for the topic so the conversation continues on THIS machine.
+                    // Only fires for a FIRST-seen forwarded deliverMessage (the ledger dedupes
+                    // redeliveries), and a deliverMessage only arrives from a router peer — but we
+                    // double-gate on stage!=='dark' to be safe. Fire-and-forget: the durable receipt
+                    // is already recorded + ACKed before this runs.
+                    onAccepted: (cmd) => {
+                        if (_sessionPoolStage() === 'dark' || !telegram)
+                            return;
+                        const tg = telegram;
+                        const topicId = Number(cmd.session);
+                        if (!Number.isFinite(topicId))
+                            return;
+                        const text = typeof cmd.payload === 'string'
+                            ? cmd.payload
+                            : (cmd.payload && typeof cmd.payload === 'object' && 'text' in cmd.payload)
+                                ? String(cmd.payload.text)
+                                : undefined;
+                        const sessionName = tg.getSessionForTopic(topicId) ?? `topic-${topicId}`;
+                        void spawnSessionForTopic(sessionManager, tg, sessionName, topicId, text, undefined, undefined)
+                            .then((name) => {
+                            tg.registerTopicSession(topicId, name, sessionName);
+                            console.log(pc.green(`  [session-pool] owner-side resume for forwarded topic ${topicId} → ${name}`));
+                        })
+                            .catch((err) => console.warn(`  [session-pool] owner-side resume failed for topic ${topicId}: ${err instanceof Error ? err.message : String(err)}`));
+                    },
                 });
                 meshRpcDispatcher = new meshMod.MeshRpcDispatcher({
                     verify: {
@@ -8328,6 +8388,76 @@ export async function startServer(options) {
                     },
                     logger: (m) => console.log(pc.dim(`  ${m}`)),
                 });
+                // ── L4 SessionRouter (activation transport) — shared via _sessionRouter ──
+                // Constructed with the real registry/ownership/placement + the outbound
+                // MeshRpcClient so it can reach peers. INERT until the rollout stage advances
+                // past 'dark': the inbound dispatch interception only consults it when
+                // _sessionPoolStage() !== 'dark'. Single-machine → placement keeps everything local.
+                try {
+                    const routerMod = await import('../core/SessionRouter.js');
+                    const placeMod = await import('../core/PlacementExecutor.js');
+                    const clientMod = await import('../core/MeshRpcClient.js');
+                    let routerNonce = 0;
+                    const meshClient = new clientMod.MeshRpcClient({
+                        selfMachineId: meshSelfId,
+                        sign: (c) => idMod.sign(c, localSigningKeyPem),
+                        nonce: () => `${meshSelfId}:r:${Date.now()}:${++routerNonce}`,
+                        now: () => Date.now(),
+                    });
+                    const peerUrl = (machineId) => meshIdMgr.getActiveMachines().find((m) => m.machineId === machineId)?.entry.lastKnownUrl ?? null;
+                    _sessionRouter = new routerMod.SessionRouter({
+                        selfMachineId: meshSelfId,
+                        placement: new placeMod.PlacementExecutor(),
+                        machineRegistry: () => machinePoolRegistry?.getCapacities() ?? [],
+                        resolveOwnership: (sk) => {
+                            const r = ownReg.read(sk);
+                            if (!r)
+                                return { owner: null, epoch: 0, status: null };
+                            const status = r.status === 'released' ? null : r.status;
+                            return { owner: ownReg.ownerOf(sk), epoch: r.ownershipEpoch, status, target: ownReg.placementTargetOf(sk) ?? undefined };
+                        },
+                        isMachineAlive: (m) => m === meshSelfId || (machinePoolRegistry?.getCapacity(m)?.online ?? false),
+                        casClaimOwnership: (sk, machineId) => {
+                            const r = ownReg.cas({ type: 'place', machineId }, { sessionKey: sk, sender: meshSelfId, nonce: `${meshSelfId}:c:${++routerNonce}` });
+                            return { ok: r.ok, epoch: ownReg.read(sk)?.ownershipEpoch ?? 0 };
+                        },
+                        deliverMessage: async (target, env) => {
+                            const url = peerUrl(target);
+                            if (!url)
+                                throw new Error(`no peer url for ${target}`);
+                            const res = await meshClient.send({ machineId: target, url }, { type: 'deliverMessage', session: env.sessionKey, messageId: env.messageId, payload: env.payload, ownershipEpoch: env.ownershipEpoch }, env.ownershipEpoch);
+                            if (res.ok && res.result && typeof res.result === 'object' && 'accepted' in res.result) {
+                                return res.result;
+                            }
+                            throw new Error(`deliverMessage rejected: ${res.status} ${res.reason ?? ''}`);
+                        },
+                        spawnOnMachine: async (machineId, msg) => {
+                            const url = peerUrl(machineId);
+                            if (!url)
+                                throw new Error(`no peer url for ${machineId}`);
+                            await meshClient.send({ machineId, url }, { type: 'deliverMessage', session: msg.sessionKey, messageId: msg.messageId, payload: msg.payload, ownershipEpoch: 0 }, 0);
+                        },
+                        handleLocally: async () => { },
+                        queueMessage: () => { },
+                        raiseAttention: (title, body) => console.log(pc.dim(`  [session-router] attention: ${title} — ${body}`)),
+                        sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+                        log: (line) => console.log(pc.dim(`  [session-router] ${line}`)),
+                    });
+                    _sessionPoolStage = () => {
+                        try {
+                            const fallback = (config.multiMachine?.sessionPool ?? {});
+                            const live = liveConfig.get('multiMachine.sessionPool', fallback);
+                            return live?.enabled && live?.stage ? String(live.stage) : 'dark';
+                        }
+                        catch {
+                            return 'dark';
+                        }
+                    };
+                    console.log(pc.green('  SessionRouter wired (L4) — inert until rollout stage advances past dark'));
+                }
+                catch (err) {
+                    console.log(pc.dim(`  [session-router] not wired: ${err instanceof Error ? err.message : String(err)}`));
+                }
             }
         }
         catch (err) {