instar 1.3.1345 → 1.3.1347

package/dist/commands/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"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"}

package/dist/commands/server.js

@@ -242,7 +242,14 @@ import { ConversationStore } from '../threadline/ConversationStore.js';
 import { ThreadLog } from '../threadline/ThreadLog.js';
 import { ThreadMessageRecorder } from '../threadline/recordThreadMessage.js';
 import { recordInboundAck } from '../threadline/recordInboundAck.js';
-import { isAutoAckInbound, autoAckRecognition, looksLikeAutoAckText, createAckRateLimiter, runRelayAckStage } from '../threadline/autoAck.js';
+import { isAutoAckInbound, autoAckRecognition, looksLikeAutoAckText, createAckRateLimiter, runRelayAckStage, createRelayAckSettler, describeUndeliveredRouterResult } from '../threadline/autoAck.js';
+/** ACT-091: the session manager's observed paste → the topic handler's inject outcome (starts the busy watch lazily). */
+function liveInjectOutcomeFromObservation(r) {
+    if (r.state === 'queued-busy')
+        return { state: 'queued-busy', settled: r.settle() };
+    return { state: r.state };
+}
+import { createThreadlineTopicRespawn } from '../threadline/topicRespawnHook.js';
 import { WarrantsReplyGate, evaluateAndRecordInbound } from '../threadline/WarrantsReplyGate.js';
 import { CollaborationSurfacer } from '../threadline/CollaborationSurfacer.js';
 import { ListenerSessionManager } from '../threadline/ListenerSessionManager.js';
@@ -586,6 +593,12 @@ let _sweptInboundStore = null;
 // The drain's local-delivery tail (§3.1 via:'drain') — assigned inside
 // wireTelegramRouting where the session primitives live in scope.
 let _drainLocalDeliver = null;
+// ACT-091: wake a topic's dead/reaped session for a topic-bound Threadline
+// reply — assigned inside wireTelegramRouting where the respawn primitives
+// (and the per-topic spawn guard) live in scope. Null ⇒ not wired.
+let _threadlineTopicRespawn = null;
+/** ACT-091: "is a spawn for this topic in flight?" — the spawningTopics read, for the handler. */
+let _threadlineTopicSpawning = null;
 // Emergency-stop integration (§3.6): marks a topic stopped for the drain's
 // pass/batch/chokepoint consults AND settles its custody (terminal
 // operator-stop + PIS cleanup + loss report). Set with the engine.
@@ -3049,6 +3062,72 @@ getHubClassifierDeps) {
             spawningTopics.clear(topicId, _spawnTokD);
         }
     };
