mixdog 0.9.55 → 0.9.59

package/src/runtime/agent/orchestrator/session/manager/ask-session.mjs

@@ -6,7 +6,7 @@
 import { createHash } from 'crypto';
 import { getProvider } from '../../providers/registry.mjs';
 import { normalizeCompactType, DEFAULT_COMPACT_TYPE } from '../compact.mjs';
-import { loadSession, saveSessionAsync, saveSessionAsyncDeferred } from '../store.mjs';
+import { loadSession, saveSessionAsync, saveSessionAsyncDeferred, readSessionLifecycleFromDisk } from '../store.mjs';
 import { createAbortController } from '../../../../shared/abort-controller.mjs';
 import { logLlmCall } from '../../../../shared/llm/usage-log.mjs';
 import { appendAgentTrace } from '../../agent-trace.mjs';
@@ -59,6 +59,70 @@ import { _getAgentLoop } from './runtime-loaders.mjs';
 import { getAgentRuntimeSync } from './agent-runtime-singleton.mjs';
 import { recordProviderContextBaseline } from '../loop/compact-policy.mjs';
 
+export function persistedAssistantTranscriptMetadata(value, fallbackAt = Date.now()) {
+    if (!value || typeof value !== 'object') return null;
+    const candidateAt = Number(value.assistantAt);
+    const assistantAt = Number.isFinite(candidateAt) && candidateAt > 0 ? candidateAt : fallbackAt;
+    value.assistantAt = assistantAt;
+    return {
+        at: assistantAt,
+        ...(typeof value.model === 'string' && value.model ? { model: value.model } : {}),
+        ...(typeof value.provider === 'string' && value.provider ? { provider: value.provider } : {}),
+        ...(typeof value.agent === 'string' && value.agent ? { agent: value.agent } : {}),
+    };
+}
+
+export function attachAssistantTranscriptCompletion(messages, completion, turnStartedAt = 0) {
+    if (!Array.isArray(messages) || !completion || typeof completion !== 'object') return false;
+    const elapsedMs = Math.max(0, Number(completion.elapsedMs || 0));
+    const status = typeof completion.status === 'string' && completion.status
+        ? completion.status
+        : 'done';
+    const verb = typeof completion.verb === 'string' && completion.verb
+        ? completion.verb
+        : 'Thought';
+    let turnStart = -1;
+    const expectedAt = Number(turnStartedAt || 0);
+    if (expectedAt > 0) {
+        for (let index = messages.length - 1; index >= 0; index -= 1) {
+            const message = messages[index];
+            if (message?.role !== 'user') continue;
+            if (Number(message?.meta?.transcript?.at || 0) !== expectedAt) continue;
+            turnStart = index;
+            break;
+        }
+    }
+    for (let index = messages.length - 1; index > turnStart; index -= 1) {
+        const message = messages[index];
+        if (message?.role !== 'assistant') continue;
+        const content = message.content;
+        const hasVisibleText = typeof content === 'string'
+            ? Boolean(content.trim())
+            : Array.isArray(content) && content.some((part) => {
+                if (typeof part === 'string') return Boolean(part.trim());
+                if (!part || typeof part !== 'object') return false;
+                return Boolean(String(part.text || part.content || '').trim());
+            });
+        if (!hasVisibleText) continue;
+        const meta = message.meta && typeof message.meta === 'object' ? message.meta : {};
+        const transcript = meta.transcript && typeof meta.transcript === 'object'
+            ? meta.transcript
+            : {};
+        messages[index] = {
+            ...message,
+            meta: {
+                ...meta,
+                transcript: {
+                    ...transcript,
+                    completion: { status, verb, elapsedMs },
+                },
+            },
+        };
+        return true;
+    }
+    return false;
+}
+
 /**
  * Wrap an async call so that if the session's controller aborts mid-flight,
  * the wrapper settles with a SessionClosedError even if the underlying promise
@@ -102,6 +166,20 @@ export async function _api_call_with_interrupt(sessionId, fn) {
 
 export async function askSession(sessionId, prompt, context, onToolCall, cwdOverride, explicitPrefetch, askOpts = {}) {
     const _askStartedAt = Date.now();
+    const _rawTranscriptMeta = askOpts?.transcriptMeta;
+    const _transcriptMeta = _rawTranscriptMeta && typeof _rawTranscriptMeta === 'object'
+        ? {
+            ...(Number.isFinite(Number(_rawTranscriptMeta.at)) ? { at: Number(_rawTranscriptMeta.at) } : {}),
+            ...(typeof _rawTranscriptMeta.model === 'string' && _rawTranscriptMeta.model ? { model: _rawTranscriptMeta.model } : {}),
+            ...(typeof _rawTranscriptMeta.provider === 'string' && _rawTranscriptMeta.provider ? { provider: _rawTranscriptMeta.provider } : {}),
+            ...(typeof _rawTranscriptMeta.agent === 'string' && _rawTranscriptMeta.agent ? { agent: _rawTranscriptMeta.agent } : {}),
+        }
+        : null;
+    const _takeAssistantTranscriptMetadata = () => {
+        const metadata = persistedAssistantTranscriptMetadata(_rawTranscriptMeta);
+        if (_rawTranscriptMeta && typeof _rawTranscriptMeta === 'object') delete _rawTranscriptMeta.assistantAt;
+        return metadata;
+    };
     const _promptSrc = 'prompt';
     const _prefetchFiles = (explicitPrefetch?.files?.length) || 0;
     const _prefetchCallers = (explicitPrefetch?.callers?.length) || 0;
@@ -188,6 +266,19 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         // recover the stale transient stage before the loop's pre-send compact
         // path runs (it will overwrite lastStage with real telemetry).
         normalizeStaleCompactingStage(preSession);
+        // Split-brain re-adoption: another surface (e.g. desktop click-through
+        // of a session still actively owned by this process) may have
+        // resumed-and-detached this session, bumping the ON-DISK generation
+        // while the conversation kept going here. Every save from this process
+        // would then be silently dropped by _shouldDrop's ownership rule and
+        // the on-disk transcript would freeze at the last landed save. A new
+        // ask on a NON-closed session is an explicit ownership claim: adopt
+        // the disk generation so this turn's commits land and heal the file.
+        const diskLifecycle = readSessionLifecycleFromDisk(sessionId);
+        if (diskLifecycle && diskLifecycle.closed !== true
+            && diskLifecycle.generation > (typeof preSession.generation === 'number' ? preSession.generation : 0)) {
+            preSession.generation = diskLifecycle.generation;
+        }
         askGeneration = typeof preSession.generation === 'number' ? preSession.generation : 0;
         const runtime = _touchRuntime(sessionId);
         // Preserve any parent-abort link agent-dispatch established BEFORE we
@@ -299,7 +390,11 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 session.sessionStartMetaInjected = true;
             }
             cancelledUserTurnContent = _userTurnContent;
-            const outgoing = [...historyMessages, { role: 'user', content: _userTurnContent }];
+            const outgoing = [...historyMessages, {
+                role: 'user',
+                content: _userTurnContent,
+                ...(_transcriptMeta ? { meta: { transcript: _transcriptMeta } } : {}),
+            }];
             _turnOutgoing = outgoing;
             // Expose the in-flight working transcript so contextStatus() can
             // estimate the LIVE context footprint mid-turn. agentLoop mutates
@@ -403,6 +498,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     onTextReset: _trackTextReset,
                     onReasoningDelta: _trackReasoningDelta,
                     onAssistantText: _trackAssistantText,
+                    takeAssistantTranscriptMetadata: _takeAssistantTranscriptMetadata,
                     onAssistantMessageCommitted: () => _turnInterruption.markAssistantMessageCommitted(),
                     onAssistantToolCallObserved: (call, detail) => _turnInterruption.recordToolCalls([call], detail),
                     onProviderSendStarted: () => _turnInterruption.markProviderSendStarted(),
@@ -503,6 +599,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // Turn committed into session.messages; drop the live-turn alias so
             // contextStatus() reverts to the authoritative committed transcript.
             session.liveTurnMessages = null;
+            const _assistantTranscriptMeta = persistedAssistantTranscriptMetadata(_rawTranscriptMeta);
             if (result.content || result.reasoningContent) {
                 // Max-output recovery returns the complete concatenated text to
                 // callers/TUI, while outgoing already contains prior partial
@@ -518,6 +615,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     // if any, are swapped for a placeholder only at disk write
                     // time inside the session store (store.mjs _sessionForDisk).
                     content: persistedAssistantContent,
+                    ...(_assistantTranscriptMeta ? { meta: { transcript: _assistantTranscriptMeta } } : {}),
                     ...(typeof result.reasoningContent === 'string' && result.reasoningContent
                         ? { reasoningContent: result.reasoningContent }
                         : {}),
@@ -553,6 +651,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     role: 'assistant',
                     content: '',
                     emptyFinal: true,
+                    ...(_assistantTranscriptMeta ? { meta: { transcript: _assistantTranscriptMeta } } : {}),
                     stopReason: _emptyStop,
                     iterations: result?.iterations ?? null,
                     toolCallsTotal: result?.toolCallsTotal ?? null,
@@ -668,6 +767,14 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // replay; duplicate memory/spool copies share the same id.
             recordPendingMessageDelivery(session, _turnPendingEntries);
             _pwstTurnDrained = drainPendingMessages(sessionId);
+            if (_pwstTurnDrained.length === 0) {
+                const turnStartedAt = Number(_rawTranscriptMeta?.at || _askStartedAt);
+                attachAssistantTranscriptCompletion(session.messages, {
+                    status: 'done',
+                    verb: _rawTranscriptMeta?.completionVerb,
+                    elapsedMs: Date.now() - turnStartedAt,
+                }, turnStartedAt);
+            }
             let terminalRelayed = false;
             if (_pwstTurnDrained.length === 0 && typeof askOpts?.onTerminalResult === 'function') {
                 terminalRelayed = true;

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -200,6 +200,7 @@ async function runRecallFastTrackForSession(session, messages, opts = {}) {
             limit: positiveContextWindow(session?.compaction?.recallDigestLimit) || 30,
             includeMembers: true,
             includeRaw: true,
+            compactDigest: true,
         }, callerCtx, memoryTimeoutMs);
         recallText = typeof browsed === 'string' ? browsed : String(browsed?.text ?? browsed ?? '');
     } catch (err) {
@@ -270,7 +271,7 @@ export async function runSessionCompaction(session, opts = {}) {
     const targetBudgetTokens = alignedPolicy
         ? (compactTargetBudgetForPolicy({ ...alignedPolicy, force }) || boundary)
         : boundary;
-    const pressureTokens = estimateTranscriptContextUsage(messages, session.tools || []);
+    const pressureTokens = estimateTranscriptContextUsage(messages, session.tools || [], { provider: session.provider });
     const beforeTokens = pressureTokens;
     // Manual /compact may explicitly request the original semantic path:
     // summarize THIS session's transcript directly without hydrating/searching
@@ -322,6 +323,7 @@ export async function runSessionCompaction(session, opts = {}) {
                 recallText: recallPayload.recallText,
                 query: recallPayload.query,
                 querySha: recallPayload.querySha,
+                cwd: session.cwd,
                 // Ingest just ran on the live transcript, so an empty recall dump
                 // means the memory pipeline is broken — do NOT erase history
                 // behind an empty summary shell. Empty recall now throws and is
@@ -352,12 +354,13 @@ export async function runSessionCompaction(session, opts = {}) {
                     semanticCompactResult = await semanticCompactMessages(
                         provider,
                         messages,
-                        opts.model || session.model,
+                        opts.model || resolveSemanticSummaryModel(session, { budgetTokens: budget }) || session.model,
                         budget,
                         {
                             reserveTokens,
                             providerName: session.provider || provider?.name || null,
                             sessionId: opts.sessionId || session.id || null,
+                            cwd: session.cwd,
                             signal: opts.signal || null,
                             promptCacheKey: session.promptCacheKey || null,
                             providerCacheKey: session.promptCacheKey || null,
@@ -396,12 +399,13 @@ export async function runSessionCompaction(session, opts = {}) {
             semanticCompactResult = await semanticCompactMessages(
                 provider,
                 messages,
-                opts.model || session.model,
+                opts.model || resolveSemanticSummaryModel(session, { budgetTokens: budget }) || session.model,
                 budget,
                 {
                     reserveTokens,
                     providerName: session.provider || provider?.name || null,
                     sessionId: opts.sessionId || session.id || null,
+                    cwd: session.cwd,
                     signal: opts.signal || null,
                     promptCacheKey: session.promptCacheKey || null,
                     providerCacheKey: session.promptCacheKey || null,
@@ -552,9 +556,13 @@ export async function runSessionCompaction(session, opts = {}) {
         lastChangedAt: changed ? now : session.compaction?.lastChangedAt || null,
         lastCompactAt: changed ? now : session.compaction?.lastCompactAt || null,
         lastSemantic: semanticCompactResult?.semantic === true,
-        lastSemanticError: semanticCompactError?.message || null,
+        // This is a terminal success record. A failed component may have been
+        // recovered by semantic compaction or pruning, but must not remain as a
+        // status/UI failure after the final compacted transcript is accepted.
+        lastSemanticError: null,
         lastRecallFastTrack: recallFastTrackResult?.recallFastTrack === true,
-        lastRecallFastTrackError: recallFastTrackError?.message || null,
+        lastRecallFastTrackError: null,
+        lastError: null,
         lastRecallFastTrackQuerySha: recallFastTrackResult?.query ? createHash('sha256').update(recallFastTrackResult.query).digest('hex').slice(0, 16) : null,
         lastSemanticUsage: semanticCompactResult?.usage ? {
             inputTokens: semanticCompactResult.usage.inputTokens || 0,
@@ -584,9 +592,9 @@ export async function runSessionCompaction(session, opts = {}) {
         targetBudgetTokens: budget,
         reserveTokens,
         semanticCompact: semanticCompactResult?.semantic === true,
-        semanticError: semanticCompactError?.message || null,
+        semanticError: null,
         recallFastTrack: recallFastTrackResult?.recallFastTrack === true,
-        recallFastTrackError: recallFastTrackError?.message || null,
+        recallFastTrackError: null,
         usage: semanticCompactResult?.usage || null,
     };
 }

package/src/runtime/agent/orchestrator/session/manager/idle-cleanup.mjs

@@ -2,16 +2,14 @@
 // Periodic idle-session + tombstone sweep extracted verbatim from manager.mjs.
 // Drives sweepStaleSessions on an unref'd interval; closeSession is imported
 // from session-close.mjs (one-way dependency, no cycle).
-import { sweepStaleSessions } from '../store.mjs';
+import { sweepStaleSessions, evictIdleLiveSessions } from '../store.mjs';
 import { sweepOrphanedPendingMessages } from './pending-messages.mjs';
 import {
     _getRuntimeEntry,
     _clearSessionRuntime,
-    _runtimeEntries,
     _sweepTerminalSessionRuntimes,
 } from './runtime-liveness.mjs';
 import { _closeBashSessionLazy } from './runtime-loaders.mjs';
-import { closeSession } from './session-close.mjs';
 import { nonNegativeIntEnv } from './env-utils.mjs';
 
 // --- Periodic idle session cleanup ---
@@ -41,6 +39,32 @@ function _previewIds(items, limit = 5) {
     return ` (${ids.join(', ')}${more})`;
 }
 
+const IN_FLIGHT_STAGES = new Set(['connecting', 'requesting', 'streaming', 'tool_running', 'cancelling']);
+
+export function _finalizeSweptSessionRuntime(detail) {
+    if (!detail?.id) return false;
+    const rtEntry = _getRuntimeEntry(detail.id);
+    // The store scan and this runtime cleanup are not atomic. If the session
+    // became active after the scan, leave its controller and runtime untouched;
+    // a later idle cycle can reconsider it after the work settles.
+    if (rtEntry && (
+        (rtEntry.controller && !rtEntry.controller.signal?.aborted)
+        || IN_FLIGHT_STAGES.has(rtEntry.stage)
+    )) return false;
+    _clearSessionRuntime(detail.id);
+    if (detail.bashSessionId) {
+        try { _closeBashSessionLazy(detail.bashSessionId, `idle-sweep:${detail.id}`); } catch { /* ignore */ }
+    }
+    return true;
+}
+
+// Informational sweep telemetry is debug-gated: unconditional stderr writes
+// land inside the interactive TUI and corrupt the composer/status line.
+// Genuine sweep errors (catch paths) stay unconditional.
+const _sweepLog = (line) => {
+    if (process.env.MIXDOG_DEBUG_SESSION_LOG) process.stderr.write(line);
+};
+
 function sweepIdleSessions({ includeTombstones = true, sweepIdle = true } = {}) {
     const startedAt = Date.now();
     try {
@@ -59,35 +83,24 @@ function sweepIdleSessions({ includeTombstones = true, sweepIdle = true } = {})
         } = result;
         if (cleaned > 0) {
             for (const d of details) {
-                // Skip entries with an active in-flight controller — aborting
-                // them via closeSession() is the safe path; clearing the runtime
-                // without signalling the controller leaves orphan provider work.
-                const rtEntry = _getRuntimeEntry(d.id);
-                if (rtEntry && rtEntry.controller && !rtEntry.controller.signal?.aborted) {
-                    try { closeSession(d.id, 'idle-sweep'); } catch { /* ignore */ }
-                } else {
-                    _clearSessionRuntime(d.id);
-                    if (d.bashSessionId) {
-                        try { _closeBashSessionLazy(d.bashSessionId, `idle-sweep:${d.id}`); } catch { /* ignore */ }
-                    }
-                }
-                process.stderr.write(`[agent-session] idle cleanup: closed ${d.id} (idle ${d.idleMinutes}m, owner=${d.owner})\n`);
+                if (!_finalizeSweptSessionRuntime(d)) continue;
+                _sweepLog(`[agent-session] idle cleanup: closed ${d.id} (idle ${d.idleMinutes}m, owner=${d.owner})\n`);
             }
-            process.stderr.write(`[agent-session] idle sweep: cleaned ${cleaned} session(s), ${remaining} remaining\n`);
+            _sweepLog(`[agent-session] idle sweep: cleaned ${cleaned} session(s), ${remaining} remaining\n`);
         }
         if (tombstonesCleaned > 0) {
             for (const d of tombstoneDetails) {
                 if (d?.id && !_isSessionLive(d.id)) _clearSessionRuntime(d.id);
             }
-            process.stderr.write(`[session-sweep] unlinked ${tombstonesCleaned} tombstone(s)${_previewIds(tombstoneDetails)}\n`);
+            _sweepLog(`[session-sweep] unlinked ${tombstonesCleaned} tombstone(s)${_previewIds(tombstoneDetails)}\n`);
         }
         if (tombstoneErrors.length > 0) {
             const first = tombstoneErrors[0];
-            process.stderr.write(`[session-sweep] tombstone unlink failed for ${tombstoneErrors.length} session(s): ${first?.id || 'unknown'} ${first?.message || ''}\n`);
+            _sweepLog(`[session-sweep] tombstone unlink failed for ${tombstoneErrors.length} session(s): ${first?.id || 'unknown'} ${first?.message || ''}\n`);
         }
         const elapsed = Date.now() - startedAt;
         if (elapsed >= CLEANUP_SLOW_LOG_MS) {
-            process.stderr.write(`[session-sweep] cleanup took ${elapsed}ms (idle=${cleaned}, tombstones=${tombstonesCleaned}, remaining=${remaining})\n`);
+            _sweepLog(`[session-sweep] cleanup took ${elapsed}ms (idle=${cleaned}, tombstones=${tombstonesCleaned}, remaining=${remaining})\n`);
         }
     } catch (e) {
         process.stderr.write(`[agent-session] idle sweep error: ${e && e.message || e}\n`);
@@ -117,11 +130,11 @@ export function sweepTombstones() {
             if (d?.id && !_isSessionLive(d.id)) _clearSessionRuntime(d.id);
         }
         if (tombstonesCleaned > 0) {
-            process.stderr.write(`[session-sweep] unlinked ${tombstonesCleaned} tombstone(s)${_previewIds(tombstoneDetails)}\n`);
+            _sweepLog(`[session-sweep] unlinked ${tombstonesCleaned} tombstone(s)${_previewIds(tombstoneDetails)}\n`);
         }
         if (tombstoneErrors.length > 0) {
             const first = tombstoneErrors[0];
-            process.stderr.write(`[session-sweep] tombstone unlink failed for ${tombstoneErrors.length} session(s): ${first?.id || 'unknown'} ${first?.message || ''}\n`);
+            _sweepLog(`[session-sweep] tombstone unlink failed for ${tombstoneErrors.length} session(s): ${first?.id || 'unknown'} ${first?.message || ''}\n`);
         }
         return tombstonesCleaned;
     } catch (e) {
@@ -130,28 +143,15 @@ export function sweepTombstones() {
     }
 }
 
