@winspan/claude-forge 8.51.1 → 8.54.3

package/tests/unit/core/forge-paths.test.ts

@@ -1,99 +0,0 @@
-/**
- * Unit tests for FORGE_PATHS (src/core/constants.ts)
- *
- * Verifies that every path method returns a value prefixed by FORGE_HOME
- * and matches the expected sub-path.
- */
-
-import { describe, it, expect } from 'vitest';
-import { join } from 'node:path';
-import { FORGE_HOME, FORGE_PATHS } from '../../../src/core/constants.js';
-
-describe('FORGE_PATHS', () => {
-  describe('existing methods', () => {
-    it('home() returns FORGE_HOME', () => {
-      expect(FORGE_PATHS.home()).toBe(FORGE_HOME);
-    });
-
-    it('config() returns FORGE_HOME/config.yaml', () => {
-      expect(FORGE_PATHS.config()).toBe(join(FORGE_HOME, 'config.yaml'));
-      expect(FORGE_PATHS.config().startsWith(FORGE_HOME)).toBe(true);
-    });
-
-    it('database() returns FORGE_HOME/data.db', () => {
-      expect(FORGE_PATHS.database()).toBe(join(FORGE_HOME, 'data.db'));
-      expect(FORGE_PATHS.database().startsWith(FORGE_HOME)).toBe(true);
-    });
-
-    it('logs() returns FORGE_HOME/logs', () => {
-      expect(FORGE_PATHS.logs()).toBe(join(FORGE_HOME, 'logs'));
-      expect(FORGE_PATHS.logs().startsWith(FORGE_HOME)).toBe(true);
-    });
-  });
-
-  describe('daemon runtime files', () => {
-    it('daemonSocket() returns FORGE_HOME/daemon.sock', () => {
-      expect(FORGE_PATHS.daemonSocket()).toBe(join(FORGE_HOME, 'daemon.sock'));
-      expect(FORGE_PATHS.daemonSocket().startsWith(FORGE_HOME)).toBe(true);
-    });
-
-    it('daemonPid() returns FORGE_HOME/daemon.pid', () => {
-      expect(FORGE_PATHS.daemonPid()).toBe(join(FORGE_HOME, 'daemon.pid'));
-      expect(FORGE_PATHS.daemonPid().startsWith(FORGE_HOME)).toBe(true);
-    });
-
-    it('daemonToken() returns FORGE_HOME/daemon.token', () => {
-      expect(FORGE_PATHS.daemonToken()).toBe(join(FORGE_HOME, 'daemon.token'));
-      expect(FORGE_PATHS.daemonToken().startsWith(FORGE_HOME)).toBe(true);
-    });
-
-    it('daemonLog() returns FORGE_HOME/daemon.log', () => {
-      expect(FORGE_PATHS.daemonLog()).toBe(join(FORGE_HOME, 'daemon.log'));
-      expect(FORGE_PATHS.daemonLog().startsWith(FORGE_HOME)).toBe(true);
-    });
-
-    it('daemonStdout() returns FORGE_HOME/daemon-stdout.log', () => {
-      expect(FORGE_PATHS.daemonStdout()).toBe(join(FORGE_HOME, 'daemon-stdout.log'));
-      expect(FORGE_PATHS.daemonStdout().startsWith(FORGE_HOME)).toBe(true);
-    });
-
-    it('daemonStderr() returns FORGE_HOME/daemon-stderr.log', () => {
-      expect(FORGE_PATHS.daemonStderr()).toBe(join(FORGE_HOME, 'daemon-stderr.log'));
-      expect(FORGE_PATHS.daemonStderr().startsWith(FORGE_HOME)).toBe(true);
-    });
-  });
-
-  describe('subdirs', () => {
-    it('hooks() returns FORGE_HOME/hooks', () => {
-      expect(FORGE_PATHS.hooks()).toBe(join(FORGE_HOME, 'hooks'));
-      expect(FORGE_PATHS.hooks().startsWith(FORGE_HOME)).toBe(true);
-    });
-
-    it('queue() returns FORGE_HOME/queue', () => {
-      expect(FORGE_PATHS.queue()).toBe(join(FORGE_HOME, 'queue'));
-      expect(FORGE_PATHS.queue().startsWith(FORGE_HOME)).toBe(true);
-    });
-
-    it('queueDead() returns FORGE_HOME/queue/dead', () => {
-      expect(FORGE_PATHS.queueDead()).toBe(join(FORGE_HOME, 'queue', 'dead'));
-      expect(FORGE_PATHS.queueDead().startsWith(FORGE_HOME)).toBe(true);
-    });
-  });
-
-  describe('patchable targets', () => {
-    it('routingYaml() returns FORGE_HOME/routing.yaml', () => {
-      expect(FORGE_PATHS.routingYaml()).toBe(join(FORGE_HOME, 'routing.yaml'));
-      expect(FORGE_PATHS.routingYaml().startsWith(FORGE_HOME)).toBe(true);
-    });
-
-    it("backups('skills') returns FORGE_HOME/backups/skills", () => {
-      expect(FORGE_PATHS.backups('skills')).toBe(join(FORGE_HOME, 'backups', 'skills'));
-      expect(FORGE_PATHS.backups('skills').startsWith(FORGE_HOME)).toBe(true);
-    });
-
-    it("backups('routing') returns FORGE_HOME/backups/routing", () => {
-      expect(FORGE_PATHS.backups('routing')).toBe(join(FORGE_HOME, 'backups', 'routing'));
-      expect(FORGE_PATHS.backups('routing').startsWith(FORGE_HOME)).toBe(true);
-    });
-  });
-});

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

@@ -1,71 +0,0 @@
-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

@@ -1,121 +0,0 @@
-/**
- * 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

@@ -1,202 +0,0 @@
-/**
- * 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

@@ -1,84 +0,0 @@
-/**
- * 单测：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

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