+    // ── ACT-091: topic-bound Threadline reply into a dead/reaped topic session ──
+    // The decision lives in createThreadlineTopicRespawn (testable); this binds
+    // it to the REAL primitives the Telegram dead-session path uses: ownership,
+    // the G3 lease gate, the death classification, SpawnAdmission (its own
+    // journal-only callsite), the spawningTopics guard, respawnSessionForTopic
+    // (--resume) / spawnSessionForTopic, each awaited through the initial
+    // injection. A spawn already in flight is WAITED for, then the reply is typed
+    // into the live session — a second reply inside one respawn is never lost.
+    {
+        _threadlineTopicSpawning = (topicId) => spawningTopics.has(topicId);
+        _threadlineTopicRespawn = createThreadlineTopicRespawn({
+            spawning: spawningTopics,
+            ownedElsewhere: (topicId) => {
+                if (!_ownershipReadForDrain || !_meshSelfId)
+                    return false;
+                const ownRec = _ownershipReadForDrain(String(topicId));
+                return !!ownRec && ownRec.status === 'active' && ownRec.ownerMachineId !== _meshSelfId;
+            },
+            registeredSession: (topicId) => telegram.getSessionForTopic(topicId),
+            isSessionAlive: (name) => sessionManager.isSessionAlive(name),
+            injectConfirmed: async (name, text) => liveInjectOutcomeFromObservation(await sessionManager.injectPasteNotificationObserved(name, text)),
+            leaseGate: (topicId) => g3ShouldSpawnLocally(topicId),
+            classifyDeath: (name) => {
+                try {
+                    const output = sessionManager.captureOutput(name, 100);
+                    if (!output)
+                        return null;
+                    const death = classifySessionDeath(output, quotaTracker?.getState() ?? null);
+                    if (death.cause === 'quota_exhaustion' && death.confidence !== 'low')
+                        return 'quota';
+                    if (death.cause === 'context_exhausted')
+                        return 'context-exhausted';
+                    return 'other';
+                }
+                catch {
+                    return null; /* @silent-fallback-ok: classification failed — respawn as the Telegram dead path does */
+                }
+            },
+            admit: (topicId) => {
+                if (!_spawnAdmission)
+                    return { allow: true };
+                try {
+                    const d = _spawnAdmission.admit({ sessionKey: String(topicId), callsite: 'threadline-topic-respawn' });
+                    if (d.allow)
+                        _ladderDryRunConsult(d, String(topicId), topicId);
+                    return { allow: d.allow, reason: d.reason };
+                }
+                catch (err) {
+                    // Same posture as the Telegram seam: an admission ERROR fails open.
+                    console.warn(`[spawn-admission] threadline-topic-respawn admit error (fail-open): ${err instanceof Error ? err.message : String(err)}`);
+                    return { allow: true };
+                }
+            },
+            respawn: async (name, topicId, text, fresh) => {
+                if (fresh)
+                    _topicResumeMap?.remove(topicId);
+                await respawnSessionForTopic(sessionManager, telegram, name, topicId, text, topicMemory, undefined, undefined, { silent: true, awaitInitialInjection: true });
+            },
+            coldSpawn: async (topicId, text) => {
+                const topicName = telegram.getTopicName(topicId) || `topic-${topicId}`;
+                const newSessionName = await spawnSessionForTopic(sessionManager, telegram, topicName, topicId, text, topicMemory, undefined, undefined, undefined, { awaitInitialInjection: true });
+                telegram.registerTopicSession(topicId, newSessionName, topicName);
+                return newSessionName;
+            },
+        });
+    }
 }
 /**
  * Wire WhatsApp message routing: incoming messages → Claude sessions.
@@ -16834,9 +16913,11 @@ export async function startServer(options) {
                     // Confirm the inject actually submitted (not left stuck at the prompt
                     // by the paste-end race). A bare dispatch returning true is the A2 bug:
                     // a stalled inject must NOT count as delivered, so the Telegram fallback
-                    // surfaces the reply instead.
+                    // surfaces the reply instead. A paste into a MID-TURN session is
+                    // reported `queued-busy` (provisional) — the handler finishes the
+                    // route from the late verdict (ACT-091).
                     try {
-                        return await sessionManager.injectPasteNotificationConfirmed(sessionName, text);
+                        return liveInjectOutcomeFromObservation(await sessionManager.injectPasteNotificationObserved(sessionName, text));
                     }
                     catch {
                         return false;
@@ -16856,6 +16937,12 @@ export async function startServer(options) {
                 getSessionForTopic: telegram
                     ? (topicId) => telegram.getSessionForTopic(topicId)
                     : undefined,
+                // ACT-091: a reply into a reaped topic session wakes it (late-bound —
+                // Telegram routing is wired after this handler is constructed).
+                respawnTopicSession: (args) => _threadlineTopicRespawn
+                    ? _threadlineTopicRespawn(args)
+                    : Promise.resolve({ delivered: false, reason: 'telegram-routing-not-wired' }),
+                isTopicSpawning: (topicId) => _threadlineTopicSpawning?.(topicId) === true,
                 // A2A cross-machine route §5: a topic-bound reply is typed into the
                 // topic's live session on whichever machine has it. Late-bound: the
                 // mesh client exists only after the multi-machine wiring below.
@@ -17373,15 +17460,29 @@ export async function startServer(options) {
                     // the implicit delivery ack + the ledger disposition `no-reply` and the
                     // handler RETURNS here, before the auto-ack send, the inbox append, the
                     // Telegram mirror and the gate. Any other message gets our own ack
-                    // (post-trust-verification, never for status messages, rate-limited).
+                    // (post-trust-verification, never for status messages, rate-limited)
+                    // once routing has an outcome — see relayAck below.
                     const recordRelayDelivery = () => recordInboundAck({ a2aDeliveryTracker }, { threadId: msg.threadId, senderFingerprint, senderName: senderName ?? null });
-                    const ackStage = runRelayAckStage({
+                    // ACT-091: any hand-off can reach no live consumer (a reaped topic
+                    // session, a refused or queued spawn, a listener gone stale), so
+                    // our ack — which promises a reply — waits for the routing outcome on
+                    // EVERY path. Each terminal exit below calls relayAck.settle(...) just
+                    // before it returns; an exit that settles nothing (a throw) sends no
+                    // ack, which is the honest result when nothing received the message.
+                    const isTopicBoundReply = !!msg.threadId && threadResumeMap.get(msg.threadId)?.originTopicId !== undefined;
+                    const relayAckDeps = {
                         autoAckEnabled: config.threadline?.autoAck !== false,
                         autoAckMessage: config.threadline?.autoAckMessage,
                         isAckRateLimited,
                         sendAck: (to, text, threadId) => { threadlineRelayClient.sendAck(to, text, threadId); },
                         recordDelivery: recordRelayDelivery,
-                    }, { isAutoAck, trustLevel, msgType, senderFingerprint, threadId: msg.threadId, ticket: ledgerTicket });
+                    };
+                    const relayAckInput = {
+                        isAutoAck, trustLevel, msgType, senderFingerprint, threadId: msg.threadId, ticket: ledgerTicket,
+                        deferSend: true,
+                    };
+                    const relayAck = createRelayAckSettler(relayAckDeps, relayAckInput);
+                    const ackStage = runRelayAckStage(relayAckDeps, relayAckInput);
                     if (ackStage === 'ack-consumed') {
                         console.log(`[relay] delivery ack from ${senderName} (thread: ${msg.threadId ?? 'none'}, by ${autoAckRecognition({ type: msgType, text: textContent })}) recorded — not acked, not routed`);
                         return;
@@ -17462,6 +17563,11 @@ export async function startServer(options) {
                                 else
                                     ledgerTicket?.recordNoReply();
                                 console.log(`[relay] warrants-reply gate suppressed reply (${decision.verdict.signal}) for ${senderName} thread ${gateThreadId.slice(0, 8)}`);
+                                // ACT-091: the ack on a terminal no-reply exit (a no-reply verdict
+                                // or an exhausted loop budget) is the non-promising "Message
+                                // received." — received, deliberately not answered — so the
+                                // sender's tracker never reads a stuck channel.
+                                relayAck.settle('no-reply');
                                 // On budget exhaustion, surface ONE status notice — never silently
                                 // drop. CMT-519: route it to the SILENT Threadline hub (not a
                                 // per-event attention topic, not the parent topic the operator is
@@ -17499,8 +17605,9 @@ export async function startServer(options) {
                     }
                     // Phase 2a: Pipe-mode session for simple queries (lightweight, auto-exit)
                     // Rapid-fire same-thread guard: if an active pipe session already exists for this
-                    // thread, fall through to the listener/cold-spawn path so messages queue serially
-                    // via ListenerSessionManager.writeToInbox instead of killing the prior tmux session.
+                    // thread, fall through to the listener/router path instead of killing the prior
+                    // tmux session. With no proven listener reader that is the router, which does not
+                    // know about the pipe session: a second session may answer on the same thread.
                     if (pipeSpawner &&
                         msg.threadId &&
                         !threadResumeMap.get(msg.threadId) &&
@@ -17533,6 +17640,9 @@ export async function startServer(options) {
                                     if (result.spawned) {
                                         ledgerTicket?.recordHandoff('pipe');
                                         console.log(`[relay] Pipe session spawned for ${senderName} (thread: ${msg.threadId.slice(0, 8)})`);
+                                        // ACT-091: the pipe session exists and the message is its
+                                        // prompt — a live consumer has it, so the ack goes out now.
+                                        relayAck.settle('pipe-spawned');
                                         return;
                                     }
                                 }
@@ -17543,6 +17653,9 @@ export async function startServer(options) {
                         }
                     }
                     // Phase 2b: Route to warm listener if available and appropriate.
+                    // shouldUseListener is false unless a live inbox reader is PROVEN (a
+                    // fresh heartbeat); with none, the message falls through to the router
+                    // below instead of being written to a file nothing reads.
                     // EXCEPT topic-bound replies: a reply on a thread bound to a Telegram
                     // topic must reach handleInboundMessage → TopicLinkageHandler so it
                     // surfaces in the bound topic. The listener inbox is a side-channel
@@ -17551,11 +17664,19 @@ export async function startServer(options) {
                     // for the user even though transport succeeded. (The pipe-spawn branch
                     // above is already excluded for topic-bound threads via its
                     // `!threadResumeMap.get(...)` guard, now that get() no longer nulls them.)
-                    const isTopicBoundReply = !!msg.threadId && threadResumeMap.get(msg.threadId)?.originTopicId !== undefined;
                     if (listenerManager && listenerManager.shouldUseListener(trustLevel, textContent.length) && !isTopicBoundReply) {
                         listenerManager.writeToInbox({ from: senderFingerprint, senderName, trustLevel, threadId: msg.threadId ?? getSyntheticThreadId(senderFingerprint), text: ledgerNotice ? `[server notice: ${ledgerNotice}]\n\n${textContent}` : textContent });
                         ledgerTicket?.recordHandoff('listener');
                         console.log(`[relay] Routed to listener inbox from ${senderName} (trust: ${trustLevel})`);
+                        // ACT-091: shouldUseListener is true only while a reader's heartbeat
+                        // is fresh (ListenerSessionManager.hasLiveReader), so this hand-off
+                        // reaches a proven live reader and gets the promising ack. Re-read
+                        // after the write: if the heartbeat went stale in between, the write
+                        // is only a queue entry and the ack is withheld.
+                        const listenerAck = relayAck.settle(listenerManager.hasLiveReader() ? 'listener-delivered' : 'listener-queued');
+                        if (listenerAck === 'skipped-undelivered') {
+                            console.warn(`[relay] Auto-ack withheld for ${senderName} (thread: ${msg.threadId ?? 'none'}) — queued in the listener inbox; no live listener is proven`);
+                        }
                         return;
                     }
                     // Route through ThreadlineRouter (cold-spawn path)
@@ -17596,6 +17717,35 @@ export async function startServer(options) {
                         console.log(`[relay] Spawned session for ${senderName} (trust: ${trustLevel}, thread: ${result.threadId})`);
                     if (result.resumed)
                         console.log(`[relay] Resumed session for ${senderName} (thread: ${result.threadId})`);
+                    if (result.handled && result.delivered === false && !result.deliveryPending) {
+                        console.warn(`[relay] Message from ${senderName} (thread: ${result.threadId}) accepted but not delivered to a live session${result.queued ? ' (queued)' : ''}`);
+                    }
+                    // ACT-091: the last exit — the ack follows the router's own report of
+                    // a live hand-off (cold spawn, resumed/warm session, topic session).
+                    // A capacity refusal the spawn manager queued (`queued: true`) is
+                    // still undelivered: no ack, logged as queued — the decision and its
+                    // reasons are at describeUndeliveredRouterResult.
+                    if (result.deliveryPending) {
+                        // The reply was typed into a live session that is mid-turn, so it
+                        // sits as queued input: not delivered YET. The ack is settled from
+                        // the late verdict (bounded by the session manager's watch
+                        // ceiling), through the same one-shot settler — the promising ack
+                        // is sent only once the text has actually left the prompt.
+                        console.log(`[relay] Delivery to ${senderName} (thread: ${result.threadId}) pending — queued in a busy live session; the ack waits for the text to leave the prompt`);
+                        void result.deliveryPending.then(({ delivered, reason }) => {
+                            const late = relayAck.settle(delivered ? 'router-delivered' : 'router-undelivered');
+                            if (delivered)
+                                console.log(`[relay] Queued reply for ${senderName} (thread: ${result.threadId}) left the prompt (${reason}) — delivered${late === 'sent' ? ', ack sent' : ''}`);
+                            else
+                                console.warn(`[relay] Auto-ack withheld for ${senderName} (thread: ${result.threadId}) — queued text never left the prompt (${reason})`);
+                        });
+                    }
+                    else {
+                        const ackOutcome = relayAck.settle(result.delivered === true ? 'router-delivered' : 'router-undelivered');
+                        if (ackOutcome === 'skipped-undelivered') {
+                            console.warn(`[relay] Auto-ack withheld for ${senderName} (thread: ${result.threadId}) — ${describeUndeliveredRouterResult(result)}`);
+                        }
+                    }
                 }
                 // Relay client is passed to AgentServer → RouteContext for the /threadline/relay-send endpoint
                 // Report the client's ACTUAL state. This line used to say "connected"