mixdog 0.9.170 → 0.9.172

package/src/runtime/agent/orchestrator/session/manager/delivered-completions.mjs

@@ -24,6 +24,7 @@
 // time. This requires >512 live completions between a delivery and its drain,
 // which is far outside normal single-process interactive use.
 import { createHash } from 'node:crypto';
+import { taskNotificationId } from '../../../../shared/task-notification-envelope.mjs';
 
 const DELIVERED_TTL_MS = 6 * 60 * 60 * 1000; // 6h, sliding (refreshed on record + hit)
 const DELIVERED_MAX_ENTRIES = 512;
@@ -70,7 +71,7 @@ export function recordDeliveredCompletion({ executionId, text } = {}) {
   pruneExpired(now);
   const expiresAt = now + DELIVERED_TTL_MS;
   let recorded = false;
-  for (const key of [execKey(executionId), textKey(text)]) {
+  for (const key of [execKey(executionId || taskNotificationId(text)), textKey(text)]) {
     if (!key) continue;
     _delivered.delete(key); // re-insert to refresh age order
     _delivered.set(key, expiresAt);
@@ -82,7 +83,7 @@ export function recordDeliveredCompletion({ executionId, text } = {}) {
 
 export function isDeliveredCompletion({ executionId, text } = {}) {
   const now = Date.now();
-  const keys = [execKey(executionId), textKey(text)].filter(Boolean);
+  const keys = [execKey(executionId || taskNotificationId(text)), textKey(text)].filter(Boolean);
   let hit = false;
   for (const key of keys) {
     const expiresAt = _delivered.get(key);

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

@@ -0,0 +1,47 @@
+// manager/failed-turn-rewind.mjs
+// A failed turn's retry resubmits the user's prompt. When the failed turn
+// sampled nothing — the trailing model-visible message is still that prompt —
+// the stale copy is rewound first so the resubmission reaches the model
+// exactly once. A turn that already produced assistant/tool output is left
+// intact: the retry then continues from it. The rewind is gated on the
+// resubmitted text matching the trailing prompt, so a continuation prompt or a
+// merged queue batch can never remove a prompt it did not repeat.
+import { stripRuntimeUserContext } from '../runtime-user-context.mjs';
+import { promptContentText } from './prompt-utils.mjs';
+
+function isTextOnlyContent(content) {
+  if (typeof content === 'string') return true;
+  return Array.isArray(content) && content.every((part) => typeof part === 'string' || part?.type === 'text');
+}
+
+/** Index of the trailing user prompt that `prompt` repeats verbatim, or -1
+ *  when the history tail was answered (assistant/tool output followed it),
+ *  the texts differ, or the stored prompt carries media a text resubmission
+ *  would lose. */
+export function trailingUnansweredPromptIndex(messages, prompt) {
+  const list = Array.isArray(messages) ? messages : [];
+  const resubmitted = promptContentText(prompt).trim();
+  if (!resubmitted) return -1;
+  for (let index = list.length - 1; index >= 0; index -= 1) {
+    const message = list[index];
+    if (message?.role === 'system') continue;
+    if (message?.role !== 'user') return -1;
+    const { content } = stripRuntimeUserContext(message);
+    if (!isTextOnlyContent(content)) return -1;
+    return promptContentText(content).trim() === resubmitted ? index : -1;
+  }
+  return -1;
+}
+
+/** Drops the trailing unanswered copy of `prompt` from the live session.
+ *  Returns whether the history shrank. */
+export function rewindUnansweredPrompt(session, prompt) {
+  const index = trailingUnansweredPromptIndex(session?.messages, prompt);
+  if (index < 0) return false;
+  session.messages = session.messages.slice(0, index);
+  // The transcript shrank: the provider prefix snapshot and any chained
+  // provider state re-baseline with it (same reset as the failure persist).
+  session.providerState = undefined;
+  delete session._providerPrefixGuardState;
+  return true;
+}

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

@@ -1,4 +1,4 @@
-import { stat } from 'fs/promises';
+import { stat } from 'node:fs/promises';
 import {
   isCompletionNotificationEntry,
   isStaleUserInjection,

package/src/runtime/agent/orchestrator/session/manager/idle-cleanup.mjs

@@ -97,7 +97,7 @@ async function sweepIdleSessions({ includeTombstones = true, sweepIdle = true }
       );
     }
   } catch (e) {
-    process.stderr.write(`[agent-session] idle sweep error: ${(e && e.message) || e}\n`);
+    process.stderr.write(`[agent-session] idle sweep error: ${e?.message || e}\n`);
   }
 }
 
@@ -138,7 +138,7 @@ export function sweepTombstones() {
     }
     return tombstonesCleaned;
   } catch (e) {
-    process.stderr.write(`[session-sweep] tombstone sweep error: ${(e && e.message) || e}\n`);
+    process.stderr.write(`[session-sweep] tombstone sweep error: ${e?.message || e}\n`);
     return 0;
   }
 }

package/src/runtime/agent/orchestrator/session/manager/message-sanitize.mjs

@@ -1,30 +1,11 @@
-// Model-visible session filtering and compaction-failure persistence.
-import { isInternalRuntimeNotificationText } from './prompt-utils.mjs';
+// Model-visible session snapshots and compaction-failure persistence.
 import { saveSessionAsync } from '../store.mjs';
 import { _getRuntimeEntry } from './runtime-liveness.mjs';
 
 export function filterModelVisibleSessionMessages(messages) {
-  // Internal runtime notifications and their synthetic responses never enter
-  // model history. Image content remains intact; the store replaces image
-  // bytes only in its disk serialization snapshot.
-  if (!Array.isArray(messages) || messages.length === 0) return [];
-  const out = [];
-  let droppingInternalTurn = false;
-  for (const message of messages) {
-    if (message?.role === 'user' && isInternalRuntimeNotificationText(message.content)) {
-      droppingInternalTurn = true;
-      continue;
-    }
-    if (droppingInternalTurn) {
-      if (message?.role === 'user') {
-        droppingInternalTurn = false;
-      } else {
-        continue;
-      }
-    }
-    out.push(message);
-  }
-  return out;
+  // Runtime notifications already sent to the model are part of its history.
+  // Snapshot the array without dropping them or the work that followed them.
+  return Array.isArray(messages) ? messages.slice() : [];
 }
 
 function sessionMessagesSnapshotChanged(before, after) {
@@ -42,7 +23,7 @@ function sessionMessagesSnapshotChanged(before, after) {
 }
 
 function isCompactedOutgoingFinalAssistantMessage(message) {
-  if (!message || message.role !== 'assistant') return false;
+  if (message?.role !== 'assistant') return false;
   if (message.emptyFinal === true) return true;
   return true;
 }
@@ -101,7 +82,7 @@ function applyCompactFailurePersistToSession(
     const overflow = error?.code === 'AGENT_CONTEXT_OVERFLOW';
     activeSession.compaction = {
       ...prev,
-      lastStage: prev.lastStage === 'overflow_failed' ? 'overflow_failed' : overflow ? 'overflow_failed' : 'failed',
+      lastStage: prev.lastStage === 'overflow_failed' || overflow ? 'overflow_failed' : 'failed',
       lastCheckedAt: Date.now(),
       lastError: prev.lastError || cause?.message || error?.message || null,
       lastFreshContextError: prev.lastFreshContextError || cause?.message || error?.message || null,

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

@@ -1,7 +1,8 @@
-import { createHash, randomBytes } from 'crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import { mergeNormalizedContentEntries } from '../loop/steering.mjs';
 import { isDeliveredCompletion, logDuplicateSkip } from './delivered-completions.mjs';
 import { isInternalRuntimeNotificationText, promptContentText } from './prompt-utils.mjs';
+import { parseTaskNotification, taskNotificationId } from '../../../../shared/task-notification-envelope.mjs';
 
 const STALE_USER_INJECTION_TTL_MS = 30 * 60 * 1000;
 const PENDING_PROCESS_START_MS = Date.now();
@@ -59,7 +60,7 @@ export function pendingEntryMode(entry) {
 
 export function completionExecutionId(entry) {
   const value = typeof entry?.executionId === 'string' ? entry.executionId.trim() : '';
-  return value || null;
+  return value || entry?.execution?.id || taskNotificationId(pendingMessageText(entry)) || null;
 }
 
 function normalizeExecution(value, executionId = null) {
@@ -113,14 +114,17 @@ export function completionWasDelivered(entry, site) {
 
 /** Canonical tagger for deferred tool and agent completion notifications. */
 export function markCompletionEntry(text, options = {}) {
-  const value =
-    typeof text === 'string' ? text : text && typeof text === 'object' ? text.text || text.content || '' : '';
+  let value = '';
+  if (typeof text === 'string') value = text;
+  else if (text && typeof text === 'object') value = text.text || text.content || '';
   const content = String(value ?? '');
-  const executionId = String(options?.executionId || options?.meta?.execution_id || '').trim();
+  const notification = parseTaskNotification(content);
+  const executionId = String(options?.executionId || options?.meta?.execution_id || taskNotificationId(content)).trim();
   const identity = executionId ? `execution:${executionId}` : `content:${content}`;
   const id = `completion_${createHash('sha256').update(identity).digest('hex').slice(0, 24)}`;
   const execution = normalizeExecution(
     {
+      ...(notification ? { surface: notification.surface, status: notification.status } : {}),
       ...(executionFromCompletionMeta(options?.meta) || {}),
       ...(options?.execution && typeof options.execution === 'object' ? options.execution : {}),
     },
@@ -177,13 +181,10 @@ export function normalizePendingMessageEntry(entry) {
           enqueuedAt: Number(entry.enqueuedAt) || Date.now(),
         }
       : null;
-  const content = Object.hasOwn(entry, 'content')
-    ? entry.content
-    : typeof entry.message === 'string'
-      ? entry.message
-      : typeof entry.text === 'string'
-        ? entry.text
-        : null;
+  let content = null;
+  if (Object.hasOwn(entry, 'content')) content = entry.content;
+  else if (typeof entry.message === 'string') content = entry.message;
+  else if (typeof entry.text === 'string') content = entry.text;
   if (content == null) return null;
   const text = typeof entry.text === 'string' ? entry.text.trim() : promptContentText(content).trim();
   let out = null;

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

@@ -1,6 +1,6 @@
 // Steering / pending-message queue with sync buffering and atomic persistence.
-import { join } from 'path';
-import { readFileSync } from 'fs';
+import { join } from 'node:path';
+import { readFileSync } from 'node:fs';
 import { resolvePluginData } from '../../../../shared/plugin-paths.mjs';
 import { updateJsonAtomic } from '../../../../shared/atomic-file.mjs';
 import { loadSession, readSessionLifecycleStateFromDisk, saveSessionAsync } from '../store.mjs';
@@ -225,14 +225,7 @@ function normalizeTuiSteeringQueueEntry(entry) {
     return text || null;
   }
   if (!entry || typeof entry !== 'object') return null;
-  const rawText =
-    typeof entry.text === 'string'
-      ? entry.text
-      : typeof entry.message === 'string'
-        ? entry.message
-        : typeof entry.content === 'string'
-          ? entry.content
-          : '';
+  const rawText = [entry.text, entry.message, entry.content].find((value) => typeof value === 'string') ?? '';
   if (rawText.trim()) {
     const text = rawText.trim();
     const id = typeof entry.id === 'string' && entry.id.trim() ? entry.id.trim() : null;
@@ -243,13 +236,9 @@ function normalizeTuiSteeringQueueEntry(entry) {
       message: text,
       enqueuedAt: Number(entry.enqueuedAt) || Date.now(),
     };
-    return entry.notificationKind === COMPLETION_NOTIFICATION_KIND
-      ? {
-          ...normalized,
-          notificationKind: COMPLETION_NOTIFICATION_KIND,
-          ...(completionExecutionId(entry) ? { executionId: completionExecutionId(entry) } : {}),
-        }
-      : normalized;
+    if (entry.notificationKind !== COMPLETION_NOTIFICATION_KIND) return normalized;
+    const executionId = completionExecutionId(entry);
+    return { ...normalized, notificationKind: COMPLETION_NOTIFICATION_KIND, ...(executionId ? { executionId } : {}) };
   }
   return null;
 }
@@ -748,7 +737,7 @@ export function releasePendingMessages(sessionId, deliveredEntries) {
   // falls back to the map when the two agree — a newer claim/ack that
   // replaced or removed the map state can never re-open an old release.
   const claimToken = (entry) =>
-    entryLifecycleToken(entry) || (claim && claim.entries.has(pendingMessageId(entry)) ? claim.token : null);
+    entryLifecycleToken(entry) || (claim?.entries.has(pendingMessageId(entry)) ? claim.token : null);
   const releasedIds = [];
   const restored = [];
   for (const entry of Array.isArray(deliveredEntries) ? deliveredEntries : []) {
@@ -985,12 +974,11 @@ export function enqueuePendingMessage(sessionId, message) {
   // Completion ids are content/execution-addressed by markCompletionEntry:
   // preserving them makes fallback retries idempotent, while genuine
   // user/steering ids remain freshly generated and session-local.
-  const entry = normalized
-    ? {
-        ...normalized,
-        id: isCompletionNotificationEntry(normalized) && normalized.id ? normalized.id : newPendingMessageId(),
-      }
-    : null;
+  let entry = null;
+  if (normalized) {
+    const keepId = isCompletionNotificationEntry(normalized) && normalized.id;
+    entry = { ...normalized, id: keepId ? normalized.id : newPendingMessageId() };
+  }
   if (!sessionId || !entry) return 0;
   // A terminal task read may ACK before an async fallback enqueue settles.
   // Treat that completion as already delivered and never publish it.

package/src/runtime/agent/orchestrator/session/manager/prefetch-bridge/file-entries.mjs

@@ -0,0 +1,36 @@
+// files[] normalisation. String entries use the default head excerpt; object
+// entries {path, n?, full?} let the caller widen the window or pull the full
+// file so a worker does not re-read deep ranges of an already-prefetched file
+// (a recurring iteration burner observed in baseline session telemetry).
+export function collectPrefetchFiles(rawFiles) {
+  const files = [];
+  const readOpts = new Map();
+  const seen = new Set();
+  const add = (file, opts = null) => {
+    if (typeof file !== 'string' || !file) return;
+    if (!seen.has(file)) {
+      seen.add(file);
+      files.push(file);
+    }
+    if (!opts || Object.keys(opts).length === 0) return;
+    const merged = { ...(readOpts.get(file) || {}) };
+    if (opts.mode === 'full') {
+      merged.mode = 'full';
+      delete merged.n;
+    } else if (merged.mode !== 'full' && Number.isFinite(opts.n) && opts.n > 0) {
+      merged.n = Math.max(Number(merged.n) || 0, opts.n);
+    }
+    if (Object.keys(merged).length > 0) readOpts.set(file, merged);
+  };
+  for (const entry of Array.isArray(rawFiles) ? rawFiles : []) {
+    if (typeof entry === 'string' && entry) {
+      add(entry);
+    } else if (entry && typeof entry === 'object' && typeof entry.path === 'string' && entry.path) {
+      const opts = {};
+      if (entry.full === true) opts.mode = 'full';
+      else if (Number.isFinite(entry.n) && entry.n > 0) opts.n = entry.n;
+      add(entry.path, opts);
+    }
+  }
+  return { files, readOpts };
+}

package/src/runtime/agent/orchestrator/session/manager/prefetch-bridge/file-prefetch.mjs

@@ -0,0 +1,85 @@
+// files[] prefetch through the per-file cross-dispatch cache (process-local):
+// cached files are served from memory, misses are read once and — default
+// window only — cached for the next dispatch.
+import { isAbsolute, normalize, resolve } from 'node:path';
+import { executeInternalTool } from '../../../internal-tools.mjs';
+import { classifyResultKind } from '../../result-classification.mjs';
+import { tryPrefetchCached, setPrefetchCached, capturePrefetchCacheState } from '../../read-dedup.mjs';
+import { runAbortable, throwIfAborted } from '../../../../../shared/abort-race.mjs';
+
+const DEFAULT_HEAD_LINES = 120;
+
+export async function prefetchFiles(session, { files, readOpts }, signal) {
+  throwIfAborted(signal);
+  const cwd = session.cwd || null;
+  const absPath = (file) => normalize(isAbsolute(file) ? file : resolve(cwd || process.cwd(), file));
+  const hits = new Map(); // file → cached content
+  const misses = []; // { file, abs } — need a disk read
+  for (const file of files) {
+    const abs = absPath(file);
+    // Skip the cross-dispatch cache when the caller asked for a non-default
+    // window (custom n or full-file). The cache key is the path alone, so a
+    // default-window cache hit would silently feed the wrong slice back to
+    // the next caller.
+    const hit = readOpts.has(file) ? null : tryPrefetchCached(abs);
+    if (hit) hits.set(file, hit.content);
+    else misses.push({ file, abs });
+  }
+
+  const failed = [];
+  const missResults = {}; // file → content string
+  if (misses.length > 0) {
+    // Read misses concurrently while retaining per-file cache provenance.
+    const readStates = new Map();
+    await runAbortable(signal, () =>
+      Promise.all(
+        misses.map(async ({ file, abs }) => {
+          const opts = readOpts.get(file) || {};
+          let readArgs;
+          if (opts.mode === 'full') {
+            readArgs = { path: file, mode: 'full' };
+          } else {
+            readArgs = { path: file, mode: 'head', n: Number.isFinite(opts.n) ? opts.n : DEFAULT_HEAD_LINES };
+          }
+          readStates.set(file, capturePrefetchCacheState(abs));
+          const out = await executeInternalTool('read', readArgs, {
+            scopeId: session.mcpScopeId || null,
+            callerSessionId: session.id,
+            callerCwd: session.cwd,
+            signal,
+          }).catch((e) => {
+            process.stderr.write(`[agent-prefetch] file read failed (${file}): ${e?.message || e}\n`);
+            return null;
+          });
+          if (out !== null) missResults[file] = String(out);
+        })
+      )
+    );
+    for (const { file, abs } of misses) {
+      const content = missResults[file];
+      if (content && classifyResultKind(content) !== 'error') {
+        // Only cache default-window reads; custom-window results would poison
+        // the shared cross-dispatch cache.
+        if (!readOpts.has(file)) setPrefetchCached(abs, content, readStates.get(file));
+      } else if (content === undefined || classifyResultKind(content) === 'error') {
+        failed.push(file);
+      }
+    }
+  }
+
+  // Combined output in the original file order.
+  const readParts = [];
+  for (const file of files) {
+    if (hits.has(file)) {
+      readParts.push(hits.get(file));
+      continue;
+    }
+    const content = missResults[file];
+    if (content && classifyResultKind(content) !== 'error') readParts.push(content);
+  }
+  return {
+    readParts,
+    failed,
+    stats: { files: files.length, cached: hits.size, miss: misses.length, failed: failed.length },
+  };
+}

package/src/runtime/agent/orchestrator/session/manager/prefetch-bridge/symbol-prefetch.mjs

@@ -0,0 +1,31 @@
+// callers[] / references[] prefetch through code_graph, one lookup per symbol.
+import { classifyResultKind } from '../../result-classification.mjs';
+import { _executeCodeGraphToolLazy } from '../runtime-loaders.mjs';
+import { runAbortable } from '../../../../../shared/abort-race.mjs';
+
+export function symbolEntries(list) {
+  return Array.isArray(list) ? list.filter((entry) => entry && typeof entry.symbol === 'string') : [];
+}
+
+export async function prefetchSymbols(session, mode, entries, signal) {
+  const tasks = entries.map(({ symbol, file }) => {
+    const cgArgs = { mode, symbol };
+    if (file) cgArgs.file = file;
+    if (session?.cwd) cgArgs.cwd = session.cwd;
+    return _executeCodeGraphToolLazy('code_graph', cgArgs, session?.cwd)
+      .then((out) => ({ symbol, out }))
+      .catch((e) => {
+        process.stderr.write(`[agent-prefetch] ${mode}(${symbol}) failed: ${e?.message || e}\n`);
+        return { symbol, out: null };
+      });
+  });
+  const results = await runAbortable(signal, () => Promise.allSettled(tasks));
+  const parts = [];
+  const failed = [];
+  for (const r of results) {
+    const { symbol, out } = r.status === 'fulfilled' ? r.value : { symbol: '?', out: null };
+    if (out && classifyResultKind(String(out)) !== 'error') parts.push(`### prefetch ${mode} ${symbol}\n${out}`);
+    else failed.push(symbol);
+  }
+  return { parts, failed };
+}