mixdog 0.9.87 → 0.9.89

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

@@ -4,7 +4,7 @@
 // in-flight controller, tears down runtime/bash/dedup/offload/pending state,
 // and defers the runtime-map clear. abortSessionTurn cancels the current turn
 // without tombstoning.
-import { loadSession, markSessionClosed, bumpSessionGeneration } from '../store.mjs';
+import { loadSession, markSessionClosed, bumpSessionGeneration, getSessionLifecycleCommitError } from '../store.mjs';
 import { clearReadDedupSession } from '../read-dedup.mjs';
 import { clearOffloadSession } from '../tool-result-offload.mjs';
 import { SessionClosedError } from './session-errors.mjs';
@@ -70,9 +70,43 @@ export function closeSession(id, reason = 'manual', opts = {}) {
     //    write could silently overwrite the session after the user resumes
     //    it back (BL: burned-session late-save clobber).
     const newGen = tombstone ? markSessionClosed(id, reason) : bumpSessionGeneration(id, reason);
+    // Durable lifecycle barrier check. `null` is ambiguous — it covers both a
+    // legitimate veto (session gone, live owner, contended commit) and a
+    // FAILED durable write. Only the latter publishes a lifecycle commit
+    // error. When the barrier never landed there is no tombstone and no
+    // generation bump on disk, so nothing fences a late save: tearing down
+    // here would abort the provider and clear the crash checkpoint while the
+    // session remains open and resumable on disk — the exact way a failed
+    // close silently destroys a turn. Leave every runtime structure intact,
+    // surface the cause, and report failure to the caller.
+    // ANY nonnumeric result means the barrier is not on disk — a write
+    // failure, a liveness/ownership veto, a contended commit lock, or a
+    // missing record. The detail map only explains WHY when the cause was a
+    // failed write; its absence is not evidence of success. Treating a
+    // detail-less null as a close is what let a vetoed/failed close abort the
+    // provider and drop the crash checkpoint while the session stayed open and
+    // resumable on disk. Leave every runtime structure intact and report
+    // failure in all of them.
+    if (typeof newGen !== 'number') {
+        const commitError = getSessionLifecycleCommitError(id);
+        const detail = commitError
+            ? `${commitError.message}${commitError.code ? ` (${commitError.code})` : ''}`
+            : 'no durable barrier written (veto, contended commit, or missing record)';
+        if (entry) {
+            entry.lastError = `session close failed: ${detail}`;
+            entry.closeBarrierError = commitError || { message: detail, code: null, reason, at: Date.now() };
+        }
+        try {
+            process.stderr.write(
+                `[agent-close] session=${id} reason=${reason} tombstone=${tombstone} `
+                + `FAILED durable lifecycle barrier: ${detail}\n`,
+            );
+        } catch { /* best-effort */ }
+        return false;
+    }
     // prepareCloseSnapshot was folded into the synchronous generation write
     // above. Only now is it safe to remove the crash fallback.
-    if (typeof newGen === 'number') clearTurnCheckpoint(id);
+    clearTurnCheckpoint(id);
     // 2. Mark runtime as closed so post-await validation in askSession fires.
     if (entry) {
         entry.closed = true;
@@ -134,3 +168,67 @@ export function abortSessionTurn(id, reason = 'turn-abort') {
     try { globalThis.__mixdogCloseProviderConnectionsForSession?.(id, `turn-abort:${reason}`); } catch { /* ignore */ }
     return true;
 }
+
+// Stages that still own live provider/tool work. An entry in one of them is
+// never unloaded — the caller's "this agent finished" belief lost a race.
+const _UNLOAD_BLOCKED_STAGES = new Set([
+    'connecting', 'requesting', 'streaming', 'tool_running', 'cancelling',
+]);
+
+/**
+ * Runtime-only unload for a session whose work is DONE.
+ *
+ * Releases the heavy process-local runtime a finished agent still pins —
+ * persistent bash shells (real child processes), pooled provider connections,
+ * the read-dedup cache, and the liveness/metric runtime entry — WITHOUT
+ * touching lifecycle state. Deliberately NOT a close:
+ *   - no markSessionClosed() tombstone and no bumpSessionGeneration(): the
+ *     session file stays open and resumable, so a same-tag follow-up
+ *     (`agent type=send`) resumes the SAME session with its full transcript
+ *     instead of respawning a fresh one through tombstone absorption;
+ *   - no controller abort: an unload never cancels work, it only reclaims
+ *     what a settled turn left behind;
+ *   - offload sidecars, the turn checkpoint and persisted pending messages
+ *     are left intact — they are the follow-up turn's context, not runtime.
+ * Terminal ownership stays with the caller's own reap path (agent-tool
+ * scheduleReap → closeSession('terminal-reap')).
+ *
+ * Returns false (changing nothing) when the session is still in flight.
+ */
+export function unloadSessionRuntime(id, reason = 'runtime-unload') {
+    if (!id) return false;
+    const entry = _getRuntimeEntry(id);
+    // Liveness veto: an unaborted controller or a non-settled stage means the
+    // session still owns provider/tool work. Unloading under it would kill the
+    // shells and connections of a running turn.
+    //
+    // `closed === true` is NOT an exemption. closeSession() flips closed and
+    // sets stage='cancelling' while the provider call is still unwinding (it
+    // defers _clearSessionRuntime to the next tick precisely because the turn
+    // has not settled yet), and a close whose durable barrier failed leaves an
+    // unaborted controller behind. Both are live work: veto and touch nothing.
+    if (entry) {
+        if (entry.controller && !entry.controller.signal?.aborted) return false;
+        if (_UNLOAD_BLOCKED_STAGES.has(entry.stage)) return false;
+    }
+    _stopToolActivityHeartbeat(id);
+    // Prefer the in-memory runtime session: shells opened in the last turn may
+    // not be on disk yet (same BL-bash-disk-sync reason as closeSession).
+    const persisted = entry?.session || loadSession(id);
+    const bashSessionId = persisted?.implicitBashSessionId || null;
+    const allBashIds = Array.isArray(persisted?.allBashSessionIds)
+        ? persisted.allBashSessionIds.filter(Boolean)
+        : (bashSessionId ? [bashSessionId] : []);
+    if (bashSessionId && !allBashIds.includes(bashSessionId)) allBashIds.push(bashSessionId);
+    for (const bsid of allBashIds) {
+        try { _closeBashSessionLazy(bsid, `runtime-unload:${id}`); } catch { /* ignore */ }
+    }
+    try { globalThis.__mixdogCloseProviderConnectionsForSession?.(id, `runtime-unload:${reason}`); } catch { /* ignore */ }
+    // Pure caches — a resumed turn rebuilds them from the transcript/disk.
+    try { clearReadDedupSession(id); } catch { /* ignore */ }
+    _clearSessionRuntime(id);
+    if (process.env.MIXDOG_DEBUG_SESSION_LOG) {
+        try { process.stderr.write(`[agent-unload] session=${id} reason=${reason} shells=${allBashIds.length}\n`); } catch { /* best-effort */ }
+    }
+    return true;
+}

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

@@ -47,6 +47,34 @@ export function listSessions(opts = {}) {
     // (e.g. agent list includeClosed:true).
     return sessions.filter(s => !hiddenIds.has(s.id) && (includeClosed || s.closed !== true));
 }
+export async function updateSessionGeneratedTitle(id, title, stage) {
+    const session = loadSession(id);
+    if (!session || session.closed === true) return false;
+    const normalized = String(title || '').replace(/\s+/g, ' ').trim().slice(0, 100);
+    const normalizedStage = stage === 'third' ? 'third' : stage === 'first' ? 'first' : '';
+    if (!normalized || !normalizedStage) return false;
+    if (session.titleLocked === true) return false;
+    if (session.generatedTitleStage === 'third') return false;
+    if (normalizedStage === 'first' && session.generatedTitleStage === 'first') return false;
+    if (session.title === normalized && session.generatedTitleStage === normalizedStage) return false;
+    session.title = normalized;
+    session.generatedTitleStage = normalizedStage;
+    session.titleUpdatedAt = Date.now();
+    await saveSessionAsync(session, { expectedGeneration: session.generation });
+    return true;
+}
+export async function updateSessionManualTitle(id, title) {
+    const session = loadSession(id);
+    if (!session || session.closed === true) return false;
+    const normalized = String(title || '').replace(/\s+/g, ' ').trim().slice(0, 100);
+    if (!normalized) return false;
+    if (session.title === normalized && session.titleLocked === true) return false;
+    session.title = normalized;
+    session.titleLocked = true;
+    session.titleUpdatedAt = Date.now();
+    await saveSessionAsync(session, { expectedGeneration: session.generation });
+    return true;
+}
 // --- Clear messages (keep system prompt + provider/model/cwd) ---
 export async function clearSessionMessages(sessionId, options = {}) {
     const session = loadSession(sessionId);

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

@@ -538,16 +538,62 @@ function _rememberPreparedResume(sessionId, prepared) {
     }
 }
 
+function _preparedResumeForSession(session, preset) {
+    const cached = _preparedResumes.get(session.id);
+    if (cached?.session === session && cached?.preset === preset) return cached;
+    const prepared = _prepareResumeTools(session, preset);
+    _rememberPreparedResume(session.id, prepared);
+    return prepared;
+}
+
 // 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));
+    _preparedResumeForSession(session, preset);
     return true;
 }
 
+// Read-only desktop-pane projection. It shares the exact prepared tool surface
+// that resumeSession will consume, but clones the session instead of claiming
+// ownership or persisting refreshed metadata. This lets every visible pane run
+// the live context-pressure calculation before it is ever focused.
+export function prepareSessionProjection(session, preset = 'full') {
+    if (!session?.id) return null;
+    const prepared = _preparedResumeForSession(session, preset);
+    let contextMeta = null;
+    try {
+        const provider = session.provider ? getProvider(session.provider) : null;
+        if (provider && session.model) {
+            contextMeta = resolveSessionContextMeta(provider, session.model, session);
+        }
+    } catch {
+        // A cold metadata/provider failure must not make the transcript vanish.
+    }
+    return {
+        ...session,
+        toolSpec: prepared.toolSpec,
+        tools: prepared.tools,
+        ...(contextMeta ? {
+            contextWindow: contextMeta.contextWindow,
+            rawContextWindow: contextMeta.rawContextWindow,
+            effectiveContextWindowPercent: contextMeta.effectiveContextWindowPercent,
+            autoCompactTokenLimit: contextMeta.autoCompactTokenLimit,
+            compactBoundaryTokens: contextMeta.compactBoundaryTokens,
+            compaction: {
+                ...(session.compaction || {}),
+                boundaryTokens: contextMeta.compactBoundaryTokens,
+                contextWindow: contextMeta.contextWindow,
+                rawContextWindow: contextMeta.rawContextWindow,
+                effectiveContextWindowPercent: contextMeta.effectiveContextWindowPercent,
+                autoCompactTokenLimit: contextMeta.autoCompactTokenLimit,
+            },
+        } : {}),
+    };
+}
+
 // Owner-pid hint for liveness signals that carry NO pid of their own:
 // `session.lastHeartbeatAt` is persisted in the session file and therefore
 // survives its writer forever, and pre-pid `.hb` sidecars only hold a
@@ -620,6 +666,38 @@ export function isSessionOwnerGone(sessionId) {
     return !_isActivelyOwnedElsewhere(session, sessionId);
 }
 
+function _recoverTurnCheckpointDurably(session, sessionId) {
+    const recovery = recoverTurnCheckpoint(session);
+    if (!recovery.changed) return recovery;
+    // Recovery is a durable reconnect boundary, not a renderer-only view.
+    // Persist before removing the checkpoint so a second crash leaves at
+    // least one complete copy of the interrupted turn.
+    saveSession(session, {
+        sync: true,
+        expectedGeneration: session.generation,
+    });
+    if (recovery.turnToken) {
+        clearTurnCheckpoint(sessionId, recovery.turnToken);
+    }
+    // A force-killed owner cannot clear its activity/presence sidecars. Once
+    // its checkpoint is committed as interrupted, neither sidecar may keep a
+    // restored pane busy or make a new prompt queue behind a dead process.
+    deleteSessionPresence(sessionId);
+    void deleteHeartbeat(sessionId);
+    return recovery;
+}
+
+// Reconnect-safe historical read used by desktop pane peeks. Unlike a normal
+// read-only load, it resolves a dead owner's durable turn checkpoint before
+// returning the transcript. A genuinely live foreign owner remains untouched.
+export function recoverSessionAfterProcessRestart(sessionId) {
+    const session = loadSession(sessionId);
+    if (!session || session.closed === true) return session || null;
+    if (_isActivelyOwnedElsewhere(session, sessionId)) return session;
+    _recoverTurnCheckpointDurably(session, sessionId);
+    return session;
+}
+
 export async function resumeSession(sessionId, preset, options = {}) {
     let session = loadSession(sessionId);
     if (!session)
@@ -658,19 +736,7 @@ export async function resumeSession(sessionId, preset, options = {}) {
         }
         return attached;
     }
-    const crashRecovery = recoverTurnCheckpoint(session);
-    if (crashRecovery.changed) {
-        // Resume must not expose a recovered frame that exists only in memory.
-        // Persist synchronously, then remove the sidecar; a second crash at
-        // either boundary therefore leaves at least one complete copy.
-        saveSession(session, {
-            sync: true,
-            expectedGeneration: session.generation,
-        });
-        if (crashRecovery.turnToken) {
-            clearTurnCheckpoint(sessionId, crashRecovery.turnToken);
-        }
-    }
+    _recoverTurnCheckpointDurably(session, sessionId);
     const oldTools = session.tools || [];
     const cached = _preparedResumes.get(sessionId);
     _preparedResumes.delete(sessionId);

package/src/runtime/agent/orchestrator/session/manager/turn-checkpoint.mjs

@@ -5,6 +5,7 @@ import {
     unlinkSync,
     writeFileSync,
 } from 'fs';
+import { writeFile } from 'fs/promises';
 import { randomBytes } from 'crypto';
 import { join } from 'path';
 import { getPluginData } from '../../config.mjs';
@@ -54,10 +55,134 @@ export function turnMessagesForCheckpoint(messages, currentUserContent) {
     return turn.map(checkpointMessage);
 }
 
-export function writeTurnCheckpoint(checkpoint) {
+/** Read-only projection for a turn still owned by another process. Unlike
+ * recoverTurnCheckpoint this never mutates the session, clears the checkpoint,
+ * or marks a live turn as interrupted. */
+export function projectTurnCheckpointMessages(session, checkpoint) {
+    const source = Array.isArray(session?.messages) ? session.messages : [];
+    if (!session?.id || checkpoint?.sessionId !== session.id
+        || !Array.isArray(checkpoint?.turnMessages)) return source;
+    const sessionGeneration = Number(session.generation) || 0;
+    const checkpointGeneration = Number(checkpoint.generation) || 0;
+    const owner = String(session.owner || '').trim().toLowerCase();
+    const agent = String(session.agent || '').trim().toLowerCase();
+    const detachedLiveAgent = session.closed === true
+        && (owner === 'agent' || (agent && agent !== 'lead'))
+        && Boolean(String(session.ownerSessionId || session.parentSessionId || '').trim());
+    const markerToken = typeof session.activeTurnCheckpoint?.turnToken === 'string'
+        ? session.activeTurnCheckpoint.turnToken
+        : null;
+    const markerMatches = markerToken === checkpoint.turnToken;
+    const checkpointIsNewer = Number(checkpoint.updatedAt) > Number(session.updatedAt || 0);
+    // External workers deliberately detach the durable session before their
+    // shard-owned turn finishes. closeSession writes the lifecycle fence by
+    // advancing the session generation once, while that already-running turn
+    // keeps publishing under its original generation. Accept exactly that
+    // one-generation handoff only when the durable marker token still proves
+    // identity and the checkpoint was written after the detach.
+    const detachedGenerationHandoff = detachedLiveAgent
+        && sessionGeneration === checkpointGeneration + 1
+        && markerMatches
+        && checkpointIsNewer;
+    if ((checkpointGeneration !== sessionGeneration && !detachedGenerationHandoff)
+        || (markerToken && !markerMatches)
+        || (!markerToken && !checkpointIsNewer)) return source;
+    let start = -1;
+    for (let index = source.length - 1; index >= 0; index -= 1) {
+        if (matchingUserMessage(source[index], checkpoint.currentUserContent)) {
+            start = index;
+            break;
+        }
+    }
+    return [
+        ...(start >= 0 ? source.slice(0, start) : source),
+        ...checkpoint.turnMessages,
+    ];
+}
+
+// ── Async checkpoint writes ──────────────────────────────────────────────────
+// The throttled streaming-delta flushes used to serialize+write synchronously
+// on the engine thread (up to ~6 stalls/second during a tool-heavy turn). The
+// async lane keeps per-session latest-wins coalescing (one in-flight write,
+// one queued payload) with an epoch so clear/stop can retire stale writes —
+// no locks, sessions stay fully parallel. The FIRST write of a turn stays
+// sync (opts.sync) because it is the crash-durability anchor for the prompt.
+const _pendingCheckpointWrites = new Map(); // sessionId → { queued, writing, epoch }
+const _asyncWriteWarned = new Set(); // sessionId — warn once per session
+
+function _warnAsyncWriteOnce(sessionId, error) {
+    if (_asyncWriteWarned.has(sessionId)) return;
+    _asyncWriteWarned.add(sessionId);
+    try {
+        process.stderr.write(`[turn-checkpoint] async write failed session=${sessionId}: ${error?.message || error}\n`);
+    } catch { /* stderr best-effort */ }
+}
+
+/** Retire queued + in-flight async writes for a session (epoch bump). */
+export function cancelPendingTurnCheckpoint(sessionId) {
+    const entry = _pendingCheckpointWrites.get(sessionId);
+    if (!entry) return;
+    entry.queued = null;
+    entry.epoch += 1;
+    if (!entry.writing) _pendingCheckpointWrites.delete(sessionId);
+}
+
+function _pumpCheckpointWrites(sessionId) {
+    const entry = _pendingCheckpointWrites.get(sessionId);
+    if (!entry || entry.writing) return;
+    if (!entry.queued) {
+        _pendingCheckpointWrites.delete(sessionId);
+        return;
+    }
+    const { target, json } = entry.queued;
+    entry.queued = null;
+    entry.writing = true;
+    const epoch = entry.epoch;
+    const temp = `${target}.${randomBytes(6).toString('hex')}.tmp`;
+    writeFile(temp, json, 'utf8')
+        .then(() => {
+            // A clear/stop after this write was dequeued must win: renaming a
+            // retired payload would resurrect a checkpoint the turn already
+            // finalized. The epoch check and rename run in one synchronous
+            // block, so cancel (also synchronous) can never interleave.
+            if (entry.epoch !== epoch) {
+                try { unlinkSync(temp); } catch { /* best-effort */ }
+                return;
+            }
+            renameWithRetrySync(temp, target);
+        })
+        .catch((error) => {
+            try { unlinkSync(temp); } catch { /* best-effort */ }
+            _warnAsyncWriteOnce(sessionId, error);
+        })
+        .finally(() => {
+            entry.writing = false;
+            _pumpCheckpointWrites(sessionId);
+        });
+}
+
+// Hard-exit parity with the old sync behavior: a queued-but-unwritten payload
+// is flushed synchronously so a clean process exit never loses the newest
+// checkpoint state (crash loss remains bounded by the caller's throttle).
+process.on('exit', () => {
+    for (const [sessionId, entry] of _pendingCheckpointWrites) {
+        if (!entry.queued) continue;
+        const { target, json } = entry.queued;
+        entry.queued = null;
+        const temp = `${target}.${randomBytes(6).toString('hex')}.tmp`;
+        try {
+            writeFileSync(temp, json, 'utf8');
+            renameWithRetrySync(temp, target);
+        } catch (error) {
+            try { unlinkSync(temp); } catch { /* best-effort */ }
+            _warnAsyncWriteOnce(sessionId, error);
+        }
+    }
+});
+
+export function writeTurnCheckpoint(checkpoint, { sync = true } = {}) {
     if (!checkpoint?.sessionId || !checkpoint?.turnToken) return false;
     const target = turnCheckpointPath(checkpoint.sessionId);
-    const temp = `${target}.${randomBytes(6).toString('hex')}.tmp`;
     const payload = {
         ...checkpoint,
         version: TURN_CHECKPOINT_VERSION,
@@ -66,6 +191,16 @@ export function writeTurnCheckpoint(checkpoint) {
             .map(checkpointMessage),
         updatedAt: Date.now(),
     };
+    if (!sync) {
+        const json = JSON.stringify(payload);
+        const entry = _pendingCheckpointWrites.get(checkpoint.sessionId)
+            ?? { queued: null, writing: false, epoch: 0 };
+        _pendingCheckpointWrites.set(checkpoint.sessionId, entry);
+        entry.queued = { target, json };
+        _pumpCheckpointWrites(checkpoint.sessionId);
+        return true;
+    }
+    const temp = `${target}.${randomBytes(6).toString('hex')}.tmp`;
     try {
         writeFileSync(temp, JSON.stringify(payload), 'utf8');
         renameWithRetrySync(temp, target);
@@ -94,12 +229,17 @@ export function readTurnCheckpoint(sessionId) {
 
 export function clearTurnCheckpoint(sessionId, turnToken = null) {
     const target = turnCheckpointPath(sessionId);
+    // Queued async writes are stale the moment the caller decides to clear
+    // this turn's checkpoint; retire them BEFORE the token guard reads disk
+    // so a lagging write can never resurrect the file after the unlink.
+    if (!turnToken) cancelPendingTurnCheckpoint(sessionId);
     if (!existsSync(target)) return true;
     if (turnToken) {
         const current = readTurnCheckpoint(sessionId);
         // A token guard prevents an older turn's late terminal save from
         // deleting the checkpoint already created by its queued follow-up.
         if (current?.turnToken && current.turnToken !== turnToken) return false;
+        cancelPendingTurnCheckpoint(sessionId);
     }
     try {
         unlinkSync(target);