kodelyth-ecc 1.8.0 → 1.8.2

package/tests/memory/instincts.test.js

@@ -1,258 +0,0 @@
-// Tests for scripts/memory/instincts.js — runs against a temp directory.
-// Covers Improvement B (structured instinct schema), C (outcome tracking),
-// and D (pattern confidence decay).
-'use strict';
-
-const test   = require('node:test');
-const assert = require('node:assert/strict');
-const fs     = require('fs');
-const os     = require('os');
-const path   = require('path');
-
-// ── Temp directory isolation ──────────────────────────────────────────────────
-const TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-instincts-'));
-process.env.KODELYTH_MEMORY_DIR = TMP;
-
-// Require AFTER setting env
-const instincts = require('../../scripts/memory/instincts');
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-const PROJECT_A = '/projects/test-a';
-const PROJECT_B = '/projects/test-b';
-
-function freshFile() {
-  // Wipe the instincts file before each group of tests that needs isolation
-  if (fs.existsSync(instincts.INSTINCTS_FILE)) {
-    fs.unlinkSync(instincts.INSTINCTS_FILE);
-  }
-}
-
-// ── captureFromCorrection ─────────────────────────────────────────────────────
-
-test('captureFromCorrection stores a new instinct', () => {
-  freshFile();
-  const inst = instincts.captureFromCorrection('always use pnpm not npm', PROJECT_A, 'project');
-  assert.ok(inst.id, 'should have an id');
-  assert.ok(inst.rule.includes('pnpm'), 'rule should contain original text');
-  assert.equal(inst.scope, 'project');
-  assert.equal(inst.source, 'correction');
-  assert.ok(inst.confidence >= 0.5 && inst.confidence <= 1.0, 'confidence in range');
-  assert.equal(inst.use_count, 1);
-  assert.equal(inst.stale, false);
-  assert.equal(inst.outcome, null);
-  assert.equal(inst.project_path, PROJECT_A);
-});
-
-test('captureFromCorrection is idempotent — re-capture increments use_count', () => {
-  freshFile();
-  const first  = instincts.captureFromCorrection('never use var', PROJECT_A, 'project');
-  const second = instincts.captureFromCorrection('never use var', PROJECT_A, 'project');
-  assert.equal(first.id, second.id, 'same correction should produce same id');
-  assert.equal(second.use_count, 2);
-  assert.ok(second.confidence > first.confidence, 're-capture should boost confidence');
-});
-
-test('captureFromCorrection creates distinct records for different projects', () => {
-  freshFile();
-  const a = instincts.captureFromCorrection('always use async/await', PROJECT_A, 'project');
-  const b = instincts.captureFromCorrection('always use async/await', PROJECT_B, 'project');
-  assert.notEqual(a.id, b.id, 'same rule, different project = different instinct');
-});
-
-test('captureFromCorrection caps confidence at 1.0', () => {
-  freshFile();
-  // Capture 10 times — confidence should never exceed 1.0
-  for (let i = 0; i < 10; i++) {
-    instincts.captureFromCorrection('use const not let', PROJECT_A, 'project');
-  }
-  const all = instincts.list({ projectPath: PROJECT_A });
-  const inst = all.find(i => i.rule.includes('const'));
-  assert.ok(inst, 'instinct should exist');
-  assert.ok(inst.confidence <= 1.0, 'confidence should not exceed 1.0');
-});
-
-// ── recordOutcome (by id) ─────────────────────────────────────────────────────
-
-test('recordOutcome boosts confidence on success', () => {
-  freshFile();
-  const inst = instincts.captureFromCorrection('prefer interface over type for objects', PROJECT_A);
-  const before = inst.confidence;
-  const updated = instincts.recordOutcome(inst.id, 'success');
-  assert.ok(updated.confidence > before, 'success should boost confidence');
-  assert.equal(updated.outcome, 'success');
-});
-
-test('recordOutcome reduces confidence on failure', () => {
-  freshFile();
-  const inst = instincts.captureFromCorrection('avoid class components', PROJECT_A);
-  const before = inst.confidence;
-  const updated = instincts.recordOutcome(inst.id, 'failure');
-  assert.ok(updated.confidence < before, 'failure should reduce confidence');
-  assert.equal(updated.outcome, 'failure');
-});
-
-test('recordOutcome floors confidence at 0.0', () => {
-  freshFile();
-  const inst = instincts.captureFromCorrection('do not use callbacks', PROJECT_A);
-  // Record failure 5 times — should never go below 0
-  for (let i = 0; i < 5; i++) {
-    instincts.recordOutcome(inst.id, 'failure');
-  }
-  const updated = instincts.recordOutcome(inst.id, 'failure');
-  assert.ok(updated.confidence >= 0.0, 'confidence should not go below 0');
-});
-
-test('recordOutcome returns null for unknown id', () => {
-  freshFile();
-  const result = instincts.recordOutcome('nonexistent-id-xyz', 'success');
-  assert.equal(result, null);
-});
-
-// ── recordOutcomeByProject (Improvement C bridge) ─────────────────────────────
-
-test('recordOutcomeByProject downgrades matching instincts by project + hint', () => {
-  freshFile();
-  instincts.captureFromCorrection('always use pnpm not npm', PROJECT_A);
-  instincts.captureFromCorrection('always run tests before commit', PROJECT_A);
-  instincts.captureFromCorrection('use tailwind not inline styles', PROJECT_B);
-
-  const before = instincts.list({ projectPath: PROJECT_A });
-  const pnpmBefore = before.find(i => i.rule.includes('pnpm')).confidence;
-
-  const changed = instincts.recordOutcomeByProject(PROJECT_A, 'use pnpm not npm', false);
-
-  assert.ok(changed.length >= 1, 'at least one instinct should be changed');
-
-  const after = instincts.list({ projectPath: PROJECT_A });
-  const pnpmAfter = after.find(i => i.rule.includes('pnpm')).confidence;
-  assert.ok(pnpmAfter < pnpmBefore, 'matched instinct confidence should decrease');
-
-  // PROJECT_B instinct should be untouched
-  const bInstincts = instincts.list({ projectPath: PROJECT_B });
-  assert.ok(bInstincts[0].confidence >= 0.7, 'unrelated project instinct should be unchanged');
-});
-
-test('recordOutcomeByProject skips instincts with < 20% token overlap', () => {
-  freshFile();
-  instincts.captureFromCorrection('always use pnpm', PROJECT_A);
-  const changed = instincts.recordOutcomeByProject(PROJECT_A, 'completely unrelated topic xyz', false);
-  // Should change 0 because token overlap < 20%
-  assert.equal(changed.length, 0, 'should not match on low overlap');
-});
-
-// ── runDecayCheck (Improvement D) ─────────────────────────────────────────────
-
-test('runDecayCheck marks old instincts as stale', () => {
-  freshFile();
-  const inst = instincts.captureFromCorrection('prefer named exports', PROJECT_A);
-
-  // Manually backdate last_used to 35 days ago
-  const all = instincts.list();
-  const record = all.find(i => i.id === inst.id);
-  const old = new Date();
-  old.setDate(old.getDate() - 35);
-  record.last_used = old.toISOString();
-  // Write back manually via the file
-  const lines = fs.readFileSync(instincts.INSTINCTS_FILE, 'utf8').split('\n').filter(Boolean);
-  const rewritten = lines.map(l => {
-    try {
-      const r = JSON.parse(l);
-      return r.id === inst.id ? JSON.stringify(record) : l;
-    } catch { return l; }
-  });
-  fs.writeFileSync(instincts.INSTINCTS_FILE, rewritten.join('\n') + '\n', 'utf8');
-
-  const stale = instincts.runDecayCheck();
-  assert.ok(stale.length >= 1, 'should detect at least one stale instinct');
-  assert.equal(stale[0].id, inst.id);
-  assert.equal(stale[0].stale, true);
-});
-
-test('runDecayCheck does not mark recent instincts as stale', () => {
-  freshFile();
-  instincts.captureFromCorrection('use strict mode', PROJECT_A);
-  const stale = instincts.runDecayCheck();
-  assert.equal(stale.length, 0, 'fresh instinct should not be stale');
-});
-
-test('runDecayCheck returns only newly-stale (not already-stale)', () => {
-  freshFile();
-  const inst = instincts.captureFromCorrection('prefer optional chaining', PROJECT_A);
-
-  // Backdate and mark already stale
-  const lines = fs.readFileSync(instincts.INSTINCTS_FILE, 'utf8').split('\n').filter(Boolean);
-  const old = new Date();
-  old.setDate(old.getDate() - 40);
-  const rewritten = lines.map(l => {
-    try {
-      const r = JSON.parse(l);
-      if (r.id === inst.id) {
-        return JSON.stringify({ ...r, stale: true, last_used: old.toISOString() });
-      }
-      return l;
-    } catch { return l; }
-  });
-  fs.writeFileSync(instincts.INSTINCTS_FILE, rewritten.join('\n') + '\n', 'utf8');
-
-  const stale = instincts.runDecayCheck();
-  assert.equal(stale.length, 0, 'already-stale instincts should not be re-reported');
-});
-
-// ── pruneWeak ─────────────────────────────────────────────────────────────────
-
-test('pruneWeak removes instincts below threshold', () => {
-  freshFile();
-  const inst = instincts.captureFromCorrection('do not shadow outer variables', PROJECT_A);
-
-  // Drive confidence below threshold via repeated failures
-  for (let i = 0; i < 5; i++) {
-    instincts.recordOutcome(inst.id, 'failure');
-  }
-
-  const pruned = instincts.pruneWeak(0.2);
-  assert.ok(pruned >= 1, 'should prune at least one weak instinct');
-
-  const remaining = instincts.list();
-  const found = remaining.find(i => i.id === inst.id);
-  assert.equal(found, undefined, 'pruned instinct should be gone');
-});
-
-test('pruneWeak keeps high-confidence instincts', () => {
-  freshFile();
-  instincts.captureFromCorrection('use es modules not commonjs', PROJECT_A);
-  const pruned = instincts.pruneWeak(0.2);
-  assert.equal(pruned, 0, 'strong instinct should not be pruned');
-});
-
-// ── list + filtering ──────────────────────────────────────────────────────────
-
-test('list filters by scope', () => {
-  freshFile();
-  instincts.captureFromCorrection('global rule one', null, 'global');
-  instincts.captureFromCorrection('project rule one', PROJECT_A, 'project');
-
-  const globals  = instincts.list({ scope: 'global' });
-  const projects = instincts.list({ scope: 'project' });
-  assert.ok(globals.every(i => i.scope === 'global'));
-  assert.ok(projects.every(i => i.scope === 'project'));
-});
-
-test('list filters by minConfidence', () => {
-  freshFile();
-  const inst = instincts.captureFromCorrection('high confidence rule', PROJECT_A);
-  instincts.recordOutcome(inst.id, 'success'); // boosts to ~0.85
-
-  const high = instincts.list({ minConfidence: 0.8 });
-  assert.ok(high.length >= 1);
-  assert.ok(high.every(i => i.confidence >= 0.8));
-});
-
-test('list filters by projectPath', () => {
-  freshFile();
-  instincts.captureFromCorrection('rule for project a', PROJECT_A, 'project');
-  instincts.captureFromCorrection('rule for project b', PROJECT_B, 'project');
-
-  const aOnly = instincts.list({ projectPath: PROJECT_A });
-  assert.ok(aOnly.every(i => i.project_path === PROJECT_A));
-  assert.ok(aOnly.length >= 1);
-});

