cognitive-core 0.2.4 → 0.3.1

package/tests/learning/huggingface-trajectory-source.test.ts

@@ -1,817 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { HuggingFaceTrajectorySource } from '../../src/learning/trajectory-sources/huggingface.js';
-import { TrajectorySchema } from '../../src/types/trajectory.js';
-import type { DataclawSession } from '../../src/types/dataclaw.js';
-
-// ── Realistic dataclaw sessions (matching real HF dataset schema) ──
-
-function claudeSession(): DataclawSession {
-  return {
-    session_id: 'abc-def-001',
-    project: 'my-web-app',
-    model: 'claude-opus-4-6',
-    source: 'claude',
-    git_branch: 'fix/auth-bug',
-    start_time: '2026-02-01T09:00:00+00:00',
-    end_time: '2026-02-01T09:25:00+00:00',
-    messages: [
-      {
-        role: 'user',
-        content: 'The login endpoint returns 500 when the user has no email.',
-        timestamp: '2026-02-01T09:00:05+00:00',
-      },
-      {
-        role: 'assistant',
-        content: "Let me look at the login handler.",
-        thinking: 'Likely a null reference on user.email.',
-        tool_uses: [
-          {
-            tool: 'Read',
-            input: { file_path: '/src/routes/auth.ts' },
-            output: { text: 'const email = user.email.toLowerCase();' },
-            status: 'success',
-          },
-        ],
-        timestamp: '2026-02-01T09:00:15+00:00',
-      },
-      {
-        role: 'assistant',
-        content: "Found it — adding optional chaining.",
-        tool_uses: [
-          {
-            tool: 'Edit',
-            input: {
-              file_path: '/src/routes/auth.ts',
-              old_string: 'user.email.toLowerCase()',
-              new_string: 'user.email?.toLowerCase() ?? ""',
-            },
-            output: { text: 'File edited successfully' },
-            status: 'success',
-          },
-        ],
-        timestamp: '2026-02-01T09:01:00+00:00',
-      },
-      {
-        role: 'assistant',
-        content: 'Fix applied. The login handler now handles null emails.',
-        timestamp: '2026-02-01T09:02:30+00:00',
-      },
-    ],
-    stats: {
-      user_messages: 1,
-      assistant_messages: 3,
-      tool_uses: 2,
-      input_tokens: 12000,
-      output_tokens: 2500,
-    },
-  };
-}
-
-function codexSession(): DataclawSession {
-  return {
-    session_id: 'codex-042',
-    project: 'ml-pipeline',
-    model: 'gpt-5.3-codex',
-    source: 'codex',
-    git_branch: 'feature/data-loader',
-    start_time: '2026-02-10T14:00:00+00:00',
-    end_time: '2026-02-10T14:45:00+00:00',
-    messages: [
-      {
-        role: 'user',
-        content: 'Add a CSV data loader to the pipeline',
-        timestamp: '2026-02-10T14:00:00+00:00',
-      },
-      {
-        role: 'assistant',
-        content: 'Creating the CSV loader.',
-        tool_uses: [
-          {
-            tool: 'write_file',
-            input: { file_path: 'src/pipeline/csv_loader.py', content: 'import pandas as pd' },
-            output: {},
-            status: 'success',
-          },
-        ],
-        timestamp: '2026-02-10T14:05:00+00:00',
-      },
-      {
-        role: 'assistant',
-        content: 'Done. CSV loader is ready.',
-        timestamp: '2026-02-10T14:11:00+00:00',
-      },
-    ],
-    stats: {
-      user_messages: 1,
-      assistant_messages: 2,
-      tool_uses: 1,
-      input_tokens: 8000,
-      output_tokens: 2000,
-    },
-  };
-}
-
-function failedSession(): DataclawSession {
-  return {
-    session_id: 'failed-007',
-    project: 'my-web-app',
-    model: 'claude-opus-4-6',
-    source: 'claude',
-    git_branch: 'main',
-    start_time: '2026-02-05T16:00:00+00:00',
-    end_time: '2026-02-05T16:10:00+00:00',
-    messages: [
-      {
-        role: 'user',
-        content: 'Deploy the app to production',
-        timestamp: '2026-02-05T16:00:00+00:00',
-      },
-      {
-        role: 'assistant',
-        content: 'Attempting deployment.',
-        tool_uses: [
-          {
-            tool: 'bash',
-            input: { command: 'npm run deploy' },
-            output: { text: 'Error: Missing DEPLOY_TOKEN' },
-            status: 'error',
-          },
-        ],
-        timestamp: '2026-02-05T16:01:00+00:00',
-      },
-      {
-        role: 'assistant',
-        content: 'I was unable to deploy. Missing DEPLOY_TOKEN.',
-        timestamp: '2026-02-05T16:03:00+00:00',
-      },
-    ],
-    stats: {
-      user_messages: 1,
-      assistant_messages: 2,
-      tool_uses: 1,
-      input_tokens: 5000,
-      output_tokens: 1000,
-    },
-  };
-}
-
-// ── Mock helpers ──
-
-type FetchFn = typeof globalThis.fetch;
-
-/** Wraps sessions into an HF datasets-server /rows response */
-function makeRowsResponse(
-  sessions: DataclawSession[],
-  totalRows: number,
-  offset = 0,
-) {
-  return {
-    features: [],
-    rows: sessions.map((s, i) => ({ row_idx: offset + i, row: s })),
-    num_rows_total: totalRows,
-    num_rows_per_page: 100,
-    partial: false,
-  };
-}
-
-/** Wraps a row count into an HF datasets-server /info response */
-function makeInfoResponse(numRows: number, config = 'default') {
-  return {
-    dataset_info: {
-      [config]: {
-        num_rows: numRows,
-        dataset_name: 'test-dataset',
-      },
-    },
-  };
-}
-
-/** Creates a mock fetch that returns controlled responses */
-function createMockFetch(
-  sessions: DataclawSession[],
-  opts?: { pageSize?: number; failOnPage?: number; infoFails?: boolean },
-): FetchFn {
-  const pageSize = opts?.pageSize ?? 100;
-
-  return vi.fn(async (input: RequestInfo | URL, _init?: RequestInit) => {
-    const url = typeof input === 'string' ? input : input.toString();
-
-    // /info endpoint
-    if (url.includes('/info')) {
-      if (opts?.infoFails) {
-        return new Response('Internal Server Error', { status: 500 });
-      }
-      return new Response(
-        JSON.stringify(makeInfoResponse(sessions.length)),
-        { status: 200, headers: { 'Content-Type': 'application/json' } },
-      );
-    }
-
-    // /rows endpoint
-    if (url.includes('/rows')) {
-      const parsed = new URL(url);
-      const offset = parseInt(parsed.searchParams.get('offset') ?? '0', 10);
-      const length = parseInt(parsed.searchParams.get('length') ?? String(pageSize), 10);
-
-      // Simulate page failure
-      if (opts?.failOnPage !== undefined) {
-        const pageNum = Math.floor(offset / length);
-        if (pageNum === opts.failOnPage) {
-          return new Response('Internal Server Error', { status: 500 });
-        }
-      }
-
-      const page = sessions.slice(offset, offset + length);
-      return new Response(
-        JSON.stringify(makeRowsResponse(page, sessions.length, offset)),
-        { status: 200, headers: { 'Content-Type': 'application/json' } },
-      );
-    }
-
-    return new Response('Not Found', { status: 404 });
-  }) as unknown as FetchFn;
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-describe('HuggingFaceTrajectorySource', () => {
-  describe('basic loading', () => {
-    it('should have name "huggingface"', () => {
-      const mockFetch = createMockFetch([]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      expect(source.name).toBe('huggingface');
-    });
-
-    it('should load sessions from a single-page dataset', async () => {
-      const sessions = [claudeSession(), codexSession()];
-      const mockFetch = createMockFetch(sessions);
-
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      expect(items).toHaveLength(2);
-    });
-
-    it('should produce valid Trajectory objects', async () => {
-      const sessions = [claudeSession(), codexSession(), failedSession()];
-      const mockFetch = createMockFetch(sessions);
-
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      for (const { trajectory } of items) {
-        const parsed = TrajectorySchema.safeParse(trajectory);
-        expect(parsed.success, `Invalid trajectory: ${trajectory.id}`).toBe(true);
-      }
-    });
-
-    it('should synthesize trajectories with correct IDs', async () => {
-      const sessions = [claudeSession(), codexSession()];
-      const mockFetch = createMockFetch(sessions);
-
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      expect(items[0].trajectory.id).toBe('dataclaw-claude-abc-def-001');
-      expect(items[1].trajectory.id).toBe('dataclaw-codex-codex-042');
-    });
-
-    it('should set analysis to undefined (not pre-computed)', async () => {
-      const mockFetch = createMockFetch([claudeSession()]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      expect(items[0].analysis).toBeUndefined();
-    });
-  });
-
-  describe('pagination', () => {
-    it('should paginate through large datasets', async () => {
-      // Create 5 sessions but use pageSize=2 to force 3 pages
-      const sessions = Array.from({ length: 5 }, (_, i) =>
-        claudeSession(),
-      ).map((s, i) => ({ ...s, session_id: `sess-${i}` })) as DataclawSession[];
-
-      const mockFetch = createMockFetch(sessions, { pageSize: 2 });
-
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-        pageSize: 2,
-      });
-      const items = await source.load();
-
-      expect(items).toHaveLength(5);
-      // Should have made 3 fetch calls (2+2+1 rows)
-      expect(mockFetch).toHaveBeenCalledTimes(3);
-    });
-
-    it('should handle empty dataset', async () => {
-      const mockFetch = createMockFetch([]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      expect(items).toHaveLength(0);
-    });
-
-    it('should pass correct query parameters', async () => {
-      const mockFetch = createMockFetch([claudeSession()]);
-      const source = new HuggingFaceTrajectorySource(
-        'peteromallet/dataclaw-peteromallet',
-        {
-          fetchFn: mockFetch,
-          config: 'my-config',
-          split: 'test',
-          pageSize: 50,
-        },
-      );
-      await source.load();
-
-      const callUrl = (mockFetch as ReturnType<typeof vi.fn>).mock.calls[0][0] as string;
-      expect(callUrl).toContain('dataset=peteromallet%2Fdataclaw-peteromallet');
-      expect(callUrl).toContain('config=my-config');
-      expect(callUrl).toContain('split=test');
-      expect(callUrl).toContain('length=50');
-    });
-  });
-
-  describe('authentication', () => {
-    it('should include Authorization header when token is provided', async () => {
-      const mockFetch = createMockFetch([claudeSession()]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-        token: 'hf_test_token_123',
-      });
-      await source.load();
-
-      const callInit = (mockFetch as ReturnType<typeof vi.fn>).mock.calls[0][1] as RequestInit;
-      expect((callInit.headers as Record<string, string>)['Authorization']).toBe(
-        'Bearer hf_test_token_123',
-      );
-    });
-
-    it('should not include Authorization header when no token', async () => {
-      // Clear env vars for this test
-      const origHf = process.env.HF_TOKEN;
-      const origHub = process.env.HUGGING_FACE_HUB_TOKEN;
-      delete process.env.HF_TOKEN;
-      delete process.env.HUGGING_FACE_HUB_TOKEN;
-
-      try {
-        const mockFetch = createMockFetch([claudeSession()]);
-        const source = new HuggingFaceTrajectorySource('user/dataset', {
-          fetchFn: mockFetch,
-        });
-        await source.load();
-
-        const callInit = (mockFetch as ReturnType<typeof vi.fn>).mock.calls[0][1] as RequestInit;
-        expect((callInit.headers as Record<string, string>)['Authorization']).toBeUndefined();
-      } finally {
-        if (origHf !== undefined) process.env.HF_TOKEN = origHf;
-        if (origHub !== undefined) process.env.HUGGING_FACE_HUB_TOKEN = origHub;
-      }
-    });
-
-    it('should pick up HF_TOKEN from environment', async () => {
-      const origHf = process.env.HF_TOKEN;
-      process.env.HF_TOKEN = 'hf_env_token';
-
-      try {
-        const mockFetch = createMockFetch([claudeSession()]);
-        const source = new HuggingFaceTrajectorySource('user/dataset', {
-          fetchFn: mockFetch,
-        });
-        await source.load();
-
-        const callInit = (mockFetch as ReturnType<typeof vi.fn>).mock.calls[0][1] as RequestInit;
-        expect((callInit.headers as Record<string, string>)['Authorization']).toBe(
-          'Bearer hf_env_token',
-        );
-      } finally {
-        if (origHf !== undefined) process.env.HF_TOKEN = origHf;
-        else delete process.env.HF_TOKEN;
-      }
-    });
-  });
-
-  describe('filtering', () => {
-    let allSessions: DataclawSession[];
-
-    beforeEach(() => {
-      allSessions = [claudeSession(), codexSession(), failedSession()];
-    });
-
-    it('should filter by dataclaw source', async () => {
-      const mockFetch = createMockFetch(allSessions);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-        sources: ['codex'],
-      });
-      const items = await source.load();
-
-      expect(items).toHaveLength(1);
-      expect(items[0].trajectory.metadata.dataclawSource).toBe('codex');
-    });
-
-    it('should filter by model', async () => {
-      const mockFetch = createMockFetch(allSessions);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-        models: ['claude-opus-4-6'],
-      });
-      const items = await source.load();
-
-      // claude + failed sessions both use claude-opus-4-6
-      expect(items).toHaveLength(2);
-    });
-
-    it('should filter by domain (load option)', async () => {
-      const mockFetch = createMockFetch(allSessions);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load({ domain: 'python' });
-
-      expect(items).toHaveLength(1);
-      expect(items[0].trajectory.task.domain).toBe('python');
-    });
-
-    it('should filter by successOnly', async () => {
-      const mockFetch = createMockFetch(allSessions);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load({ successOnly: true });
-
-      for (const { trajectory } of items) {
-        expect(trajectory.outcome.success).toBe(true);
-      }
-    });
-
-    it('should filter by since date', async () => {
-      const mockFetch = createMockFetch(allSessions);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load({
-        since: new Date('2026-02-08T00:00:00Z'),
-      });
-
-      // Only codex session (Feb 10) — failed is Feb 5, claude is Feb 1
-      expect(items).toHaveLength(1);
-      expect(items[0].trajectory.id).toContain('codex');
-    });
-
-    it('should respect limit', async () => {
-      const mockFetch = createMockFetch(allSessions);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load({ limit: 1 });
-
-      expect(items).toHaveLength(1);
-    });
-
-    it('should combine source filter + successOnly', async () => {
-      const mockFetch = createMockFetch(allSessions);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-        sources: ['claude'],
-      });
-      const items = await source.load({ successOnly: true });
-
-      // claude session is success, failed session is filtered out
-      expect(items).toHaveLength(1);
-      expect(items[0].trajectory.id).toContain('abc-def-001');
-    });
-  });
-
-  describe('count', () => {
-    it('should use /info endpoint for fast unfiltered count', async () => {
-      const sessions = [claudeSession(), codexSession()];
-      const mockFetch = createMockFetch(sessions);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-
-      const count = await source.count();
-      expect(count).toBe(2);
-
-      // Should have called /info, not /rows
-      const calls = (mockFetch as ReturnType<typeof vi.fn>).mock.calls;
-      expect(calls).toHaveLength(1);
-      expect(calls[0][0]).toContain('/info');
-    });
-
-    it('should fall back to loading when /info fails', async () => {
-      const sessions = [claudeSession(), codexSession()];
-      const mockFetch = createMockFetch(sessions, { infoFails: true });
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-
-      const count = await source.count();
-      expect(count).toBe(2);
-    });
-
-    it('should load and filter when count has filters', async () => {
-      const sessions = [claudeSession(), codexSession(), failedSession()];
-      const mockFetch = createMockFetch(sessions);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-
-      const count = await source.count({ successOnly: true });
-      // Should have loaded all sessions and filtered
-      expect(count).toBe(2); // claude + codex succeed, failed does not
-    });
-
-    it('should use load for count when dataclaw source filter is set', async () => {
-      const sessions = [claudeSession(), codexSession()];
-      const mockFetch = createMockFetch(sessions);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-        sources: ['claude'],
-      });
-
-      const count = await source.count();
-      expect(count).toBe(1);
-
-      // Should have called /rows (not /info) because source filter is set
-      const calls = (mockFetch as ReturnType<typeof vi.fn>).mock.calls;
-      expect(calls.some((c: unknown[]) => (c[0] as string).includes('/rows'))).toBe(true);
-    });
-  });
-
-  describe('trajectory synthesis quality', () => {
-    it('should extract task description from first user message', async () => {
-      const mockFetch = createMockFetch([claudeSession()]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      expect(items[0].trajectory.task.description).toContain('login endpoint');
-    });
-
-    it('should extract tool-use steps', async () => {
-      const mockFetch = createMockFetch([claudeSession()]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-      const steps = items[0].trajectory.steps;
-
-      const readStep = steps.find((s) => s.metadata?.toolName === 'Read');
-      expect(readStep).toBeDefined();
-      expect(readStep!.observation).toContain('user.email');
-
-      const editStep = steps.find((s) => s.metadata?.toolName === 'Edit');
-      expect(editStep).toBeDefined();
-    });
-
-    it('should preserve dataclaw metadata', async () => {
-      const mockFetch = createMockFetch([claudeSession()]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-      const meta = items[0].trajectory.metadata;
-
-      expect(meta.source).toBe('dataclaw');
-      expect(meta.dataclawSource).toBe('claude');
-      expect(meta.project).toBe('my-web-app');
-      expect(meta.model).toBe('claude-opus-4-6');
-      expect(meta.gitBranch).toBe('fix/auth-bug');
-    });
-
-    it('should infer domain from tool file paths', async () => {
-      const mockFetch = createMockFetch([claudeSession(), codexSession()]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      expect(items[0].trajectory.task.domain).toBe('typescript');
-      expect(items[1].trajectory.task.domain).toBe('python');
-    });
-
-    it('should compute token totals from stats', async () => {
-      const mockFetch = createMockFetch([claudeSession()]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      expect(items[0].trajectory.totalTokens).toBe(14500); // 12000 + 2500
-    });
-
-    it('should compute wall time from timestamps', async () => {
-      const mockFetch = createMockFetch([claudeSession()]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      expect(items[0].trajectory.wallTimeSeconds).toBe(25 * 60); // 25 min
-    });
-
-    it('should infer outcome heuristically', async () => {
-      const mockFetch = createMockFetch([claudeSession(), failedSession()]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      const claude = items.find((i) => i.trajectory.id.includes('abc-def'));
-      const failed = items.find((i) => i.trajectory.id.includes('failed'));
-
-      expect(claude!.trajectory.outcome.success).toBe(true);
-      expect(failed!.trajectory.outcome.success).toBe(false);
-    });
-
-    it('should use configured domain override', async () => {
-      const mockFetch = createMockFetch([claudeSession()]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-        domain: 'web-security',
-      });
-      const items = await source.load();
-
-      expect(items[0].trajectory.task.domain).toBe('web-security');
-    });
-  });
-
-  describe('error handling', () => {
-    it('should throw when /rows returns an error', async () => {
-      const mockFetch = vi.fn(async () =>
-        new Response('Forbidden', { status: 403 }),
-      ) as unknown as FetchFn;
-
-      const source = new HuggingFaceTrajectorySource('private/dataset', {
-        fetchFn: mockFetch,
-      });
-
-      await expect(source.load()).rejects.toThrow('403');
-    });
-
-    it('should throw when a pagination page fails', async () => {
-      const sessions = Array.from({ length: 5 }, (_, i) => ({
-        ...claudeSession(),
-        session_id: `sess-${i}`,
-      })) as DataclawSession[];
-
-      const mockFetch = createMockFetch(sessions, { pageSize: 2, failOnPage: 1 });
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-        pageSize: 2,
-      });
-
-      await expect(source.load()).rejects.toThrow('500');
-    });
-
-    it('should skip rows that fail Zod validation', async () => {
-      // Create a mock that returns one valid row and one invalid row
-      const mockFetch = vi.fn(async (input: RequestInfo | URL) => {
-        const url = typeof input === 'string' ? input : input.toString();
-
-        if (url.includes('/rows')) {
-          return new Response(
-            JSON.stringify({
-              features: [],
-              rows: [
-                { row_idx: 0, row: claudeSession() },
-                { row_idx: 1, row: { not_a_valid_session: true } },
-                { row_idx: 2, row: codexSession() },
-              ],
-              num_rows_total: 3,
-              num_rows_per_page: 100,
-              partial: false,
-            }),
-            { status: 200, headers: { 'Content-Type': 'application/json' } },
-          );
-        }
-
-        if (url.includes('/info')) {
-          return new Response(
-            JSON.stringify(makeInfoResponse(3)),
-            { status: 200, headers: { 'Content-Type': 'application/json' } },
-          );
-        }
-
-        return new Response('Not Found', { status: 404 });
-      }) as unknown as FetchFn;
-
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      // Invalid row should be skipped, 2 valid remain
-      expect(items).toHaveLength(2);
-    });
-  });
-
-  describe('real-world dataclaw format edge cases', () => {
-    it('should handle sessions with missing optional fields', async () => {
-      const minimalSession: DataclawSession = {
-        session_id: 'minimal-001',
-        project: '',
-        model: '',
-        source: '',
-        messages: [],
-      };
-      const mockFetch = createMockFetch([minimalSession]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      expect(items).toHaveLength(1);
-      const t = items[0].trajectory;
-      expect(t.id).toBe('dataclaw--minimal-001');
-      expect(t.task.description).toBe('Unknown task');
-      expect(t.wallTimeSeconds).toBe(0);
-      expect(t.totalTokens).toBe(0);
-    });
-
-    it('should handle sessions with null git_branch', async () => {
-      const session: DataclawSession = {
-        ...claudeSession(),
-        git_branch: null,
-      };
-      const mockFetch = createMockFetch([session]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      expect(items[0].trajectory.metadata.gitBranch).toBeUndefined();
-    });
-
-    it('should handle tool_uses with missing output', async () => {
-      const session: DataclawSession = {
-        ...claudeSession(),
-        messages: [
-          { role: 'user', content: 'Do it' },
-          {
-            role: 'assistant',
-            content: 'Done',
-            tool_uses: [
-              {
-                tool: 'Write',
-                input: { file_path: '/a.ts', content: 'x' },
-                output: {},
-                status: 'success',
-              },
-            ],
-          },
-        ],
-      };
-      const mockFetch = createMockFetch([session]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      expect(items).toHaveLength(1);
-      expect(items[0].trajectory.steps[0].observation).toBe('');
-    });
-
-    it('should handle sessions with thinking but no tool_uses', async () => {
-      const session: DataclawSession = {
-        ...claudeSession(),
-        messages: [
-          { role: 'user', content: 'Explain TypeScript generics' },
-          {
-            role: 'assistant',
-            content: 'TypeScript generics allow...',
-            thinking: 'The user wants an explanation of generics.',
-          },
-        ],
-      };
-      const mockFetch = createMockFetch([session]);
-      const source = new HuggingFaceTrajectorySource('user/dataset', {
-        fetchFn: mockFetch,
-      });
-      const items = await source.load();
-
-      expect(items).toHaveLength(1);
-      expect(items[0].trajectory.steps).toHaveLength(1);
-      expect(items[0].trajectory.steps[0].thought).toContain('user wants an explanation');
-    });
-  });
-});