mixdog 0.9.87 → 0.9.89

package/src/runtime/agent/orchestrator/session/loop/stop-hooks.mjs

@@ -0,0 +1,88 @@
+// Codex-style turn stop hook (refs/codex core/src/session/turn.rs:372-404).
+//
+// Codex semantics: a sampling request that needs no follow-up ends the turn.
+// Before breaking, the turn runs its stop hooks; a hook may block ONCE by
+// returning continuation fragments, which are recorded as a prompt message
+// before sampling resumes (`stop_hook_active = true`, never cleared inside the
+// turn). Nothing else can force another turn: no mandatory terminal tool, no
+// completion strikes, no lexical inspection of the assistant text.
+//
+// The single hook implemented here preserves the original failed-apply_patch
+// protection: while a real tool failure is unresolved, the first terminal
+// assistant message is blocked once with a structural continuation prompt.
+// Afterwards ordinary final text (or further tool calls) is accepted.
+
+export const STOP_HOOK_SOURCE = 'tool-failure-stop-hook';
+
+// Only a genuinely EXECUTED result resolves a failure, i.e. kind 'normal'.
+// Cache hits ('cache-hit' / 'scoped-cache-hit') replay an earlier result
+// without running anything, and dedup/guard skips ('skipped') execute nothing
+// either, so both are neutral: they neither arm nor clear the hook.
+const EXECUTED_SUCCESS_TOOL_KINDS = new Set(['normal']);
+
+function bareToolName(name) {
+    const raw = String(name || '');
+    return raw.startsWith('mcp__') ? raw.split('__').pop() : raw;
+}
+
+export function toolFailureContinuationPrompt(failedTool) {
+    const which = failedTool ? `\`${failedTool}\`` : 'a tool call';
+    return `[mixdog-runtime] Stop hook: ${which} failed and no tool call has succeeded since.`
+        + ' Re-run the fixed action (or a verifying tool) if it is recoverable; otherwise say in your'
+        + ' final message that it stays unresolved and why. This hook fires once — your next message ends the turn.';
+}
+
+/**
+ * Structural unresolved-tool-failure stop hook.
+ *  - observeToolResult(message) / endBatch(calls): a batch containing any
+ *    failed tool result arms it; a later batch with a genuinely executed
+ *    success clears it.
+ *  - takeContinuationPrompt(): returns the continuation prompt the FIRST time
+ *    a terminal assistant message arrives while a failure is unresolved, then
+ *    stays silent for the rest of the turn (Codex `stop_hook_active`).
+ */
+export function createToolFailureStopHook() {
+    let unresolvedFailure = false;
+    let lastFailedTool = null;
+    let batchFailure = false;
+    let batchSuccess = false;
+    let failedCallIds = new Set();
+    let active = false;
+    return {
+        get unresolvedFailure() { return unresolvedFailure; },
+        get lastFailedTool() { return lastFailedTool; },
+        get active() { return active; },
+        observeToolResult(message) {
+            if (!message || message.role !== 'tool') return;
+            // Guard skips (repeat-failure guard) are tagged as errors so every
+            // downstream consumer keeps treating the call as unresolved, but
+            // nothing was dispatched — they must not arm the hook.
+            if (message.guardSkip === true) return;
+            if (message.toolKind === 'error') {
+                batchFailure = true;
+                if (message.toolCallId) failedCallIds.add(message.toolCallId);
+            } else if (EXECUTED_SUCCESS_TOOL_KINDS.has(message.toolKind)) {
+                batchSuccess = true;
+            }
+        },
+        endBatch(calls) {
+            if (batchFailure) {
+                unresolvedFailure = true;
+                const failed = (Array.isArray(calls) ? calls : [])
+                    .find((call) => call?.id && failedCallIds.has(call.id));
+                if (failed) lastFailedTool = bareToolName(failed.name);
+            } else if (batchSuccess) {
+                unresolvedFailure = false;
+                lastFailedTool = null;
+            }
+            batchFailure = false;
+            batchSuccess = false;
+            failedCallIds = new Set();
+        },
+        takeContinuationPrompt() {
+            if (active || !unresolvedFailure) return null;
+            active = true;
+            return toolFailureContinuationPrompt(lastFailedTool);
+        },
+    };
+}

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

