mixdog 0.9.32 → 0.9.34

package/src/runtime/agent/orchestrator/tools/patch/orchestrator.mjs

@@ -11,7 +11,7 @@ import { withBuiltinPathLocks } from '../builtin.mjs';
 import { withAdvisoryLocks } from '../builtin/advisory-lock.mjs';
 import { wrapMutationRouteOutput } from '../mutation-planner.mjs';
 import { getPluginData } from '../../config.mjs';
-import { prepareInput, isV4APatchInput, hasUnifiedBareV4AHunk, canFallbackCountedUnified, parseV4APatch, isCompactedPlaceholderPatch, salvageV4AOpening } from './parsing.mjs';
+import { prepareInput, isV4APatchInput, hasUnifiedBareV4AHunk, canFallbackCountedUnified, parseV4APatch, parseUnifiedBareV4APatch, parseUnifiedCountedAsV4APatch, isCompactedPlaceholderPatch, salvageV4AOpening } from './parsing.mjs';
 import {
   resolveBasePath,
   resolveV4AEntryPath,
@@ -21,6 +21,8 @@ import {
   renderParsedUnifiedPatch,
   rewriteHeaderPaths,
   preValidateNativeBatch,
+  classifyEntry,
+  stripDiffPrefix,
 } from './paths.mjs';
 import { ensureNativePatchBinaryAvailable } from './native-server.mjs';
 import { assertPathReachable } from '../builtin/fs-reachability.mjs';
@@ -33,12 +35,264 @@ import {
   convertV4ASectionsToUnifiedPatch,
   convertUnifiedBareV4AToUnifiedPatch,
   convertUnifiedCountedToUnifiedPatchViaV4A,
+  isV4ARenameSection,
 } from './v4a-convert.mjs';
 
 function isPatchErrorText(text) {
   return /^Error:/i.test(String(text ?? '').trimStart());
 }
 
+// Apply one "wave" (a set of unique-target parsed entries) via the native
+// (+ JS out-of-base) split. Returns { backend, text } on success or
+// { backend, error } so the caller decides whether earlier waves already
+// committed to disk. Extracted verbatim from the inline applyWave closure so
+// both the default wave loop and sequence mode share identical apply
+// semantics.
+async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewrites: whr }, basePath, opts) {
+  const { fuzz, rejectPartial, dryRun, fuzzy, readStateScope, abortSignal } = opts;
+  const insideEntries = wentries.filter((entry) => !isResolvedPathOutsideBase(entry.fullPath, basePath));
+  const outsideEntries = wentries.filter((entry) => isResolvedPathOutsideBase(entry.fullPath, basePath));
+  const parsedInside = (wparsed || []).filter(
+    (entry) => !isResolvedPathOutsideBase(parsedEntryResolvedPath(entry, basePath), basePath),
+  );
+  const backend = outsideEntries.length > 0
+    ? (insideEntries.length > 0 ? 'native+js-patch' : 'js-patch')
+    : 'native-patch';
+  const resultParts = [];
+  if (insideEntries.length > 0) {
+    const nativePatchStr = rewriteHeaderPaths(renderParsedUnifiedPatch(parsedInside), whr);
+    const nativeResult = await dispatchNativePatch({
+      entries: insideEntries,
+      basePath,
+      nativePatchStr,
+      fuzz,
+      rejectPartial,
+      dryRun,
+      readStateScope,
+      signal: abortSignal,
+      parsed: parsedInside,
+    });
+    if (isPatchErrorText(nativeResult)) return { backend, error: nativeResult };
+    resultParts.push(nativeResult);
+  }
+  if (outsideEntries.length > 0) {
+    // Out-of-base targets are applied via the JS dispatcher (no base-path
+    // confinement); write permission is enforced at the hook layer.
+    const jsResult = await dispatchJsPatchEntries({
+      rows: outsideEntries,
+      parsed: wparsed,
+      basePath,
+      dryRun,
+      fuzzy,
+      readStateScope,
+    });
+    if (isPatchErrorText(jsResult)) return { backend, error: jsResult };
+    resultParts.push(jsResult);
+  }
+  return { backend, text: resultParts.join('\n') };
+}
+
+// Default ordered section mode. Apply each file section in listed order,
+// converting every V4A section against the CURRENT on-disk state (i.e. after
+// all earlier sections have committed), and stop at the first section that
+// fails. Reports applied / failed / skipped reflecting true disk state.
+async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
+  const {
+    v4aConvertOpts, dryRun, fuzz, fuzzy, rejectPartial,
+    readStateScope, abortSignal, mutationPlan,
+  } = ctx;
+
+  // Build the ordered section "units". Each unit resolves its own parsed
+  // unified entry lazily via buildParsed(), so a V4A section is converted
+  // only when it is its turn — against disk mutated by the earlier sections.
+  const units = [];
+  // Build a per-section unit from a V4A-style section. Conversion is deferred
+  // into buildParsed() so each section is resolved against the disk state the
+  // earlier sections left behind — a later section that fails to convert/apply
+  // never blocks the earlier ones from committing (ordered-stop). This is
+  // shared by the V4A path AND the bare-@@/counted-unified fallbacks, so those
+  // salvageable formats keep ordered-stop instead of aborting whole-patch.
+  const pushSectionUnit = (section) => {
+    const displayPath = normalizeOutputPath(section.path);
+    const fullPath = resolveV4AEntryPath(basePath, section.path);
+    // A V4A rename cannot be sequenced, but ordered-stop requires we still
+    // apply every section BEFORE it and surface the rename as the failed
+    // section — never abort before earlier sections commit. Defer the
+    // rejection into buildParsed() so the loop marks it failed and keeps
+    // earlier commits.
+    if (isV4ARenameSection(section)) {
+      units.push({
+        displayPath,
+        fullPath,
+        buildParsed: async () => {
+          throw new Error('sequence mode does not support V4A rename (*** Move to:) sections; apply the rename in a separate non-sequence patch');
+        },
+      });
+      return;
+    }
+    units.push({
+      displayPath,
+      fullPath,
+      // Honor reject_partial via v4aConvertOpts: a bad hunk throws under
+      // reject_partial=true (section fails → sequence stops) but is recorded in
+      // rejectedHunks and skipped under reject_partial=false.
+      buildParsed: async () => {
+        const unified = await convertV4ASectionsToUnifiedPatch([section], basePath, v4aConvertOpts);
+        return parsePatch(prepareInput(unified));
+      },
+    });
+  };
+  if (isV4APatchInput(patchStr, requestedFormat)) {
+    let allSections;
+    try {
+      allSections = parseV4APatch(patchStr);
+    } catch (err) {
+      throw new Error(`apply_patch: V4A parse failed — ${err?.message || String(err)}`);
+    }
+    for (const section of allSections) pushSectionUnit(section);
+  } else if (requestedFormat !== 'unified' && hasUnifiedBareV4AHunk(patchStr)) {
+    // Bare `@@` V4A hunks in a unified body: parse to sections and defer each
+    // section's conversion into its own unit (ordered-stop preserved) rather
+    // than converting the whole patch up front.
+    let sections;
+    try {
+      sections = parseUnifiedBareV4APatch(patchStr);
+    } catch (err) {
+      throw new Error(`apply_patch: bare @@ parse failed — ${err?.message || String(err)}`);
+    }
+    for (const section of sections) pushSectionUnit(section);
+  } else {
+    let parsed = null;
+    let countedSections = null;
+    try {
+      parsed = parsePatch(prepareInput(patchStr));
+    } catch (err) {
+      if (!canFallbackCountedUnified(patchStr, requestedFormat, err)) {
+        throw new Error(`apply_patch: parse failed — ${err?.message || String(err)}; prefer V4A envelope for multi-hunk edits (no @@ line counts)`);
+      }
+      // Counted-unified (`@@ -a,b +c,d @@`) that parsePatch rejects: parse to
+      // V4A-style sections and defer per-section conversion — same ordered-stop
+      // guarantee as the V4A path (no whole-patch up-front convert).
+      try {
+        countedSections = parseUnifiedCountedAsV4APatch(patchStr);
+      } catch (fallbackErr) {
+        throw new Error(`apply_patch: parse failed — ${err?.message || String(err)}; V4A fallback failed — ${fallbackErr?.message || String(fallbackErr)}`);
+      }
+    }
+    if (countedSections) {
+      for (const section of countedSections) pushSectionUnit(section);
+    } else {
+      for (const entry of parsed || []) {
+        const kind = classifyEntry(entry);
+        const headerName = kind === 'create' ? entry.newFileName : entry.oldFileName;
+        units.push({
+          displayPath: normalizeOutputPath(stripDiffPrefix(headerName || '')),
+          fullPath: parsedEntryResolvedPath(entry, basePath),
+          buildParsed: async () => [entry],
+        });
+      }
+    }
+  }
+  if (units.length === 0) return 'Error: patch contained no file sections';
+
+  try {
+    await ensureNativePatchBinaryAvailable();
+  } catch (err) {
+    return `Error: ${err?.message || String(err)}`;
+  }
+
+  const lockPaths = [...new Set(units.map((u) => u.fullPath))];
+  const waveOpts = { fuzz, rejectPartial, dryRun, fuzzy, readStateScope, abortSignal };
+
+  return withBuiltinPathLocks(lockPaths, () =>
+    withAdvisoryLocks(lockPaths, async () => {
+      const applied = [];
+      const skipped = [];
+      let failed = null;
+      let failedIndex = -1;
+      let backend = 'native-patch';
+      for (let i = 0; i < units.length; i++) {
+        const unit = units[i];
+        if (failed) { skipped.push(unit.displayPath); continue; }
+        if (abortSignal?.aborted) {
+          failed = { displayPath: unit.displayPath, error: 'Error: apply_patch aborted' };
+          failedIndex = i;
+          continue;
+        }
+        let parsed;
+        try {
+          parsed = await unit.buildParsed();
+        } catch (err) {
+          failed = { displayPath: unit.displayPath, error: `Error: ${err?.message || String(err)}` };
+          failedIndex = i;
+          continue;
+        }
+        if (!Array.isArray(parsed) || parsed.length === 0) {
+          // Section produced no applicable hunks (all skipped / no-op). Nothing
+          // to commit; record and continue.
+          applied.push({ displayPath: unit.displayPath, text: `(no changes) ${unit.displayPath}` });
+          continue;
+        }
+        let wave;
+        try {
+          const { entries, headerRewrites } = await preValidateNativeBatch(parsed, basePath);
+          wave = { parsed, entries, headerRewrites };
+        } catch (err) {
+          failed = { displayPath: unit.displayPath, error: `Error: ${err?.message || String(err)}` };
+          failedIndex = i;
+          continue;
+        }
+        const res = await applyParsedWave(wave, basePath, waveOpts);
+        backend = res.backend;
+        if (res.error) {
+          failed = { displayPath: unit.displayPath, error: res.error };
+          failedIndex = i;
+          continue;
+        }
+        applied.push({ displayPath: unit.displayPath, text: res.text });
+      }
+
+      const verb = dryRun ? 'validated' : 'applied';
+      const dryNote = (dryRun && units.length > 1)
+        ? '\n(dry_run: each section validated against unchanged disk; a section depending on an earlier section\'s edits may report a false failure)'
+        : '';
+      const appliedTexts = applied.map((a) => a.text).filter(Boolean).join('\n');
+      // reject_partial=false may have skipped individual V4A hunks in ANY
+      // already-processed section; surface them in BOTH the success and failure
+      // reports so the reported disk state stays complete even when a later
+      // section fails.
+      const rejected = Array.isArray(v4aConvertOpts?.rejectedHunks) ? v4aConvertOpts.rejectedHunks : [];
+      const rejectedTail = rejected.length > 0
+        ? '\n' + [
+          '',
+          `hunk-level rejected (rejectPartial=false, V4A): ${rejected.length}`,
+          ...rejected.map((r) => `  REJECT ${r.file || '(unknown)'} — ${String(r.reason || '').split(';')[0].trim()}`),
+        ].join('\n')
+        : '';
+      if (!failed) {
+        const head = `apply_patch sequence: ${verb} ${units.length} section(s) in listed order`;
+        const body = (appliedTexts ? `${head}\n${appliedTexts}` : head) + dryNote + rejectedTail;
+        return wrapPatchMutationOutput(body, mutationPlan, { backend });
+      }
+      const failMsg = failed.error.replace(/^Error:\s*/, '');
+      const committedPhrase = dryRun
+        ? `${applied.length} earlier section(s) were validated`
+        : `${applied.length} earlier section(s) were applied to disk (committed) and left in place`;
+      const lines = [
+        `Error: apply_patch sequence stopped at section ${failedIndex + 1}/${units.length} (${failed.displayPath}); `
+          + `${committedPhrase}; ${skipped.length} later section(s) were skipped (not attempted).`,
+      ];
+      if (appliedTexts) {
+        lines.push(`--- ${dryRun ? 'validated' : 'applied (committed to disk)'} ---`, appliedTexts);
+      }
+      lines.push(`--- failed section: ${failed.displayPath} ---`, failMsg);
+      if (skipped.length > 0) {
+        lines.push(`--- skipped (not attempted): ${skipped.join(', ')} ---`);
+      }
+      return wrapPatchMutationOutput(lines.join('\n') + dryNote + rejectedTail, mutationPlan, { backend });
+    }));
+}
+
 const APPLY_PATCH_UI_DIFF_MAX_CHARS = 64 * 1024;
 // Reject oversized patch bodies before parse / native Buffer.from
 // (native-server.mjs Buffer.from(patchText)). A few MB covers any legitimate
