mixdog 0.9.45 → 0.9.47

package/scripts/memory-core-input-test.mjs

@@ -0,0 +1,137 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { normalizeCoreInput } from '../src/runtime/memory/lib/core-memory-store.mjs'
+import { createMemoryActionHandlers } from '../src/runtime/memory/lib/memory-action-handlers.mjs'
+
+test('core content aliases summary and derives a bounded element', () => {
+  const content = 'A durable preference that callers should receive concise answers.'
+  const input = normalizeCoreInput({ content, category: 'preference' }, {
+    requireElement: true,
+    requireSummary: true,
+    requireCategory: true,
+  })
+  assert.equal(input.summary, content)
+  assert.equal(input.element, content.slice(0, 40))
+  assert.deepEqual(input.errors, [])
+})
+
+test('core add reports every invalid field and cwd project hint together', async () => {
+  const cwd = await mkdtemp(join(tmpdir(), 'mixdog-core-input-'))
+  await mkdir(join(cwd, '.mixdog'))
+  await writeFile(join(cwd, '.mixdog', 'project.id'), 'owner/repo\n')
+  try {
+    const { handleMemoryAction } = createMemoryActionHandlers({
+      getDb: () => ({}),
+      dataDir: cwd,
+      readMainConfig: () => ({}),
+    })
+    const result = await handleMemoryAction({
+      action: 'core',
+      op: 'add',
+      cwd,
+      element: 'x'.repeat(41),
+      summary: 'y'.repeat(101),
+      category: 'unknown',
+    })
+    assert.equal(result.isError, true)
+    assert.equal(
+      result.text,
+      'core add: project_id required — pass "common" for COMMON pool, or project slug like "owner/repo" for scoped pool (cwd suggests "owner/repo"); element too long (41/40 chars, remove 1); summary too long (101/100 chars, remove 1); invalid category "unknown". Valid: rule, constraint, decision, fact, goal, preference, task, issue',
+    )
+  } finally {
+    await rm(cwd, { recursive: true, force: true })
+  }
+})
+
+test('core add rejects blank project_id in the batched error', async () => {
+  const { handleMemoryAction } = createMemoryActionHandlers({
+    getDb: () => ({}),
+    dataDir: tmpdir(),
+    readMainConfig: () => ({}),
+  })
+  const result = await handleMemoryAction({
+    action: 'core',
+    op: 'add',
+    project_id: ' ',
+    element: 'x'.repeat(41),
+    summary: 'y'.repeat(101),
+    category: 'unknown',
+  })
+  assert.equal(result.isError, true)
+  assert.match(result.text, /^core add: project_id required —/)
+  assert.match(result.text, /element too long \(41\/40 chars, remove 1\)/)
+  assert.match(result.text, /summary too long \(101\/100 chars, remove 1\)/)
+  assert.match(result.text, /invalid category "unknown"/)
+})
+
+test('core add folds project_id "*" into the batched error', async () => {
+  const { handleMemoryAction } = createMemoryActionHandlers({
+    getDb: () => ({}),
+    dataDir: tmpdir(),
+    readMainConfig: () => ({}),
+  })
+  const result = await handleMemoryAction({
+    action: 'core',
+    op: 'add',
+    project_id: '*',
+    element: 'x'.repeat(41),
+    summary: 'y'.repeat(101),
+    category: 'unknown',
+  })
+  assert.equal(result.isError, true)
+  assert.match(result.text, /^core add: project_id "\*" only valid for op="list"; element too long/)
+  assert.match(result.text, /summary too long \(101\/100 chars, remove 1\)/)
+  assert.match(result.text, /invalid category "unknown"/)
+})
+
+test('core add suppresses malformed cwd project hints', async () => {
+  const cwd = await mkdtemp(join(tmpdir(), 'mixdog-core-input-'))
+  await mkdir(join(cwd, '.mixdog'))
+  await writeFile(join(cwd, '.mixdog', 'project.id'), '/absolute/path\n')
+  try {
+    const { handleMemoryAction } = createMemoryActionHandlers({
+      getDb: () => ({}),
+      dataDir: cwd,
+      readMainConfig: () => ({}),
+    })
+    const result = await handleMemoryAction({
+      action: 'core',
+      op: 'add',
+      cwd,
+      element: 'durable preference',
+      summary: 'Callers prefer concise answers.',
+      category: 'preference',
+    })
+    assert.equal(result.text, 'core add: project_id required — pass "common" for COMMON pool, or project slug like "owner/repo" for scoped pool')
+  } finally {
+    await rm(cwd, { recursive: true, force: true })
+  }
+})
+
+test('core edit by id succeeds without project_id', async () => {
+  let call
+  const { handleMemoryAction } = createMemoryActionHandlers({
+    getDb: () => ({}),
+    dataDir: tmpdir(),
+    readMainConfig: () => ({}),
+    editCoreImpl: async (dataDir, id, patch) => {
+      call = { dataDir, id, patch }
+      return { id: Number(id), element: patch.element, summary: patch.summary, category: patch.category }
+    },
+  })
+  const result = await handleMemoryAction({
+    action: 'core',
+    op: 'edit',
+    id: 7,
+    element: 'reply style',
+    summary: 'Use concise answers.',
+    category: 'preference',
+  })
+  assert.equal(result.isError, undefined)
+  assert.equal(result.text, 'core edited (id=7): [preference] reply style — Use concise answers.')
+  assert.equal(call.id, 7)
+  assert.equal(call.patch.project_id, undefined)
+})

