mixdog 0.9.55 → 0.9.59

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

@@ -2,7 +2,7 @@
 // Session read + mutate CRUD extracted verbatim from manager.mjs: lookup
 // (getSession/listSessions/findSessionByScopeKey), message clear (with
 // clear-fork), manual compaction, status update, and metric flush.
-import { loadSession, saveSessionAsync, setLiveSession, listStoredSessionSummaries } from '../store.mjs';
+import { loadSession, saveSessionAsync, setLiveSession, evictLiveSession, listStoredSessionSummaries } from '../store.mjs';
 import { estimateMessagesTokens, estimateTranscriptContextUsage } from '../context-utils.mjs';
 import { normalizeCompactType, DEFAULT_COMPACT_TYPE, SUMMARY_PREFIX } from '../compact.mjs';
 import { runSessionCompaction } from './compaction-runner.mjs';
@@ -125,8 +125,8 @@ export async function clearSessionMessages(sessionId, options = {}) {
         }
     }
     const afterMessageTokens = estimateMessagesTokens(keep);
-    const beforeTokens = estimateTranscriptContextUsage(messages, session.tools || []);
-    const afterTokens = estimateTranscriptContextUsage(keep, session.tools || []);
+    const beforeTokens = estimateTranscriptContextUsage(messages, session.tools || [], { provider: session.provider });
+    const afterTokens = estimateTranscriptContextUsage(keep, session.tools || [], { provider: session.provider });
     const now = Date.now();
     // --- Fork the outgoing transcript to a separate resumable session BEFORE
     // the wipe below. Runs for every clear path (plain /clear, auto-clear,
@@ -174,7 +174,14 @@ export async function clearSessionMessages(sessionId, options = {}) {
             };
             delete fork.liveTurnMessages;
             setLiveSession(fork);
