cognitive-core 0.0.2 → 0.1.2

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

@@ -0,0 +1,817 @@
+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');
+    });
+  });
+});