package/scripts/memory-rule-contract-test.mjs

@@ -48,8 +48,8 @@ test('cycle2 preserves essential taxonomy, phases, rejects, formats, and fields'
     'Anything unclear or outside these concepts is `archived`',
     '`phase1_new_chunks` → `active` if clearly essential, otherwise `archived`',
     '`phase2_reevaluate` → `active` to promote, otherwise `archived`',
-    '`phase3_active_review` requires every-row verdict: default `archived`, or `active`, `update`, `merge`',
-    'silence is not keep', 'work narratives', 'static facts without behavior/user value',
+    '`phase3_active_review` requires an `archived`, `active`, `update`, or `merge` verdict for every row',
+    'defaults to `archived`', 'never treats silence as keep', 'work narratives', 'static facts without behavior/user value',
     'rule-system meta', 'resolved bug/fix logs', 'rule-file duplicates',
     'single-run measurements/counts/versions', 'session-scoped or in-progress decisions',
     '<id>|<verb>', '<id>|update|<element>|<summary>',
@@ -59,7 +59,7 @@ test('cycle2 preserves essential taxonomy, phases, rejects, formats, and fields'
     'complete sentences in input language', 'preserve important specifics verbatim',
     'omit actor/meta filler', '`rule > constraint > decision > fact > goal > preference > task > issue`',
     'Replace literal `|` with `/`', 'fields contain no newlines',
-    'For phase 3, emit one verdict per input row', 'start with a digit',
+    'Start every verdict with a digit',
   ])
 })
 
@@ -70,7 +70,7 @@ test('cycle3 preserves durable-event verdicts, formats, and exceptions', () => {
     'rules, preferences, identity, goals, and current system/structure descriptions—not a log',
     'Each entry is one short clause (≤120 chars)',
     'Current rule/preference/live structure = durable',
-    'past event (shipped version, measured value, made fix) = not durable', 'When unsure, keep',
+    'past event = not durable', 'When unsure, keep',
     '`keep`: durable, already one short clause',
     '`update`: durable but verbose/multi-sentence; compress to one ≤120-char clause',
     '`merge`: duplicate; fold into its survivor in the same project pool',
@@ -81,7 +81,7 @@ test('cycle3 preserves durable-event verdicts, formats, and exceptions', () => {
     'IDs match input rows; never invent them', 'summary is one ≤120-char clause',
     '`element` is short', 'retains `target_id`, absorbs sources, and stays within one `project_id`',
     'Replace literal `|` with `/`', 'fields contain no newlines',
-    'Emit a verdict for every input row', 'start with a digit',
+    'Emit a digit-starting verdict for every input row',
   ])
 })
 

