@winspan/claude-forge 8.50.6 → 8.51.1

package/tests/unit/storage/migration-idempotent.test.ts

@@ -0,0 +1,304 @@
+/**
+ * H4: migration idempotent
+ *
+ * 覆盖 schema.sql 与 base.ts::runMigrations 的去重边界：
+ *   1. baseline — 老库缺索引/列，SQLiteStorage 启动后必须补齐
+ *   2. 新库无害 — 走完整 schema.sql 后，再 new SQLiteStorage 不抛错，不重复创建
+ *   3. idempotent — 连续 new 多次，索引/列数量不变
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import Database from 'better-sqlite3';
+import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import { logger } from '../../../src/core/utils/logger.js';
+
+// 与 base.ts::initSchema 解析方式一致
+const THIS_DIR = dirname(fileURLToPath(import.meta.url));
+const SCHEMA_PATH = join(THIS_DIR, '../../../src/core/storage/schema.sql');
+
+function listIndexes(db: Database.Database): Set<string> {
+  const rows = db
+    .prepare(`SELECT name FROM sqlite_master WHERE type='index' AND name NOT LIKE 'sqlite_%'`)
+    .all() as Array<{ name: string }>;
+  return new Set(rows.map(r => r.name));
+}
+
+function listColumns(db: Database.Database, table: string): Set<string> {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return new Set(rows.map(r => r.name));
+}
+
+/**
+ * 写入一份"老库"——故意删掉若干索引，模拟存量库。
+ * 列定义保持与最新 schema.sql 等价（不缺列），因为 schema.sql 的
+ * CREATE TABLE IF NOT EXISTS 在表已存在时不会补列；同时 schema.sql 中
+ * 多个索引（如 idx_skill_invocations_workflow）依赖 workflow 列存在。
+ * 故"老库缺列"测试见单独 case，与"老库缺索引"分开覆盖，避免初始化期失败。
+ */
+function execLegacySchemaMissingIndexes(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE events (
+      event_id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      project_path TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      hook_type TEXT NOT NULL,
+      tool_name TEXT,
+      tool_input TEXT,
+      tool_output TEXT,
+      user_prompt TEXT,
+      ai_response TEXT,
+      distilled INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE sessions (
+      session_id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      first_prompt TEXT,
+      start_time TEXT NOT NULL,
+      end_time TEXT,
+      last_event_time TEXT,
+      event_count INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE injections (
+      id TEXT PRIMARY KEY,
+      event_id TEXT,
+      session_id TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      source_handler TEXT NOT NULL,
+      injection_type TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE tasks (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT,
+      start_time TEXT NOT NULL,
+      end_time TEXT,
+      status TEXT DEFAULT 'active',
+      event_count INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE task_events (
+      task_id TEXT NOT NULL,
+      event_id TEXT NOT NULL,
+      PRIMARY KEY (task_id, event_id)
+    );
+
+    CREATE TABLE routing_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      route_request_id TEXT,
+      project_path TEXT NOT NULL,
+      ts INTEGER NOT NULL,
+      prompt TEXT NOT NULL,
+      intent_json TEXT NOT NULL,
+      routed_to_type TEXT,
+      routed_to_name TEXT,
+      is_forced INTEGER DEFAULT 0,
+      obeyed INTEGER,
+      classification_ms INTEGER,
+      fallback_used INTEGER DEFAULT 0,
+      refusal_reason TEXT,
+      first_tool_name TEXT,
+      first_tool_ts INTEGER,
+      completed_ts INTEGER,
+      total_execution_ms INTEGER,
+      completion_reason TEXT,
+      downstream_task_chain TEXT,
+      injection_version TEXT,
+      experiment_id TEXT,
+      experiment_group TEXT,
+      skill_confidence REAL,
+      skill_source TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE token_usage (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      timestamp INTEGER NOT NULL,
+      input_tokens INTEGER NOT NULL,
+      output_tokens INTEGER NOT NULL,
+      total_tokens INTEGER NOT NULL,
+      model TEXT,
+      tool_name TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE skill_invocations (
+      id TEXT PRIMARY KEY,
+      route_request_id TEXT,
+      session_id TEXT NOT NULL,
+      agent_id TEXT,
+      skill_id TEXT NOT NULL,
+      invocation_type TEXT NOT NULL,
+      reason TEXT,
+      workflow TEXT,
+      phase TEXT,
+      feature_slug TEXT,
+      artifact_path TEXT,
+      depth INTEGER DEFAULT 0,
+      success INTEGER DEFAULT 1,
+      error TEXT,
+      timestamp INTEGER NOT NULL,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    -- 故意不创建以下任何索引（migration 必须补齐）
+  `);
+}
+
+/**
+ * 老库——只缺 sessions.first_prompt 列（其他列齐全 + 完整索引）。
+ * 单独 case，验证 addColumnIfMissing 补齐。
+ */
+function execLegacySchemaMissingFirstPrompt(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE sessions (
+      session_id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      start_time TEXT NOT NULL,
+      end_time TEXT,
+      last_event_time TEXT,
+      event_count INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+  `);
+}
+
+describe('H4: storage migration idempotent', () => {
+  let tmp: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-h4-migration-'));
+    dbPath = join(tmp, 'data.db');
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('baseline (缺索引): 老库索引齐缺，SQLiteStorage 启动后补齐全部 migration 索引', () => {
+    // 1) 手工写入只缺索引的旧 schema
+    const raw = new Database(dbPath);
+    execLegacySchemaMissingIndexes(raw);
+    const beforeIdx = listIndexes(raw);
+    expect(beforeIdx.has('idx_routing_events_type_ts')).toBe(false);
+    expect(beforeIdx.has('idx_skill_invocations_workflow')).toBe(false);
+    expect(beforeIdx.has('idx_skill_invocations_feature')).toBe(false);
+    expect(beforeIdx.has('idx_sessions_start_time')).toBe(false);
+    expect(beforeIdx.has('idx_events_session_ts')).toBe(false);
+    raw.close();
+
+    // 2) 用 SQLiteStorage 打开 → 触发 schema.sql + runMigrations
+    const storage = new SQLiteStorage(dbPath);
+    const db = storage.getDatabase();
+
+    // 3) 关键索引全部补齐（涵盖 spec 重复清单中所有 migration-only / 双写索引）
+    const idx = listIndexes(db);
+    const expected = [
+      'idx_sessions_start_time',
+      'idx_events_session_ts',
+      'idx_routing_events_session_ts',
+      'idx_skill_invocations_session_ts',
+      'idx_routing_events_obeyed_ts',
+      'idx_events_session_hook',
+      'idx_injections_session_handler',
+      'idx_routing_events_type_ts',
+      'idx_skill_invocations_workflow',
+      'idx_skill_invocations_feature',
+    ];
+    for (const name of expected) {
+      expect(idx.has(name), `expected index ${name} to exist after migration`).toBe(true);
+    }
+
+    storage.close();
+  });
+
+  it('baseline (缺列): 老库缺 sessions.first_prompt，migration ALTER 补齐', () => {
+    const raw = new Database(dbPath);
+    execLegacySchemaMissingFirstPrompt(raw);
+    expect(listColumns(raw, 'sessions').has('first_prompt')).toBe(false);
+    raw.close();
+
+    const storage = new SQLiteStorage(dbPath);
+    const db = storage.getDatabase();
+
+    // first_prompt 列由 addColumnIfMissing 补齐
+    expect(listColumns(db, 'sessions').has('first_prompt')).toBe(true);
+
+    storage.close();
+  });
+
+  it('新库（完整 schema.sql 初始化）再启动 SQLiteStorage：migration 不会重复创建索引', () => {
+    // 1) 用完整 schema.sql 初始化（模拟 base.initSchema 已跑完，sqlite-base 同样这么干）
+    expect(existsSync(SCHEMA_PATH)).toBe(true);
+    const schemaSql = readFileSync(SCHEMA_PATH, 'utf-8');
+    const raw = new Database(dbPath);
+    raw.exec(schemaSql);
+    const indexesAfterSchema = listIndexes(raw);
+    raw.close();
+
+    // 2) 监听 logger.debug，统计"migration created idx_xxx"次数
+    const debugSpy = vi.spyOn(logger, 'debug').mockImplementation(() => {});
+    const warnSpy = vi.spyOn(logger, 'warn').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(logger, 'error').mockImplementation(() => {});
+
+    // 3) new SQLiteStorage → runMigrations 应当跳过所有 createIndexIfMissing
+    const storage = new SQLiteStorage(dbPath);
+
+    const createdCalls = debugSpy.mock.calls.filter(
+      args => typeof args[0] === 'string' && args[0].includes('migration created'),
+    );
+    expect(createdCalls.length).toBe(0);
+
+    // 不应有 warn/error
+    expect(warnSpy).not.toHaveBeenCalled();
+    expect(errorSpy).not.toHaveBeenCalled();
+
+    // 索引集合相比 schema.sql 初始化后无变化
+    const indexesAfterMigration = listIndexes(storage.getDatabase());
+    expect(indexesAfterMigration).toEqual(indexesAfterSchema);
+
+    storage.close();
+  });
+
+  it('idempotent: 连续多次 new SQLiteStorage 不改变索引/列数量', () => {
+    const snapshots: Array<{ idx: Set<string>; cols: Set<string> }> = [];
+
+    for (let i = 0; i < 3; i++) {
+      const storage = new SQLiteStorage(dbPath);
+      const db = storage.getDatabase();
+      snapshots.push({
+        idx: listIndexes(db),
+        cols: listColumns(db, 'skill_invocations'),
+      });
+      storage.close();
+    }
+
+    // 索引集合在三次之间完全一致
+    expect(snapshots[0].idx).toEqual(snapshots[1].idx);
+    expect(snapshots[1].idx).toEqual(snapshots[2].idx);
+
+    // skill_invocations 列集合在三次之间一致
+    expect(snapshots[0].cols).toEqual(snapshots[1].cols);
+    expect(snapshots[1].cols).toEqual(snapshots[2].cols);
+  });
+});

package/tests/unit/storage/routing-aggregates.test.ts

@@ -0,0 +1,276 @@
+/**
+ * H1 storage aggregates: routing_events
+ *
+ * 覆盖：
+ *   - 空表返回 0
+ *   - 混合 obeyed=1/0/NULL 的计数
+ *   - since_ts 过滤边界
+ *   - by_agent 排除 obeyed != 1 / routed_to_name IS NULL
+ *   - by_skill_routed 只统计 routed_to_type='skill'
+ *   - aggregateRoutingTrendByDay 跨日聚合（UTC）
+ *   - ts <= 0 兜底（不应崩，不进入 trend 结果）
+ *   - project_path 过滤
+ */
+
+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';
+
+const SESSION = 'sess-r';
+const PROJECT = '/tmp/p';
+
+describe('storage.aggregateRoutingStats', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-h1-routing-'));
+    storage = new SQLiteStorage(join(tmp, 'data.db'));
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('空表返回全 0 / 空数组', () => {
+    const r = storage.aggregateRoutingStats({ since_ts: 0 });
+    expect(r.total).toBe(0);
+    expect(r.obeyed).toBe(0);
+    expect(r.refused).toBe(0);
+    expect(r.unknown).toBe(0);
+    expect(r.by_type).toEqual([]);
+    expect(r.by_agent).toEqual([]);
+    expect(r.by_skill_routed).toEqual([]);
+  });
+
+  it('混合 obeyed=1/0/NULL 的计数正确', () => {
+    const now = Date.now();
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p1', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'researcher', obeyed: 1,
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p2', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'coder', obeyed: 0,
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p3', intent_json: '{}',
+      routed_to_type: 'skill', routed_to_name: 'tdd', obeyed: null,
+    });
+
+    const r = storage.aggregateRoutingStats({ since_ts: 0 });
+    expect(r.total).toBe(3);
+    expect(r.obeyed).toBe(1);
+    expect(r.refused).toBe(1);
+    expect(r.unknown).toBe(1);
+  });
+
+  it('by_type 分布（含 NULL → "none"）', () => {
+    const now = Date.now();
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'a', intent_json: '{}', routed_to_type: 'agent', routed_to_name: 'x',
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'b', intent_json: '{}', routed_to_type: 'skill', routed_to_name: 'y',
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'c', intent_json: '{}', routed_to_type: null, routed_to_name: null,
+    });
+
+    const r = storage.aggregateRoutingStats({ since_ts: 0 });
+    const map = Object.fromEntries(r.by_type.map(e => [e.type, e.count]));
+    expect(map.agent).toBe(1);
+    expect(map.skill).toBe(1);
+    expect(map.none).toBe(1);
+  });
+
+  it('by_agent 仅含 obeyed=1 且 routed_to_name 非 NULL', () => {
+    const now = Date.now();
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p1', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'researcher', obeyed: 1,
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p2', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'researcher', obeyed: 1,
+    });
+    // obeyed = 0 → 不计入 by_agent
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p3', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'tester', obeyed: 0,
+    });
+    // obeyed = NULL → 不计入 by_agent
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p4', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'planner', obeyed: null,
+    });
+    // routed_to_name NULL → 不计入
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p5', intent_json: '{}',
+      routed_to_type: null, routed_to_name: null, obeyed: 1,
+    });
+
+    const r = storage.aggregateRoutingStats({ since_ts: 0 });
+    expect(r.by_agent).toEqual([{ agent: 'researcher', count: 2 }]);
+  });
+
+  it('by_skill_routed 仅含 routed_to_type=skill 且 routed_to_name 非 NULL', () => {
+    const now = Date.now();
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p1', intent_json: '{}',
+      routed_to_type: 'skill', routed_to_name: 'official-tdd',
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p2', intent_json: '{}',
+      routed_to_type: 'skill', routed_to_name: 'official-tdd',
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p3', intent_json: '{}',
+      routed_to_type: 'skill', routed_to_name: 'debug',
+    });
+    // agent 不计入
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p4', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'researcher',
+    });
+
+    const r = storage.aggregateRoutingStats({ since_ts: 0 });
+    expect(r.by_skill_routed).toEqual([
+      { skill: 'official-tdd', count: 2 },
+      { skill: 'debug', count: 1 },
+    ]);
+  });
+
+  it('since_ts 严格 >= 边界（等于通过 / 小于排除）', () => {
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: 1000,
+      prompt: 'old', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'a', obeyed: 1,
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: 2000,
+      prompt: 'mid', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'a', obeyed: 1,
+    });
+
+    const r1 = storage.aggregateRoutingStats({ since_ts: 2000 });
+    expect(r1.total).toBe(1); // 仅 ts=2000
+
+    const r2 = storage.aggregateRoutingStats({ since_ts: 1500 });
+    expect(r2.total).toBe(1); // 仅 ts=2000
+
+    const r3 = storage.aggregateRoutingStats({ since_ts: 1000 });
+    expect(r3.total).toBe(2);
+  });
+
+  it('project_path 过滤', () => {
+    const now = Date.now();
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: '/proj/a', ts: now,
+      prompt: 'pa', intent_json: '{}', routed_to_type: 'agent', routed_to_name: 'x', obeyed: 1,
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: '/proj/b', ts: now,
+      prompt: 'pb', intent_json: '{}', routed_to_type: 'agent', routed_to_name: 'y', obeyed: 1,
+    });
+
+    const r = storage.aggregateRoutingStats({ since_ts: 0, project_path: '/proj/a' });
+    expect(r.total).toBe(1);
+    expect(r.by_agent).toEqual([{ agent: 'x', count: 1 }]);
+  });
+
+  it('ts <= 0 被 WHERE ts > 0 兜底排除', () => {
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: 0,
+      prompt: 'zero', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'a', obeyed: 1,
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: 1000,
+      prompt: 'ok', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'a', obeyed: 1,
+    });
+
+    const r = storage.aggregateRoutingStats({ since_ts: 0 });
+    // ts=0 被排除
+    expect(r.total).toBe(1);
+  });
+});
+
+describe('storage.aggregateRoutingTrendByDay', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-h1-trend-'));
+    storage = new SQLiteStorage(join(tmp, 'data.db'));
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('空表返回 []', () => {
+    expect(storage.aggregateRoutingTrendByDay({ since_ts: 0 })).toEqual([]);
+  });
+
+  it('跨日聚合（UTC），返回每日 total + skill 计数', () => {
+    // 2026-01-01T00:00:01Z, 01-01T23:00:00Z, 01-02T00:00:01Z
+    const day1 = Date.UTC(2026, 0, 1, 0, 0, 1);   // 2026-01-01
+    const day1b = Date.UTC(2026, 0, 1, 23, 0, 0); // 2026-01-01
+    const day2 = Date.UTC(2026, 0, 2, 0, 0, 1);   // 2026-01-02
+
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: day1,
+      prompt: 'a', intent_json: '{}', routed_to_type: 'agent', routed_to_name: 'x',
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: day1b,
+      prompt: 'b', intent_json: '{}', routed_to_type: 'skill', routed_to_name: 'y',
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: day2,
+      prompt: 'c', intent_json: '{}', routed_to_type: 'skill', routed_to_name: 'y',
+    });
+
+    const trend = storage.aggregateRoutingTrendByDay({ since_ts: 0 });
+    expect(trend).toHaveLength(2);
+    expect(trend[0]).toEqual({ day: '2026-01-01', total: 2, skill: 1 });
+    expect(trend[1]).toEqual({ day: '2026-01-02', total: 1, skill: 1 });
+  });
+
+  it('ts <= 0 不出现在结果中（strftime 兜底）', () => {
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: 0,
+      prompt: 'zero', intent_json: '{}', routed_to_type: 'agent', routed_to_name: 'x',
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: Date.UTC(2026, 0, 1, 0, 0, 0),
+      prompt: 'ok', intent_json: '{}', routed_to_type: 'skill', routed_to_name: 'y',
+    });
+
+    const trend = storage.aggregateRoutingTrendByDay({ since_ts: 0 });
+    expect(trend.every(t => t.day !== null && t.day.length > 0)).toBe(true);
+    expect(trend).toHaveLength(1);
+    expect(trend[0].day).toBe('2026-01-01');
+  });
+});

