@vsuryav/agent-sim 0.1.0

package/src/collector/claude-code.ts

@@ -0,0 +1,133 @@
+import fs from 'fs';
+import path from 'path';
+import { getDb } from './db.js';
+import { extractTraits } from './personality.js';
+import type { CollectedAgent } from './types.js';
+
+interface SessionMeta {
+  pid: number;
+  sessionId: string;
+  cwd: string;
+  startedAt: number;
+}
+
+export function scanClaudeCode(claudeDir: string): CollectedAgent[] {
+  const db = getDb();
+  const sessionsDir = path.join(claudeDir, 'sessions');
+  const projectsDir = path.join(claudeDir, 'projects');
+  const agents: CollectedAgent[] = [];
+
+  if (!fs.existsSync(sessionsDir)) return agents;
+
+  // Read all session metadata files
+  const sessionFiles = fs.readdirSync(sessionsDir).filter(f => f.endsWith('.json'));
+  const sessions: SessionMeta[] = [];
+
+  for (const file of sessionFiles) {
+    try {
+      const content = fs.readFileSync(path.join(sessionsDir, file), 'utf-8');
+      const meta = JSON.parse(content) as SessionMeta;
+      if (meta.sessionId) sessions.push(meta);
+    } catch {
+      // skip malformed files
+    }
+  }
+
+  if (!fs.existsSync(projectsDir)) return agents;
+
+  const projectDirs = fs.readdirSync(projectsDir).filter(d =>
+    fs.statSync(path.join(projectsDir, d)).isDirectory()
+  );
+
+  for (const session of sessions) {
+    // Skip if already in DB
+    const existing = db.prepare('SELECT id FROM agents WHERE id = ?').get(session.sessionId);
+    if (existing) continue;
+
+    // Find the conversation JSONL file for this session
+    let convFile: string | null = null;
+    for (const projDir of projectDirs) {
+      const candidate = path.join(projectsDir, projDir, `${session.sessionId}.jsonl`);
+      if (fs.existsSync(candidate)) {
+        convFile = candidate;
+        break;
+      }
+    }
+
+    let model: string | null = null;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheTokens = 0;
+    let messageCount = 0;
+    const toolCounts: Record<string, number> = {};
+    const contentTypeCounts: Record<string, number> = {};
+
+    if (convFile) {
+      const lines = fs.readFileSync(convFile, 'utf-8').split('\n').filter(Boolean);
+      for (const line of lines) {
+        try {
+          const obj = JSON.parse(line);
+          const msg = obj?.message;
+          if (!msg || typeof msg !== 'object') continue;
+
+          if (msg.role) messageCount++;
+
+          if (msg.usage) {
+            inputTokens += msg.usage.input_tokens ?? 0;
+            outputTokens += msg.usage.output_tokens ?? 0;
+            cacheTokens += (msg.usage.cache_read_input_tokens ?? 0)
+              + (msg.usage.cache_creation_input_tokens ?? 0);
+          }
+
+          if (msg.model && !model) model = msg.model;
+
+          const content = msg.content;
+          if (Array.isArray(content)) {
+            for (const block of content) {
+              if (typeof block === 'object' && block !== null) {
+                const btype = block.type as string;
+                if (btype) {
+                  contentTypeCounts[btype] = (contentTypeCounts[btype] ?? 0) + 1;
+                }
+                if (btype === 'tool_use' && block.name) {
+                  toolCounts[block.name] = (toolCounts[block.name] ?? 0) + 1;
+                }
+              }
+            }
+          }
+        } catch {
+          // skip malformed lines
+        }
+      }
+    }
+
+    const totalTokens = inputTokens + outputTokens + cacheTokens;
+    const traits = extractTraits(toolCounts, contentTypeCounts, messageCount, 0);
+    const cwd = session.cwd || '/unknown';
+    const clan = path.basename(cwd) || 'home';
+
+    agents.push({
+      id: session.sessionId,
+      tool: 'claude-code',
+      model,
+      project: cwd,
+      clan,
+      created_at: session.startedAt,
+      total_tokens: totalTokens,
+      input_tokens: inputTokens,
+      output_tokens: outputTokens,
+      cache_tokens: cacheTokens,
+      reasoning_tokens: 0,
+      duration_ms: 0,
+      message_count: messageCount,
+      trait_builder: traits.builder,
+      trait_creator: traits.creator,
+      trait_explorer: traits.explorer,
+      trait_leader: traits.leader,
+      trait_thinker: traits.thinker,
+      trait_scholar: traits.scholar,
+    });
+  }
+
+  return agents;
+}

