mixdog 0.7.17 → 0.8.0

package/scripts/test-fault-inject.mjs

@@ -1,164 +0,0 @@
-// Fault-injection test: a victim acquires the advisory lock then is SIGKILL'd
-// (release never runs). Followers must detect the orphan via isPidAlive=false,
-// cleanup the lockfile, and succeed.
-import { spawn } from 'child_process';
-import {
-    mkdtempSync, writeFileSync, readFileSync, existsSync, statSync,
-    readdirSync, rmSync,
-} from 'fs';
-import { tmpdir } from 'os';
-import { join, dirname, basename } from 'path';
-import { fileURLToPath } from 'url';
-import { performance } from 'perf_hooks';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const repoRoot = dirname(__dirname);
-
-const atomicModUrl = 'file://' + join(repoRoot, 'src/agent/orchestrator/tools/builtin/atomic-write.mjs').replace(/\\/g, '/');
-const lockModUrl = 'file://' + join(repoRoot, 'src/agent/orchestrator/tools/builtin/advisory-lock.mjs').replace(/\\/g, '/');
-
-function snapshot(p) {
-    try {
-        const s = statSync(p);
-        return { exists: true, size: s.size, mtimeMs: s.mtimeMs, ino: s.ino };
-    } catch { return { exists: false }; }
-}
-
-// --- Victim mode ---
-if (process.argv[2] === '--victim') {
-    const target = process.argv[3];
-    const { acquireAdvisoryLock } = await import(lockModUrl);
-    const handle = await acquireAdvisoryLock(target, { timeoutMs: 5000 });
-    process.stdout.write(JSON.stringify({
-        event: 'acquired', pid: process.pid, lockFile: handle.lockFile,
-    }) + '\n');
-    // Block forever — parent will SIGKILL
-    await new Promise(() => { /* never resolves */ });
-}
-
-// --- Follower mode ---
-if (process.argv[2] === '--follower') {
-    const target = process.argv[3];
-    const content = process.argv[4];
-    const { atomicWrite } = await import(atomicModUrl);
-    const { acquireAdvisoryLock } = await import(lockModUrl);
-    const t0 = performance.now();
-    try {
-        const acquireT0 = Date.now();
-        const handle = await acquireAdvisoryLock(target, { timeoutMs: 15000 });
-        const acquireT1 = Date.now();
-        try {
-            await atomicWrite(target, content, { expectedTargetSnapshot: snapshot(target) });
-        } finally { handle.release(); }
-        const dt = +(performance.now() - t0).toFixed(2);
-        process.stdout.write(JSON.stringify({
-            ok: true, pid: process.pid, dt, acquireMs: acquireT1 - acquireT0,
-        }) + '\n');
-        process.exit(0);
-    } catch (err) {
-        process.stdout.write(JSON.stringify({
-            ok: false, code: err.code, msg: String(err.message).slice(0, 150), pid: process.pid,
-        }) + '\n');
-        process.exit(1);
-    }
-}
-
-// --- Driver ---
-const dir = mkdtempSync(join(tmpdir(), 'fault-inject-'));
-const target = join(dir, 'target.txt');
-writeFileSync(target, 'INITIAL\n');
-const lockFile = join(dir, '.target.txt.mixdog-lock');
-
-console.log('=== Fault injection: victim SIGKILL + 5 followers ===');
-console.log('dir=' + dir);
-
-// 1. Spawn victim, wait for acquire signal
-const victim = spawn(process.execPath, [__filename, '--victim', target], {
-    stdio: ['ignore', 'pipe', 'pipe'],
-});
-let victimOut = '';
-victim.stdout.on('data', d => { victimOut += d; });
-// Pre-attach the close listener BEFORE kill — otherwise SIGKILL fires the
-// close event before the listener is attached and the driver hangs forever.
-const victimClosed = new Promise(r => victim.on('close', code => r(code)));
-
-const deadline = Date.now() + 5000;
-while (!/acquired/.test(victimOut) && Date.now() < deadline) {
-    await new Promise(r => setTimeout(r, 10));
-}
-if (!/acquired/.test(victimOut)) {
-    console.error('FAIL: victim did not acquire within 5s');
-    victim.kill('SIGKILL');
-    rmSync(dir, { recursive: true, force: true });
-    process.exit(1);
-}
-const victimInfo = JSON.parse(victimOut.trim().split('\n').pop());
-console.log('victim acquired: pid=' + victimInfo.pid + ' lockfile=' + basename(victimInfo.lockFile));
-
-// 2. SIGKILL victim — release() never runs
-const killT0 = Date.now();
-victim.kill('SIGKILL');
-await victimClosed;
-const killT1 = Date.now();
-console.log('SIGKILL sent + victim closed in ' + (killT1 - killT0) + 'ms');
-
-// 3. Verify lockfile remains (orphan)
-if (!existsSync(lockFile)) {
-    console.error('FAIL: lockfile vanished after SIGKILL — release ran? unexpected.');
-    rmSync(dir, { recursive: true, force: true });
-    process.exit(1);
-}
-console.log('orphan lockfile remains: ' + readFileSync(lockFile, 'utf8'));
-
-// 4. Spawn 5 followers in parallel
-const N = 5;
-const followerStart = Date.now();
-const followerProcs = [];
-for (let i = 0; i < N; i += 1) {
-    const f = spawn(process.execPath, [__filename, '--follower', target, 'FOLLOWER-' + i + '\n'], {
-        stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    let out = '';
-    f.stdout.on('data', d => { out += d; });
-    followerProcs.push(new Promise(res => f.on('close', code => {
-        try {
-            res({ code, ...JSON.parse(out.trim().split('\n').pop()) });
-        } catch {
-            res({ code, ok: false, raw: out.slice(-100) });
-        }
-    })));
-}
-const results = await Promise.all(followerProcs);
-const followerWallMs = Date.now() - followerStart;
-
-// 5. Verify final state
-const okCount = results.filter(r => r.ok).length;
-const finalContent = readFileSync(target, 'utf8');
-const isValid = /^FOLLOWER-\d+\n?$/.test(finalContent);
-const leftovers = readdirSync(dir).filter(n =>
-    n.endsWith('.mixdog-lock') || n.includes('.mixdog-tmp-')
-);
-
-console.log('');
-console.log('Follower results (' + followerWallMs + 'ms total):');
-results.forEach((r, i) => {
-    console.log('  #' + i + ' pid=' + r.pid + ' ok=' + r.ok
-        + (r.acquireMs !== undefined ? ' acquireMs=' + r.acquireMs : '')
-        + (r.code ? ' code=' + r.code : '')
-        + (r.dt ? ' dt=' + r.dt + 'ms' : ''));
-});
-
-console.log('');
-console.log('Final state:');
-console.log('  okCount: ' + okCount + '/' + N);
-console.log('  final content: ' + JSON.stringify(finalContent));
-console.log('  isValid: ' + isValid);
-console.log('  leftovers: ' + (leftovers.length === 0 ? 'CLEAN' : leftovers.join(', ')));
-
-const pass = okCount === N && isValid && leftovers.length === 0;
-console.log('');
-console.log(pass ? '=== PASS ===' : '=== FAIL ===');
-
-rmSync(dir, { recursive: true, force: true });
-process.exit(pass ? 0 : 1);

package/scripts/test-large-file.mjs

@@ -1,174 +0,0 @@
-// Large-file streaming test: 100MB target, 4 concurrent writers replacing
-// with ~100MB payloads of different sizes, 4 concurrent readers verifying
-// sentinels + expected-size set. Forces atomic-write streaming path
-// (>1MB threshold) + Windows EBUSY backoff during reader hold.
-import { spawn } from 'child_process';
-import {
-    mkdtempSync, writeFileSync, readFileSync, statSync, readdirSync, rmSync,
-} from 'fs';
-import { tmpdir } from 'os';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { performance } from 'perf_hooks';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const repoRoot = dirname(__dirname);
-const atomicModUrl = 'file://' + join(repoRoot, 'src/agent/orchestrator/tools/builtin/atomic-write.mjs').replace(/\\/g, '/');
-const lockModUrl = 'file://' + join(repoRoot, 'src/agent/orchestrator/tools/builtin/advisory-lock.mjs').replace(/\\/g, '/');
-
-function snapshot(p) {
-    try {
-        const s = statSync(p);
-        return { exists: true, size: s.size, mtimeMs: s.mtimeMs, ino: s.ino };
-    } catch { return { exists: false }; }
-}
-
-// --- Writer mode ---
-if (process.argv[2] === '--writer') {
-    const target = process.argv[3];
-    const payloadFile = process.argv[4];
-    const { atomicWrite } = await import(atomicModUrl);
-    const { acquireAdvisoryLock } = await import(lockModUrl);
-    const t0 = performance.now();
-    const handle = await acquireAdvisoryLock(target, { timeoutMs: 60000 });
-    try {
-        const payload = readFileSync(payloadFile);
-        await atomicWrite(target, payload, { expectedTargetSnapshot: snapshot(target) });
-    } finally { handle.release(); }
-    const dt = +(performance.now() - t0).toFixed(2);
-    process.stdout.write(JSON.stringify({ ok: true, mode: 'writer', dt, pid: process.pid }) + '\n');
-    process.exit(0);
-}
-
-// --- Reader mode ---
-if (process.argv[2] === '--reader') {
-    const target = process.argv[3];
-    const expectedSizes = process.argv[4].split(',').map(Number);
-    const N = 30;
-    const sizes = new Set();
-    let reads = 0;
-    for (let i = 0; i < N; i += 1) {
-        try {
-            const buf = readFileSync(target);
-            sizes.add(buf.length);
-            if (buf.length === 0 || !expectedSizes.includes(buf.length)) {
-                process.stdout.write(JSON.stringify({
-                    ok: false, torn: true, reason: 'unexpected-size', len: buf.length, pid: process.pid,
-                }) + '\n');
-                process.exit(2);
-            }
-            const tail = buf.subarray(buf.length - 4).toString();
-            if (tail !== '|END') {
-                process.stdout.write(JSON.stringify({
-                    ok: false, torn: true, reason: 'tail', len: buf.length, tail, pid: process.pid,
-                }) + '\n');
-                process.exit(2);
-            }
-        } catch (err) {
-            if (err.code !== 'ENOENT') throw err;
-        }
-        reads += 1;
-        await new Promise(r => setTimeout(r, 10));
-    }
-    process.stdout.write(JSON.stringify({
-        ok: true, mode: 'reader', reads, distinctSizes: sizes.size, pid: process.pid,
-    }) + '\n');
-    process.exit(0);
-}
-
-// --- Driver ---
-const dir = mkdtempSync(join(tmpdir(), 'large-file-'));
-const target = join(dir, 'big.dat');
-console.log('=== C. Large-file streaming edit (~100MB) ===');
-console.log('dir=' + dir);
-
-const SIZE_BYTES = 100 * 1024 * 1024;
-const t0 = Date.now();
-const initBuf = Buffer.alloc(SIZE_BYTES);
-initBuf.fill('a');
-initBuf.write('INIT-', 0);
-initBuf.write('|END', SIZE_BYTES - 4);
-writeFileSync(target, initBuf);
-const initSize = statSync(target).size;
-console.log('initial: ' + (initSize / 1024 / 1024).toFixed(1) + 'MB in ' + (Date.now() - t0) + 'ms');
-
-const payloads = [];
-for (let i = 0; i < 4; i += 1) {
-    const sz = SIZE_BYTES + (i - 1) * 1024; // 99.999MB .. 100.003MB
-    const buf = Buffer.alloc(sz);
-    buf.fill('b');
-    buf.write('PAY' + i + '-', 0);
-    buf.write('|END', sz - 4);
-    const p = join(dir, 'payload-' + i + '.bin');
-    writeFileSync(p, buf);
-    payloads.push({ path: p, size: sz });
-}
-console.log('payloads: ' + payloads.map(p => p.size).join(', '));
-
-const expectedSizes = [initSize, ...payloads.map(p => p.size)].join(',');
-
-// 4 readers spawned first, then 4 writers
-const readerProcs = [];
-for (let i = 0; i < 4; i += 1) {
-    const f = spawn(process.execPath, [__filename, '--reader', target, expectedSizes], {
-        stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    let out = '';
-    f.stdout.on('data', d => { out += d; });
-    readerProcs.push(new Promise(res => f.on('close', code => {
-        try { res({ code, ...JSON.parse(out.trim().split('\n').pop()) }); }
-        catch { res({ code, ok: false, raw: out.slice(-100) }); }
-    })));
-}
-await new Promise(r => setTimeout(r, 100));
-
-const writerProcs = [];
-for (let i = 0; i < 4; i += 1) {
-    const f = spawn(process.execPath, [__filename, '--writer', target, payloads[i].path], {
-        stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    let out = '';
-    f.stdout.on('data', d => { out += d; });
-    writerProcs.push(new Promise(res => f.on('close', code => {
-        try { res({ code, ...JSON.parse(out.trim().split('\n').pop()) }); }
-        catch { res({ code, ok: false, raw: out.slice(-100) }); }
-    })));
-}
-
-const writeStart = Date.now();
-const [writers, readers] = await Promise.all([
-    Promise.all(writerProcs),
-    Promise.all(readerProcs),
-]);
-const wallMs = Date.now() - writeStart;
-
-const writersOk = writers.filter(r => r.ok).length;
-const readersOk = readers.filter(r => r.ok).length;
-const tornFound = readers.some(r => r.torn === true);
-const leftovers = readdirSync(dir).filter(n =>
-    n.endsWith('.mixdog-lock') || n.includes('.mixdog-tmp-')
-);
-const finalSize = statSync(target).size;
-const finalIsPayload = payloads.some(p => p.size === finalSize);
-
-console.log('');
-console.log('Writers (' + wallMs + 'ms):');
-writers.forEach((r, i) => console.log('  #' + i + ' ok=' + r.ok + ' dt=' + (r.dt || '?') + 'ms'));
-console.log('Readers:');
-readers.forEach((r, i) => console.log('  #' + i + ' ok=' + r.ok + ' reads=' + (r.reads || 0) + ' distinctSizes=' + (r.distinctSizes || 0)));
-console.log('');
-console.log('Final:');
-console.log('  finalSize: ' + (finalSize / 1024 / 1024).toFixed(2) + 'MB');
-console.log('  finalIsPayload: ' + finalIsPayload);
-console.log('  writersOk: ' + writersOk + '/4');
-console.log('  readersOk: ' + readersOk + '/4');
-console.log('  torn: ' + (tornFound ? 'YES' : 'no'));
-console.log('  leftovers: ' + (leftovers.length === 0 ? 'CLEAN' : leftovers.join(', ')));
-
-const pass = writersOk === 4 && readersOk === 4 && !tornFound && finalIsPayload && leftovers.length === 0;
-console.log('');
-console.log(pass ? '=== PASS ===' : '=== FAIL ===');
-
-rmSync(dir, { recursive: true, force: true });
-process.exit(pass ? 0 : 1);

package/scripts/tool-edge-smoke.mjs

@@ -1,209 +0,0 @@
-// tool-edge-smoke.mjs — regression suite locking in builtin-tool edge cases
-// proven by live testing. Self-contained: builds throwaway fixtures under a
-// temp dir, drives the real tool impls imported straight from ../src, prints
-// PASS/FAIL per case, and exits 1 if any case fails.
-//
-// Run:  bun scripts/tool-edge-smoke.mjs   (or: node scripts/tool-edge-smoke.mjs)
-//
-// Cases (all anchored to behaviour observed live):
-//   1  grep anchored glob src/**/*.mjs matches under absolute proper-case,
-//      absolute lowercase, and relative path (true-cased rg cwd fix)
-//   2  grep array pattern -> `# per-pattern:` summary exposes a zero-hit member
-//   3  `-i` hint appears on a true zero-match cased pattern, absent when offset>0
-//   4  resolveSymbolReadSpan: const-arrow decl gets an exact end; fn decl unchanged
-//   5  list find: invalid modified_after errors; `24h` works
-//   6  grep pattern caps: 21-array -> error, 6 multiline -> error
-//   7  glob magic path `dir/*` + pattern matches files directly in dir
-//   8  diagnostics node --check fallback flags a syntax-error fixture
-//   9  list tree output >50KB hits the char-cap truncation marker
-//  10  read a 1x1 PNG -> image content block, not an error
-
-import { tmpdir } from 'os';
-import { join, dirname, sep } from 'path';
-import { fileURLToPath } from 'url';
-import { mkdirSync, writeFileSync, rmSync } from 'fs';
-
-const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
-const IS_WIN = process.platform === 'win32';
-
-// Tool impls imported directly from ../src.
-const { executeGrepTool, executeGlobTool } =
-  await import('../src/agent/orchestrator/tools/builtin/search-tool.mjs');
-const { executeListTool } =
-  await import('../src/agent/orchestrator/tools/builtin/list-tool.mjs');
-const { executeDiagnosticsTool } =
-  await import('../src/agent/orchestrator/tools/builtin/diagnostics-tool.mjs');
-const { resolveSymbolReadSpan } =
-  await import('../src/agent/orchestrator/tools/code-graph.mjs');
-// read has a thick helper-injection signature; drive it through the builtin
-// dispatcher so the real image fast-path runs exactly as in production.
-const { executeBuiltinTool } =
-  await import('../src/agent/orchestrator/tools/builtin.mjs');
-
-// grep wants an executeChildBuiltinTool arg; none of our grep cases hit the
-// glob-only fallback (a pattern is always present), so a noop suffices.
-const noopChild = async () => '';
-
-// ---- fixtures ----------------------------------------------------------
-const FIX = join(tmpdir(), `mixdog-tool-edge-smoke-${process.pid}`);
-function mk(rel, content) {
-  const p = join(FIX, rel);
-  mkdirSync(dirname(p), { recursive: true });
-  writeFileSync(p, content);
-  return p;
-}
-mkdirSync(FIX, { recursive: true });
-
-// ---- harness -----------------------------------------------------------
-let passed = 0;
-let failed = 0;
-function assert(cond, msg) { if (!cond) throw new Error(msg || 'assertion failed'); }
-async function check(name, fn) {
-  try { await fn(); passed++; console.log(`  PASS  ${name}`); }
-  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e?.message || e}`); }
-}
-
-try {
-  // ---- 1: anchored glob across path-casing forms ----------------------
-  await check('grep anchored glob src/**/*.mjs matches (proper / lower / relative)', async () => {
-    const glob = 'src/**/*.mjs';
-    const pattern = 'export';
-    const run = (searchPath, workDir) =>
-      executeGrepTool({ pattern, path: searchPath, glob, head_limit: 5 }, workDir, noopChild, null, {});
-
-    const proper = await run(ROOT, IS_WIN ? ROOT.toLowerCase() : ROOT);
-    assert(typeof proper === 'string' && /\.mjs/.test(proper) && !/no matches/i.test(proper),
-      `proper-case absolute produced no matches: ${proper.slice(0, 120)}`);
-
-    if (IS_WIN) {
-      const lower = await run(ROOT.toLowerCase(), ROOT);
-      assert(/\.mjs/.test(lower) && !/no matches/i.test(lower),
-        `lowercase absolute produced no matches: ${lower.slice(0, 120)}`);
-    }
-
-    const rel = await run('.', ROOT);
-    assert(/\.mjs/.test(rel) && !/no matches/i.test(rel),
-      `relative path produced no matches: ${rel.slice(0, 120)}`);
-  });
-
-  // ---- 2: per-pattern summary exposes a zero-hit member ---------------
-  await check('grep array pattern -> # per-pattern: shows a zero-hit member', async () => {
-    const out = await executeGrepTool(
-      { pattern: ['export', 'zzz_no_such_token_qwxyz'], path: ROOT, glob: 'src/**/*.mjs', head_limit: 3 },
-      ROOT, noopChild, null, {});
-    assert(/# per-pattern:/.test(out), `missing per-pattern summary: ${out.slice(-200)}`);
-    assert(/zzz_no_such_token_qwxyz.*?=0 files/.test(out), `zero-hit member not shown as 0 files: ${out.slice(-200)}`);
-  });
-
-  // ---- 3: -i hint only on a true zero-match cased search --------------
-  await check('grep -i hint present at offset 0, absent at offset>0', async () => {
-    mk('hint/file.txt', 'HelloWorld lives here\n');
-    const dir = join(FIX, 'hint');
-    const hit = await executeGrepTool({ pattern: 'helloworld', path: dir }, FIX, noopChild, null, {});
-    assert(/case-insensitive would match — try -i/.test(hit), `expected -i hint: ${hit}`);
-    const skipped = await executeGrepTool({ pattern: 'helloworld', path: dir, offset: 1 }, FIX, noopChild, null, {});
-    assert(!/case-insensitive would match/.test(skipped), `hint must be suppressed at offset>0: ${skipped}`);
-  });
-
-  // ---- 4: span end inference for a const-arrow decl -------------------
-  await check('resolveSymbolReadSpan: const-arrow exact end, fn decl unchanged', async () => {
-    const cgDir = join(FIX, 'cg');
-    mk('cg/sample.mjs', [
-      'export const myArrow = (a, b) => {',   // 1
-      '  const x = a + b;',                    // 2
-      '  const y = x * 2;',                    // 3
-      '  const z = y - 1;',                    // 4
-      '  return z;',                           // 5
-      '};',                                    // 6
-      'function plainFn(n) {',                 // 7
-      '  return n + 1;',                       // 8
-      '}',                                     // 9
-      '',
-    ].join('\n'));
-
-    const arrow = await resolveSymbolReadSpan(cgDir, { symbol: 'myArrow', path: 'sample.mjs' });
-    assert(!arrow.error, `myArrow lookup errored: ${arrow.error}`);
-    assert(arrow.startLine === 1 && arrow.endLine === 6 && arrow.approximate === false,
-      `const-arrow span wrong: ${JSON.stringify(arrow)}`);
-
-    const fn = await resolveSymbolReadSpan(cgDir, { symbol: 'plainFn', path: 'sample.mjs' });
-    assert(!fn.error, `plainFn lookup errored: ${fn.error}`);
-    assert(fn.startLine === 7 && fn.endLine === 9,
-      `function decl span changed: ${JSON.stringify(fn)}`);
-  });
-
-  // ---- 5: list find time-window validation ----------------------------
-  await check('list find: invalid modified_after errors, 24h works', async () => {
-    mk('find/recent.txt', 'x\n');
-    const dir = join(FIX, 'find');
-    const bad = await executeListTool({ mode: 'find', path: dir, modified_after: 'not-a-date' }, FIX, {});
-    assert(/Error: invalid modified_after/.test(bad), `expected invalid-date error: ${bad}`);
-    const ok = await executeListTool({ mode: 'find', path: dir, modified_after: '24h' }, FIX, {});
-    assert(!/^Error/.test(ok) && /recent\.txt/.test(ok), `24h window should list the fresh fixture: ${ok}`);
-  });
-
-  // ---- 6: grep pattern-count caps -------------------------------------
-  await check('grep caps: 21-array errors, 6 multiline errors', async () => {
-    const twentyOne = Array.from({ length: 21 }, (_, i) => `p${i}`);
-    const arr = await executeGrepTool({ pattern: twentyOne, path: FIX }, FIX, noopChild, null, {});
-    assert(/Error: pattern array exceeds the 20-pattern cap/.test(arr), `expected array cap error: ${arr}`);
-    const six = Array.from({ length: 6 }, (_, i) => `m${i}`);
-    const ml = await executeGrepTool({ pattern: six, path: FIX, multiline: true }, FIX, noopChild, null, {});
-    assert(/Error: multiline:true with more than 5 patterns/.test(ml), `expected multiline cap error: ${ml}`);
-  });
-
-  // ---- 7: glob magic path `dir/*` + pattern ---------------------------
-  await check('glob magic path dir/* + pattern matches files directly in dir', async () => {
-    mk('gdir/a.txt', '1');
-    mk('gdir/b.txt', '2');
-    mk('gdir/c.log', '3');
-    const out = await executeGlobTool({ path: 'gdir/*', pattern: '*.txt' }, FIX, {});
-    assert(/a\.txt/.test(out) && /b\.txt/.test(out), `direct-in-dir files missing: ${out}`);
-    assert(!/c\.log/.test(out), `pattern should exclude non-matching file: ${out}`);
-  });
-
-  // ---- 8: diagnostics node --check fallback ---------------------------
-  await check('diagnostics node --check fallback flags a syntax-error fixture', async () => {
-    const broken = mk('diag/broken.mjs', 'const x = (;\n');
-    const out = await executeDiagnosticsTool({ path: broken }, FIX, {});
-    let parsed;
-    try { parsed = JSON.parse(out); } catch { throw new Error(`non-JSON envelope: ${out}`); }
-    assert(/node --check/.test(String(parsed.checker || '')), `expected node --check fallback: ${parsed.checker}`);
-    assert(parsed.count >= 1 && parsed.findings.some((f) => f.severity === 'error'),
-      `syntax error not flagged: ${out}`);
-  });
-
-  // ---- 9: tree char-cap truncation marker -----------------------------
-  await check('list tree output >50KB hits the char-cap truncation marker', async () => {
-    // Wide+padded tree so the rendered output exceeds TREE_OUTPUT_CHAR_CAP
-    // (50KB). head_limit:0 disables the row page-cap so the char-cap is what
-    // actually trips. Long names keep the file count modest.
-    const pad = 'x'.repeat(40);
-    for (let d = 0; d < 40; d++) {
-      for (let f = 0; f < 40; f++) {
-        mk(`bigtree/dir_${pad}_${d}/file_${pad}_${f}.txt`, '.');
-      }
-    }
-    const out = await executeListTool({ mode: 'tree', path: join(FIX, 'bigtree'), depth: 3, head_limit: 0 }, FIX, {});
-    assert(/output truncated at 49 KB/.test(out), `expected char-cap truncation marker: ...${out.slice(-160)}`);
-  });
-
-  // ---- 10: read a 1x1 PNG returns image content -----------------------
-  await check('read 1x1 PNG -> image content block, not an error', async () => {
-    const pngB64 =
-      'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==';
-    const png = join(FIX, 'img', 'pixel.png');
-    mkdirSync(dirname(png), { recursive: true });
-    writeFileSync(png, Buffer.from(pngB64, 'base64'));
-    const res = await executeBuiltinTool('read', { path: png }, FIX, {});
-    assert(res && typeof res === 'object' && !Array.isArray(res), `expected a content-block object, got: ${typeof res}`);
-    assert(res.isError !== true, `read flagged an error: ${JSON.stringify(res).slice(0, 200)}`);
-    assert(Array.isArray(res.content) && res.content.some((c) => c && c.type === 'image'),
-      `no image content block returned: ${JSON.stringify(res).slice(0, 200)}`);
-  });
-} finally {
-  try { rmSync(FIX, { recursive: true, force: true }); } catch { /* best-effort cleanup */ }
-}
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed > 0 ? 1 : 0);