package/scripts/openai-oauth-refresh-race-test.mjs

@@ -0,0 +1,120 @@
+import test, { after } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const root = mkdtempSync(join(tmpdir(), 'mixdog-openai-race-'));
+const tokenPath = join(root, 'openai-oauth.json');
+const readyDir = join(root, 'ready');
+const exchangeDir = join(root, 'exchanges');
+const resultDir = join(root, 'results');
+const startPath = join(root, 'start');
+const moduleUrl = new URL(
+  '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs',
+  import.meta.url,
+).href;
+
+after(() => rmSync(root, { recursive: true, force: true }));
+
+function waitForExit(child) {
+  return new Promise((resolve, reject) => {
+    let stderr = '';
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.on('error', reject);
+    child.on('exit', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`OpenAI contention child exited ${code}: ${stderr}`));
+    });
+  });
+}
+
+test('contending OpenAI OAuth processes share one reread/exchange/write lock', async () => {
+  mkdirSync(readyDir);
+  mkdirSync(exchangeDir);
+  mkdirSync(resultDir);
+  writeFileSync(tokenPath, JSON.stringify({
+    access_token: 'fixture-old-access',
+    refresh_token: 'fixture-old-refresh',
+    expires_at: Date.now() + 1_000,
+  }));
+
+  const childSource = `
+import { existsSync, writeFileSync } from 'node:fs';
+const { OpenAIOAuthProvider } = await import(${JSON.stringify(moduleUrl)});
+const provider = Object.create(OpenAIOAuthProvider.prototype);
+provider.config = {};
+provider.tokens = {
+  ...JSON.parse(await (await import('node:fs/promises')).readFile(process.env.TOKEN_PATH, 'utf8')),
+  _mtimeMs: (await (await import('node:fs/promises')).stat(process.env.TOKEN_PATH)).mtimeMs
+};
+provider._lastDiskScan = provider.tokens._mtimeMs;
+provider._refreshFallbackUntil = 0;
+writeFileSync(process.env.READY_PATH, 'ready');
+while (!existsSync(process.env.START_PATH)) await new Promise((resolve) => setTimeout(resolve, 10));
+globalThis.fetch = async () => {
+  const owner = String(process.pid);
+  writeFileSync(process.env.EXCHANGE_DIR + '/' + owner, 'exchange', { flag: 'wx' });
+  await new Promise((resolve) => setTimeout(resolve, 75));
+  return {
+    ok: true,
+    status: 200,
+    async json() {
+      return {
+        access_token: 'fixture-new-access-' + owner,
+        refresh_token: 'fixture-new-refresh-' + owner,
+        expires_in: 600
+      };
+    }
+  };
+};
+const tokens = await provider.ensureAuth();
+writeFileSync(process.env.RESULT_PATH, tokens.access_token);
+`;
+
+  const exits = [];
+  for (let index = 0; index < 10; index += 1) {
+    const child = spawn(process.execPath, ['--input-type=module', '--eval', childSource], {
+      env: {
+        ...process.env,
+        MIXDOG_DATA_DIR: root,
+        OPENAI_OAUTH_CREDENTIALS_PATH: tokenPath,
+        TOKEN_PATH: tokenPath,
+        READY_PATH: join(readyDir, String(index)),
+        START_PATH: startPath,
+        EXCHANGE_DIR: exchangeDir,
+        RESULT_PATH: join(resultDir, String(index)),
+      },
+      stdio: ['ignore', 'ignore', 'pipe'],
+    });
+    exits.push(waitForExit(child));
+  }
+
+  const deadline = Date.now() + 30_000;
+  while (readdirSync(readyDir).length < 10) {
+    if (Date.now() >= deadline) throw new Error('OpenAI contention children did not become ready');
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  }
+  writeFileSync(startPath, 'start');
+  await Promise.all(exits);
+
+  const exchanges = readdirSync(exchangeDir);
+  assert.equal(exchanges.length, 1);
+  const winner = exchanges[0];
+  const expected = `fixture-new-access-${winner}`;
+  assert.equal(JSON.parse(readFileSync(tokenPath, 'utf8')).access_token, expected);
+  for (const result of readdirSync(resultDir)) {
+    assert.equal(readFileSync(join(resultDir, result), 'utf8'), expected);
+  }
+  assert.equal(existsSync(`${tokenPath}.refresh.lock`), false);
+});