package/tests/unit/storage/routing.test.ts

@@ -0,0 +1,117 @@
+/**
+ * M7: getRecentPendingRoutingEvent semantics.
+ *
+ * Verifies the "pending only" filter that the PostToolUseHandler relies on
+ * to associate Agent invocations with the still-unfilled routing_event from
+ * the current user prompt (rather than re-overwriting a completed one).
+ */
+
+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';
+
+const PROJECT = '/tmp/m7-proj';
+
+describe('storage.getRecentPendingRoutingEvent', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-m7-routing-'));
+    storage = new SQLiteStorage(join(tmp, 'data.db'));
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('case 1: older obeyed=1 + newer pending → returns newer pending', () => {
+    const sess = 'sess-1';
+    const oldId = storage.writeRoutingEvent({
+      session_id: sess, project_path: PROJECT, ts: 1000,
+      prompt: 'old', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'a', obeyed: 1,
+    });
+    const newId = storage.writeRoutingEvent({
+      session_id: sess, project_path: PROJECT, ts: 2000,
+      prompt: 'new', intent_json: '{}',
+      obeyed: null,
+    });
+
+    const recent = storage.getRecentPendingRoutingEvent(sess);
+    expect(recent).not.toBeNull();
+    expect(recent!.id).toBe(newId);
+    expect(recent!.id).not.toBe(oldId);
+  });
+
+  it('case 2: all events obeyed=1 → returns null', () => {
+    const sess = 'sess-2';
+    storage.writeRoutingEvent({
+      session_id: sess, project_path: PROJECT, ts: 1000,
+      prompt: 'p1', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'a', obeyed: 1,
+    });
+    storage.writeRoutingEvent({
+      session_id: sess, project_path: PROJECT, ts: 2000,
+      prompt: 'p2', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'b', obeyed: 1,
+    });
+
+    expect(storage.getRecentPendingRoutingEvent(sess)).toBeNull();
+  });
+
+  it('case 3: session isolation — pending in another session is ignored', () => {
+    const sessA = 'sess-A';
+    const sessB = 'sess-B';
+    const aId = storage.writeRoutingEvent({
+      session_id: sessA, project_path: PROJECT, ts: 1000,
+      prompt: 'a-pending', intent_json: '{}',
+      obeyed: null,
+    });
+    storage.writeRoutingEvent({
+      session_id: sessB, project_path: PROJECT, ts: 2000,
+      prompt: 'b-pending', intent_json: '{}',
+      obeyed: null,
+    });
+
+    const rA = storage.getRecentPendingRoutingEvent(sessA);
+    expect(rA).not.toBeNull();
+    expect(rA!.id).toBe(aId);
+
+    // Session with no rows at all returns null.
+    expect(storage.getRecentPendingRoutingEvent('sess-none')).toBeNull();
+  });
+
+  it('case 4: single pending row → returns that row', () => {
+    const sess = 'sess-4';
+    const id = storage.writeRoutingEvent({
+      session_id: sess, project_path: PROJECT, ts: 1234,
+      prompt: 'only', intent_json: '{}',
+      obeyed: null,
+    });
+
+    const recent = storage.getRecentPendingRoutingEvent(sess);
+    expect(recent).not.toBeNull();
+    expect(recent!.id).toBe(id);
+  });
+
+  it('legacy getRecentRoutingEvent still returns most-recent regardless of obeyed', () => {
+    const sess = 'sess-legacy';
+    storage.writeRoutingEvent({
+      session_id: sess, project_path: PROJECT, ts: 1000,
+      prompt: 'old-pending', intent_json: '{}', obeyed: null,
+    });
+    const newerCompletedId = storage.writeRoutingEvent({
+      session_id: sess, project_path: PROJECT, ts: 2000,
+      prompt: 'new-completed', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'x', obeyed: 1,
+    });
+
+    const recent = storage.getRecentRoutingEvent(sess);
+    expect(recent).not.toBeNull();
+    expect(recent!.id).toBe(newerCompletedId);
+  });
+});