@winspan/claude-forge 8.50.6 → 8.51.1

package/tests/unit/hooks/resolve-project-path.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Safety-net unit tests for the bash function `resolve_project_path` in
+ * `src/hooks/hook-lib.sh`.
+ *
+ * We invoke bash directly through `child_process.execSync`, sourcing the lib
+ * and calling the function with various inputs. Each fixture is created under
+ * a per-test scratch directory in $TMPDIR (or /tmp) and cleaned up afterwards.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const HOOK_LIB = path.resolve(__dirname, '../../../src/hooks/hook-lib.sh');
+
+/**
+ * Invoke `resolve_project_path` and return its stdout (the resolved path).
+ * Throws if the bash invocation itself fails.
+ */
+function callResolve(input: string, options: { cwd?: string } = {}): string {
+  // Use a single-quoted bash command body to avoid shell quoting hell;
+  // pass the input as $1 to the inner function so we don't need to escape it.
+  const cmd = `bash -c 'source "$1" && resolve_project_path "$2"' _ "${HOOK_LIB}" "${input}"`;
+  return execSync(cmd, {
+    cwd: options.cwd ?? process.cwd(),
+    encoding: 'utf-8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).toString();
+}
+
+describe('hook-lib.sh :: resolve_project_path', () => {
+  let scratch: string;
+  let repoRoot: string;
+  let nestedDir: string;
+  let worktreeRoot: string;
+  let nonGitDir: string;
+
+  beforeAll(() => {
+    scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-resolve-'));
+
+    // Fixture 1: standard git repo with .git as a directory
+    repoRoot = path.join(scratch, 'repo');
+    nestedDir = path.join(repoRoot, 'a', 'b', 'c');
+    fs.mkdirSync(nestedDir, { recursive: true });
+    fs.mkdirSync(path.join(repoRoot, '.git'));
+
+    // Fixture 2: git worktree where .git is a regular file
+    worktreeRoot = path.join(scratch, 'worktree');
+    fs.mkdirSync(path.join(worktreeRoot, 'src'), { recursive: true });
+    fs.writeFileSync(
+      path.join(worktreeRoot, '.git'),
+      'gitdir: /tmp/somewhere/else\n',
+    );
+
+    // Fixture 3: a plain directory with no git ancestor anywhere up to scratch
+    nonGitDir = path.join(scratch, 'plain', 'x', 'y');
+    fs.mkdirSync(nonGitDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    fs.rmSync(scratch, { recursive: true, force: true });
+  });
+
+  it('case 1: resolves a deeply nested git child dir to repo root', () => {
+    const out = callResolve(nestedDir);
+    expect(out).toBe(repoRoot);
+  });
+
+  it('case 2: returns input cwd unchanged when no .git is found upstream', () => {
+    // To make this test robust we point HOME-ish ancestor away from any real
+    // repo by passing the fixture directly. Even if /tmp ancestors had .git
+    // somewhere, the guard caps at 64 levels. Here scratch lives in /tmp and
+    // has no .git, so the function should fall back to the input.
+    const out = callResolve(nonGitDir);
+    expect(out).toBe(nonGitDir);
+  });
+
+  it('case 3: empty input falls back to $PWD of the invoking shell', () => {
+    // We invoke bash with cwd=repoRoot/a so $PWD is that path and there IS a
+    // git ancestor — it should still resolve to repoRoot because empty input
+    // triggers `dir=$PWD` and then upstream search succeeds.
+    // Note: on macOS /tmp and /var are symlinked to /private/tmp /private/var,
+    // and bash's $PWD reflects the resolved path. We compare against realpath
+    // so the test is portable.
+    const startCwd = path.join(repoRoot, 'a');
+    const out = callResolve('', { cwd: startCwd });
+    expect(out).toBe(fs.realpathSync(repoRoot));
+  });
+
+  it('case 4: recognises git worktree (.git is a file, not a directory)', () => {
+    const sub = path.join(worktreeRoot, 'src');
+    const out = callResolve(sub);
+    expect(out).toBe(worktreeRoot);
+  });
+
+  it('case 5: walking all the way up without finding .git returns the original input', () => {
+    // /nonexistent/deeply/nested has no .git anywhere up to /
+    const out = callResolve('/nonexistent/deeply/nested');
+    expect(out).toBe('/nonexistent/deeply/nested');
+  });
+
+  it('case 6: simulates hook INPUT JSON with cwd pointing to nested dir', () => {
+    // Mirrors what a real hook does:
+    //   RAW_CWD=$(echo "$INPUT" | jq -r '.cwd // ""')
+    //   PROJECT_PATH=$(resolve_project_path "${RAW_CWD:-$PWD}")
+    // We just test resolve_project_path with the cwd extracted from such JSON.
+    const extractedCwd = nestedDir; // simulates jq result for cwd in fixture repo
+    const out = callResolve(extractedCwd);
+    expect(out).toBe(repoRoot);
+  });
+
+  it('case 7: hook INPUT with empty cwd field falls back to shell $PWD (repoRoot)', () => {
+    // When jq returns "" for .cwd, bash sets RAW_CWD="" and calls
+    // resolve_project_path "${RAW_CWD:-$PWD}" — effectively resolve_project_path ""
+    // with bash cwd=repoRoot/a, so $PWD-based lookup should find repoRoot.
+    const startCwd = path.join(repoRoot, 'a');
+    const out = callResolve('', { cwd: startCwd });
+    expect(out).toBe(fs.realpathSync(repoRoot));
+  });
+});

package/tests/unit/socket-server.test.ts

@@ -0,0 +1,183 @@
+/**
+ * SocketServer behavior tests
+ *
+ * 重点验证 L3 性能修复：buffer 分片到达时，仅在遇到换行符后才解析，
+ * 避免大事件每个 chunk 都跑一次完整 JSON.parse 的 N² 行为。
+ */
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+import { SocketServer } from '../../src/daemon/server.js';
+import { EventParser } from '../../src/daemon/event-parser.js';
+
+function makeSockPath(): string {
+  const name = `forge-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.sock`;
+  return path.join(os.tmpdir(), name);
+}
+
+function makeEvent(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    hook_type: 'PostToolUse',
+    timestamp: new Date().toISOString(),
+    session_id: 'test-session',
+    project_path: '/tmp/test',
+    tool_name: 'Read',
+    ...overrides,
+  };
+}
+
+function sendOnSocket(sockPath: string, chunks: string[], delayMs = 5): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const client = net.createConnection(sockPath);
+    let response = '';
+    client.on('connect', async () => {
+      for (const chunk of chunks) {
+        client.write(chunk);
+        if (delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
+      }
+    });
+    client.on('data', (data) => {
+      response += data.toString();
+    });
+    client.on('end', () => resolve(response));
+    client.on('close', () => resolve(response));
+    client.on('error', reject);
+  });
+}
+
+describe('SocketServer — L3 chunked-parse behavior', () => {
+  const servers: SocketServer[] = [];
+  const sockPaths: string[] = [];
+
+  afterEach(async () => {
+    for (const s of servers) await s.close();
+    servers.length = 0;
+    for (const p of sockPaths) {
+      try { fs.unlinkSync(p); } catch { /* ignore */ }
+    }
+    sockPaths.length = 0;
+  });
+
+  it('parses a complete single-chunk message (with trailing newline)', async () => {
+    const sockPath = makeSockPath();
+    sockPaths.push(sockPath);
+
+    const handler = vi.fn().mockReturnValue({ allow: true });
+    const server = new SocketServer(sockPath, handler);
+    servers.push(server);
+    await new Promise((r) => setTimeout(r, 30));
+
+    const event = makeEvent();
+    const payload = JSON.stringify(event) + '\n';
+    await sendOnSocket(sockPath, [payload]);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    const passed = handler.mock.calls[0][0];
+    expect(passed.hook_type).toBe('PostToolUse');
+    expect(passed.session_id).toBe('test-session');
+  });
+
+  it('parses a large message split across many chunks WITHOUT per-chunk JSON.parse', async () => {
+    const sockPath = makeSockPath();
+    sockPaths.push(sockPath);
+
+    // 监视 JSON.parse —— 用于断言不再 N²（不能为每个 chunk 都 parse 一次）
+    const parseSpy = vi.spyOn(JSON, 'parse');
+
+    const handler = vi.fn().mockReturnValue({ allow: true });
+    const server = new SocketServer(sockPath, handler);
+    servers.push(server);
+    await new Promise((r) => setTimeout(r, 30));
+
+    // 构造大事件（约 50KB tool_output），分成 ~20 个 chunk 喂入
+    const bigOutput = 'x'.repeat(50_000);
+    const event = makeEvent({ tool_output: { data: bigOutput } });
+    const payload = JSON.stringify(event) + '\n';
+    const chunkSize = Math.ceil(payload.length / 20);
+    const chunks: string[] = [];
+    for (let i = 0; i < payload.length; i += chunkSize) {
+      chunks.push(payload.slice(i, i + chunkSize));
+    }
+    expect(chunks.length).toBeGreaterThan(10);
+
+    const callsBefore = parseSpy.mock.calls.length;
+    await sendOnSocket(sockPath, chunks, 2);
+    const callsAfter = parseSpy.mock.calls.length;
+
+    // 关键断言：handler 必须收到完整事件
+    expect(handler).toHaveBeenCalledTimes(1);
+
+    // 关键断言：JSON.parse 调用次数远少于 chunk 数（旧代码会 ≈ chunks.length 次）
+    // 现在应该只有：可能 1 次（无 auth 时）或 2 次（有 auth 时——auth 检查 + EventParser）
+    const parseDelta = callsAfter - callsBefore;
+    expect(parseDelta).toBeLessThanOrEqual(3);
+    expect(parseDelta).toBeLessThan(chunks.length); // 强对比旧 N² 行为
+
+    parseSpy.mockRestore();
+  });
+
+  it('rejects oversized buffer that never sees a newline', async () => {
+    const sockPath = makeSockPath();
+    sockPaths.push(sockPath);
+
+    const handler = vi.fn();
+    const server = new SocketServer(sockPath, handler);
+    servers.push(server);
+    await new Promise((r) => setTimeout(r, 30));
+
+    // 600KB 无换行 —— 必须超过 MAX_BUFFER_SIZE (512KB) 并被丢弃
+    // 注意：服务端 destroy 后客户端继续 write 会触发 EPIPE，要容错
+    const oversized = 'a'.repeat(600 * 1024);
+    await new Promise<void>((resolve) => {
+      const client = net.createConnection(sockPath);
+      client.on('error', () => { /* EPIPE 预期 */ });
+      client.on('close', () => resolve());
+      client.on('connect', () => {
+        client.write(oversized, () => {
+          // 给服务端处理时间
+          setTimeout(() => client.destroy(), 80);
+        });
+      });
+    });
+
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('uses fallback parse on socket end() for messages without trailing newline', async () => {
+    const sockPath = makeSockPath();
+    sockPaths.push(sockPath);
+
+    const handler = vi.fn().mockReturnValue({ allow: true });
+    const server = new SocketServer(sockPath, handler);
+    servers.push(server);
+    await new Promise((r) => setTimeout(r, 30));
+
+    // 无换行结尾 —— 走 socket.end() 兜底
+    const event = makeEvent();
+    const payload = JSON.stringify(event);
+    await new Promise<void>((resolve, reject) => {
+      const client = net.createConnection(sockPath);
+      client.on('connect', () => {
+        client.end(payload); // 写完即关闭：触发 server 的 'end' 事件
+      });
+      client.on('close', () => resolve());
+      client.on('error', reject);
+    });
+    // 等 server 端处理完
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('EventParser — sanity', () => {
+  it('parses a valid event JSON', () => {
+    const parser = new EventParser();
+    const raw = JSON.stringify(makeEvent());
+    const out = parser.parse(raw);
+    expect(out.session_id).toBe('test-session');
+    expect(out.hook_type).toBe('PostToolUse');
+  });
+});

package/tests/unit/storage/event-operations-aggregates.test.ts

@@ -0,0 +1,342 @@
+/**
+ * H2: EventOperations 新增 aggregate / count / query 方法测试
+ *
+ * 覆盖 11 个方法：
+ *   countAllEvents
+ *   aggregateToolUsage（含 hook_type 过滤）
+ *   aggregateDailyEventCounts
+ *   aggregateHookTypeBySession
+ *   aggregateAgentTypeBySession
+ *   aggregateToolUsageBySession
+ *   countActiveDays
+ *   aggregateOverviewByRange
+ *   queryDistinctProjects
+ *   aggregateToolFailureRate
+ *   queryFileEditInputs
+ *   queryEventsByTimeRange
+ */
+
+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 type { ForgeEvent } from '../../../src/core/types.js';
+
+describe('EventOperations H2 aggregates', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-h2-events-'));
+    storage = new SQLiteStorage(join(tmp, 'data.db'));
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  function makeEvent(overrides: Partial<ForgeEvent>): ForgeEvent {
+    return {
+      session_id: 's1',
+      project_path: '/tmp/proj',
+      timestamp: '2026-05-10T10:00:00.000Z',
+      hook_type: 'PreToolUse',
+      ...overrides,
+    };
+  }
+
+  // ── countAllEvents ─────────────────────────────────────────────────
+  describe('countAllEvents', () => {
+    it('空表返回 0', () => {
+      expect(storage.countAllEvents()).toBe(0);
+    });
+    it('多条事件返回总数', () => {
+      storage.writeEvent(makeEvent({ session_id: 'a' }));
+      storage.writeEvent(makeEvent({ session_id: 'b' }));
+      storage.writeEvent(makeEvent({ session_id: 'c' }));
+      expect(storage.countAllEvents()).toBe(3);
+    });
+  });
+
+  // ── aggregateToolUsage ─────────────────────────────────────────────
+  describe('aggregateToolUsage', () => {
+    it('空表返回空数组', () => {
+      expect(storage.aggregateToolUsage()).toEqual([]);
+    });
+    it('按 count 降序，跳过空 tool_name', () => {
+      storage.writeEvent(makeEvent({ tool_name: 'Bash' }));
+      storage.writeEvent(makeEvent({ tool_name: 'Bash' }));
+      storage.writeEvent(makeEvent({ tool_name: 'Read' }));
+      storage.writeEvent(makeEvent({ hook_type: 'UserPromptSubmit' })); // null tool_name
+      const r = storage.aggregateToolUsage();
+      expect(r).toEqual([
+        { tool_name: 'Bash', count: 2 },
+        { tool_name: 'Read', count: 1 },
+      ]);
+    });
+    it('hook_type 过滤只统计指定类型', () => {
+      storage.writeEvent(makeEvent({ tool_name: 'Bash', hook_type: 'PreToolUse' }));
+      storage.writeEvent(makeEvent({ tool_name: 'Bash', hook_type: 'PostToolUse' }));
+      storage.writeEvent(makeEvent({ tool_name: 'Read', hook_type: 'PreToolUse' }));
+      const r = storage.aggregateToolUsage({ hook_type: 'PreToolUse' });
+      expect(r.find(x => x.tool_name === 'Bash')?.count).toBe(1);
+      expect(r.find(x => x.tool_name === 'Read')?.count).toBe(1);
+    });
+    it('since 过滤排除早期事件', () => {
+      storage.writeEvent(makeEvent({ tool_name: 'Bash', timestamp: '2026-01-01T00:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ tool_name: 'Bash', timestamp: '2026-05-10T00:00:00.000Z', session_id: 's2' }));
+      const r = storage.aggregateToolUsage({ since: '2026-03-01T00:00:00.000Z' });
+      expect(r).toEqual([{ tool_name: 'Bash', count: 1 }]);
+    });
+  });
+
+  // ── aggregateDailyEventCounts ──────────────────────────────────────
+  describe('aggregateDailyEventCounts', () => {
+    it('按 date 分组并升序', () => {
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-10T10:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-10T15:00:00.000Z', session_id: 's2' }));
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-11T10:00:00.000Z', session_id: 's3' }));
+      const r = storage.aggregateDailyEventCounts({ since: '2026-05-01T00:00:00.000Z' });
+      expect(r).toEqual([
+        { date: '2026-05-10', count: 2 },
+        { date: '2026-05-11', count: 1 },
+      ]);
+    });
+    it('until 过滤排除上界', () => {
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-10T10:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-15T10:00:00.000Z', session_id: 's2' }));
+      const r = storage.aggregateDailyEventCounts({
+        since: '2026-05-01T00:00:00.000Z',
+        until: '2026-05-12T00:00:00.000Z',
+      });
+      expect(r).toEqual([{ date: '2026-05-10', count: 1 }]);
+    });
+  });
+
+  // ── aggregateHookTypeBySession ─────────────────────────────────────
+  describe('aggregateHookTypeBySession', () => {
+    it('空表返回空', () => {
+      expect(storage.aggregateHookTypeBySession('nope')).toEqual([]);
+    });
+    it('只统计指定 session 的 hook_type', () => {
+      storage.writeEvent(makeEvent({ session_id: 'a', hook_type: 'PreToolUse' }));
+      storage.writeEvent(makeEvent({ session_id: 'a', hook_type: 'PostToolUse' }));
+      storage.writeEvent(makeEvent({ session_id: 'a', hook_type: 'PreToolUse' }));
+      storage.writeEvent(makeEvent({ session_id: 'b', hook_type: 'PreToolUse' }));
+      const r = storage.aggregateHookTypeBySession('a');
+      const map = Object.fromEntries(r.map(x => [x.hook_type, x.count]));
+      expect(map).toEqual({ PreToolUse: 2, PostToolUse: 1 });
+    });
+  });
+
+  // ── aggregateAgentTypeBySession ────────────────────────────────────
+  describe('aggregateAgentTypeBySession', () => {
+    it('json_extract subagent_type 并分组', () => {
+      storage.writeEvent(makeEvent({
+        session_id: 'a',
+        tool_name: 'Task',
+        tool_input: { subagent_type: 'researcher' },
+      }));
+      storage.writeEvent(makeEvent({
+        session_id: 'a',
+        tool_name: 'Task',
+        tool_input: { subagent_type: 'researcher' },
+      }));
+      storage.writeEvent(makeEvent({
+        session_id: 'a',
+        tool_name: 'Agent',
+        tool_input: { subagent_type: 'coder' },
+      }));
+      // 非 Agent/Task 不应被纳入
+      storage.writeEvent(makeEvent({
+        session_id: 'a',
+        tool_name: 'Bash',
+        tool_input: { foo: 'bar' },
+      }));
+      const r = storage.aggregateAgentTypeBySession('a');
+      const map = Object.fromEntries(r.map(x => [x.agent_type, x.count]));
+      expect(map.researcher).toBe(2);
+      expect(map.coder).toBe(1);
+    });
+  });
+
+  // ── aggregateToolUsageBySession ────────────────────────────────────
+  describe('aggregateToolUsageBySession', () => {
+    it('按 session_id 统计 tool_name', () => {
+      storage.writeEvent(makeEvent({ session_id: 'a', tool_name: 'Bash' }));
+      storage.writeEvent(makeEvent({ session_id: 'a', tool_name: 'Bash' }));
+      storage.writeEvent(makeEvent({ session_id: 'a', tool_name: 'Read' }));
+      storage.writeEvent(makeEvent({ session_id: 'b', tool_name: 'Bash' }));
+      const r = storage.aggregateToolUsageBySession('a');
+      expect(r).toEqual([
+        { tool_name: 'Bash', count: 2 },
+        { tool_name: 'Read', count: 1 },
+      ]);
+    });
+  });
+
+  // ── countActiveDays ────────────────────────────────────────────────
+  describe('countActiveDays', () => {
+    it('distinct date 计数', () => {
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-10T10:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-10T11:00:00.000Z', session_id: 's2' }));
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-11T10:00:00.000Z', session_id: 's3' }));
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-12T10:00:00.000Z', session_id: 's4' }));
+      expect(storage.countActiveDays({ since: '2026-05-01T00:00:00.000Z' })).toBe(3);
+    });
+    it('空范围返回 0', () => {
+      expect(storage.countActiveDays({ since: '2026-05-01T00:00:00.000Z' })).toBe(0);
+    });
+  });
+
+  // ── aggregateOverviewByRange ───────────────────────────────────────
+  describe('aggregateOverviewByRange', () => {
+    it('返回 event/session/day 复合计数', () => {
+      storage.writeEvent(makeEvent({ session_id: 'a', timestamp: '2026-05-10T10:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ session_id: 'a', timestamp: '2026-05-10T11:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ session_id: 'b', timestamp: '2026-05-11T10:00:00.000Z' }));
+      const r = storage.aggregateOverviewByRange({
+        since: '2026-05-01T00:00:00.000Z',
+        until: '2026-06-01T00:00:00.000Z',
+      });
+      expect(r.event_count).toBe(3);
+      expect(r.session_count).toBe(2);
+      expect(r.day_count).toBe(2);
+    });
+    it('空表返回全 0', () => {
+      const r = storage.aggregateOverviewByRange({
+        since: '2026-05-01T00:00:00.000Z',
+        until: '2026-06-01T00:00:00.000Z',
+      });
+      expect(r).toEqual({ event_count: 0, session_count: 0, day_count: 0 });
+    });
+  });
+
+  // ── queryDistinctProjects ──────────────────────────────────────────
+  describe('queryDistinctProjects', () => {
+    it('返回 distinct project_path', () => {
+      storage.writeEvent(makeEvent({ project_path: '/a' }));
+      storage.writeEvent(makeEvent({ project_path: '/a', session_id: 's2' }));
+      storage.writeEvent(makeEvent({ project_path: '/b', session_id: 's3' }));
+      const r = storage.queryDistinctProjects({
+        since: '2026-05-01T00:00:00.000Z',
+        until: '2026-06-01T00:00:00.000Z',
+      });
+      expect(r.sort()).toEqual(['/a', '/b']);
+    });
+  });
+
+  // ── aggregateToolFailureRate ───────────────────────────────────────
+  describe('aggregateToolFailureRate', () => {
+    it('LIKE %error% 三个分支正确识别失败', () => {
+      // PostToolUse with error
+      storage.writeEvent(makeEvent({
+        hook_type: 'PostToolUse',
+        tool_name: 'Bash',
+        tool_output: { error: 'oops' }, // becomes '"error":"oops"' in JSON
+      }));
+      storage.writeEvent(makeEvent({
+        hook_type: 'PostToolUse',
+        tool_name: 'Bash',
+        tool_output: { is_error: true },
+        session_id: 's2',
+      }));
+      storage.writeEvent(makeEvent({
+        hook_type: 'PostToolUse',
+        tool_name: 'Bash',
+        tool_output: { isError: true },
+        session_id: 's3',
+      }));
+      // PostToolUse OK
+      storage.writeEvent(makeEvent({
+        hook_type: 'PostToolUse',
+        tool_name: 'Bash',
+        tool_output: { result: 'ok' },
+        session_id: 's4',
+      }));
+      // PreToolUse should not count
+      storage.writeEvent(makeEvent({
+        hook_type: 'PreToolUse',
+        tool_name: 'Bash',
+        tool_output: { error: 'should not count' },
+        session_id: 's5',
+      }));
+
+      const r = storage.aggregateToolFailureRate({
+        since: '2026-05-01T00:00:00.000Z',
+        until: '2026-06-01T00:00:00.000Z',
+      });
+      expect(r.post_total).toBe(4);
+      expect(r.failed).toBe(3);
+    });
+    it('空范围返回 0/0', () => {
+      const r = storage.aggregateToolFailureRate({
+        since: '2026-05-01T00:00:00.000Z',
+        until: '2026-06-01T00:00:00.000Z',
+      });
+      expect(r).toEqual({ post_total: 0, failed: 0 });
+    });
+  });
+
+  // ── queryFileEditInputs ────────────────────────────────────────────
+  describe('queryFileEditInputs', () => {
+    it('IN 展开多个 tool_name', () => {
+      storage.writeEvent(makeEvent({
+        hook_type: 'PreToolUse',
+        tool_name: 'Edit',
+        tool_input: { file_path: '/a.ts' },
+      }));
+      storage.writeEvent(makeEvent({
+        hook_type: 'PreToolUse',
+        tool_name: 'Write',
+        tool_input: { file_path: '/b.ts' },
+        session_id: 's2',
+      }));
+      storage.writeEvent(makeEvent({
+        hook_type: 'PreToolUse',
+        tool_name: 'Bash', // not file edit
+        tool_input: { command: 'ls' },
+        session_id: 's3',
+      }));
+      const r = storage.queryFileEditInputs({
+        since: '2026-05-01T00:00:00.000Z',
+        until: '2026-06-01T00:00:00.000Z',
+        tool_names: ['Edit', 'Write', 'MultiEdit'],
+      });
+      expect(r.length).toBe(2);
+      expect(r.map(x => JSON.parse(x.tool_input).file_path).sort()).toEqual(['/a.ts', '/b.ts']);
+    });
+    it('空 tool_names 返回空', () => {
+      storage.writeEvent(makeEvent({ tool_name: 'Edit', tool_input: { file_path: '/a.ts' } }));
+      expect(storage.queryFileEditInputs({
+        since: '2026-05-01T00:00:00.000Z',
+        until: '2026-06-01T00:00:00.000Z',
+        tool_names: [],
+      })).toEqual([]);
+    });
+  });
+
+  // ── queryEventsByTimeRange ─────────────────────────────────────────
+  describe('queryEventsByTimeRange', () => {
+    it('返回 [since, until) 区间事件，升序', () => {
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-10T10:00:00.000Z', tool_name: 'A' }));
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-11T10:00:00.000Z', tool_name: 'B', session_id: 's2' }));
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-12T10:00:00.000Z', tool_name: 'C', session_id: 's3' }));
+      const r = storage.queryEventsByTimeRange({
+        since: '2026-05-10T00:00:00.000Z',
+        until: '2026-05-12T00:00:00.000Z',
+      });
+      expect(r.length).toBe(2);
+      expect(r[0].tool_name).toBe('A');
+      expect(r[1].tool_name).toBe('B');
+    });
+    it('未指定 until 返回 since 起始的全部', () => {
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-10T10:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ timestamp: '2026-05-20T10:00:00.000Z', session_id: 's2' }));
+      const r = storage.queryEventsByTimeRange({ since: '2026-05-15T00:00:00.000Z' });
+      expect(r.length).toBe(1);
+    });
+  });
+});