cognitive-core 0.1.2 → 0.2.0

package/tests/session-bank/parser.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { EntireTranscriptParser } from '../../src/session-bank/parser.js';
+import { CheckpointParser, detectFormat } from '../../src/session-bank/parser.js';
 
 const FIXTURES = join(import.meta.dirname, 'fixtures');
 
@@ -11,8 +11,8 @@ async function loadFixture(
   return readFile(join(FIXTURES, ...segments), 'utf-8');
 }
 
-describe('EntireTranscriptParser', () => {
-  const parser = new EntireTranscriptParser();
+describe('CheckpointParser', () => {
+  const parser = new CheckpointParser();
 
   // ──────────────────────────────────────────────────────────────
   // parseMetadata
@@ -318,4 +318,136 @@ describe('EntireTranscriptParser', () => {
       expect(session.source.sessionIndex).toBe('0');
     });
   });
+
+  // ──────────────────────────────────────────────────────────────
+  // detectFormat
+  // ──────────────────────────────────────────────────────────────
+
+  describe('detectFormat', () => {
+    it('should detect Entire CLI format (snake_case)', () => {
+      expect(detectFormat({ checkpoint_id: 'abc' })).toBe('entire');
+    });
+
+    it('should detect SessionLog format (camelCase)', () => {
+      expect(detectFormat({ checkpointID: 'abc' })).toBe('sessionlog');
+    });
+
+    it('should detect SessionLog via cliVersion', () => {
+      expect(detectFormat({ cliVersion: 'opentasks-sessionlog' })).toBe('sessionlog');
+    });
+
+    it('should detect Entire via cli_version', () => {
+      expect(detectFormat({ cli_version: '0.4.0' })).toBe('entire');
+    });
+
+    it('should return unknown for empty object', () => {
+      expect(detectFormat({})).toBe('unknown');
+    });
+  });
+
+  // ──────────────────────────────────────────────────────────────
+  // SessionLog format parsing
+  // ──────────────────────────────────────────────────────────────
+
+  describe('SessionLog format', () => {
+    it('should parse SessionLog camelCase metadata', async () => {
+      const json = await loadFixture('sessionlog-session', 'metadata.json');
+      const result = parser.parseMetadata(json);
+
+      expect(result.format).toBe('sessionlog');
+      expect(result.sessionId).toBe(
+        '2026-02-15-aabbccdd-1122-3344-5566-778899aabbcc',
+      );
+      expect(result.checkpointId).toBe('c4d5e6f7a8b9');
+      expect(result.metadata.cliVersion).toBe('opentasks-sessionlog');
+      expect(result.metadata.strategy).toBe('manual-commit');
+      expect(result.metadata.createdAt).toBeInstanceOf(Date);
+      expect(result.metadata.branch).toBe('main');
+      expect(result.metadata.agent).toBe('Claude Code');
+      expect(result.metadata.filesTouched).toEqual([
+        'src/api.ts',
+        'tests/api.test.ts',
+      ]);
+      expect(result.metadata.isTask).toBe(false);
+      expect(result.metadata.checkpointTranscriptStart).toBe(0);
+    });
+
+    it('should parse SessionLog summary with CodeLearning normalization', async () => {
+      const json = await loadFixture('sessionlog-session', 'metadata.json');
+      const result = parser.parseMetadata(json);
+
+      expect(result.summary).toBeDefined();
+      expect(result.summary!.intent).toBe('Add validation to the API endpoint');
+      expect(result.summary!.outcome).toContain('Zod schema');
+      expect(result.summary!.learnings.repoPatterns).toEqual([
+        'API routes use Zod for validation',
+      ]);
+      // CodeLearning[] → string[]
+      expect(result.summary!.learnings.codeFindings).toHaveLength(1);
+      expect(result.summary!.learnings.codeFindings[0]).toBe(
+        'src/api.ts:15 - Zod schema must be defined before route handler',
+      );
+      expect(result.summary!.learnings.workflowPractices).toEqual([
+        'Run API tests with --reporter=verbose flag',
+      ]);
+      expect(result.summary!.frictionPoints).toEqual([
+        'Had to look up Zod coercion syntax',
+      ]);
+      expect(result.summary!.openItems).toEqual([
+        'Add validation for the PUT endpoint too',
+      ]);
+    });
+
+    it('should parse SessionLog token usage with single subagentTokens', async () => {
+      const json = await loadFixture('sessionlog-session', 'metadata.json');
+      const result = parser.parseMetadata(json);
+
+      expect(result.tokenUsage.inputTokens).toBe(20000);
+      expect(result.tokenUsage.cacheCreationTokens).toBe(3000);
+      expect(result.tokenUsage.cacheReadTokens).toBe(6000);
+      expect(result.tokenUsage.outputTokens).toBe(4000);
+      expect(result.tokenUsage.apiCallCount).toBe(10);
+      expect(result.tokenUsage.total).toBe(20000 + 3000 + 6000 + 4000);
+
+      // Single subagentTokens object wrapped in array
+      expect(result.tokenUsage.subagentUsage).toBeDefined();
+      expect(result.tokenUsage.subagentUsage).toHaveLength(1);
+      expect(result.tokenUsage.subagentUsage![0].inputTokens).toBe(2000);
+      expect(result.tokenUsage.subagentUsage![0].outputTokens).toBe(800);
+      expect(result.tokenUsage.subagentUsage![0].total).toBe(2000 + 800);
+    });
+
+    it('should parse SessionLog attribution', async () => {
+      const json = await loadFixture('sessionlog-session', 'metadata.json');
+      const result = parser.parseMetadata(json);
+
+      expect(result.attribution).toBeDefined();
+      expect(result.attribution!.agentLinesAdded).toBe(30);
+      expect(result.attribution!.humanAdditions).toBe(3);
+      expect(result.attribution!.humanModifications).toBe(1);
+      expect(result.attribution!.humanRemovals).toBe(0);
+      expect(result.attribution!.totalCommittedLines).toBe(34);
+      expect(result.attribution!.agentContribution).toBe(0.88);
+    });
+
+    it('should parse SessionLog transcript (uses "user" not "human")', async () => {
+      const jsonl = await loadFixture('sessionlog-session', 'full.jsonl');
+      const messages = parser.parseTranscript(jsonl);
+
+      expect(messages).toHaveLength(6);
+      expect(messages[0].role).toBe('user');
+      expect(messages[0].uuid).toBe('msg-sl-001');
+      expect(messages[1].role).toBe('assistant');
+      expect(messages[1].content).toHaveLength(2);
+    });
+
+    it('should parse SessionLog root checkpoint summary', async () => {
+      const json = await loadFixture('sessionlog-root-metadata.json');
+      const ref = parser.parseCheckpointSummary(json, 'c4/d5e6f7a8b9');
+
+      expect(ref.checkpointId).toBe('c4d5e6f7a8b9');
+      expect(ref.path).toBe('c4/d5e6f7a8b9');
+      expect(ref.sessionCount).toBe(1);
+    });
+  });
 });