package/tests/memory/store.test.js

@@ -1,203 +0,0 @@
-// Tests for scripts/memory/store.js — runs against a temp directory
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs   = require('fs');
-const os   = require('os');
-const path = require('path');
-
-const TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-mem-'));
-process.env.KODELYTH_MEMORY_DIR = TMP;
-
-// Require AFTER setting env so the store picks up the temp dir
-const store = require('../../scripts/memory/store');
-const { buildContextBlock } = require('../../scripts/memory/inject');
-
-test('tokenise removes stopwords and short tokens', () => {
-  const tokens = store.tokenise('The Stripe webhook signature failed in production');
-  assert.ok(tokens.includes('stripe'));
-  assert.ok(tokens.includes('webhook'));
-  assert.ok(tokens.includes('signature'));
-  assert.ok(tokens.includes('failed'));
-  assert.ok(!tokens.includes('the'));
-  assert.ok(!tokens.includes('in'));
-});
-
-test('capture stores a memory and returns it with id', () => {
-  const m = store.capture({
-    problem:  'Stripe webhook signature failed in production',
-    approach: 'Switched body parser from json to raw, validated with constructEvent',
-    tags:     ['payments', 'stripe', 'webhooks'],
-    project:  '/test/project-a',
-    language: 'typescript',
-  });
-  assert.ok(m.id);
-  assert.equal(m.problem, 'Stripe webhook signature failed in production');
-  assert.equal(m.tags.length, 3);
-  assert.ok(m.captured_at);
-});
-
-test('capture rejects missing problem or approach', () => {
-  assert.throws(() => store.capture({ problem: '', approach: 'x' }));
-  assert.throws(() => store.capture({ problem: 'x', approach: '' }));
-});
-
-test('recall finds memory by keyword', () => {
-  const results = store.recall('stripe webhook');
-  assert.ok(results.length >= 1);
-  assert.match(results[0].problem, /stripe/i);
-  assert.ok(results[0].score > 0);
-});
-
-test('recall returns empty for irrelevant query', () => {
-  const results = store.recall('completely unrelated quantum mechanics');
-  assert.equal(results.length, 0);
-});
-
-test('recallForProject prioritises project memories then falls back to global', () => {
-  store.capture({
-    problem:  'Database connection pool exhausted',
-    approach: 'Increased pool size and added connection timeout',
-    tags:     ['database', 'postgres'],
-    project:  '/test/project-b',
-    language: 'typescript',
-  });
-  const projectA = store.recallForProject('/test/project-a', 'webhook');
-  assert.ok(projectA.length >= 1);
-  assert.equal(projectA[0].project_path, '/test/project-a');
-});
-
-test('listAll returns all non-deleted memories', () => {
-  const all = store.listAll();
-  assert.ok(all.length >= 2);
-});
-
-test('forget marks memory deleted', () => {
-  const all = store.listAll();
-  const target = all[0];
-  const ok = store.forget(target.id);
-  assert.equal(ok, true);
-  const after = store.listAll();
-  assert.ok(after.length < all.length);
-});
-
-test('rebuildIndex restores searchability after manual log edit', () => {
-  const r = store.rebuildIndex();
-  assert.ok(r.count >= 1);
-});
-
-test('stats summarises store contents', () => {
-  const s = store.stats();
-  assert.ok(s.total >= 1);
-  assert.equal(s.storageDir, TMP);
-  assert.ok(s.byLanguage.typescript >= 1);
-});
-
-test('buildContextBlock returns null when memory is empty', () => {
-  const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-empty-'));
-  process.env.KODELYTH_MEMORY_DIR = emptyDir;
-  // Force fresh require by clearing cache
-  delete require.cache[require.resolve('../../scripts/memory/store')];
-  delete require.cache[require.resolve('../../scripts/memory/inject')];
-  const { buildContextBlock: bcb } = require('../../scripts/memory/inject');
-  const result = bcb({ projectRoot: '/test/project-x' });
-  assert.equal(result, null);
-  // Restore
-  process.env.KODELYTH_MEMORY_DIR = TMP;
-  delete require.cache[require.resolve('../../scripts/memory/store')];
-  delete require.cache[require.resolve('../../scripts/memory/inject')];
-});
-
-test('buildContextBlock returns structured block when memory exists', () => {
-  const fresh = require('../../scripts/memory/inject');
-  const result = fresh.buildContextBlock({
-    projectRoot: '/test/project-b',
-    query:       'database pool',
-  });
-  assert.ok(result);
-  assert.ok(result.text.includes('Kodelyth Memory'));
-  assert.ok(result.memoryCount >= 1);
-});
-
-// ── Improvement C: outcome tracking ──────────────────────────────────────────
-
-test('resolveMemory marks a memory with outcome', () => {
-  // Capture a memory with a file reference
-  const m = store.capture({
-    problem:  'Auth token refresh race condition',
-    approach: 'Added mutex lock around token refresh logic',
-    tags:     ['auth', 'race-condition'],
-    project:  '/test/project-c',
-    files:    ['/test/project-c/src/auth/refresh.ts'],
-  });
-  const ok = store.resolveMemory(m.id, false);
-  assert.equal(ok, true, 'resolveMemory should return true when memory found');
-
-  const all = store.listAll();
-  const updated = all.find(mem => mem.id === m.id);
-  assert.ok(updated, 'memory should still exist');
-  assert.equal(updated.resolved, false);
-  assert.ok(updated.resolved_at, 'resolved_at should be set');
-});
-
-test('resolveMemory returns false for unknown id', () => {
-  const ok = store.resolveMemory('totally-unknown-id-123', true);
-  assert.equal(ok, false);
-});
-
-test('findMemoriesForFile finds memories by exact file path', () => {
-  store.capture({
-    problem:  'Database migration ran twice',
-    approach: 'Added idempotency check in migration runner',
-    tags:     ['migrations', 'database'],
-    project:  '/test/project-d',
-    files:    ['/test/project-d/migrations/001_users.sql'],
-  });
-  const matches = store.findMemoriesForFile('/test/project-d/migrations/001_users.sql');
-  assert.ok(matches.length >= 1, 'should find memory with exact file path');
-});
-
-test('findMemoriesForFile returns empty when no file match', () => {
-  const matches = store.findMemoriesForFile('/completely/unrelated/path/file.ts');
-  assert.equal(matches.length, 0);
-});
-
-test('findMemoriesForFile excludes already-resolved memories', () => {
-  const m = store.capture({
-    problem:  'Cache invalidation bug in product listing',
-    approach: 'Switched to event-driven cache clearing',
-    tags:     ['cache', 'redis'],
-    project:  '/test/project-e',
-    files:    ['/test/project-e/src/cache/products.ts'],
-  });
-  store.resolveMemory(m.id, true);  // mark as resolved
-
-  const matches = store.findMemoriesForFile('/test/project-e/src/cache/products.ts');
-  const found = matches.find(mem => mem.id === m.id);
-  assert.equal(found, undefined, 'resolved memory should not be returned');
-});
-
-test('autoResolveOnEdit marks matching memory resolved:false', () => {
-  const filePath = '/test/project-f/src/api/users.ts';
-  const m = store.capture({
-    problem:  'User endpoint returned 500 on empty body',
-    approach: 'Added body validation middleware before handler',
-    tags:     ['api', 'validation'],
-    project:  '/test/project-f',
-    files:    [filePath],
-  });
-
-  const resolved = store.autoResolveOnEdit(filePath, '/test/project-f');
-  assert.ok(resolved.length >= 1, 'should resolve at least one memory');
-  assert.equal(resolved[0].id, m.id);
-
-  const all = store.listAll();
-  const updated = all.find(mem => mem.id === m.id);
-  assert.equal(updated.resolved, false);
-});
-
-test('autoResolveOnEdit returns empty when no matching memory', () => {
-  const resolved = store.autoResolveOnEdit('/no/memory/for/this/file.ts');
-  assert.equal(resolved.length, 0);
-});

