@winspan/claude-forge 8.41.0 → 8.51.0

package/tests/unit/web/routes-events.test.ts

@@ -0,0 +1,101 @@
+/**
+ * Unit tests for /api/events route (list + SSE smoke).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import express, { type Application } from 'express';
+import request from 'supertest';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import { registerEventsRoutes } from '../../../src/web/routes/events.js';
+
+const PROJECT = '/tmp/proj';
+
+function ts(offsetMs = 0): string {
+  return new Date(Date.UTC(2026, 0, 1) + offsetMs).toISOString();
+}
+
+describe('Events Routes', () => {
+  let app: Application;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    app = express();
+    app.use(express.json());
+    registerEventsRoutes(app, { storage });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  describe('GET /api/events', () => {
+    it('returns empty list initially', async () => {
+      const res = await request(app).get('/api/events');
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual([]);
+    });
+
+    it('returns events ordered by timestamp desc', async () => {
+      storage.writeEvent({
+        session_id: 's1', project_path: PROJECT, timestamp: ts(0),
+        hook_type: 'PreToolUse', tool_name: 'Bash',
+      });
+      storage.writeEvent({
+        session_id: 's1', project_path: PROJECT, timestamp: ts(1000),
+        hook_type: 'PreToolUse', tool_name: 'Edit',
+      });
+      const res = await request(app).get('/api/events');
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(2);
+      expect(res.body[0].tool_name).toBe('Edit');
+    });
+
+    it('respects limit query param', async () => {
+      for (let i = 0; i < 5; i++) {
+        storage.writeEvent({
+          session_id: 's1', project_path: PROJECT, timestamp: ts(i * 100),
+          hook_type: 'PreToolUse', tool_name: 'Bash',
+        });
+      }
+      const res = await request(app).get('/api/events').query({ limit: 2 });
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(2);
+    });
+
+    it('filters by session id', async () => {
+      storage.writeEvent({
+        session_id: 's1', project_path: PROJECT, timestamp: ts(0),
+        hook_type: 'PreToolUse', tool_name: 'Bash',
+      });
+      storage.writeEvent({
+        session_id: 's2', project_path: PROJECT, timestamp: ts(0),
+        hook_type: 'PreToolUse', tool_name: 'Bash',
+      });
+      const res = await request(app).get('/api/events').query({ session: 's2' });
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(1);
+      expect(res.body[0].session_id).toBe('s2');
+    });
+  });
+
+  describe('GET /api/events/stream (SSE)', () => {
+    it('returns 200 with text/event-stream content type', async () => {
+      const server = app.listen(0);
+      const port = (server.address() as { port: number }).port;
+      try {
+        const res = await fetch(`http://127.0.0.1:${port}/api/events/stream`);
+        expect(res.status).toBe(200);
+        expect(res.headers.get('content-type')).toContain('text/event-stream');
+        // Read first chunk and bail
+        const reader = res.body!.getReader();
+        const { value } = await reader.read();
+        const text = new TextDecoder().decode(value);
+        expect(text).toContain('"connected"');
+        await reader.cancel();
+      } finally {
+        await new Promise<void>((resolve) => server.close(() => resolve()));
+      }
+    });
+  });
+});

package/tests/unit/web/routes-rules.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Unit tests for /api/rules/hit-rate.
+ *
+ * H1 baseline — establishes contract before migrating rules.ts to SQL aggregates.
+ * Response shape must remain identical after the route refactor.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import express, { type Application } from 'express';
+import request from 'supertest';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import { registerRulesRoutes } from '../../../src/web/routes/rules.js';
+import type { SkillRegistry } from '../../../src/skills/registry.js';
+
+const SESSION = 'sess-rules';
+const PROJECT = '/tmp/proj-rules';
+
+/** Minimal SkillRegistry stub for the never-triggered list. */
+function makeRegistry(ids: string[]): SkillRegistry {
+  return {
+    getAll: () => ids.map(id => ({ id })),
+  } as unknown as SkillRegistry;
+}
+
+function makeInv(opts: {
+  id: string;
+  skill_id: string;
+  success: 0 | 1;
+  timestamp: number;
+}) {
+  return {
+    id: opts.id,
+    route_request_id: null,
+    session_id: SESSION,
+    agent_id: null,
+    skill_id: opts.skill_id,
+    invocation_type: 'dynamic' as const,
+    reason: null,
+    workflow: null, phase: null, feature_slug: null, artifact_path: null,
+    depth: 0,
+    success: opts.success,
+    error: opts.success === 0 ? 'boom' : null,
+    timestamp: opts.timestamp,
+  };
+}
+
+describe('GET /api/rules/hit-rate', () => {
+  let app: Application;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    app = express();
+    app.use(express.json());
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  it('空数据：summary 全 0，skills/agents 为空，neverTriggered 列出 registry 全部', async () => {
+    registerRulesRoutes(app, { storage, skillRegistry: makeRegistry(['tdd', 'debug']) });
+
+    const res = await request(app).get('/api/rules/hit-rate').query({ days: 7 });
+    expect(res.status).toBe(200);
+    expect(res.body.period.days).toBe(7);
+    expect(typeof res.body.period.since).toBe('string');
+    expect(res.body.summary).toEqual({
+      totalPrompts: 0,
+      agentDelegations: 0,
+      agentRate: '0%',
+      skillInvocations: 0,
+      skillRate: '0%',
+    });
+    expect(res.body.skills).toEqual([]);
+    expect(res.body.agents).toEqual([]);
+    expect(res.body.neverTriggered.sort()).toEqual(['debug', 'tdd']);
+  });
+
+  it('混合数据：totalPrompts、agentDelegations(obeyed=1)、agents 排序、skills 频次、neverTriggered 排除已触发', async () => {
+    registerRulesRoutes(app, { storage, skillRegistry: makeRegistry(['tdd', 'debug', 'unused-skill']) });
+
+    const now = Date.now();
+    // 5 个 routing events，3 个 obeyed (2 researcher + 1 coder)
+    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,
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p3', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'coder', obeyed: 1,
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p4', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'tester', obeyed: 0,
+    });
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: now,
+      prompt: 'p5', intent_json: '{}',
+      routed_to_type: 'skill', routed_to_name: 'tdd', obeyed: null,
+    });
+
+    // 3 个 skill invocations
+    storage.writeSkillInvocation(makeInv({ id: 's1', skill_id: 'tdd', success: 1, timestamp: now }));
+    storage.writeSkillInvocation(makeInv({ id: 's2', skill_id: 'tdd', success: 0, timestamp: now }));
+    storage.writeSkillInvocation(makeInv({ id: 's3', skill_id: 'debug', success: 1, timestamp: now }));
+
+    const res = await request(app).get('/api/rules/hit-rate').query({ days: 7 });
+    expect(res.status).toBe(200);
+
+    // Summary
+    expect(res.body.summary.totalPrompts).toBe(5);
+    expect(res.body.summary.agentDelegations).toBe(3);
+    expect(res.body.summary.agentRate).toBe('60.0%');
+    expect(res.body.summary.skillInvocations).toBe(3);
+    expect(res.body.summary.skillRate).toBe('60.0%');
+
+    // Skills 排序 by total desc
+    expect(res.body.skills).toHaveLength(2);
+    expect(res.body.skills[0]).toEqual({
+      skill_id: 'tdd', total: 2, success: 1, failed: 1, rate: '40.0%',
+    });
+    expect(res.body.skills[1]).toEqual({
+      skill_id: 'debug', total: 1, success: 1, failed: 0, rate: '20.0%',
+    });
+
+    // Agents 排序 by count desc，仅 obeyed=1
+    expect(res.body.agents).toHaveLength(2);
+    expect(res.body.agents[0]).toEqual({ agent: 'researcher', count: 2, rate: '40.0%' });
+    expect(res.body.agents[1]).toEqual({ agent: 'coder', count: 1, rate: '20.0%' });
+
+    // neverTriggered = registry - skills with invocations
+    expect(res.body.neverTriggered).toEqual(['unused-skill']);
+  });
+
+  it('days 默认 7、可被 query 覆盖', async () => {
+    registerRulesRoutes(app, { storage, skillRegistry: makeRegistry([]) });
+
+    const res1 = await request(app).get('/api/rules/hit-rate');
+    expect(res1.body.period.days).toBe(7);
+
+    const res2 = await request(app).get('/api/rules/hit-rate').query({ days: 30 });
+    expect(res2.body.period.days).toBe(30);
+  });
+
+  it('days 窗口过滤：旧 routing/skill 数据不计入', async () => {
+    registerRulesRoutes(app, { storage, skillRegistry: makeRegistry(['tdd']) });
+
+    const old = Date.now() - 30 * 24 * 3600 * 1000;
+    storage.writeRoutingEvent({
+      session_id: SESSION, project_path: PROJECT, ts: old,
+      prompt: 'old', intent_json: '{}',
+      routed_to_type: 'agent', routed_to_name: 'researcher', obeyed: 1,
+    });
+    storage.writeSkillInvocation(makeInv({ id: 's-old', skill_id: 'tdd', success: 1, timestamp: old }));
+
+    const res = await request(app).get('/api/rules/hit-rate').query({ days: 7 });
+    expect(res.body.summary.totalPrompts).toBe(0);
+    expect(res.body.summary.skillInvocations).toBe(0);
+    expect(res.body.skills).toEqual([]);
+    expect(res.body.agents).toEqual([]);
+    // 旧数据没触发 → tdd 仍在 neverTriggered
+    expect(res.body.neverTriggered).toEqual(['tdd']);
+  });
+
+  it('skillRegistry 缺失：neverTriggered 为空', async () => {
+    // 不传 skillRegistry
+    registerRulesRoutes(app, { storage });
+
+    const res = await request(app).get('/api/rules/hit-rate');
+    expect(res.status).toBe(200);
+    expect(res.body.neverTriggered).toEqual([]);
+  });
+});

