cognitive-core 0.2.0 → 0.2.2

package/tests/memory/source-resolver.test.ts

@@ -0,0 +1,700 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  isGitSource,
+  parseGitSource,
+  discoverPlaybookDir,
+  resolvePlaybookSource,
+  sourceStateKey,
+  type SourceState,
+} from '../../src/memory/source-resolver.js';
+import { loadCuratedPlaybooks } from '../../src/memory/curated-loader.js';
+import { PlaybookLibrary, createPlaybookLibrary } from '../../src/memory/playbook.js';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
+import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFile = promisify(execFileCb);
+
+// ============================================================================
+// Unit: isGitSource
+// ============================================================================
+
+describe('isGitSource', () => {
+  it('should recognize git: prefix', () => {
+    expect(isGitSource('git:https://github.com/org/repo')).toBe(true);
+  });
+
+  it('should recognize github: shorthand', () => {
+    expect(isGitSource('github:org/repo')).toBe(true);
+  });
+
+  it('should recognize git@ SSH URLs', () => {
+    expect(isGitSource('git@github.com:org/repo.git')).toBe(true);
+  });
+
+  it('should recognize git+ prefix', () => {
+    expect(isGitSource('git+https://github.com/org/repo')).toBe(true);
+  });
+
+  it('should not match local paths', () => {
+    expect(isGitSource('/home/user/playbooks')).toBe(false);
+    expect(isGitSource('./playbooks')).toBe(false);
+    expect(isGitSource('playbooks/')).toBe(false);
+  });
+});
+
+// ============================================================================
+// Unit: parseGitSource
+// ============================================================================
+
+describe('parseGitSource', () => {
+  it('should parse git:https URL', () => {
+    const result = parseGitSource('git:https://github.com/org/repo');
+    expect(result.url).toBe('https://github.com/org/repo.git');
+    expect(result.ref).toBeUndefined();
+    expect(result.cacheKey).toBe('github.com/org/repo');
+  });
+
+  it('should parse git:https URL with ref', () => {
+    const result = parseGitSource('git:https://github.com/org/repo#v1.0.0');
+    expect(result.url).toBe('https://github.com/org/repo.git');
+    expect(result.ref).toBe('v1.0.0');
+    expect(result.cacheKey).toBe('github.com/org/repo');
+  });
+
+  it('should parse github: shorthand', () => {
+    const result = parseGitSource('github:EveryInc/compound-engineering-plugin');
+    expect(result.url).toBe('https://github.com/EveryInc/compound-engineering-plugin.git');
+    expect(result.ref).toBeUndefined();
+    expect(result.cacheKey).toBe('github.com/EveryInc/compound-engineering-plugin');
+  });
+
+  it('should parse github: shorthand with ref', () => {
+    const result = parseGitSource('github:org/repo#main');
+    expect(result.url).toBe('https://github.com/org/repo.git');
+    expect(result.ref).toBe('main');
+    expect(result.cacheKey).toBe('github.com/org/repo');
+  });
+
+  it('should parse git+ prefix', () => {
+    const result = parseGitSource('git+https://github.com/org/repo');
+    expect(result.url).toBe('https://github.com/org/repo.git');
+    expect(result.ref).toBeUndefined();
+  });
+
+  it('should not double-append .git suffix', () => {
+    const result = parseGitSource('git:https://github.com/org/repo.git');
+    expect(result.url).toBe('https://github.com/org/repo.git');
+  });
+});
+
+// ============================================================================
+// Unit: discoverPlaybookDir
+// ============================================================================
+
+describe('discoverPlaybookDir', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'resolver-discover-'));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should find playbooks from manifest', async () => {
+    const pbDir = join(tempDir, 'my-playbooks');
+    await mkdir(pbDir, { recursive: true });
+    await writeFile(
+      join(tempDir, 'cognitive-core.json'),
+      JSON.stringify({ playbooks: 'my-playbooks' }),
+    );
+
+    const result = await discoverPlaybookDir(tempDir);
+    expect(result).toBe(pbDir);
+  });
+
+  it('should find conventional playbooks/ directory', async () => {
+    const pbDir = join(tempDir, 'playbooks');
+    await mkdir(pbDir);
+
+    const result = await discoverPlaybookDir(tempDir);
+    expect(result).toBe(pbDir);
+  });
+
+  it('should find conventional curated-playbooks/ directory', async () => {
+    const pbDir = join(tempDir, 'curated-playbooks');
+    await mkdir(pbDir);
+
+    const result = await discoverPlaybookDir(tempDir);
+    expect(result).toBe(pbDir);
+  });
+
+  it('should prefer manifest over convention', async () => {
+    const manifestDir = join(tempDir, 'custom');
+    const conventionDir = join(tempDir, 'playbooks');
+    await mkdir(manifestDir);
+    await mkdir(conventionDir);
+    await writeFile(
+      join(tempDir, 'cognitive-core.json'),
+      JSON.stringify({ playbooks: 'custom' }),
+    );
+
+    const result = await discoverPlaybookDir(tempDir);
+    expect(result).toBe(manifestDir);
+  });
+
+  it('should detect root dir with playbook JSON files', async () => {
+    await writeFile(
+      join(tempDir, 'my-playbook.json'),
+      JSON.stringify({
+        name: 'test',
+        applicability: { situations: ['test'], domains: ['test'] },
+        guidance: { strategy: 'test', tactics: ['test'] },
+      }),
+    );
+
+    const result = await discoverPlaybookDir(tempDir);
+    expect(result).toBe(tempDir);
+  });
+
+  it('should return null for empty directory', async () => {
+    const result = await discoverPlaybookDir(tempDir);
+    expect(result).toBeNull();
+  });
+
+  it('should fall through when manifest points to non-existent directory', async () => {
+    const conventionDir = join(tempDir, 'playbooks');
+    await mkdir(conventionDir);
+    // Manifest points to a dir that doesn't exist
+    await writeFile(
+      join(tempDir, 'cognitive-core.json'),
+      JSON.stringify({ playbooks: 'does-not-exist' }),
+    );
+
+    const result = await discoverPlaybookDir(tempDir);
+    // Should fall through to convention: playbooks/
+    expect(result).toBe(conventionDir);
+  });
+
+  it('should fall through when manifest is malformed JSON', async () => {
+    const conventionDir = join(tempDir, 'playbooks');
+    await mkdir(conventionDir);
+    await writeFile(join(tempDir, 'cognitive-core.json'), '{ not valid json');
+
+    const result = await discoverPlaybookDir(tempDir);
+    expect(result).toBe(conventionDir);
+  });
+
+  it('should not match root dir with JSON files that lack playbook fields', async () => {
+    await writeFile(
+      join(tempDir, 'package.json'),
+      JSON.stringify({ name: 'some-package', version: '1.0.0' }),
+    );
+
+    const result = await discoverPlaybookDir(tempDir);
+    expect(result).toBeNull();
+  });
+});
+
+// ============================================================================
+// Integration: resolvePlaybookSource — local paths
+// ============================================================================
+
+describe('resolvePlaybookSource — local paths', () => {
+  let tempDir: string;
+  let cacheDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'resolver-local-'));
+    cacheDir = join(tempDir, 'cache');
+    await mkdir(cacheDir);
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should pass through existing local paths', async () => {
+    const pbDir = join(tempDir, 'playbooks');
+    await mkdir(pbDir);
+
+    const result = await resolvePlaybookSource(pbDir, {
+      cacheDir,
+      maxAgeMs: 86400_000,
+    });
+
+    expect(result).not.toBeNull();
+    expect(result!.playbookDir).toBe(pbDir);
+    expect(result!.isGit).toBe(false);
+    expect(result!.updated).toBe(false);
+    expect(result!.sourceId).toBe(pbDir);
+  });
+
+  it('should return null for non-existent local paths', async () => {
+    const result = await resolvePlaybookSource('/nonexistent/path', {
+      cacheDir,
+      maxAgeMs: 86400_000,
+    });
+
+    expect(result).toBeNull();
+  });
+});
+
+// ============================================================================
+// Integration: resolvePlaybookSource — git sources
+// ============================================================================
+
+describe('resolvePlaybookSource — git sources (integration)', () => {
+  let tempDir: string;
+  let cacheDir: string;
+  let sourceStates: Map<string, SourceState>;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'resolver-git-'));
+    cacheDir = join(tempDir, 'cache');
+    await mkdir(cacheDir);
+    sourceStates = new Map();
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  /**
+   * Creates a local bare git repo with a playbooks/ directory containing
+   * test playbook JSON files. Returns the bare repo path (acts as "remote").
+   */
+  async function createLocalGitRepo(opts?: {
+    playbookNames?: string[];
+    useManifest?: boolean;
+    playbookSubdir?: string;
+    createTag?: string;
+  }): Promise<string> {
+    const repoDir = join(tempDir, `fake-remote-${Date.now()}`);
+    await mkdir(repoDir);
+    await execFile('git', ['init', '--bare', repoDir]);
+
+    const workDir = join(tempDir, `work-${Date.now()}`);
+    await mkdir(workDir);
+    await execFile('git', ['clone', repoDir, workDir]);
+    await execFile('git', ['config', 'commit.gpgSign', 'false'], { cwd: workDir });
+
+    const subdir = opts?.playbookSubdir ?? 'playbooks';
+    const pbDir = join(workDir, subdir);
+    await mkdir(pbDir, { recursive: true });
+
+    const names = opts?.playbookNames ?? ['test-from-git'];
+    for (const name of names) {
+      await writeFile(
+        join(pbDir, `${name}.json`),
+        JSON.stringify({
+          name,
+          applicability: { situations: [`${name} situation`], domains: ['testing'] },
+          guidance: { strategy: `${name} strategy`, tactics: [`${name} tactic`] },
+          verification: {
+            successIndicators: ['Tests pass'],
+            failureIndicators: ['Tests fail'],
+          },
+          confidence: 0.8,
+          curatedBy: 'test-suite',
+        }),
+      );
+    }
+
+    // Optional manifest
+    if (opts?.useManifest) {
+      await writeFile(
+        join(workDir, 'cognitive-core.json'),
+        JSON.stringify({ playbooks: subdir }),
+      );
+    }
+
+    await execFile('git', ['add', '.'], { cwd: workDir });
+    await execFile('git', ['commit', '-m', 'Initial playbooks'], {
+      cwd: workDir,
+      env: {
+        ...process.env,
+        GIT_AUTHOR_NAME: 'Test',
+        GIT_AUTHOR_EMAIL: 'test@test.com',
+        GIT_COMMITTER_NAME: 'Test',
+        GIT_COMMITTER_EMAIL: 'test@test.com',
+      },
+    });
+    await execFile('git', ['push', 'origin', 'HEAD'], { cwd: workDir });
+
+    if (opts?.createTag) {
+      await execFile('git', ['tag', opts.createTag], { cwd: workDir });
+      await execFile('git', ['push', 'origin', opts.createTag], { cwd: workDir });
+    }
+
+    return repoDir;
+  }
+
+  function makeResolveOpts(overrides?: Partial<Parameters<typeof resolvePlaybookSource>[1]>) {
+    return {
+      cacheDir,
+      maxAgeMs: 86400_000,
+      getSourceState: (s: string) => sourceStates.get(s),
+      setSourceState: (s: string, state: SourceState) => sourceStates.set(s, state),
+      ...overrides,
+    };
+  }
+
+  it('should clone and discover playbooks from a local git repo', async () => {
+    const repoDir = await createLocalGitRepo();
+
+    const result = await resolvePlaybookSource(`git:${repoDir}`, makeResolveOpts());
+
+    expect(result).not.toBeNull();
+    expect(result!.isGit).toBe(true);
+    expect(result!.updated).toBe(true);
+    expect(result!.commitSha).toBeDefined();
+    expect(result!.commitSha!.length).toBe(40);
+    expect(result!.playbookDir).toContain('playbooks');
+
+    // Source state should be persisted
+    const stateKey = `git:${repoDir}`;
+    expect(sourceStates.has(stateKey)).toBe(true);
+    const state = sourceStates.get(stateKey)!;
+    expect(state.commitSha).toBe(result!.commitSha);
+    expect(state.url).toBe(`${repoDir}`);
+  });
+
+  it('should use cached version on second resolve when not stale', async () => {
+    const repoDir = await createLocalGitRepo();
+    const source = `git:${repoDir}`;
+
+    // First resolve
+    const first = await resolvePlaybookSource(source, makeResolveOpts());
+    expect(first!.updated).toBe(true);
+
+    // Second resolve — should not update (same SHA, not stale)
+    const second = await resolvePlaybookSource(source, makeResolveOpts());
+    expect(second!.updated).toBe(false);
+    expect(second!.commitSha).toBe(first!.commitSha);
+  });
+
+  it('should force update when forceUpdate is true', async () => {
+    const repoDir = await createLocalGitRepo();
+    const source = `git:${repoDir}`;
+
+    // First resolve
+    await resolvePlaybookSource(source, makeResolveOpts());
+
+    // Force update resolve — should report updated even though SHA is same
+    const result = await resolvePlaybookSource(
+      source,
+      makeResolveOpts({ forceUpdate: true }),
+    );
+    expect(result!.updated).toBe(true);
+  });
+
+  it('should fetch when cache is stale but return updated:false if SHA unchanged', async () => {
+    const repoDir = await createLocalGitRepo();
+    const source = `git:${repoDir}`;
+
+    // First resolve
+    const first = await resolvePlaybookSource(source, makeResolveOpts());
+    expect(first!.updated).toBe(true);
+
+    // Backdate the source state's loadedAt so it appears stale
+    const state = sourceStates.get(source)!;
+    state.loadedAt = new Date(Date.now() - 2 * 86400_000).toISOString(); // 2 days ago
+    sourceStates.set(source, state);
+
+    // Resolve again with 1-day maxAge — should trigger a fetch,
+    // but since SHA is unchanged, resolver returns updated:false
+    const result = await resolvePlaybookSource(
+      source,
+      makeResolveOpts({ maxAgeMs: 86400_000 }),
+    );
+    expect(result).not.toBeNull();
+    expect(result!.isGit).toBe(true);
+    expect(result!.commitSha).toBe(first!.commitSha);
+    // SHA matched cached state → no re-load needed
+    expect(result!.updated).toBe(false);
+  });
+
+  it('should detect new commits after stale cache fetch', async () => {
+    const repoDir = await createLocalGitRepo({ playbookNames: ['original-pb'] });
+    const source = `git:${repoDir}`;
+
+    // First resolve
+    const first = await resolvePlaybookSource(source, makeResolveOpts());
+    expect(first!.updated).toBe(true);
+    const originalSha = first!.commitSha;
+
+    // Push a new commit to the "remote"
+    const workDir = join(tempDir, `work-update-${Date.now()}`);
+    await mkdir(workDir);
+    await execFile('git', ['clone', repoDir, workDir]);
+    await execFile('git', ['config', 'commit.gpgSign', 'false'], { cwd: workDir });
+    await writeFile(
+      join(workDir, 'playbooks', 'new-pb.json'),
+      JSON.stringify({
+        name: 'new-pb',
+        applicability: { situations: ['new situation'], domains: ['testing'] },
+        guidance: { strategy: 'new strategy', tactics: ['new tactic'] },
+      }),
+    );
+    await execFile('git', ['add', '.'], { cwd: workDir });
+    await execFile('git', ['commit', '-m', 'Add new playbook'], {
+      cwd: workDir,
+      env: {
+        ...process.env,
+        GIT_AUTHOR_NAME: 'Test',
+        GIT_AUTHOR_EMAIL: 'test@test.com',
+        GIT_COMMITTER_NAME: 'Test',
+        GIT_COMMITTER_EMAIL: 'test@test.com',
+      },
+    });
+    await execFile('git', ['push', 'origin', 'HEAD'], { cwd: workDir });
+
+    // Backdate state to trigger fetch
+    const state = sourceStates.get(source)!;
+    state.loadedAt = new Date(Date.now() - 2 * 86400_000).toISOString();
+    sourceStates.set(source, state);
+
+    // Resolve again — should detect new SHA
+    const result = await resolvePlaybookSource(
+      source,
+      makeResolveOpts({ maxAgeMs: 86400_000 }),
+    );
+    expect(result).not.toBeNull();
+    expect(result!.updated).toBe(true);
+    expect(result!.commitSha).not.toBe(originalSha);
+  });
+
+  it('should resolve repo with manifest-based discovery', async () => {
+    const repoDir = await createLocalGitRepo({
+      playbookNames: ['manifest-pb'],
+      useManifest: true,
+      playbookSubdir: 'custom-dir',
+    });
+
+    const result = await resolvePlaybookSource(`git:${repoDir}`, makeResolveOpts());
+    expect(result).not.toBeNull();
+    expect(result!.playbookDir).toContain('custom-dir');
+  });
+
+  it('should resolve repo using a tag ref', async () => {
+    const repoDir = await createLocalGitRepo({
+      playbookNames: ['tagged-pb'],
+      createTag: 'v1.0.0',
+    });
+
+    const result = await resolvePlaybookSource(
+      `git:${repoDir}#v1.0.0`,
+      makeResolveOpts(),
+    );
+    expect(result).not.toBeNull();
+    expect(result!.isGit).toBe(true);
+    expect(result!.commitSha).toBeDefined();
+    expect(result!.commitSha!.length).toBe(40);
+  });
+
+  it('should return null for git repo with no discoverable playbook dir', async () => {
+    // Create a bare repo with no playbooks directory
+    const repoDir = join(tempDir, 'empty-remote');
+    await mkdir(repoDir);
+    await execFile('git', ['init', '--bare', repoDir]);
+
+    const workDir = join(tempDir, 'empty-work');
+    await mkdir(workDir);
+    await execFile('git', ['clone', repoDir, workDir]);
+    await execFile('git', ['config', 'commit.gpgSign', 'false'], { cwd: workDir });
+    await writeFile(join(workDir, 'README.md'), '# Empty repo');
+    await execFile('git', ['add', '.'], { cwd: workDir });
+    await execFile('git', ['commit', '-m', 'No playbooks'], {
+      cwd: workDir,
+      env: {
+        ...process.env,
+        GIT_AUTHOR_NAME: 'Test',
+        GIT_AUTHOR_EMAIL: 'test@test.com',
+        GIT_COMMITTER_NAME: 'Test',
+        GIT_COMMITTER_EMAIL: 'test@test.com',
+      },
+    });
+    await execFile('git', ['push', 'origin', 'HEAD'], { cwd: workDir });
+
+    const result = await resolvePlaybookSource(`git:${repoDir}`, makeResolveOpts());
+    expect(result).toBeNull();
+  });
+});
+
+// ============================================================================
+// End-to-end: git source → resolve → load into PlaybookLibrary
+// ============================================================================
+
+describe('End-to-end: git source → PlaybookLibrary', () => {
+  let tempDir: string;
+  let cacheDir: string;
+  let library: PlaybookLibrary;
+  let persistence: ReturnType<typeof createSqlitePersistence>;
+  let sourceStates: Map<string, SourceState>;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'resolver-e2e-'));
+    cacheDir = join(tempDir, 'cache');
+    await mkdir(cacheDir);
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    library = createPlaybookLibrary(persistence);
+    await library.init();
+    sourceStates = new Map();
+  });
+
+  afterEach(async () => {
+    await library.close();
+    persistence.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  async function createLocalGitRepo(names: string[]): Promise<string> {
+    const repoDir = join(tempDir, `e2e-remote-${Date.now()}`);
+    await mkdir(repoDir);
+    await execFile('git', ['init', '--bare', repoDir]);
+
+    const workDir = join(tempDir, `e2e-work-${Date.now()}`);
+    await mkdir(workDir);
+    await execFile('git', ['clone', repoDir, workDir]);
+    await execFile('git', ['config', 'commit.gpgSign', 'false'], { cwd: workDir });
+
+    const pbDir = join(workDir, 'playbooks');
+    await mkdir(pbDir);
+
+    for (const name of names) {
+      await writeFile(
+        join(pbDir, `${name}.json`),
+        JSON.stringify({
+          name,
+          applicability: {
+            situations: [`${name} situation`],
+            triggers: [`${name} trigger`],
+            domains: ['testing'],
+          },
+          guidance: {
+            strategy: `${name} strategy`,
+            tactics: [`${name} tactic 1`, `${name} tactic 2`],
+          },
+          verification: {
+            successIndicators: ['Tests pass'],
+            failureIndicators: ['Tests fail'],
+          },
+          confidence: 0.85,
+          curatedBy: 'e2e-test',
+        }),
+      );
+    }
+
+    await execFile('git', ['add', '.'], { cwd: workDir });
+    await execFile('git', ['commit', '-m', 'Add playbooks'], {
+      cwd: workDir,
+      env: {
+        ...process.env,
+        GIT_AUTHOR_NAME: 'Test',
+        GIT_AUTHOR_EMAIL: 'test@test.com',
+        GIT_COMMITTER_NAME: 'Test',
+        GIT_COMMITTER_EMAIL: 'test@test.com',
+      },
+    });
+    await execFile('git', ['push', 'origin', 'HEAD'], { cwd: workDir });
+    return repoDir;
+  }
+
+  it('should resolve a git source and load playbooks into the library', async () => {
+    const repoDir = await createLocalGitRepo(['alpha-pb', 'beta-pb', 'gamma-pb']);
+    const source = `git:${repoDir}`;
+
+    // Resolve
+    const resolved = await resolvePlaybookSource(source, {
+      cacheDir,
+      maxAgeMs: 86400_000,
+      getSourceState: (s) => sourceStates.get(s),
+      setSourceState: (s, state) => sourceStates.set(s, state),
+    });
+
+    expect(resolved).not.toBeNull();
+    expect(resolved!.updated).toBe(true);
+
+    // Load into library
+    const loadResult = await loadCuratedPlaybooks(
+      resolved!.playbookDir,
+      library,
+      { sourceId: resolved!.sourceId },
+    );
+
+    expect(loadResult.loaded).toBe(3);
+    expect(loadResult.errors).toEqual([]);
+
+    // Verify playbooks are in the library with correct provenance
+    const alpha = await library.getByName('alpha-pb');
+    expect(alpha).toBeDefined();
+    expect(alpha!.provenance?.origin).toBe('curated');
+    expect(alpha!.provenance?.sourceFile).toMatch(new RegExp(`^${source.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}:`));
+    expect(alpha!.provenance?.curatedBy).toBe('e2e-test');
+    expect(alpha!.confidence).toBe(0.85);
+
+    const beta = await library.getByName('beta-pb');
+    expect(beta).toBeDefined();
+
+    const gamma = await library.getByName('gamma-pb');
+    expect(gamma).toBeDefined();
+
+    // Verify searchable
+    const matches = await library.findMatching('alpha situation');
+    expect(matches.length).toBeGreaterThan(0);
+    expect(matches.some(m => m.playbook.name === 'alpha-pb')).toBe(true);
+  });
+
+  it('should support per-source recreate in e2e flow', async () => {
+    const repoA = await createLocalGitRepo(['pb-from-a']);
+    const repoB = await createLocalGitRepo(['pb-from-b']);
+    const sourceA = `git:${repoA}`;
+    const sourceB = `git:${repoB}`;
+
+    // Resolve and load both
+    const resolvedA = await resolvePlaybookSource(sourceA, {
+      cacheDir,
+      maxAgeMs: 86400_000,
+      getSourceState: (s) => sourceStates.get(s),
+      setSourceState: (s, state) => sourceStates.set(s, state),
+    });
+    await loadCuratedPlaybooks(resolvedA!.playbookDir, library, { sourceId: sourceA });
+
+    const resolvedB = await resolvePlaybookSource(sourceB, {
+      cacheDir,
+      maxAgeMs: 86400_000,
+      getSourceState: (s) => sourceStates.get(s),
+      setSourceState: (s, state) => sourceStates.set(s, state),
+    });
+    await loadCuratedPlaybooks(resolvedB!.playbookDir, library, { sourceId: sourceB });
+
+    expect(await library.count()).toBe(2);
+
+    // Recreate only source A — source B's playbook should survive
+    await loadCuratedPlaybooks(resolvedA!.playbookDir, library, {
+      sourceId: sourceA,
+      recreate: true,
+    });
+
+    expect(await library.count()).toBe(2); // 1 from A (reloaded) + 1 from B (untouched)
+    expect(await library.getByName('pb-from-a')).toBeDefined();
+    expect(await library.getByName('pb-from-b')).toBeDefined();
+  });
+});
+
+// ============================================================================
+// Unit: sourceStateKey
+// ============================================================================
+
+describe('sourceStateKey', () => {
+  it('should generate prefixed key', () => {
+    expect(sourceStateKey('github:org/repo')).toBe('curated-source:github:org/repo');
+  });
+});