package/tests/replay/bundle.test.js

@@ -1,181 +0,0 @@
-// Tests for scripts/replay/bundle.js — pure read/write of session bundles.
-'use strict';
-
-const test   = require('node:test');
-const assert = require('node:assert/strict');
-const fs     = require('fs');
-const os     = require('os');
-const path   = require('path');
-
-const B = require('../../scripts/replay/bundle.js');
-
-function tmp() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-bundle-'));
-}
-
-function seedSession(root, sessionName, workers) {
-  const sessionDir = path.join(root, sessionName);
-  fs.mkdirSync(sessionDir, { recursive: true });
-  for (const w of workers) {
-    const wdir = path.join(sessionDir, w.slug);
-    fs.mkdirSync(wdir);
-    fs.writeFileSync(path.join(wdir, 'task.md'),    w.task    || `# task for ${w.slug}`);
-    fs.writeFileSync(path.join(wdir, 'handoff.md'), w.handoff || `# handoff for ${w.slug}`);
-    fs.writeFileSync(path.join(wdir, 'status.md'),  w.status  || `# status for ${w.slug}\n- State: completed`);
-  }
-  return sessionDir;
-}
-
-// ── exportBundle ─────────────────────────────────────────────────────────────
-
-test('exportBundle: rejects missing session dir', () => {
-  assert.throws(() => B.exportBundle({ sessionDir: '/no/such/path' }), /not found/);
-});
-
-test('exportBundle: gathers task/handoff/status per worker', () => {
-  const root = tmp();
-  const dir = seedSession(root, 'swarm-test', [
-    { slug: 'security-reviewer', task: 'audit', handoff: 'found 3 issues', status: 'completed' },
-    { slug: 'code-reviewer',     task: 'review', handoff: 'all good',       status: 'completed' },
-  ]);
-  const bundle = B.exportBundle({ sessionDir: dir, sessionName: 'swarm-test', meta: { task: 'audit oauth', harness: 'claude' } });
-  assert.equal(bundle.schema, B.BUNDLE_SCHEMA);
-  assert.equal(bundle.session, 'swarm-test');
-  assert.equal(bundle.workers.length, 2);
-  assert.equal(bundle.meta.task, 'audit oauth');
-  // Sorted by slug:
-  assert.deepEqual(bundle.workers.map(w => w.slug), ['code-reviewer', 'security-reviewer']);
-  // Content preserved:
-  const sec = bundle.workers.find(w => w.slug === 'security-reviewer');
-  assert.equal(sec.task, 'audit');
-  assert.equal(sec.handoff, 'found 3 issues');
-});
-
-test('exportBundle: handles empty session dir gracefully', () => {
-  const root = tmp();
-  const empty = path.join(root, 'empty');
-  fs.mkdirSync(empty);
-  const bundle = B.exportBundle({ sessionDir: empty });
-  assert.equal(bundle.workers.length, 0);
-});
-
-// ── writeBundle / readBundle round-trip ──────────────────────────────────────
-
-test('writeBundle + readBundle: round-trips losslessly', () => {
-  const root = tmp();
-  const dir = seedSession(root, 's1', [{ slug: 'a' }, { slug: 'b' }]);
-  const bundle = B.exportBundle({ sessionDir: dir, meta: { task: 'foo' } });
-  const out = path.join(root, 'out.json');
-  B.writeBundle(bundle, out);
-
-  const reread = B.readBundle(out);
-  assert.equal(reread.session, bundle.session);
-  assert.equal(reread.workers.length, 2);
-  assert.equal(reread.meta.task, 'foo');
-});
-
-test('writeBundle: rejects bad schema', () => {
-  assert.throws(() => B.writeBundle({ schema: 'bogus' }, '/tmp/x.json'), /invalid schema/);
-});
-
-test('readBundle: rejects unknown schema', () => {
-  const root = tmp();
-  const out = path.join(root, 'bad.json');
-  fs.writeFileSync(out, JSON.stringify({ schema: 'not.kodelyth/v0', session: 'x', workers: [] }));
-  assert.throws(() => B.readBundle(out), /unsupported schema/);
-});
-
-test('readBundle: rejects empty workers', () => {
-  const root = tmp();
-  const out = path.join(root, 'empty.json');
-  fs.writeFileSync(out, JSON.stringify({ schema: B.BUNDLE_SCHEMA, session: 'x', workers: [] }));
-  assert.throws(() => B.readBundle(out), /non-empty array/);
-});
-
-// ── importBundle ─────────────────────────────────────────────────────────────
-
-test('importBundle: restores worker files into target dir', () => {
-  const root = tmp();
-  const dir = seedSession(root, 'src', [
-    { slug: 'a', task: 'task-a', handoff: 'handoff-a', status: 'status-a' },
-  ]);
-  const bundle = B.exportBundle({ sessionDir: dir });
-
-  const target = path.join(root, 'restored');
-  const out = B.importBundle(bundle, { targetDir: target });
-  assert.equal(out.targetDir, target);
-  assert.deepEqual(out.workers, ['a']);
-
-  assert.equal(fs.readFileSync(path.join(target, 'a', 'task.md'),    'utf8'), 'task-a');
-  assert.equal(fs.readFileSync(path.join(target, 'a', 'handoff.md'), 'utf8'), 'handoff-a');
-  assert.equal(fs.readFileSync(path.join(target, 'a', 'status.md'),  'utf8'), 'status-a');
-});
-
-test('importBundle: refuses to overwrite without flag', () => {
-  const root = tmp();
-  const dir = seedSession(root, 'src', [{ slug: 'a' }]);
-  const bundle = B.exportBundle({ sessionDir: dir });
-  const target = path.join(root, 'exists');
-  fs.mkdirSync(target);
-  assert.throws(() => B.importBundle(bundle, { targetDir: target }), /already exists/);
-});
-
-test('importBundle: overwrite=true replaces existing dir', () => {
-  const root = tmp();
-  const dir = seedSession(root, 'src', [{ slug: 'a', task: 'fresh' }]);
-  const bundle = B.exportBundle({ sessionDir: dir });
-  const target = path.join(root, 'exists');
-  fs.mkdirSync(target);
-  fs.writeFileSync(path.join(target, 'stale.txt'), 'leftover');
-
-  B.importBundle(bundle, { targetDir: target, overwrite: true });
-  assert.equal(fs.existsSync(path.join(target, 'stale.txt')), false);
-  assert.equal(fs.readFileSync(path.join(target, 'a', 'task.md'), 'utf8'), 'fresh');
-});
-
-// ── diffBundles ──────────────────────────────────────────────────────────────
-
-test('diffBundles: detects handoff changes', () => {
-  const root = tmp();
-  const a = B.exportBundle({ sessionDir: seedSession(root, 'a', [
-    { slug: 'x', handoff: 'aaa' }, { slug: 'y', handoff: 'shared' },
-  ]) });
-  const b = B.exportBundle({ sessionDir: seedSession(root, 'b', [
-    { slug: 'x', handoff: 'bbb' }, { slug: 'y', handoff: 'shared' },
-  ]) });
-  const d = B.diffBundles(a, b);
-  const x = d.find(r => r.slug === 'x');
-  const y = d.find(r => r.slug === 'y');
-  assert.equal(x.handoff_changed, true);
-  assert.equal(y.handoff_changed, false);
-});
-
-test('diffBundles: surfaces workers that exist on only one side', () => {
-  const root = tmp();
-  const a = B.exportBundle({ sessionDir: seedSession(root, 'a', [
-    { slug: 'only-a' }, { slug: 'shared' },
-  ]) });
-  const b = B.exportBundle({ sessionDir: seedSession(root, 'b', [
-    { slug: 'shared' }, { slug: 'only-b' },
-  ]) });
-  const d = B.diffBundles(a, b);
-  assert.equal(d.find(r => r.slug === 'only-a').in_a, true);
-  assert.equal(d.find(r => r.slug === 'only-a').in_b, false);
-  assert.equal(d.find(r => r.slug === 'only-b').in_b, true);
-  assert.equal(d.find(r => r.slug === 'only-b').in_a, false);
-});
-
-// ── nextReplayName ───────────────────────────────────────────────────────────
-
-test('nextReplayName: generates -replay-1 for fresh origin', () => {
-  assert.equal(B.nextReplayName('swarm-2026-05-10-4a'), 'swarm-2026-05-10-4a-replay-1');
-});
-
-test('nextReplayName: skips taken numbers', () => {
-  const taken = new Set(['swarm-x-replay-1', 'swarm-x-replay-2']);
-  assert.equal(B.nextReplayName('swarm-x', taken), 'swarm-x-replay-3');
-});
-
-test('nextReplayName: strips existing -replay-N suffix to find canonical base', () => {
-  assert.equal(B.nextReplayName('swarm-x-replay-3'), 'swarm-x-replay-1');
-});