package/tests/unit/web/routes-sessions.test.ts

@@ -0,0 +1,181 @@
+/**
+ * Unit tests for /api/sessions* routes (sessions list, detail, timeline, search).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import express, { type Application } from 'express';
+import request from 'supertest';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import { registerSessionsRoutes } from '../../../src/web/routes/sessions.js';
+
+const SESSION_ID = 'sess-aaaa-bbbb';
+const PROJECT = '/tmp/proj';
+
+function ts(offsetMs = 0): string {
+  return new Date(Date.UTC(2026, 0, 1, 0, 0, 0) + offsetMs).toISOString();
+}
+
+describe('Session Routes', () => {
+  let app: Application;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    app = express();
+    app.use(express.json());
+    registerSessionsRoutes(app, { storage });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  describe('GET /api/sessions', () => {
+    it('returns empty array initially', async () => {
+      const res = await request(app).get('/api/sessions');
+      expect(res.status).toBe(200);
+      expect(Array.isArray(res.body)).toBe(true);
+      expect(res.body).toHaveLength(0);
+    });
+
+    it('returns sessions list after events written', async () => {
+      storage.writeEvent({
+        session_id: SESSION_ID,
+        project_path: PROJECT,
+        timestamp: ts(),
+        hook_type: 'UserPromptSubmit',
+        user_prompt: 'hello world',
+      });
+
+      const res = await request(app).get('/api/sessions');
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(1);
+      expect(res.body[0].session_id).toBe(SESSION_ID);
+      expect(res.body[0].first_prompt).toBe('hello world');
+    });
+
+    it('honours project filter', async () => {
+      storage.writeEvent({
+        session_id: 's1', project_path: '/a', timestamp: ts(),
+        hook_type: 'UserPromptSubmit', user_prompt: 'a',
+      });
+      storage.writeEvent({
+        session_id: 's2', project_path: '/b', timestamp: ts(1000),
+        hook_type: 'UserPromptSubmit', user_prompt: 'b',
+      });
+
+      const res = await request(app).get('/api/sessions').query({ project: '/b' });
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(1);
+      expect(res.body[0].session_id).toBe('s2');
+    });
+  });
+
+  describe('GET /api/sessions/:sessionId/detail', () => {
+    it('returns 404 for non-existent session', async () => {
+      const res = await request(app).get('/api/sessions/does-not-exist/detail');
+      expect(res.status).toBe(404);
+      expect(res.body.error).toBe('Session not found');
+    });
+
+    it('returns task-grouped detail (virtual task when no tasks)', async () => {
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(),
+        hook_type: 'UserPromptSubmit', user_prompt: 'do thing',
+      });
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(1000),
+        hook_type: 'PreToolUse', tool_name: 'Edit',
+        tool_input: { file_path: '/x.ts' },
+      });
+
+      const res = await request(app).get(`/api/sessions/${SESSION_ID}/detail`);
+      expect(res.status).toBe(200);
+      expect(res.body.session.session_id).toBe(SESSION_ID);
+      expect(res.body.tasks).toHaveLength(1);
+      expect(res.body.tasks[0].id).toBe('virtual');
+      expect(res.body.tasks[0].summary.toolUsage.Edit).toBe(1);
+      expect(res.body.tasks[0].summary.filesChanged).toContain('/x.ts');
+    });
+
+    it('supports session id prefix lookup', async () => {
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(),
+        hook_type: 'UserPromptSubmit', user_prompt: 'hi',
+      });
+      const prefix = SESSION_ID.slice(0, 8);
+      const res = await request(app).get(`/api/sessions/${prefix}/detail`);
+      expect(res.status).toBe(200);
+      expect(res.body.session.session_id).toBe(SESSION_ID);
+    });
+  });
+
+  describe('GET /api/sessions/:sessionId/events/search', () => {
+    it('returns 404 when session does not exist', async () => {
+      const res = await request(app).get('/api/sessions/missing/events/search');
+      expect(res.status).toBe(404);
+    });
+
+    it('filters events by query string', async () => {
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(),
+        hook_type: 'UserPromptSubmit', user_prompt: 'banana smoothie',
+      });
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(1000),
+        hook_type: 'UserPromptSubmit', user_prompt: 'apple pie',
+      });
+
+      const res = await request(app)
+        .get(`/api/sessions/${SESSION_ID}/events/search`)
+        .query({ q: 'banana' });
+      expect(res.status).toBe(200);
+      expect(res.body.session_id).toBe(SESSION_ID);
+      expect(res.body.events).toHaveLength(1);
+      expect(res.body.events[0].user_prompt).toContain('banana');
+    });
+  });
+
+  describe('GET /api/sessions/:id/timeline', () => {
+    it('returns 404 for unknown session prefix', async () => {
+      const res = await request(app).get('/api/sessions/zzz/timeline');
+      expect(res.status).toBe(404);
+    });
+
+    it('returns timeline with user inputs and tool calls', async () => {
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(),
+        hook_type: 'UserPromptSubmit', user_prompt: 'go',
+      });
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(1000),
+        hook_type: 'PreToolUse', tool_name: 'Bash',
+        tool_input: { command: 'git commit -m "feat: stuff"' },
+      });
+
+      const res = await request(app).get(`/api/sessions/${SESSION_ID}/timeline`);
+      expect(res.status).toBe(200);
+      expect(res.body.session.session_id).toBe(SESSION_ID);
+      expect(res.body.timeline.length).toBeGreaterThanOrEqual(2);
+      expect(res.body.timeline.some((t: { type: string }) => t.type === 'user_input')).toBe(true);
+      expect(res.body.timeline.some((t: { type: string }) => t.type === 'tool_call')).toBe(true);
+      expect(res.body.summary.commits[0].message).toBe('feat: stuff');
+    });
+
+    it('paginates timeline entries', async () => {
+      for (let i = 0; i < 5; i++) {
+        storage.writeEvent({
+          session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(i * 100),
+          hook_type: 'UserPromptSubmit', user_prompt: `q${i}`,
+        });
+      }
+      const res = await request(app)
+        .get(`/api/sessions/${SESSION_ID}/timeline`)
+        .query({ limit: 2, offset: 1 });
+      expect(res.status).toBe(200);
+      expect(res.body.timeline).toHaveLength(2);
+      expect(res.body.total).toBe(5);
+      expect(res.body.hasMore).toBe(true);
+    });
+  });
+});

package/tests/unit/web/routes-skill-stats.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Unit tests for /api/skill-stats/* and /api/routing/stats routes.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import express, { type Application } from 'express';
+import request from 'supertest';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import { registerSkillStatsRoutes } from '../../../src/web/routes/skill-stats.js';
+
+const SESSION = 'sess-skill';
+const PROJECT = '/tmp/proj';
+
+describe('Skill Stats Routes', () => {
+  let app: Application;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    app = express();
+    app.use(express.json());
+    registerSkillStatsRoutes(app, { storage });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  describe('GET /api/skill-stats/distribution', () => {
+    it('returns zero counts when no routing events', async () => {
+      const res = await request(app).get('/api/skill-stats/distribution');
+      expect(res.status).toBe(200);
+      expect(res.body.windowHours).toBe(168);
+      expect(Array.isArray(res.body.distribution)).toBe(true);
+      const map = Object.fromEntries(
+        res.body.distribution.map((d: { type: string; count: number }) => [d.type, d.count]),
+      );
+      expect(map.agent).toBe(0);
+      expect(map.skill).toBe(0);
+      expect(map.none).toBe(0);
+    });
+
+    it('counts routing events grouped by type', async () => {
+      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',
+      });
+      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: 'official-tdd',
+      });
+
+      const res = await request(app).get('/api/skill-stats/distribution');
+      expect(res.status).toBe(200);
+      const map = Object.fromEntries(
+        res.body.distribution.map((d: { type: string; count: number }) => [d.type, d.count]),
+      );
+      expect(map.agent).toBe(1);
+      expect(map.skill).toBe(2);
+    });
+  });
+
+  describe('GET /api/skill-stats/frequency', () => {
+    it('returns skill call frequency sorted by count desc', async () => {
+      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: 'tdd',
+      });
+      storage.writeRoutingEvent({
+        session_id: SESSION, project_path: PROJECT, ts: now,
+        prompt: 'p2', intent_json: '{}', routed_to_type: 'skill', routed_to_name: 'debug',
+      });
+      storage.writeRoutingEvent({
+        session_id: SESSION, project_path: PROJECT, ts: now,
+        prompt: 'p3', intent_json: '{}', routed_to_type: 'skill', routed_to_name: 'tdd',
+      });
+
+      const res = await request(app).get('/api/skill-stats/frequency');
+      expect(res.status).toBe(200);
+      expect(res.body.frequency[0]).toEqual({ name: 'tdd', count: 2 });
+      expect(res.body.frequency[1]).toEqual({ name: 'debug', count: 1 });
+    });
+  });
+
+  describe('GET /api/skill-stats/invocations', () => {
+    it('aggregates invocations grouped by skill_id', async () => {
+      const now = Date.now();
+      storage.writeSkillInvocation({
+        id: 'si-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: now,
+      });
+      storage.writeSkillInvocation({
+        id: 'si-2', 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: 0, error: 'boom', timestamp: now,
+      });
+      storage.writeSkillInvocation({
+        id: 'si-3', 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: now,
+      });
+
+      const res = await request(app).get('/api/skill-stats/invocations').query({ days: 7 });
+      expect(res.status).toBe(200);
+      expect(res.body.days).toBe(7);
+      expect(res.body.total).toBe(3);
+      const tdd = res.body.invocations.find((i: { skill_id: string }) => i.skill_id === 'official-tdd');
+      expect(tdd.total).toBe(2);
+      expect(tdd.success).toBe(1);
+      expect(tdd.failed).toBe(1);
+    });
+
+    it('respects days window (excludes old invocations)', async () => {
+      const old = Date.now() - 10 * 24 * 3600 * 1000;
+      storage.writeSkillInvocation({
+        id: 'si-old', 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: old,
+      });
+      const res = await request(app).get('/api/skill-stats/invocations').query({ days: 7 });
+      expect(res.status).toBe(200);
+      expect(res.body.total).toBe(0);
+    });
+  });
+
+  describe('GET /api/routing/stats', () => {
+    it('returns zero stats when no routing events', async () => {
+      const res = await request(app).get('/api/routing/stats').query({ days: 7 });
+      expect(res.status).toBe(200);
+      expect(res.body.total).toBe(0);
+      expect(res.body.agentCalls).toBe(0);
+      expect(res.body.agentRate).toBe(0);
+      expect(res.body.byAgent).toEqual([]);
+    });
+
+    it('aggregates agent obey rate and breakdown', async () => {
+      const now = Date.now();
+      // 3 events: 2 obeyed researcher, 1 not obeyed
+      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,
+      });
+      storage.writeRoutingEvent({
+        session_id: SESSION, project_path: PROJECT, ts: now,
+        prompt: 'p3', intent_json: '{}', routed_to_type: 'agent',
+        routed_to_name: 'tester', obeyed: 0,
+      });
+
+      const res = await request(app).get('/api/routing/stats').query({ days: 7 });
+      expect(res.status).toBe(200);
+      expect(res.body.total).toBe(3);
+      expect(res.body.agentCalls).toBe(2);
+      expect(res.body.noAgent).toBe(1);
+      expect(res.body.agentRate).toBeCloseTo(66.7, 0);
+      expect(res.body.byAgent).toEqual([{ agent: 'researcher', count: 2 }]);
+    });
+  });
+});