mixdog 0.9.51 → 0.9.53

package/scripts/code-graph-aggregate-cwd-test.mjs

@@ -6,11 +6,13 @@ import { homedir, tmpdir } from 'node:os';
 import { findCachedGraphBinary } from '../src/runtime/agent/orchestrator/tools/graph-binary-fetcher.mjs';
 
 const previousDataDir = process.env.MIXDOG_DATA_DIR;
+const previousHome = process.env.MIXDOG_HOME;
 const previousGraphBin = process.env.MIXDOG_GRAPH_BIN;
 const ambientDataDir = previousDataDir || join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data');
 const ambientGraphBin = findCachedGraphBinary(ambientDataDir);
 const isolatedDataDir = await mkdtemp(join(tmpdir(), 'mixdog-code-graph-test-data-'));
 process.env.MIXDOG_DATA_DIR = isolatedDataDir;
+process.env.MIXDOG_HOME = isolatedDataDir;
 if (!previousGraphBin && ambientGraphBin) process.env.MIXDOG_GRAPH_BIN = ambientGraphBin;
 const { executeCodeGraphTool } = await import('../src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs');
 const { drainCodeGraphCache } = await import('../src/runtime/agent/orchestrator/tools/code-graph/disk-cache.mjs');
@@ -40,6 +42,9 @@ async function makeProject() {
 }
 
 const primaryProject = await makeProject();
+await writeFile(join(isolatedDataDir, 'projects.json'), JSON.stringify({
+  projects: [{ name: 'primary', path: primaryProject, addedAt: 1 }],
+}));
 
 test.after(async () => {
   drainCodeGraphCache();
@@ -49,6 +54,8 @@ test.after(async () => {
   ]);
   if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
   else process.env.MIXDOG_DATA_DIR = previousDataDir;
+  if (previousHome === undefined) delete process.env.MIXDOG_HOME;
+  else process.env.MIXDOG_HOME = previousHome;
   if (previousGraphBin === undefined) delete process.env.MIXDOG_GRAPH_BIN;
   else process.env.MIXDOG_GRAPH_BIN = previousGraphBin;
 });