-            void saveSessionAsync(fork).catch((err) => {
+            void saveSessionAsync(fork).then(() => {
+                // The fork is a cold snapshot kept for /resume. Once durable on
+                // disk it must not pin a full transcript copy (image bytes
+                // included) in the same-process cache for the rest of the
+                // process lifetime — this was the largest _liveSessions leak
+                // (one whole conversation retained per clear).
+                evictLiveSession(forkId);
+            }).catch((err) => {
                 try { process.stderr.write(`[session] clear-fork save failed (sess=${forkId}): ${err?.message || err}\n`); } catch { /* best-effort */ }
             });
         } catch (err) {
@@ -227,15 +234,19 @@ export async function compactSessionMessages(sessionId) {
     const result = await runSessionCompaction(session, {
         mode: 'manual',
         force: true,
-        // /compact is a direct reduction of the active session transcript.
-        // Do not re-ingest/search Memory (recall-fasttrack) before summarizing.
-        compactType: DEFAULT_COMPACT_TYPE,
-        // Older source history uses the same pure-conversation filter as
-        // Memory ingest_session; protected system context and recent turns are
-        // still preserved separately by semantic compaction.
+        // No compactType/model override: follow the hard-locked per-session
+        // type (main = recall-fasttrack, agent = semantic). The former forced
+        // semantic + session.model here ran every manual /compact as a
+        // flagship-model summary call (27-38s measured); fasttrack is local
+        // (ingest + digest) and semantic remains only the degraded fallback
+        // inside the runner, where resolveSemanticSummaryModel downshifts the
+        // summary model.
+        // If the semantic fallback does run, filter older source history
+        // through the same pure-conversation filter as Memory ingest_session;
+        // protected system context and recent turns are still preserved
+        // separately by semantic compaction.
         filterOldHistoryForIngest: true,
         provider: getProvider(session.provider),
-        model: session.model,
         sessionId,
         signal: getSessionAbortSignal(sessionId),
     });

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

@@ -6,7 +6,8 @@
 import { getProvider } from '../../providers/registry.mjs';
 import { normalizeCompactType, DEFAULT_COMPACT_TYPE } from '../compact.mjs';
 import { collectPromptSkillsCached, buildSkillManifest, composeSystemPrompt } from '../../context/collect.mjs';
-import { saveSession, saveSessionAsync, loadSession, setLiveSession } from '../store.mjs';
+import { saveSession, saveSessionAsync, saveSessionAsyncDeferred, loadSession, setLiveSession, readSessionHeartbeatMtime, readSessionPresenceMtime, isSessionPresenceOwnerDead, deleteSessionPresence } from '../store.mjs';
+import { _getRuntimeEntry } from './runtime-liveness.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
 import { getHiddenAgent } from '../../internal-agents.mjs';
 import { loadConfig } from '../../config.mjs';
@@ -481,8 +482,109 @@ export function updateSessionRoute(id, route = {}) {
 }
 
 // --- resume (reload tools for a stored session) ---
-export async function resumeSession(sessionId, preset, options = {}) {
+// Attach-on-resume guard: resuming a session that another live process is
+// ACTIVELY driving right now must not create a second writer on the same
+// file — that split-brain silently freezes one side's transcript (generation
+// ownership drops the loser's saves). Such a resume ATTACHES instead: the
+// caller gets the live transcript flagged remoteAttached, its submits are
+// persisted into the shared pending spool (the owner's injection poller runs
+// them as normal user turns), and its view refreshes from disk. ONE writer,
+// ONE transcript, every surface talking into the same conversation. Idle
+// sessions keep the normal single-identity handoff.
+const ACTIVE_OWNER_HB_FRESH_MS = 2 * 60 * 1000; // heartbeat freshness window
+const PREPARED_RESUME_LIMIT = 8;
+const _preparedResumes = new Map();
+
+function _prepareResumeTools(session, preset) {
+    const ownerIsAgent = isAgentOwner(session);
+    const skills = ownerIsAgent ? [] : collectPromptSkillsCached(session.cwd);
+    let toolSpec = ownerIsAgent ? 'full' : (preset || session.preset || 'full');
+    const agentRuntime = getAgentRuntimeSync();
+    if (session.profileId && agentRuntime?.getProfile) {
+        try {
+            const profile = agentRuntime.getProfile(session.profileId);
+            if (!ownerIsAgent && Array.isArray(profile?.tools)) toolSpec = profile.tools;
+        } catch { /* ignore lookup failures, keep preset fallback */ }
+    }
+    let toolsForRouting = resolveSessionTools(toolSpec, skills, { ownerIsAgentSession: ownerIsAgent });
+    if (ownerIsAgent) {
+        toolsForRouting = applyToolPermissionNarrowing(toolsForRouting, session.toolPermission, session.agent || null);
+    }
+    return {
+        session,
+        preset,
+        toolSpec,
+        ownerIsAgent,
+        tools: finalizeSessionToolList(toolsForRouting, {
+            schemaAllowedTools: Array.isArray(session.schemaAllowedTools) ? session.schemaAllowedTools : null,
+            disallowedTools: getHiddenAgent(session.agent || null) ? ['Skill'] : null,
+            ownerIsAgent,
+            resolvedAgent: session.agent || null,
+        }),
+    };
+}
+
+function _rememberPreparedResume(sessionId, prepared) {
+    _preparedResumes.delete(sessionId);
+    _preparedResumes.set(sessionId, prepared);
+    while (_preparedResumes.size > PREPARED_RESUME_LIMIT) {
+        const oldest = _preparedResumes.keys().next().value;
+        if (oldest === undefined) break;
+        _preparedResumes.delete(oldest);
+    }
+}
+
+// Desktop session-row hover/idle prefetch. loadSession validates the atomic
+// file signature before reusing its parsed object, so a later external write
+// naturally misses this preparation and rebuilds from the new session object.
+export function prefetchSession(sessionId, preset = 'full') {
+    const session = loadSession(sessionId);
+    if (!session || session.closed === true) return false;
+    _rememberPreparedResume(sessionId, _prepareResumeTools(session, preset));
+    return true;
+}
+
+function _isActivelyOwnedElsewhere(session, sessionId) {
+    // This process already owns the runtime for the id — switching back to
+    // one of our own sessions (desktop tab switch, TUI /resume) never attaches.
+    const entry = _getRuntimeEntry(sessionId);
+    if (entry && entry.closed !== true) return false;
+    // A FORCE-KILLED owner leaves its `.own` sidecar behind looking fresh.
+    // The recorded pid is authoritative: when it no longer exists, the owner
+    // is gone — clear the stale sidecar and resume with normal ownership
+    // instead of viewer-attaching into a spool nobody drains.
+    if (isSessionPresenceOwnerDead(sessionId)) {
+        deleteSessionPresence(sessionId);
+        return false;
+    }
+    // Heartbeats publish only while a turn is running (≤5s cadence) and the
+    // sidecar is deleted on detach/close, so freshness here means another
+    // process is mid-conversation on this session right now. Presence (`.own`)
+    // covers the idle gaps between turns: a live interactive surface keeps
+    // refreshing it (~20s) for its CURRENT session, so cross-opening an
+    // idle-but-open session still attaches as a viewer instead of splitting
+    // ownership into two writers that clobber each other's saves.
+    const lastHb = Math.max(
+        Number(readSessionHeartbeatMtime(sessionId)) || 0,
+        Number(session.lastHeartbeatAt) || 0,
+        Number(readSessionPresenceMtime(sessionId)) || 0,
+    );
+    return lastHb > 0 && Date.now() - lastHb <= ACTIVE_OWNER_HB_FRESH_MS;
+}
+
+// Viewer self-heal probe: true when a re-resume of this session would NO
+// LONGER attach (owner dead or every liveness signal stale). Attached
+// surfaces poll this so a dead owner promotes the viewer instead of leaving
+// it spooling messages to nobody. Single source of truth: the same guard
+// the resume path uses.
+export function isSessionOwnerGone(sessionId) {
     const session = loadSession(sessionId);
+    if (!session) return false;
+    return !_isActivelyOwnedElsewhere(session, sessionId);
+}
+
+export async function resumeSession(sessionId, preset, options = {}) {
+    let session = loadSession(sessionId);
     if (!session)
         return null;
     // Resuming a closed session is a resurrection attempt — refuse. The guarded
@@ -505,34 +607,40 @@ export async function resumeSession(sessionId, preset, options = {}) {
         session.desktopSession = expectedDesktop;
     }
     if (!session.owner) session.owner = 'user';
-    const oldTools = session.tools || [];
-    const ownerIsAgent = isAgentOwner(session);
-    const skills = ownerIsAgent ? [] : collectPromptSkillsCached(session.cwd);
-    let toolSpec = ownerIsAgent ? 'full' : (preset || session.preset || 'full');
-    const agentRuntime = getAgentRuntimeSync();
-    if (session.profileId && agentRuntime?.getProfile) {
-        try {
-            const profile = agentRuntime.getProfile(session.profileId);
-            if (!ownerIsAgent && Array.isArray(profile?.tools)) toolSpec = profile.tools;
-        } catch { /* ignore lookup failures, keep preset fallback */ }
-    }
-    let toolsForRouting = resolveSessionTools(toolSpec, skills, { ownerIsAgentSession: ownerIsAgent });
-    if (ownerIsAgent) {
-        toolsForRouting = applyToolPermissionNarrowing(toolsForRouting, session.toolPermission, session.agent || null);
+    if (_isActivelyOwnedElsewhere(session, sessionId)) {
+        // ATTACH (viewer mode, zero ownership): hand back the live transcript
+        // under the SAME id, flagged remoteAttached. No tool refresh, no save,
+        // no generation claim — the session file remains exclusively the
+        // owner's. session-turn-api routes this surface's submits into the
+        // shared pending spool instead of running a local turn.
+        const attached = { ...session, remoteAttached: true };
+        delete attached.liveTurnMessages;
+        delete attached.toolApprovalHook;
+        if (process.env.MIXDOG_DEBUG_SESSION_LOG) {
+            try { process.stderr.write(`[session] attach-on-resume: ${sessionId} is live elsewhere → viewer attach\n`); } catch { /* best-effort */ }
+        }
+        return attached;
     }
+    const oldTools = session.tools || [];
+    const cached = _preparedResumes.get(sessionId);
+    _preparedResumes.delete(sessionId);
+    const prepared = cached?.session === session && cached?.preset === preset
+        ? cached
+        : _prepareResumeTools(session, preset);
     // Keep the persisted tool mode in sync on resume (see createSession note).
-    session.toolSpec = toolSpec;
-    session.tools = finalizeSessionToolList(toolsForRouting, {
-        schemaAllowedTools: Array.isArray(session.schemaAllowedTools) ? session.schemaAllowedTools : null,
-        disallowedTools: getHiddenAgent(session.agent || null) ? ['Skill'] : null,
-        ownerIsAgent,
-        resolvedAgent: session.agent || null,
-    });
+    session.toolSpec = prepared.toolSpec;
+    session.tools = prepared.tools;
     const newTools = session.tools;
     const missing = oldTools.filter(t => !newTools.find(n => n.name === t.name));
     if (missing.length) {
         process.stderr.write(`[session] Warning: ${missing.length} tools no longer available: ${missing.map(t => t.name).join(', ')}\n`);
     }
-    await saveSessionAsync(session, { expectedGeneration: session.generation });
+    // The live session already owns the refreshed tools and desktop scope.
+    // Defer the structured clone + worker round-trip so opening a conversation
+    // is not blocked on persisting the same in-memory state back to disk.
+    void saveSessionAsyncDeferred(session, { expectedGeneration: session.generation })
+        .catch((err) => {
+            try { process.stderr.write(`[session] resume save failed: ${err?.message || err}\n`); } catch {}
+        });
     return session;
 }

package/src/runtime/agent/orchestrator/session/manager/status-telemetry.mjs

@@ -50,7 +50,7 @@ export function recordStandaloneStatusTelemetry(session, result, durationMs) {
     // as afterTokens. This lights up summarizeGatewayUsage's estimate-based
     // contextUsedPct branch (provider input_tokens swing wildly / unbounded on
     // e.g. OpenAI gpt-5.5), and lets a genuine >100% pass through.
-    const _estTokens = estimateTranscriptContextUsage(session.messages, session.tools || []);
+    const _estTokens = estimateTranscriptContextUsage(session.messages, session.tools || [], { provider: session.provider });
     const _compactArg = { ...(result.compact && typeof result.compact === 'object' ? result.compact : {}), afterTokens: _estTokens };
     try {
         const summary = {

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

@@ -43,6 +43,7 @@ export {
     markSessionAskStart,
     markSessionStreamDelta,
     markSessionToolCall,
+    markSessionToolOutputTail,
     markSessionDone,
     markSessionEmptyFinal,
     markSessionError,
@@ -62,10 +63,17 @@ export { previewSessionTools } from './manager/tool-resolution.mjs';
 export {
     _mergePendingMessageEntries,
     enqueuePendingMessage,
+    enqueueRemotePendingMessage,
+    drainForeignUserInjections,
     drainPendingMessages,
     markCompletionEntry,
     COMPLETION_NOTIFICATION_KIND,
+    pendingMessagesSpoolPath,
 } from './manager/pending-messages.mjs';
+// Interactive-presence sidecar (idle-open ownership signal for the
+// attach-on-resume guard) — resolved through the manager facade so the
+// session-runtime turn API reaches it as mgr.publishSessionPresence.
+export { publishSessionPresence, deleteSessionPresence } from './store.mjs';
 export { isInternalRuntimeNotificationText as _isInternalRuntimeNotificationText } from './manager/prompt-utils.mjs';
 
 // ── Usage-metrics surface — re-exported unchanged so loop.mjs / smoke scripts
@@ -104,7 +112,13 @@ export const _preserveBufferConfigFields = preserveBufferConfigFields;
 // ── Session lifecycle / ask / crud / close / cleanup ──────────────────────
 export { SessionClosedError } from './manager/session-errors.mjs';
 export { setAgentRuntime } from './manager/agent-runtime-singleton.mjs';
-export { createSession, updateSessionRoute, resumeSession } from './manager/session-lifecycle.mjs';
+export {
+    createSession,
+    updateSessionRoute,
+    prefetchSession,
+    resumeSession,
+    isSessionOwnerGone,
+} from './manager/session-lifecycle.mjs';
 export { askSession, _api_call_with_interrupt } from './manager/ask-session.mjs';
 export {
     _sessionMessagesAdvancedBeyondCompactedOutgoing,
@@ -119,5 +133,6 @@ export {
     updateSessionStatus,
     flushSessionMetrics,
 } from './manager/session-crud.mjs';
+export { deleteSession } from './store.mjs';
 export { closeSession, abortSessionTurn } from './manager/session-close.mjs';
 export { sweepTombstones, startIdleCleanup, stopIdleCleanup } from './manager/idle-cleanup.mjs';

package/src/runtime/agent/orchestrator/session/pre-send-compact.mjs

@@ -13,6 +13,7 @@ import {
     rememberCompactTelemetry,
     emitCompactEvent,
     compactEventType,
+    resolveSemanticSummaryModel,
 } from './loop/compact-policy.mjs';
 import {
     pruneToolOutputs,
@@ -32,6 +33,25 @@ import { traceAgentCompact, messagePrefixHash } from '../agent-trace.mjs';
 import { invalidateProviderRequestToolsScope } from '../../../../session-runtime/provider-request-tools.mjs';
 import { bumpUsageMetricsEpoch } from './manager.mjs';
 
+const RECOVERED_ERROR_MESSAGE_MAX_CHARS = 300;
+const ANSI_ESCAPE_RE = /[\u001B\u009B][[\]()#;?]*(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d/#&.:=?%@~_]+)*)?\u0007|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))/g;
+
+function compactRecoveredError(err) {
+    const rawMessage = err?.message || String(err);
+    const message = String(rawMessage)
+        .replace(ANSI_ESCAPE_RE, '')
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return {
+        // Preserve machine-readable codes exactly; only the display payload is bounded.
+        code: err?.code ?? null,
+        message: message.length > RECOVERED_ERROR_MESSAGE_MAX_CHARS
+            ? `${message.slice(0, 299)}…`
+            : message,
+    };
+}
+
 export async function runPreSendCompactPass(state) {
     const {
         provider, messages, model, requestTools, sessionRef, sessionId, cwd, opts, signal,
@@ -47,21 +67,6 @@ export async function runPreSendCompactPass(state) {
             // a best-effort JSON.stringify length — close enough to the
             // payload we hand the provider for prefix-cache analysis.
             const beforeCount = messages.length;
-            // beforeBytes is only ever read inside the shouldCompact telemetry
-            // branches below. Computing it eagerly serialized the ENTIRE message
-            // array (Buffer.byteLength(JSON.stringify(messages))) on every loop
-            // iteration — including the common no-compact path — which grows
-            // linearly with transcript size and was a real per-iteration drag.
-            // Defer it to a memoized lazy getter so the no-compact path pays
-            // nothing and the compact path still gets an exact byte count once.
-            let _beforeBytes;
-            let _beforeBytesComputed = false;
-            const getBeforeBytes = () => {
-                if (_beforeBytesComputed) return _beforeBytes;
-                _beforeBytesComputed = true;
-                try { _beforeBytes = Buffer.byteLength(JSON.stringify(messages), 'utf8'); } catch { _beforeBytes = null; }
-                return _beforeBytes;
-            };
             const messageTokensEst = estimateMessagesTokensSafe(messages);
             const reactivePending = reactiveOverflowRetryPending === true;
             const pressureTokens = compactionTelemetryPressureTokens(messageTokensEst, compactPolicy, {
@@ -93,6 +98,14 @@ export async function runPreSendCompactPass(state) {
                     pressureTokens,
                 });
             } else {
+                // Snapshot BEFORE mutating the live array below. Keeping this
+                // inside the compact branch preserves the no-compact fast path
+                // while ensuring compact_meta reports real savings and the true
+                // input prefix rather than the replacement transcript.
+                let beforeBytes = null;
+                let beforePrefixHash = null;
+                try { beforeBytes = Buffer.byteLength(JSON.stringify(messages), 'utf8'); } catch { /* best-effort telemetry */ }
+                try { beforePrefixHash = messagePrefixHash(messages); } catch { /* best-effort telemetry */ }
                 try { await opts.onStageChange?.('compacting'); } catch { /* best-effort */ }
                 const compactStartedAt = Date.now();
                 // Clear the one-shot reactive-overflow flag now that this
@@ -125,6 +138,7 @@ export async function runPreSendCompactPass(state) {
                 let semanticCompactError = null;
                 let recallFastTrackResult = null;
                 let recallFastTrackError = null;
+                let recoveredError = null;
                 try {
                     let compactInputMessages = messages;
                     if (compactPolicy.prune) {
@@ -164,12 +178,13 @@ export async function runPreSendCompactPass(state) {
                             semanticCompactResult = await semanticCompactMessages(
                                 provider,
                                 compactInputMessages,
-                                model,
+                                resolveSemanticSummaryModel(sessionRef, { budgetTokens: compactBudgetTokens }) || model,
                                 compactBudgetTokens,
                                 {
                                     reserveTokens: compactPolicy.reserveTokens,
                                     providerName: sessionRef.provider || provider?.name || null,
                                     sessionId,
+                                    cwd: sessionRef?.cwd,
                                     signal,
                                     sendOpts: opts,
                                     promptCacheKey: opts.promptCacheKey || null,
@@ -259,6 +274,7 @@ export async function runPreSendCompactPass(state) {
                         } catch { /* fall through to overflow escalation */ }
                     }
                     if (compacted !== undefined) {
+                        recoveredError = compactRecoveredError(compactErr);
                         try {
                             process.stderr.write(
                                 `[loop] compact fallback prune recovered (sess=${sessionId || 'unknown'}): ` +
@@ -317,11 +333,11 @@ export async function runPreSendCompactPass(state) {
                         compact_type: compactPolicy.compactType || compactPolicy.type || DEFAULT_COMPACT_TYPE,
                         prune_count: pruneCount,
                         compact_changed: false,
-                        input_prefix_hash: messagePrefixHash(messages),
+                        input_prefix_hash: beforePrefixHash,
                         before_count: beforeCount,
                         after_count: messages.length,
-                        before_bytes: getBeforeBytes(),
-                        after_bytes: getBeforeBytes(),
+                        before_bytes: beforeBytes,
+                        after_bytes: beforeBytes,
                         context_window: compactPolicy.contextWindow,
                         budget_tokens: compactPolicy.boundaryTokens,
                         boundary_tokens: compactPolicy.boundaryTokens,
@@ -448,10 +464,10 @@ export async function runPreSendCompactPass(state) {
                     compact_type: compactPolicy.compactType || compactPolicy.type || DEFAULT_COMPACT_TYPE,
                     prune_count: pruneCount,
                     compact_changed: compactChanged || summaryChanged,
-                    input_prefix_hash: messagePrefixHash(messages),
+                    input_prefix_hash: beforePrefixHash,
                     before_count: beforeCount,
                     after_count: messages.length,
-                    before_bytes: getBeforeBytes(),
+                    before_bytes: beforeBytes,
                     after_bytes: afterBytes,
                     context_window: compactPolicy.contextWindow,
                     budget_tokens: compactPolicy.boundaryTokens,
@@ -464,9 +480,11 @@ export async function runPreSendCompactPass(state) {
                     duration_ms: compactDurationMs,
                     provider: sessionRef.provider,
                     model: sessionRef.model || model,
+                    recovered_error: recoveredError,
                     details: {
                         semantic: semanticCompactResult?.diagnostics || null,
                         recallFastTrack: recallFastTrackResult?.diagnostics || null,
+                        recovered_error_code: recoveredError?.code ?? null,
                     },
                 });
                 emitCompactEvent(opts, {

package/src/runtime/agent/orchestrator/session/save-session-worker.mjs

@@ -6,6 +6,24 @@
  * race protection is preserved by ordering.
  */
 import { parentPort } from 'worker_threads';
+
+// Route every stray stdout/stderr print through the parent as a `{ __log }`
+// message instead of worker stdio. Piped worker stdio (stdout:true) keeps the
+// parent's event loop alive for the worker's lifetime once read, and default
+// (copied) stdio bypasses the TUI's process.stderr.write guard and prints
+// over the terminal frame. postMessage does neither: the parent writes the
+// text through its own guarded stderr.
+function _forwardWrite(chunk, encoding, callback) {
+    try { parentPort.postMessage({ __log: typeof chunk === 'string' ? chunk : String(chunk) }); } catch { /* best-effort */ }
+    const cb = typeof encoding === 'function' ? encoding : callback;
+    if (typeof cb === 'function') cb();
+    return true;
+}
+try {
+    process.stdout.write = _forwardWrite;
+    process.stderr.write = _forwardWrite;
+} catch { /* best-effort: worker still functions with default stdio */ }
+
 import { _saveSessionSync } from './store.mjs';
 
 parentPort.on('message', ({ session, opts, reqId }) => {

package/src/runtime/agent/orchestrator/session/store/paths-heartbeat.mjs

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, unlinkSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync } from 'fs';
 import * as fsp from 'fs/promises';
 import { join } from 'path';
 import { getPluginData } from '../../config.mjs';
@@ -50,3 +50,93 @@ export function deleteHeartbeat(id) {
     try { unlinkSync(_heartbeatPath(id)); } catch { /* ignore */ }
     _hbLastAt.delete(id);
 }
+
+// Batch reader for session catalogs. Scanning only the handful of `.hb`
+// sidecars avoids one failed stat per historical session while still exposing
+// cross-process turn activity to desktop/TUI resume lists.
+export function listSessionHeartbeatMtimes() {
+    const result = new Map();
+    try {
+        const dir = getStoreDir();
+        for (const filename of readdirSync(dir)) {
+            if (!filename.endsWith('.hb')) continue;
+            const id = filename.slice(0, -3);
+            if (!/^[A-Za-z0-9_-]+$/.test(id)) continue;
+            try {
+                const mtime = statSync(join(dir, filename)).mtimeMs || 0;
+                if (mtime > 0) result.set(id, mtime);
+            } catch { /* sidecar disappeared after readdir */ }
+        }
+    } catch { /* catalog activity is best-effort */ }
+    return result;
+}
+
+// ── Interactive presence publish ──────────────────────────
+// `<id>.own` marks a live interactive surface (TUI/desktop engine) HOLDING
+// the session open — including idle time between turns. Kept separate from
+// `.hb` (turn-activity signal consumed by the status aggregator and deleted
+// at turn end) so idle presence never fakes a "running" badge. Consumed by
+// the attach-on-resume guard (_isActivelyOwnedElsewhere): fresh presence
+// means a cross-open must attach as a viewer instead of claiming a second
+// writer on the same session file (dual-writer last-save-wins clobbering).
+// Refreshed by the engine share tick (~3s call, throttled here) and cleared
+// on session switch/dispose; staleness covers crashes.
+const _PRESENCE_THROTTLE_MS = 20_000;
+const _presenceLastAt = new Map();
+
+function _presencePath(id) {
+    if (!id || typeof id !== 'string' || !/^[A-Za-z0-9_-]+$/.test(id)) {
+        throw new Error(`[session-store] invalid session id: ${JSON.stringify(id)}`);
+    }
+    return join(getStoreDir(), `${id}.own`);
+}
+
+export function publishSessionPresence(id, ts) {
+    if (!id) return;
+    const now = ts || Date.now();
+    const last = _presenceLastAt.get(id) || 0;
+    if (now - last < _PRESENCE_THROTTLE_MS) return;
+    const target = _presencePath(id);
+    _presenceLastAt.set(id, now);
+    void fsp.writeFile(target, `${now}\n${process.pid}\n`, 'utf8').catch(() => {});
+}
+
+export function deleteSessionPresence(id) {
+    if (!id) return;
+    try { unlinkSync(_presencePath(id)); } catch { /* ignore */ }
+    _presenceLastAt.delete(id);
+}
+
+export function readSessionPresenceMtime(id) {
+    if (!id) return 0;
+    try {
+        const path = _presencePath(id);
+        return existsSync(path) ? (statSync(path).mtimeMs || 0) : 0;
+    } catch {
+        return 0;
+    }
+}
+
+// A force-killed owner never clears its presence sidecar, so bare mtime
+// freshness would lock every resume inside the window into viewer mode with
+// nobody draining the shared spool. The `.own` payload records the holder's
+// pid; a recorded-but-dead pid is authoritative proof the owner is gone.
+export function isSessionPresenceOwnerDead(id) {
+    if (!id) return false;
+    let pid = 0;
+    try {
+        const path = _presencePath(id);
+        if (!existsSync(path)) return false;
+        pid = Number(String(readFileSync(path, 'utf8')).split('\n')[1]) || 0;
+    } catch {
+        return false;
+    }
+    if (!pid) return false;
+    try {
+        process.kill(pid, 0);
+        return false;
+    } catch (error) {
+        // ESRCH: no such process. EPERM means the pid exists (alive).
+        return error?.code === 'ESRCH';
+    }
+}

package/src/runtime/agent/orchestrator/session/store-summary-index.mjs

@@ -9,8 +9,13 @@ import { mkdirSync } from 'fs';
 import { join } from 'path';
 import { getPluginData } from '../config.mjs';
 import { updateJsonAtomicSync, updateJsonAtomic, writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
+import {
+    cleanSessionPreview,
+    isSessionPreviewNoise,
+    sessionMessageText,
+} from '../../../../session-runtime/session-text.mjs';
 
-export const SESSION_SUMMARY_INDEX_VERSION = 1;
+export const SESSION_SUMMARY_INDEX_VERSION = 2;
 
 export function summaryIndexPath() {
     const dir = getPluginData();
@@ -19,52 +24,28 @@ export function summaryIndexPath() {
 }
 
 function _messageText(content) {
-    if (typeof content === 'string') return content;
-    if (Array.isArray(content)) {
-        return content.map((part) => {
-            if (typeof part === 'string') return part;
-            if (part?.type === 'text') return part.text || '';
-            if (typeof part?.text === 'string') return part.text;
-            try { return JSON.stringify(part); } catch { return ''; }
-        }).filter(Boolean).join('\n');
-    }
-    if (content && typeof content === 'object') {
-        if (typeof content.text === 'string') return content.text;
-        try { return JSON.stringify(content); } catch { return ''; }
-    }
-    return '';
+    return sessionMessageText(content);
 }
 
 export function _cleanPreview(text, max = 240) {
-    const value = String(text || '').replace(/\s+/g, ' ').trim();
+    const value = cleanSessionPreview(text, max);
     return value.length > max ? value.slice(0, max).replace(/\s+\S*$/, '').trim() : value;
 }
 
 function _isPreviewNoise(text) {
-    const value = String(text || '').trim();
-    if (!value) return true;
-    if (value.startsWith('<system-reminder>')) return true;
-    if (/^Reference files:/i.test(value)) return true;
-    return false;
+    return isSessionPreviewNoise(text);
 }
 
 function _sessionPreview(session) {
     const messages = Array.isArray(session?.messages) ? session.messages : [];
-    let first = '';
     for (const m of messages) {
         if (m?.role !== 'user') continue;
-        const text = _cleanPreview(_messageText(m.content));
-        if (_isPreviewNoise(text)) continue;
-        if (!first) first = text;
+        const raw = _messageText(m.content);
+        if (_isPreviewNoise(raw)) continue;
+        const text = _cleanPreview(raw);
+        if (text) return text;
     }
-    for (let i = messages.length - 1; i >= 0; i -= 1) {
-        const m = messages[i];
-        if (m?.role !== 'user') continue;
-        const text = _cleanPreview(_messageText(m.content));
-        if (_isPreviewNoise(text)) continue;
-        return text || first;
-    }
-    return first;
+    return '';
 }
 
 function _sessionMessageCount(session) {