@@ -5,6 +5,14 @@
 // patch text is the model's own draft, and leaving only the marker made models
 // copy `[mixdog compacted …]` back as literal patch input. Bodies of calls that
 // did NOT fail stay compacted so an already-applied patch cannot be replayed.
+//
+// Mutation bodies additionally get ONE turn of grace: the push that commits a
+// tool-call turn defers body compaction (deferBodies), so the send that
+// immediately follows a successful patch still shows the model its own patch
+// verbatim. compactSettledToolCallBodies then collapses settled successful
+// bodies to markers on the next push / loop entry. This closes the observed
+// failure where a model writing a follow-up patch right after a success copies
+// the marker it was just shown as literal patch input.
 import { createHash } from 'crypto';
 
 const STORED_TOOL_ARG_BODY_KEY_RE = /^(?:content|old_string|new_string|patch|rewrite)$/i;
@@ -20,14 +28,20 @@ const STORED_TOOL_ARG_LIMIT = 10_000;
 const STORED_TOOL_ARG_PREVIEW_HEAD = 360;
 const STORED_TOOL_ARG_PREVIEW_TAIL = 160;
 
-function compactStoredToolArgString(value, key = '') {
+function compactStoredToolArgString(value, key = '', opts = {}) {
     if (typeof value !== 'string') return value;
     const isBody = STORED_TOOL_ARG_BODY_KEY_RE.test(key);
+    if (isBody && opts.deferBodies === true) return value;
     const isLong = isBody || STORED_TOOL_ARG_LONG_KEY_RE.test(key);
     const limit = isLong ? STORED_TOOL_ARG_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}; do not copy]`;
+    // Body markers carry the recovery instruction inline: the compaction
+    // detectors only require the `[mixdog compacted ...]` shape (no ']' or
+    // newline inside), so the longer text stays fully compatible.
+    const marker = isBody
+        ? `[mixdog compacted ${key}: ${value.length} chars, sha256:${hash}; already applied - do not copy; re-read the file and write a fresh patch]`
+        : `[mixdog compacted ${key || 'string'}: ${value.length} chars, sha256:${hash}; do not copy]`;
     // 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
@@ -40,32 +54,60 @@ function compactStoredToolArgString(value, key = '') {
     return `${marker}\n${head}\n... [middle omitted from stored tool-call args] ...\n${tail}`;
 }
 
-function compactStoredToolArgValue(value, key = '', depth = 0) {
+function compactStoredToolArgValue(value, key = '', depth = 0, opts = {}) {
     if (value === null || value === undefined) return value;
-    if (typeof value === 'string') return compactStoredToolArgString(value, key);
+    if (typeof value === 'string') return compactStoredToolArgString(value, key, opts);
     if (typeof value !== 'object') return value;
     if (depth >= 6) return Array.isArray(value) ? `[${value.length} items]` : '{...}';
     if (Array.isArray(value)) {
-        return value.map((item) => compactStoredToolArgValue(item, key, depth + 1));
+        return value.map((item) => compactStoredToolArgValue(item, key, depth + 1, opts));
     }
     const out = {};
     for (const [k, v] of Object.entries(value)) {
-        out[k] = compactStoredToolArgValue(v, k, depth + 1);
+        out[k] = compactStoredToolArgValue(v, k, depth + 1, opts);
     }
     return out;
 }
 
-export function compactToolCallsForHistory(calls) {
+export function compactToolCallsForHistory(calls, opts = {}) {
     if (!Array.isArray(calls)) return calls;
     return calls.map((call) => {
         if (!call || typeof call !== 'object') return call;
         return {
             ...call,
-            arguments: compactStoredToolArgValue(call.arguments),
+            arguments: compactStoredToolArgValue(call.arguments, '', 0, opts),
         };
     });
 }
 
+// Collapse the body args of every SETTLED, non-failed tool call in history to
+// their compacted markers. Runs at loop entry and before each new assistant
+// push, so a deferred verbatim body survives exactly the send(s) that follow
+// its own turn and no longer. Contract guards:
+//   - a call whose result is an error keeps its full body (retry-safe, same
+//     contract as restoreToolCallBodyForId);
+//   - a call with no result row yet (current batch / interrupted turn) is
+//     left untouched.
+export function compactSettledToolCallBodies(messages) {
+    if (!Array.isArray(messages)) return;
+    const resultKinds = new Map();
+    for (const message of messages) {
+        if (message?.role === 'tool' && message.toolCallId) {
+            resultKinds.set(message.toolCallId, message.toolKind || 'normal');
+        }
+    }
+    for (const message of messages) {
+        if (message?.role !== 'assistant' || !Array.isArray(message.toolCalls)) continue;
+        for (const call of message.toolCalls) {
+            if (!call || typeof call !== 'object') continue;
+            if (!call.arguments || typeof call.arguments !== 'object') continue;
+            const kind = call.id ? resultKinds.get(call.id) : undefined;
+            if (kind === undefined || kind === 'error') continue;
+            call.arguments = compactStoredToolArgValue(call.arguments);
+        }
+    }
+}
+
 // Restore retry-safe long command/script text for ONE failed tool call inside a
 // history assistant message whose toolCalls were compacted at push time.
 // Mutation bodies (patch, old_string, new_string, content, rewrite) are restored

package/src/runtime/agent/orchestrator/session/loop/termination.mjs

@@ -24,6 +24,31 @@ export function isOutputLimitStopReason(reason) {
         && OUTPUT_LIMIT_STOP_REASONS.has(reason.trim().toLowerCase());
 }
 
+// Provider-declared continuation signals. A response carrying one of these is
+// NOT a completed assistant turn even when it holds final-looking text: the
+// provider explicitly stated it intends to keep sampling inside the SAME user
+// turn. Two structured shapes are honored:
+//   - `endTurn === false` (Codex/Responses `end_turn=false`; see
+//     codex-rs/core/src/session/turn.rs Completed{ end_turn } → needs_follow_up)
+//   - Anthropic `stop_reason: 'pause_turn'` (server-side pause; the turn is
+//     resumed by replaying the transcript unchanged)
+// Structural only — no lexical/progress-text heuristic is consulted, and a
+// provider that omits both fields is unaffected (returns null → terminal).
+const CONTINUATION_STOP_REASONS = new Set(['pause_turn']);
+
+export function providerContinuationSignal(response) {
+    if (!response || typeof response !== 'object') return null;
+    // Only an explicit boolean false continues; undefined/null/absent means
+    // "provider did not signal" and keeps legacy terminal semantics.
+    if (response.endTurn === false || response.end_turn === false) return 'end_turn_false';
+    const stopReason = response.stopReason ?? response.stop_reason ?? null;
+    if (typeof stopReason === 'string'
+        && CONTINUATION_STOP_REASONS.has(stopReason.trim().toLowerCase())) {
+        return 'pause_turn';
+    }
+    return null;
+}
+
 // Classify WHY the loop ended so agent-tool can promote an empty/abnormal
 // finish to an explicit Lead-facing error instead of a silent empty
 // "completed". Determine "has content" exactly the way the no-tool-call

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

@@ -179,7 +179,7 @@ export async function executeTool(name, args, cwd, callerSessionId, sessionRef,
     if (name === 'code_graph') {
         // cwd chain: args.cwd (caller-explicit) → session cwd → undefined (handler throws)
         const graphCwd = (typeof args?.cwd === 'string' && args.cwd.trim()) ? args.cwd.trim() : cwd;
-        return executeCodeGraphToolLazy(name, args, graphCwd, null, toolOpts);
+        return executeCodeGraphToolLazy(name, args, graphCwd, executeOpts.signal || null, toolOpts);
     }
     if (isInternalTool(name)) {
         // callerSessionId propagates into server.mjs dispatchTool so that

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

@@ -5,6 +5,7 @@
 // helper it used in manager.mjs is now imported from its split module.
 import { createHash, randomUUID } from 'crypto';
 import { getProvider } from '../../providers/registry.mjs';
+import { readStreamOutcome } from '../../providers/lib/stream-outcome.mjs';
 import { normalizeCompactType, DEFAULT_COMPACT_TYPE } from '../compact.mjs';
 import { loadSession, saveSession, saveSessionAsync, saveSessionAsyncDeferred, readSessionLifecycleFromDisk } from '../store.mjs';
 import { createAbortController } from '../../../../shared/abort-controller.mjs';
@@ -57,6 +58,7 @@ import {
 } from './message-sanitize.mjs';
 import { createTurnInterruptionTracker } from './turn-interruption.mjs';
 import {
+    cancelPendingTurnCheckpoint,
     clearTurnCheckpoint,
     recoverTurnCheckpoint,
     turnMessagesForCheckpoint,
@@ -342,6 +344,13 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     currentUserContent: cancelledUserTurnContent,
                     turnMessages: turnMessagesForCheckpoint(_turnOutgoing, cancelledUserTurnContent),
                     interruption: _turnInterruption.snapshot(),
+                }, {
+                    // The turn's first checkpoint is the crash-durability
+                    // anchor for the prompt and must land before the provider
+                    // runs; every later streaming/tool-boundary flush moves to
+                    // the async latest-wins lane so serialization+disk never
+                    // stall the engine thread mid-stream.
+                    sync: _turnCheckpointLastAt === 0,
                 });
                 if (written) _turnCheckpointLastAt = Date.now();
                 return written;
@@ -373,6 +382,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             _turnCheckpointStopped = true;
             if (_turnCheckpointTimer) clearTimeout(_turnCheckpointTimer);
             _turnCheckpointTimer = null;
+            cancelPendingTurnCheckpoint(sessionId);
         };
         const _sessionStartMetaInjectedBeforeTurn = preSession.sessionStartMetaInjected === true;
         let _interruptionSnapshot = null;
@@ -679,11 +689,31 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                                 if (Array.isArray(drained)) out.push(...drained);
                             } catch { /* best-effort steering drain */ }
                         }
-                        // Do NOT drain manager/pending-messages here: those
-                        // entries have no mode/priority/slash metadata, so
-                        // draining them mid-chain would bypass Claude Code's
-                        // queued_command filters. They are consumed by the
-                        // post-loop _pendingTail drain below.
+                        // Manager/pending-messages entries carry no
+                        // mode/priority/slash metadata, so they stay OUT of the
+                        // mid-chain (post-tool-batch) drain — that would bypass
+                        // Claude Code's queued_command filters. At the TERMINAL
+                        // boundary they are exactly Codex `has_pending_input`
+                        // (turn.rs:304-318): an `agent type=send` queued while
+                        // the terminal sample was in flight must be folded into
+                        // THIS turn before any stop hook runs, instead of losing
+                        // its slot to a synthetic continuation prompt. The mutex
+                        // is held for the whole ask, so this drain races nothing.
+                        // Entries consumed here join _turnPendingEntries: their
+                        // delivery/ack (and release on failure) rides this turn,
+                        // and the post-loop drain can no longer see them.
+                        if (drainOptions?.stage === 'terminal') {
+                            const _pendingNow = drainPendingMessages(sessionId);
+                            if (_pendingNow.length > 0) {
+                                const _mergedNow = _mergePendingMessageEntries(_pendingNow);
+                                if (_mergedNow?.content) {
+                                    _turnPendingEntries.push(..._pendingNow);
+                                    out.push(_mergedNow);
+                                } else {
+                                    releasePendingMessages(sessionId, _pendingNow);
+                                }
+                            }
+                        }
                         return out;
                     },
                     onSteerMessage: (text, detail) => {
@@ -1029,8 +1059,19 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // non-streaming request starts. If that restart fails, restore the
             // tombstone and persist the one exposed partial as interruption
             // history. Failed/absent acknowledgements never tombstoned it.
+            // Provider-specific legacy flags are NOT consulted here: the
+            // canonical stream-outcome contract answers "did the provider
+            // produce output we must commit?" for every transport. Anthropic's
+            // stall/truncation errors carry neither liveTextEmitted nor
+            // unsafeToRetry — only partialContent/partialToolCalls — and used
+            // to drop the streamed summary from history on that provider.
+            const _providerOutcome = readStreamOutcome(err);
             const preserveProviderPartial = restoredResetText
-                || err?.liveTextEmitted === true
+                || _providerOutcome.observedOutput === true
+                // Positive exposure evidence only: an error with no observed
+                // output must not be mistaken for a turn that produced
+                // provider output.
+                || _providerOutcome.replayUnsafe === true
                 || err?.unsafeToRetry === true;
             let _errorStateDurable = false;
             if (preserveProviderPartial && activeSession && _turnInterruption.hasResponseStarted()) {