mixdog 0.9.19 → 0.9.21

package/src/runtime/agent/orchestrator/session/compact/engine.mjs

@@ -88,6 +88,12 @@ function indexLiveTurns(live) {
 function splitTurnStartIndexForBudget(turn, budget) {
     const { start, end, messages } = turn;
     for (let i = 0; i < messages.length; i += 1) {
+        // A tool result must stay paired with its preceding assistant tool_call,
+        // so the preserved tail suffix can never begin at one (mirrors
+        // findValidCutIndices). Skip tool-result boundaries; if no non-tool
+        // suffix fits the budget, fall through to `end` so the caller keeps the
+        // whole turn in the head for summarization instead of orphaning it.
+        if (messages[i]?.role === 'tool') continue;
         const suffixStart = start + i;
         const suffix = messages.slice(i);
         if (suffix.length > 0 && estimateMessagesTokens(suffix) <= budget) {

package/src/runtime/agent/orchestrator/session/eager-dispatch.mjs

@@ -0,0 +1,153 @@
+// Eager tool-dispatch controller, extracted from agent-loop.mjs. Owns the
+// per-turn pending promise map, the intra-turn in-flight signature set, and
+// the mutation epoch. Read-only tool calls start executing the instant the
+// provider streams a tool_use event so execution overlaps the remaining SSE
+// parse; writes/unknown tools wait for the serial batch loop. Behavior
+// identical to the inline closures it replaced.
+import { normalizeToolEnvelope } from './tool-envelope.mjs';
+import { isInvalidToolArgsMarker } from '../providers/openai-compat-stream.mjs';
+import { _intraTurnSig } from './loop/tool-classify.mjs';
+import { preDispatchDenyForSession } from './loop/pre-dispatch-deny.mjs';
+import { executeTool } from './loop/tool-exec.mjs';
+import { crossTurnSignature } from './loop/completion-guards.mjs';
+import { getToolKind, isEagerDispatchable } from './loop/tool-helpers.mjs';
+
+export function createEagerDispatcher({
+    tools, cwd, sessionId, sessionRef, signal, opts,
+    crossTurnCalls, getIterations, getNextIteration, repeatFailLimit,
+}) {
+        const pending = new Map();
+        // Streaming-time intra-turn dedup. When the LLM emits two
+        // tool_use blocks with identical (name, args) signatures in
+        // sequence, the provider's onToolCall fires for both BEFORE
+        // the iter for-body runs, so the batch-level pre-pass would be
+        // too late to prevent the eager dispatch of the second one.
+        // Track signatures of in-flight eager calls and skip starting a
+        // second one for the same sig. The duplicate's executeTool is
+        // never invoked; the for-body's pre-pass marks it as a duplicate
+        // and emits a stub tool_result. The sig is NOT cleared when the
+        // eager promise settles (see finally below): a streaming onToolCall
+        // can deliver a same-turn identical call AFTER the first promise
+        // settles but BEFORE the deferred cache set (:1256), and the static
+        // pre-pass (:909) only runs after send() returns — so clearing the
+        // sig on settle would let that second streaming eager call
+        // re-execute. A fresh Map() is created per turn, so the sig set
+        // resets at the turn boundary without leaking across getIterations().
+        const _eagerInFlightSigs = new Map();
+        const epoch = { mutation: 0 };
+        const startEagerTool = (call) => {
+            if (!call?.id || pending.has(call.id) || !isEagerDispatchable(call.name, tools)) return null;
+            // Never eager-execute a call whose arguments failed to parse
+            // (invalid-args marker). It has no usable arguments; the serial
+            // body handles it via the invalid-args feedback path.
+            if (isInvalidToolArgsMarker(call.arguments)) return null;
+            const _sig = _intraTurnSig(call.name, call.arguments);
+            if (_eagerInFlightSigs.has(_sig)) return null;
+            // Repeat-failure guard also gates eager dispatch (reviewer-flagged):
+            // streaming onToolCall / startEagerRun would otherwise re-run an
+            // identical read-only call that already failed repeatFailLimit
+            // times before the serial for-body guard runs. Returning null here
+            // lets the serial body push the [repeat-failure-guard] stub.
+            {
+                const _rfg = sessionRef?._repeatFailGuard;
+                if (_rfg && _rfg.sig === _sig && _rfg.count >= repeatFailLimit) return null;
+            }
+            // Cross-turn dedup also gates eager dispatch (mirror of the
+            // repeat-failure guard above): a read-only call whose (name,args)
+            // signature already ran in an EARLIER turn must NOT be eagerly
+            // re-executed — the serial for-body pushes the [cross-turn-dedup]
+            // stub instead. Without this gate startEagerRun/onToolCall would
+            // re-run the call before the serial dedup check ever sees it.
+            {
+                const _ctSig = crossTurnSignature(call.name, call.arguments);
+                const _prior = crossTurnCalls.get(_ctSig);
+                if (_prior && _prior.firstIteration < getIterations()) return null;
+            }
+            const toolKind = getToolKind(call.name);
+            // Shared pre-dispatch deny: identical predicate runs in the
+            // serial path below. If any role/permission guard would reject
+            // this call there, never start it eagerly here.
+            if (preDispatchDenyForSession(sessionRef, call, toolKind) !== null) return null;
+            const entry = { startedAt: Date.now(), endedAt: null, mutationEpoch: epoch.mutation };
+            _eagerInFlightSigs.set(_sig, call.id);
+            entry.promise = (async () => {
+                try {
+                    return { ok: true, value: await executeTool(call.name, call.arguments, cwd, sessionId, sessionRef, { toolCallId: call.id, signal, notifyFn: opts.notifyFn, toolApprovalHook: opts.onToolApproval, iteration: getNextIteration() }) };
+                } catch (error) {
+                    return { ok: false, error };
+                }
+            })()
+                .then((settled) => {
+                    entry.endedAt = Date.now();
+                    // EARLY UI-ONLY NOTIFY (completion-order, NOT history).
+                    // The serial result-collection loop below `await`s each
+                    // eager promise strictly in CALL order, so a fast call[1]
+                    // that settles before a slow call[0] cannot surface its
+                    // tool card completion until call[0] resolves. Fire
+                    // onToolResult here — the instant THIS eager tool settles —
+                    // so parallel cards complete independently in the order they
+                    // actually finish.
+                    //
+                    // This message is NOT pushed into `messages`: provider
+                    // history ordering stays exactly call-order. The serial loop
+                    // still builds the REAL tool_result and pushes it via
+                    // pushToolResultMessage (which fires onToolResult AGAIN for
+                    // the same toolCallId in call order — the TUI dedupes by id,
+                    // so the duplicate notify is harmless). __earlyNotify marks
+                    // this as the pre-history, UI-only signal.
+                    //
+                    // Only genuinely-executed eager promises reach here:
+                    // startEagerTool never creates an entry for dedup /
+                    // repeat-failure-guard / pre-dispatch-deny / invalid-args
+                    // calls (they return null above), so those `continue`-before-
+                    // execution stub paths can never early-notify (contract #5).
+                    try {
+                        // UI-only: surface the model-VISIBLE result (envelope
+                        // stub for envelope returns), never the envelope object
+                        // or its injected newMessages body — no [object Object],
+                        // no full skill body in the tool card.
+                        const _earlyVisible = settled && settled.ok
+                            ? normalizeToolEnvelope(settled.value).result
+                            : null;
+                        const _earlyContent = settled && settled.ok
+                            ? (typeof _earlyVisible === 'string'
+                                ? _earlyVisible
+                                : (_earlyVisible == null ? '' : String(_earlyVisible)))
+                            : `Error: ${settled && settled.error instanceof Error ? settled.error.message : String(settled && settled.error)}`;
+                        opts.onToolResult?.({
+                            role: 'tool',
+                            toolCallId: call.id,
+                            content: _earlyContent,
+                            isError: !(settled && settled.ok),
+                            __earlyNotify: true,
+                        });
+                    } catch { /* best-effort — UI notify must never break the eager path */ }
+                    // Intentionally do NOT delete _sig here — see the block
+                    // comment above. The sig must outlive promise settlement
+                    // so a later same-turn streaming duplicate stays blocked
+                    // at the _eagerInFlightSigs.has(_sig) guard until the turn
+                    // boundary recreates the Map.
+                    return settled;
+                });
+            pending.set(call.id, entry);
+            return entry;
+        };
+        const startEagerRun = (calls, startIndex, dupSet) => {
+            for (let j = startIndex; j < calls.length; j += 1) {
+                const call = calls[j];
+                if (!call?.id || !isEagerDispatchable(call.name, tools)) break;
+                if (dupSet && dupSet.has(call.id)) continue;
+                if (!startEagerTool(call) && !pending.has(call.id)) break;
+            }
+        };
+        let _streamEagerBlocked = false;
+        const onToolCall = (call) => {
+            if (!isEagerDispatchable(call?.name, tools)) {
+                _streamEagerBlocked = true;
+                return;
+            }
+            if (_streamEagerBlocked) return;
+            startEagerTool(call);
+        };
+    return { pending, epoch, startEagerTool, startEagerRun, onToolCall };
+}

package/src/runtime/agent/orchestrator/session/loop/recall-fasttrack.mjs

@@ -67,6 +67,20 @@ function buildRecallDigestText(sessionId, digestBody, maxKb) {
     ].join('\n');
 }
 
+// Abort/cancel detection: a cancelled session (ESC / new prompt / signal abort)
+// surfaces as an AbortError or a DOMException with ABORT_ERR from the internal
+// tool. That is NOT a memory-pipeline failure — rethrow it unchanged so the
+// caller records a cancellation, never an AGENT_CONTEXT_OVERFLOW.
+function isAbortLikeError(err, signal) {
+    if (signal?.aborted) return true;
+    if (!err) return false;
+    const name = err.name || '';
+    const code = err.code || '';
+    if (name === 'AbortError' || code === 'ABORT_ERR' || code === 'ABORT') return true;
+    const msg = String(err.message || err).toLowerCase();
+    return /\babort(ed|ing)?\b|\bcancel(l?ed|ling)?\b/.test(msg);
+}
+
 export async function runRecallFastTrackCompact({ sessionRef, messages, compactBudgetTokens, compactPolicy, sessionId, signal }) {
     if (!sessionId) throw new Error('recall-fasttrack requires a session id');
     const startedAt = Date.now();
@@ -103,6 +117,10 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
         || Math.max(500, Math.min(5000, messages.length || 0));
     diagnostics.hydrateLimit = hydrateLimit;
     let t0 = Date.now();
+    let ingestFailed = false;
+    let searchFailed = false;
+    let ingestErr = null;
+    let searchErr = null;
     try {
         await executeInternalTool('memory', {
             action: 'ingest_session',
@@ -112,6 +130,8 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
             limit: hydrateLimit,
         }, callerCtx);
     } catch (err) {
+        ingestFailed = true;
+        ingestErr = err;
         diagnostics.ingestSkipped = true;
         diagnostics.ingestError = compactDiagnosticError(err);
         try { process.stderr.write(`[loop] recall-fasttrack ingest skipped (sess=${sessionId || 'unknown'}): ${err?.message || err}\n`); } catch {}
@@ -138,6 +158,8 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
         }, callerCtx);
         digestBody = typeof browsed === 'string' ? browsed : String(browsed?.text ?? browsed ?? '');
     } catch (err) {
+        searchFailed = true;
+        searchErr = err;
         diagnostics.cycle1Error = compactDiagnosticError(err);
         try { process.stderr.write(`[loop] recall-digest browse failed (sess=${sessionId || 'unknown'}): ${err?.message || err}\n`); } catch {}
     }
@@ -145,6 +167,30 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
     diagnostics.cycle1Skipped = true;
     diagnostics.cycle1SkipReason = 'digest mode';
     diagnostics.cycle1Passes = 0;
+    // Fail-safe: memory ingest or search failed, so the digest cannot honestly
+    // represent "full history is in memory". Do NOT drop head messages behind a
+    // false recall notice — abort the fast-track so no context is silently lost
+    // for this cycle. The failure is already on stderr above; surface it here
+    // too and record it in the diagnostics before throwing.
+    if (ingestFailed || searchFailed) {
+        diagnostics.totalMs = Date.now() - startedAt;
+        diagnostics.failSafeAbort = true;
+        compactDebugLog('recall-digest pipeline', diagnostics);
+        // Cancellation is not a memory failure: rethrow the original abort error
+        // unchanged so the session is marked cancelled, not context-overflow.
+        const abortErr = isAbortLikeError(ingestErr, signal) ? ingestErr
+            : isAbortLikeError(searchErr, signal) ? searchErr
+            : (signal?.aborted ? (ingestErr || searchErr) : null);
+        if (abortErr) {
+            try { process.stderr.write(`[loop] recall-fasttrack cancelled (sess=${sessionId || 'unknown'}): ${abortErr?.message || abortErr}\n`); } catch {}
+            throw abortErr;
+        }
+        const reason = ingestFailed
+            ? (searchFailed ? 'ingest+search failed' : 'ingest failed')
+            : 'search failed';
+        try { process.stderr.write(`[loop] recall-fasttrack fail-safe abort (sess=${sessionId || 'unknown'}): ${reason} — keeping full history, no recall notice injected\n`); } catch {}
+        throw new Error(`recall-fasttrack aborted: memory ${reason}; head preserved`);
+    }
     const digestText = buildRecallDigestText(sessionId, digestBody, digestMaxKb);
     diagnostics.finalRecallChars = digestText.length;
     diagnostics.finalRecallBytes = compactByteLength(digestText);
@@ -161,6 +207,9 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
         recallText: digestText,
         query,
         querySha,
+        // Ingest + search both succeeded above, so the memory DB genuinely holds
+        // this transcript and the recall notice is truthful even when the digest
+        // body is small. A failure would have aborted before reaching here.
         allowEmptyRecall: true,
         tailTurns: compactPolicy.tailTurns,
         keepTokens: compactPolicy.keepTokens,

package/src/runtime/agent/orchestrator/session/loop/stored-tool-args.mjs

@@ -18,9 +18,17 @@ function compactStoredToolArgString(value, key = '') {
     const limit = isBody ? STORED_TOOL_ARG_BODY_LIMIT : (isLong ? STORED_TOOL_ARG_LONG_LIMIT : Infinity);
     if (value.length <= limit) return value;
     const hash = createHash('sha256').update(value).digest('hex').slice(0, 16);
+    const marker = `[mixdog compacted ${key || 'string'}: ${value.length} chars, sha256:${hash}]`;
+    // Body args (patch / old_string / new_string / content / rewrite) are
+    // apply_patch / edit inputs. Keeping a head/tail preview leaves real patch
+    // fragments (a "*** Begin Patch" opening, diff lines) inside a SUCCESSFUL
+    // history entry that the model can copy back verbatim as new tool input.
+    // Emit the marker ALONE for these keys so nothing copyable survives; a
+    // FAILED call still restores the full original via restoreToolCallBodyForId.
+    if (isBody) return marker;
     const head = value.slice(0, STORED_TOOL_ARG_PREVIEW_HEAD).replace(/\r\n/g, '\n');
     const tail = value.slice(-STORED_TOOL_ARG_PREVIEW_TAIL).replace(/\r\n/g, '\n');
-    return `[mixdog compacted ${key || 'string'}: ${value.length} chars, sha256:${hash}]\n${head}\n... [middle omitted from stored tool-call args] ...\n${tail}`;
+    return `${marker}\n${head}\n... [middle omitted from stored tool-call args] ...\n${tail}`;
 }
 
 function compactStoredToolArgValue(value, key = '', depth = 0) {