cognitive-core 0.2.4 → 0.3.1

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

@@ -1,231 +0,0 @@
-/**
- * Integration test: SessionBank → SessionTrajectorySource → LearningPipeline
- *
- * Creates a real git repo with fixture data on an orphan branch,
- * runs the full flow from session discovery through trajectory
- * synthesis to learning pipeline processing.
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtemp, rm, readFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { execFileSync } from 'node:child_process';
-import { SessionBank } from '../../src/session-bank/session-bank.js';
-import { SessionTrajectorySource } from '../../src/learning/trajectory-sources/entire.js';
-import { TrajectorySchema } from '../../src/types/trajectory.js';
-import { UnifiedLearningPipeline } from '../../src/learning/unified-pipeline.js';
-import { MemorySystem, createMemorySystem } from '../../src/memory/system.js';
-import { createSqlitePersistence } from '../../src/persistence/index.js';
-
-const FIXTURES = join(import.meta.dirname, '..', 'session-bank', 'fixtures');
-
-function git(cwd: string, args: string[]): string {
-  return execFileSync('git', ['-c', 'commit.gpgsign=false', ...args], {
-    cwd,
-    encoding: 'utf-8',
-    env: {
-      ...process.env,
-      GIT_AUTHOR_NAME: 'Test',
-      GIT_AUTHOR_EMAIL: 'test@test.com',
-      GIT_COMMITTER_NAME: 'Test',
-      GIT_COMMITTER_EMAIL: 'test@test.com',
-    },
-  }).trim();
-}
-
-function hashObject(cwd: string, content: string): string {
-  return execFileSync('git', ['hash-object', '-w', '--stdin'], {
-    cwd,
-    input: content,
-    encoding: 'utf-8',
-  }).trim();
-}
-
-function mktree(cwd: string, entries: string): string {
-  return execFileSync('git', ['mktree'], {
-    cwd,
-    input: entries,
-    encoding: 'utf-8',
-  }).trim();
-}
-
-function commitTree(
-  cwd: string,
-  treeHash: string,
-  message: string,
-): string {
-  return execFileSync(
-    'git',
-    ['-c', 'commit.gpgsign=false', 'commit-tree', treeHash, '-m', message],
-    {
-      cwd,
-      encoding: 'utf-8',
-      env: {
-        ...process.env,
-        GIT_AUTHOR_NAME: 'Test',
-        GIT_AUTHOR_EMAIL: 'test@test.com',
-        GIT_COMMITTER_NAME: 'Test',
-        GIT_COMMITTER_EMAIL: 'test@test.com',
-      },
-    },
-  ).trim();
-}
-
-async function createFixtureRepo(): Promise<string> {
-  const tmpDir = await mkdtemp(join(tmpdir(), 'integration-test-'));
-
-  git(tmpDir, ['init']);
-  const emptyTree = git(tmpDir, ['hash-object', '-t', 'tree', '/dev/null']);
-  const mainCommit = commitTree(tmpDir, emptyTree, 'initial');
-  git(tmpDir, ['update-ref', 'refs/heads/master', mainCommit]);
-
-  const simpleMeta = await readFile(
-    join(FIXTURES, 'simple-session', 'metadata.json'),
-    'utf-8',
-  );
-  const simpleTranscript = await readFile(
-    join(FIXTURES, 'simple-session', 'full.jsonl'),
-    'utf-8',
-  );
-  const rootMeta = JSON.stringify({
-    sessions: [
-      {
-        metadata: '0/metadata.json',
-        transcript: '0/full.jsonl',
-        context: '0/context.md',
-        content_hash: '0/content_hash.txt',
-        prompt: '0/prompt.txt',
-      },
-    ],
-  });
-
-  const filler = hashObject(tmpDir, 'filler');
-  const s1MetaHash = hashObject(tmpDir, simpleMeta);
-  const s1TransHash = hashObject(tmpDir, simpleTranscript);
-  const root1Hash = hashObject(tmpDir, rootMeta);
-
-  const sess1Tree = mktree(
-    tmpDir,
-    [
-      `100644 blob ${filler}\tcontent_hash.txt`,
-      `100644 blob ${filler}\tcontext.md`,
-      `100644 blob ${s1TransHash}\tfull.jsonl`,
-      `100644 blob ${s1MetaHash}\tmetadata.json`,
-      `100644 blob ${filler}\tprompt.txt`,
-    ].join('\n') + '\n',
-  );
-
-  const cp1Tree = mktree(
-    tmpDir,
-    [
-      `040000 tree ${sess1Tree}\t0`,
-      `100644 blob ${root1Hash}\tmetadata.json`,
-    ].join('\n') + '\n',
-  );
-
-  const shardTree = mktree(
-    tmpDir,
-    `040000 tree ${cp1Tree}\tb2c4d5e6f7\n`,
-  );
-  const rootTree = mktree(tmpDir, `040000 tree ${shardTree}\ta3\n`);
-
-  const orphanCommit = commitTree(tmpDir, rootTree, 'checkpoint data');
-  git(tmpDir, [
-    'update-ref',
-    'refs/heads/sessionlog/checkpoints/v1',
-    orphanCommit,
-  ]);
-
-  return tmpDir;
-}
-
-describe('Session Bank Integration', () => {
-  let tmpDir: string;
-  let memoryDir: string;
-  let memory: MemorySystem;
-  let persistence: any;
-
-  beforeEach(async () => {
-    tmpDir = await createFixtureRepo();
-    memoryDir = await mkdtemp(join(tmpdir(), 'memory-'));
-    persistence = createSqlitePersistence({ baseDir: memoryDir });
-    await persistence.init();
-    memory = createMemorySystem(persistence, memoryDir);
-    await memory.init();
-  });
-
-  afterEach(async () => {
-    persistence.close();
-    await rm(tmpDir, { recursive: true, force: true });
-    await rm(memoryDir, { recursive: true, force: true });
-  });
-
-  it('should flow from SessionBank through synthesis to LearningPipeline', async () => {
-    // 1. Create and init SessionBank
-    const bank = new SessionBank({
-      repoPath: tmpDir,
-      stateDir: join(tmpDir, '.atlas', 'session-bank'),
-    });
-    await bank.init();
-    expect(bank.isAvailable()).toBe(true);
-
-    // 2. Create SessionTrajectorySource
-    const source = new SessionTrajectorySource(bank);
-
-    // 3. Load trajectories
-    const items = await source.load();
-    expect(items).toHaveLength(1);
-
-    // 4. Validate the synthesized trajectory
-    const trajectory = items[0].trajectory;
-    const parsed = TrajectorySchema.safeParse(trajectory);
-    expect(parsed.success).toBe(true);
-
-    expect(trajectory.id).toContain('sessionlog-');
-    expect(trajectory.task.description).toBe(
-      'Fix the authentication token refresh bug in the middleware',
-    );
-    expect(trajectory.task.domain).toBe('typescript');
-    expect(trajectory.steps.length).toBeGreaterThan(0);
-    expect(trajectory.outcome.success).toBe(true);
-    expect(trajectory.totalTokens).toBe(25000);
-    expect(trajectory.agentId).toBe('Claude Code');
-
-    // 5. Process through UnifiedLearningPipeline
-    const pipeline = new UnifiedLearningPipeline(memory, {
-      batch: { learning: { minTrajectories: 100 }, energy: {} },
-    });
-    await pipeline.init();
-    const result = await pipeline.processTrajectory(trajectory);
-    expect(result.instantLoop.experienceId).toBeDefined();
-
-    // 6. Mark as processed
-    await bank.markProcessed(
-      '2026-01-08-abc123de-f456-7890-abcd-ef1234567890',
-      { trajectoryId: trajectory.id },
-    );
-    expect(
-      bank.isProcessed(
-        '2026-01-08-abc123de-f456-7890-abcd-ef1234567890',
-      ),
-    ).toBe(true);
-
-    // 7. Verify unprocessed filter works
-    const remaining = await source.load();
-    // Still returns 1 because SessionTrajectorySource doesn't use unprocessedOnly by default
-    expect(remaining).toHaveLength(1);
-
-    await bank.close();
-  });
-
-  it('should count sessions correctly', async () => {
-    const bank = new SessionBank({ repoPath: tmpDir });
-    await bank.init();
-
-    const source = new SessionTrajectorySource(bank);
-    const count = await source.count();
-    expect(count).toBe(1);
-
-    await bank.close();
-  });
-});

package/tests/integration/sessionlog-e2e.test.ts

@@ -1,329 +0,0 @@
-/**
- * Full end-to-end test for the SessionLog flow:
- *
- *   SessionLog camelCase fixtures
- *     → git orphan branch (sessionlog/checkpoints/v1)
- *     → SessionBank.init() / discover() / query()
- *     → CheckpointParser (camelCase metadata, CodeLearning normalization)
- *     → SessionTrajectorySource.synthesize()
- *     → LearningPipeline.processTrajectory()
- *
- * Verifies the primary SessionLog path end-to-end using camelCase
- * fixture data and the default branch/trailer configuration.
- */
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { mkdtemp, rm, readFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { execFileSync } from 'node:child_process';
-import { SessionBank } from '../../src/session-bank/session-bank.js';
-import { SessionTrajectorySource } from '../../src/learning/trajectory-sources/entire.js';
-import { TrajectorySchema } from '../../src/types/trajectory.js';
-import { UnifiedLearningPipeline } from '../../src/learning/unified-pipeline.js';
-import { MemorySystem, createMemorySystem } from '../../src/memory/system.js';
-import { createSqlitePersistence } from '../../src/persistence/index.js';
-
-const FIXTURES = join(import.meta.dirname, '..', 'session-bank', 'fixtures');
-
-function git(cwd: string, args: string[]): string {
-  return execFileSync('git', ['-c', 'commit.gpgsign=false', ...args], {
-    cwd,
-    encoding: 'utf-8',
-    env: {
-      ...process.env,
-      GIT_AUTHOR_NAME: 'Test',
-      GIT_AUTHOR_EMAIL: 'test@test.com',
-      GIT_COMMITTER_NAME: 'Test',
-      GIT_COMMITTER_EMAIL: 'test@test.com',
-    },
-  }).trim();
-}
-
-function hashObject(cwd: string, content: string): string {
-  return execFileSync('git', ['hash-object', '-w', '--stdin'], {
-    cwd,
-    input: content,
-    encoding: 'utf-8',
-  }).trim();
-}
-
-function mktree(cwd: string, entries: string): string {
-  return execFileSync('git', ['mktree'], {
-    cwd,
-    input: entries,
-    encoding: 'utf-8',
-  }).trim();
-}
-
-function commitTree(cwd: string, treeHash: string, message: string): string {
-  return execFileSync(
-    'git',
-    ['-c', 'commit.gpgsign=false', 'commit-tree', treeHash, '-m', message],
-    {
-      cwd,
-      encoding: 'utf-8',
-      env: {
-        ...process.env,
-        GIT_AUTHOR_NAME: 'Test',
-        GIT_AUTHOR_EMAIL: 'test@test.com',
-        GIT_COMMITTER_NAME: 'Test',
-        GIT_COMMITTER_EMAIL: 'test@test.com',
-      },
-    },
-  ).trim();
-}
-
-describe('SessionLog E2E', () => {
-  let tmpDir: string;
-  let memoryDir: string;
-  let memory: MemorySystem;
-  let persistence: any;
-
-  beforeAll(async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'sessionlog-e2e-'));
-    memoryDir = await mkdtemp(join(tmpdir(), 'sessionlog-memory-'));
-
-    // Init git repo
-    git(tmpDir, ['init']);
-    const emptyTree = git(tmpDir, ['hash-object', '-t', 'tree', '/dev/null']);
-    const mainCommit = commitTree(tmpDir, emptyTree, 'initial');
-    git(tmpDir, ['update-ref', 'refs/heads/master', mainCommit]);
-
-    // Load SessionLog camelCase fixtures
-    const sessionMeta = await readFile(
-      join(FIXTURES, 'sessionlog-session', 'metadata.json'),
-      'utf-8',
-    );
-    const sessionTranscript = await readFile(
-      join(FIXTURES, 'sessionlog-session', 'full.jsonl'),
-      'utf-8',
-    );
-    const rootMeta = await readFile(
-      join(FIXTURES, 'sessionlog-root-metadata.json'),
-      'utf-8',
-    );
-
-    // Build orphan branch tree: c4/d5e6f7a8b9/1/{metadata.json, full.jsonl, ...}
-    const filler = hashObject(tmpDir, 'filler');
-    const metaHash = hashObject(tmpDir, sessionMeta);
-    const transHash = hashObject(tmpDir, sessionTranscript);
-    const rootMetaHash = hashObject(tmpDir, rootMeta);
-
-    const sessionTree = mktree(
-      tmpDir,
-      [
-        `100644 blob ${filler}\tcontext.md`,
-        `100644 blob ${transHash}\tfull.jsonl`,
-        `100644 blob ${metaHash}\tmetadata.json`,
-        `100644 blob ${filler}\tprompt.txt`,
-      ].join('\n') + '\n',
-    );
-
-    const checkpointTree = mktree(
-      tmpDir,
-      [
-        `040000 tree ${sessionTree}\t1`,
-        `100644 blob ${rootMetaHash}\tmetadata.json`,
-      ].join('\n') + '\n',
-    );
-
-    const shardTree = mktree(
-      tmpDir,
-      `040000 tree ${checkpointTree}\td5e6f7a8b9\n`,
-    );
-    const rootTree = mktree(tmpDir, `040000 tree ${shardTree}\tc4\n`);
-
-    const orphanCommit = commitTree(tmpDir, rootTree, 'sessionlog checkpoint');
-    git(tmpDir, [
-      'update-ref',
-      'refs/heads/sessionlog/checkpoints/v1',
-      orphanCommit,
-    ]);
-
-    // Init memory system
-    persistence = createSqlitePersistence({ baseDir: memoryDir });
-    await persistence.init();
-    memory = createMemorySystem(persistence, memoryDir);
-    await memory.init();
-  });
-
-  afterAll(async () => {
-    persistence?.close();
-    if (tmpDir) await rm(tmpDir, { recursive: true, force: true });
-    if (memoryDir) await rm(memoryDir, { recursive: true, force: true });
-  });
-
-  it('should discover SessionLog sessions using default branch', async () => {
-    const bank = new SessionBank({
-      repoPath: tmpDir,
-      stateDir: join(tmpDir, '.state-discover'),
-    });
-    await bank.init();
-
-    expect(bank.isAvailable()).toBe(true);
-    expect(bank.getBranch()).toBe('sessionlog/checkpoints/v1');
-
-    const sessions = await bank.discover();
-    expect(sessions).toHaveLength(1);
-    expect(sessions[0].sessionId).toBe(
-      '2026-02-15-aabbccdd-1122-3344-5566-778899aabbcc',
-    );
-    expect(sessions[0].checkpointId).toBe('c4d5e6f7a8b9');
-    expect(sessions[0].metadata.agent).toBe('Claude Code');
-    expect(sessions[0].metadata.branch).toBe('main');
-    expect(sessions[0].metadata.filesTouched).toEqual([
-      'src/api.ts',
-      'tests/api.test.ts',
-    ]);
-
-    await bank.close();
-  });
-
-  it('should parse camelCase metadata with summary and attribution', async () => {
-    const bank = new SessionBank({
-      repoPath: tmpDir,
-      stateDir: join(tmpDir, '.state-meta'),
-    });
-    await bank.init();
-
-    const sessions = await bank.discover();
-    const session = sessions[0];
-
-    // Summary
-    expect(session.summary).toBeDefined();
-    expect(session.summary!.intent).toBe(
-      'Add validation to the API endpoint',
-    );
-    expect(session.summary!.outcome).toContain('Zod schema');
-
-    // CodeLearning[] normalized to string[]
-    expect(session.summary!.learnings.codeFindings).toHaveLength(1);
-    expect(session.summary!.learnings.codeFindings[0]).toBe(
-      'src/api.ts:15 - Zod schema must be defined before route handler',
-    );
-    expect(session.summary!.learnings.repoPatterns).toEqual([
-      'API routes use Zod for validation',
-    ]);
-    expect(session.summary!.learnings.workflowPractices).toEqual([
-      'Run API tests with --reporter=verbose flag',
-    ]);
-    expect(session.summary!.frictionPoints).toEqual([
-      'Had to look up Zod coercion syntax',
-    ]);
-
-    // Attribution
-    expect(session.attribution).toBeDefined();
-    expect(session.attribution!.agentLinesAdded).toBe(30);
-    expect(session.attribution!.agentContribution).toBe(0.88);
-
-    // Token usage with subagentTokens → array
-    expect(session.tokenUsage.inputTokens).toBe(20000);
-    expect(session.tokenUsage.total).toBe(33000);
-    expect(session.tokenUsage.subagentUsage).toHaveLength(1);
-    expect(session.tokenUsage.subagentUsage![0].inputTokens).toBe(2000);
-
-    await bank.close();
-  });
-
-  it('should load and parse SessionLog transcript', async () => {
-    const bank = new SessionBank({
-      repoPath: tmpDir,
-      stateDir: join(tmpDir, '.state-query'),
-    });
-    await bank.init();
-
-    const result = await bank.query();
-    expect(result.sessions).toHaveLength(1);
-
-    const transcript = result.sessions[0].transcript;
-    expect(transcript.length).toBe(6);
-
-    // First message is user (SessionLog uses "user", not "human")
-    expect(transcript[0].role).toBe('user');
-    expect(transcript[0].content[0].type).toBe('text');
-
-    // Second message is assistant with text + tool_use
-    expect(transcript[1].role).toBe('assistant');
-    expect(transcript[1].content).toHaveLength(2);
-    expect(transcript[1].content[0].type).toBe('text');
-    expect(transcript[1].content[1].type).toBe('tool_use');
-
-    await bank.close();
-  });
-
-  it('should synthesize SessionLog session into a valid Trajectory', async () => {
-    const bank = new SessionBank({
-      repoPath: tmpDir,
-      stateDir: join(tmpDir, '.state-synth'),
-    });
-    await bank.init();
-
-    const source = new SessionTrajectorySource(bank);
-    const items = await source.load();
-    expect(items).toHaveLength(1);
-
-    const { trajectory } = items[0];
-
-    // Schema validation
-    const parsed = TrajectorySchema.safeParse(trajectory);
-    expect(parsed.success).toBe(true);
-
-    // ID and source
-    expect(trajectory.id).toContain('sessionlog-');
-    expect(trajectory.id).toContain('c4d5e6f7a8b9');
-    expect(trajectory.metadata.source).toBe('sessionlog');
-    expect(trajectory.agentId).toBe('Claude Code');
-
-    // Task from summary.intent
-    expect(trajectory.task.description).toBe(
-      'Add validation to the API endpoint',
-    );
-
-    // Steps from assistant tool_use blocks
-    expect(trajectory.steps.length).toBeGreaterThan(0);
-    const toolSteps = trajectory.steps.filter((s) =>
-      s.action.includes('Read') || s.action.includes('Edit'),
-    );
-    expect(toolSteps.length).toBeGreaterThan(0);
-
-    // Outcome inferred from summary
-    expect(trajectory.outcome.success).toBe(true);
-
-    // Token counts
-    expect(trajectory.totalTokens).toBe(33000);
-    expect(trajectory.llmCalls).toBe(10);
-
-    await bank.close();
-  });
-
-  it('should flow through LearningPipeline', async () => {
-    const bank = new SessionBank({
-      repoPath: tmpDir,
-      stateDir: join(tmpDir, '.state-pipeline'),
-    });
-    await bank.init();
-
-    const source = new SessionTrajectorySource(bank);
-    const items = await source.load();
-    const trajectory = items[0].trajectory;
-
-    // Process through unified learning pipeline
-    const pipeline = new UnifiedLearningPipeline(memory, {
-      batch: { learning: { minTrajectories: 100 }, energy: {} },
-    });
-    await pipeline.init();
-    const result = await pipeline.processTrajectory(trajectory);
-    expect(result.instantLoop.experienceId).toBeDefined();
-
-    // Mark processed and verify
-    await bank.markProcessed(
-      '2026-02-15-aabbccdd-1122-3344-5566-778899aabbcc',
-      { trajectoryId: trajectory.id },
-    );
-    expect(
-      bank.isProcessed('2026-02-15-aabbccdd-1122-3344-5566-778899aabbcc'),
-    ).toBe(true);
-
-    await bank.close();
-  });
-});

