mixdog 0.9.95 → 0.9.96

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

@@ -1,7 +1,8 @@
 // Steering / pending-message queue with sync buffered + atomic-file persistence.
 // Extracted verbatim from manager.mjs (behavior-preserving).
 import { join } from 'path';
-import { readFileSync, statSync } from 'fs';
+import { readFileSync } from 'fs';
+import { stat } from 'fs/promises';
 import { createHash, randomBytes } from 'crypto';
 import { resolvePluginData } from '../../../../shared/plugin-paths.mjs';
 import { updateJsonAtomic } from '../../../../shared/atomic-file.mjs';
@@ -20,8 +21,8 @@ const PENDING_ORPHAN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const PENDING_ORPHAN_GRACE_MS = 60 * 60 * 1000;
 // Replay window for genuine user/steering entries. A cross-surface submit is
 // meant for a LIVE owner; entries that predate this process and exceeded the
-// window are still DELIVERED (CC parity, reference messageQueueManager.ts:
-// queued user input is never silently discarded), but annotated with an
+// window are still DELIVERED (queued user input is never silently
+// discarded), but annotated with an
 // explicit late-delivery header so a session resumed hours later reads them
 // as clearly-late input instead of a surprise self-injection.
 const STALE_USER_INJECTION_TTL_MS = 30 * 60 * 1000;
@@ -44,7 +45,7 @@ function isStaleUserInjection(entry, now = Date.now()) {
     return (now - enqueuedAt) > STALE_USER_INJECTION_TTL_MS;
 }
 
-// CC parity: never silently discard queued user input. A stale entry is
+// Never silently discard queued user input. A stale entry is
 // delivered with this explicit age-annotated header so neither the user nor
 // the model mistakes it for fresh input.
 function lateDeliveryText(text, entry, now = Date.now()) {
@@ -823,7 +824,7 @@ export function hydratePendingMessages(sessionId, options = {}) {
                 if (!id || inDelivery.has(id) || acked.has(id)) return false;
                 return true;
             });
-            // CC parity: stale genuine user/steering entries DELIVER with a
+            // Stale genuine user/steering entries DELIVER with a
             // late-delivery header instead of being silently dropped (the old
             // behavior discarded them; user report: remote/steering sends
             // silently ignored around owner restarts). Completion entries
@@ -1092,8 +1093,14 @@ export function enqueueRemotePendingMessage(sessionId, message) {
 // several sessions (desktop tabs, TUI + engine hosts) and a single shared
 // counter let the first drain of a tick swallow the mtime bump for every
 // other session, stranding their foreign submits until the next spool write.
-const FOREIGN_SPOOL_SCAN_LIMIT = 64;
+const FOREIGN_SPOOL_SCAN_LIMIT = Math.max(
+    128,
+    Number(process.env.MIXDOG_FOREIGN_SPOOL_SCAN_LIMIT) || 512,
+);
 const _foreignSpoolScanMtimes = new Map();
+const _foreignDrainRequests = new Map();
+let _foreignDrainScheduled = false;
+let _foreignDrainRunning = false;
 
 function _rememberForeignSpoolScan(sessionId, mtime) {
     _foreignSpoolScanMtimes.delete(sessionId);
@@ -1105,28 +1112,7 @@ function _rememberForeignSpoolScan(sessionId, mtime) {
     }
 }
 
-/**
- * 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 async function drainForeignUserInjections(sessionId) {
-    if (!isValidPendingSessionId(sessionId)) return [];
-    // DELIVERY path, not cleanup: this takes rows out of the spool and hands
-    // them to a live turn. A tombstoned (or otherwise invalidated) session may
-    // neither receive nor lose input, so the tombstone-TOLERANT epoch check
-    // used by the explicit cleanup mutations (ack / clear) is wrong here — the
-    // token is refused outright when it was captured from a closed session.
-    // Checked BEFORE the mtime memo so a later reopen still sees this spool
-    // state as unscanned.
-    const epochToken = currentPendingLifecycleToken(sessionId);
-    if (pendingLifecycleInvalidated(sessionId)) return [];
-    let mtime = 0;
-    try { mtime = statSync(pendingMessagesPath()).mtimeMs || 0; } catch { return []; }
-    if (_foreignSpoolScanMtimes.get(sessionId) === mtime) return [];
+function _foreignLocalIds(sessionId) {
     const localIds = new Set();
     for (const map of [_sessionPendingMessages, _pendingPersistBuffers, _hydratedPendingMessages]) {
         for (const entry of map.get(sessionId) || []) {
@@ -1146,59 +1132,86 @@ export async function drainForeignUserInjections(sessionId) {
             if (typeof id === 'string' && id) localIds.add(id);
         }
     } catch { /* ledger unavailable — in-memory sets still guard */ }