@@ -63,8 +70,8 @@ serialTest('aggregate file anchors recover an invalid cwd only for one project r
   assert.match(result, new RegExp(`# overview ${files[1].replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
 
   const relativeResult = await executeCodeGraphTool('code_graph', { mode: 'overview', files: relativeFiles }, invalidCwd);
-  assert.match(relativeResult, new RegExp(`# overview ${files[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
-  assert.match(relativeResult, new RegExp(`# overview ${files[1].replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
+  assert.match(relativeResult, /file: src\/one\.mjs/);
+  assert.match(relativeResult, /file: src\/two\.mjs/);
   drainCodeGraphCache();
 });
 
@@ -72,21 +79,18 @@ serialTest('singleton JSON files retain aggregate cwd provenance', async () => {
   const project = primaryProject;
   const invalidCwd = parse(project).root;
   const file = join(project, 'src', 'one.mjs');
-  const rejected = /aggregate file anchors do not all exist under exactly one detectable project root/;
   const result = await executeCodeGraphTool(
     'code_graph',
     { mode: 'overview', files: JSON.stringify([file]), cwd: invalidCwd },
     project,
   );
   assert.doesNotMatch(result, /^Error:/);
-  await assert.rejects(
-    executeCodeGraphTool(
-      'code_graph',
-      { mode: 'overview', files: JSON.stringify([join(project, 'missing.mjs')]), cwd: invalidCwd },
-      project,
-    ),
-    rejected,
+  const missingAggregate = await executeCodeGraphTool(
+    'code_graph',
+    { mode: 'overview', files: JSON.stringify([join(project, 'missing.mjs')]), cwd: invalidCwd },
+    project,
   );
+  assert.match(missingAggregate, /^Error: code_graph: file not found:/);
   const scalarResult = await executeCodeGraphTool(
     'code_graph',
     { mode: 'overview', file: join(project, 'missing.mjs'), cwd: invalidCwd },
@@ -99,26 +103,27 @@ serialTest('aggregate cwd recovery rejects missing and multi-root anchors', asyn
   const first = await makeProject();
   const second = await makeProject();
   const invalidCwd = parse(first).root;
-  const rejected = /aggregate file anchors do not all exist under exactly one detectable project root/;
   const relativeFirst = relative(invalidCwd, join(first, 'src', 'one.mjs'));
   const relativeSecond = relative(invalidCwd, join(second, 'src', 'one.mjs'));
   try {
-    await assert.rejects(
-      executeCodeGraphTool('code_graph', { mode: 'overview', files: [join(first, 'src', 'one.mjs'), join(first, 'missing.mjs')] }, invalidCwd),
-      rejected,
-    );
-    await assert.rejects(
-      executeCodeGraphTool('code_graph', { mode: 'overview', files: [relativeFirst, relative(invalidCwd, join(first, 'missing.mjs'))] }, invalidCwd),
-      rejected,
-    );
-    await assert.rejects(
-      executeCodeGraphTool('code_graph', { mode: 'overview', files: [join(first, 'src', 'one.mjs'), join(second, 'src', 'one.mjs')] }, invalidCwd),
-      rejected,
-    );
-    await assert.rejects(
-      executeCodeGraphTool('code_graph', { mode: 'overview', files: [relativeFirst, relativeSecond] }, invalidCwd),
-      rejected,
-    );
+    for (const filesArg of [
+      [join(first, 'src', 'one.mjs'), join(first, 'missing.mjs')],
+      [relativeFirst, relative(invalidCwd, join(first, 'missing.mjs'))],
+    ]) {
+      assert.match(
+        await executeCodeGraphTool('code_graph', { mode: 'overview', files: filesArg }, invalidCwd),
+        /^Error: code_graph: file not found:/,
+      );
+    }
+    for (const filesArg of [
+      [join(first, 'src', 'one.mjs'), join(second, 'src', 'one.mjs')],
+      [relativeFirst, relativeSecond],
+    ]) {
+      assert.match(
+        await executeCodeGraphTool('code_graph', { mode: 'overview', files: filesArg }, invalidCwd),
+        /^Error: code_graph: file anchor is not owned by a trusted project:/,
+      );
+    }
   } finally {
     await Promise.all([rm(first, { recursive: true, force: true }), rm(second, { recursive: true, force: true })]);
   }
@@ -127,7 +132,6 @@ serialTest('aggregate cwd recovery rejects missing and multi-root anchors', asyn
 serialTest('aggregate cwd recovery rejects capped, comma-delimited, and wildcard anchors', async () => {
   const project = await makeProject();
   const invalidCwd = parse(project).root;
-  const rejected = /aggregate file anchors do not all exist under exactly one detectable project root/;
   const cappedFiles = await Promise.all(Array.from({ length: 21 }, async (_, index) => {
     const file = join(project, 'src', `anchor-${index}.mjs`);
     await writeFile(file, `export const anchor${index} = ${index};\n`);
@@ -136,17 +140,17 @@ serialTest('aggregate cwd recovery rejects capped, comma-delimited, and wildcard
   const literalWildcard = join(project, 'src', 'literal[glob].mjs');
   await writeFile(literalWildcard, 'export const wildcard = true;\n');
   try {
-    await assert.rejects(
-      executeCodeGraphTool('code_graph', { mode: 'overview', files: cappedFiles }, invalidCwd),
-      rejected,
+    assert.match(
+      await executeCodeGraphTool('code_graph', { mode: 'overview', files: cappedFiles }, invalidCwd),
+      /file list exceeds cap/,
     );
-    await assert.rejects(
-      executeCodeGraphTool('code_graph', { mode: 'overview', files: `${join(project, 'src', 'one.mjs')},${join(project, 'src', 'two.mjs')}` }, invalidCwd),
-      rejected,
+    assert.match(
+      await executeCodeGraphTool('code_graph', { mode: 'overview', files: `${join(project, 'src', 'one.mjs')},${join(project, 'src', 'two.mjs')}` }, invalidCwd),
+      /^Error: code_graph: file anchor is not owned by a trusted project:/,
     );
-    await assert.rejects(
-      executeCodeGraphTool('code_graph', { mode: 'overview', files: [literalWildcard] }, invalidCwd),
-      rejected,
+    assert.match(
+      await executeCodeGraphTool('code_graph', { mode: 'overview', files: [literalWildcard] }, invalidCwd),
+      /wildcard-shaped file anchors/,
     );
   } finally {
     await rm(project, { recursive: true, force: true });

package/scripts/code-graph-disk-hit-test.mjs

@@ -262,6 +262,17 @@ test('Worker drains all migrated cache entries before posting success', () => {
   assert.deepEqual(events, ['drain', 'post']);
 });
 
+test('cache-disabled scoped Worker posts success without touching disk-cache state', () => {
+  const events = [];
+  _postCodeGraphWorkerSuccess(
+    { signature: 'scoped', nodes: new Map() },
+    (message) => events.push(message.ok ? 'post' : 'bad-post'),
+    () => events.push('drain'),
+    { cache: false },
+  );
+  assert.deepEqual(events, ['post']);
+});
+
 test('strict persistence failure prevents Worker success post', () => {
   let posted = false;
   assert.throws(

package/scripts/code-graph-root-federation-test.mjs

@@ -0,0 +1,273 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { join, parse } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+import { findCachedGraphBinary } from '../src/runtime/agent/orchestrator/tools/graph-binary-fetcher.mjs';
+
+const home = await mkdtemp(join(tmpdir(), 'mixdog-federation-home-'));
+const data = join(home, 'data');
+const ambientGraphBin = findCachedGraphBinary(join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data'));
+process.env.MIXDOG_HOME = home;
+process.env.MIXDOG_DATA_DIR = data;
+delete process.env.MIXDOG_SESSION_CWD;
+if (!process.env.MIXDOG_GRAPH_BIN && ambientGraphBin) process.env.MIXDOG_GRAPH_BIN = ambientGraphBin;
+
+const {
+  _isFilesystemRootPath,
+  collectTrustedCodeGraphRoots,
+} = await import('../src/runtime/agent/orchestrator/tools/code-graph/trusted-roots.mjs');
+const {
+  _codeGraphInflightKey,
+  _runGraphFilesChunked,
+  _scopeCodeGraphManifest,
+} = await import('../src/runtime/agent/orchestrator/tools/code-graph/build.mjs');
+
+test.after(() => rm(home, { recursive: true, force: true }));
+
+test('filesystem-root semantics recognize Unix and Windows roots only', () => {
+  assert.equal(_isFilesystemRootPath('/'), true);
+  assert.equal(_isFilesystemRootPath('C:\\'), true);
+  assert.equal(_isFilesystemRootPath('d:/'), true);
+  assert.equal(_isFilesystemRootPath('C:'), false);
+  assert.equal(_isFilesystemRootPath('/tmp'), false);
+  assert.equal(_isFilesystemRootPath('C:\\repo'), false);
+});
+
+test('trusted sources are unioned, normalized, deduped, and filtered', async () => {
+  const project = await mkdtemp(join(tmpdir(), 'mixdog-trusted-project-'));
+  const nested = join(project, 'nested');
+  await mkdir(nested);
+  await writeFile(join(nested, 'package.json'), '{}');
+  const missing = join(project, 'missing');
+  try {
+    const roots = collectTrustedCodeGraphRoots(parse(project).root, {
+      registered: () => [project, `${project}/`],
+      selected: () => [nested, parse(project).root],
+      cached: () => [project, missing],
+    });
+    assert.deepEqual(new Set(roots), new Set([project, nested]));
+  } finally {
+    await rm(project, { recursive: true, force: true });
+  }
+});
+
+test('nested project exclusion precedes cap selection and scoped truncation metadata', () => {
+  const parent = join(parse(process.cwd()).root, 'parent-scope');
+  const child = join(parent, 'child');
+  const manifest = [
+    { rel: 'child/a.mjs', fp: 'a' },
+    { rel: 'child/b.mjs', fp: 'b' },
+    { rel: 'child/c.mjs', fp: 'c' },
+    { rel: 'parent-one.mjs', fp: '1' },
+    { rel: 'parent-two.mjs', fp: '2' },
+  ];
+  const scoped = _scopeCodeGraphManifest(manifest, parent, {
+    excludedProjectRoots: [child],
+    maxFiles: 2,
+  });
+  assert.deepEqual(scoped.indexed.map((row) => row.rel), ['parent-one.mjs', 'parent-two.mjs']);
+  assert.equal(scoped.manifest.length, 2);
+  assert.equal(scoped.truncated, false);
+
+  const truncated = _scopeCodeGraphManifest(
+    [...manifest, { rel: 'parent-three.mjs', fp: '3' }],
+    parent,
+    { excludedProjectRoots: [child], maxFiles: 2 },
+  );
+  assert.equal(truncated.manifest.length, 3);
+  assert.equal(truncated.indexed.length, 2);
+  assert.equal(truncated.truncated, true);
+});
+
+test('nested Windows project exclusion is case-insensitive and containment-aware', () => {
+  const scoped = _scopeCodeGraphManifest([
+    { rel: 'Child/inside.mjs', fp: 'inside' },
+    { rel: 'childish/outside.mjs', fp: 'outside' },
+    { rel: 'parent.mjs', fp: 'parent' },
+  ], 'C:\\Repo', {
+    excludedProjectRoots: ['c:\\repo\\CHILD'],
+  });
+  assert.deepEqual(scoped.manifest.map((row) => row.rel), [
+    'childish/outside.mjs',
+    'parent.mjs',
+  ]);
+  assert.deepEqual(scoped.prefixes, ['child']);
+});
+
+test('scoped in-flight keys cannot collide through delimiters', () => {
+  const onePrefix = _codeGraphInflightKey('/repo', {
+    scoped: true,
+    maxFiles: 100,
+    prefixes: ['child|vendor'],
+  });
+  const twoPrefixes = _codeGraphInflightKey('/repo', {
+    scoped: true,
+    maxFiles: 100,
+    prefixes: ['child', 'vendor'],
+  });
+  assert.notEqual(onePrefix, twoPrefixes);
+  assert.notEqual(onePrefix, _codeGraphInflightKey('/repo'));
+});
+
+test('scoped --files builds use bounded chunks and merge relationship records', async () => {
+  const rels = Array.from({ length: 10_000 }, (_, index) => `src/file-${index}.mjs`);
+  const calls = [];
+  const records = await _runGraphFilesChunked('/repo', rels, [{ rel: 'reused.mjs' }], {
+    maxArgChars: 1_024,
+    runGraphFiles: async (_root, rels) => {
+      calls.push(rels);
+      return [
+        ...rels.map((rel) => ({ rel, fp: rel, resolvedImports: ['reused.mjs'] })),
+        { rel: 'reused.mjs', importedBy: [rels[0]] },
+      ];
+    },
+  });
+  assert.ok(calls.length > 1);
+  for (const rels of calls) {
+    assert.ok(rels.reduce((sum, rel) => sum + rel.length + 3, 0) <= 1_024);
+  }
+  assert.equal(records.filter((row) => row.rel !== 'reused.mjs').length, 10_000);
+  assert.deepEqual(new Set(records.map((row) => row.rel)), new Set([...rels, 'reused.mjs']));
+  assert.deepEqual(
+    new Set(records.find((row) => row.rel === 'reused.mjs').importedBy),
+    new Set(calls.map((rels) => rels[0])),
+  );
+});
+
+test('default trusted sources include actual registration, selected nested project, and cache manifest', async () => {
+  const parent = await mkdtemp(join(tmpdir(), 'mixdog-source-parent-'));
+  const child = join(parent, 'child');
+  const cached = await mkdtemp(join(tmpdir(), 'mixdog-source-cache-'));
+  await mkdir(child);
+  await writeFile(join(parent, 'package.json'), '{}');
+  await writeFile(join(child, 'package.json'), '{}');
+  await mkdir(join(data, 'code-graph-cache'), { recursive: true });
+  await writeFile(join(home, 'projects.json'), JSON.stringify({
+    projects: [{ name: 'parent', path: parent, addedAt: 1 }],
+  }));
+  await writeFile(join(data, 'code-graph-cache', 'manifest.json'), JSON.stringify({
+    [cached]: { hash: '12345678', builtAt: 1 },
+  }));
+  process.env.MIXDOG_SESSION_CWD = child;
+  try {
+    const roots = collectTrustedCodeGraphRoots(parse(parent).root);
+    assert.deepEqual(new Set(roots), new Set([parent, child, cached]));
+  } finally {
+    delete process.env.MIXDOG_SESSION_CWD;
+    await Promise.all([
+      rm(parent, { recursive: true, force: true }),
+      rm(cached, { recursive: true, force: true }),
+    ]);
+  }
+});
+
+test('root federation labels repositories, includes registered non-Git projects, and isolates failures', async () => {
+  const good = await mkdtemp(join(tmpdir(), 'mixdog-federated-good-'));
+  const bad = await mkdtemp(join(tmpdir(), 'mixdog-federated-bad-'));
+  await mkdir(join(good, 'src'));
+  await writeFile(join(good, 'package.json'), '{}');
+  await writeFile(join(good, 'src', 'good.mjs'), 'export function federatedNeedle() { return 1; }\n');
+  await writeFile(join(home, 'projects.json'), JSON.stringify({
+    projects: [
+      { name: 'good', path: good, addedAt: 2 },
+      { name: 'bad', path: bad, addedAt: 1 },
+    ],
+  }));
+  await writeFile(join(bad, 'package.json'), '{}');
+  const { executeCodeGraphTool } = await import('../src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs');
+  const result = await executeCodeGraphTool(
+    'code_graph',
+    { mode: 'symbol_search', symbol: 'federatedNeedle' },
+    parse(good).root,
+  );
+  assert.match(result, new RegExp(`# project .+ \\[${good.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\]`));
+  assert.match(result, /federatedNeedle/);
+  assert.match(result, new RegExp(`# project .+ \\[${bad.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\]`));
+  assert.match(result, /contains zero eligible files/);
+
+  await Promise.all([
+    rm(good, { recursive: true, force: true }),
+    rm(bad, { recursive: true, force: true }),
+  ]);
+});
+
+test('trusted file and relationship anchors route to owners; missing and untrusted anchors stop at root', async () => {
+  const project = await mkdtemp(join(tmpdir(), 'mixdog-file-route-'));
+  const untrusted = await mkdtemp(join(tmpdir(), 'mixdog-untrusted-route-'));
+  await writeFile(join(project, 'package.json'), '{}');
+  await writeFile(join(project, 'one.mjs'), 'export function routedNeedle() { return 1; }\n');
+  await writeFile(join(project, 'two.mjs'), "import { routedNeedle } from './one.mjs';\nexport const routedUse = routedNeedle();\n");
+  await writeFile(join(untrusted, 'package.json'), '{}');
+  await writeFile(join(untrusted, 'hidden.mjs'), 'export const hidden = 1;\n');
+  await writeFile(join(home, 'projects.json'), JSON.stringify({
+    projects: [{ name: 'route', path: project, addedAt: 1 }],
+  }));
+  const { executeCodeGraphTool } = await import('../src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs');
+  const root = parse(project).root;
+  const overview = await executeCodeGraphTool('code_graph', { mode: 'overview' }, root);
+  assert.match(overview, /# project .+\[/);
+  assert.match(overview, /files\t2/);
+  const imports = await executeCodeGraphTool('code_graph', { mode: 'imports', file: join(project, 'two.mjs') }, root);
+  assert.match(imports, /# project .+\[/);
+  assert.match(imports, /one\.mjs/);
+  const dependents = await executeCodeGraphTool('code_graph', {
+    mode: 'dependents',
+    file: join(project, 'one.mjs'),
+  }, root);
+  assert.match(dependents, /# project .+\[/);
+  assert.match(dependents, /two\.mjs/);
+  const missing = await executeCodeGraphTool('code_graph', {
+    mode: 'overview',
+    file: join(project, 'definitely-missing.mjs'),
+  }, root);
+  assert.match(missing, /^Error: code_graph: file not found:/);
+  assert.doesNotMatch(missing, /Same filename exists/);
+  const rejected = await executeCodeGraphTool('code_graph', {
+    mode: 'overview',
+    file: join(untrusted, 'hidden.mjs'),
+  }, root);
+  assert.match(rejected, /^Error: code_graph: file anchor is not owned by a trusted project:/);
+  await Promise.all([
+    rm(project, { recursive: true, force: true }),
+    rm(untrusted, { recursive: true, force: true }),
+  ]);
+});
+
+test('overlapping trusted roots keep nested symbols and edges out of the parent graph', async () => {
+  const parent = await mkdtemp(join(tmpdir(), 'mixdog-overlap-parent-'));
+  const child = join(parent, 'child');
+  await mkdir(child);
+  await writeFile(join(parent, 'package.json'), '{}');
+  await writeFile(join(parent, 'parent.mjs'), "import { childNeedle } from './child/child.mjs';\nexport const parentUse = childNeedle();\n");
+  await writeFile(join(child, 'package.json'), '{}');
+  await writeFile(join(child, 'child.mjs'), 'export function childNeedle() { return 1; }\n');
+  await writeFile(join(home, 'projects.json'), JSON.stringify({
+    projects: [
+      { name: 'parent', path: parent, addedAt: 2 },
+      { name: 'child', path: child, addedAt: 1 },
+    ],
+  }));
+  const { executeCodeGraphTool } = await import('../src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs');
+  const result = await executeCodeGraphTool('code_graph', {
+    mode: 'symbol_search',
+    symbol: 'childNeedle',
+  }, parse(parent).root);
+  const parentLabel = `# project ${parent.split(/[\\/]/).pop().toLowerCase()} [${parent.toLowerCase()}]`;
+  const childLabel = `# project ${child.split(/[\\/]/).pop().toLowerCase()} [${child.toLowerCase()}]`;
+  const normalized = result.toLowerCase();
+  const parentSection = normalized.slice(
+    normalized.indexOf(parentLabel),
+    normalized.indexOf(childLabel) > normalized.indexOf(parentLabel)
+      ? normalized.indexOf(childLabel)
+      : normalized.length,
+  );
+  assert.doesNotMatch(parentSection, /child\/child\.mjs|childneedle\s+\(/);
+  assert.match(normalized.slice(normalized.indexOf(childLabel)), /childneedle/);
+  const imports = await executeCodeGraphTool('code_graph', {
+    mode: 'imports',
+    file: join(parent, 'parent.mjs'),
+  }, parse(parent).root);
+  assert.doesNotMatch(imports.split('# raw')[0], /child\/child\.mjs/);
+  await rm(parent, { recursive: true, force: true });
+});

package/scripts/compact-pressure-test.mjs

@@ -21,6 +21,9 @@ import {
 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';
+import { recallFastTrackCompactMessages } from '../src/runtime/agent/orchestrator/session/compact/engine.mjs';
+import { _combineUsageWithWarmup } from '../src/runtime/agent/orchestrator/providers/openai-ws-events.mjs';
+import { applyAskTerminalUsageTotals } from '../src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs';
 
 function policyFor(session) {
     return resolveWorkerCompactPolicy(session, []);
@@ -371,12 +374,13 @@ test('tool reserve and status cache detect nested schema mutation', () => {
     assert.ok(statusAfter.request.toolSchemaTokens > statusBefore.request.toolSchemaTokens);
 });
 
-test('native replay fingerprint detects encrypted reasoning and assistant metadata mutation', () => {
+test('native replay fingerprint detects encrypted reasoning and provider metadata mutation', () => {
     const message = {
         role: 'assistant',
         content: '',
         reasoningItems: [{ type: 'reasoning', encrypted_content: 'short' }],
         assistantBlocks: [{ type: 'tool_use', id: 'c1', name: 'read', input: { path: 'a' }, cache_control: { type: 'ephemeral' } }],
+        providerMetadata: { gemini: { thoughtParts: [{ text: 'short', thoughtSignature: 'sig' }] } },
     };
     const messages = [message];
     const first = summarizeContextMessages(messages).estimatedTokens;
@@ -386,6 +390,58 @@ test('native replay fingerprint detects encrypted reasoning and assistant metada
     message.assistantBlocks[0].cache_control.mode = 'metadata_'.repeat(1_000);
     const third = summarizeContextMessages(messages).estimatedTokens;
     assert.ok(third > second, 'in-place assistant-block metadata mutation must invalidate the message memo');
+    message.providerMetadata.gemini.thoughtParts[0].text = 'gemini_private_thought_'.repeat(1_000);
+    const fourth = summarizeContextMessages(messages).estimatedTokens;
+    assert.ok(fourth > third, 'in-place Gemini replay metadata mutation must invalidate the message memo');
+});
+
+test('recall compaction preserves provider-scoped Gemini replay metadata on the live tail', () => {
+    const providerMetadata = {
+        gemini: {
+            textParts: [{ text: 'signed answer', thoughtSignature: 'sig-tail' }],
+        },
+    };
+    const result = recallFastTrackCompactMessages([
+        { role: 'user', content: `old request ${'x'.repeat(20_000)}` },
+        { role: 'assistant', content: `old answer ${'y'.repeat(20_000)}` },
+        { role: 'user', content: 'recent request' },
+        { role: 'assistant', content: 'signed answer', providerMetadata },
+    ], 8_000, {
+        force: true,
+        recallText: 'Older history summary.',
+        recallTailMaxUsers: 1,
+        recallTailTokenCap: 4_000,
+    });
+    const tail = result.messages.find((message) => message?.content === 'signed answer');
+    assert.deepEqual(tail?.providerMetadata, providerMetadata);
+});
+
+test('recall tail cap drops oversized replay metadata instead of raising the budget', () => {
+    const result = recallFastTrackCompactMessages([
+        { role: 'user', content: `old request ${'x'.repeat(20_000)}` },
+        { role: 'assistant', content: `old answer ${'y'.repeat(20_000)}` },
+        { role: 'user', content: 'recent request' },
+        {
+            role: 'assistant',
+            content: 'recent answer',
+            providerMetadata: {
+                gemini: {
+                    thoughtParts: [{
+                        text: 'private_'.repeat(20_000),
+                        thoughtSignature: 'sig',
+                    }],
+                },
+            },
+        },
+    ], 8_000, {
+        force: true,
+        recallText: 'Older history summary.',
+        recallTailMaxUsers: 1,
+        recallTailTokenCap: 200,
+    });
+    assert.ok(result.diagnostics.tailTokens <= 200, `tail tokens ${result.diagnostics.tailTokens}`);
+    const recent = result.messages.find((message) => message?.content === 'recent answer');
+    assert.equal(recent?.providerMetadata, undefined);
 });
 
 test('provider baseline pressure includes only the configured extra reserve', () => {
@@ -572,6 +628,108 @@ test('thinking-only continuation without assistant replay excludes provider outp
     }), false, 'unreplayed thinking output must not cause an early compact');
 });
 
+test('OpenAI OAuth WS warmup remains billed but does not double the main context footprint', async () => {
+    const main = {
+        inputTokens: 167_635,
+        outputTokens: 611,
+        cachedTokens: 160_000,
+        promptTokens: 167_635,
+        raw: {},
+    };
+    const usage = _combineUsageWithWarmup(main, main, { separateMainContext: true });
+    assert.equal(usage.inputTokens, 335_270, 'billing usage must retain warmup plus main input');
+    const { initProviders, getProvider } = await import('../src/runtime/agent/orchestrator/providers/registry.mjs');
+    const { createSession, askSession, getSession } = await import('../src/runtime/agent/orchestrator/session/manager.mjs');
+    await initProviders({ 'openai-oauth': { enabled: true } });
+    const provider = getProvider('openai-oauth');
+    const originalSend = provider.send;
+    const compactEvents = [];
+    provider.send = async () => ({ content: 'done', usage });
+    try {
+        const session = createSession({
+            provider: 'openai-oauth',
+            model: 'warmup-context-regression',
+            tools: [],
+            cwd: process.cwd(),
+            skipAgentRules: true,
+            skipSkills: true,
+            compaction: { auto: true },
+        });
+        session.contextWindow = 272_000;
+        session.rawContextWindow = 272_000;
+        await askSession(session.id, 'large OAuth WebSocket request', null, null, process.cwd(), null, {
+            onCompactEvent: event => compactEvents.push(event),
+        });
+
+        const persisted = getSession(session.id);
+        const policy = { ...policyFor(persisted), reserveTokens: 0 };
+        const messageTokens = estimateMessagesTokens(persisted.messages);
+        const pressure = resolveCompactionPressureTokens(messageTokens, policy, {
+            messages: persisted.messages,
+            sessionRef: persisted,
+        });
+        assert.equal(persisted.totalInputTokens, 335_270, 'incremental lifetime totals must retain warmup billing');
+        assert.equal(persisted.lastContextTokens, 167_635, 'incremental context snapshot must exclude warmup');
+        assert.equal(persisted.contextPressureBaselineTokens, 168_246, 'stored baseline must use main request usage');
+        assert.equal(pressure, 168_246, 'resolved pressure must use the stored baseline without transcript growth');
+        assert.equal(policy.triggerTokens, 258_400, 'fixture trigger must match the reported premature-compaction threshold');
+        assert.equal(shouldCompactForSession(messageTokens, policy, {
+            messages: persisted.messages,
+            sessionRef: persisted,
+            pressureTokens: pressure,
+        }), false, 'main-request pressure must not trigger compaction');
+        assert.equal(compactEvents.length, 0, 'warmup must not cause an auto-compaction');
+    } finally {
+        provider.send = originalSend;
+    }
+});
+
+test('warmup-only OpenAI OAuth WS usage stays billable but invalidates context usage', () => {
+    const warmup = { inputTokens: 167_635, outputTokens: 611, cachedTokens: 160_000, promptTokens: 167_635 };
+    const usage = _combineUsageWithWarmup(null, warmup, { separateMainContext: true });
+    const session = { provider: 'openai-oauth', contextPressureBaselineTokens: 99_000 };
+    assert.equal(usage.mainUsageAvailable, false);
+    assert.equal(recordProviderContextBaseline(session, [], usage), false);
+    assert.equal(session.contextPressureBaselineTokens, null, 'warmup-only usage must not remain a provider baseline');
+    applyAskTerminalUsageTotals(session, { usage, lastTurnUsage: usage });
+    assert.equal(session.totalInputTokens, 167_635, 'warmup-only usage remains billable');
+    assert.equal(session.lastContextTokens, null, 'warmup-only usage has no main-request context snapshot');
+});
+
+test('xAI warmup remains billable while main usage alone drives context pressure', () => {
+    const actual = { inputTokens: 20, outputTokens: 2, cachedTokens: 5, promptTokens: 20, raw: { provider: 'xai', cost_in_usd_ticks: 200 } };
+    const warmup = { inputTokens: 10, outputTokens: 1, cachedTokens: 3, promptTokens: 10, raw: { phase: 'warmup', cost_in_usd_ticks: 100 } };
+    const usage = _combineUsageWithWarmup(actual, warmup, { separateMainContext: true });
+    assert.deepEqual(usage, {
+        ...actual,
+        inputTokens: 30,
+        outputTokens: 3,
+        cachedTokens: 8,
+        promptTokens: 30,
+        warmupInputTokens: 10,
+        warmupCachedTokens: 3,
+        warmupOutputTokens: 1,
+        warmupPromptTokens: 10,
+        warmupCacheWriteTokens: 0,
+        raw: {
+            provider: 'xai',
+            cost_in_usd_ticks: 300,
+            warmup_usage: { phase: 'warmup', cost_in_usd_ticks: 100 },
+        },
+        mainInputTokens: 20,
+        mainOutputTokens: 2,
+        mainCachedTokens: 5,
+        mainPromptTokens: 20,
+        mainCacheWriteTokens: 0,
+        mainUsageAvailable: true,
+    });
+    const session = { provider: 'xai', contextPressureBaselineTokens: null };
+    assert.equal(recordProviderContextBaseline(session, [], usage), true);
+    applyAskTerminalUsageTotals(session, { usage, lastTurnUsage: usage });
+    assert.equal(session.totalInputTokens, 30, 'lifetime total includes xAI warmup');
+    assert.equal(session.lastContextTokens, 20, 'context snapshot excludes xAI warmup');
+});
+
 test('successful compact invalidates stale usage and cannot immediately compact again', () => {
     const session = { provider: 'openai', contextWindow: 100_000, compaction: {} };
     const policy = { ...policyFor(session), reserveTokens: 0 };