@winspan/claude-forge 8.50.6 → 8.51.1

package/tests/unit/daemon/hook-sync.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { syncHooks } from '../../../src/daemon/hook-sync.js';
+
+describe('syncHooks', () => {
+  let tmpRoot: string;
+  let sourceDir: string;
+  let targetDir: string;
+
+  beforeEach(() => {
+    tmpRoot = mkdtempSync(join(tmpdir(), 'forge-hook-sync-'));
+    sourceDir = join(tmpRoot, 'src-hooks');
+    targetDir = join(tmpRoot, 'target-hooks');
+    mkdirSync(sourceDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tmpRoot, { recursive: true, force: true });
+  });
+
+  it('target dir not exist → returns zero counts (user did not init)', () => {
+    writeFileSync(join(sourceDir, 'pre-tool-use.sh'), '#!/bin/bash\necho "new"\n');
+    const result = syncHooks({ sourceDir, targetDir });
+    expect(result.copied).toBe(0);
+    expect(result.checked).toBe(0);
+  });
+
+  it('source and target identical → no copy', () => {
+    mkdirSync(targetDir, { recursive: true });
+    const content = '#!/bin/bash\necho "same"\n';
+    writeFileSync(join(sourceDir, 'pre-tool-use.sh'), content);
+    writeFileSync(join(targetDir, 'pre-tool-use.sh'), content);
+
+    const result = syncHooks({ sourceDir, targetDir });
+    expect(result.copied).toBe(0);
+    expect(result.checked).toBe(1);
+  });
+
+  it('source and target differ → copies new content', () => {
+    mkdirSync(targetDir, { recursive: true });
+    writeFileSync(join(sourceDir, 'pre-tool-use.sh'), '#!/bin/bash\necho "NEW"\n');
+    writeFileSync(join(targetDir, 'pre-tool-use.sh'), '#!/bin/bash\necho "old"\n');
+
+    const result = syncHooks({ sourceDir, targetDir });
+    expect(result.copied).toBe(1);
+    expect(result.checked).toBe(1);
+    expect(readFileSync(join(targetDir, 'pre-tool-use.sh'), 'utf-8')).toContain('NEW');
+  });
+
+  it('target missing file but exists in source → copies it', () => {
+    mkdirSync(targetDir, { recursive: true });
+    writeFileSync(join(sourceDir, 'hook-lib.sh'), '# lib\n');
+    // target has no hook-lib.sh
+
+    const result = syncHooks({ sourceDir, targetDir });
+    expect(result.copied).toBe(1);
+    expect(existsSync(join(targetDir, 'hook-lib.sh'))).toBe(true);
+  });
+
+  it('source missing some files → skips them silently', () => {
+    mkdirSync(targetDir, { recursive: true });
+    // Only one source file out of 6
+    writeFileSync(join(sourceDir, 'pre-tool-use.sh'), '#!/bin/bash\necho "x"\n');
+
+    const result = syncHooks({ sourceDir, targetDir });
+    expect(result.checked).toBe(1);
+    expect(result.skipped).toBe(5);
+  });
+});

package/tests/unit/daemon/post-tool-use.test.ts