package/src/collector/codex-cli.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { scanCodexCli } from './codex-cli.js';
+import { initDb, getDb, closeDb } from './db.js';
+import Database from 'better-sqlite3';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+describe('Codex CLI collector', () => {
+  const testDir = path.join(os.tmpdir(), `agent-sim-codex-test-${Date.now()}`);
+  const testDbPath = path.join(testDir, 'db.sqlite');
+  const mockCodexDir = path.join(testDir, '.codex');
+
+  beforeEach(() => {
+    fs.mkdirSync(testDir, { recursive: true });
+    initDb(testDbPath);
+  });
+
+  afterEach(() => {
+    closeDb();
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('reads sessions from Codex SQLite threads table', () => {
+    fs.mkdirSync(mockCodexDir, { recursive: true });
+    const codexDb = new Database(path.join(mockCodexDir, 'state_5.sqlite'));
+    codexDb.exec(`
+      CREATE TABLE threads (
+        id TEXT PRIMARY KEY,
+        rollout_path TEXT NOT NULL DEFAULT '',
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        source TEXT NOT NULL DEFAULT 'cli',
+        model_provider TEXT NOT NULL DEFAULT 'openai',
+        cwd TEXT NOT NULL,
+        title TEXT NOT NULL DEFAULT '',
+        sandbox_policy TEXT NOT NULL DEFAULT '',
+        approval_mode TEXT NOT NULL DEFAULT '',
+        tokens_used INTEGER NOT NULL DEFAULT 0,
+        has_user_event INTEGER NOT NULL DEFAULT 0,
+        archived INTEGER NOT NULL DEFAULT 0,
+        cli_version TEXT NOT NULL DEFAULT '',
+        first_user_message TEXT NOT NULL DEFAULT '',
+        model TEXT,
+        reasoning_effort TEXT
+      )
+    `);
+    codexDb.prepare(`INSERT INTO threads (id, created_at, updated_at, cwd, tokens_used, model, reasoning_effort)
+      VALUES (?, ?, ?, ?, ?, ?, ?)`).run(
+      'test-codex-1', 1700000000, 1700001000, '/test/project', 130000, 'gpt-5.4', 'xhigh'
+    );
+    codexDb.close();
+
+    const rolloutDir = path.join(mockCodexDir, 'sessions', '2026', '04', '08');
+    fs.mkdirSync(rolloutDir, { recursive: true });
+    const rolloutLines = [
+      JSON.stringify({
+        timestamp: 1700000500, type: 'event_msg',
+        payload: {
+          type: 'token_count',
+          info: {
+            total_token_usage: {
+              input_tokens: 100000, cached_input_tokens: 2000,
+              output_tokens: 20000, reasoning_output_tokens: 8000, total_tokens: 130000,
+            },
+          },
+        },
+      }),
+      JSON.stringify({ timestamp: 1700000100, type: 'event_msg', payload: { type: 'web_search_end' } }),
+      JSON.stringify({ timestamp: 1700000101, type: 'event_msg', payload: { type: 'web_search_end' } }),
+    ];
+    fs.writeFileSync(
+      path.join(rolloutDir, `rollout-2026-04-08T00-00-00-test-codex-1.jsonl`),
+      rolloutLines.join('\n')
+    );
+
+    const result = scanCodexCli(mockCodexDir);
+
+    expect(result.length).toBe(1);
+    expect(result[0].id).toBe('test-codex-1');
+    expect(result[0].tool).toBe('codex-cli');
+    expect(result[0].model).toBe('gpt-5.4');
+    expect(result[0].input_tokens).toBe(100000);
+    expect(result[0].output_tokens).toBe(20000);
+    expect(result[0].reasoning_tokens).toBe(8000);
+    expect(result[0].total_tokens).toBe(130000);
+    expect(result[0].trait_scholar).toBeGreaterThan(0);
+  });
+
+  it('skips sessions already in the database', () => {
+    const db = getDb();
+    db.prepare(`INSERT INTO agents (id, tool, project, clan, created_at)
+      VALUES (?, ?, ?, ?, ?)`).run('test-codex-1', 'codex-cli', '/test/project', 'project', Date.now());
+
+    fs.mkdirSync(mockCodexDir, { recursive: true });
+    const codexDb = new Database(path.join(mockCodexDir, 'state_5.sqlite'));
+    codexDb.exec(`
+      CREATE TABLE threads (
+        id TEXT PRIMARY KEY, rollout_path TEXT NOT NULL DEFAULT '', created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL, source TEXT NOT NULL DEFAULT 'cli',
+        model_provider TEXT NOT NULL DEFAULT 'openai', cwd TEXT NOT NULL,
+        title TEXT NOT NULL DEFAULT '', sandbox_policy TEXT NOT NULL DEFAULT '',
+        approval_mode TEXT NOT NULL DEFAULT '', tokens_used INTEGER NOT NULL DEFAULT 0,
+        has_user_event INTEGER NOT NULL DEFAULT 0, archived INTEGER NOT NULL DEFAULT 0,
+        cli_version TEXT NOT NULL DEFAULT '', first_user_message TEXT NOT NULL DEFAULT '',
+        model TEXT, reasoning_effort TEXT
+      )
+    `);
+    codexDb.prepare(`INSERT INTO threads (id, created_at, updated_at, cwd, tokens_used)
+      VALUES (?, ?, ?, ?, ?)`).run('test-codex-1', 1700000000, 1700001000, '/test', 50000);
+    codexDb.close();
+
+    const result = scanCodexCli(mockCodexDir);
+    expect(result.length).toBe(0);
+  });
+});

package/src/collector/codex-cli.ts

@@ -0,0 +1,149 @@
+import Database from 'better-sqlite3';
+import fs from 'fs';
+import path from 'path';
+import { getDb } from './db.js';
+import { extractTraits } from './personality.js';
+import type { CollectedAgent } from './types.js';
+
+interface CodexThread {
+  id: string;
+  created_at: number;
+  updated_at: number;
+  cwd: string;
+  tokens_used: number;
+  model: string | null;
+  reasoning_effort: string | null;
+}
+
+export function scanCodexCli(codexDir: string): CollectedAgent[] {
+  const db = getDb();
+  const agents: CollectedAgent[] = [];
+  const statePath = path.join(codexDir, 'state_5.sqlite');
+
+  if (!fs.existsSync(statePath)) return agents;
+
+  const codexDb = new Database(statePath, { readonly: true });
+  let threads: CodexThread[];
+  try {
+    threads = codexDb.prepare(
+      `SELECT id, created_at, updated_at, cwd, tokens_used, model, reasoning_effort
+       FROM threads WHERE archived = 0`
+    ).all() as CodexThread[];
+  } catch {
+    codexDb.close();
+    return agents;
+  }
+
+  for (const thread of threads) {
+    const existing = db.prepare('SELECT id FROM agents WHERE id = ?').get(thread.id);
+    if (existing) continue;
+
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cachedTokens = 0;
+    let reasoningTokens = 0;
+    let totalTokens = thread.tokens_used;
+    const toolCounts: Record<string, number> = {};
+    const contentTypeCounts: Record<string, number> = {};
+    let messageCount = 0;
+
+    const rolloutFile = findRolloutFile(codexDir, thread.id);
+    if (rolloutFile) {
+      const lines = fs.readFileSync(rolloutFile, 'utf-8').split('\n').filter(Boolean);
+      let lastTokenCount: any = null;
+
+      for (const line of lines) {
+        try {
+          const obj = JSON.parse(line);
+          if (obj.type === 'event_msg') {
+            const payload = obj.payload;
+            const eventType = payload?.type as string;
+
+            if (eventType) {
+              contentTypeCounts[eventType] = (contentTypeCounts[eventType] ?? 0) + 1;
+            }
+            if (eventType === 'web_search_end') {
+              toolCounts['web_search_end'] = (toolCounts['web_search_end'] ?? 0) + 1;
+            }
+            if (eventType === 'user_message' || eventType === 'agent_message') {
+              messageCount++;
+            }
+            if (eventType === 'token_count' && payload.info) {
+              lastTokenCount = payload.info;
+            }
+          }
+        } catch {
+          // skip malformed
+        }
+      }
+
+      if (lastTokenCount?.total_token_usage) {
+        const usage = lastTokenCount.total_token_usage;
+        inputTokens = usage.input_tokens ?? 0;
+        outputTokens = usage.output_tokens ?? 0;
+        cachedTokens = usage.cached_input_tokens ?? 0;
+        reasoningTokens = usage.reasoning_output_tokens ?? 0;
+        totalTokens = usage.total_tokens ?? thread.tokens_used;
+      }
+    }
+
+    const durationMs = (thread.updated_at - thread.created_at) * 1000;
+    const traits = extractTraits(toolCounts, contentTypeCounts, messageCount, durationMs);
+    const cwd = thread.cwd || '/unknown';
+    const clan = path.basename(cwd) || 'home';
+
+    agents.push({
+      id: thread.id,
+      tool: 'codex-cli',
+      model: thread.model,
+      project: cwd,
+      clan,
+      created_at: thread.created_at * 1000,
+      total_tokens: totalTokens,
+      input_tokens: inputTokens,
+      output_tokens: outputTokens,
+      cache_tokens: cachedTokens,
+      reasoning_tokens: reasoningTokens,
+      duration_ms: durationMs,
+      message_count: messageCount,
+      trait_builder: traits.builder,
+      trait_creator: traits.creator,
+      trait_explorer: traits.explorer,
+      trait_leader: traits.leader,
+      trait_thinker: traits.thinker,
+      trait_scholar: traits.scholar,
+    });
+  }
+
+  codexDb.close();
+  return agents;
+}
+
+function findRolloutFile(codexDir: string, threadId: string): string | null {
+  const sessionsDir = path.join(codexDir, 'sessions');
+  if (!fs.existsSync(sessionsDir)) return null;
+
+  try {
+    const years = fs.readdirSync(sessionsDir);
+    for (const year of years) {
+      const yearPath = path.join(sessionsDir, year);
+      if (!fs.statSync(yearPath).isDirectory()) continue;
+      const months = fs.readdirSync(yearPath);
+      for (const month of months) {
+        const monthPath = path.join(yearPath, month);
+        if (!fs.statSync(monthPath).isDirectory()) continue;
+        const days = fs.readdirSync(monthPath);
+        for (const day of days) {
+          const dayPath = path.join(monthPath, day);
+          if (!fs.statSync(dayPath).isDirectory()) continue;
+          const files = fs.readdirSync(dayPath);
+          const match = files.find(f => f.includes(threadId) && f.endsWith('.jsonl'));
+          if (match) return path.join(dayPath, match);
+        }
+      }
+    }
+  } catch {
+    // directory doesn't exist or unreadable
+  }
+  return null;
+}

package/src/collector/db.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { initDb, getDb, closeDb } from './db.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+describe('database', () => {
+  const testDir = path.join(os.tmpdir(), `agent-sim-test-${Date.now()}`);
+  const testDbPath = path.join(testDir, 'db.sqlite');
+
+  beforeEach(() => {
+    fs.mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    closeDb();
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('creates database with all tables', () => {
+    initDb(testDbPath);
+    const db = getDb();
+
+    const tables = db
+      .prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+      .all()
+      .map((r: any) => r.name);
+
+    expect(tables).toContain('agents');
+    expect(tables).toContain('clans');
+    expect(tables).toContain('tiles');
+    expect(tables).toContain('events');
+    expect(tables).toContain('world');
+  });
+
+  it('initializes world state with defaults', () => {
+    initDb(testDbPath);
+    const db = getDb();
+
+    const phase = db.prepare("SELECT value FROM world WHERE key = 'phase'").get() as any;
+    expect(phase.value).toBe('space');
+  });
+
+  it('can insert and retrieve an agent', () => {
+    initDb(testDbPath);
+    const db = getDb();
+
+    db.prepare(`INSERT INTO agents (id, tool, model, project, clan, created_at, total_tokens)
+      VALUES (?, ?, ?, ?, ?, ?, ?)`).run(
+      'test-session-1', 'claude-code', 'claude-opus-4-6',
+      '/Users/test/project', 'project', Date.now(), 50000
+    );
+
+    const agent = db.prepare('SELECT * FROM agents WHERE id = ?').get('test-session-1') as any;
+    expect(agent.tool).toBe('claude-code');
+    expect(agent.total_tokens).toBe(50000);
+    expect(agent.maturity).toBe('spark');
+  });
+});

package/src/collector/db.ts

@@ -0,0 +1,125 @@
+import Database from 'better-sqlite3';
+
+let db: Database.Database | null = null;
+
+export function initDb(dbPath: string): void {
+  db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agents (
+      id TEXT PRIMARY KEY,
+      tool TEXT NOT NULL,
+      model TEXT,
+      project TEXT NOT NULL,
+      clan TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      total_tokens INTEGER DEFAULT 0,
+      input_tokens INTEGER DEFAULT 0,
+      output_tokens INTEGER DEFAULT 0,
+      cache_tokens INTEGER DEFAULT 0,
+      reasoning_tokens INTEGER DEFAULT 0,
+      duration_ms INTEGER DEFAULT 0,
+      message_count INTEGER DEFAULT 0,
+      trait_builder REAL DEFAULT 0,
+      trait_creator REAL DEFAULT 0,
+      trait_explorer REAL DEFAULT 0,
+      trait_leader REAL DEFAULT 0,
+      trait_thinker REAL DEFAULT 0,
+      trait_scholar REAL DEFAULT 0,
+      name TEXT,
+      maturity TEXT DEFAULT 'spark',
+      mood TEXT DEFAULT 'content',
+      x INTEGER DEFAULT 0,
+      y INTEGER DEFAULT 0,
+      current_activity TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS clans (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      color TEXT,
+      district_x INTEGER,
+      district_y INTEGER,
+      culture TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS tiles (
+      x INTEGER NOT NULL,
+      y INTEGER NOT NULL,
+      terrain TEXT NOT NULL,
+      building TEXT,
+      built_by TEXT,
+      PRIMARY KEY (x, y)
+    );
+
+    CREATE TABLE IF NOT EXISTS events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp INTEGER NOT NULL,
+      agent_id TEXT,
+      type TEXT NOT NULL,
+      description TEXT,
+      x INTEGER,
+      y INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS world (
+      key TEXT PRIMARY KEY,
+      value TEXT
+    );
+  `);
+
+  const existing = db.prepare("SELECT value FROM world WHERE key = 'phase'").get();
+  if (!existing) {
+    const seed = Math.floor(Math.random() * 2147483647).toString();
+    const initWorld = db.prepare('INSERT OR IGNORE INTO world (key, value) VALUES (?, ?)');
+    const batch = db.transaction(() => {
+      initWorld.run('phase', 'space');
+      initWorld.run('day', '0');
+      initWorld.run('seed', seed);
+    });
+    batch();
+  }
+}
+
+export function getDb(): Database.Database {
+  if (!db) throw new Error('Database not initialized. Call initDb() first.');
+  return db;
+}
+
+export function getWorldValue(key: string): string | null {
+  const row = getDb().prepare('SELECT value FROM world WHERE key = ?').get(key) as { value?: string } | undefined;
+  return row?.value ?? null;
+}
+
+export function setWorldValue(key: string, value: string): void {
+  getDb().prepare(`
+    INSERT INTO world (key, value) VALUES (?, ?)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value
+  `).run(key, value);
+}
+
+export function setWorldConfig(world: {
+  seed: number;
+  ruleset_version?: number;
+  github_login?: string;
+}): void {
+  const batch = getDb().transaction(() => {
+    setWorldValue('seed', `${world.seed}`);
+    if (world.ruleset_version !== undefined) {
+      setWorldValue('ruleset_version', `${world.ruleset_version}`);
+    }
+    if (world.github_login) {
+      setWorldValue('github_login', world.github_login);
+    }
+  });
+  batch();
+}
+
+export function closeDb(): void {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}

package/src/collector/names.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import { generateName } from './names.js';
+
+describe('generateName', () => {
+  it('returns a string', () => {
+    const name = generateName('seed-1');
+    expect(typeof name).toBe('string');
+    expect(name.length).toBeGreaterThan(0);
+  });
+
+  it('is deterministic for same seed', () => {
+    const a = generateName('same-seed');
+    const b = generateName('same-seed');
+    expect(a).toBe(b);
+  });
+
+  it('produces different names for different seeds', () => {
+    const names = new Set(Array.from({ length: 20 }, (_, i) => generateName(`seed-${i}`)));
+    expect(names.size).toBeGreaterThan(10);
+  });
+});

package/src/collector/names.ts

@@ -0,0 +1,28 @@
+const ADJECTIVES = [
+  'tiny', 'bright', 'swift', 'gentle', 'bold', 'calm', 'warm', 'keen',
+  'soft', 'wild', 'cozy', 'plucky', 'merry', 'deft', 'kind', 'fair',
+  'brave', 'quick', 'wise', 'neat', 'jolly', 'quiet', 'proud', 'lucky',
+  'witty', 'snug', 'perky', 'nimble', 'breezy', 'peppy', 'spry', 'rosy',
+];
+
+const NOUNS = [
+  'Spark', 'Ember', 'Pixel', 'Scout', 'Fern', 'Sage', 'Moss', 'Flint',
+  'Wren', 'Pip', 'Dusk', 'Glow', 'Chip', 'Bloom', 'Forge', 'Reed',
+  'Lark', 'Haze', 'Drift', 'Crest', 'Pebble', 'Brook', 'Twig', 'Mote',
+  'Sprout', 'Coral', 'Plume', 'Thistle', 'Clover', 'Breeze', 'Flicker', 'Ripple',
+];
+
+function simpleHash(str: string): number {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) - hash + str.charCodeAt(i)) | 0;
+  }
+  return Math.abs(hash);
+}
+
+export function generateName(seed: string): string {
+  const h = simpleHash(seed);
+  const adj = ADJECTIVES[h % ADJECTIVES.length]!;
+  const noun = NOUNS[(h >>> 8) % NOUNS.length]!;
+  return `${adj[0]!.toUpperCase()}${adj.slice(1)} ${noun}`;
+}

package/src/collector/personality.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { extractTraits } from './personality.js';
+
+describe('extractTraits', () => {
+  it('derives builder trait from Bash tool usage', () => {
+    const toolCounts = { Bash: 50, Read: 5, Write: 2 };
+    const contentTypeCounts = { thinking: 3, text: 10, tool_use: 57, tool_result: 57 };
+    const traits = extractTraits(toolCounts, contentTypeCounts, 100, 60000);
+
+    expect(traits.builder).toBeGreaterThan(0.5);
+    expect(traits.builder).toBeLessThanOrEqual(1.0);
+  });
+
+  it('derives explorer trait from Read/Grep/Glob usage', () => {
+    const toolCounts = { Read: 30, Grep: 20, Glob: 10, Bash: 2 };
+    const contentTypeCounts = { thinking: 1, text: 5, tool_use: 62, tool_result: 62 };
+    const traits = extractTraits(toolCounts, contentTypeCounts, 50, 30000);
+
+    expect(traits.explorer).toBeGreaterThan(0.5);
+  });
+
+  it('derives thinker trait from thinking blocks', () => {
+    const toolCounts = { Bash: 5 };
+    const contentTypeCounts = { thinking: 40, text: 10, tool_use: 5, tool_result: 5 };
+    const traits = extractTraits(toolCounts, contentTypeCounts, 20, 60000);
+
+    expect(traits.thinker).toBeGreaterThan(0.5);
+  });
+
+  it('normalizes all traits to 0-1 range', () => {
+    const toolCounts = { Bash: 100, Write: 100, Read: 100, Agent: 100, WebSearch: 100 };
+    const contentTypeCounts = { thinking: 100, text: 100, tool_use: 500, tool_result: 500 };
+    const traits = extractTraits(toolCounts, contentTypeCounts, 200, 600000);
+
+    for (const value of Object.values(traits)) {
+      expect(value).toBeGreaterThanOrEqual(0);
+      expect(value).toBeLessThanOrEqual(1);
+    }
+  });
+});