package/tests/integration/skill-tree-wiring.test.ts

@@ -1,152 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { createAtlas, type Atlas } from '../../src/atlas.js';
-import { mkdtemp, rm, access } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-describe('Skill-tree wiring in Atlas', () => {
-  let tempDir: string;
-  let atlas: Atlas;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'atlas-skilltree-'));
-  });
-
-  afterEach(async () => {
-    if (atlas) await atlas.close();
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  it('auto-wires skill-tree publisher by default', async () => {
-    atlas = createAtlas({
-      storage: { baseDir: tempDir },
-    });
-    await atlas.init();
-
-    // Skill library should have a publisher set
-    const skillLibrary = atlas.getSkillLibrary();
-    expect(skillLibrary).not.toBeNull();
-    expect(skillLibrary!.getPublisher()).not.toBeNull();
-
-    // Storage adapter should be accessible
-    const storage = atlas.getSkillTreeStorage();
-    expect(storage).not.toBeNull();
-  });
-
-  it('creates skills.db file in baseDir', async () => {
-    atlas = createAtlas({
-      storage: { baseDir: tempDir },
-    });
-    await atlas.init();
-
-    // Verify the database file was created
-    await expect(access(join(tempDir, 'skills.db'))).resolves.toBeUndefined();
-  });
-
-  it('can disable skill-tree wiring via config', async () => {
-    atlas = createAtlas({
-      storage: { baseDir: tempDir },
-      skillTree: { enabled: false },
-    });
-    await atlas.init();
-
-    const storage = atlas.getSkillTreeStorage();
-    expect(storage).toBeNull();
-  });
-
-  it('supports custom dbPath', async () => {
-    atlas = createAtlas({
-      storage: { baseDir: tempDir },
-      skillTree: { dbPath: 'custom-skills.db' },
-    });
-    await atlas.init();
-
-    await expect(access(join(tempDir, 'custom-skills.db'))).resolves.toBeUndefined();
-  });
-
-  it('publishes promoted playbooks to skill-tree storage', async () => {
-    atlas = createAtlas({
-      storage: { baseDir: tempDir },
-      skillLibrary: {
-        promotion: {
-          minConfidence: 0.5,
-          minSuccessCount: 2,
-          minSuccessRate: 0.5,
-        },
-      },
-    });
-    await atlas.init();
-
-    // Add a playbook that meets promotion criteria
-    const playbooks = atlas.getMemory().playbooks;
-    if (playbooks) {
-      const now = new Date();
-      await playbooks.add({
-        id: 'pb-promoted',
-        name: 'test-promotion',
-        applicability: {
-          situations: ['Test scenario'],
-          triggers: ['test-trigger'],
-          antiPatterns: [],
-          domains: ['test'],
-        },
-        guidance: {
-          strategy: 'Run the test',
-          tactics: ['Step 1'],
-          steps: [],
-        },
-        verification: {
-          successIndicators: ['Tests pass'],
-          failureIndicators: [],
-        },
-        evolution: {
-          version: '1.0.0',
-          createdFrom: ['session-1'],
-          failures: [],
-          refinements: [],
-          successCount: 10,
-          failureCount: 1,
-          lastUsed: now,
-        },
-        confidence: 0.9,
-        complexity: 'simple',
-        estimatedEffort: 1,
-        createdAt: now,
-        updatedAt: now,
-      });
-
-      // Refresh tiers — should trigger publication
-      const skillLibrary = atlas.getSkillLibrary()!;
-      const result = await skillLibrary.refreshTiers();
-      expect(result.promoted).toContain('pb-promoted');
-
-      // Verify the skill was published to storage
-      const storage = atlas.getSkillTreeStorage()!;
-      const skill = await storage.getSkill('pb-promoted');
-      expect(skill).not.toBeNull();
-      expect(skill!.name).toBe('test-promotion');
-      expect(skill!.status).toBe('active');
-    }
-  });
-
-  it('closes skill-tree storage on atlas.close()', async () => {
-    atlas = createAtlas({
-      storage: { baseDir: tempDir },
-    });
-    await atlas.init();
-
-    const storage = atlas.getSkillTreeStorage();
-    expect(storage).not.toBeNull();
-
-    await atlas.close();
-
-    // After close, the storage reference should exist but DB is closed
-    // Creating a new atlas on the same dir should work fine
-    const atlas2 = createAtlas({
-      storage: { baseDir: tempDir },
-    });
-    await atlas2.init();
-    expect(atlas2.getSkillTreeStorage()).not.toBeNull();
-    await atlas2.close();
-  });
-});