-    const taken = [];
-    // The mtime memo may ONLY be armed by a scan that actually reached a
-    // lifecycle-valid decision under the spool lock. Arming it upfront meant a
-    // drain refused in-lock (a close/detach/reopen landing in the window) still
-    // recorded this spool state as "seen": after the reopen the new owner
-    // polled the same unchanged mtime and skipped it, stranding the rows until
-    // some unrelated spool WRITE bumped the file. A refusal must leave the
-    // spool immediately pollable again.
-    let lifecycleDecided = false;
+    return localIds;
+}
+
+function _settleForeignDrain(request, value) {
+    for (const resolve of request.waiters) {
+        try { resolve(value); } catch { /* a consumer cannot break the batch */ }
+    }
+}
+
+function _scheduleForeignDrainBatch() {
+    if (_foreignDrainScheduled || _foreignDrainRunning || _foreignDrainRequests.size === 0) return;
+    _foreignDrainScheduled = true;
+    setImmediate(() => {
+        _foreignDrainScheduled = false;
+        void _flushForeignDrainBatch();
+    });
+}
+
+async function _flushForeignDrainBatch() {
+    if (_foreignDrainRunning) return;
+    _foreignDrainRunning = true;
+    const batch = [..._foreignDrainRequests.values()];
+    _foreignDrainRequests.clear();
     try {
-        // ASYNC spool lock. The sync variant parked the owning process's event
-        // loop in Atomics.wait for the whole timeout: in the daemon (PTYs,
-        // engines, IPC and SSE fan-out share one loop) every poll that lost the
-        // race froze the entire app, and it could never win against an async
-        // holder in the SAME process. Waiting off the loop also lets the
-        // in-process lock queue serialize sibling sessions for free.
+        let mtime = 0;
+        try { mtime = (await stat(pendingMessagesPath())).mtimeMs || 0; }
+        catch {
+            for (const request of batch) _settleForeignDrain(request, []);
+            return;
+        }
+        const candidates = batch.filter((request) =>
+            _foreignSpoolScanMtimes.get(request.sessionId) !== mtime
+            && !pendingLifecycleInvalidated(request.sessionId, request.epochToken));
+        for (const request of batch) {
+            if (!candidates.includes(request)) _settleForeignDrain(request, []);
+        }
+        if (candidates.length === 0) return;
+        for (const request of candidates) {
+            request.localIds = _foreignLocalIds(request.sessionId);
+            request.taken = [];
+            request.lifecycleDecided = false;
+        }
         await updateJsonAtomic(pendingMessagesPath(), (raw) => {
-            // Same authority re-read INSIDE the spool lock: a close/detach
-            // landing in this window must neither deliver to the old owner nor
-            // remove the reopened owner's rows.
-            runPendingTestHook('foreignDrain:beforeCommit', { sessionId });
-            if (pendingLifecycleInvalidated(sessionId, epochToken)) return undefined;
-            // Authoritative from here on: whatever this pass decides (take,
-            // drop-stale, or "nothing foreign here") is a real answer for THIS
-            // spool state, so the memo may skip re-scanning it.
-            lifecycleDecided = true;
             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);
-                // CC parity: stale foreign submits still deliver, carrying a
-                // late-delivery header instead of being silently removed
-                // (user report: remote sends silently discarded around owner
-                // restarts).
-                if (foreignUser && isStaleUserInjection(entry)) {
-                    taken.push({ text: lateDeliveryText(text, entry), id });
+            let changed = false;
+            for (const request of candidates) {
+                const { sessionId, epochToken, localIds, taken } = request;
+                // Same authority re-read INSIDE the spool lock: a close/detach
+                // landing in this window must neither deliver to the old owner
+                // nor remove the reopened owner's rows.
+                runPendingTestHook('foreignDrain:beforeCommit', { sessionId });
+                if (pendingLifecycleInvalidated(sessionId, epochToken)) continue;
+                request.lifecycleDecided = true;
+                const q = Array.isArray(next.sessions[sessionId]) ? next.sessions[sessionId] : [];
+                if (q.length === 0) continue;
+                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 && isStaleUserInjection(entry)) {
+                        taken.push({ text: lateDeliveryText(text, entry), id });
+                    } else if (foreignUser) {
+                        taken.push({ text, id });
+                    } else {
+                        kept.push(entry);
+                    }
+                }
+                if (taken.length === 0) continue;
+                changed = true;
+                if (kept.length > 0) next.sessions[sessionId] = kept;
+                else {
+                    delete next.sessions[sessionId];
+                    if (next.sessionTouchedAt) delete next.sessionTouchedAt[sessionId];
                 }
-                else if (foreignUser) taken.push({ text, id });
-                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];
             }
+            if (!changed) return undefined;
             next.updatedAt = Date.now();
             return next;
         }, {
@@ -1206,18 +1219,63 @@ export async function drainForeignUserInjections(sessionId) {
             lock: true,
             mode: PENDING_MESSAGES_MODE,
             fsync: false,
-            // Delivery polling must never wait on an async spool writer in the
-            // same daemon process: waiting synchronously prevents that writer
-            // from ever reaching its finally/release path.
+            // Delivery polling must never wait behind a spool writer. A later
+            // fs.watch/poll tick retries unchanged requests.
             timeoutMs: 0,
         });
