mixdog 0.9.47 → 0.9.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.47",
+  "version": "0.9.49",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -34,7 +34,7 @@
   ],
   "scripts": {
     "prepack": "npm run build:tui",
-    "prepublishOnly": "node -e \"if(!process.env.CI){console.error('local npm publish is disabled — run the Release workflow: gh workflow run release -f bump=patch');process.exit(1)}\"",
+    "prepublishOnly": "node -e \"if(!process.env.CI){console.error('local npm publish is disabled — run npm run release:patch');process.exit(1)}\"",
     "start": "node src/cli.mjs",
     "smoke": "node scripts/smoke.mjs && node --test scripts/ship-mode-test.mjs && npm run test:memory-routing && node --test scripts/explore-prompt-policy-test.mjs && node --test scripts/routing-corpus-test.mjs",
     "smoke:all": "npm run smoke && npm run smoke:boot && npm run smoke:tools && npm run smoke:patch && npm run smoke:output && npm run smoke:tui && npm run smoke:freevars && npm run smoke:logguard && npm run smoke:live-worker && npm run test:session",
@@ -46,22 +46,32 @@
     "smoke:tools": "node scripts/tool-smoke.mjs",
     "smoke:patch": "node scripts/apply-patch-edit-smoke.mjs",
     "smoke:output": "node scripts/output-style-smoke.mjs",
-    "smoke:tui": "node scripts/tui-render-smoke.mjs && npm run test:tui-queue",
+    "smoke:tui": "node scripts/tui-render-smoke.mjs && npm run test:tui-input-render && npm run test:tui-streaming-window && npm run test:tui-queue",
     "smoke:freevars": "node scripts/freevar-smoke.mjs",
     "smoke:logguard": "node scripts/log-writer-guard-smoke.mjs",
     "smoke:live-worker": "node scripts/live-worker-smoke.mjs",
     "smoke:agent-tag-reuse": "node scripts/agent-tag-reuse-smoke.mjs",
     "test:agent-terminal-reap": "node scripts/agent-terminal-reap-test.mjs",
+    "test:agent-fanout": "node scripts/agent-parallel-smoke.mjs && node --test scripts/agent-route-batch-test.mjs scripts/execution-completion-dedup-test.mjs",
     "test:toolcall": "node --test scripts/toolcall-args-test.mjs",
     "test:shipmode": "node --test scripts/ship-mode-test.mjs",
-    "test:shellhardening": "node --test scripts/shell-hardening-test.mjs",
+    "test:shellhardening": "node --test scripts/shell-hardening-test.mjs scripts/shell-failure-diagnostics-test.mjs",
     "test:placeholder": "node --test scripts/compacted-placeholder-scrub-test.mjs",
     "test:providers": "node --test scripts/provider-toolcall-test.mjs",
+    "test:deferred-tools": "node --test scripts/deferred-tool-loading-test.mjs",
     "test:anthropic-oauth-race": "node --test scripts/anthropic-oauth-refresh-race-test.mjs",
     "test:grok-oauth-race": "node --test scripts/grok-oauth-refresh-race-test.mjs",
     "test:atomiclock": "node --test scripts/atomic-lock-tryonce-test.mjs",
     "test:memory-routing": "node --test scripts/memory-cycle-routing-test.mjs scripts/memory-rule-contract-test.mjs scripts/maintenance-default-routes-test.mjs",
+    "test:code-graph-dispatch": "node --test scripts/code-graph-dispatch-test.mjs",
+    "test:code-graph-clean-cache": "node --test scripts/code-graph-dispatch-test.mjs",
     "test:tui-queue": "node --test scripts/submit-commandbusy-race-test.mjs scripts/steering-drain-buckets-test.mjs scripts/abort-recovery-test.mjs scripts/execution-pending-resume-kick-test.mjs scripts/execution-resume-esc-integration-test.mjs",
+    "test:tui-input-render": "node --test scripts/prompt-immediate-render-test.mjs",
+    "test:tui-streaming-window": "node --test scripts/streaming-tail-window-test.mjs",
+    "test:release-assets": "node --check scripts/verify-release-assets.mjs && node --check scripts/verify-release-assets-test.mjs && node --test scripts/verify-release-assets-test.mjs",
+    "test:release-focused": "npm run test:release-assets && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && npm run smoke:tools && node --test scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && node --test scripts/windows-hide-spawn-options-test.mjs && node --test scripts/tui-transcript-perf-test.mjs",
+    "test:native-edit-wire": "node --test scripts/native-edit-wire-test.mjs",
+    "test:patch-binary-cache": "node --test scripts/patch-binary-cache-test.mjs",
     "test:session": "node --test scripts/session-orphan-sweep-test.mjs",
     "test:rebindtail": "node --test scripts/forwarder-rebind-tail-test.mjs",
     "failures": "node scripts/tool-failures.mjs",

package/scripts/agent-parallel-smoke.mjs

@@ -142,7 +142,10 @@ async function main() {
   await realInitProviders({ 'openai-oauth': { enabled: true } });
 
   // --- 1+2: parallel spawns return task_ids fast and non-blocking ---
-  const batchSize = 6;
+  const requestedBatchSize = Number.parseInt(process.env.MIXDOG_AGENT_PARALLEL_SMOKE_BATCH || '6', 10);
+  const batchSize = Number.isFinite(requestedBatchSize) && requestedBatchSize > 0
+    ? requestedBatchSize
+    : 6;
   const t0 = Date.now();
   const outs = await Promise.all(
     Array.from({ length: batchSize }, (_, i) => agent.execute({

package/scripts/agent-route-batch-test.mjs

@@ -0,0 +1,40 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+test('parallel agent routes flush in one atomic batch', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-agent-route-batch-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = root;
+  try {
+    const {
+      flushAgentStatuslineRoutes,
+      writeAgentStatuslineRoute,
+    } = await import(`../src/standalone/agent-tool/helpers.mjs?batch=${Date.now()}`);
+    const {
+      readGatewaySessionRoute,
+    } = await import('../src/vendor/statusline/src/gateway/session-routes.mjs');
+
+    const count = 48;
+    for (let i = 0; i < count; i += 1) {
+      assert.equal(writeAgentStatuslineRoute(`sess_route_batch_${i}`, {
+        id: 'worker',
+        name: 'Worker',
+        provider: 'openai-oauth',
+        model: 'gpt-5.5',
+      }), true);
+    }
+    assert.equal(flushAgentStatuslineRoutes(), true);
+
+    const routes = Array.from({ length: count }, (_, i) =>
+      readGatewaySessionRoute(`sess_route_batch_${i}`));
+    assert.equal(routes.every((route) => route?.defaultProvider === 'openai-oauth'), true);
+    assert.equal(new Set(routes.map((route) => route?.updatedAt)).size, 1);
+  } finally {
+    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previousDataDir;
+    rmSync(root, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,154 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { join, parse, relative } from 'node:path';
+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 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;
+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');
+let testTail = Promise.resolve();
+
+function serialTest(name, fn) {
+  test(name, async (t) => {
+    const previous = testTail;
+    let release;
+    testTail = new Promise((resolve) => { release = resolve; });
+    await previous;
+    try {
+      await fn(t);
+    } finally {
+      release();
+    }
+  });
+}
+
+async function makeProject() {
+  const root = await mkdtemp(join(tmpdir(), 'mixdog-code-graph-project-'));
+  await mkdir(join(root, 'src'));
+  await writeFile(join(root, 'package.json'), '{}');
+  await writeFile(join(root, 'src', 'one.mjs'), 'export const one = 1;\n');
+  await writeFile(join(root, 'src', 'two.mjs'), 'export const two = 2;\n');
+  return root;
+}
+
+const primaryProject = await makeProject();
+
+test.after(async () => {
+  drainCodeGraphCache();
+  await Promise.all([
+    rm(primaryProject, { recursive: true, force: true }),
+    rm(isolatedDataDir, { recursive: true, force: true }),
+  ]);
+  if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
+  else process.env.MIXDOG_DATA_DIR = previousDataDir;
+  if (previousGraphBin === undefined) delete process.env.MIXDOG_GRAPH_BIN;
+  else process.env.MIXDOG_GRAPH_BIN = previousGraphBin;
+});
+
+serialTest('aggregate file anchors recover an invalid cwd only for one project root', async () => {
+  const project = primaryProject;
+  const invalidCwd = parse(project).root;
+  const files = [join(project, 'src', 'one.mjs'), join(project, 'src', 'two.mjs')];
+  const relativeFiles = files.map((file) => relative(invalidCwd, file));
+  const result = await executeCodeGraphTool('code_graph', { mode: 'overview', files }, invalidCwd);
+  assert.match(result, new RegExp(`# overview ${files[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
+  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, '\\$&')}`));
+  drainCodeGraphCache();
+});
+
+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 scalarResult = await executeCodeGraphTool(
+    'code_graph',
+    { mode: 'overview', file: join(project, 'missing.mjs'), cwd: invalidCwd },
+    project,
+  );
+  assert.match(scalarResult, /^Error: code_graph: file not found:/);
+});
+
+serialTest('aggregate cwd recovery rejects missing and multi-root anchors', async () => {
+  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,
+    );
+  } finally {
+    await Promise.all([rm(first, { recursive: true, force: true }), rm(second, { recursive: true, force: true })]);
+  }
+});
+
+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`);
+    return file;
+  }));
+  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,
+    );
+    await assert.rejects(
+      executeCodeGraphTool('code_graph', { mode: 'overview', files: `${join(project, 'src', 'one.mjs')},${join(project, 'src', 'two.mjs')}` }, invalidCwd),
+      rejected,
+    );
+    await assert.rejects(
+      executeCodeGraphTool('code_graph', { mode: 'overview', files: [literalWildcard] }, invalidCwd),
+      rejected,
+    );
+  } finally {
+    await rm(project, { recursive: true, force: true });
+  }
+});

package/scripts/code-graph-description-contract.mjs

@@ -0,0 +1,185 @@
+const FILE_MODES = ['overview', 'imports', 'dependents', 'related', 'impact'];
+const SYMBOL_MODES = ['find_symbol', 'symbol_search', 'search', 'references', 'callers', 'callees'];
+const EXACT_MODES = ['find_symbol', 'references', 'callers', 'callees'];
+const KEYWORD_MODES = ['symbol_search', 'search'];
+const NEGATION = /\b(?:no|not|never|without|cannot|won['’]t|ain['’]t|(?:is|are|was|were|do|does|did|has|have|had|can|could|would|should|must)(?:\s+not|n['’]t)|will\s+not|fail(?:s|ed|ing)?\s+to)\b/i;
+
+const clauses = (text) => String(text || '').split(/[.;]\s*/).map((part) => part.trim()).filter(Boolean);
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const includesTerm = (text, term) => {
+  if (/^[a-z_][a-z0-9_]*$/i.test(term)) {
+    return new RegExp(`(?<![a-z0-9_])${escapeRegExp(term)}(?![a-z0-9_])`, 'i').test(text);
+  }
+  return text.toLowerCase().includes(term.toLowerCase());
+};
+const includesAll = (text, terms) => terms.every((term) => includesTerm(text, term));
+const hasPositiveClause = (text, terms) => clauses(text).some((clause) => !NEGATION.test(clause) && includesAll(clause, terms));
+const hasModeClause = (text, label, modes, target = null) => (
+  hasPositiveClause(text, [label, ...modes, ...(target ? [target] : [])])
+);
+const hasContradictoryTargetAssignment = (text) => (
+  hasPositiveClause(text, [...FILE_MODES, 'symbols[]'])
+  || hasPositiveClause(text, [...SYMBOL_MODES, 'files[]'])
+);
+const removeIdentifier = (text, identifier) => (
+  text.replace(new RegExp(`(?<![a-z0-9_])${escapeRegExp(identifier)}(?![a-z0-9_])`, 'gi'), '')
+);
+
+export const CODE_GRAPH_EQUIVALENT_DESCRIPTION_PROBES = [
+  {
+    description: [
+      'Keywords use search/symbol_search while callers/callees/references/find_symbol use exact identifiers.',
+      'symbols[] targets callees, search, references, symbol_search, callers, and find_symbol symbol modes.',
+      'files[] targets impact, related, dependents, imports, and overview file modes.',
+    ].join(' '),
+    modeDescription: [
+      'A file outline uses files[] for symbols with files.',
+      'Impact, related, dependents, imports, and overview are file modes.',
+      'Callees, callers, references, search, symbol_search, and find_symbol are symbol modes.',
+      'Keywords from fileless symbols route to symbol_search.',
+    ].join(' '),
+    symbolsDescription: [
+      'Keywords select search/symbol_search while callers/callees/references/find_symbol select exact identifiers.',
+      'Pass multiple exact symbols in one symbols[] call.',
+    ].join(' '),
+  },
+  {
+    description: [
+      'Exact identifiers route through callees, references, callers, or find_symbol.',
+      'Keywords route through search or symbol_search.',
+      'The overview, impact, imports, related, and dependents file modes accept files[].',
+      'The search, callees, find_symbol, references, symbol_search, and callers symbol modes accept symbols[].',
+    ].join(' '),
+    modeDescription: [
+      'Related, overview, impact, dependents, and imports are file modes.',
+      'Symbols with files produce a file outline from files[].',
+      'References, callers, callees, find_symbol, search, and symbol_search are symbol modes.',
+      'Fileless symbols treat keywords as symbol_search input.',
+    ].join(' '),
+    symbolsDescription: [
+      'Exact identifiers select references, callees, callers, or find_symbol.',
+      'Keywords select symbol_search or search.',
+      'Multiple exact symbols belong in one symbols[] call.',
+    ].join(' '),
+  },
+];
+
+export const CODE_GRAPH_DESCRIPTION_MUTATION_CORPUS = [
+  {
+    name: 'contracted negated file assignment',
+    mutate: (parts) => ({
+      ...parts,
+      description: parts.description.replace(/file modes take files\[\]/i, "file modes aren't assigned files[]"),
+    }),
+  },
+  {
+    name: 'contracted outline polarity inversion',
+    allPositiveProbes: true,
+    mutate: (parts) => ({
+      ...parts,
+      modeDescription: parts.modeDescription.replace(/file outline/i, "isn't a file outline"),
+    }),
+  },
+  {
+    name: 'keyword routing polarity inversion',
+    allPositiveProbes: true,
+    mutate: (parts) => ({
+      ...parts,
+      description: parts.description.replace(/keywords\s+(?:use|route through|select)/i, "keywords won't use"),
+    }),
+  },
+  {
+    name: 'symbols-with-files outline inversion',
+    allPositiveProbes: true,
+    mutate: (parts) => ({
+      ...parts,
+      modeDescription: parts.modeDescription.replace(/symbols with files/i, 'symbols without files'),
+    }),
+  },
+  {
+    name: 'exact-symbol one-call inversion',
+    allPositiveProbes: true,
+    mutate: (parts) => ({
+      ...parts,
+      symbolsDescription: parts.symbolsDescription.replace(/one symbols\[\] call/i, 'one files[] call'),
+    }),
+  },
+  {
+    name: 'contradictory file-mode assignment retained beside correct clause',
+    allPositiveProbes: true,
+    mutate: (parts) => ({
+      ...parts,
+      description: `${parts.description} Overview, imports, dependents, related, and impact take symbols[].`,
+    }),
+  },
+  {
+    name: 'contradictory symbol-mode assignment retained beside correct clause',
+    allPositiveProbes: true,
+    mutate: (parts) => ({
+      ...parts,
+      description: `${parts.description} Find_symbol, symbol_search, search, references, callers, and callees take files[].`,
+    }),
+  },
+  {
+    name: 'swapped file-mode/symbol-mode array assignments',
+    allPositiveProbes: true,
+    mutate: (parts) => ({
+      ...parts,
+      description: `${parts.description} Overview, imports, dependents, related, and impact take symbols[]. Find_symbol, symbol_search, search, references, callers, and callees take files[].`,
+    }),
+  },
+  {
+    name: 'standalone search removed from symbol modes and keyword routing',
+    allPositiveProbes: true,
+    mutate: (parts) => ({
+      ...parts,
+      description: removeIdentifier(parts.description, 'search'),
+      modeDescription: removeIdentifier(parts.modeDescription, 'search'),
+      symbolsDescription: removeIdentifier(parts.symbolsDescription, 'search'),
+    }),
+  },
+];
+
+export function hasCodeGraphDescriptionContract({ description, modeDescription, symbolsDescription }) {
+  return (
+    hasPositiveClause(description, ['file modes', 'files[]'])
+    && hasModeClause(description, 'symbol modes', SYMBOL_MODES, 'symbols[]')
+    && hasPositiveClause(description, ['exact identifiers', ...EXACT_MODES])
+    && hasPositiveClause(description, ['keywords', ...KEYWORD_MODES])
+    && !hasContradictoryTargetAssignment(description)
+    && hasModeClause(modeDescription, 'file modes', FILE_MODES)
+    && hasPositiveClause(modeDescription, ['symbols with files', 'files[]', 'file outline'])
+    && hasModeClause(modeDescription, 'symbol modes', SYMBOL_MODES)
+    && hasPositiveClause(modeDescription, ['fileless symbols', 'symbol_search', 'keywords'])
+    && !hasContradictoryTargetAssignment(modeDescription)
+    && hasPositiveClause(symbolsDescription, ['exact identifiers', ...EXACT_MODES])
+    && hasPositiveClause(symbolsDescription, ['keywords', ...KEYWORD_MODES])
+    && hasPositiveClause(symbolsDescription, ['multiple exact symbols', 'one symbols[] call'])
+    && !hasContradictoryTargetAssignment(symbolsDescription)
+  );
+}
+
+export function assertCodeGraphDescriptionContract(parts) {
+  if (!hasCodeGraphDescriptionContract(parts)) {
+    throw new Error('code_graph descriptions must preserve per-mode files[]/symbols[] batching and exact-vs-keyword routing');
+  }
+  for (const probe of CODE_GRAPH_EQUIVALENT_DESCRIPTION_PROBES) {
+    if (!hasCodeGraphDescriptionContract(probe)) {
+      throw new Error('code_graph description contract must accept equivalent reordered compact prose');
+    }
+    for (const mutation of CODE_GRAPH_DESCRIPTION_MUTATION_CORPUS.filter((entry) => entry.allPositiveProbes)) {
+      const mutated = mutation.mutate(probe);
+      if (JSON.stringify(mutated) === JSON.stringify(probe)) {
+        throw new Error(`code_graph description mutation did not apply to positive probe: ${mutation.name}`);
+      }
+      if (hasCodeGraphDescriptionContract(mutated)) {
+        throw new Error(`code_graph description contract accepted positive-probe mutation: ${mutation.name}`);
+      }
+    }
+  }
+  for (const mutation of CODE_GRAPH_DESCRIPTION_MUTATION_CORPUS) {
+    if (hasCodeGraphDescriptionContract(mutation.mutate(parts))) {
+      throw new Error(`code_graph description contract accepted mutation: ${mutation.name}`);
+    }
+  }
+}

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

@@ -1,16 +1,71 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {
+  _codeGraphWorkerFailure,
   _isCompatibleDiskCodeGraphEntry,
   _postCodeGraphWorkerSuccess,
+  _prewarmCodeGraph,
   _prepareDiskCodeGraphFastPath,
   _runDiskCodeGraphFastPath,
+  _spawnCodeGraphWorker,
   _validateDiskCodeGraphHit,
 } from '../src/runtime/agent/orchestrator/tools/code-graph/build.mjs';
 import { CODE_GRAPH_MAX_FILES } from '../src/runtime/agent/orchestrator/tools/code-graph/constants.mjs';
 import { _serializeGraph } from '../src/runtime/agent/orchestrator/tools/code-graph/graph-model.mjs';
 import { _persistDiskCodeGraphCacheNow } from '../src/runtime/agent/orchestrator/tools/code-graph/disk-cache.mjs';
 
+function workerMessage(message, hooks = {}) {
+  return _spawnCodeGraphWorker('/worker', '/worker', 0, null, () => {}, null, null, {
+    createWorker: () => ({
+      once(event, listener) {
+        if (event === 'message') queueMicrotask(() => listener(message));
+      },
+      terminate() {},
+    }),
+    getGeneration: () => 0,
+    setMemoryCache: () => {},
+    setDiskCache: () => {},
+    ...hooks,
+  });
+}
+
+test('Worker message path preserves success and validates failure text', async () => {
+  const graph = { signature: 'success', nodes: new Map() };
+  const memory = [];
+  const disk = [];
+  assert.equal(await workerMessage({ ok: true, signature: 'success', graph }, {
+    setMemoryCache: (cwd, entry) => memory.push({ cwd, entry }),
+    setDiskCache: (cwd, entry) => disk.push({ cwd, entry }),
+  }), graph);
+  assert.deepEqual(memory, [{ cwd: '/worker', entry: { ts: memory[0].entry.ts, signature: 'success', graph } }]);
+  assert.deepEqual(disk, [{ cwd: '/worker', entry: graph }]);
+  await assert.rejects(workerMessage({ ok: false, error: ' worker build failed ' }), /worker build failed/);
+  for (const message of [{ ok: false }, { ok: false, error: ' \t ' }, null]) {
+    await assert.rejects(workerMessage(message), /code-graph prewarm worker failed/);
+  }
+});
+
+test('worker failure protocol trims its error text', () => {
+  assert.equal(
+    _codeGraphWorkerFailure({ ok: false, error: ' disk cache flush failed ' }).message,
+    'disk cache flush failed',
+  );
+  for (const message of [{ ok: false }, { ok: false, error: '' }, { ok: false, error: ' \t ' }]) {
+    assert.equal(_codeGraphWorkerFailure(message).message, 'code-graph prewarm worker failed');
+  }
+});
+
+test('best-effort prewarm swallows build failures', () => {
+  let swallowed = false;
+  _prewarmCodeGraph('/worker', () => ({
+    catch(handler) {
+      swallowed = true;
+      handler(new Error('worker build failed'));
+    },
+  }));
+  assert.equal(swallowed, true);
+});
+
 test('signature-validated disk hit restores memory without a Worker build', async () => {
   const graph = { nodes: new Map() };
   let restored = null;

package/scripts/code-graph-dispatch-test.mjs

@@ -0,0 +1,96 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+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 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-dispatch-data-'));
+process.env.MIXDOG_DATA_DIR = 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');
+const project = await mkdtemp(join(tmpdir(), 'mixdog-code-graph-dispatch-project-'));
+const sourceDir = join(project, 'src');
+await mkdir(sourceDir);
+await writeFile(join(project, 'package.json'), '{}');
+await writeFile(join(sourceDir, 'one.mjs'), [
+  'export function alpha() { return beta(); }',
+  'export function beta() { return 2; }',
+  '',
+].join('\n'));
+await writeFile(join(sourceDir, 'two.mjs'), [
+  "import { alpha } from './one.mjs';",
+  'export function gamma() { return alpha(); }',
+  '',
+].join('\n'));
+
+test.after(async () => {
+  drainCodeGraphCache();
+  await Promise.all([
+    rm(project, { recursive: true, force: true }),
+    rm(isolatedDataDir, { recursive: true, force: true }),
+  ]);
+  if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
+  else process.env.MIXDOG_DATA_DIR = previousDataDir;
+  if (previousGraphBin === undefined) delete process.env.MIXDOG_GRAPH_BIN;
+  else process.env.MIXDOG_GRAPH_BIN = previousGraphBin;
+});
+
+test('dispatch partitions every file and symbol mode by its supported target array', async () => {
+  const files = ['src/one.mjs', 'src/two.mjs'];
+  const assertNoErrorBody = (mode, result) => {
+    assert.doesNotMatch(result, /(?:^|\n)Error:/i, `${mode} returned a caught/error body`);
+  };
+  const fileModeEvidence = {
+    overview: [/file: src\/one\.mjs/, /file: src\/two\.mjs/, /symbols:.*alpha/, /symbols:.*gamma/],
+    imports: [/# imports src\/two\.mjs[\s\S]*src\/one\.mjs/],
+    dependents: [/# dependents src\/one\.mjs[\s\S]*src\/two\.mjs/],
+    related: [/file\tsrc\/one\.mjs/, /file\tsrc\/two\.mjs/, /# related/],
+    impact: [/file\tsrc\/one\.mjs/, /file\tsrc\/two\.mjs/, /external_callers\t\d+/],
+    symbols: [/function alpha \(L1\)/, /function beta \(L2\)/, /function gamma \(L2\)/],
+  };
+  for (const mode of ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols']) {
+    const result = await executeCodeGraphTool('code_graph', { mode, files }, project);
+    assertNoErrorBody(mode, result);
+    for (const file of files) assert.match(result, new RegExp(`# ${mode} ${file.replace('.', '\\.')}`));
+    for (const evidence of fileModeEvidence[mode]) assert.match(result, evidence);
+  }
+
+  const exactModeEvidence = {
+    find_symbol: [/src\/one\.mjs:1/, /src\/one\.mjs:2/, /# candidates/],
+    references: [/src\/two\.mjs:2:\d+\s+export function gamma\(\) \{ return alpha\(\); \}/, /src\/one\.mjs:1:\d+\s+export function alpha\(\) \{ return beta\(\); \}/],
+    callers: [/caller=gamma/, /caller=alpha/],
+    callees: [/# callees/, /\bbeta\b/, /\(no callees\)/],
+  };
+  for (const mode of ['find_symbol', 'references', 'callers', 'callees']) {
+    const result = await executeCodeGraphTool('code_graph', {
+      mode,
+      symbols: ['alpha', 'beta'],
+      body: false,
+    }, project);
+    assertNoErrorBody(mode, result);
+    assert.match(result, new RegExp(`# ${mode} alpha\\b`));
+    assert.match(result, new RegExp(`# ${mode} beta\\b`));
+    for (const evidence of exactModeEvidence[mode]) assert.match(result, evidence);
+  }
+
+  for (const mode of ['symbol_search', 'search']) {
+    const result = await executeCodeGraphTool('code_graph', {
+      mode,
+      symbols: ['alp', 'bet'],
+      body: false,
+    }, project);
+    const routedMode = mode === 'search' ? 'symbol_search' : mode;
+    assertNoErrorBody(mode, result);
+    assert.match(result, new RegExp(`# ${routedMode} alp\\b`));
+    assert.match(result, new RegExp(`# ${routedMode} bet\\b`));
+    assert.match(result, /# search keyword=alp matches=\d+ shown=\d+[\s\S]*\balpha\b/);
+    assert.match(result, /# search keyword=bet matches=\d+ shown=\d+[\s\S]*\bbeta\b/);
+  }
+});

package/scripts/compact-pressure-test.mjs

@@ -396,6 +396,46 @@ test('provider baseline pressure includes only the configured extra reserve', ()
     assert.equal(resolveCompactionPressureTokens(1, policy, { messages, sessionRef: session }), 87_000);
 });
 
+test('context status uses the automatic compaction pressure numerator and trigger', () => {
+    const session = {
+        id: 'status-pressure',
+        provider: 'openai',
+        model: 'm',
+        tools: [],
+        contextWindow: 100_000,
+        messages: [{ role: 'user', content: 'small local estimate' }],
+        compaction: {},
+    };
+    recordProviderContextBaseline(session, session.messages, {
+        inputTokens: 80_000,
+        outputTokens: 2_000,
+    });
+    const policy = policyFor(session);
+    const expectedPressure = resolveCompactionPressureTokens(
+        estimateMessagesTokens(session.messages),
+        policy,
+        { messages: session.messages, sessionRef: session },
+    );
+    const { contextStatus } = createContextStatus({
+        getSession: () => session,
+        getRoute: () => ({ provider: 'openai', model: 'm' }),
+        getCurrentCwd: () => '',
+        getMode: () => 'default',
+    });
+
+    const status = contextStatus();
+    assert.equal(status.usedTokens, expectedPressure);
+    assert.equal(status.currentEstimatedTokens, expectedPressure);
+    assert.equal(status.compaction.triggerTokens, policy.triggerTokens);
+    assert.equal(
+        shouldCompactForSession(estimateMessagesTokens(session.messages), policy, {
+            messages: session.messages,
+            sessionRef: session,
+        }),
+        status.usedTokens >= status.compaction.triggerTokens,
+    );
+});
+
 test('provider baselines fingerprint actual sendTools and reject provider, model, tool-schema, and prefix changes', () => {
     const make = () => ({
         provider: 'openai',