@@ -0,0 +1,121 @@
+/**
+ * M7: PostToolUseHandler routing_event association behavior.
+ *
+ * Targets the time-ordering bug where 2+ Agent invocations within a single
+ * user prompt could overwrite the same routing_event repeatedly. After M7,
+ * the handler must only touch the *pending* (obeyed IS NULL) recent event;
+ * later Agents within the same prompt are silently skipped (M7 limitation).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import { PostToolUseHandler } from '../../../src/daemon/handlers/post-tool-use.js';
+import type { PostToolUseEvent } from '../../../src/core/types.js';
+
+const PROJECT = '/tmp/m7-handler-proj';
+
+function makeAgentEvent(session_id: string, agentType: string): PostToolUseEvent {
+  return {
+    session_id,
+    project_path: PROJECT,
+    timestamp: new Date().toISOString(),
+    hook_type: 'PostToolUse',
+    tool_name: 'Agent',
+    tool_input: { subagent_type: agentType },
+    tool_output: {},
+  };
+}
+
+describe('PostToolUseHandler — routing_event association (M7)', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+  let handler: PostToolUseHandler;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-m7-handler-'));
+    storage = new SQLiteStorage(join(tmp, 'data.db'));
+    handler = new PostToolUseHandler(storage);
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('case 1: same prompt, 2 Agent calls — first updates pending row, second does NOT re-overwrite', async () => {
+    const sess = 'sess-same-prompt';
+
+    // UserPromptHandler writes a single pending routing_event.
+    const eventId = storage.writeRoutingEvent({
+      session_id: sess, project_path: PROJECT, ts: 1000,
+      prompt: 'spawn two agents', intent_json: '{}',
+      obeyed: null,
+    });
+
+    // Agent #1 fires → first PostToolUse fills the row.
+    await handler.handle(makeAgentEvent(sess, 'researcher'));
+
+    const rowsAfter1 = storage.queryRoutingEvents({ session_id: sess });
+    expect(rowsAfter1).toHaveLength(1);
+    expect(rowsAfter1[0].id).toBe(eventId);
+    expect(rowsAfter1[0].obeyed).toBe(1);
+    expect(rowsAfter1[0].routed_to_name).toBe('researcher');
+    const firstToolTs = rowsAfter1[0].first_tool_ts;
+    expect(firstToolTs).not.toBeNull();
+
+    // Agent #2 fires → with the pending filter, no pending row remains;
+    // the handler must NOT overwrite the existing obeyed=1 row.
+    await handler.handle(makeAgentEvent(sess, 'coder'));
+
+    const rowsAfter2 = storage.queryRoutingEvents({ session_id: sess });
+    expect(rowsAfter2).toHaveLength(1);
+    expect(rowsAfter2[0].id).toBe(eventId);
+    expect(rowsAfter2[0].routed_to_name).toBe('researcher'); // NOT overwritten to 'coder'
+    expect(rowsAfter2[0].first_tool_ts).toBe(firstToolTs);    // ts not stomped
+    expect(rowsAfter2[0].obeyed).toBe(1);
+  });
+
+  it('case 2: cross-prompt — each prompt’s Agent updates its own pending event', async () => {
+    const sess = 'sess-cross-prompt';
+
+    // Prompt 1 → routing_event #1 pending.
+    const eid1 = storage.writeRoutingEvent({
+      session_id: sess, project_path: PROJECT, ts: 1000,
+      prompt: 'p1', intent_json: '{}',
+      obeyed: null,
+    });
+    // Agent for P1.
+    await handler.handle(makeAgentEvent(sess, 'researcher'));
+
+    // Prompt 2 → routing_event #2 pending.
+    const eid2 = storage.writeRoutingEvent({
+      session_id: sess, project_path: PROJECT, ts: 2000,
+      prompt: 'p2', intent_json: '{}',
+      obeyed: null,
+    });
+    // Agent for P2.
+    await handler.handle(makeAgentEvent(sess, 'coder'));
+
+    const rows = storage.queryRoutingEvents({ session_id: sess });
+    expect(rows).toHaveLength(2);
+
+    const byId = new Map(rows.map(r => [r.id, r]));
+    const r1 = byId.get(eid1)!;
+    const r2 = byId.get(eid2)!;
+    expect(r1.routed_to_name).toBe('researcher');
+    expect(r1.obeyed).toBe(1);
+    expect(r2.routed_to_name).toBe('coder');
+    expect(r2.obeyed).toBe(1);
+  });
+
+  it('case 3: no routing_event in DB — handler does not throw', async () => {
+    const sess = 'sess-none';
+    await expect(handler.handle(makeAgentEvent(sess, 'researcher'))).resolves.toEqual({ allow: true });
+
+    const rows = storage.queryRoutingEvents({ session_id: sess });
+    expect(rows).toHaveLength(0);
+  });
+});

package/tests/unit/daemon/stop-handler-behavior-summary.test.ts

@@ -0,0 +1,202 @@
+/**
+ * H2 Phase 1 safety-net: StopHandler behavior summary.
+ *
+ * Locks the output format and aggregation logic of `generateBehaviorSummary`
+ * before its inline SQL (events GROUP BY tool_name / Agent-Task subagent_type /
+ * COUNT skill_invocations) is migrated into EventOperations / SkillOperations.
+ *
+ * Since `generateBehaviorSummary` is `private`, we exercise it indirectly via
+ * `handle()` and capture the resume content passed to `resume.save`. That is
+ * also the actually-exercised path in production, so this gives a higher-value
+ * baseline than reflection-style private access.
+ *
+ * NOTE on test location: the spec listed `src/tests/...`, but vitest.config.ts
+ * only discovers `tests/unit/**` and `tests/integration/**`, so the file is
+ * placed under `tests/unit/daemon/` to ensure it actually runs. The semantic
+ * intent (a unit test, not an integration test) is preserved.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { StopHandler } from '../../../src/daemon/handlers/stop.js';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import type { HistoryExporter } from '../../../src/daemon/handlers/history-exporter.js';
+import type { StopEvent } from '../../../src/core/types.js';
+
+const SESSION = 'sess-behavior-summary';
+const PROJECT = '/tmp/proj-behavior-summary';
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function makeEvent(): StopEvent {
+  return {
+    session_id: SESSION,
+    project_path: PROJECT,
+    timestamp: nowIso(),
+    hook_type: 'Stop',
+  };
+}
+
+describe('StopHandler.generateBehaviorSummary (safety-net)', () => {
+  let storage: SQLiteStorage;
+  let exporter: HistoryExporter;
+  let saved: { content: string | null };
+
+  // Build a mock ResumeManager that returns a known stub from generate() and
+  // captures whatever the handler ends up passing to save().
+  function makeResumeMock(): { generate: ReturnType<typeof vi.fn>; save: ReturnType<typeof vi.fn>; load: ReturnType<typeof vi.fn>; clear: ReturnType<typeof vi.fn> } {
+    return {
+      generate: vi.fn().mockReturnValue('STUB_RESUME\n_生成时间: 2026-01-01T00:00:00.000Z_\n'),
+      save: vi.fn((_p: string, c: string) => { saved.content = c; }),
+      load: vi.fn(),
+      clear: vi.fn(),
+    };
+  }
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    saved = { content: null };
+    exporter = { export: vi.fn().mockResolvedValue(undefined) } as unknown as HistoryExporter;
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  it('does not append summary when storage has no events for the session', async () => {
+    const resume = makeResumeMock();
+    const handler = new StopHandler(exporter, resume as any, null, storage, null, null);
+
+    const res = await handler.handle(makeEvent());
+    expect(res.allow).toBe(true);
+    // resume.save should still be called (resume content exists)
+    expect(resume.save).toHaveBeenCalledTimes(1);
+    expect(saved.content).not.toBeNull();
+    // Behavior summary line MUST NOT appear when there are no tool calls
+    expect(saved.content!).not.toContain('会话行为');
+  });
+
+  it('appends a tool-only behavior summary when only tool events exist', async () => {
+    // Seed events: 2 Bash, 1 Edit — no Agent/Task, no skill invocations
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'ls' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'pwd' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Edit', tool_input: { file_path: '/x' },
+    });
+
+    const resume = makeResumeMock();
+    const handler = new StopHandler(exporter, resume as any, null, storage, null, null);
+
+    const res = await handler.handle(makeEvent());
+    expect(res.allow).toBe(true);
+    expect(saved.content).not.toBeNull();
+
+    // Must contain a behavior summary line with total tool calls
+    expect(saved.content!).toContain('**会话行为**');
+    expect(saved.content!).toContain('工具调用 3 次');
+    expect(saved.content!).toContain('Agent 委托 0 次');
+    expect(saved.content!).toContain('Skill 调用 0 次');
+  });
+
+  it('includes Agent delegation counts and agent type names', async () => {
+    // 2 normal tools + 2 Task delegations to different subagents
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'ls' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Read', tool_input: { file_path: '/a' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Task',
+      tool_input: { subagent_type: 'explore', description: 'find x' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Task',
+      tool_input: { subagent_type: 'coder', description: 'fix y' },
+    });
+
+    const resume = makeResumeMock();
+    const handler = new StopHandler(exporter, resume as any, null, storage, null, null);
+
+    await handler.handle(makeEvent());
+    expect(saved.content).not.toBeNull();
+
+    const summary = saved.content!;
+    expect(summary).toContain('工具调用 4 次');
+    expect(summary).toContain('Agent 委托 2 次');
+    // Agent names appear in parenthesised detail
+    expect(summary).toMatch(/explore|coder/);
+  });
+
+  it('includes skill invocation count when skill_invocations rows exist', async () => {
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'ls' },
+    });
+    storage.writeSkillInvocation({
+      id: 'si-bs-1', route_request_id: null, session_id: SESSION,
+      agent_id: null, skill_id: 'official-tdd',
+      invocation_type: 'dynamic', reason: null,
+      workflow: null, phase: null, feature_slug: null, artifact_path: null,
+      depth: 0, success: 1, error: null, timestamp: Date.now(),
+    });
+    storage.writeSkillInvocation({
+      id: 'si-bs-2', route_request_id: null, session_id: SESSION,
+      agent_id: null, skill_id: 'official-debug',
+      invocation_type: 'dynamic', reason: null,
+      workflow: null, phase: null, feature_slug: null, artifact_path: null,
+      depth: 0, success: 1, error: null, timestamp: Date.now(),
+    });
+
+    const resume = makeResumeMock();
+    const handler = new StopHandler(exporter, resume as any, null, storage, null, null);
+
+    await handler.handle(makeEvent());
+    expect(saved.content).not.toBeNull();
+    expect(saved.content!).toContain('Skill 调用 2 次');
+  });
+
+  it('does not include events from other sessions in the summary', async () => {
+    // Same session — 1 tool call
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'ls' },
+    });
+    // Different session — 5 tool calls + 3 skill invocations: MUST be excluded
+    for (let i = 0; i < 5; i++) {
+      storage.writeEvent({
+        session_id: 'other-session', project_path: PROJECT, timestamp: nowIso(),
+        hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'noise' },
+      });
+    }
+    for (let i = 0; i < 3; i++) {
+      storage.writeSkillInvocation({
+        id: `si-noise-${i}`, route_request_id: null, session_id: 'other-session',
+        agent_id: null, skill_id: 'official-noise',
+        invocation_type: 'dynamic', reason: null,
+        workflow: null, phase: null, feature_slug: null, artifact_path: null,
+        depth: 0, success: 1, error: null, timestamp: Date.now(),
+      });
+    }
+
+    const resume = makeResumeMock();
+    const handler = new StopHandler(exporter, resume as any, null, storage, null, null);
+
+    await handler.handle(makeEvent());
+    expect(saved.content).not.toBeNull();
+    expect(saved.content!).toContain('工具调用 1 次');
+    expect(saved.content!).toContain('Skill 调用 0 次');
+  });
+});

package/tests/unit/daemon/task-segmenter-recover.test.ts

@@ -0,0 +1,84 @@
+/**
+ * 单测：TaskSegmenter.completeCurrentTask recover fallback
+ *
+ * 覆盖：
+ *   - Map 为空但 DB 有 active task → completeCurrentTask 仍能将其转为 completed
+ *   - Map 不为空的正常路径不退化
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import { TaskSegmenter } from '../../../src/daemon/services/task-segmenter.js';
+
+const SESSION = 'sess-segmenter-recover';
+
+function openStorage(tmp: string): SQLiteStorage {
+  return new SQLiteStorage(join(tmp, 'data.db'));
+}
+
+describe('TaskSegmenter.completeCurrentTask recover fallback', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-segmenter-recover-'));
+    storage = openStorage(tmp);
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('Map 为空但 DB 有 active task → completeCurrentTask 将其转 completed', () => {
+    // 直接写 active task 到 DB（不经过 processPrompt，模拟 daemon 重启后内存丢失）
+    storage.writeTask({
+      id: 'task-in-db',
+      session_id: SESSION,
+      title: 'Persisted active task',
+      start_time: '2026-01-01T10:00:00.000Z',
+    });
+
+    // 确认此刻 DB 中是 active
+    expect(storage.getTask('task-in-db')?.status).toBe('active');
+
+    // 创建新的 TaskSegmenter，Map 为空（模拟重启）
+    const segmenter = new TaskSegmenter(storage);
+
+    // Stop hook 触发 completeCurrentTask，Map 中没有该 session 的 entry
+    segmenter.completeCurrentTask(SESSION, '2026-01-01T10:30:00.000Z');
+
+    // task 应该被 recover 并标记为 completed
+    const task = storage.getTask('task-in-db');
+    expect(task?.status).toBe('completed');
+    expect(task?.end_time).toBe('2026-01-01T10:30:00.000Z');
+  });
+
+  it('DB 中无 active task 时 completeCurrentTask 安全退出（不报错）', () => {
+    // 完全空 DB，completeCurrentTask 不应抛出
+    const segmenter = new TaskSegmenter(storage);
+    expect(() => {
+      segmenter.completeCurrentTask(SESSION, '2026-01-01T10:30:00.000Z');
+    }).not.toThrow();
+  });
+
+  it('Map 有 entry 时（正常路径）completeCurrentTask 正常关闭 task', () => {
+    const segmenter = new TaskSegmenter(storage);
+
+    // 通过 processPrompt 走正常路径，将 task 写入 Map
+    const taskId = segmenter.processPrompt(SESSION, 'implement feature', '2026-01-01T10:00:00.000Z');
+
+    // 确认 DB 中是 active
+    expect(storage.getTask(taskId)?.status).toBe('active');
+
+    // completeCurrentTask 正常关闭
+    segmenter.completeCurrentTask(SESSION, '2026-01-01T10:30:00.000Z');
+
+    const task = storage.getTask(taskId);
+    expect(task?.status).toBe('completed');
+    expect(task?.end_time).toBe('2026-01-01T10:30:00.000Z');
+  });
+});

package/tests/unit/event-fields.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+import {
+  getCommand,
+  getFilePath,
+  getUserPrompt,
+  getSubagentType,
+} from '../../src/core/event-fields.js';
+import type { ForgeEvent } from '../../src/core/types.js';
+
+function makeEvent(overrides: Partial<ForgeEvent> = {}): ForgeEvent {
+  return {
+    session_id: 's',
+    project_path: '/p',
+    timestamp: '2026-05-18T00:00:00Z',
+    hook_type: 'PreToolUse',
+    ...overrides,
+  };
+}
+
+describe('event-fields getters', () => {
+  describe('getCommand', () => {
+    it('returns undefined when tool_input is missing', () => {
+      expect(getCommand(makeEvent())).toBeUndefined();
+    });
+
+    it('returns undefined when command is not a string', () => {
+      expect(getCommand(makeEvent({ tool_input: { command: 42 as unknown as string } }))).toBeUndefined();
+    });
+
+    it('returns the command string when present', () => {
+      expect(getCommand(makeEvent({ tool_input: { command: 'ls -la' } }))).toBe('ls -la');
+    });
+  });
+
+  describe('getFilePath', () => {
+    it('returns undefined when tool_input is missing', () => {
+      expect(getFilePath(makeEvent())).toBeUndefined();
+    });
+
+    it('returns undefined when file_path is wrong type', () => {
+      expect(getFilePath(makeEvent({ tool_input: { file_path: 123 as unknown as string } }))).toBeUndefined();
+    });
+
+    it('returns file_path when present', () => {
+      expect(getFilePath(makeEvent({ tool_input: { file_path: '/foo/bar.ts' } }))).toBe('/foo/bar.ts');
+    });
+
+    it('falls back to notebook_path when file_path is missing', () => {
+      expect(getFilePath(makeEvent({ tool_input: { notebook_path: '/x.ipynb' } }))).toBe('/x.ipynb');
+    });
+
+    it('returns undefined for empty string', () => {
+      expect(getFilePath(makeEvent({ tool_input: { file_path: '' } }))).toBeUndefined();
+    });
+  });
+
+  describe('getUserPrompt', () => {
+    it('returns undefined when neither field set', () => {
+      expect(getUserPrompt(makeEvent())).toBeUndefined();
+    });
+
+    it('returns top-level user_prompt when set', () => {
+      expect(getUserPrompt(makeEvent({ user_prompt: 'hi' }))).toBe('hi');
+    });
+
+    it('falls back to tool_input.user_prompt envelope', () => {
+      expect(getUserPrompt(makeEvent({ tool_input: { user_prompt: 'envelope' } }))).toBe('envelope');
+    });
+
+    it('returns undefined when fallback is wrong type', () => {
+      expect(getUserPrompt(makeEvent({ tool_input: { user_prompt: 7 as unknown as string } }))).toBeUndefined();
+    });
+  });
+
+  describe('getSubagentType', () => {
+    it('returns undefined when missing', () => {
+      expect(getSubagentType(makeEvent())).toBeUndefined();
+    });
+
+    it('returns undefined when wrong type', () => {
+      expect(getSubagentType(makeEvent({ tool_input: { subagent_type: {} as unknown as string } }))).toBeUndefined();
+    });
+
+    it('returns the subagent_type string', () => {
+      expect(getSubagentType(makeEvent({ tool_input: { subagent_type: 'planner' } }))).toBe('planner');
+    });
+  });
+});

package/tests/unit/event-parser.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { EventParser } from '../../src/daemon/event-parser.js';
+
+const parser = new EventParser();
+
+function makeRaw(overrides: Record<string, unknown> = {}) {
+  return JSON.stringify({
+    hook_type: 'PreToolUse',
+    timestamp: '2026-05-18T00:00:00Z',
+    session_id: 's1',
+    project_path: '/p',
+    tool_name: 'Bash',
+    ...overrides,
+  });
+}
+
+describe('EventParser', () => {
+  it('generates a UUID event_id when none is provided', () => {
+    const evt = parser.parse(makeRaw());
+    expect(evt.event_id).toMatch(/^[0-9a-f-]{36}$/i);
+  });
+
+  it('passes through a valid externally-supplied event_id', () => {
+    const id = '11111111-2222-4333-8444-555555555555';
+    const evt = parser.parse(makeRaw({ event_id: id }));
+    expect(evt.event_id).toBe(id);
+  });
+
+  it('rejects a malformed event_id via schema', () => {
+    expect(() => parser.parse(makeRaw({ event_id: 'not-a-uuid' }))).toThrow();
+  });
+
+  it('lands tool_input fields into ToolInputFields shape', () => {
+    const evt = parser.parse(
+      makeRaw({ tool_input: { command: 'ls', file_path: '/a/b.ts', extra: 1 } })
+    );
+    expect(evt.tool_input?.command).toBe('ls');
+    expect(evt.tool_input?.file_path).toBe('/a/b.ts');
+    expect(evt.tool_input?.extra).toBe(1);
+  });
+
+  it('handles UserPromptSubmit hook with user_prompt at top level', () => {
+    const evt = parser.parse(
+      JSON.stringify({
+        hook_type: 'UserPromptSubmit',
+        timestamp: '2026-05-18T00:00:00Z',
+        session_id: 's1',
+        project_path: '/p',
+        user_prompt: 'hi there',
+      })
+    );
+    expect(evt.user_prompt).toBe('hi there');
+    expect(evt.event_id).toMatch(/^[0-9a-f-]{36}$/i);
+  });
+});