package/tests/session-bank/session-bank.test.ts

@@ -167,7 +167,7 @@ async function createFixtureRepo(): Promise<string> {
   );
 
   const orphanCommit = commitTree(tmpDir, rootTree, 'checkpoint data');
-  git(tmpDir, ['update-ref', 'refs/heads/entire/checkpoints/v1', orphanCommit]);
+  git(tmpDir, ['update-ref', 'refs/heads/sessionlog/checkpoints/v1', orphanCommit]);
 
   return tmpDir;
 }

package/tests/surfacing/skill-library.test.ts

@@ -3,6 +3,7 @@ import { SkillLibrary, createSkillLibrary } from '../../src/surfacing/skill-libr
 import { PlaybookLibrary, createPlaybookLibrary } from '../../src/memory/playbook.js';
 import type { Playbook } from '../../src/types/playbook.js';
 import type { Task } from '../../src/types/task.js';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
@@ -11,10 +12,13 @@ describe('SkillLibrary', () => {
   let tempDir: string;
   let playbooks: PlaybookLibrary;
   let skillLibrary: SkillLibrary;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'atlas-test-'));
-    playbooks = createPlaybookLibrary(tempDir);
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    playbooks = createPlaybookLibrary(persistence);
     await playbooks.init();
     skillLibrary = createSkillLibrary(playbooks, {
       promotion: {
@@ -32,6 +36,7 @@ describe('SkillLibrary', () => {
 
   afterEach(async () => {
     await playbooks.close();
+    persistence.close();
     await rm(tempDir, { recursive: true, force: true });
   });
 

package/tests/surfacing/skill-publisher.test.ts

@@ -73,34 +73,34 @@ describe('SkillPublisher', () => {
       expect(skill.status).toBe('active');
     });
 
-    it('should map situations to problem and description', () => {
+    it('should map situations to description and instructions', () => {
       const playbook = createSamplePlaybook();
       const skill = convertPlaybookToSkill(playbook);
 
       expect(skill.description).toBe('TypeScript import fails with TS2307');
-      expect(skill.problem).toContain('TypeScript import fails with TS2307');
+      expect(skill.instructions).toContain('TypeScript import fails with TS2307');
     });
 
-    it('should build solution from strategy, tactics, and steps', () => {
+    it('should build instructions from strategy, tactics, and steps', () => {
       const playbook = createSamplePlaybook();
       const skill = convertPlaybookToSkill(playbook);
 
-      expect(skill.solution).toContain('Add .js extension to ES module imports');
-      expect(skill.solution).toContain('Tactics:');
-      expect(skill.solution).toContain('Check for imports without file extensions');
-      expect(skill.solution).toContain('Steps:');
-      expect(skill.solution).toContain('Verify with tsc --noEmit');
+      expect(skill.instructions).toContain('Add .js extension to ES module imports');
+      expect(skill.instructions).toContain('Tactics:');
+      expect(skill.instructions).toContain('Check for imports without file extensions');
+      expect(skill.instructions).toContain('Steps:');
+      expect(skill.instructions).toContain('Verify with tsc --noEmit');
     });
 
-    it('should map verification and notes correctly', () => {
+    it('should include verification and notes in instructions', () => {
       const playbook = createSamplePlaybook();
       const skill = convertPlaybookToSkill(playbook);
 
-      expect(skill.verification).toContain('Build passes');
-      expect(skill.notes).toContain('Do NOT use when:');
-      expect(skill.notes).toContain('Watch for:');
-      expect(skill.notes).toContain('Refinements:');
-      expect(skill.notes).toContain('Rollback:');
+      expect(skill.instructions).toContain('Build passes');
+      expect(skill.instructions).toContain('Do NOT use when:');
+      expect(skill.instructions).toContain('Watch for:');
+      expect(skill.instructions).toContain('Refinements:');
+      expect(skill.instructions).toContain('Rollback:');
     });
 
     it('should compute metrics from evolution data', () => {
@@ -113,50 +113,20 @@ describe('SkillPublisher', () => {
       expect(skill.metrics.lastUsed).toBeDefined();
     });
 
-    it('should create trigger conditions with correct types', () => {
+    it('should include code example in instructions', () => {
       const playbook = createSamplePlaybook();
       const skill = convertPlaybookToSkill(playbook);
 
-      const contextTriggers = skill.triggerConditions.filter(t => t.type === 'context');
-      expect(contextTriggers.length).toBe(1);
-      expect(contextTriggers[0].value).toContain('TS2307');
-
-      const errorTriggers = skill.triggerConditions.filter(t => t.type === 'error');
-      expect(errorTriggers.some(t => t.value === 'TS2307')).toBe(true);
-
-      const keywordTriggers = skill.triggerConditions.filter(t => t.type === 'keyword');
-      expect(keywordTriggers.some(t => t.value === 'Cannot find module')).toBe(true);
-    });
-
-    it('should detect pattern-type triggers', () => {
-      const playbook = createSamplePlaybook({
-        applicability: {
-          situations: [],
-          triggers: ['*.config.ts', '/src/**/*.tsx'],
-          antiPatterns: [],
-          domains: [],
-        },
-      });
-      const skill = convertPlaybookToSkill(playbook);
-
-      const patternTriggers = skill.triggerConditions.filter(t => t.type === 'pattern');
-      expect(patternTriggers.length).toBe(2);
-    });
-
-    it('should map code example to examples array', () => {
-      const playbook = createSamplePlaybook();
-      const skill = convertPlaybookToSkill(playbook);
-
-      expect(skill.examples.length).toBe(1);
-      expect(skill.examples[0].after).toContain('utils.js');
+      expect(skill.instructions).toContain('utils.js');
+      expect(skill.instructions).toContain('Example');
     });
 
-    it('should produce empty examples when no codeExample', () => {
+    it('should omit example section when no codeExample', () => {
       const playbook = createSamplePlaybook();
       playbook.guidance.codeExample = undefined;
       const skill = convertPlaybookToSkill(playbook);
 
-      expect(skill.examples.length).toBe(0);
+      expect(skill.instructions).not.toContain('## Example');
     });
 
     it('should set serving metadata with token estimate', () => {
@@ -195,11 +165,8 @@ describe('SkillPublisher', () => {
       });
       const skill = convertPlaybookToSkill(playbook);
 
-      expect(skill.problem).toBe('');
-      expect(skill.triggerConditions.length).toBe(0);
       expect(skill.tags.length).toBe(0);
-      expect(skill.notes).toBeUndefined();
-      expect(skill.verification).toContain('Verify the approach worked');
+      expect(skill.instructions).toContain('Verify the approach worked');
     });
 
     it('should be type-compatible with skill-tree Skill', () => {
@@ -252,7 +219,7 @@ describe('SkillPublisher', () => {
 
       const skill = await storage.getSkill('update-1');
       expect(skill!.version).toBe('2.0.0');
-      expect(skill!.solution).toContain('Updated approach');
+      expect(skill!.instructions).toContain('Updated approach');
     });
 
     it('should track published IDs', async () => {
@@ -298,7 +265,7 @@ describe('SkillPublisher', () => {
 
       const skill = await storage.getSkill('dep-1');
       expect(skill!.status).toBe('deprecated');
-      expect(skill!.notes).toContain('Deprecated: Low performance');
+      expect(skill!.description).toContain('Deprecated: Low performance');
     });
 
     it('should return error for non-existent skill', async () => {
@@ -315,13 +282,12 @@ describe('SkillPublisher', () => {
       await publisher.publishPlaybook(createSamplePlaybook({ id: 'notes-1' }));
 
       const before = await storage.getSkill('notes-1');
-      expect(before!.notes).toContain('Do NOT use when:');
+      expect(before!.instructions).toContain('Do NOT use when:');
 
       await publisher.deprecateSkill('notes-1', 'Superseded');
 
       const after = await storage.getSkill('notes-1');
-      expect(after!.notes).toContain('Do NOT use when:');
-      expect(after!.notes).toContain('Deprecated: Superseded');
+      expect(after!.description).toContain('Deprecated: Superseded');
     });
   });
 

package/tests/surfacing/sqlite-storage-adapter.test.ts

@@ -12,19 +12,10 @@ function createSampleSkill(overrides?: Partial<Skill>): Skill {
     name: 'fix-ts-import',
     version: '1.0.0',
     description: 'Fix TypeScript import errors',
-    problem: 'TypeScript import fails with TS2307',
-    solution: 'Add .js extension to ES module imports',
-    verification: 'Build passes without TS2307 errors',
-    notes: undefined,
+    instructions: 'Add .js extension to ES module imports',
     author: 'cognitive-core',
     status: 'active',
     tags: ['typescript', 'nodejs'],
-    triggerConditions: [
-      { type: 'error', value: 'TS2307', description: 'Import error' },
-    ],
-    examples: [
-      { scenario: 'Missing .js extension', before: 'import { x } from "./util"', after: 'import { x } from "./util.js"' },
-    ],
     metrics: {
       usageCount: 8,
       successRate: 0.9,
@@ -44,7 +35,7 @@ function createSampleSkill(overrides?: Partial<Skill>): Skill {
     createdAt: now,
     updatedAt: now,
     ...overrides,
-  } as Skill;
+  };
 }
 
 describe('SqliteStorageAdapter', () => {
@@ -77,7 +68,7 @@ describe('SqliteStorageAdapter', () => {
     expect(retrieved!.id).toBe('skill-roundtrip');
     expect(retrieved!.name).toBe('fix-ts-import');
     expect(retrieved!.version).toBe('1.0.0');
-    expect(retrieved!.solution).toBe('Add .js extension to ES module imports');
+    expect(retrieved!.instructions).toBe('Add .js extension to ES module imports');
     expect(retrieved!.status).toBe('active');
   });
 
@@ -90,12 +81,12 @@ describe('SqliteStorageAdapter', () => {
     const skill = createSampleSkill({ id: 'skill-update', version: '1.0.0' });
     await adapter.saveSkill(skill);
 
-    const updated = createSampleSkill({ id: 'skill-update', version: '2.0.0', solution: 'Updated solution' });
+    const updated = createSampleSkill({ id: 'skill-update', version: '2.0.0', instructions: 'Updated solution' });
     await adapter.saveSkill(updated);
 
     const retrieved = await adapter.getSkill('skill-update');
     expect(retrieved!.version).toBe('2.0.0');
-    expect(retrieved!.solution).toBe('Updated solution');
+    expect(retrieved!.instructions).toBe('Updated solution');
   });
 
   it('listSkills() returns all skills', async () => {
@@ -135,13 +126,10 @@ describe('SqliteStorageAdapter', () => {
 
     const retrieved = await adapter.getSkill('skill-json');
     expect(retrieved!.tags).toEqual(['typescript', 'nodejs']);
-    expect(retrieved!.triggerConditions).toHaveLength(1);
-    expect(retrieved!.triggerConditions[0].type).toBe('error');
-    expect(retrieved!.examples).toHaveLength(1);
     expect(retrieved!.metrics.usageCount).toBe(8);
     expect(retrieved!.metrics.successRate).toBe(0.9);
-    expect(retrieved!.source.type).toBe('extracted');
-    expect(retrieved!.serving.tokenEstimate).toBe(150);
+    expect(retrieved!.source!.type).toBe('extracted');
+    expect(retrieved!.serving!.tokenEstimate).toBe(150);
   });
 
   it('Date fields survive round-trip', async () => {
@@ -173,7 +161,7 @@ describe('SqliteStorageAdapter', () => {
     const skill1 = createSampleSkill({ id: 'skill-versioned', version: '1.0.0' });
     await adapter.saveSkill(skill1);
 
-    const skill2 = createSampleSkill({ id: 'skill-versioned', version: '2.0.0', solution: 'Updated' });
+    const skill2 = createSampleSkill({ id: 'skill-versioned', version: '2.0.0', instructions: 'Updated' });
     await adapter.saveSkill(skill2);
 
     const history = await adapter.getVersionHistory('skill-versioned');
@@ -198,17 +186,17 @@ describe('SqliteStorageAdapter', () => {
 
   it('searchSkills() finds by name', async () => {
     await adapter.saveSkill(createSampleSkill({ id: 'skill-search', name: 'fix-import-error' }));
-    await adapter.saveSkill(createSampleSkill({ id: 'skill-other', name: 'refactor-tests', solution: 'Reorganize test files' }));
+    await adapter.saveSkill(createSampleSkill({ id: 'skill-other', name: 'refactor-tests', instructions: 'Reorganize test files' }));
 
     const results = await adapter.searchSkills('refactor');
     expect(results).toHaveLength(1);
     expect(results[0].id).toBe('skill-other');
   });
 
-  it('searchSkills() finds by solution content', async () => {
+  it('searchSkills() finds by instructions content', async () => {
     await adapter.saveSkill(createSampleSkill({
       id: 'skill-solution',
-      solution: 'Use jest.mock() to mock dependencies',
+      instructions: 'Use jest.mock() to mock dependencies',
     }));
 
     const results = await adapter.searchSkills('jest.mock');

package/tests/utils/partitioned-store.test.ts

@@ -0,0 +1,230 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { PartitionedStore } from '../../src/utils/partitioned-store.js';
+import { mkdtemp, rm, writeFile, mkdir, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+interface TestItem {
+  id: string;
+  name: string;
+  domain?: string;
+}
+
+describe('PartitionedStore', () => {
+  let tempDir: string;
+  let store: PartitionedStore<TestItem>;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-partitioned-test-'));
+    store = new PartitionedStore<TestItem>(
+      tempDir,
+      'items',
+      (item) => item.domain || undefined,
+      { pretty: true },
+    );
+    await store.init();
+  });
+
+  afterEach(async () => {
+    await store.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('set and get', () => {
+    it('should store and retrieve items', async () => {
+      const item: TestItem = { id: 'a', name: 'alpha', domain: 'ts' };
+      store.set('a', item);
+
+      expect(store.get('a')).toEqual(item);
+    });
+
+    it('should route items to correct partition', async () => {
+      store.set('a', { id: 'a', name: 'alpha', domain: 'ts' });
+      store.set('b', { id: 'b', name: 'beta', domain: 'py' });
+
+      expect(store.valuesInPartition('ts')).toHaveLength(1);
+      expect(store.valuesInPartition('ts')[0].name).toBe('alpha');
+      expect(store.valuesInPartition('py')).toHaveLength(1);
+      expect(store.valuesInPartition('py')[0].name).toBe('beta');
+    });
+
+    it('should put items without domain in _global partition', async () => {
+      store.set('a', { id: 'a', name: 'alpha' }); // no domain
+      expect(store.valuesInPartition('_global')).toHaveLength(1);
+    });
+
+    it('should return undefined for non-existent key', () => {
+      expect(store.get('missing')).toBeUndefined();
+    });
+
+    it('should move item to new partition when domain changes', () => {
+      store.set('a', { id: 'a', name: 'alpha', domain: 'ts' });
+      expect(store.valuesInPartition('ts')).toHaveLength(1);
+
+      store.set('a', { id: 'a', name: 'alpha', domain: 'py' });
+      expect(store.valuesInPartition('ts')).toHaveLength(0);
+      expect(store.valuesInPartition('py')).toHaveLength(1);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete an item from its partition', () => {
+      store.set('a', { id: 'a', name: 'alpha', domain: 'ts' });
+      expect(store.has('a')).toBe(true);
+
+      const deleted = store.delete('a');
+      expect(deleted).toBe(true);
+      expect(store.has('a')).toBe(false);
+      expect(store.size()).toBe(0);
+    });
+
+    it('should return false for non-existent key', () => {
+      expect(store.delete('missing')).toBe(false);
+    });
+  });
+
+  describe('has', () => {
+    it('should return true for existing items', () => {
+      store.set('a', { id: 'a', name: 'alpha', domain: 'ts' });
+      expect(store.has('a')).toBe(true);
+    });
+
+    it('should return false for missing items', () => {
+      expect(store.has('missing')).toBe(false);
+    });
+  });
+
+  describe('values and valuesInPartition', () => {
+    it('should return all values across partitions', () => {
+      store.set('a', { id: 'a', name: 'alpha', domain: 'ts' });
+      store.set('b', { id: 'b', name: 'beta', domain: 'py' });
+      store.set('c', { id: 'c', name: 'gamma' }); // global
+
+      const all = store.values();
+      expect(all).toHaveLength(3);
+    });
+
+    it('should return only values in a specific partition', () => {
+      store.set('a', { id: 'a', name: 'alpha', domain: 'ts' });
+      store.set('b', { id: 'b', name: 'beta', domain: 'ts' });
+      store.set('c', { id: 'c', name: 'gamma', domain: 'py' });
+
+      expect(store.valuesInPartition('ts')).toHaveLength(2);
+      expect(store.valuesInPartition('py')).toHaveLength(1);
+      expect(store.valuesInPartition('unknown')).toHaveLength(0);
+    });
+  });
+
+  describe('keys, entries, size', () => {
+    it('should return all keys across partitions', () => {
+      store.set('a', { id: 'a', name: 'alpha', domain: 'ts' });
+      store.set('b', { id: 'b', name: 'beta', domain: 'py' });
+
+      const keys = store.keys();
+      expect(keys).toContain('a');
+      expect(keys).toContain('b');
+      expect(keys).toHaveLength(2);
+    });
+
+    it('should return correct size across partitions', () => {
+      expect(store.size()).toBe(0);
+      store.set('a', { id: 'a', name: 'alpha', domain: 'ts' });
+      store.set('b', { id: 'b', name: 'beta', domain: 'py' });
+      expect(store.size()).toBe(2);
+    });
+
+    it('should return all entries', () => {
+      store.set('a', { id: 'a', name: 'alpha', domain: 'ts' });
+      store.set('b', { id: 'b', name: 'beta', domain: 'py' });
+
+      const entries = store.entries();
+      expect(entries).toHaveLength(2);
+      expect(entries.map(([k]) => k)).toContain('a');
+    });
+  });
+
+  describe('getPartitionNames', () => {
+    it('should list all partition names', () => {
+      store.set('a', { id: 'a', name: 'alpha', domain: 'ts' });
+      store.set('b', { id: 'b', name: 'beta', domain: 'py' });
+
+      const names = store.getPartitionNames();
+      expect(names).toContain('_global');
+      expect(names).toContain('ts');
+      expect(names).toContain('py');
+    });
+  });
+
+  describe('persistence', () => {
+    it('should persist data across reloads', async () => {
+      store.set('a', { id: 'a', name: 'alpha', domain: 'ts' });
+      store.set('b', { id: 'b', name: 'beta', domain: 'py' });
+      await store.flush();
+      await store.close();
+
+      // Create new store instance
+      const store2 = new PartitionedStore<TestItem>(
+        tempDir,
+        'items',
+        (item) => item.domain || undefined,
+        { pretty: true },
+      );
+      await store2.init();
+
+      expect(store2.get('a')?.name).toBe('alpha');
+      expect(store2.get('b')?.name).toBe('beta');
+      expect(store2.size()).toBe(2);
+
+      await store2.close();
+    });
+  });
+
+  describe('migration from flat layout', () => {
+    it('should auto-migrate flat JSON files into partition subdirectories', async () => {
+      await store.close();
+
+      // Create a flat layout manually (files directly in collection dir)
+      const collectionDir = join(tempDir, 'migrated');
+      await mkdir(collectionDir, { recursive: true });
+
+      await writeFile(
+        join(collectionDir, 'item1.json'),
+        JSON.stringify({ id: 'item1', name: 'first', domain: 'ts' }),
+      );
+      await writeFile(
+        join(collectionDir, 'item2.json'),
+        JSON.stringify({ id: 'item2', name: 'second', domain: 'py' }),
+      );
+      await writeFile(
+        join(collectionDir, 'item3.json'),
+        JSON.stringify({ id: 'item3', name: 'third' }), // no domain → _global
+      );
+
+      // Create PartitionedStore on top of it
+      const migratingStore = new PartitionedStore<TestItem>(
+        tempDir,
+        'migrated',
+        (item) => item.domain || undefined,
+        { pretty: true },
+      );
+      await migratingStore.init();
+
+      // Flat files should have been migrated into subdirs
+      expect(migratingStore.get('item1')?.name).toBe('first');
+      expect(migratingStore.get('item2')?.name).toBe('second');
+      expect(migratingStore.get('item3')?.name).toBe('third');
+
+      expect(migratingStore.valuesInPartition('ts')).toHaveLength(1);
+      expect(migratingStore.valuesInPartition('py')).toHaveLength(1);
+      expect(migratingStore.valuesInPartition('_global')).toHaveLength(1);
+
+      // Verify subdirectories were created on disk
+      const entries = await readdir(collectionDir);
+      expect(entries).toContain('ts');
+      expect(entries).toContain('py');
+      expect(entries).toContain('_global');
+
+      await migratingStore.close();
+    });
+  });
+});