cognitive-core 0.1.0 → 0.2.0

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

@@ -0,0 +1,232 @@
+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 { CheckpointGitReader } from '../../src/session-bank/git-reader.js';
+
+const FIXTURES = join(import.meta.dirname, '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();
+}
+
+/**
+ * Create a temp git repo with an Entire-style orphan branch containing
+ * fixture data at checkpoint path a3/b2c4d5e6f7 with session 0.
+ */
+async function createFixtureRepo(): Promise<string> {
+  const tmpDir = await mkdtemp(join(tmpdir(), 'git-reader-test-'));
+
+  // Initialize bare-minimum repo with an empty initial commit
+  git(tmpDir, ['init']);
+  // Create an empty tree for the initial commit
+  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 fixture files
+  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 = await readFile(
+    join(FIXTURES, 'root-metadata.json'),
+    'utf-8',
+  );
+
+  // Create blobs
+  const rootMetaHash = hashObject(tmpDir, rootMeta);
+  const sessionMetaHash = hashObject(tmpDir, simpleMeta);
+  const transcriptHash = hashObject(tmpDir, simpleTranscript);
+  const promptHash = hashObject(tmpDir, 'Fix the bug in auth.ts');
+  const contextHash = hashObject(tmpDir, '# Context\nAuth module');
+  const contentHashHash = hashObject(tmpDir, 'abc123hash');
+
+  // Build trees bottom-up
+  // Session 0 tree
+  const session0Tree = mktree(
+    tmpDir,
+    [
+      `100644 blob ${contentHashHash}\tcontent_hash.txt`,
+      `100644 blob ${contextHash}\tcontext.md`,
+      `100644 blob ${transcriptHash}\tfull.jsonl`,
+      `100644 blob ${sessionMetaHash}\tmetadata.json`,
+      `100644 blob ${promptHash}\tprompt.txt`,
+    ].join('\n') + '\n',
+  );
+
+  // Checkpoint tree: metadata.json + 0/
+  const checkpointTree = mktree(
+    tmpDir,
+    [
+      `040000 tree ${session0Tree}\t0`,
+      `100644 blob ${rootMetaHash}\tmetadata.json`,
+    ].join('\n') + '\n',
+  );
+
+  // Shard tree: b2c4d5e6f7/
+  const shardTree = mktree(
+    tmpDir,
+    `040000 tree ${checkpointTree}\tb2c4d5e6f7\n`,
+  );
+
+  // Root tree: a3/
+  const rootTree = mktree(tmpDir, `040000 tree ${shardTree}\ta3\n`);
+
+  // Create commit on orphan branch (no parent)
+  const orphanCommit = commitTree(tmpDir, rootTree, 'checkpoint data');
+  git(tmpDir, [
+    'update-ref',
+    'refs/heads/sessionlog/checkpoints/v1',
+    orphanCommit,
+  ]);
+
+  return tmpDir;
+}
+
+describe('CheckpointGitReader', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await createFixtureRepo();
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should detect that the orphan branch exists', async () => {
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
+    expect(await reader.branchExists()).toBe(true);
+  });
+
+  it('should return false for non-existent branch', async () => {
+    const reader = new CheckpointGitReader({
+      repoPath: tmpDir,
+      branch: 'nonexistent/branch',
+    });
+    expect(await reader.branchExists()).toBe(false);
+  });
+
+  it('should list checkpoint paths', async () => {
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
+    const checkpoints = await reader.listCheckpoints();
+
+    expect(checkpoints).toHaveLength(1);
+    expect(checkpoints[0]).toBe('a3/b2c4d5e6f7');
+  });
+
+  it('should list session indices', async () => {
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
+    const sessions = await reader.listSessions('a3/b2c4d5e6f7');
+
+    expect(sessions).toHaveLength(1);
+    expect(sessions[0]).toBe('0');
+  });
+
+  it('should read a file from the orphan branch', async () => {
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
+    const content = await reader.readFile(
+      'a3/b2c4d5e6f7/0/metadata.json',
+    );
+
+    const meta = JSON.parse(content);
+    expect(meta.checkpoint_id).toBe('a3b2c4d5e6f7');
+    expect(meta.session_id).toContain('2026-01-08');
+  });
+
+  it('should batch-read multiple files', async () => {
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
+    const files = await reader.readFiles([
+      'a3/b2c4d5e6f7/0/metadata.json',
+      'a3/b2c4d5e6f7/0/full.jsonl',
+      'a3/b2c4d5e6f7/0/nonexistent.txt',
+    ]);
+
+    expect(files.size).toBe(2);
+    expect(files.has('a3/b2c4d5e6f7/0/metadata.json')).toBe(true);
+    expect(files.has('a3/b2c4d5e6f7/0/full.jsonl')).toBe(true);
+    expect(files.has('a3/b2c4d5e6f7/0/nonexistent.txt')).toBe(false);
+  });
+
+  it('should return null for missing files', async () => {
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
+    const content = await reader.readFileOrNull('does/not/exist');
+    expect(content).toBeNull();
+  });
+
+  it('should get the orphan branch HEAD SHA', async () => {
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
+    const sha = await reader.getBranchHead();
+
+    expect(sha).toBeDefined();
+    expect(sha).toMatch(/^[0-9a-f]{40}$/);
+  });
+
+  it('should return null for HEAD of non-existent branch', async () => {
+    const reader = new CheckpointGitReader({
+      repoPath: tmpDir,
+      branch: 'nope',
+    });
+    const sha = await reader.getBranchHead();
+    expect(sha).toBeNull();
+  });
+
+  it('should return empty checkpoints for non-existent branch', async () => {
+    const reader = new CheckpointGitReader({
+      repoPath: tmpDir,
+      branch: 'nope',
+    });
+    const checkpoints = await reader.listCheckpoints();
+    expect(checkpoints).toEqual([]);
+  });
+});

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

