mixdog 0.9.51 → 0.9.52

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,7 @@ 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';
 
 function policyFor(session) {
     return resolveWorkerCompactPolicy(session, []);
@@ -371,12 +372,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 +388,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', () => {

package/scripts/compact-smoke.mjs

@@ -2,6 +2,7 @@
 import { semanticCompactMessages, recallFastTrackCompactMessages, SUMMARY_PREFIX, COMPACT_TYPE_SEMANTIC, COMPACT_TYPE_RECALL_FASTTRACK, normalizeCompactType } from '../src/runtime/agent/orchestrator/session/compact.mjs';
 import { agentLoop } from '../src/runtime/agent/orchestrator/session/loop.mjs';
 import { estimateMessagesTokens, estimateToolSchemaTokens } from '../src/runtime/agent/orchestrator/session/context-utils.mjs';
+import { runSessionCompaction } from '../src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs';
 import { autoCompactWindowForRoute, summarizeGatewayUsage } from '../src/vendor/statusline/src/gateway/route-meta.mjs';
 
 function assert(condition, message) {
@@ -104,6 +105,85 @@ const wholeTranscriptForced = await semanticCompactMessages(wholeTranscriptProvi
 assert(wholeTranscriptForced.semantic === true && wholeTranscriptForcedCalls === 1, 'forced semantic compact must summarize when tail budget would preserve the whole live transcript (default tailTurns)');
 assert(findSummary(wholeTranscriptForced.messages), 'whole-transcript forced semantic compact should insert an anchored summary');
 
+// Manual /compact must reduce the active session transcript directly through
+// semantic compaction even when main-session policy is recall-fasttrack. If the
+// override regresses, this test enters Memory first (unregistered in this smoke)
+// and reports recall-fasttrack metadata before falling back.
+let manualDirectCalls = 0;
+let manualDirectPrompt = '';
+const manualDirectMessages = [
+  { role: 'system', content: 'MANUAL_SYSTEM_RULE_STAYS_EXACT' },
+  {
+    role: 'user',
+    content: '# Session\nCwd: C:\\Injected\\Noise\nModel: fake-model\nWorkflow: Solo\n\n# Additional context\nOLD_ADDITIONAL_CONTEXT_INJECTION\n\n# Prefetch\nOLD_PREFETCH_INJECTION\n\n# Task\nREAL_OLD_USER_REQUEST\n<system-reminder>OLD_SYSTEM_REMINDER_INJECTION</system-reminder>\n<memory-context>OLD_MEMORY_CONTEXT_INJECTION</memory-context>',
+  },
+  {
+    role: 'assistant',
+    content: 'REAL_OLD_ASSISTANT_REPLY\n```text\nOLD_CODE_FENCE_TRACE\n```',
+    toolCalls: [{ id: 'OLD_TOOL_CALL_ID', name: 'OLD_TOOL_CALL_TRACE', arguments: '{"password":"OLD_TOOL_SECRET"}' }],
+  },
+  { role: 'tool', toolCallId: 'OLD_TOOL_CALL_ID', content: 'OLD_TOOL_RESULT_TRACE' },
+  { role: 'developer', content: 'OLD_DEVELOPER_INJECTION' },
+  { role: 'user', content: 'Reference files:\nOLD_REFERENCE_FILE_INJECTION' },
+  { role: 'user', content: '[mixdog-runtime] OLD_RUNTIME_INJECTION' },
+  { role: 'user', content: 'CURRENT_REQUEST_STAYS_VERBATIM' },
+  { role: 'assistant', content: 'CURRENT_ASSISTANT_STAYS_VERBATIM' },
+];
+const manualDirectSession = {
+  id: `compact-smoke-manual-direct-${process.pid}`,
+  provider: 'manual-direct-smoke',
+  model: 'fake-model',
+  contextWindow: 100_000,
+  compactBoundaryTokens: 100_000,
+  messages: manualDirectMessages.map((m) => ({ ...m })),
+  tools: [],
+  compaction: {
+    type: COMPACT_TYPE_RECALL_FASTTRACK,
+    compactType: COMPACT_TYPE_RECALL_FASTTRACK,
+    tailTurns: 1,
+  },
+};
+const manualDirect = await runSessionCompaction(manualDirectSession, {
+  mode: 'manual',
+  force: true,
+  compactType: COMPACT_TYPE_SEMANTIC,
+  filterOldHistoryForIngest: true,
+  provider: {
+    name: 'manual-direct-smoke',
+    async send(sentMessages) {
+      manualDirectCalls += 1;
+      manualDirectPrompt = sentMessages.map((m) => String(m?.content || '')).join('\n');
+      return { content: '## Goal\n- compact only the active session\n\n## Constraints & Preferences\n- preserve the recent tail\n\n## Progress\n### Done\n- reduced old transcript content\n\n### In Progress\n- (none)\n\n### Blocked\n- (none)\n\n## Key Decisions\n- use direct semantic compaction\n\n## Next Steps\n- continue from the preserved tail\n\n## Critical Context\n- active session only\n\n## Relevant Files\n- session-crud.mjs' };
+    },
+  },
+  model: 'fake-model',
+});
+assert(manualDirectCalls === 1, 'manual direct compact should make exactly one semantic provider call');
+assert(manualDirect.compactType === COMPACT_TYPE_SEMANTIC, 'manual direct compact must bypass recall-fasttrack policy');
+assert(manualDirect.semanticCompact === true, 'manual direct compact should produce a semantic summary');
+assert(manualDirect.recallFastTrackError == null, 'manual direct compact must not touch Memory recall');
+assert(findSummary(manualDirectSession.messages), 'manual direct compact should replace old active-session history with a handoff summary');
+assert(manualDirectPrompt.includes('REAL_OLD_USER_REQUEST'), 'manual compact prompt should retain genuine old user prose');
+assert(manualDirectPrompt.includes('REAL_OLD_ASSISTANT_REPLY'), 'manual compact prompt should retain genuine old assistant prose');
+for (const excluded of [
+  'OLD_ADDITIONAL_CONTEXT_INJECTION',
+  'OLD_PREFETCH_INJECTION',
+  'OLD_SYSTEM_REMINDER_INJECTION',
+  'OLD_MEMORY_CONTEXT_INJECTION',
+  'OLD_CODE_FENCE_TRACE',
+  'OLD_TOOL_CALL_TRACE',
+  'OLD_TOOL_SECRET',
+  'OLD_TOOL_RESULT_TRACE',
+  'OLD_DEVELOPER_INJECTION',
+  'OLD_REFERENCE_FILE_INJECTION',
+  'OLD_RUNTIME_INJECTION',
+]) {
+  assert(!manualDirectPrompt.includes(excluded), `manual compact old-history filter must exclude ${excluded}`);
+}
+assert(manualDirectSession.messages.some((m) => m.role === 'system' && m.content === 'MANUAL_SYSTEM_RULE_STAYS_EXACT'), 'manual compact must preserve system rules separately');
+assert(manualDirectSession.messages.some((m) => m.role === 'user' && m.content === 'CURRENT_REQUEST_STAYS_VERBATIM'), 'manual compact must preserve the recent user turn verbatim');
+assert(manualDirectSession.messages.some((m) => m.role === 'assistant' && m.content === 'CURRENT_ASSISTANT_STAYS_VERBATIM'), 'manual compact must preserve the recent assistant turn verbatim');
+
 assert(normalizeCompactType('type1') === COMPACT_TYPE_SEMANTIC, 'type1 should resolve to semantic compact');
 assert(normalizeCompactType('recall-fasttrack') === COMPACT_TYPE_RECALL_FASTTRACK, 'type2 should resolve to recall fast-track compact');
 // Alias parity: snake_case + dash + no-dash spellings of fast-track must all