mixdog 0.9.150 → 0.9.151

package/README.md

@@ -150,17 +150,34 @@ npm run dev
 
 ## Terminal-Bench 2.1
 
-Controlled single-model runs on the same 89 tasks produced:
-
-- **82/89** with Claude Opus 5 vs Claude Code's **77/89**
-- **79/89** with GPT-5.6 Sol xhigh vs Codex CLI's **75/89**
-- **1.21×** faster vs Claude Code and **1.15×** faster vs Codex CLI
-- **31–47%** smaller median final context
-- **16%** lower priced cost vs Claude Code and **41%** lower vs Codex CLI
-
-These are self-reported single runs (`k=1`, 2026-08-23), not leaderboard
-submissions. Raw artifacts, commands, comparison charts, and metric scripts
-live under [`benchmarks/terminal-bench-2.1/`](benchmarks/terminal-bench-2.1/).
+Head-to-head runs against other agent CLIs on the same 89 tasks, holding the
+model fixed and changing only the harness. Every run uses the official Harbor
+verifier, fast mode off, a 272k context window, and zero retries.
+
+**GPT-5.6 Sol xhigh — Mixdog vs Codex CLI**
+
+- Score: **86.5%** (385/445) vs Codex CLI's **84.3%** (75/89)
+- **1.11×** faster per trial (339s vs 378s)
+- **42%** lower priced cost ($0.641 vs $1.096 per trial)
+- **45%** smaller median final context (18.5k vs 33.5k tokens)
+
+**Claude Opus 5 — Mixdog vs Claude Code**
+
+- Score: **79/89** vs Claude Code's **77/89**
+- **1.15×** faster and **19%** lower priced cost ($104.29 vs $129.21 per run)
+- **28%** smaller median final context (27.6k vs 38.2k tokens)
+
+Measurement: the Mixdog Sol run follows the same protocol the official
+Terminal-Bench leaderboard requires — all 89 tasks repeated five times
+(`k=5`, 445 trials), scored by the official Harbor verifier. The Codex CLI
+baseline and both Opus-side runs are single passes (`k=1`, 89 trials each).
+
+The official leaderboard is not accepting community submissions, so every run
+here ships its raw artifacts instead — Harbor verdicts, official verifier
+output, pinned task checksums, and the usage snapshots behind every cost
+figure — alongside the harness, presets, and metric scripts that recompute
+each number above:
+[`benchmarks/terminal-bench-2.1/`](benchmarks/terminal-bench-2.1/).
 
 ## Data and configuration
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.150",
+  "version": "0.9.151",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/src/headless-exec.mjs

