mixdog 0.9.45 → 0.9.47

package/scripts/agent-trace-io-test.mjs

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -11,7 +11,8 @@ const traceModuleUrl = pathToFileURL(join(root, 'src/runtime/agent/orchestrator/
 
 test('drainAgentTrace awaits delayed local JSONL append without a memory service', () => {
   const dir = mkdtempSync(join(tmpdir(), 'mixdog-agent-trace-io-test-'));
-  const tracePath = join(dir, 'agent-trace.jsonl');
+  const traceParent = join(dir, 'nested');
+  const tracePath = join(traceParent, 'history', 'agent-trace.jsonl');
   const loaderPath = join(dir, 'loader.mjs');
   const delayedFsPath = join(dir, 'delayed-fs-promises.mjs');
   try {
@@ -36,9 +37,10 @@ test('drainAgentTrace awaits delayed local JSONL append without a memory service
       '--input-type=module',
       '-e',
       `
-        import { readFileSync } from 'node:fs';
+        import { readFileSync, rmSync } from 'node:fs';
         import { appendAgentTrace, drainAgentTrace } from ${JSON.stringify(traceModuleUrl)};
         appendAgentTrace({ kind: 'delayed-local-test', session_id: 'sess_delayed' });
+        rmSync(process.env.TRACE_PARENT, { recursive: true, force: true });
         const started = Date.now();
         await drainAgentTrace();
         const rows = readFileSync(process.env.MIXDOG_AGENT_TRACE_PATH, 'utf8').trim().split(/\\r?\\n/).map(JSON.parse);
@@ -52,6 +54,7 @@ test('drainAgentTrace awaits delayed local JSONL append without a memory service
         MIXDOG_AGENT_TRACE_DISABLE: '',
         MIXDOG_AGENT_TRACE_LOCAL_DISABLE: '',
         MIXDOG_RUNTIME_ROOT: join(dir, 'no-service'),
+        TRACE_PARENT: traceParent,
         TRACE_APPEND_DELAY_MS: '75',
       },
       timeout: 5000,
@@ -67,3 +70,64 @@ test('drainAgentTrace awaits delayed local JSONL append without a memory service
     rmSync(dir, { recursive: true, force: true });
   }
 });
+
+test('explicit trace path stays append-only across concurrent writers', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'mixdog-agent-trace-multiwriter-test-'));
+  const tracePath = join(dir, 'agent-trace.jsonl');
+  const writerCount = 4;
+  const rowsPerWriter = 20;
+  try {
+    // Start above the normal rotation threshold. An explicit shared sink must
+    // retain this row in the live file while every child appends to it.
+    writeFileSync(tracePath, `${JSON.stringify({
+      kind: 'multiwriter-seed',
+      session_id: 'sess_seed',
+      payload: 'x'.repeat(10 * 1024 * 1024),
+    })}\n`);
+    const childSource = `
+      import { appendAgentTrace, drainAgentTrace } from ${JSON.stringify(traceModuleUrl)};
+      for (let i = 0; i < Number(process.env.ROWS_PER_WRITER); i += 1) {
+        appendAgentTrace({
+          kind: 'multiwriter',
+          session_id: 'sess_writer_' + process.env.WRITER_ID,
+          payload: { writer: Number(process.env.WRITER_ID), index: i },
+        });
+      }
+      await drainAgentTrace();
+    `;
+    await Promise.all(Array.from({ length: writerCount }, (_, writer) => new Promise((resolveChild, rejectChild) => {
+      const child = spawn(process.execPath, ['--input-type=module', '-e', childSource], {
+        cwd: root,
+        env: {
+          ...process.env,
+          MIXDOG_AGENT_TRACE_PATH: tracePath,
+          MIXDOG_AGENT_TRACE_DISABLE: '',
+          MIXDOG_AGENT_TRACE_LOCAL_DISABLE: '',
+          MIXDOG_RUNTIME_ROOT: join(dir, `no-service-${writer}`),
+          ROWS_PER_WRITER: String(rowsPerWriter),
+          WRITER_ID: String(writer),
+        },
+        stdio: ['ignore', 'ignore', 'pipe'],
+      });
+      let stderr = '';
+      child.stderr.setEncoding('utf8');
+      child.stderr.on('data', (chunk) => { stderr += chunk; });
+      child.on('error', rejectChild);
+      child.on('exit', (code) => {
+        if (code === 0) resolveChild();
+        else rejectChild(new Error(`writer ${writer} exited ${code}: ${stderr}`));
+      });
+    })));
+    assert.equal(existsSync(`${tracePath}.1`), false);
+    const rows = readFileSync(tracePath, 'utf8').trim().split(/\r?\n/).map(JSON.parse);
+    assert.equal(rows[0].kind, 'multiwriter-seed');
+    const written = rows.filter((row) => row.kind === 'multiwriter');
+    assert.equal(written.length, writerCount * rowsPerWriter);
+    assert.deepEqual(
+      [...new Set(written.map((row) => row.session_id))].sort(),
+      Array.from({ length: writerCount }, (_, writer) => `sess_writer_${writer}`),
+    );
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/scripts/bench-run.mjs

@@ -18,9 +18,10 @@
 // vs codex/claude (tree-total vs solo) is a separate future mode; codex/claude
 // runners are left as slots.
 import { execFile, execFileSync, spawn } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { dirname, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 
 const __dir = dirname(fileURLToPath(import.meta.url));
 const HEADLESS = pathToFileURL(resolve(__dir, '../src/headless-role.mjs')).href;
@@ -160,6 +161,11 @@ const RUNNERS = {
     return { sessionId: extractSessionId(raw), ok, ms: Date.now() - started, raw };
   },
   async mixdog(task, opts) {
+    if (!opts.provider || !opts.model) {
+      throw new Error(
+        'mixdog headless runner requires explicit --provider and --model (or a model alias)',
+      );
+    }
     const driver = [
       `import { runHeadlessRole } from ${JSON.stringify(HEADLESS)};`,
       `const out = [];`,
@@ -302,6 +308,9 @@ function num(v) {
 // only harness-neutral metric. Unknown models fall back to gpt-5.5 rates.
 const USD_PER_1M = {
   'gpt-5.5': { in: 5.00, cachedIn: 0.50, out: 30.00 },
+  'gpt-5.6-sol': { in: 5.00, cachedIn: 0.50, out: 30.00 },
+  'gpt-5.6-terra': { in: 2.50, cachedIn: 0.25, out: 15.00 },
+  'gpt-5.6-luna': { in: 1.00, cachedIn: 0.10, out: 6.00 },
   'claude-sonnet-5': { in: 2.00, cachedIn: 0.20, out: 10.00 },
   'claude-fable-5': { in: 5.00, cachedIn: 0.50, out: 25.00 },
 };
@@ -344,6 +353,13 @@ const _mo = resolveModelOpts(argValue('--model', null), argValue('--provider', n
 // A/B knobs -> child env. --read-max-lines is a convenience for the read-policy
 // bench; --env KEY=VAL (repeatable) passes any override verbatim.
 const _env = {};
+let ownedBenchTraceDir = null;
+function cleanupOwnedBenchTrace() {
+  if (!ownedBenchTraceDir) return;
+  const dir = ownedBenchTraceDir;
+  ownedBenchTraceDir = null;
+  rmSync(dir, { recursive: true, force: true });
+}
 const _readMax = argValue('--read-max-lines', null);
 if (_readMax) _env.MIXDOG_READ_MAX_LINES = String(_readMax);
 for (let i = 0; i < process.argv.length; i++) {
@@ -352,6 +368,15 @@ for (let i = 0; i < process.argv.length; i++) {
     if (eq > 0) _env[process.argv[i + 1].slice(0, eq)] = process.argv[i + 1].slice(eq + 1);
   }
 }
+if (runnerName === 'mixdog' && !_env.MIXDOG_AGENT_TRACE_PATH) {
+  if (process.env.MIXDOG_AGENT_TRACE_PATH) {
+    _env.MIXDOG_AGENT_TRACE_PATH = process.env.MIXDOG_AGENT_TRACE_PATH;
+  } else {
+    ownedBenchTraceDir = mkdtempSync(join(tmpdir(), 'mixdog-bench-trace-'));
+    _env.MIXDOG_AGENT_TRACE_PATH = join(ownedBenchTraceDir, 'agent-trace.jsonl');
+    process.once('exit', cleanupOwnedBenchTrace);
+  }
+}
 const opts = {
   provider: _mo.provider,
   model: _mo.model,
@@ -478,4 +503,6 @@ if (jsonMode) {
     console.log(`group: wall=${Math.round((g.wall_ms || 0) / 1000)}s turns=${g.turns} tools=${g.tool_calls} tpt=${g.tools_per_turn} tool_ms=${Math.round((g.total_tool_ms || 0) / 1000)}s cache=${Math.round((g.cache_ratio || 0) * 100)}% antipatterns=${g.antipatterns}`);
   }
 }
-if (roundResult.task_complete === false || roundResult.score_complete === false) process.exit(1);
+const incomplete = roundResult.task_complete === false || roundResult.score_complete === false;
+cleanupOwnedBenchTrace();
+if (incomplete) process.exit(1);

package/scripts/compact-pressure-test.mjs

@@ -14,18 +14,23 @@ import {
     recordProviderContextBaseline,
     resolveCompactionPressureTokens,
     rememberCompactTelemetry,
+    compactTargetBudget,
     resolveWorkerCompactPolicy,
     shouldCompactForSession,
 } from '../src/runtime/agent/orchestrator/session/loop/compact-policy.mjs';
+import { initialCompactionConfig } from '../src/runtime/agent/orchestrator/session/manager/session-lifecycle.mjs';
+import { resolveSessionCompactionPolicy } from '../src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs';
+import { sendWithRecovery } from '../src/runtime/agent/orchestrator/session/send-with-recovery.mjs';
 
 function policyFor(session) {
     return resolveWorkerCompactPolicy(session, []);
 }
 
-test('Lead/main auto-compaction triggers at 95% of the effective boundary', () => {
+test('Lead/main auto-compaction uses an independent configurable early buffer', () => {
     const leadPolicy = policyFor({ contextWindow: 100_000, compaction: {} });
     assert.equal(leadPolicy.triggerTokens, 95_000);
     assert.equal(leadPolicy.bufferTokens, 5_000);
+    assert.equal(leadPolicy.bufferRatio, 0.05);
 
     const noReserve = { ...leadPolicy, reserveTokens: 0 };
     assert.equal(shouldCompactForSession(94_999, noReserve), false);
@@ -33,6 +38,182 @@ test('Lead/main auto-compaction triggers at 95% of the effective boundary', () =
 
     const agentPolicy = policyFor({ owner: 'agent', contextWindow: 100_000, compaction: {} });
     assert.equal(agentPolicy.triggerTokens, 90_000, 'agent default 10% headroom must remain unchanged');
+    assert.equal(agentPolicy.bufferTokens, 10_000);
+    assert.equal(agentPolicy.bufferRatio, 0.1);
+
+    const configured = policyFor({ contextWindow: 100_000, compaction: { mainBufferPercent: 15 } });
+    assert.equal(configured.triggerTokens, 85_000);
+    assert.equal(configured.bufferTokens, 15_000);
+    assert.equal(configured.bufferRatio, 0.15);
+
+    const oldEnv = {
+        tokens: process.env.MIXDOG_MAIN_COMPACT_BUFFER_TOKENS,
+        percent: process.env.MIXDOG_MAIN_COMPACT_BUFFER_PERCENT,
+        ratio: process.env.MIXDOG_MAIN_COMPACT_BUFFER_RATIO,
+    };
+    try {
+        process.env.MIXDOG_MAIN_COMPACT_BUFFER_PERCENT = '20';
+        const envConfigured = policyFor({ contextWindow: 100_000, compaction: {} });
+        assert.equal(envConfigured.triggerTokens, 80_000);
+        assert.equal(envConfigured.bufferTokens, 20_000);
+        assert.equal(envConfigured.bufferRatio, 0.2);
+
+        delete process.env.MIXDOG_MAIN_COMPACT_BUFFER_PERCENT;
+        process.env.MIXDOG_MAIN_COMPACT_BUFFER_RATIO = '0.1';
+        const envRatioConfigured = policyFor({ contextWindow: 100_000, compaction: {} });
+        assert.equal(envRatioConfigured.bufferTokens, 10_000, 'env ratio must configure the main buffer');
+
+        process.env.MIXDOG_MAIN_COMPACT_BUFFER_TOKENS = '10000';
+        process.env.MIXDOG_MAIN_COMPACT_BUFFER_RATIO = '0.1';
+        const envTokenConfigured = policyFor({ contextWindow: 100_000, compaction: {} });
+        assert.equal(envTokenConfigured.bufferTokens, 10_000, 'env tokens must beat env percent/ratio');
+        assert.equal(envTokenConfigured.triggerTokens, 90_000);
+
+        const configBeatsEnv = policyFor({
+            contextWindow: 100_000,
+            compaction: { mainBufferRatio: 0.15 },
+        });
+        assert.equal(configBeatsEnv.bufferTokens, 15_000, 'config ratio must beat all env units');
+
+        const configTokenWins = policyFor({
+            contextWindow: 100_000,
+            compaction: { mainBufferTokens: 12_000, mainBufferPercent: 15, mainBufferRatio: 0.1 },
+        });
+        assert.equal(configTokenWins.bufferTokens, 12_000, 'config tokens must beat config percent/ratio');
+
+        const clamped = policyFor({
+            contextWindow: 100_000,
+            compaction: { mainBufferPercent: 250, mainBufferRatio: 0.1 },
+        });
+        assert.equal(clamped.bufferTokens, 25_000, 'buffer percent must cap at the configured 25% maximum');
+    } finally {
+        for (const [name, value] of Object.entries({
+            MIXDOG_MAIN_COMPACT_BUFFER_TOKENS: oldEnv.tokens,
+            MIXDOG_MAIN_COMPACT_BUFFER_PERCENT: oldEnv.percent,
+            MIXDOG_MAIN_COMPACT_BUFFER_RATIO: oldEnv.ratio,
+        })) {
+            if (value === undefined) delete process.env[name];
+            else process.env[name] = value;
+        }
+    }
+});
+
+test('fresh session compaction config preserves main buffer fields', () => {
+    const config = initialCompactionConfig({
+        mainBufferTokens: 12_000,
+        mainBufferPercent: 15,
+        mainBufferRatio: 0.2,
+        mainBufferFraction: 0.1,
+    }, { compactBoundaryTokens: 80_000 });
+    assert.equal(config.mainBufferTokens, 12_000);
+    assert.equal(config.mainBufferPercent, 15);
+    assert.equal(config.mainBufferRatio, 0.2);
+    assert.equal(config.mainBufferFraction, 0.1);
+    assert.equal(config.boundaryTokens, 80_000);
+});
+
+test('small main boundary leaves a margin above the post-compact target', () => {
+    const session = {
+        contextWindow: 8_000,
+        compaction: { reservedTokens: 2_000 },
+        tools: [],
+        messages: [],
+    };
+    const policy = policyFor(session);
+    const target = compactTargetBudget(policy);
+    assert.ok(policy.triggerTokens > target,
+        `trigger ${policy.triggerTokens} must exceed post-compact target ${target}`);
+    assert.equal(shouldCompactForSession(target - policy.reserveTokens, policy), false,
+        'reaching the post-compact target must not immediately re-trigger compaction');
+    const { contextStatus } = createContextStatus({
+        getSession: () => session,
+        getRoute: () => ({ provider: 'openai', model: 'test-model' }),
+        getCurrentCwd: () => '',
+        getMode: () => 'default',
+    });
+    const statusCompact = contextStatus().compaction;
+    assert.equal(statusCompact.triggerTokens, policy.triggerTokens);
+    assert.equal(statusCompact.bufferTokens, policy.bufferTokens);
+    assert.equal(statusCompact.bufferRatio, policy.bufferRatio);
+    const manualPolicy = resolveSessionCompactionPolicy(session);
+    assert.equal(manualPolicy.triggerTokens, policy.triggerTokens);
+    assert.equal(compactTargetBudget(manualPolicy), target);
+});
+
+test('degenerate main budgets use a documented single-shot fallback', () => {
+    const reserveAtTrigger = {
+        contextWindow: 100_000,
+        // Explicit sub-boundary limit fixes the trigger at 90k while reserve
+        // remains below the context boundary.
+        autoCompactTokenLimit: 90_000,
+        compaction: { reservedTokens: 91_000 },
+        tools: [],
+    };
+    const reserveAtTriggerPolicy = policyFor(reserveAtTrigger);
+    assert.equal(reserveAtTriggerPolicy.singleShot, true,
+        'reserve at/above the actual trigger must be single-shot even below the boundary');
+    assert.equal(compactTargetBudget(reserveAtTriggerPolicy), reserveAtTriggerPolicy.boundaryTokens,
+        'automatic single-shot keeps the legacy target budget');
+    assert.equal(compactTargetBudget({ ...reserveAtTriggerPolicy, force: true }), reserveAtTriggerPolicy.boundaryTokens,
+        'forced manual compaction must retain the viable legacy target budget');
+
+    const overReserved = {
+        contextWindow: 8_000,
+        compaction: { reservedTokens: 20_000 },
+        tools: [],
+    };
+    const overReservedPolicy = policyFor(overReserved);
+    assert.equal(overReservedPolicy.singleShot, true);
+    assert.equal(compactTargetBudget(overReservedPolicy), 8_000,
+        'reserve at or above the boundary must retain the legacy bounded target');
+    assert.equal(shouldCompactForSession(0, overReservedPolicy, { sessionRef: overReserved }), true);
+    rememberCompactTelemetry(overReserved, overReservedPolicy, { stage: 'compacting' });
+    assert.equal(shouldCompactForSession(0, overReservedPolicy, { sessionRef: overReserved }), false,
+        'single-shot fallback must suppress automatic repeats');
+
+    const oneToken = { contextWindow: 1, compaction: {}, tools: [] };
+    const oneTokenPolicy = policyFor(oneToken);
+    assert.ok(oneTokenPolicy.reserveTokens >= oneTokenPolicy.triggerTokens);
+    assert.equal(oneTokenPolicy.singleShot, true,
+        'the request reserve, not the one-token boundary itself, makes this degenerate');
+    assert.equal(oneTokenPolicy.triggerTokens, 1);
+    assert.equal(compactTargetBudget(oneTokenPolicy), 1);
+
+    // The reactive retry is explicitly bounded by send-with-recovery's
+    // contextOverflowRetryUsed flag: forceReactive may admit this one retry
+    // after the consumed one-shot, but no second retry is scheduled.
+    assert.equal(shouldCompactForSession(0, reserveAtTriggerPolicy, {
+        sessionRef: { compaction: { singleShotConsumed: true } },
+        forceReactive: true,
+    }), true, 'the one bounded reactive retry remains available after one-shot consumption');
+});
+
+test('a one-shot overflow receives only one reactive compact retry', async () => {
+    const overflow = new Error('context length exceeded');
+    const ctx = {
+        provider: { send: async () => { throw overflow; } },
+        messages: [{ role: 'user', content: 'overflowing prompt' }],
+        model: 'test-model',
+        sendTools: [],
+        tools: [],
+        opts: {},
+        sessionId: 'single-shot-reactive-test',
+        sessionRef: {
+            contextWindow: 100_000,
+            autoCompactTokenLimit: 90_000,
+            compaction: { reservedTokens: 91_000 },
+        },
+        nextIteration: 1,
+    };
+    assert.deepEqual(await sendWithRecovery({
+        ...ctx,
+        contextOverflowRetryUsed: false,
+    }), { action: 'retry' });
+    await assert.rejects(
+        sendWithRecovery({ ...ctx, contextOverflowRetryUsed: true }),
+        err => err?.code === 'AGENT_CONTEXT_OVERFLOW',
+        'a second overflow after the reactive compact must surface instead of retrying again',
+    );
 });
 
 test('image payload bytes do not inflate live gauge or fallback compaction estimates', () => {
@@ -82,8 +263,10 @@ test('image payload bytes do not inflate live gauge or fallback compaction estim
         `image-aware live gauge must remain below compaction threshold, got ${status.usedTokens}`);
     assert.ok(status.usedTokens < status.contextWindow,
         `raw base64 must not pin the live gauge at 100%, got ${status.usedTokens}/${status.contextWindow}`);
+    assert.equal(status.compaction.bufferRatio, 0.05,
+        'context status buffer ratio must match the shared compaction policy');
 
-    recordProviderContextBaseline(session, messages, { inputTokens: 80_000, outputTokens: 0 });
+    recordProviderContextBaseline(session, messages, { inputTokens: 70_000, outputTokens: 0 });
     const policy = { ...policyFor(session), reserveTokens: 0 };
     assert.equal(
         shouldCompactForSession(fallbackEstimate, policy, { messages, sessionRef: session }),
@@ -329,7 +512,7 @@ test('thinking-only continuation without assistant replay excludes provider outp
     recordProviderContextBaseline(session, messages, {
         inputTokens: 5_000,
         outputTokens: 2_000,
-        cachedTokens: 88_000,
+        cachedTokens: 68_000,
         cacheWriteTokens: 1_000,
     }, { boundary: 'request' });
     const nudge = {
@@ -340,7 +523,7 @@ test('thinking-only continuation without assistant replay excludes provider outp
 
     const wholeEstimate = estimateMessagesTokens(messages);
     const pressure = compactionTelemetryPressureTokens(wholeEstimate, policy, { messages, sessionRef: session });
-    const expectedPressure = 94_000 + estimateMessagesTokens([nudge]);
+    const expectedPressure = 74_000 + estimateMessagesTokens([nudge]);
     assert.equal(pressure, expectedPressure, 'unreplayed output must be removed while the later nudge is estimated');
     assert.equal(shouldCompactForSession(wholeEstimate, policy, {
         messages,

package/scripts/compact-prior-context-flatten-test.mjs

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+// Regression test for the repeated-compaction prior-context invariant: every
+// generated recall-fasttrack summary carries AT MOST ONE
+// <prior-compacted-context> wrapper (never nested/duplicated across cycles),
+// preserves each prior requirement exactly once, and keeps repeated-cycle
+// token size bounded even when the same content is re-fed every cycle.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+    formatPriorCompactedContextBlock,
+    stripPriorCompactedContextWrappers,
+    stripNestedSummaryHeaderLines,
+    fitRecallFastTrackSummaryMessage,
+    fitRecallRootsMessage,
+} from '../src/runtime/agent/orchestrator/session/compact/summary.mjs';
+
+const OPEN = '<prior-compacted-context>';
+const CLOSE = '</prior-compacted-context>';
+const countOpen = (s) => (String(s).match(/<prior-compacted-context>/g) || []).length;
+const countClose = (s) => (String(s).match(/<\/prior-compacted-context>/g) || []).length;
+const countAll = (s, needle) => (String(s).match(new RegExp(needle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')) || []).length;
+
+// A stable, non-empty compaction head so compactHeader() is deterministic.
+const OLD = [{ role: 'user', content: 'seed task' }, { role: 'assistant', content: 'ack' }];
+// Large enough budget that no fit-time truncation fires — the flattening path,
+// not the truncation path, is under test.
+const BIG = 1_000_000;
+// The engine feeds the previous summary body back as the next cycle's prior
+// after stripping the summary header lines (compact/engine.mjs splitRecallFitInputs).
+const nextPrior = (msg) => stripNestedSummaryHeaderLines(String(msg?.content || ''));
+
+test('formatPriorCompactedContextBlock wraps bare prior text exactly once', () => {
+    const out = formatPriorCompactedContextBlock('REQ-A keep files\nREQ-B run tests');
+    assert.equal(countOpen(out), 1);
+    assert.equal(countClose(out), 1);
+    assert.match(out, /REQ-A keep files/);
+    assert.match(out, /REQ-B run tests/);
+});
+
+test('formatPriorCompactedContextBlock flattens an already-wrapped prior to one wrapper', () => {
+    const alreadyWrapped = `${OPEN}\nREQ-A\nREQ-B\n${CLOSE}\n\nREQ-C`;
+    const out = formatPriorCompactedContextBlock(alreadyWrapped);
+    assert.equal(countOpen(out), 1);
+    assert.equal(countClose(out), 1);
+    for (const req of ['REQ-A', 'REQ-B', 'REQ-C']) assert.match(out, new RegExp(req));
+});
+
+test('formatPriorCompactedContextBlock flattens deeply nested wrappers to one', () => {
+    const nested = `${OPEN}\n${OPEN}\n${OPEN}\nDEEP\n${CLOSE}\nMID\n${CLOSE}\nTOP\n${CLOSE}`;
+    const out = formatPriorCompactedContextBlock(nested);
+    assert.equal(countOpen(out), 1);
+    assert.equal(countClose(out), 1);
+    for (const req of ['DEEP', 'MID', 'TOP']) assert.match(out, new RegExp(req));
+});
+
+test('formatPriorCompactedContextBlock keeps duplicate blocks exactly once', () => {
+    const dupe = 'REQ-A keep\n\nREQ-B test\n\nREQ-A keep';
+    const out = formatPriorCompactedContextBlock(dupe);
+    assert.equal(countAll(out, 'REQ-A keep'), 1);
+    assert.equal(countAll(out, 'REQ-B test'), 1);
+});
+
+test('dedupe is byte/content preserving: distinct-whitespace blocks are NOT merged', () => {
+    // `printf 'a  b'` (two spaces) and `printf 'a b'` (one space) are DISTINCT
+    // commands — collapsing whitespace for the dedupe key would wrongly merge
+    // them and silently corrupt a preserved command. Both must survive verbatim.
+    const prior = "printf 'a  b'\n\nprintf 'a b'";
+    const out = formatPriorCompactedContextBlock(prior);
+    assert.match(out, /printf 'a  b'/, 'two-space variant preserved verbatim');
+    assert.match(out, /printf 'a b'/, 'one-space variant preserved verbatim');
+    // Both distinct blocks are kept (neither is dropped as a "duplicate").
+    assert.equal(countAll(out, "printf 'a  b'"), 1);
+    // Exactly one structural wrapper around the two distinct blocks.
+    assert.equal(countOpen(out), 1);
+    assert.equal(countClose(out), 1);
+});
+
+test('dedupe removes only structurally identical blocks and preserves inner whitespace', () => {
+    // The two byte-identical `run   step` blocks collapse to one (bounded
+    // growth); a block with distinct inner whitespace is preserved untouched.
+    const prior = 'run   step\n\nrun   step\n\nkeep\tthis  spacing';
+    const out = formatPriorCompactedContextBlock(prior);
+    assert.equal(countAll(out, 'run   step'), 1, 'exact repeats collapse to one');
+    assert.match(out, /keep\tthis  spacing/, 'inner whitespace never collapsed/trimmed');
+});
+
+test('formatPriorCompactedContextBlock returns empty for blank / tag-only input', () => {
+    assert.equal(formatPriorCompactedContextBlock(''), '');
+    assert.equal(formatPriorCompactedContextBlock(`${OPEN}\n${CLOSE}`), '');
+});
+
+test('empty / blank / boundary-only prior yields ZERO wrappers (optimization-safe at-most-one)', () => {
+    // The production summary body joins only non-empty parts, so an empty prior
+    // is canonicalized to NO wrapper rather than an empty tag pair — "exactly
+    // one wrapper" is realized as one-when-content-exists, none otherwise,
+    // never more than one and never nested.
+    assert.equal(formatPriorCompactedContextBlock(''), '');
+    assert.equal(formatPriorCompactedContextBlock('   \n  \t '), '');
+    assert.equal(formatPriorCompactedContextBlock(`${OPEN}\n${CLOSE}`), '');
+    assert.equal(formatPriorCompactedContextBlock(`${OPEN}\n\n   \n${CLOSE}`), '');
+    assert.equal(formatPriorCompactedContextBlock(`${OPEN}\n${OPEN}\n${CLOSE}\n${CLOSE}`), '');
+});
+
+test('flattening preserves inline marker-like content verbatim (no P1 corruption)', () => {
+    // Regression: an earlier inline-strip regex turned "keep <prior-compacted-context>
+    // literal" into "keepliteral". Only STRUCTURAL boundary lines may be removed;
+    // inline marker-like user content must survive byte-for-byte.
+    const note = 'keep <prior-compacted-context> literal in this note';
+    const bare = stripPriorCompactedContextWrappers(`${OPEN}\n${note}\n${CLOSE}`);
+    assert.equal(bare, note);
+    assert.doesNotMatch(bare, /keepliteral/);
+});
+
+test('formatPriorCompactedContextBlock does not corrupt inline marker-like content', () => {
+    const note = 'REQ keep <prior-compacted-context> literal';
+    const out = formatPriorCompactedContextBlock(`${OPEN}\n${note}\n${CLOSE}`);
+    // Exactly one STRUCTURAL wrapper: boundary tags each appear once on their
+    // own line (the inline literal is content, not a boundary).
+    const lines = out.split('\n');
+    assert.equal(lines.filter((l) => l.trim() === OPEN).length, 1);
+    assert.equal(lines.filter((l) => l.trim() === CLOSE).length, 1);
+    assert.match(out, /REQ keep <prior-compacted-context> literal/);
+});
+
+test('stripPriorCompactedContextWrappers removes every wrapper tag', () => {
+    const bare = stripPriorCompactedContextWrappers(`${OPEN}\ninner-A\ninner-B\n${CLOSE}`);
+    assert.doesNotMatch(bare, /prior-compacted-context/);
+    assert.equal(bare, 'inner-A\ninner-B');
+});
+
+test('stripNestedSummaryHeaderLines strips the prior-compacted-context wrapper', () => {
+    const body = `${OPEN}\nREQ-A\n${CLOSE}\n\nREQ-B`;
+    const out = stripNestedSummaryHeaderLines(body);
+    assert.doesNotMatch(out, /prior-compacted-context/);
+    assert.match(out, /REQ-A/);
+    assert.match(out, /REQ-B/);
+});
+
+test('canonicalization preserves leading, trailing, and repeated newline bytes', () => {
+    const prior = '\n\nleading\n\n\nmiddle\n\ntrailing\n';
+    const out = formatPriorCompactedContextBlock(prior);
+    assert.ok(out.includes(`${OPEN}\n${prior}\n${CLOSE}`), 'wrapper keeps the prior bytes untouched');
+    assert.equal(stripNestedSummaryHeaderLines(out), prior,
+        'structural header removal does not trim or collapse surrounding bytes');
+});
+
+test('both recall fitters retain prior whitespace byte-for-byte', () => {
+    const prior = '\n  leading\n\n\ntrailing  \n';
+    const fast = fitRecallFastTrackSummaryMessage(OLD, 'recall', BIG, {}, prior);
+    const roots = fitRecallRootsMessage(OLD, '# chunk 1 root=1\nbody', BIG, {}, prior);
+    for (const message of [fast, roots]) {
+        assert.ok(String(message.content).includes(`${OPEN}\n${prior}\n${CLOSE}`));
+    }
+});
+
+test('repeated recall-fasttrack compaction keeps one prior wrapper and every req once', () => {
+    const reqs = [
+        'REQ-1 initial spec',
+        'REQ-2 second decision',
+        'REQ-3 third step',
+        'REQ-4 fourth fact',
+        'REQ-5 fifth note',
+    ];
+    let prior = '';
+    let last = '';
+    for (let i = 0; i < reqs.length; i += 1) {
+        const msg = fitRecallFastTrackSummaryMessage(OLD, reqs[i], BIG, {}, prior);
+        assert.ok(msg, `cycle ${i} produced a summary message`);
+        const body = String(msg.content || '');
+        assert.ok(countOpen(body) <= 1, `cycle ${i} has at most one open wrapper`);
+        assert.equal(countOpen(body), countClose(body), `cycle ${i} wrappers are balanced`);
+        prior = nextPrior(msg);
+        last = body;
+    }
+    for (const req of reqs) {
+        assert.equal(countAll(last, req), 1, `${req} survives into the final summary exactly once`);
+    }
+});
+
+test('repeated compaction with identical recall is byte-stable after the first canonical cycle', () => {
+    const recall = 'STABLE REQUIREMENT preserve exactly one copy';
+    let prior = '';
+    const sizes = [];
+    const serialized = [];
+    for (let i = 0; i < 8; i += 1) {
+        const msg = fitRecallFastTrackSummaryMessage(OLD, recall, BIG, {}, prior);
+        const body = String(msg.content || '');
+        assert.ok(countOpen(body) <= 1, `cycle ${i} never nests wrappers`);
+        // At most one copy inside the prior wrapper + one live recall copy.
+        assert.ok(countAll(body, 'STABLE REQUIREMENT') <= 2, `cycle ${i} keeps bounded copies`);
+        sizes.push(body.length);
+        serialized.push(body);
+        prior = nextPrior(msg);
+    }
+    const stableSizes = sizes.slice(1);
+    const stableBodies = serialized.slice(1);
+    assert.ok(stableSizes.every((size) => size === stableSizes[0]),
+        `serialized size is exactly stable after canonical cycle (sizes=${sizes.join(',')})`);
+    assert.ok(stableBodies.every((body) => body === stableBodies[0]),
+        'serialized output is exactly stable after canonical cycle');
+});
+
+test('many generated-summary refeeds add no newline bytes', () => {
+    const recall = 'NO NEWLINE GROWTH';
+    let prior = '';
+    let canonical = null;
+    for (let i = 0; i < 32; i += 1) {
+        const message = fitRecallFastTrackSummaryMessage(OLD, recall, BIG, {}, prior);
+        const body = String(message.content || '');
+        if (i === 1) canonical = body;
+        if (i > 1) assert.equal(body, canonical, `cycle ${i} must not add wrapper separator bytes`);
+        prior = nextPrior(message);
+    }
+});
+
+test('duplicate live recall never consumes prior-owned leading or trailing newlines', () => {
+    const variants = [
+        'X\n',
+        'X\n\n',
+        'X\n\n\n',
+        '\nX',
+        '\n\nX',
+        '\nX\n\n',
+    ];
+    for (const initialPrior of variants) {
+        let prior = initialPrior;
+        let canonical = null;
+        for (let i = 0; i < 32; i += 1) {
+            const message = fitRecallFastTrackSummaryMessage(OLD, 'X', BIG, {}, prior);
+            const body = String(message.content || '');
+            if (i === 0) canonical = body;
+            assert.equal(body, canonical, `variant=${JSON.stringify(initialPrior)} cycle=${i} changed bytes`);
+            prior = nextPrior(message);
+        }
+    }
+});
+
+test('smart-arrival roots compaction also flattens the re-fed prior to one wrapper', () => {
+    const roots = '# chunk 1 root=1\nmember a\n\n# chunk 2 root=2\nmember b';
+    const first = fitRecallRootsMessage(OLD, roots, BIG, {}, '');
+    let prior = nextPrior(first);
+    const second = fitRecallRootsMessage(OLD, '# chunk 3 root=3\nmember c', BIG, {}, prior);
+    const body = String(second.content || '');
+    assert.equal(countOpen(body), 1);
+    assert.equal(countClose(body), 1);
+    // Feed once more to prove the wrapper never nests across a third cycle.
+    prior = nextPrior(second);
+    const third = fitRecallRootsMessage(OLD, '# chunk 4 root=4\nmember d', BIG, {}, prior);
+    const body3 = String(third.content || '');
+    assert.equal(countOpen(body3), 1);
+    assert.equal(countClose(body3), 1);
+});