package/scripts/openai-oauth-ws-1006-retry-test.mjs

@@ -51,6 +51,32 @@ test('pre-response 1006 opens a fresh WS and replays the same request', async ()
     assert.equal(result.__midstreamRetries, 1);
 });
 
+test('successful iteration emits one compact send-spans row', async () => {
+    const rows = [];
+    const result = await sendViaWebSocket(wsArgs({
+        _sendSpanTraceFn: (row) => rows.push(row),
+        _acquireWithRetryFn: async (opts) => {
+            opts.onRetry?.({ classifier: 'timeout' });
+            opts.onRetry?.({ classifier: 'timeout' });
+            return { entry: entry(), reused: true };
+        },
+        _streamFn: async ({ state }) => {
+            state.sendSpan.firstEventMs += 7;
+            state.sendSpan.preResponseCreatedMs += 9;
+            return { content: 'ok', model: 'gpt-5.5', toolCalls: [], usage: {}, closeSocket: true };
+        },
+    }));
+    assert.equal(result.content, 'ok');
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].kind, 'send_spans');
+    assert.equal(rows[0].payload.acquire_mode, 'reused');
+    assert.equal(rows[0].payload.acquire_attempts, 1);
+    assert.equal(rows[0].payload.handshake_retries, 2);
+    assert.equal(rows[0].payload.first_event_ms, 7);
+    assert.equal(rows[0].payload.pre_response_created_ms, 9);
+    assert.equal('body' in rows[0].payload, false);
+});
+
 test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async () => {
     const savedEnv = Object.fromEntries([
         'MIXDOG_OAI_TRANSPORT',

package/scripts/parent-abort-link-test.mjs

@@ -25,6 +25,28 @@ test('markSessionError drops parent AbortSignal listener but keeps runtime entry
   assert.equal(childAborted, false);
 });
 
+test('an already/early-aborted parent signal is retained and re-cascades onto a swapped controller', () => {
+  const sessionId = `parent-abort-early-${Date.now()}`;
+  const parent = new AbortController();
+  parent.abort(new Error('canceled before dispatch'));
+  linkParentSignalToSession(sessionId, parent.signal);
+  const runtime = getSessionRuntime(sessionId);
+  // The controller present at link time was aborted up front...
+  assert.equal(runtime.controller.signal.aborted, true);
+  // ...and the parent signal is RETAINED (listener null: nothing left to fire)
+  // so askSession's fresh-controller swap can detect + re-cascade the early abort.
+  assert.ok(runtime.parentAbortLink?.signal === parent.signal);
+  assert.equal(runtime.parentAbortLink.listener, null);
+  // Simulate askSession swapping in a fresh (non-aborted) controller, then
+  // re-linking the retained parent signal: the early abort must re-cascade so
+  // provider computation actually aborts instead of running detached.
+  const linked = runtime.parentAbortLink.signal;
+  runtime.controller = null;
+  linkParentSignalToSession(sessionId, linked);
+  assert.equal(runtime.controller.signal.aborted, true,
+    'early parent abort re-cascaded onto the freshly swapped controller');
+});
+
 test('markSessionCancelled drops parent AbortSignal listener but keeps runtime entry', () => {
   const sessionId = `parent-abort-cancel-${Date.now()}`;
   const parent = new AbortController();

package/scripts/provider-toolcall-test.mjs

@@ -36,6 +36,7 @@ import {
 } from '../src/runtime/agent/orchestrator/providers/openai-ws-delta.mjs';
 import {
     _cacheObservationForTest,
+    _cacheContinuityResetReasonForTest,
 } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
 import {
     _withCodexWsClientMetadata,
@@ -1679,6 +1680,27 @@ test('openai oauth ws cache observation detects warm zero and partial retreats',
     });
     assert.equal(healthy.actualMiss, false);
     assert.equal(healthy.missReason, null);
+
+    const compacted = _cacheObservationForTest({
+        entry: { promptCacheMaxCachedTokens: 255_488 },
+        result: { usage: { inputTokens: 21_066, promptTokens: 21_066, cachedTokens: 8_704 } },
+        continuityResetReason: 'input_prefix_mismatch',
+    });
+    assert.equal(compacted.actualMiss, false, 'intentional prompt rewrite must reset the old high-water');
+    assert.equal(compacted.wasWarm, false);
+
+    const previousInput = [{ type: 'message', role: 'user', content: 'old long transcript' }];
+    const rewrittenBody = { model: 'gpt-5.5', input: [{ type: 'message', role: 'user', content: 'compact summary' }] };
+    assert.equal(_cacheContinuityResetReasonForTest({
+        mode: 'full',
+        deltaReason: 'full_default',
+        entry: {
+            lastResponseId: 'resp_old',
+            lastRequestSansInput: _stableStringify(_sansInput(rewrittenBody)),
+            lastRequestInput: previousInput,
+        },
+        body: rewrittenBody,
+    }), 'input_prefix_mismatch', 'ws-full must detect prompt rewrites hidden by full_default');
 });
 
 // === 10. OpenAI transport-policy switch (MIXDOG_OAI_TRANSPORT) ==============

package/scripts/reactive-compact-persist-smoke.mjs

@@ -83,6 +83,9 @@ const session = {
   contextWindow: 12_000,
   rawContextWindow: 12_000,
   compactBoundaryTokens: 12_000,
+  // Keep this fixture on the reactive-overflow path; main/user now compacts at
+  // 75% by default, while this explicit sub-boundary limit remains authoritative.
+  autoCompactTokenLimit: 11_500,
   compaction: { auto: true, semantic: true, type: 1, compactType: 1, lastStage: 'compacting' },
   cwd: process.cwd(),
   sessionStartMetaInjected: true,
@@ -107,9 +110,9 @@ try {
 // exact "memory pipeline broken" condition the fail-safe must cover. Assert the
 // fail-safe: recall-fasttrack aborts rather than dropping head behind a false
 // "Full history is in memory" notice, so no context is silently lost and the
-// overflow is surfaced instead of being masked by an empty summary shell.
-assert(threw, 'askSession should surface overflow error');
-assert(thrownCode === 'AGENT_CONTEXT_OVERFLOW', `expected AGENT_CONTEXT_OVERFLOW, got ${thrownCode}`);
+// compaction failure is surfaced instead of being masked by an empty summary shell.
+assert(threw, 'askSession should surface compaction failure');
+assert(thrownCode === 'AGENT_COMPACT_FAILED', `expected AGENT_COMPACT_FAILED, got ${thrownCode}`);
 // Recall-fasttrack aborted (memory failed), so the reactive retry never produced
 // a smaller transcript to re-send: exactly one failing main send, no LLM compact.
 assert(mainSendCount === 1, `expected 1 main send (reactive retry aborted by fail-safe), got ${mainSendCount}`);
@@ -135,6 +138,7 @@ assert(
   'current user turn should remain in persisted transcript',
 );
 assert(reloaded.compaction?.lastStage === 'overflow_failed', `compaction lastStage should be overflow_failed, got ${reloaded.compaction?.lastStage}`);
-assert(reloaded.providerState === undefined, 'providerState should clear after reactive compact abort');
+assert(reloaded.providerState?.xaiResponses?.previousResponseId === 'stale-after-compact',
+  'providerState should remain when a failed reactive compact leaves the transcript unchanged');
 
 process.stdout.write('reactive-compact-persist smoke passed ✓\n');

package/scripts/session-bench.mjs

@@ -52,6 +52,9 @@ const opts = {
 };
 
 function defaultTracePath() {
+  if (process.env.MIXDOG_AGENT_TRACE_PATH) {
+    return resolve(process.env.MIXDOG_AGENT_TRACE_PATH);
+  }
   const data = process.env.MIXDOG_DATA_DIR || resolvePluginData() || resolve(homedir(), '.mixdog', 'data');
   return resolve(data, 'history', 'agent-trace.jsonl');
 }
@@ -129,32 +132,6 @@ function toolArgsHash(row) {
   return field(row, 'tool_args_hash') || hashValue(args);
 }
 
-function grepPatternTerms(pattern) {
-  const raw = Array.isArray(pattern) ? pattern.join('|') : String(pattern || '');
-  return [...new Set(raw
-    .split(/[|,\s()"'`[\]{}.*+?^$\\:-]+/g)
-    .map((s) => s.trim().toLowerCase())
-    .filter((s) => s.length >= 4))];
-}
-
-function normalizePathForCompare(pathValue) {
-  return String(pathValue || '.')
-    .replace(/\\/g, '/')
-    .replace(/^([A-Za-z]):/, (_, d) => d.toLowerCase() + ':')
-    .replace(/\/+/g, '/')
-    .replace(/\/$/, '') || '.';
-}
-
-function grepSweepKey(row) {
-  const args = toolArgs(row) || {};
-  const path = normalizePathForCompare(String(args.path || '.'));
-  const glob = Array.isArray(args.glob) ? args.glob.join(',') : String(args.glob || '');
-  const terms = grepPatternTerms(args.pattern).slice(0, 3).join('|');
-  return `${path}::${glob}::${terms}`;
-}
-
-const GREP_SWEEP_MIN_CALLS = 20;
-const GREP_SWEEP_MIN_UNIQUE = 16;
 const READONLY_TOOL_NAMES = new Set(['read', 'grep', 'glob', 'list', 'find', 'code_graph', 'recall', 'explore', 'search', 'web_fetch']);
 const READONLY_STALL_MIN_RUN = 8;
 const READONLY_ROLE_AGENTS = new Set(['reviewer', 'explore', 'explorer', 'debugger']);
@@ -691,37 +668,6 @@ function buildToolDiagnostics(rows, failureRows = []) {
   }
   readFragmentation.sort((a, b) => b.count - a.count);
 
-  const grepSweeps = [];
-  for (const [sid, srows] of groupBy(tools.filter((r) => field(r, 'tool_name') === 'grep'), sessionId).entries()) {
-    const sorted = [...srows].sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
-    let cluster = [];
-    const flush = () => {
-      if (cluster.length < GREP_SWEEP_MIN_CALLS) { cluster = []; return; }
-      const unique = new Set(cluster.map(grepSweepKey));
-      const spanMs = Number(cluster[cluster.length - 1].ts || 0) - Number(cluster[0].ts || 0);
-      if (unique.size >= GREP_SWEEP_MIN_UNIQUE && spanMs <= 10 * 60_000) {
-        const pathCounts = countBy(cluster, (r) => normalizePathForCompare(String((toolArgs(r) || {}).path || '.'))).slice(0, 3);
-        const patterns = cluster.slice(0, 5).map((r) => compactText(String((toolArgs(r) || {}).pattern || ''), 70));
-        grepSweeps.push({
-          session_id: sid,
-          count: cluster.length,
-          unique_queries: unique.size,
-          span_ms: spanMs,
-          paths: pathCounts.map(([path, count]) => ({ path, count })),
-          examples: patterns,
-        });
-      }
-      cluster = [];
-    };
-    for (const row of sorted) {
-      const prev = cluster[cluster.length - 1];
-      if (!prev || Number(row.ts || 0) - Number(prev.ts || 0) <= 45_000) cluster.push(row);
-      else { flush(); cluster = [row]; }
-    }
-    flush();
-  }
-  grepSweeps.sort((a, b) => b.count - a.count || b.unique_queries - a.unique_queries);
-
   const singleToolBatches = rows.filter((r) => r.kind === 'batch' && Number(field(r, 'tool_call_count')) === 1)
     .sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
   let missedParallelism = 0;
@@ -875,7 +821,6 @@ function buildToolDiagnostics(rows, failureRows = []) {
     failed_repeats: failedRepeats.slice(0, 20),
     broad_results: broadResults.slice(0, 20),
     read_fragmentation: readFragmentation.slice(0, 20),
-    grep_sweeps: grepSweeps.slice(0, 20),
     missed_parallelism_heuristic: {
       consecutive_single_tool_batches: missedParallelism,
       single_tool_batches: singleToolBatches.length,
@@ -1268,10 +1213,6 @@ function buildIssues(routeGroups, cache, tools) {
   for (const frag of tools.read_fragmentation.slice(0, 5)) {
     issues.push({ severity: 'low', type: 'read_fragmentation', message: `read fragmentation x${frag.count} within ${frag.line_span} lines: ${frag.path}` });
   }
-  for (const sweep of (tools.grep_sweeps || []).slice(0, 3)) {
-    const scope = sweep.paths?.[0]?.path || '-';
-    issues.push({ severity: 'low', type: 'grep_sweep', message: `grep sweep x${sweep.count}/${sweep.unique_queries} over ${fmtMs(sweep.span_ms)} in ${scope}`, session_id: sweep.session_id });
-  }
   if (tools.missed_parallelism_heuristic.consecutive_single_tool_batches >= 3) {
     issues.push({ severity: 'low', type: 'missed_parallelism', message: `${tools.missed_parallelism_heuristic.consecutive_single_tool_batches} close consecutive single-tool batches` });
   }
@@ -1651,14 +1592,6 @@ function renderText(report) {
       lines.push('read fragmentation:');
       for (const f of report.tools.read_fragmentation.slice(0, 10)) lines.push(`- x${f.count} span=${f.line_span} lines: ${f.path}`);
     }
-    if (report.tools.grep_sweeps?.length) {
-      lines.push('grep sweeps:');
-      for (const s of report.tools.grep_sweeps.slice(0, 8)) {
-        const scope = s.paths?.map((p) => `${p.count}×${p.path}`).join(', ') || '-';
-        lines.push(`- x${s.count}/${s.unique_queries} span=${fmtMs(s.span_ms)} scope=${scope}`);
-        if (s.examples?.length) lines.push(`  e.g. ${s.examples.join(' | ')}`);
-      }
-    }
     if (report.tools.sequential_tool_clusters?.length) {
       lines.push('sequential single-tool clusters:');
       for (const c of report.tools.sequential_tool_clusters.slice(0, 8)) {

package/scripts/task-bench.mjs

@@ -55,7 +55,6 @@ function scorecard(report) {
   const issues = Array.isArray(report.issues) ? report.issues : [];
   const antipatterns =
     (tools.read_fragmentation?.length || 0) +
-    (tools.grep_sweeps?.length || 0) +
     (tools.sequential_tool_clusters?.length || 0) +
     (tools.duplicates?.length || 0) +
     (tools.failed_repeats?.length || 0);
@@ -94,7 +93,6 @@ function scorecard(report) {
     issues: issues.length,
     issue_types: uniq(issues.map((i) => i?.type)),
     read_fragmentation_paths: uniq((tools.read_fragmentation || []).map((f) => f?.path)),
-    grep_sweep_count: (tools.grep_sweeps || []).length,
   };
 }
 

package/scripts/terminal-bench-isolation-guards-test.mjs

@@ -0,0 +1,102 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+process.env.MIXDOG_DISABLE_MCP = '1';
+process.env.MIXDOG_DISABLE_SKILLS = '1';
+
+const {
+  buildSkillManifest,
+  buildSkillToolDefs,
+  collectSkills,
+  collectSkillsCached,
+  loadSkillResource,
+} = await import('../src/runtime/agent/orchestrator/context/collect.mjs');
+const { seedBundledSkills } = await import('../src/standalone/seeds.mjs');
+const { createMcpGlue } = await import('../src/session-runtime/mcp-glue.mjs');
+
+test('skills guard suppresses discovery, bundled seeding, prompt, and tool exposure', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-tb-skill-guard-'));
+  try {
+    const bundled = join(root, 'defaults', 'skills', 'bundled');
+    const project = join(root, 'project', '.mixdog', 'skills', 'project');
+    const data = join(root, 'data');
+    for (const dir of [bundled, project]) mkdirSync(dir, { recursive: true });
+    writeFileSync(join(bundled, 'SKILL.md'), '---\nname: bundled\n---\nsecret');
+    writeFileSync(join(project, 'SKILL.md'), '---\nname: project\n---\nsecret');
+
+    seedBundledSkills({ rootDir: root, dataDir: data });
+    assert.equal(readFileSync(join(bundled, 'SKILL.md'), 'utf8').includes('secret'), true);
+    assert.deepEqual(collectSkills(join(root, 'project')), []);
+    assert.deepEqual(collectSkillsCached(join(root, 'project')), []);
+    assert.equal(loadSkillResource('project', join(root, 'project')), null);
+    assert.equal(buildSkillManifest([{ name: 'injected', description: 'secret' }]), '');
+    assert.deepEqual(
+      buildSkillToolDefs([{ name: 'injected' }], { ownerIsAgentSession: true }),
+      [],
+    );
+    const runtimeCore = readFileSync(
+      fileURLToPath(new URL('../src/session-runtime/runtime-core.mjs', import.meta.url)),
+      'utf8',
+    );
+    assert.match(
+      runtimeCore,
+      /envFlag\('MIXDOG_DISABLE_SKILLS'\) \? \[\] : \[SKILL_TOOL\]/,
+    );
+    assert.throws(
+      () => readFileSync(join(data, 'skills', 'bundled', 'SKILL.md'), 'utf8'),
+      /ENOENT/,
+    );
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('MCP guard ignores config and project sources and disconnects without connecting', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-tb-mcp-guard-'));
+  try {
+    writeFileSync(
+      join(root, '.mcp.json'),
+      JSON.stringify({ mcpServers: { project: { command: 'personal-project' } } }),
+    );
+    const calls = [];
+    const glue = createMcpGlue({
+      mcpClient: {
+        getMcpServerStatus: () => [{ name: 'stale', connected: true }],
+        connectMcpServers: async () => calls.push('connect'),
+        disconnectAll: async () => calls.push('disconnect-all'),
+        disconnectMcpServer: async (name) => calls.push(`disconnect:${name}`),
+      },
+      getConfig: () => ({
+        mcpServers: { configured: { command: 'personal-config' } },
+      }),
+      getCurrentCwd: () => root,
+      state: {
+        mcpFailures: [{ name: 'personal', msg: 'secret' }],
+        mcpConnectGeneration: 0,
+        mcpConnectInFlight: null,
+      },
+    });
+
+    assert.deepEqual(glue.resolveEffectiveMcpServers(), { servers: {}, sources: {} });
+    assert.deepEqual(glue.mcpStatus(), {
+      servers: [],
+      configuredCount: 0,
+      connectedCount: 0,
+      failedCount: 0,
+    });
+    await glue.connectConfiguredMcp({ reset: true });
+    assert.deepEqual(calls, ['disconnect-all']);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});