@@ -14,6 +14,7 @@ import {
 import { hasActiveBackgroundTasks } from './runtime/shared/background-tasks.mjs';
 import { installProcessSignalCleanup } from './runtime/shared/process-shutdown.mjs';
 import { stopStandaloneMemoryRuntimesForProcess } from './standalone/memory-runtime-proxy.mjs';
+import { shutdownDaemonForRuntimeRoot } from './standalone/session-client.mjs';
 import { applyUsageDelta, createSessionStats } from './ui/session-stats.mjs';
 
 function clean(value) {
@@ -558,6 +559,7 @@ export async function runHeadlessExec({
   boundaryFactory = createPristineExecutionBoundary,
   runtimeFactory = null,
   memoryRuntimeCleanup = stopStandaloneMemoryRuntimesForProcess,
+  daemonRuntimeCleanup = shutdownDaemonForRuntimeRoot,
   hasActiveTasks = hasActiveBackgroundTasks,
   installSignalCleanupFn = installProcessSignalCleanup,
 } = {}) {
@@ -616,17 +618,28 @@ export async function runHeadlessExec({
       } catch (error) {
         errors.push(error);
       }
-      let memoryCleanupFailed = false;
+      let resourceCleanupFailed = false;
+      if (boundary?.runtimeRoot) {
+        try {
+          await daemonRuntimeCleanup(boundary.runtimeRoot, {
+            waitForExit: true,
+            timeoutMs: 8_000,
+          });
+        } catch (error) {
+          resourceCleanupFailed = true;
+          errors.push(error);
+        }
+      }
       if (boundary) {
         try {
           await memoryRuntimeCleanup({ waitForExit: true, timeoutMs: 10_000 });
         } catch (error) {
-          memoryCleanupFailed = true;
+          resourceCleanupFailed = true;
           errors.push(error);
         }
       }
       try {
-        const cleanupResult = boundary?.cleanup(memoryCleanupFailed
+        const cleanupResult = boundary?.cleanup(resourceCleanupFailed
           ? { preserveRoot: true }
           : { tolerateRootRemovalFailure: true });
         if (cleanupResult?.rootRemovalError) {

package/src/headless-exec.test.mjs

@@ -62,6 +62,7 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
   let activeChecks = 0;
   let boundaryCleaned = false;
   let runtimeClosed = false;
+  const daemonCleanupCalls = [];
   const cleanupOrder = [];
   try {
     const code = await runHeadlessExec({
@@ -75,6 +76,7 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
       write: (text) => output.push(text),
       writeErr: (text) => errors.push(text),
       boundaryFactory: () => ({
+        runtimeRoot: join(root, 'runtime-root'),
         loadConfig: () => ({ providers: { 'openai-oauth': { enabled: true } } }),
         cleanup: () => {
           boundaryCleaned = true;
@@ -106,6 +108,10 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
       memoryRuntimeCleanup: async () => {
         cleanupOrder.push('memory');
       },
+      daemonRuntimeCleanup: async (runtimeRoot, options) => {
+        daemonCleanupCalls.push({ runtimeRoot, options });
+        cleanupOrder.push('daemon');
+      },
       hasActiveTasks: (scope) => {
         activeScopes.push(scope);
         activeChecks += 1;
@@ -128,7 +134,11 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
     });
     assert.equal(boundaryCleaned, true);
     assert.equal(runtimeClosed, true);
-    assert.deepEqual(cleanupOrder, ['runtime', 'memory', 'boundary']);
+    assert.deepEqual(cleanupOrder, ['runtime', 'daemon', 'memory', 'boundary']);
+    assert.deepEqual(daemonCleanupCalls, [{
+      runtimeRoot: join(root, 'runtime-root'),
+      options: { waitForExit: true, timeoutMs: 8_000 },
+    }]);
     const usage = JSON.parse(readFileSync(usageLogPath, 'utf8'));
     assert.deepEqual(usage.sessions[0].models, ['gpt-test', 'gpt-fallback']);
     assert.deepEqual(usage.totals, {
@@ -143,6 +153,39 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
   }
 });
 
+test('headless exec preserves the pristine root when isolated daemon shutdown fails', async () => {
+  const errors = [];
+  let cleanupOptions = null;
+  const code = await runHeadlessExec({
+    message: 'done',
+    provider: 'openai-oauth',
+    model: 'gpt-test',
+    usageLogPath: '',
+    write() {},
+    writeErr: (text) => errors.push(text),
+    boundaryFactory: () => ({
+      runtimeRoot: '/isolated/runtime',
+      loadConfig: () => ({ providers: { 'openai-oauth': { enabled: true } } }),
+      cleanup: (options) => { cleanupOptions = options; },
+    }),
+    runtimeFactory: async () => ({
+      id: 'sess_cleanup_failure',
+      model: 'gpt-test',
+      clientHostPid: 123,
+      async ask() { return { result: { content: 'done' } }; },
+      async close() {},
+    }),
+    daemonRuntimeCleanup: async () => { throw new Error('daemon stuck'); },
+    memoryRuntimeCleanup: async () => {},
+    hasActiveTasks: () => false,
+    installSignalCleanupFn: () => ({ uninstall() {} }),
+  });
+
+  assert.equal(code, 1);
+  assert.deepEqual(cleanupOptions, { preserveRoot: true });
+  assert.ok(errors.some((line) => line.includes('shutdown failed: daemon stuck')));
+});
+
 test('headless exec flushes the usage snapshot mid-session, before any exit path', async () => {
   const root = mkdtempSync(join(tmpdir(), 'mixdog-headless-usage-flush-test-'));
   const usageLogPath = join(root, 'usage.json');

package/src/rules/shared/30-exploration.md

@@ -27,7 +27,8 @@
   locator searches. Within the current project, pass project-relative paths and
   omit optional scopes equal to its root; explicit paths may be outside cwd
   only for targets outside the project.
-- Inspect source content only when its format is required and unknown.
+- Before deciding how to parse, count, transform, or summarize files whose
+  format has not been inspected, inspect the original content itself.
 - Returned declarations, bodies, usages, relations, and contextual spans from
   any tool — not only `read` — are source context; `read` covers only omitted
   lines or missing anchored ranges.

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

@@ -1,6 +1,5 @@
 import { estimateTokens } from '../context-utils.mjs';
 
-const CONVERSATION_LINE_CHARS = 800;
 const TOOL_OUTCOME_CHARS = 80;
 
 function textOf(m) {
@@ -339,7 +338,7 @@ export function conversationLinesFromMemoryText(text) {
             .replace(/\s+#\d+\s*$/, '')
             .trim();
         if (body && body !== '.' && body !== '…') {
-            rows.push(`${current.role}: ${body.slice(0, CONVERSATION_LINE_CHARS)}`);
+            rows.push(`${current.role}: ${body}`);
         }
         current = null;
     };
@@ -372,8 +371,7 @@ export function excludeTailFromConversation(lines, tailMessages) {
         if (m?.role !== 'user' && m?.role !== 'assistant') continue;
         const body = String(typeof m.content === 'string' ? m.content : '')
             .replace(/\s+/g, ' ')
-            .trim()
-            .slice(0, CONVERSATION_LINE_CHARS);
+            .trim();
         if (body) tails.push(body);
     }
     if (!tails.length) return Array.isArray(lines) ? lines : [];

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

@@ -45,7 +45,6 @@ import {
     enforceSemanticSummarySchema,
     fitSemanticSummaryMessage,
     fitRecallFastTrackSummaryMessage,
-    stripNestedSummaryHeaderLines,
     RECALL_TAIL_TRUNCATION_MARKER,
     RECALL_TAIL_SHORT_TRUNCATION_MARKER,
 } from './summary.mjs';
@@ -57,7 +56,6 @@ import {
     fitRecallHandoffText,
     conversationLinesFromMemoryText,
     excludeTailFromConversation,
-    stripWorkingFileSections,
 } from './handoff.mjs';
 
 // Post-compact file re-attachment: re-inject fresh reads
@@ -555,12 +553,12 @@ export function recallFastTrackCompactMessages(messages, budgetTokens, opts = {}
 //
 // Turns are anchored on user-role boundaries: each turn = a user message plus
 // the assistant/tool/system/developer messages that follow it. Recall-fasttrack
-// keeps the newest live turn verbatim. Older conversation comes from memory.
+// keeps the newest five live turns verbatim. Older conversation comes from memory.
 //
 // Partial tool_call/tool_result pairs that truncation might leave behind are
 // repaired by sanitizeToolPairs/reconcileDedupStubs in the caller, so pairing
 // stays valid even after trimming.
-const RECALL_TAIL_USER_MAX = 1;
+const RECALL_TAIL_USER_MAX = 5;
 const RECALL_TAIL_TOKEN_CAP = DEFAULT_COMPACTION_KEEP_TOKENS; // 8k
 // A caller may request a cap smaller than one structurally valid message. Keep
 // the cap strict above this unavoidable floor while retaining a real anchor.
@@ -695,10 +693,10 @@ function truncateTailToCap(messages, cap) {
     return estimateMessagesTokens(sanitized) <= cap ? sanitized : [];
 }
 
-function splitRecallFitInputs(recallText, previousSummary) {
+function splitRecallFitInputs(recallText) {
     return {
         recall: String(recallText || '').trim(),
-        prior: previousSummary ? stripNestedSummaryHeaderLines(previousSummary) : '',
+        prior: '',
     };
 }
 
@@ -799,7 +797,7 @@ function _recallFastTrackCompactMessages(messages, budgetTokens, opts = {}) {
     }
     const sanitized = redactToolCallSecretsInMessages(baseSanitized);
 
-    const { system: safeSystem, live, previousSummary } = splitLiveCompactionContext(sanitized);
+    const { system: safeSystem, live } = splitLiveCompactionContext(sanitized);
     const recallTailOpts = {
         maxUsers: opts.recallTailMaxUsers ?? opts.tailTurns ?? RECALL_TAIL_USER_MAX,
         tokenCap: (() => {
@@ -815,8 +813,8 @@ function _recallFastTrackCompactMessages(messages, budgetTokens, opts = {}) {
         head: recallHead,
         lastTurnStartIdx = recallHead.length,
     } = selectRecallPreservedTail(live, recallTailOpts);
-    const recallFit = splitRecallFitInputs(opts.recallText, previousSummary);
-    if (recallHead.length === 0 && !previousSummary
+    const recallFit = splitRecallFitInputs(opts.recallText);
+    if (recallHead.length === 0
         && !(recallFit.recall || recallFit.prior || opts.allowEmptyRecall === true)) {
         throw new Error('recallFastTrackCompactMessages: no compactable prior history before preserved tail');
     }
@@ -848,44 +846,31 @@ function _recallFastTrackCompactMessages(messages, budgetTokens, opts = {}) {
     const recallRoom = (Number.isFinite(recallTokenCap) && recallTokenCap > 0)
         ? Math.min(recallRoomUncapped, Math.max(512, recallTokenCap - tailTokens))
         : recallRoomUncapped;
-    const priorWithoutWorkingFiles = stripWorkingFileSections(recallFit.prior);
-    const priorLines = new Set(
-        priorWithoutWorkingFiles
-            .split('\n')
-            .map((line) => line.trim())
-            .filter(Boolean),
-    );
-    const toolLines = collectToolOutcomeLines(live)
-        .filter((line) => !priorLines.has(String(line || '').trim()));
-    const workingFiles = collectWorkingFileGroups(live, undefined, {
+    const toolLines = collectToolOutcomeLines(recallHead)
+        .filter((line) => !recallFit.recall.includes(String(line || '').trim()));
+    const workingFiles = collectWorkingFileGroups(recallHead, undefined, {
         cwd: opts.cwd,
-        previousSummary: recallFit.prior,
+        previousSummary: '',
         now: Date.now(),
     });
     const conversationLines = excludeTailFromConversation(
         conversationLinesFromMemoryText(recallFit.recall),
         recallTail,
-    ).filter((line) => !priorLines.has(String(line || '').trim()));
+    );
     const composedRecall = composeRecallHandoff({
         sessionId: opts.sessionId || '',
         conversationLines,
         toolLines,
         workingFiles,
     });
-    const priorRoom = priorWithoutWorkingFiles
-        ? Math.max(256, Math.floor((recallRoom - 200) * 0.55))
-        : 0;
-    const currentRoom = Math.max(256, recallRoom - priorRoom - 200);
+    const currentRoom = Math.max(256, recallRoom - 200);
     const fittedRecall = fitRecallHandoffText(composedRecall, currentRoom);
-    const priorPart = priorWithoutWorkingFiles
-        ? fitRecallHandoffText(priorWithoutWorkingFiles, priorRoom)
-        : '';
     const summaryMessage = fitRecallFastTrackSummaryMessage(
         oldHistory,
         fittedRecall,
         recallRoom,
         recallMeta,
-        priorPart,
+        '',
     );
     if (!summaryMessage) {
         throw new Error(`recallFastTrackCompactMessages: summary cannot fit remaining budget=${recallRoom}`);
@@ -929,18 +914,18 @@ function _recallFastTrackCompactMessages(messages, budgetTokens, opts = {}) {
         recallRoom,
         recallChars: recallFit.recall.length,
         recallBytes: textByteLength(recallFit.recall),
-        priorChars: recallFit.prior.length,
-        priorBytes: textByteLength(recallFit.prior),
+        priorChars: 0,
+        priorBytes: 0,
         summaryMessageChars: summaryContent.length,
         summaryMessageBytes: textByteLength(summaryContent),
         recallEmpty: !recallFit.recall,
         priorEmpty: !recallFit.prior,
         recallTruncatedInSummary: !!recallFit.recall && !summaryContent.includes(recallFit.recall),
-        priorTruncatedInSummary: !!priorPart && !summaryContent.includes(priorPart),
+        priorTruncatedInSummary: false,
         tailTruncated: recallTail.some((m) => messageContentHasMarker(m, RECALL_TAIL_TRUNCATION_MARKER) || messageContentHasMarker(m, RECALL_TAIL_SHORT_TRUNCATION_MARKER)),
         fileReattached: reattach.reattached,
         tailOptions: recallTailOpts,
-        previousSummary: !!previousSummary,
+        previousSummary: false,
         durationMs: Date.now() - startedAt,
     };
     compactDebugLog('recall-fasttrack result', diagnostics);

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

@@ -19,43 +19,11 @@ import {
     compactDebugLog,
 } from './compact-debug.mjs';
 import { positiveTokenInt } from './env.mjs';
-import { TOOL_OUTPUT_MAX_BYTES } from '../../tools/builtin/tool-output-limit.mjs';
 
 // ── Digest injection ────────────────────────────────────────────────────────
-// Inject a small newest-first digest plus an instruction telling the model to
-// pull details lazily via recall(sessionId/query/period). The memory DB holds
-// the full session (ingest_session below), and raw rows are embedded
-// synchronously at ingest, so recall serves everything the old full-dump
-// injection used to carry.
-// Default digest cap = the SHARED tool-output limit (TOOL_OUTPUT_MAX_BYTES,
-// 50KB default, env MIXDOG_TOOL_OUTPUT_MAX_BYTES) — the digest injection is
-// budgeted like any other tool result, not a special context share.
-// compaction.recallDigestMaxKb still overrides per-session.
-export const DIGEST_DEFAULT_MAX_KB = Math.max(1, Math.floor(TOOL_OUTPUT_MAX_BYTES / 1024));
-
-// Byte-capped line-boundary truncation. Digest source is newest-first, so
-// keeping the HEAD keeps the newest turns.
-// Exported for manager/compaction-runner.mjs (manual//clear digest path) so
-// both digest producers share one cap implementation.
-export function truncateToKb(text, maxKb) {
-    const maxBytes = Math.max(1, maxKb) * 1024;
-    const s = String(text || '');
-    if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;
-    const lines = s.split('\n');
-    const marker = '[digest truncated at ' + maxKb + 'KB]';
-    const contentBudget = maxBytes - Buffer.byteLength(marker, 'utf8');
-    const out = [];
-    let used = 0;
-    for (const line of lines) {
-        const cost = Buffer.byteLength(line, 'utf8') + 1;
-        if (used + cost > contentBudget) break;
-        out.push(line);
-        used += cost;
-    }
-    return out.length ? out.join('\n') + '\n' + marker : marker;
-}
-
-function buildRecallDigestText(sessionId, digestBody, maxKb) {
+// Memory provides every available summary/raw row. Only the final compaction
+// budget is allowed to reduce the handoff.
+function buildRecallDigestText(sessionId, digestBody) {
     // No recall-usage instruction block here: the recall tool description
     // already carries the usage-pattern cheatsheet (tool-defs.mjs), so
     // repeating it per-compaction would be redundant injected tokens. The
@@ -64,7 +32,7 @@ function buildRecallDigestText(sessionId, digestBody, maxKb) {
     return [
         `[context compacted — session ${sessionId}]`,
         `Recent digest (newest first):`,
-        truncateToKb(digestBody, maxKb),
+        String(digestBody || '').trim(),
     ].join('\n');
 }
 
@@ -88,7 +56,17 @@ export function isUsableRecallDigestText(value) {
     return !!trimmed && !/^\((?:no results|no current session)\)$/i.test(trimmed);
 }
 
-export async function runRecallFastTrackCompact({ sessionRef, messages, compactBudgetTokens, compactPolicy, sessionId, signal }) {
+export const RECALL_FAST_TRACK_TAIL_TURNS = 5;
+
+export async function runRecallFastTrackCompact({
+    sessionRef,
+    messages,
+    compactBudgetTokens,
+    compactPolicy,
+    sessionId,
+    signal,
+    executeMemorySearch,
+}) {
     if (!sessionId) throw new Error('recall-fasttrack requires a session id');
     const startedAt = Date.now();
     const diagnostics = {
@@ -126,14 +104,15 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
     // watcher already persisted. Do not retransmit the live transcript through
     // the memory RPC: that duplicates canonical history and can exceed the
     // bounded HTTP request body before compaction gets a chance to run.
-    const digestMaxKb = positiveTokenInt(sessionRef?.compaction?.recallDigestMaxKb) || DIGEST_DEFAULT_MAX_KB;
     let digestBody = '';
     t0 = Date.now();
     try {
-        const browsed = await executeInternalTool('memory', {
+        const searchMemory = typeof executeMemorySearch === 'function'
+            ? executeMemorySearch
+            : (args, ctx) => executeInternalTool('memory', args, ctx);
+        const browsed = await searchMemory({
             action: 'search',
             sessionId,
-            limit: positiveTokenInt(sessionRef?.compaction?.recallDigestLimit) || 100,
             includeMembers: true,
             includeRaw: true,
             compactHandoff: true,
@@ -171,7 +150,7 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
         try { process.stderr.write(`[loop] recall-fasttrack fail-safe abort (sess=${sessionId || 'unknown'}): stored session unavailable — keeping full history, no recall notice injected\n`); } catch {}
         throw new Error(`recall-fasttrack aborted: stored session memory unavailable; head preserved`);
     }
-    const digestText = buildRecallDigestText(sessionId, digestBody, digestMaxKb);
+    const digestText = buildRecallDigestText(sessionId, digestBody);
     diagnostics.finalRecallChars = digestText.length;
     diagnostics.finalRecallBytes = compactByteLength(digestText);
     const contextWindow = positiveTokenInt(compactPolicy?.contextWindow)
@@ -192,7 +171,7 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
         // Empty/sentinel browse output was rejected above, so the handoff always
         // contains real stored session context.
         allowEmptyRecall: false,
-        tailTurns: compactPolicy.tailTurns,
+        tailTurns: RECALL_FAST_TRACK_TAIL_TURNS,
         keepTokens: compactPolicy.keepTokens,
         preserveRecentTokens: compactPolicy.preserveRecentTokens,
         recallTokenCap,

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -6,22 +6,17 @@
 import { createHash } from 'crypto';
 import { getProvider } from '../../providers/registry.mjs';
 import {
-    recallFastTrackCompactMessages,
     semanticCompactMessages,
     pruneToolOutputsUnanchored,
     effectiveBudget as compactEffectiveBudget,
     compactTypeIsRecallFastTrack,
     compactTypeIsSemantic,
     normalizeCompactType,
-    CONTEXT_SHARE_RATIO,
-    RECALL_TOKEN_CAP_FLOOR_TOKENS,
 } from '../compact.mjs';
 import { estimateMessagesTokens, estimateRequestReserveTokens, estimateTranscriptContextUsage, resolveCompactBufferRatio } from '../context-utils.mjs';
 import { executeInternalTool } from '../../internal-tools.mjs';
 import {
-    truncateToKb,
-    DIGEST_DEFAULT_MAX_KB,
-    isUsableRecallDigestText,
+    runRecallFastTrackCompact,
 } from '../loop/recall-fasttrack.mjs';
 import {
     positiveContextWindow,
@@ -159,58 +154,6 @@ async function callMemoryBounded(args, callerCtx, timeoutMs, executeMemory = exe
         try { outer?.removeEventListener?.('abort', onOuterAbort); } catch {}
     }
 }
-async function runRecallFastTrackForSession(session, sessionId, opts = {}) {
-    if (!sessionId) throw new Error('recall-fasttrack requires a session id');
-    const query = `session:${sessionId}:all-chunks`;
-    const querySha = createHash('sha256').update(query).digest('hex').slice(0, 16);
-    const callerCtx = {
-        callerSessionId: sessionId,
-        callerCwd: session?.cwd || undefined,
-        routingSessionId: sessionId,
-        clientHostPid: session?.clientHostPid,
-        signal: opts.signal || null,
-    };
-    const memoryTimeoutMs = recallMemoryTimeoutMs(session);
-    const executeMemory = typeof opts.executeInternalToolFn === 'function'
-        ? opts.executeInternalToolFn
-        : executeInternalTool;
-    // The transcript watcher already persists this session incrementally.
-    // Manual/clear compaction reads those rows directly instead of sending the
-    // entire live message array through the memory RPC again.
-    let recallText = '';
-    try {
-        const browsed = await callMemoryColdStart({
-            action: 'search',
-            sessionId,
-            limit: positiveContextWindow(session?.compaction?.recallDigestLimit) || 100,
-            includeMembers: true,
-            includeRaw: true,
-            compactHandoff: true,
-        }, callerCtx, memoryTimeoutMs, executeMemory);
-        recallText = typeof browsed === 'string' ? browsed : String(browsed?.text ?? browsed ?? '');
-        if (!isUsableRecallDigestText(recallText)) {
-            throw new Error('memory has no stored history for this session');
-        }
-    } catch (err) {
-        // Without real stored context we cannot safely replace the live head.
-        // Bail to the semantic fallback rather than injecting a false recall
-        // handoff.
-        try { process.stderr.write(`[session] recall-digest browse failed — bailing (sess=${sessionId}): ${err?.message || err}\n`); } catch {}
-        throw new Error(`recall-fasttrack search failed: ${err?.message || err}`);
-    }
-    return {
-        query,
-        querySha,
-        recallText: [
-            `session_id=${sessionId}`,
-            // Same byte cap as the loop digest path (recallDigestMaxKb,
-            // default = shared tool-output limit) — without it the memory
-            // renderer bounds the browse at ~200 rows × 1000 chars, letting a
-            // manual//clear compact process a far larger digest than loop's.
-            truncateToKb(recallText, positiveContextWindow(session?.compaction?.recallDigestMaxKb) || DIGEST_DEFAULT_MAX_KB),
-        ].map(v => String(v || '').trim()).filter(Boolean).join('\n\n'),
-    };
-}
 // Element-identity change detection (same approach as loop.mjs messagesArrayChanged): two
 // arrays are "unchanged" only when same length AND every slot is the same object
 // reference. Used to reject a no-op prune (which returns a fresh array whose
@@ -307,27 +250,27 @@ export async function runSessionCompaction(session, opts = {}) {
     let recallFastTrackError = null;
     if (compactTypeIsRecallFastTrack(compactType)) {
         try {
-            const recallPayload = await runRecallFastTrackForSession(session, resolvedSessionId, opts);
             const contextWindow = positiveContextWindow(session.contextWindow) || boundary;
-            const recallTokenCap = Math.max(
-                RECALL_TOKEN_CAP_FLOOR_TOKENS,
-                Math.floor(contextWindow * CONTEXT_SHARE_RATIO),
-            );
-            recallFastTrackResult = recallFastTrackCompactMessages(messages, budget, {
-                reserveTokens,
-                force: true,
-                recallText: recallPayload.recallText,
-                query: recallPayload.query,
-                querySha: recallPayload.querySha,
-                cwd: session.cwd,
-                // The stored-memory browse above returned real session context;
-                // empty/sentinel output already threw into semantic fallback.
-                allowEmptyRecall: false,
-                tailTurns: positiveContextWindow(session.compaction?.tailTurns) || 1,
-                keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens),
-                preserveRecentTokens: positiveContextWindow(session.compaction?.preserveRecentTokens),
-                recallTokenCap,
+            const memoryTimeoutMs = recallMemoryTimeoutMs(session);
+            const executeMemory = typeof opts.executeInternalToolFn === 'function'
+                ? opts.executeInternalToolFn
+                : executeInternalTool;
+            recallFastTrackResult = await runRecallFastTrackCompact({
+                sessionRef: session,
+                messages,
+                compactBudgetTokens: budget,
+                compactPolicy: {
+                    reserveTokens,
+                    contextWindow,
+                    boundaryTokens: boundary,
+                    keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens),
+                    preserveRecentTokens: positiveContextWindow(session.compaction?.preserveRecentTokens),
+                },
                 sessionId: resolvedSessionId,
+                signal: opts.signal || null,
+                executeMemorySearch: (args, callerCtx) => (
+                    callMemoryColdStart(args, callerCtx, memoryTimeoutMs, executeMemory)
+                ),
             });
             if (Array.isArray(recallFastTrackResult?.messages)) {
                 compacted = recallFastTrackResult.messages;
@@ -338,54 +281,6 @@ export async function runSessionCompaction(session, opts = {}) {
             try {
                 process.stderr.write(`[session] recall-fasttrack ${mode} compact failed (sess=${session.id || 'unknown'}): ${err?.message || err}\n`);
             } catch { /* best-effort */ }
-            // Degraded-compact fallback: recall-fasttrack failed (empty recall,
-            // ingest error, fit failure). Before recording a hard failure, try
-            // the semantic path once so auto-clear/manual compaction still makes
-            // progress WITHOUT shipping an empty-recall summary. History is only
-            // replaced when the semantic summary actually succeeds.
-            if (semanticCompactionEnabledForSession(session)
-                && provider && typeof provider.send === 'function') {
-                try {
-                    semanticCompactResult = await semanticCompactMessages(
-                        provider,
-                        messages,
-                        opts.model || resolveSemanticSummaryModel(session, { budgetTokens: budget }) || session.model,
-                        budget,
-                        {
-                            reserveTokens,
-                            providerName: session.provider || provider?.name || null,
-                            sessionId: resolvedSessionId,
-                            cwd: session.cwd,
-                            signal: opts.signal || null,
-                            // Carries the session's wire identity so the
-                            // summary request stays on the session's own
-                            // prefix-cache slot instead of opening a second one.
-                            sendOpts: { session },
-                            promptCacheKey: session.promptCacheKey || null,
-                            providerCacheKey: session.promptCacheKey || null,
-                            timeoutMs: semanticCompactTimeoutMs(session, beforeMessageTokens),
-                            tailTurns: positiveContextWindow(session.compaction?.tailTurns) || 2,
-                            keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens),
-                            preserveRecentTokens: positiveContextWindow(session.compaction?.preserveRecentTokens),
-                            filterOldHistoryForIngest: opts.filterOldHistoryForIngest === true,
-                            force: true,
-                        },
-                    );
-                    if (Array.isArray(semanticCompactResult?.messages)) {
-                        compacted = semanticCompactResult.messages;
-                        compactError = null;
-                        addCompactUsageToSession(session, semanticCompactResult.usage);
-                        try {
-                            process.stderr.write(`[session] degraded compact: recall-fasttrack failed, semantic fallback succeeded (sess=${session.id || 'unknown'}, mode=${mode})\n`);
-                        } catch { /* best-effort */ }
-                    }
-                } catch (fallbackErr) {
-                    semanticCompactError = fallbackErr;
-                    try {
-                        process.stderr.write(`[session] degraded compact: semantic fallback also failed (sess=${session.id || 'unknown'}): ${fallbackErr?.message || fallbackErr}\n`);
-                    } catch { /* best-effort */ }
-                }
-            }
         }
     } else if (compactTypeIsSemantic(compactType)) {
         try {