@@ -82,7 +336,7 @@ function wrapPatchMutationOutput(text, plan, extras = {}) {
   return wrapMutationRouteOutput(text, plan, extras);
 }
 
-const APPLY_PATCH_SCHEMA_KEYS = new Set(['patch', 'format', 'base_path', 'dry_run', 'reject_partial', 'fuzzy']);
+const APPLY_PATCH_SCHEMA_KEYS = new Set(['patch', 'format', 'base_path', 'dry_run', 'reject_partial', 'fuzzy', 'sequence', 'mode']);
 function salvageShatteredV4APatchArgs(args) {
   if (!args || typeof args !== 'object') return args;
   const rawPatch = typeof args.patch === 'string' ? args.patch : '';
@@ -142,6 +396,17 @@ async function apply_patch(args, cwd, options = {}) {
   let inputPatchStr = patchStr;
   const rejectedV4AHunks = [];
   const v4aConvertOpts = { rejectPartial, rejectedHunks: rejectedV4AHunks, fuzzy, dryRun, readStateScope };
+  // Default internal ordered mode: apply sections in listed order, stop at the
+  // first failure, and report applied/failed/skipped with true disk state.
+  // The legacy bulk/atomic path remains available as an explicit escape hatch.
+  const legacyBulkMode = args?.sequence === false
+    || ['atomic', 'bulk'].includes(String(args?.mode || '').toLowerCase());
+  if (!legacyBulkMode) {
+    return applyPatchSequence(patchStr, requestedFormat, basePath, {
+      v4aConvertOpts, dryRun, fuzz, fuzzy, rejectPartial,
+      readStateScope, abortSignal, mutationPlan,
+    });
+  }
   let v4aRenamePlan = null;
   if (isV4APatchInput(patchStr, requestedFormat)) {
     try {
@@ -243,51 +508,9 @@ async function apply_patch(args, cwd, options = {}) {
       if (lines.length === 0) return 'Error: patch contained no applicable file sections';
       return wrapPatchMutationOutput(`${lines.join('\n')}\n`, mutationPlan, { backend: 'v4a-rename' });
     }
-    // Apply one wave (a set of unique targets) via the existing native(+js)
-    // split. Returns { backend, text } on success or { backend, error } so the
-    // caller can decide whether earlier waves already committed to disk.
-    const applyWave = async ({ parsed: wparsed, entries: wentries, headerRewrites: whr }) => {
-      const insideEntries = wentries.filter((entry) => !isResolvedPathOutsideBase(entry.fullPath, basePath));
-      const outsideEntries = wentries.filter((entry) => isResolvedPathOutsideBase(entry.fullPath, basePath));
-      const parsedInside = (wparsed || []).filter(
-        (entry) => !isResolvedPathOutsideBase(parsedEntryResolvedPath(entry, basePath), basePath),
-      );
-      const backend = outsideEntries.length > 0
-        ? (insideEntries.length > 0 ? 'native+js-patch' : 'js-patch')
-        : 'native-patch';
-      const resultParts = [];
-      if (insideEntries.length > 0) {
-        const nativePatchStr = rewriteHeaderPaths(renderParsedUnifiedPatch(parsedInside), whr);
-        const nativeResult = await dispatchNativePatch({
-          entries: insideEntries,
-          basePath,
-          nativePatchStr,
-          fuzz,
-          rejectPartial,
-          dryRun,
-          readStateScope,
-          signal: abortSignal,
-          parsed: parsedInside,
-        });
-        if (isPatchErrorText(nativeResult)) return { backend, error: nativeResult };
-        resultParts.push(nativeResult);
-      }
-      if (outsideEntries.length > 0) {
-        // Out-of-base targets are applied via the JS dispatcher (no base-path
-        // confinement); write permission is enforced at the hook layer.
-        const jsResult = await dispatchJsPatchEntries({
-          rows: outsideEntries,
-          parsed: wparsed,
-          basePath,
-          dryRun,
-          fuzzy,
-          readStateScope,
-        });
-        if (isPatchErrorText(jsResult)) return { backend, error: jsResult };
-        resultParts.push(jsResult);
-      }
-      return { backend, text: resultParts.join('\n') };
-    };
+    // Apply one wave (a set of unique targets) via applyParsedWave (native +
+    // JS split). Returns { backend, text } on success or { backend, error }.
+    const applyWave = (wave) => applyParsedWave(wave, basePath, { fuzz, rejectPartial, dryRun, fuzzy, readStateScope, abortSignal });
 
     // Duplicate-target blocks were split into contiguous sequential groups
     // (listed order preserved); apply them in order, each against the prior

package/src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs

@@ -26,7 +26,7 @@ export const PATCH_TOOL_DEFS = [
     name: 'apply_patch',
     title: 'Mixdog Apply Patch',
     annotations: { title: 'Mixdog Apply Patch', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false, compressible: false, compressibleLossless: true },
-    description: 'Apply file patches. Prefer V4A envelope with exact current context. Batch independent edits into ONE patch (multiple file blocks).',
+    description: 'Apply file patches. Put known edits in one patch, not multiple turns; sections run in listed order.',
     freeformDescription: APPLY_PATCH_FREEFORM_DESCRIPTION,
     freeform: {
       type: 'grammar',
@@ -36,10 +36,12 @@ export const PATCH_TOOL_DEFS = [
     inputSchema: {
       type: 'object',
       properties: {
-        patch: { type: 'string', description: 'Patch text. V4A preferred: `*** Begin Patch`; one file block per target file; exact current context.' },
+        patch: { type: 'string', description: 'Patch text. V4A preferred; include all known edits in listed order.' },
         format: { type: 'string', enum: ['unified', 'v4a'], description: 'Auto-detected.' },
         base_path: { type: 'string', description: 'Repo root.' },
         dry_run: { type: 'boolean', description: 'Default false. true = validate only, no write.' },
+        fuzzy: { type: 'boolean', description: 'Default true. Allows limited context fuzz.' },
+        reject_partial: { type: 'boolean', description: 'Default true. false allows V4A hunk-level rejects.' },
       },
       required: ['patch'],
     },

package/src/runtime/channels/lib/output-forwarder.mjs

@@ -157,7 +157,13 @@ class OutputForwarder {
         const noSendEvidence = (!Number.isFinite(sentCount) || sentCount <= 0)
           && (!Number.isFinite(lastSentTime) || lastSentTime <= 0)
           && !hasSentHash;
-        if (!sameTranscript || noSendEvidence) {
+        // Recover a genuinely-unsynced tail ONLY for the SAME transcript we are
+        // resuming (a reply this session generated but never delivered — crash
+        // recovery). NEVER pull the cursor back for a DIFFERENT transcript: on
+        // connect/change/rebind that would forward the newly-bound (possibly
+        // prior/unrelated) transcript's old tail. A fresh binding must only
+        // forward outputs created after the binding, so leave the cursor at EOF.
+        if (sameTranscript && noSendEvidence) {
           const tailOffset = this.findLastAssistantTextOffset(currentSize);
           if (tailOffset >= 0 && tailOffset < currentSize) {
             fileSize = tailOffset;

package/src/runtime/channels/lib/owned-runtime.mjs

@@ -156,8 +156,11 @@ async function selfHealOwnedRuntime(options = {}) {
         process.stderr.write(`mixdog: self-heal getBackend() reset failed (non-fatal): ${e instanceof Error ? e.message : String(e)}\n`);
       });
     }
-    // Nudge the forwarder to drain anything the rebind/reconnect surfaced.
-    void forwarder.forwardNewText().catch(() => {});
+    // Do NOT nudge forwardNewText() here. bindPersistedTranscriptIfAny() above
+    // already forwards the same-session catch-up from the persisted cursor; an
+    // extra drain risks surfacing the old tail of a freshly (re)bound transcript
+    // on connect/change/rebind. Only outputs created after the new binding
+    // should be forwarded, and the normal watch/poll path handles those.
   } finally {
     _ownedRuntimeSelfHealing = false;
   }

package/src/runtime/memory/lib/embedding-worker.mjs

@@ -50,6 +50,21 @@ const MODEL_CACHE_DIR = join(resolvePluginData(), 'memory-models')
 const _envIdleMs = Number(process.env.MIXDOG_EMBED_IDLE_TIMEOUT_MS)
 const IDLE_TIMEOUT_MS = Number.isFinite(_envIdleMs) && _envIdleMs >= 0 ? _envIdleMs : 0
 
+// Defensive belt against giant model inputs. Callers should already bound text
+// (see memory-embed truncateForEmbed), but the worker is the last line before
+// ORT: an unbounded string builds a [batch, seq] tensor large enough to trigger
+// multi-GB allocations and an input-tensor dump in the ORT error path. Cap each
+// text to a char budget and ask the tokenizer to truncate to the model window.
+const _envWorkerMaxChars = Number(process.env.MIXDOG_EMBED_MAX_CHARS)
+const WORKER_MAX_CHARS = (Number.isFinite(_envWorkerMaxChars) && _envWorkerMaxChars > 0)
+  ? Math.floor(_envWorkerMaxChars)
+  : 8000
+const EXTRACT_OPTS = { pooling: 'mean', normalize: true, truncation: true }
+function capEmbedText(text) {
+  if (typeof text !== 'string') return ''
+  return text.length > WORKER_MAX_CHARS ? text.slice(0, WORKER_MAX_CHARS) : text
+}
+
 let extractorPromise = null
 let configuredDtype = DEFAULT_DTYPE
 let _device = 'cpu'
@@ -262,7 +277,7 @@ async function processMessage(msg) {
           break
         }
         const t0 = Date.now()
-        const output = await extractor(texts, { pooling: 'mean', normalize: true })
+        const output = await extractor(texts.map(capEmbedText), EXTRACT_OPTS)
         const wallMs = Date.now() - t0
         if (!output.data?.length) throw new Error(`embed-batch output missing data (model=${MODEL_ID})`)
         const total = output.data.length
@@ -284,7 +299,7 @@ async function processMessage(msg) {
         resetIdleTimer()
         const extractor = await loadExtractor()
         const t0 = Date.now()
-        const output = await extractor(msg.text, { pooling: 'mean', normalize: true })
+        const output = await extractor(capEmbedText(msg.text), EXTRACT_OPTS)
         const wallMs = Date.now() - t0
         if (!output.data?.length) throw new Error(`embed output missing data (model=${MODEL_ID})`)
         const dims = output.data.length
@@ -302,7 +317,7 @@ async function processMessage(msg) {
         resetIdleTimer()
         const extractor = await loadExtractor()
         const t0 = Date.now()
-        const warmupOutput = await extractor('warmup', { pooling: 'mean', normalize: true })
+        const warmupOutput = await extractor('warmup', EXTRACT_OPTS)
         const wallMs = Date.now() - t0
         if (!warmupOutput.data?.length) throw new Error(`warmup output missing data (model=${MODEL_ID})`)
         const measuredDims = warmupOutput.data.length

package/src/runtime/memory/lib/memory-embed.mjs

@@ -75,6 +75,64 @@ const _rawTimeout = Number(process.env.MIXDOG_EMBED_FLUSH_TIMEOUT_MS)
 const EMBED_FLUSH_TIMEOUT_MS = (Number.isFinite(_rawTimeout) && _rawTimeout > 0) ? _rawTimeout : 30_000
 
 const BATCH_SIZE = 32
+const RAW_EMBEDDING_ENABLED = process.env.MIXDOG_ENABLE_RAW_EMBEDDINGS === '1'
+let _rawEmbeddingDisabledLogged = false
+
+// Conservative per-text length cap applied before any text reaches the
+// embedding provider. Raw transcript rows and tool-output content can be
+// arbitrarily large; feeding a 14k-token string to the transformer builds a
+// giant [batch, seq] tensor (observed: dims [8,14363] → ORT attempting a 79GB
+// allocation before dumping the input BigInt64Array). The model only attends to
+// its first ~512 tokens anyway, so truncating to a bounded char budget preserves
+// recall while capping tensor size and worker RSS. ~4 chars/token → 8000 chars
+// ≈ 2000 tokens, comfortably above the model window yet far below the blowup.
+const _envEmbedMaxChars = Number(process.env.MIXDOG_EMBED_MAX_CHARS)
+const EMBED_MAX_CHARS = (Number.isFinite(_envEmbedMaxChars) && _envEmbedMaxChars > 0)
+  ? Math.floor(_envEmbedMaxChars)
+  : 8000
+
+export function truncateForEmbed(text) {
+  if (typeof text !== 'string') return ''
+  return text.length > EMBED_MAX_CHARS ? text.slice(0, EMBED_MAX_CHARS) : text
+}
+
+// Raw-row dense-embed eligibility. Storage/recall rows are NEVER deleted or
+// unindexed here — but the dense embedding leg should only cover useful
+// CONVERSATIONAL text. Tool call/result traces and runtime/log/offload/debug/
+// system notifications carry no recall value as dense vectors and pollute the
+// shared embedding cache with mechanical noise, so they are excluded before
+// embedding AND before batch vector mapping. An excluded row keeps its row +
+// embedding-NULL storage state untouched (no delete, no schema change).
+const RAW_EMBED_EXCLUDE_ROLES = new Set(['tool', 'tool_result', 'tool-result', 'function', 'system', 'log', 'offload', 'debug'])
+const RAW_EMBED_EXCLUDE_CONTENT_RES = [
+  /^\s*\[tool_call\b/i,
+  /^\s*\[tool_result\b/i,
+  /^\s*\[mixdog-runtime\]/i,
+  /^\s*The async (?:shell task|agent task|\S+ execution|\S+) .*has finished\b.*review this result in your next step/i,
+  /^\s*background task\b/i,
+]
+const RAW_EMBED_EXCLUDE_NON_CONVERSATION_CONTENT_RES = [
+  /^\s*\[(?:system|log|offload|debug|trace|info|warn|warning|error|fatal)\]/i,
+]
+const RAW_EMBED_CONVERSATION_ROLES = new Set(['user', 'assistant'])
+
+export function isRawEmbeddable(role, content) {
+  const normRole = String(role ?? '').trim().toLowerCase()
+  if (RAW_EMBED_EXCLUDE_ROLES.has(normRole)) return false
+  const text = typeof content === 'string' ? content : ''
+  if (!text.trim()) return false
+  for (const re of RAW_EMBED_EXCLUDE_CONTENT_RES) if (re.test(text)) return false
+  if (!RAW_EMBED_CONVERSATION_ROLES.has(normRole)) {
+    for (const re of RAW_EMBED_EXCLUDE_NON_CONVERSATION_CONTENT_RES) if (re.test(text)) return false
+  }
+  return true
+}
+
+const RAW_EMBED_SQL_EXCLUDE_ROLE_VALUES = [...RAW_EMBED_EXCLUDE_ROLES]
+const RAW_EMBED_SQL_ALWAYS_EXCLUDE_CONTENT_RE =
+  '^\\s*(\\[tool_call\\b|\\[tool_result\\b|\\[mixdog-runtime\\]|The async (shell task|agent task|\\S+ execution|\\S+) .*has finished\\b.*review this result in your next step|background task\\b)'
+const RAW_EMBED_SQL_NON_CONVERSATION_EXCLUDE_CONTENT_RE =
+  '^\\s*\\[(system|log|offload|debug|trace|info|warn|warning|error|fatal)\\]'
 
 function throwIfAborted(signal) {
   if (signal?.aborted) throw signal.reason ?? new Error('aborted')
@@ -106,10 +164,13 @@ export async function cachedEmbedTextBatch(db, texts, options = {}) {
   // env value that doesn't match the provider would tag vectors with a
   // stale/wrong label across model/env changes.
   const modelId = getEmbeddingModelId() || process.env.MIXDOG_EMBED_MODEL || 'default'
-  const entries = texts.map(t => ({
-    text: t,
-    hash: Buffer.from(createHash('sha256').update(t).digest()),
-  }))
+  // Bound each text before hashing/embedding: the cache key and the provider
+  // input are both the truncated string, so oversized rows can never build a
+  // giant tensor and identical truncations dedup in-cache.
+  const entries = texts.map(t => {
+    const text = truncateForEmbed(t)
+    return { text, hash: Buffer.from(createHash('sha256').update(text).digest()) }
+  })
 
   // Single SELECT for all hashes
   const hashBufs = entries.map(e => e.hash)
@@ -285,6 +346,14 @@ export async function flushEmbeddingDirty(db, options = {}) {
 // dense matching, not staleness.
 export async function flushRawEmbeddings(db, options = {}) {
   const { limit = 200, signal } = options ?? {}
+  throwIfAborted(signal)
+  if (!RAW_EMBEDDING_ENABLED) {
+    if (!_rawEmbeddingDisabledLogged) {
+      __mixdogMemoryLog('[embed] raw transcript embedding disabled; only root/summary entries are embedded\n')
+      _rawEmbeddingDisabledLogged = true
+    }
+    return { attempted: 0, embedded: 0, skipped: 'raw-embedding-disabled' }
+  }
   // Optional id allow-list: restrict the SKIP LOCKED claim to a specific set of
   // rows (e.g. exactly the rows a single ingest_session call inserted) so a
   // caller can flush ONLY its own rows instead of inheriting the whole raw
@@ -294,7 +363,6 @@ export async function flushRawEmbeddings(db, options = {}) {
     ? options.ids.map(Number).filter(Number.isFinite)
     : null
   if (idFilter && idFilter.length === 0) return { attempted: 0, embedded: 0 }
-  throwIfAborted(signal)
   await ensureEmbCacheTable(db)
   throwIfAborted(signal)
 
@@ -310,7 +378,14 @@ export async function flushRawEmbeddings(db, options = {}) {
     try {
       throwIfAborted(signal)
       await client.query('BEGIN')
-      const params = [batchCap, cursor]
+      const params = [
+        batchCap,
+        cursor,
+        RAW_EMBED_SQL_EXCLUDE_ROLE_VALUES,
+        [...RAW_EMBED_CONVERSATION_ROLES],
+        RAW_EMBED_SQL_ALWAYS_EXCLUDE_CONTENT_RE,
+        RAW_EMBED_SQL_NON_CONVERSATION_EXCLUDE_CONTENT_RE,
+      ]
       let idClause = ''
       if (idFilter) {
         params.push(idFilter)
@@ -322,6 +397,9 @@ export async function flushRawEmbeddings(db, options = {}) {
            AND NULLIF(btrim(session_id), '') IS NOT NULL
            AND content IS NOT NULL
            AND id > $2${idClause}
+           AND lower(COALESCE(role, '')) <> ALL($3::text[])
+           AND content !~* $5
+           AND (lower(COALESCE(role, '')) = ANY($4::text[]) OR content !~* $6)
          ORDER BY id
          LIMIT $1
          FOR UPDATE SKIP LOCKED`,
@@ -374,7 +452,7 @@ async function syncRawBatchEmbeddings(db, ids, options = {}) {
   const signal = options?.signal
   throwIfAborted(signal)
   const rows = (await db.query(
-    `SELECT id, content FROM memory.entries
+    `SELECT id, role, content FROM memory.entries
      WHERE id = ANY($1::bigint[]) AND is_root = 0 AND chunk_root IS NULL`,
     [ids],
   )).rows
@@ -385,7 +463,10 @@ async function syncRawBatchEmbeddings(db, ids, options = {}) {
   throwIfAborted(signal)
   const expected = Number(dimsRow?.value ?? 0)
 
-  const texts = rows.map(row => (typeof row.content === 'string' ? row.content.trim() : ''))
+  // Exclude tool/tool_result/log/offload/debug/system-like rows from the dense
+  // embed leg (empty text ⇒ dropped below and never vector-mapped). The length
+  // cap still applies to survivors via cachedEmbedTextBatch → truncateForEmbed.
+  const texts = rows.map(row => (isRawEmbeddable(row.role, row.content) ? row.content.trim() : ''))
   const vectors = await cachedEmbedTextBatch(db, texts.filter(Boolean), { signal })
   throwIfAborted(signal)
   let vecIdx = 0

package/src/session-runtime/context-status.mjs

@@ -2,8 +2,7 @@ import {
   estimateRequestReserveTokens,
   estimateToolSchemaTokens,
   estimateTranscriptContextUsage,
-  resolveCompactBufferTokens,
-  resolveCompactTriggerTokens,
+  resolveSessionCompactPolicy,
   summarizeContextMessages,
 } from '../runtime/agent/orchestrator/session/context-utils.mjs';
 import { estimateToolSchemaBreakdown } from './tool-catalog.mjs';
@@ -122,10 +121,12 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     // Use the same shared compact-policy math as manager/loop. Do not trust
     // persisted trigger telemetry as an independent policy input: it is an
     // output snapshot and was the source of repeated /context false positives.
-    const compactTriggerTokens = resolveCompactTriggerTokens(session || {}, compactBoundaryTokens) || 0;
-    const compactBufferTokens = compactBoundaryTokens
-      ? Math.max(0, compactBoundaryTokens - compactTriggerTokens)
-      : resolveCompactBufferTokens(compactBoundaryTokens, session?.compaction || {});
+    // Shared session-compaction policy (same math as manager/loop): agent-owned
+    // semantic sessions report/fire at 90% of the boundary; main/user
+    // recall-fasttrack report/fire on the boundary itself (100%).
+    const compactPolicy = resolveSessionCompactPolicy(session || {}, compactBoundaryTokens);
+    const compactTriggerTokens = compactPolicy.triggerTokens || 0;
+    const compactBufferTokens = compactPolicy.bufferTokens || 0;
     const value = {
       sessionId: session?.id || null,
       provider: route.provider,