mixdog 0.7.1

package/scripts/test-config-rmw-restore.mjs

@@ -0,0 +1,122 @@
+/**
+ * Repro: malformed mixdog-config.json + writeSection('search', …) must not
+ * wipe channels/memory/agent; restores from backup or throws.
+ */
+import assert from 'node:assert/strict';
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  rmSync,
+} from 'fs';
+import { tmpdir } from 'os';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+async function loadConfigModule(dataDir, backupRoot) {
+  process.env.CLAUDE_PLUGIN_DATA = dataDir;
+  process.env.MIXDOG_USER_DATA_BACKUP_ROOT = backupRoot;
+  process.env.MIXDOG_SKIP_USER_DATA_BACKUP = '1';
+  const url = new URL(`../src/shared/config.mjs?run=${Date.now()}`, import.meta.url).href;
+  return import(url);
+}
+
+function writeConfig(dataDir, obj) {
+  writeFileSync(
+    join(dataDir, 'mixdog-config.json'),
+    JSON.stringify(obj, null, 2) + '\n',
+    'utf8',
+  );
+}
+
+async function main() {
+  const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-config-rmw-'));
+  const backupRoot = mkdtempSync(join(tmpdir(), 'mixdog-config-backup-'));
+
+  const prior = {
+    channels: { guild: '111' },
+    memory: { enabled: true },
+    agent: { presets: { default: { model: 'x' } } },
+  };
+  writeConfig(dataDir, prior);
+
+  process.env.CLAUDE_PLUGIN_DATA = dataDir;
+  process.env.MIXDOG_USER_DATA_BACKUP_ROOT = backupRoot;
+  const guardUrl = new URL(`../src/shared/user-data-guard.mjs?t=${Date.now()}`, import.meta.url).href;
+  const { backupUserData, markUserDataInitialized } = await import(guardUrl);
+  const snap = backupUserData(dataDir, 'test-fixture');
+  assert.ok(snap.dir, 'backup fixture should copy mixdog-config.json');
+
+  writeFileSync(join(dataDir, 'mixdog-config.json'), '{ not valid json\n', 'utf8');
+
+  const { writeSection } = await loadConfigModule(dataDir, backupRoot);
+  writeSection('search', { provider: 'brave' });
+
+  const onDisk = JSON.parse(readFileSync(join(dataDir, 'mixdog-config.json'), 'utf8'));
+  assert.deepEqual(onDisk.channels, prior.channels);
+  assert.deepEqual(onDisk.memory, prior.memory);
+  assert.deepEqual(onDisk.agent, prior.agent);
+  assert.deepEqual(onDisk.search, { provider: 'brave' });
+
+  const freshDir = mkdtempSync(join(tmpdir(), 'mixdog-config-fresh-'));
+  const { writeSection: writeFresh } = await loadConfigModule(freshDir, backupRoot);
+  writeFresh('search', { only: true });
+  const freshDisk = JSON.parse(readFileSync(join(freshDir, 'mixdog-config.json'), 'utf8'));
+  assert.deepEqual(freshDisk, { search: { only: true } });
+
+  const noBackupDir = mkdtempSync(join(tmpdir(), 'mixdog-config-noback-'));
+  markUserDataInitialized(noBackupDir);
+  writeFileSync(join(noBackupDir, 'mixdog-config.json'), '[]', 'utf8');
+  const { writeSection: writeNoBackup } = await loadConfigModule(
+    noBackupDir,
+    mkdtempSync(join(tmpdir(), 'empty-backup-')),
+  );
+  let threw = false;
+  try {
+    writeNoBackup('search', { x: 1 });
+  } catch (err) {
+    threw = true;
+    assert.match(String(err.message), /refusing section write/);
+  }
+  assert.equal(threw, true, 'malformed config with init marker and no backup must throw');
+
+  const pickRoot = mkdtempSync(join(tmpdir(), 'mixdog-config-pick-'));
+  const fullCfg = {
+    channels: { guild: '222' },
+    memory: { enabled: false },
+    agent: { presets: {} },
+  };
+  const oldDir = join(pickRoot, '2026-06-03T19-00-00-000Z-old-full');
+  const newDir = join(pickRoot, '2026-06-03T21-00-00-000Z-new-degenerate');
+  mkdirSync(oldDir, { recursive: true });
+  mkdirSync(newDir, { recursive: true });
+  writeFileSync(join(oldDir, 'mixdog-config.json'), JSON.stringify(fullCfg) + '\n', 'utf8');
+  writeFileSync(
+    join(newDir, 'mixdog-config.json'),
+    JSON.stringify({ search: { provider: 'tavily' } }) + '\n',
+    'utf8',
+  );
+  process.env.MIXDOG_USER_DATA_BACKUP_ROOT = pickRoot;
+  const pickUrl = new URL(`../src/shared/user-data-guard.mjs?pick=${Date.now()}`, import.meta.url).href;
+  const { loadLatestMixdogConfigFromBackup } = await import(pickUrl);
+  const picked = loadLatestMixdogConfigFromBackup(null);
+  assert.deepEqual(picked?.channels, fullCfg.channels);
+  assert.deepEqual(picked?.agent, fullCfg.agent);
+  assert.equal(picked?.search, undefined, 'must not restore newest search-only snapshot');
+  rmSync(pickRoot, { recursive: true, force: true });
+
+  rmSync(dataDir, { recursive: true, force: true });
+  rmSync(backupRoot, { recursive: true, force: true });
+  rmSync(freshDir, { recursive: true, force: true });
+  rmSync(noBackupDir, { recursive: true, force: true });
+
+  console.log('test-config-rmw-restore: ok');
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/scripts/test-fault-inject.mjs

@@ -0,0 +1,164 @@
+// 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

@@ -0,0 +1,174 @@
+// 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

@@ -0,0 +1,209 @@
+// 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);