@@ -0,0 +1,453 @@
+import { describe, it, expect } from 'vitest';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { CheckpointParser, detectFormat } from '../../src/session-bank/parser.js';
+
+const FIXTURES = join(import.meta.dirname, 'fixtures');
+
+async function loadFixture(
+  ...segments: string[]
+): Promise<string> {
+  return readFile(join(FIXTURES, ...segments), 'utf-8');
+}
+
+describe('CheckpointParser', () => {
+  const parser = new CheckpointParser();
+
+  // ──────────────────────────────────────────────────────────────
+  // parseMetadata
+  // ──────────────────────────────────────────────────────────────
+
+  describe('parseMetadata', () => {
+    it('should parse session metadata with summary', async () => {
+      const json = await loadFixture('simple-session', 'metadata.json');
+      const result = parser.parseMetadata(json);
+
+      expect(result.sessionId).toBe(
+        '2026-01-08-abc123de-f456-7890-abcd-ef1234567890',
+      );
+      expect(result.checkpointId).toBe('a3b2c4d5e6f7');
+      expect(result.metadata.cliVersion).toBe('0.3.0');
+      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/auth.ts',
+        'src/middleware.ts',
+      ]);
+      expect(result.metadata.isTask).toBe(false);
+      expect(result.metadata.checkpointTranscriptStart).toBe(0);
+    });
+
+    it('should parse the summary fields', async () => {
+      const json = await loadFixture('simple-session', 'metadata.json');
+      const result = parser.parseMetadata(json);
+
+      expect(result.summary).toBeDefined();
+      expect(result.summary!.intent).toBe(
+        'Fix the authentication token refresh bug in the middleware',
+      );
+      expect(result.summary!.outcome).toContain('Successfully fixed');
+      expect(result.summary!.learnings.repoPatterns).toHaveLength(1);
+      expect(result.summary!.learnings.codeFindings).toHaveLength(1);
+      expect(result.summary!.learnings.workflowPractices).toHaveLength(1);
+      expect(result.summary!.frictionPoints).toHaveLength(1);
+      expect(result.summary!.openItems).toHaveLength(1);
+    });
+
+    it('should parse token usage with computed total', async () => {
+      const json = await loadFixture('simple-session', 'metadata.json');
+      const result = parser.parseMetadata(json);
+
+      expect(result.tokenUsage.inputTokens).toBe(15000);
+      expect(result.tokenUsage.cacheCreationTokens).toBe(2000);
+      expect(result.tokenUsage.cacheReadTokens).toBe(5000);
+      expect(result.tokenUsage.outputTokens).toBe(3000);
+      expect(result.tokenUsage.apiCallCount).toBe(8);
+      expect(result.tokenUsage.total).toBe(15000 + 2000 + 5000 + 3000);
+    });
+
+    it('should parse attribution', async () => {
+      const json = await loadFixture('simple-session', 'metadata.json');
+      const result = parser.parseMetadata(json);
+
+      expect(result.attribution).toBeDefined();
+      expect(result.attribution!.agentLinesAdded).toBe(25);
+      expect(result.attribution!.humanAdditions).toBe(2);
+      expect(result.attribution!.humanModifications).toBe(1);
+      expect(result.attribution!.humanRemovals).toBe(0);
+      expect(result.attribution!.totalCommittedLines).toBe(28);
+      expect(result.attribution!.agentContribution).toBe(0.89);
+    });
+
+    it('should handle metadata without summary', async () => {
+      const json = await loadFixture('multi-tool-session', 'metadata.json');
+      const result = parser.parseMetadata(json);
+
+      expect(result.summary).toBeUndefined();
+      expect(result.sessionId).toBe(
+        '2026-01-09-def456ab-c789-0123-def4-567890abcdef',
+      );
+      expect(result.metadata.strategy).toBe('auto-commit');
+      expect(result.metadata.branch).toBe('feature/add-tests');
+    });
+
+    it('should parse subagent token usage', async () => {
+      const json = await loadFixture('multi-tool-session', 'metadata.json');
+      const result = parser.parseMetadata(json);
+
+      expect(result.tokenUsage.subagentUsage).toBeDefined();
+      expect(result.tokenUsage.subagentUsage).toHaveLength(1);
+      expect(result.tokenUsage.subagentUsage![0].inputTokens).toBe(3000);
+      expect(result.tokenUsage.subagentUsage![0].outputTokens).toBe(1200);
+      expect(result.tokenUsage.subagentUsage![0].total).toBe(3000 + 1200);
+    });
+
+    it('should default missing fields', () => {
+      const result = parser.parseMetadata('{}');
+
+      expect(result.sessionId).toBe('');
+      expect(result.checkpointId).toBe('');
+      expect(result.metadata.cliVersion).toBe('');
+      expect(result.metadata.strategy).toBe('manual-commit');
+      expect(result.metadata.filesTouched).toEqual([]);
+      expect(result.tokenUsage.total).toBe(0);
+      expect(result.summary).toBeUndefined();
+      expect(result.attribution).toBeUndefined();
+    });
+  });
+
+  // ──────────────────────────────────────────────────────────────
+  // parseTranscript
+  // ──────────────────────────────────────────────────────────────
+
+  describe('parseTranscript', () => {
+    it('should parse simple session transcript', async () => {
+      const jsonl = await loadFixture('simple-session', 'full.jsonl');
+      const messages = parser.parseTranscript(jsonl);
+
+      expect(messages).toHaveLength(6);
+
+      // First message: user text (string content)
+      expect(messages[0].role).toBe('user');
+      expect(messages[0].uuid).toBe('msg-001');
+      expect(messages[0].content).toHaveLength(1);
+      expect(messages[0].content[0].type).toBe('text');
+      expect((messages[0].content[0] as { text: string }).text).toContain(
+        'Fix the bug',
+      );
+      expect(messages[0].lineIndex).toBe(0);
+    });
+
+    it('should parse assistant text + tool_use blocks', async () => {
+      const jsonl = await loadFixture('simple-session', 'full.jsonl');
+      const messages = parser.parseTranscript(jsonl);
+
+      // Second message: assistant with text + tool_use
+      const msg = messages[1];
+      expect(msg.role).toBe('assistant');
+      expect(msg.content).toHaveLength(2);
+      expect(msg.content[0].type).toBe('text');
+      expect(msg.content[1].type).toBe('tool_use');
+
+      const toolBlock = msg.content[1] as {
+        type: 'tool_use';
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+      };
+      expect(toolBlock.name).toBe('Read');
+      expect(toolBlock.id).toBe('tool-001');
+      expect(toolBlock.input.file_path).toBe('/src/auth.ts');
+    });
+
+    it('should parse tool_result blocks from user messages', async () => {
+      const jsonl = await loadFixture('simple-session', 'full.jsonl');
+      const messages = parser.parseTranscript(jsonl);
+
+      // Third message: user with tool_result
+      const msg = messages[2];
+      expect(msg.role).toBe('user');
+      expect(msg.content).toHaveLength(1);
+      expect(msg.content[0].type).toBe('tool_result');
+
+      const resultBlock = msg.content[0] as {
+        type: 'tool_result';
+        toolUseId: string;
+        content: string;
+      };
+      expect(resultBlock.toolUseId).toBe('tool-001');
+      expect(resultBlock.content).toContain('refreshToken');
+    });
+
+    it('should parse multi-tool session with parallel tool calls', async () => {
+      const jsonl = await loadFixture('multi-tool-session', 'full.jsonl');
+      const messages = parser.parseTranscript(jsonl);
+
+      // msg-110 has two parallel tool_use blocks (Read + Bash)
+      const parallelMsg = messages.find((m) => m.uuid === 'msg-110');
+      expect(parallelMsg).toBeDefined();
+      expect(parallelMsg!.content).toHaveLength(3); // text + 2 tool_use
+
+      const toolCalls = parallelMsg!.content.filter(
+        (b) => b.type === 'tool_use',
+      );
+      expect(toolCalls).toHaveLength(2);
+    });
+
+    it('should handle user messages with string content', () => {
+      const jsonl =
+        '{"type":"user","uuid":"u1","message":{"content":"hello world"}}';
+      const messages = parser.parseTranscript(jsonl);
+
+      expect(messages).toHaveLength(1);
+      expect(messages[0].content).toHaveLength(1);
+      expect(messages[0].content[0].type).toBe('text');
+      expect((messages[0].content[0] as { text: string }).text).toBe(
+        'hello world',
+      );
+    });
+
+    it('should skip malformed JSONL lines gracefully', () => {
+      const jsonl = [
+        '{"type":"user","uuid":"u1","message":{"content":"valid"}}',
+        'this is not valid json',
+        '',
+        '{"type":"assistant","uuid":"a1","message":{"content":[{"type":"text","text":"ok"}]}}',
+      ].join('\n');
+
+      const messages = parser.parseTranscript(jsonl);
+      expect(messages).toHaveLength(2);
+      expect(messages[0].uuid).toBe('u1');
+      expect(messages[1].uuid).toBe('a1');
+    });
+
+    it('should skip lines with unknown roles', () => {
+      const jsonl =
+        '{"type":"system","uuid":"s1","message":{"content":"hidden"}}';
+      const messages = parser.parseTranscript(jsonl);
+      expect(messages).toHaveLength(0);
+    });
+
+    it('should track lineIndex for each message', async () => {
+      const jsonl = await loadFixture('simple-session', 'full.jsonl');
+      const messages = parser.parseTranscript(jsonl);
+
+      expect(messages[0].lineIndex).toBe(0);
+      expect(messages[1].lineIndex).toBe(1);
+      expect(messages[2].lineIndex).toBe(2);
+      expect(messages[3].lineIndex).toBe(3);
+    });
+
+    it('should handle empty content gracefully', () => {
+      const jsonl = '{"type":"user","uuid":"u1","message":{}}';
+      const messages = parser.parseTranscript(jsonl);
+
+      expect(messages).toHaveLength(1);
+      expect(messages[0].content).toEqual([]);
+    });
+  });
+
+  // ──────────────────────────────────────────────────────────────
+  // parseChunkedTranscript
+  // ──────────────────────────────────────────────────────────────
+
+  describe('parseChunkedTranscript', () => {
+    it('should concatenate and parse multiple chunks', () => {
+      const chunk1 =
+        '{"type":"user","uuid":"u1","message":{"content":"chunk one"}}';
+      const chunk2 =
+        '{"type":"assistant","uuid":"a1","message":{"content":[{"type":"text","text":"chunk two"}]}}';
+
+      const messages = parser.parseChunkedTranscript([chunk1, chunk2]);
+      expect(messages).toHaveLength(2);
+      expect(messages[0].uuid).toBe('u1');
+      expect(messages[1].uuid).toBe('a1');
+    });
+  });
+
+  // ──────────────────────────────────────────────────────────────
+  // parseCheckpointSummary
+  // ──────────────────────────────────────────────────────────────
+
+  describe('parseCheckpointSummary', () => {
+    it('should parse root metadata.json', async () => {
+      const json = await loadFixture('root-metadata.json');
+      const ref = parser.parseCheckpointSummary(json, 'a3/b2c4d5e6f7');
+
+      expect(ref.checkpointId).toBe('a3b2c4d5e6f7');
+      expect(ref.path).toBe('a3/b2c4d5e6f7');
+      expect(ref.sessionCount).toBe(2);
+    });
+  });
+
+  // ──────────────────────────────────────────────────────────────
+  // parseSession (full integration)
+  // ──────────────────────────────────────────────────────────────
+
+  describe('parseSession', () => {
+    it('should produce a complete SessionRecord', async () => {
+      const metadataJson = await loadFixture(
+        'simple-session',
+        'metadata.json',
+      );
+      const transcriptJsonl = await loadFixture(
+        'simple-session',
+        'full.jsonl',
+      );
+
+      const session = parser.parseSession(
+        metadataJson,
+        transcriptJsonl,
+        'a3/b2c4d5e6f7',
+        '0',
+      );
+
+      expect(session.sessionId).toBe(
+        '2026-01-08-abc123de-f456-7890-abcd-ef1234567890',
+      );
+      expect(session.checkpointId).toBe('a3b2c4d5e6f7');
+      expect(session.metadata.agent).toBe('Claude Code');
+      expect(session.transcript).toHaveLength(6);
+      expect(session.summary).toBeDefined();
+      expect(session.summary!.intent).toContain('authentication token');
+      expect(session.tokenUsage.total).toBeGreaterThan(0);
+      expect(session.attribution).toBeDefined();
+      expect(session.source.checkpointPath).toBe('a3/b2c4d5e6f7');
+      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);
+    });
+  });
+});