-function hasActiveRuntimeWork() {
-    for (const [, entry] of _runtimeEntries()) {
-        if (!entry || entry.closed === true) continue;
-        if (entry.controller && !entry.controller.signal?.aborted) return true;
-        if (['connecting', 'requesting', 'streaming', 'tool_running', 'cancelling'].includes(entry.stage)) return true;
-    }
-    return false;
-}
-
-function _runCleanupCycle() {
+export function _runCleanupCycle() {
     // Drain every settled runtime entry on each pass, not just the one or two
     // sessions whose on-disk idle TTL happened to expire in this interval.
     _sweepTerminalSessionRuntimes();
-    // A busy host may always have some unrelated agent in flight. Tombstones
-    // are already closed and can still be batch-reclaimed safely; only the
-    // open-session idle sweep remains gated while active work exists.
-    if (hasActiveRuntimeWork()) {
-        sweepIdleSessions({ includeTombstones: true, sweepIdle: false });
-        return;
-    }
     sweepOrphanedPendingMessages();
     sweepIdleSessions({ includeTombstones: true });
+    // Reclaim same-process session snapshots whose state is durable on disk
+    // (memory-leak guard: _liveSessions used to grow for process lifetime).
+    try { evictIdleLiveSessions({ isSessionLive: _isSessionLive }); } catch { /* best-effort */ }
 }
 
 function _startCleanupInterval() {

package/src/runtime/agent/orchestrator/session/manager/pending-messages.mjs

@@ -1,7 +1,7 @@
 // Steering / pending-message queue with sync buffered + atomic-file persistence.
 // Extracted verbatim from manager.mjs (behavior-preserving).
 import { join } from 'path';
-import { readFileSync } from 'fs';
+import { readFileSync, statSync } from 'fs';
 import { createHash, randomBytes } from 'crypto';
 import { resolvePluginData } from '../../../../shared/plugin-paths.mjs';
 import { updateJsonAtomicSync, updateJsonAtomic } from '../../../../shared/atomic-file.mjs';
@@ -47,8 +47,13 @@ function pendingMessageId(entry) {
     return typeof entry?.id === 'string' && entry.id ? entry.id : null;
 }
 
+// Content-addressed (NO index): an index-keyed id changed whenever the queue
+// shifted, so ack/ledger suppression missed the renamed entry and the foreign
+// drain re-injected it as a duplicate user message. Identical legacy strings
+// now share one id — acceptable, since ack-by-id then clears such duplicate
+// stale rows together.
 function legacyPendingMessageId(sessionId, index, value) {
-    return `legacy_${createHash('sha256').update(`${sessionId}:${index}:${value}`).digest('hex').slice(0, 24)}`;
+    return `legacy_${createHash('sha256').update(`${sessionId}:${value}`).digest('hex').slice(0, 24)}`;
 }
 
 function isCompletionNotificationEntry(entry) {
@@ -97,6 +102,12 @@ function pendingMessagesPath() {
     return join(resolvePluginData(), PENDING_MESSAGES_FILE);
 }
 
+// Exposed for live-share owners: they fs.watch this file for instant pickup
+// of cross-surface submits (the 3s drain tick remains the safety net).
+export function pendingMessagesSpoolPath() {
+    return pendingMessagesPath();
+}
+
 function isValidPendingSessionId(sessionId) {
     return typeof sessionId === 'string' && /^[A-Za-z0-9_-]+$/.test(sessionId);
 }
@@ -371,11 +382,19 @@ export function acknowledgePendingMessages(sessionId, deliveredEntries) {
     const reported = operation.then(() => true).catch((err) => {
         try { process.stderr.write(`[session] pending-message ack failed sessionId=${sessionId}: ${err?.message || err}\n`); } catch {}
         return false;
-    }).finally(() => {
+    }).then((ok) => {
+        if (_pendingPersistTails.get(sessionId) === operation) _pendingPersistTails.delete(sessionId);
+        // Keep the acked ids when the spool cleanup FAILED: the durable entry
+        // still exists, and forgetting that it was already delivered let the
+        // foreign-injection drain re-take it as a "new" cross-surface submit
+        // (user saw the same message duplicated in the transcript). Retained
+        // ids also keep suppressing the hydrate path; they are dropped only
+        // once a later ack round actually lands.
+        if (!ok) return false;
         const currentAcked = pendingIdSet(_ackedPendingIds, sessionId);
         for (const id of ids) currentAcked.delete(id);
         if (currentAcked.size === 0) _ackedPendingIds.delete(sessionId);
-        if (_pendingPersistTails.get(sessionId) === operation) _pendingPersistTails.delete(sessionId);
+        return true;
     });
     return reported;
 }
@@ -638,6 +657,91 @@ export function enqueuePendingMessage(sessionId, message) {
     return Math.max(q.length, bufferedDepth || 0);
 }
 
+/**
+ * Remote-attach injection enqueue: persist a user message into the shared
+ * cross-process spool WITHOUT touching this process's in-memory queues. Used
+ * by a viewer surface attached to a session another live process owns — the
+ * owner's injection poller (drainForeignUserInjections) picks it up there.
+ * Skipping the local queues is deliberate: if this process later takes real
+ * ownership of the session, a lingering local copy would double-inject.
+ */
+export function enqueueRemotePendingMessage(sessionId, message) {
+    if (!isValidPendingSessionId(sessionId)) return 0;
+    const normalized = pendingMessageQueueEntry(message);
+    if (!normalized) return 0;
+    return persistPendingMessages(sessionId, [{ ...normalized, id: newPendingMessageId() }]);
+}
+
+// Spool-file mtime gate so the owner's idle poller costs one stat per tick,
+// not a locked read-modify-write.
+let _foreignSpoolScanMtime = 0;
+
+/**
+ * Owner-side drain of FOREIGN user injections for a session this process
+ * owns: atomically removes (and returns the text of) genuine user/steering
+ * entries that were persisted by ANOTHER process — entries known locally
+ * (own steering buffers, hydrated, in-delivery, acked) and completion/
+ * internal-notification entries are left untouched for the normal
+ * askSession hydrate path.
+ */
+export function drainForeignUserInjections(sessionId) {
+    if (!isValidPendingSessionId(sessionId)) return [];
+    let mtime = 0;
+    try { mtime = statSync(pendingMessagesPath()).mtimeMs || 0; } catch { return []; }
+    if (mtime === _foreignSpoolScanMtime) return [];
+    _foreignSpoolScanMtime = mtime;
+    const localIds = new Set();
+    for (const map of [_sessionPendingMessages, _pendingPersistBuffers, _hydratedPendingMessages]) {
+        for (const entry of map.get(sessionId) || []) {
+            const id = pendingMessageId(entry);
+            if (id) localIds.add(id);
+        }
+    }
+    for (const set of [_inDeliveryPendingIds.get(sessionId), _ackedPendingIds.get(sessionId)]) {
+        for (const id of set || []) localIds.add(id);
+    }
+    // The durable delivered-ledger mirrors the hydrate path's suppression: an
+    // entry whose id was recorded as delivered (but whose spool cleanup has
+    // not landed yet — crash, lock contention, another process) is NOT a
+    // foreign submit and must never re-inject.
+    try {
+        for (const id of loadSession(sessionId)?.deliveredPendingMessageIds || []) {
+            if (typeof id === 'string' && id) localIds.add(id);
+        }
+    } catch { /* ledger unavailable — in-memory sets still guard */ }
+    const taken = [];
+    try {
+        updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
+            const next = normalizePendingStore(raw);
+            const q = Array.isArray(next.sessions[sessionId]) ? next.sessions[sessionId] : [];
+            if (q.length === 0) return undefined;
+            const kept = [];
+            for (const entry of q) {
+                const id = pendingMessageId(entry);
+                const text = pendingMessageText(entry);
+                const foreignUser = id && !localIds.has(id)
+                    && !isCompletionNotificationEntry(entry)
+                    && !isLegacyUnmarkedCompletionNotification(text)
+                    && text && !isInternalRuntimeNotificationText(text);
+                if (foreignUser) taken.push(text);
+                else kept.push(entry);
+            }
+            if (taken.length === 0) return undefined;
+            if (kept.length > 0) next.sessions[sessionId] = kept;
+            else {
+                delete next.sessions[sessionId];
+                if (next.sessionTouchedAt) delete next.sessionTouchedAt[sessionId];
+            }
+            next.updatedAt = Date.now();
+            return next;
+        }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
+    } catch (err) {
+        try { process.stderr.write(`[session] foreign-injection drain failed sessionId=${sessionId}: ${err?.message || err}\n`); } catch {}
+        return [];
+    }
+    return taken;
+}
+
 export function drainPendingMessages(sessionId) {
     const q = _sessionPendingMessages.get(sessionId);
     const memory = q && q.length > 0 ? q.slice() : [];

package/src/runtime/agent/orchestrator/session/manager/runtime-liveness.mjs

@@ -133,6 +133,8 @@ export function markSessionAskStart(id) {
     entry.lastToolCall = null;
     entry.toolStartedAt = null;
     entry.toolSelfDeadlineMs = null;
+    entry.toolOutputTail = null;
+    entry.toolOutputTailAt = null;
     entry.lastError = null;
     // A new ask starts a fresh turn lifecycle — clear any stale empty-final
     // classification from the prior turn so inspectBridgeEntry doesn't keep
@@ -238,6 +240,9 @@ export function markSessionToolCall(id, toolName, selfDeadlineMs) {
     const entry = _touchRuntime(id);
     entry.stage = 'tool_running';
     entry.lastToolCall = toolName || null;
+    // A new tool call invalidates the previous call's live-output tail.
+    entry.toolOutputTail = null;
+    entry.toolOutputTailAt = null;
     // Self-enforced deadline (ms) for tools that kill themselves at a known
     // budget (shell timeout / task wait). The watchdog raises the tool-running
     // ceiling to this + grace instead of aborting at toolRunningMs. Null/<=0
@@ -256,6 +261,18 @@ export function markSessionToolCall(id, toolName, selfDeadlineMs) {
     publishHeartbeat(id, entry.toolStartedAt);
     _startToolActivityHeartbeat(id);
 }
+// Live shell-output tail for the CURRENT running tool. Written by the shell
+// tool's onOutputTail timer (~1 s cadence), read by engine transcript
+// consumers via getSessionProgressSnapshot. Never creates a runtime entry —
+// a settled/unknown session ignores late writes.
+export function markSessionToolOutputTail(id, tail) {
+    if (!id) return;
+    const entry = _runtimeState.get(id);
+    if (!entry) return;
+    const text = typeof tail === 'string' ? tail : String(tail ?? '');
+    entry.toolOutputTail = text ? text.slice(-4000) : null;
+    entry.toolOutputTailAt = Date.now();
+}
 // Parent AbortSignal listeners are dropped on askSession unwind (finally /
 // terminal return) and on error/cancel/close — not in markSessionDone, which
 // also runs between queued follow-up turns within one ask.
@@ -383,6 +400,8 @@ export function getSessionProgressSnapshot(sessionId) {
         toolStartedAt: entry.toolStartedAt || 0,
         currentTool: entry.lastToolCall || null,
         toolSelfDeadlineMs: entry.toolSelfDeadlineMs || 0,
+        toolOutputTail: entry.toolOutputTail || null,
+        toolOutputTailAt: entry.toolOutputTailAt || 0,
         lastProgressAt: entry.lastProgressAt || 0,
         updatedAt: entry.updatedAt || 0,
         hasFirstActivity: Boolean(firstSemanticAt && (!askStartedAt || firstSemanticAt >= askStartedAt)),