mixdog 0.9.41 → 0.9.44

package/scripts/compact-pressure-test.mjs

@@ -1,9 +1,18 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { estimateMessagesTokens } from '../src/runtime/agent/orchestrator/session/context-utils.mjs';
+import {
+    estimateMessagesTokens,
+    estimateRequestReserveTokens,
+    estimateToolSchemaTokens,
+    estimateTokens,
+    IMAGE_VISUAL_TOKEN_ALLOWANCE,
+    summarizeContextMessages,
+} from '../src/runtime/agent/orchestrator/session/context-utils.mjs';
+import { createContextStatus } from '../src/session-runtime/context-status.mjs';
 import {
     compactionTelemetryPressureTokens,
     recordProviderContextBaseline,
+    resolveCompactionPressureTokens,
     rememberCompactTelemetry,
     resolveWorkerCompactPolicy,
     shouldCompactForSession,
@@ -26,6 +35,252 @@ test('Lead/main auto-compaction triggers at 95% of the effective boundary', () =
     assert.equal(agentPolicy.triggerTokens, 90_000, 'agent default 10% headroom must remain unchanged');
 });
 
+test('image payload bytes do not inflate live gauge or fallback compaction estimates', () => {
+    const text = 'Please describe the attached image.';
+    const imageData = 'A'.repeat(400_000);
+    const imagePart = { type: 'image', data: imageData, mimeType: 'image/png' };
+    const messages = [{
+        role: 'user',
+        content: [{ type: 'text', text }, imagePart],
+    }];
+    const plainTextEstimate = estimateTokens(text) + 4;
+    const fallbackEstimate = estimateMessagesTokens(messages);
+    const summaryEstimate = summarizeContextMessages(messages).estimatedTokens;
+
+    assert.equal(estimateMessagesTokens([{ role: 'user', content: text }]), plainTextEstimate,
+        'ordinary string estimates must remain unchanged');
+    assert.equal(fallbackEstimate, plainTextEstimate + IMAGE_VISUAL_TOKEN_ALLOWANCE,
+        'fallback compaction estimate must count text plus a visual image allowance');
+    const largerPayloadEstimate = estimateMessagesTokens([{
+        role: 'user',
+        content: [{ type: 'text', text }, { ...imagePart, data: imageData.repeat(2) }],
+    }]);
+    assert.equal(largerPayloadEstimate, fallbackEstimate,
+        'raw image byte length must not affect the visual allowance');
+    assert.equal(summaryEstimate, fallbackEstimate,
+        'display and fallback compaction must share the image-aware message estimate');
+
+    const session = {
+        id: 'image-context-test',
+        provider: 'openai',
+        contextWindow: 100_000,
+        rawContextWindow: 100_000,
+        compactBoundaryTokens: 100_000,
+        messages: [],
+        liveTurnMessages: messages,
+        tools: [],
+        compaction: {},
+    };
+    const { contextStatus } = createContextStatus({
+        getSession: () => session,
+        getRoute: () => ({ provider: 'openai', model: 'test-model' }),
+        getCurrentCwd: () => '',
+        getMode: () => 'default',
+    });
+    const status = contextStatus();
+    assert.ok(status.usedTokens < status.compaction.triggerTokens,
+        `image-aware live gauge must remain below compaction threshold, got ${status.usedTokens}`);
+    assert.ok(status.usedTokens < status.contextWindow,
+        `raw base64 must not pin the live gauge at 100%, got ${status.usedTokens}/${status.contextWindow}`);
+
+    recordProviderContextBaseline(session, messages, { inputTokens: 80_000, outputTokens: 0 });
+    const policy = { ...policyFor(session), reserveTokens: 0 };
+    assert.equal(
+        shouldCompactForSession(fallbackEstimate, policy, { messages, sessionRef: session }),
+        false,
+        'provider-backed pressure below threshold must remain below threshold',
+    );
+    assert.equal(imagePart.data, imageData,
+        'estimating live context must not sanitize or remove image content');
+});
+
+test('dense ASCII, encoded, and minified payloads do not retain the prose chars/4 estimate', () => {
+    for (const text of [
+        'A1b2C3d4E5f6G7h8'.repeat(100),
+        '%7B%22path%22%3A%22very%2Flong%2Fencoded%2Fvalue%22%7D'.repeat(40),
+        JSON.stringify({ rows: Array.from({ length: 100 }, (_, i) => ({ id: i, value: `item_${i}_abcdef` })) }),
+    ]) {
+        assert.ok(estimateTokens(text) >= Math.ceil(text.length * 0.7),
+            `dense ASCII estimate must be conservative (${estimateTokens(text)}/${text.length})`);
+    }
+    const shortJsonl = Array.from({ length: 200 }, (_, i) => `{"i":${i}}`).join('\n');
+    assert.ok(estimateTokens(shortJsonl) >= shortJsonl.replace(/\s/g, '').length * 0.7,
+        'short JSONL records must receive the structured multiline floor');
+    const spacedShortIdentifiers = 'A1b2C3d4E5 F6G7H8I9J0 '.repeat(100);
+    assert.ok(estimateTokens(spacedShortIdentifiers) >= spacedShortIdentifiers.length * 0.7,
+        'space-separated encoded identifiers below the long-run threshold must receive the dense floor');
+});
+
+test('assistantBlocks and reasoningItems count provider-visible data but not image bytes', () => {
+    const base = { role: 'assistant', content: '' };
+    const assistantBlocks = [
+        { type: 'text', text: 'native assistant replay' },
+        { type: 'tool_use', id: 'call_native', name: 'read', input: '{"path":"x"}' },
+        { type: 'image', data: 'Z'.repeat(300_000), mimeType: 'image/png' },
+    ];
+    const reasoningItems = [{ type: 'reasoning', encrypted_content: 'enc_'.repeat(2_000) }];
+    const estimated = estimateMessagesTokens([{ ...base, assistantBlocks, reasoningItems }]);
+    const noNativeReplay = estimateMessagesTokens([base]);
+    assert.ok(estimated > noNativeReplay + IMAGE_VISUAL_TOKEN_ALLOWANCE,
+        'native assistant blocks and opaque reasoning must contribute tokens');
+    assert.equal(
+        estimateMessagesTokens([{ ...base, assistantBlocks: assistantBlocks.map(block => (
+            block.type === 'image' ? { ...block, data: 'Z'.repeat(600_000) } : block
+        )), reasoningItems }]),
+        estimated,
+        'native replay image bytes must not be tokenized',
+    );
+});
+
+test('image allowance handles identity, detail, dimensions, and multiple accepted forms', () => {
+    const low = { type: 'image_url', image_url: { url: 'https://example.test/a.png', detail: 'low' } };
+    const tiled = {
+        type: 'input_image',
+        image_url: { url: 'https://example.test/b.png', detail: 'high' },
+        dimensions: { width: 2_048, height: 1_024 },
+    };
+    const inline = { inlineData: { data: 'A'.repeat(1_000), mimeType: 'image/png' }, width: 512, height: 512 };
+    const lowEstimate = estimateMessagesTokens([{ role: 'user', content: [low] }]);
+    const tiledEstimate = estimateMessagesTokens([{ role: 'user', content: [tiled] }]);
+    const multiEstimate = estimateMessagesTokens([{ role: 'user', content: [low, tiled, inline] }]);
+    assert.ok(tiledEstimate > lowEstimate, 'high-detail multi-tile image must reserve more than low detail');
+    assert.ok(lowEstimate >= IMAGE_VISUAL_TOKEN_ALLOWANCE + 4,
+        'unverified low-detail metadata must not reduce the conservative image fallback');
+    const unverifiedSmallDimensions = estimateMessagesTokens([{
+        role: 'user',
+        content: [{ type: 'image', data: 'A'.repeat(1_000), width: 1, height: 1, detail: 'low' }],
+    }]);
+    assert.ok(unverifiedSmallDimensions >= IMAGE_VISUAL_TOKEN_ALLOWANCE + 4,
+        'unverified tiny dimensions must not reduce the conservative image fallback');
+    assert.ok(multiEstimate > tiledEstimate + lowEstimate, 'every accepted image form must add visual allowance');
+
+    const session = { provider: 'openai', model: 'm', tools: [], contextWindow: 100_000, compaction: {} };
+    const messages = [{ role: 'user', content: [{ type: 'image', data: 'A'.repeat(1_000), mimeType: 'image/png' }] }];
+    const policy = policyFor(session);
+    recordProviderContextBaseline(session, messages, { inputTokens: 80_000 }, { sendTools: [] });
+    messages[0].content[0].data = 'B'.repeat(1_000);
+    assert.equal(
+        resolveCompactionPressureTokens(estimateMessagesTokens(messages), policy, { messages, sessionRef: session }),
+        estimateMessagesTokens(messages) + policy.reserveTokens,
+        'same-size image replacement must invalidate the measured prefix',
+    );
+});
+
+test('tool reserve and status cache detect nested schema mutation', () => {
+    const tools = [{ name: 'read', parameters: { type: 'object', properties: { path: { type: 'string' } } } }];
+    const beforeSchema = estimateToolSchemaTokens(tools);
+    const beforeReserve = estimateRequestReserveTokens(tools);
+    tools[0].parameters.properties.path.description = 'dense_nested_schema_description_'.repeat(200);
+    assert.ok(estimateToolSchemaTokens(tools) > beforeSchema);
+    assert.ok(estimateRequestReserveTokens(tools) > beforeReserve);
+
+    const session = { id: 'tool-cache', contextWindow: 100_000, messages: [{ role: 'user', content: 'x' }], tools, compaction: {} };
+    const { contextStatus } = createContextStatus({
+        getSession: () => session,
+        getRoute: () => ({ provider: 'openai', model: 'm' }),
+        getCurrentCwd: () => '',
+        getMode: () => 'default',
+    });
+    const statusBefore = contextStatus();
+    tools[0].parameters.properties.path.description += 'more_'.repeat(500);
+    const statusAfter = contextStatus();
+    assert.notEqual(statusAfter, statusBefore);
+    assert.ok(statusAfter.request.toolSchemaTokens > statusBefore.request.toolSchemaTokens);
+});
+
+test('native replay fingerprint detects encrypted reasoning and assistant 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' } }],
+    };
+    const messages = [message];
+    const first = summarizeContextMessages(messages).estimatedTokens;
+    message.reasoningItems[0].encrypted_content = 'encrypted_'.repeat(1_000);
+    const second = summarizeContextMessages(messages).estimatedTokens;
+    assert.ok(second > first, 'in-place encrypted_content mutation must invalidate the message memo');
+    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');
+});
+
+test('provider baseline pressure includes only the configured extra reserve', () => {
+    const session = { provider: 'openai', model: 'm', tools: [], contextWindow: 100_000, compaction: {} };
+    const messages = [{ role: 'user', content: 'baseline' }];
+    recordProviderContextBaseline(session, messages, { inputTokens: 80_000, outputTokens: 0 });
+    const policy = { ...policyFor(session), reserveTokens: 7_512, requestReserveTokens: 512, configuredReserveTokens: 7_000 };
+    assert.equal(resolveCompactionPressureTokens(1, policy, { messages, sessionRef: session }), 87_000);
+});
+
+test('provider baselines fingerprint actual sendTools and reject provider, model, tool-schema, and prefix changes', () => {
+    const make = () => ({
+        provider: 'openai',
+        model: 'm1',
+        tools: [{ name: 'read', parameters: { type: 'object' } }],
+        contextWindow: 100_000,
+        compaction: {},
+    });
+    const fallbackForMutation = (mutate) => {
+        const session = make();
+        const messages = [{ role: 'user', content: 'original prefix' }];
+        recordProviderContextBaseline(session, messages, { inputTokens: 80_000, outputTokens: 0 }, { sendTools: session.tools });
+        mutate(session, messages);
+        const policy = { ...resolveWorkerCompactPolicy(session, session.tools), reserveTokens: 0 };
+        return {
+            pressure: resolveCompactionPressureTokens(estimateMessagesTokens(messages), policy, { messages, sessionRef: session }),
+            fallback: estimateMessagesTokens(messages),
+        };
+    };
+    for (const mutate of [
+        session => { session.provider = 'anthropic'; },
+        session => { session.model = 'm2'; },
+        session => { session.tools[0].parameters.properties = { path: { type: 'string' } }; },
+        (_session, messages) => { messages[0].content = 'mutated earlier prefix'; },
+    ]) {
+        const result = fallbackForMutation(mutate);
+        assert.equal(result.pressure, result.fallback);
+    }
+    const session = make();
+    const messages = [{ role: 'user', content: 'forced tool request' }];
+    const actualSendTools = [session.tools[0]];
+    const matchingPolicy = resolveWorkerCompactPolicy(session, actualSendTools);
+    recordProviderContextBaseline(session, messages, { inputTokens: 80_000 }, { sendTools: actualSendTools });
+    session.tools = [{ name: 'different-session-tool', parameters: { type: 'object' } }];
+    assert.equal(
+        resolveCompactionPressureTokens(1, matchingPolicy, { messages, sessionRef: session }),
+        80_000,
+        'baseline must remain aligned to actual sendTools rather than mutable sessionRef.tools',
+    );
+    const changedSendPolicy = resolveWorkerCompactPolicy(session, session.tools);
+    assert.notEqual(
+        resolveCompactionPressureTokens(1, changedSendPolicy, { messages, sessionRef: session }),
+        80_000,
+        'a different next-send schema must invalidate the baseline',
+    );
+});
+
+test('context status cache notices mutation of an earlier message', () => {
+    const session = {
+        id: 'status-mutation',
+        contextWindow: 100_000,
+        messages: [{ role: 'user', content: 'short' }, { role: 'assistant', content: 'tail' }],
+        tools: [],
+        compaction: {},
+    };
+    const { contextStatus } = createContextStatus({
+        getSession: () => session,
+        getRoute: () => ({ provider: 'openai', model: 'm' }),
+        getCurrentCwd: () => '',
+        getMode: () => 'default',
+    });
+    const before = contextStatus();
+    session.messages[0].content = 'dense_earlier_message_'.repeat(1_000);
+    const after = contextStatus();
+    assert.notEqual(after, before);
+    assert.ok(after.usedTokens > before.usedTokens);
+});
+
 test('provider callback usage counts assistant output once and estimates only later tool results', () => {
     const session = { provider: 'anthropic', contextWindow: 100_000, compaction: {} };
     const policy = { ...policyFor(session), reserveTokens: 0 };

package/scripts/generate-runtime-manifest.mjs

@@ -3,13 +3,13 @@
 // Aggregator step run after all matrix build jobs succeed.
 // Reads release assets via gh CLI, filters mixdog-runtime-*.tar.gz,
 // fetches sha256 from .sha256 sidecar files, and emits runtime-manifest.json
-// to both dist/ and src/runtime/memory/data/ (for the auto-PR).
+// to both dist/ and src/runtime/memory/data/ (for the workflow branch sync).
 //
 // Environment:
 //   GITHUB_TOKEN  — PAT or GITHUB_TOKEN secret with contents:read
 //   RELEASE_TAG   — e.g. "runtime-v0.4.0" (falls back to process.argv[2])
 //   GITHUB_REPOSITORY — auto-set by Actions (e.g. "owner/repo")
-//   RUNTIME_RELEASE_REPOSITORY — override repo for gh commands (legacy trib-plugin/mixdog)
+//   RUNTIME_RELEASE_REPOSITORY — override repo for gh commands
 
 import { execSync } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
@@ -77,23 +77,23 @@ for (const t of tarballs) {
 async function fetchSha256(sha256AssetName, _downloadUrl) {
   // Try matching .sha256 sidecar from the asset list first
   const sidecar = assets.find(a => a.name === sha256AssetName);
-  if (sidecar) {
-    // Download the sidecar file text
-    try {
-      const tmpDir = resolve(tmpdir(), 'mixdog-manifest-sha256');
-      mkdirSync(tmpDir, { recursive: true });
-      execSync(
-        `gh release download ${RELEASE_TAG} --repo ${REPO} --pattern ${sha256AssetName} --dir "${tmpDir}" --clobber`,
-        { encoding: 'utf8', env: process.env }
-      );
-      const content = readFileSync(resolve(tmpDir, sha256AssetName), 'utf8').trim();
-      // Format: "<hex>  <filename>"
-      return content.split(/\s+/)[0];
-    } catch (e) {
-      console.warn(`Could not download sidecar ${sha256AssetName}: ${e.message}`);
-    }
+  if (!sidecar) {
+    throw new Error(`Missing required checksum sidecar: ${sha256AssetName}`);
   }
-  return 'TBD'; // fallback if sidecar not present
+
+  const tmpDir = resolve(tmpdir(), 'mixdog-manifest-sha256');
+  mkdirSync(tmpDir, { recursive: true });
+  execSync(
+    `gh release download ${RELEASE_TAG} --repo ${REPO} --pattern ${sha256AssetName} --dir "${tmpDir}" --clobber`,
+    { encoding: 'utf8', env: process.env }
+  );
+  const content = readFileSync(resolve(tmpDir, sha256AssetName), 'utf8').trim();
+  // Format: "<hex>  <filename>"
+  const checksum = content.split(/\s+/)[0];
+  if (!/^[a-f0-9]{64}$/i.test(checksum)) {
+    throw new Error(`Invalid checksum in sidecar ${sha256AssetName}: ${checksum}`);
+  }
+  return checksum.toLowerCase();
 }
 
 // ---------------------------------------------------------------------------
@@ -118,12 +118,29 @@ for (const tarball of tarballs) {
   };
 }
 
-// Ensure all expected platforms are present (fill missing with TBD)
+// A partial release must never produce a publishable or bundled manifest.
 const EXPECTED = ['linux-x64', 'linux-arm64', 'darwin-x64', 'darwin-arm64', 'win32-x64'];
+const missing = EXPECTED.filter(p => !assetsMap[p]);
+if (missing.length > 0) {
+  console.error(`Missing required runtime asset(s): ${missing.join(', ')}`);
+  process.exit(1);
+}
+
 for (const p of EXPECTED) {
-  if (!assetsMap[p]) {
-    console.warn(`WARNING: No asset found for platform ${p} — filling with TBD`);
-    assetsMap[p] = { url: 'TBD', sha256: 'TBD', size: 0 };
+  const asset = assetsMap[p];
+  let url;
+  try {
+    url = new URL(asset.url);
+  } catch {
+    console.error(`Invalid asset URL for ${p}: ${asset.url}`);
+    process.exit(1);
+  }
+  if (url.protocol !== 'https:' ||
+      !/^[a-f0-9]{64}$/.test(asset.sha256) ||
+      !Number.isSafeInteger(asset.size) ||
+      asset.size <= 0) {
+    console.error(`Invalid release metadata for ${p}: ${JSON.stringify(asset)}`);
+    process.exit(1);
   }
 }
 

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

@@ -0,0 +1,198 @@
+import test, { after } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+    existsSync,
+    mkdirSync,
+    mkdtempSync,
+    readFileSync,
+    readdirSync,
+    rmSync,
+    statSync,
+    writeFileSync,
+} from 'node:fs';
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { writeJsonAtomicSync } from '../src/runtime/shared/atomic-file.mjs';
+
+const root = mkdtempSync(join(tmpdir(), 'mixdog-grok-race-'));
+const tokenPath = join(root, 'grok-oauth.json');
+const moduleUrl = new URL(
+    '../src/runtime/agent/orchestrator/providers/grok-oauth.mjs',
+    import.meta.url,
+).href;
+
+after(() => {
+    rmSync(root, { recursive: true, force: true });
+});
+
+function writeTokens(accessToken, refreshToken, expiresAt) {
+    writeJsonAtomicSync(tokenPath, {
+        access_token: accessToken,
+        refresh_token: refreshToken,
+        expires_at: expiresAt,
+        token_endpoint: 'https://auth.x.ai/oauth/token',
+    }, { lock: true, fsyncDir: true, mode: 0o600, secret: true });
+}
+
+function waitForExit(child, label) {
+    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(`${label} exited ${code}: ${stderr}`));
+        });
+    });
+}
+
+async function waitForFiles(dir, count) {
+    const deadline = Date.now() + 30_000;
+    while (readdirSync(dir).length < count) {
+        if (Date.now() >= deadline) throw new Error('Grok race children did not become ready');
+        await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+}
+
+test('contending Grok processes adopt a refresh-only token rotation', async () => {
+    const readyDir = join(root, 'ready');
+    const exchangeDir = join(root, 'exchanges');
+    const resultDir = join(root, 'results');
+    const startPath = join(root, 'start');
+    mkdirSync(readyDir);
+    mkdirSync(exchangeDir);
+    mkdirSync(resultDir);
+    writeTokens('fixture-old-access', 'fixture-old-refresh', Date.now() + 1_000);
+
+    const childSource = `
+import { writeFileSync } from 'node:fs';
+const { GrokOAuthProvider } = await import(${JSON.stringify(moduleUrl)});
+const provider = Object.create(GrokOAuthProvider.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,
+  source: 'own'
+};
+provider._lastDiskScan = provider.tokens.mtimeMs;
+provider._refreshFallbackUntil = 0;
+writeFileSync(process.env.READY_PATH, 'ready');
+while (!(await (await import('node:fs/promises')).stat(process.env.START_PATH).catch(() => null))) {
+  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 text() {
+      return JSON.stringify({
+        access_token: 'fixture-old-access',
+        refresh_token: 'fixture-new-refresh-' + owner,
+        expires_in: 600
+      });
+    }
+  };
+};
+const tokens = await provider.ensureAuth();
+writeFileSync(process.env.RESULT_PATH, tokens.refresh_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,
+                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, `contention child ${index}`));
+    }
+
+    await waitForFiles(readyDir, 10);
+    writeFileSync(startPath, 'start');
+    await Promise.all(exits);
+
+    const exchanges = readdirSync(exchangeDir);
+    assert.equal(exchanges.length, 1);
+    const expectedRefresh = `fixture-new-refresh-${exchanges[0]}`;
+    const persisted = JSON.parse(readFileSync(tokenPath, 'utf8'));
+    assert.equal(persisted.access_token, 'fixture-old-access');
+    assert.equal(persisted.refresh_token, expectedRefresh);
+    for (const result of readdirSync(resultDir)) {
+        assert.equal(readFileSync(join(resultDir, result), 'utf8'), expectedRefresh);
+    }
+});
+
+test('invalid_grant adopts a valid token written by a peer without rotating it', async () => {
+    const requestStarted = join(root, 'invalid-request-started');
+    const peerWritten = join(root, 'invalid-peer-written');
+    const resultPath = join(root, 'invalid-result');
+    writeTokens('fixture-invalid-old-access', 'fixture-invalid-old-refresh', Date.now() + 1_000);
+
+    const childSource = `
+import { writeFileSync } from 'node:fs';
+const { GrokOAuthProvider } = await import(${JSON.stringify(moduleUrl)});
+const provider = Object.create(GrokOAuthProvider.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,
+  source: 'own'
+};
+provider._lastDiskScan = provider.tokens.mtimeMs;
+provider._refreshFallbackUntil = 0;
+let calls = 0;
+globalThis.fetch = async () => {
+  calls += 1;
+  writeFileSync(process.env.REQUEST_STARTED, 'started');
+  while (!(await (await import('node:fs/promises')).stat(process.env.PEER_WRITTEN).catch(() => null))) {
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  return {
+    ok: false,
+    status: 400,
+    async text() { return JSON.stringify({ error: 'invalid_grant' }); }
+  };
+};
+const tokens = await provider.ensureAuth();
+writeFileSync(process.env.RESULT_PATH, JSON.stringify({
+  adopted: tokens.access_token === 'fixture-peer-access',
+  calls
+}));
+`;
+    const child = spawn(process.execPath, ['--input-type=module', '--eval', childSource], {
+        env: {
+            ...process.env,
+            MIXDOG_DATA_DIR: root,
+            TOKEN_PATH: tokenPath,
+            REQUEST_STARTED: requestStarted,
+            PEER_WRITTEN: peerWritten,
+            RESULT_PATH: resultPath,
+        },
+        stdio: ['ignore', 'ignore', 'pipe'],
+    });
+    const exit = waitForExit(child, 'invalid_grant child');
+    const deadline = Date.now() + 30_000;
+    while (!existsSync(requestStarted)) {
+        if (Date.now() >= deadline) throw new Error('invalid_grant request did not start');
+        await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+
+    writeTokens('fixture-peer-access', 'fixture-peer-refresh', Date.now() + 10 * 60_000);
+    writeFileSync(peerWritten, 'written');
+    await exit;
+
+    assert.deepEqual(JSON.parse(readFileSync(resultPath, 'utf8')), { adopted: true, calls: 1 });
+    assert.ok(statSync(tokenPath).size > 0);
+});

package/scripts/internal-comms-bench.mjs

@@ -38,7 +38,6 @@ const RULE_FILES = [
   'agents/debugger/AGENT.md',
   'workflows/default/WORKFLOW.md',
   'workflows/solo/WORKFLOW.md',
-  'workflows/bench/WORKFLOW.md',
   'rules/lead/01-general.md',
   'rules/lead/02-channels.md',
   'rules/lead/lead-tool.md',