+        for (const request of candidates) {
+            if (request.lifecycleDecided) _rememberForeignSpoolScan(request.sessionId, mtime);
+            _settleForeignDrain(request, request.taken);
+        }
     } catch (err) {
-        if (err?.code === 'ELOCKCONTENDED') return [];
-        try { process.stderr.write(`[session] foreign-injection drain failed sessionId=${sessionId}: ${err?.message || err}\n`); } catch {}
-        return [];
+        if (err?.code !== 'ELOCKCONTENDED') {
+            try { process.stderr.write(`[session] foreign-injection drain failed: ${err?.message || err}\n`); } catch {}
+        }
+        for (const request of batch) {
+            if (request.waiters.length > 0) _settleForeignDrain(request, []);
+        }
+    } finally {
+        _foreignDrainRunning = false;
+        _scheduleForeignDrainBatch();
     }
-    if (lifecycleDecided) _rememberForeignSpoolScan(sessionId, mtime);
-    return taken;
+}
+
+/**
+ * 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 async function drainForeignUserInjections(sessionId) {
+    if (!isValidPendingSessionId(sessionId)) return [];
+    // DELIVERY path, not cleanup: this takes rows out of the spool and hands
+    // them to a live turn. A tombstoned (or otherwise invalidated) session may
+    // neither receive nor lose input, so the tombstone-TOLERANT epoch check
+    // used by the explicit cleanup mutations (ack / clear) is wrong here — the
+    // token is refused outright when it was captured from a closed session.
+    // Checked BEFORE the mtime memo so a later reopen still sees this spool
+    // state as unscanned.
+    const epochToken = currentPendingLifecycleToken(sessionId);
+    if (pendingLifecycleInvalidated(sessionId)) return [];
+    return new Promise((resolve) => {
+        const existing = _foreignDrainRequests.get(sessionId);
+        if (existing && existing.epochToken === epochToken) {
+            existing.waiters.push(resolve);
+        } else {
+            if (existing) _settleForeignDrain(existing, []);
+            _foreignDrainRequests.set(sessionId, {
+                sessionId,
+                epochToken,
+                waiters: [resolve],
+                localIds: null,
+                taken: [],
+                lifecycleDecided: false,
+            });
+        }
+        _scheduleForeignDrainBatch();
+    });
 }
 
 export function drainPendingMessages(sessionId) {

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

@@ -17,6 +17,10 @@ export async function _getAgentLoop() {
     if (typeof mod.agentLoop !== 'function') throw new Error('agent loop runtime is not available');
     return mod.agentLoop;
 }
+export async function prewarmAgentLoop() {
+    await _getAgentLoop();
+    return true;
+}
 export function _closeBashSessionLazy(sessionId, reason) {
     if (!sessionId) return;
     _bashSessionRuntimePromise ??= import('../../tools/bash-session.mjs');

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

@@ -6,7 +6,7 @@ import { loadSession, saveSessionAsync, setLiveSession, evictLiveSession, listSt
 import { estimateMessagesTokens, estimateTranscriptContextUsage } from '../context-utils.mjs';
 import { normalizeCompactType, DEFAULT_COMPACT_TYPE, SUMMARY_PREFIX } from '../compact.mjs';
 import { runSessionCompaction } from './compaction-runner.mjs';
-import { hasUserConversationMessage } from './prompt-utils.mjs';
+import { hasUserConversationMessage, promptContentText } from './prompt-utils.mjs';
 import { getProvider } from '../../providers/registry.mjs';
 import { isSessionCompactionBlocked, getSessionAbortSignal, _runtimeEntries } from './runtime-liveness.mjs';
 import { mintSessionId } from './session-id.mjs';
@@ -314,3 +314,33 @@ export async function updateSessionStatus(id, status) {
     await saveSessionAsync(session, { expectedGeneration: session.generation });
     return true;
 }
+
+// --- Rewind to a previous user message (message selector) ---
+// Claude Code's "restore conversation": the selected prompt and everything
+// after it leave the model history so the user can edit and resubmit it.
+// Earlier turns — including any compaction rewrite that precedes them — stay
+// exactly as they are. Idle-only; the caller interrupts a live turn first.
+export async function rewindSessionMessagesTo(sessionId, options = {}) {
+    const session = loadSession(sessionId);
+    if (!session || session.closed === true) return null;
+    const target = String(options?.text ?? '').trim();
+    if (!target) return null;
+    const messages = Array.isArray(session.messages) ? session.messages : [];
+    let start = -1;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message?.role !== 'user') continue;
+        if (promptContentText(message.content).trim() !== target) continue;
+        start = index;
+        break;
+    }
+    if (start < 0) return null;
+    const removed = messages.length - start;
+    session.messages = messages.slice(0, start);
+    // The provider cache is keyed on the exact prefix we just truncated.
+    session.providerState = undefined;
+    session.updatedAt = Date.now();
+    session.lastUsedAt = Date.now();
+    await saveSessionAsync(session, { expectedGeneration: session.generation });
+    return { removed, remaining: session.messages.length };
+}

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

@@ -41,18 +41,25 @@ function assistantToolCallIds(message) {
     return ids;
 }
 
-function rewindProvisionalUserTurn(messages, currentUserContent) {
+function provisionalUserTurnIndex(messages, currentUserContent) {
     const currentText = promptContentText(currentUserContent);
     for (let i = messages.length - 1; i >= 0; i -= 1) {
         const message = messages[i];
         if (message?.role !== 'user') continue;
         if (message.content === currentUserContent
             || promptContentText(message.content) === currentText) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+function rewindProvisionalUserTurn(messages, currentUserContent) {
+    const index = provisionalUserTurnIndex(messages, currentUserContent);
+    if (index >= 0) {
             // Remove the provisional user turn plus pre-send hooks appended
             // after it, while retaining any compaction rewrite before it.
-            messages.splice(i);
-            break;
-        }
+        messages.splice(index);
     }
     return messages;
 }
@@ -69,13 +76,26 @@ function finalizeInterruptedTurn({
     abortReason,
 }) {
     const messages = filterModelVisibleSessionMessages(turnOutgoing).slice();
+    // Null/unknown reasons keep the legacy rewind (status quo for wrapped
+    // aborts without a closeReason enum); named non-user reasons preserve.
+    const userCancelled = abortReason == null
+        || USER_CANCEL_ABORT_REASONS.has(abortReason);
+    // Claude Code parity: a turn cancelled while the model was only THINKING
+    // produced no model-visible message, so the provisional user turn is
+    // rewound and the prompt goes back to the input box. Anything the model
+    // actually said or did — committed messages from this turn, buffered text,
+    // tool calls/results — keeps the turn (reasoning alone does not).
+    const producedOutput = String(partialAssistantContent || '').trim() !== ''
+        || observedToolCalls.size > 0
+        || observedToolResults.size > 0
+        || (() => {
+            const index = provisionalUserTurnIndex(messages, currentUserContent);
+            return index >= 0 && index < messages.length - 1;
+        })();
     const preserveResponse = responseStarted
-        && !isInternalRuntimeNotificationText(currentUserContent);
+        && !isInternalRuntimeNotificationText(currentUserContent)
+        && (producedOutput || !userCancelled);
     if (!preserveResponse) {
-        // Null/unknown reasons keep the legacy rewind (status quo for wrapped
-        // aborts without a closeReason enum); named non-user reasons preserve.
-        const userCancelled = abortReason == null
-            || USER_CANCEL_ABORT_REASONS.has(abortReason);
         if (!userCancelled) {
             return {
                 messages,

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

@@ -101,6 +101,7 @@ export {
 // ── Session lifecycle / ask / crud / close / cleanup ──────────────────────
 export { SessionClosedError } from './manager/session-errors.mjs';
 export { setAgentRuntime } from './manager/agent-runtime-singleton.mjs';
+export { prewarmAgentLoop } from './manager/runtime-loaders.mjs';
 export {
     createSession,
     updateSessionRoute,
@@ -120,6 +121,7 @@ export {
     listSessions,
     findSessionByScopeKey,
     clearSessionMessages,
+    rewindSessionMessagesTo,
     compactSessionMessages,
     updateSessionStatus,
     updateSessionGeneratedTitle,

package/src/runtime/agent/orchestrator/session/result-classification.mjs

@@ -96,3 +96,68 @@ export function isInformationalShellExitOne(result) {
     if (payload.startsWith('[stderr') || payload.includes('\n[stderr')) return false;
     return true;
 }
+
+/**
+ * Shell-result outcome test. The shell tool reports failure through its OWN
+ * status markers (bash-tool.mjs `_shellFailureStatus`): `Error:
+ * [shell-run-failed] …`, `Error: [shell-tool-failed] …`, or a bare
+ * `[exit code: N]` / `[timeout: …]` / `[signal: …]` marker — optionally behind
+ * ⚠️ destructive-warning lines, which are prepended AFTER the error prefix is
+ * composed. A generic leading `Error:` is NOT a shell failure: it is just as
+ * likely the command's own stdout, which is why classifyResultKind (correct
+ * for tools that own the `Error:` convention) over-reports on shell output.
+ *
+ * @param {unknown} result
+ * @returns {boolean}
+ */
+export function isShellFailureResult(result) {
+    if (typeof result !== 'string') return false;
+    const body = result.replace(/^(?:\s*⚠️[^\n]*\n)+/, '').trimStart();
+    if (/^error:\s*\[shell-(?:run|tool)-failed\]/i.test(body)) return true;
+    return /^\[(?:exit code:|timeout:|signal:)/i.test(body);
+}
+
+// Evidence that a command's OUTPUT reports a real failure. Used to separate a
+// legitimate non-zero exit (a probe or report that prints its result and ends
+// with 1) from a genuine failure that happens to write only to stdout — test
+// runners, compilers and package managers all announce themselves in the text.
+// Deliberately literal: only well-known failure banners count, so an unknown
+// tool's report is never mislabelled a failure.
+const SHELL_OUTPUT_FAILURE_EVIDENCE = [
+    /^not ok \d/m,
+    /^# fail [1-9]/m,
+    /\bAssertionError\b/,
+    /\bTraceback \(most recent call last\)/,
+    /^npm ERR!/m,
+    /\berror TS\d+\b/,
+    // Indented banners count too: runners print "  FAIL <case>" under a header.
+    /^\s*FAIL(?:ED|URE)?\b/mi,
+    /\bFAILED[:!]/,
+    /^\s*✗/m,
+    /\b\d+ (?:tests? )?failed\b/i,
+    /^fatal:/m,
+    /^error:/mi,
+    /\bSyntaxError\b|\bReferenceError\b|\bTypeError\b/,
+    /\bCannot find module\b/,
+];
+export function shellOutputReportsFailure(text) {
+    const body = String(text ?? '');
+    if (!body.trim()) return false;
+    return SHELL_OUTPUT_FAILURE_EVIDENCE.some((pattern) => pattern.test(body));
+}
+
+/**
+ * Classify a non-zero shell exit as a real failure or a legitimate report.
+ * Legitimate: exit code 1 exactly, no signal, NOTHING on stderr, real output
+ * on stdout, and no failure banner in that output. Everything else — any other
+ * exit code, a signal, any stderr, an empty capture, or a failure banner —
+ * stays a failure.
+ */
+export function isLegitimateShellExit({ exitCode, signal, stdout, stderr } = {}) {
+    if (signal) return false;
+    if (exitCode !== 1) return false;
+    if (String(stderr ?? '').trim()) return false;
+    const out = String(stdout ?? '').trim();
+    if (!out || out === '(no output)') return false;
+    return !shellOutputReportsFailure(out);
+}