@winspan/claude-forge 8.41.0 → 8.51.0

package/tests/integration/queue-replay.integration.test.ts

@@ -0,0 +1,193 @@
+/**
+ * Integration test: hook failure queue → daemon startup replay
+ *
+ * Uses real SQLiteStorage (no mocks for storage layer).
+ * Does NOT start an actual daemon process — instead tests the queue
+ * module functions directly with the same storage that daemon would use.
+ *
+ * Test scenarios:
+ * 1. Enqueue 3 events → replayQueue → all 3 in DB, queue empty
+ * 2. Second replayQueue → skipped=3 (dedup), DB still has 3 rows
+ * 3. TTL and bad JSON → dead-lettered correctly
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync, utimesSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+describe('Queue → Daemon Replay Integration', () => {
+  let tempHome: string;
+  let queueDir: string;
+  let deadDir: string;
+  let dbPath: string;
+  let originalHome: string | undefined;
+
+  beforeEach(async () => {
+    originalHome = process.env['HOME'];
+    tempHome = mkdtempSync(join(tmpdir(), 'forge-integ-'));
+    process.env['HOME'] = tempHome;
+
+    queueDir = join(tempHome, '.claude-forge', 'queue');
+    deadDir = join(queueDir, 'dead');
+    dbPath = join(tempHome, 'data.db');
+
+    mkdirSync(queueDir, { recursive: true });
+    mkdirSync(deadDir, { recursive: true });
+
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.env['HOME'] = originalHome;
+    rmSync(tempHome, { recursive: true, force: true });
+    vi.resetModules();
+  });
+
+  it('enqueues 3 events then replays all into DB and empties queue', async () => {
+    const { enqueueEvent, replayQueue } = await import('../../src/core/queue/index.js');
+    const { SQLiteStorage } = await import('../../src/core/storage/sqlite.js');
+    const storage = new SQLiteStorage(dbPath);
+
+    const events = [
+      {
+        session_id: 'integ-session-1',
+        project_path: '/tmp/proj',
+        timestamp: new Date().toISOString(),
+        hook_type: 'UserPromptSubmit' as const,
+        user_prompt: 'prompt 1',
+        event_id: randomUUID(),
+      },
+      {
+        session_id: 'integ-session-1',
+        project_path: '/tmp/proj',
+        timestamp: new Date().toISOString(),
+        hook_type: 'PreToolUse' as const,
+        tool_name: 'Bash',
+        event_id: randomUUID(),
+      },
+      {
+        session_id: 'integ-session-1',
+        project_path: '/tmp/proj',
+        timestamp: new Date().toISOString(),
+        hook_type: 'PostToolUse' as const,
+        tool_name: 'Bash',
+        tool_input: { command: 'ls' },
+        tool_output: { output: 'file.txt' },
+        event_id: randomUUID(),
+      },
+    ];
+
+    // Simulate daemon downtime: enqueue all events
+    for (const event of events) {
+      enqueueEvent(event);
+    }
+
+    const queuedFiles = readdirSync(queueDir).filter((f) => f.endsWith('.json'));
+    expect(queuedFiles).toHaveLength(3);
+
+    // Simulate daemon startup: replay queue
+    const result = await replayQueue(storage);
+    expect(result.replayed).toBe(3);
+    expect(result.skipped).toBe(0);
+    expect(result.dead).toBe(0);
+
+    // Verify all events are in DB
+    const dbEvents = storage.queryEvents({ session_id: 'integ-session-1' });
+    expect(dbEvents).toHaveLength(3);
+
+    // Verify queue is empty
+    const remainingFiles = readdirSync(queueDir).filter((f) => f.endsWith('.json'));
+    expect(remainingFiles).toHaveLength(0);
+
+    storage.close();
+  });
+
+  it('second replayQueue skips all events (dedup), DB still has 3 rows', async () => {
+    const { enqueueEvent, replayQueue } = await import('../../src/core/queue/index.js');
+    const { SQLiteStorage } = await import('../../src/core/storage/sqlite.js');
+    const storage = new SQLiteStorage(dbPath);
+
+    const eventIds = [randomUUID(), randomUUID(), randomUUID()];
+    const events = eventIds.map((id, i) => ({
+      session_id: 'dedup-session',
+      project_path: '/tmp',
+      timestamp: new Date().toISOString(),
+      hook_type: 'Notification' as const,
+      event_id: id,
+      user_prompt: `prompt ${i}`,
+    }));
+
+    // First pass: enqueue + replay (all 3 enter DB)
+    for (const event of events) {
+      enqueueEvent(event);
+    }
+    const first = await replayQueue(storage);
+    expect(first.replayed).toBe(3);
+
+    // Queue is empty now. Re-enqueue the same events to simulate a second replay
+    for (const event of events) {
+      enqueueEvent(event);
+    }
+
+    // Second pass: all 3 should be skipped as duplicates
+    const second = await replayQueue(storage);
+    expect(second.skipped).toBe(3);
+    expect(second.replayed).toBe(0);
+
+    // DB still has exactly 3 events
+    const dbEvents = storage.queryEvents({ session_id: 'dedup-session' });
+    expect(dbEvents).toHaveLength(3);
+
+    storage.close();
+  });
+
+  it('dead-letters TTL-expired and corrupt files, replays valid ones', async () => {
+    const { enqueueEvent, replayQueue, TTL_DAYS } = await import('../../src/core/queue/index.js');
+    const { SQLiteStorage } = await import('../../src/core/storage/sqlite.js');
+    const storage = new SQLiteStorage(dbPath);
+
+    // Valid event
+    const validEvent = {
+      session_id: 'mixed-session',
+      project_path: '/tmp',
+      timestamp: new Date().toISOString(),
+      hook_type: 'UserPromptSubmit' as const,
+      user_prompt: 'valid',
+      event_id: randomUUID(),
+    };
+    enqueueEvent(validEvent);
+
+    // Corrupt JSON file
+    writeFileSync(join(queueDir, '2020-02-01T00-00-00-000Z-corrupt.json'), '{bad json]]');
+
+    // TTL-expired file (valid JSON but old mtime)
+    const oldEventPath = join(queueDir, '2000-01-01T00-00-00-000Z-expired.json');
+    writeFileSync(oldEventPath, JSON.stringify({
+      session_id: 'mixed-session',
+      project_path: '/tmp',
+      timestamp: '2000-01-01T00:00:00.000Z',
+      hook_type: 'Notification' as const,
+      event_id: randomUUID(),
+    }));
+    const pastTime = new Date(Date.now() - (TTL_DAYS + 2) * 24 * 60 * 60 * 1000);
+    utimesSync(oldEventPath, pastTime, pastTime);
+
+    const result = await replayQueue(storage);
+
+    expect(result.replayed).toBe(1);
+    expect(result.dead).toBe(2); // corrupt + expired
+    expect(result.skipped).toBe(0);
+
+    // dead-letter dir should have 2 files
+    const deadFiles = readdirSync(deadDir).filter((f) => f.endsWith('.json'));
+    expect(deadFiles).toHaveLength(2);
+
+    // queue is empty
+    const queueFiles = readdirSync(queueDir).filter((f) => f.endsWith('.json'));
+    expect(queueFiles).toHaveLength(0);
+
+    storage.close();
+  });
+});

package/tests/integration/tasks-filter.integration.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Integration tests for Tasks filter + pagination.
+ * Uses a real in-memory SQLite database to verify JOIN accuracy and COUNT correctness.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SQLiteStorage } from '../../src/core/storage/sqlite.js';
+
+function ts(offsetMs = 0): string {
+  return new Date(Date.UTC(2026, 0, 1) + offsetMs).toISOString();
+}
+
+const PROJECT_A = '/workspace/project-alpha';
+const PROJECT_B = '/workspace/project-beta';
+const PROJECT_C = '/workspace/project-gamma';
+
+describe('Tasks filter + pagination integration', () => {
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    // Seed sessions
+    const db = storage.getDatabase();
+    db.prepare(`INSERT INTO sessions (session_id, project_path, start_time) VALUES (?, ?, ?)`).run('sess-a', PROJECT_A, ts());
+    db.prepare(`INSERT INTO sessions (session_id, project_path, start_time) VALUES (?, ?, ?)`).run('sess-b', PROJECT_B, ts());
+    db.prepare(`INSERT INTO sessions (session_id, project_path, start_time) VALUES (?, ?, ?)`).run('sess-c', PROJECT_C, ts());
+    db.prepare(`INSERT INTO sessions (session_id, project_path, start_time) VALUES (?, ?, ?)`).run('sess-a2', PROJECT_A, ts());
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  it('JOIN preserves project_path from sessions', () => {
+    storage.writeTask({ id: 't1', session_id: 'sess-a', title: 'alpha task', start_time: ts() });
+    const result = storage.queryTasksFiltered({ limit: 10, offset: 0 });
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0].project_path).toBe(PROJECT_A);
+    expect(result.total).toBe(1);
+    expect(result.has_more).toBe(false);
+  });
+
+  it('COUNT(*) matches items length when no pagination', () => {
+    storage.writeTask({ id: 't1', session_id: 'sess-a', title: 'task1', start_time: ts() });
+    storage.writeTask({ id: 't2', session_id: 'sess-b', title: 'task2', start_time: ts(1000) });
+    storage.writeTask({ id: 't3', session_id: 'sess-c', title: 'task3', start_time: ts(2000) });
+
+    const result = storage.queryTasksFiltered({ limit: 100 });
+    expect(result.total).toBe(3);
+    expect(result.items).toHaveLength(3);
+    expect(result.has_more).toBe(false);
+  });
+
+  it('COUNT remains constant across pages (A8)', () => {
+    for (let i = 0; i < 7; i++) {
+      storage.writeTask({ id: `pg${i}`, session_id: 'sess-a', title: `task ${i}`, start_time: ts(i * 1000) });
+    }
+    const page1 = storage.queryTasksFiltered({ limit: 4, offset: 0 });
+    const page2 = storage.queryTasksFiltered({ limit: 4, offset: 4 });
+
+    expect(page1.total).toBe(7);
+    expect(page2.total).toBe(7); // total is consistent
+    expect(page1.items).toHaveLength(4);
+    expect(page2.items).toHaveLength(3);
+    expect(page1.has_more).toBe(true);
+    expect(page2.has_more).toBe(false);
+
+    // No overlap between pages
+    const p1ids = page1.items.map(t => t.id);
+    const p2ids = page2.items.map(t => t.id);
+    expect(p1ids.some(id => p2ids.includes(id))).toBe(false);
+  });
+
+  it('project filter via JOIN correctly isolates tasks (A2)', () => {
+    storage.writeTask({ id: 'ta', session_id: 'sess-a', title: 'alpha', start_time: ts() });
+    storage.writeTask({ id: 'tb', session_id: 'sess-b', title: 'beta',  start_time: ts(1000) });
+    storage.writeTask({ id: 'tc', session_id: 'sess-c', title: 'gamma', start_time: ts(2000) });
+
+    const result = storage.queryTasksFiltered({ project: PROJECT_A });
+    expect(result.total).toBe(1);
+    expect(result.items[0].id).toBe('ta');
+    expect(result.items[0].project_path).toBe(PROJECT_A);
+  });
+
+  it('multi-project OR filter returns union correctly (A3)', () => {
+    storage.writeTask({ id: 'ta', session_id: 'sess-a', title: 'alpha', start_time: ts() });
+    storage.writeTask({ id: 'tb', session_id: 'sess-b', title: 'beta',  start_time: ts(1000) });
+    storage.writeTask({ id: 'tc', session_id: 'sess-c', title: 'gamma', start_time: ts(2000) });
+
+    const result = storage.queryTasksFiltered({ project: [PROJECT_A, PROJECT_B] });
+    expect(result.total).toBe(2);
+    const ids = result.items.map(t => t.id).sort();
+    expect(ids).toEqual(['ta', 'tb']);
+  });
+
+  it('search filter uses LIKE on title (A5)', () => {
+    storage.writeTask({ id: 't1', session_id: 'sess-a', title: '重构数据库连接池', start_time: ts() });
+    storage.writeTask({ id: 't2', session_id: 'sess-a', title: 'fix build CI',    start_time: ts(1000) });
+    storage.writeTask({ id: 't3', session_id: 'sess-b', title: '重构 API 层',      start_time: ts(2000) });
+
+    const result = storage.queryTasksFiltered({ search: '重构' });
+    expect(result.total).toBe(2);
+    const ids = result.items.map(t => t.id).sort();
+    expect(ids).toEqual(['t1', 't3']);
+  });
+
+  it('from/to date range filter uses string comparison on start_time (A4)', () => {
+    storage.writeTask({ id: 'early', session_id: 'sess-a', title: 'early', start_time: '2026-01-01T00:00:00.000Z' });
+    storage.writeTask({ id: 'mid',   session_id: 'sess-a', title: 'mid',   start_time: '2026-01-15T12:00:00.000Z' });
+    storage.writeTask({ id: 'late',  session_id: 'sess-a', title: 'late',  start_time: '2026-02-01T00:00:00.000Z' });
+
+    const result = storage.queryTasksFiltered({
+      from: '2026-01-01T00:00:00.000Z',
+      to:   '2026-01-31T23:59:59.000Z',
+    });
+    expect(result.total).toBe(2);
+    const ids = result.items.map(t => t.id).sort();
+    expect(ids).toEqual(['early', 'mid']);
+  });
+
+  it('queryTaskProjects returns distinct paths with tasks only', () => {
+    // sess-a and sess-a2 both point to PROJECT_A
+    storage.writeTask({ id: 't1', session_id: 'sess-a',  title: 'a', start_time: ts() });
+    storage.writeTask({ id: 't2', session_id: 'sess-a2', title: 'b', start_time: ts(1000) });
+    storage.writeTask({ id: 't3', session_id: 'sess-b',  title: 'c', start_time: ts(2000) });
+    // sess-c has no tasks — should not appear
+
+    const projects = storage.queryTaskProjects();
+    expect(projects).toHaveLength(2);
+    expect(projects).toContain(PROJECT_A);
+    expect(projects).toContain(PROJECT_B);
+    expect(projects).not.toContain(PROJECT_C);
+  });
+
+  it('limit clamp: storage-level enforces max 200', () => {
+    for (let i = 0; i < 5; i++) {
+      storage.writeTask({ id: `lc${i}`, session_id: 'sess-a', title: `t${i}`, start_time: ts(i * 1000) });
+    }
+    const result = storage.queryTasksFiltered({ limit: 999 });
+    // Storage clamps to 200 internally
+    expect(result.items.length).toBeLessThanOrEqual(200);
+    expect(result.total).toBe(5);
+  });
+
+  it('has_more is accurate at boundary (exactly limit items)', () => {
+    for (let i = 0; i < 4; i++) {
+      storage.writeTask({ id: `bnd${i}`, session_id: 'sess-a', title: `t${i}`, start_time: ts(i * 1000) });
+    }
+    const result = storage.queryTasksFiltered({ limit: 4, offset: 0 });
+    expect(result.total).toBe(4);
+    expect(result.items).toHaveLength(4);
+    expect(result.has_more).toBe(false); // offset(0) + items(4) == total(4) → no more
+  });
+});

package/tests/integration/web-analytics.integration.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Integration safety-net for web analytics endpoints.
+ *
+ * Purpose: lock the wiring of the 3 analytics routes (drift / weekly report /
+ * insights) before migrating their backing classes from `daemon/services/` to
+ * `web/analytics/`. We assert HTTP 200 + presence of key response fields only;
+ * business-correctness coverage is out of scope.
+ *
+ * If any endpoint regresses to a 4xx/5xx response, this test fails and blocks
+ * the H6 migration commit.
+ */
+
+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 { registerDriftRoutes } from '../../src/web/routes/drift.js';
+import { registerReportsRoutes } from '../../src/web/routes/reports.js';
+import { registerInsightsRoutes } from '../../src/web/routes/insights.js';
+
+const FIXTURE_SESSION = 'sess-analytics-fixture';
+const FIXTURE_PROJECT = '/tmp/proj-analytics-fixture';
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+/**
+ * Seed a small but deterministic dataset so the analytics endpoints have
+ * something to aggregate. H2 Phase 1 enhancement: in addition to shape checks
+ * we assert key aggregated values to lock the current behaviour before the
+ * weekly-report / anti-pattern / drift inline SQL is migrated to Operations.
+ */
+function seedFixtureData(storage: SQLiteStorage): void {
+  // 4 events on the current (active) day so weekly/insights see them.
+  storage.writeEvent({
+    session_id: FIXTURE_SESSION, project_path: FIXTURE_PROJECT, timestamp: nowIso(),
+    hook_type: 'UserPromptSubmit', user_prompt: 'do work',
+  });
+  storage.writeEvent({
+    session_id: FIXTURE_SESSION, project_path: FIXTURE_PROJECT, timestamp: nowIso(),
+    hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'ls' },
+  });
+  storage.writeEvent({
+    session_id: FIXTURE_SESSION, project_path: FIXTURE_PROJECT, timestamp: nowIso(),
+    hook_type: 'PreToolUse', tool_name: 'Edit', tool_input: { file_path: '/a.ts' },
+  });
+  storage.writeEvent({
+    session_id: FIXTURE_SESSION, project_path: FIXTURE_PROJECT, timestamp: nowIso(),
+    hook_type: 'PostToolUse', tool_name: 'Edit', tool_output: 'ok',
+  });
+}
+
+describe('Web analytics endpoints (safety-net)', () => {
+  let app: Application;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    app = express();
+    app.use(express.json());
+    registerDriftRoutes(app, { storage });
+    registerReportsRoutes(app, { storage });
+    registerInsightsRoutes(app, { storage });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  it('GET /api/drift/report returns a DriftReport shape', async () => {
+    const res = await request(app).get('/api/drift/report');
+    expect(res.status).toBe(200);
+    expect(res.body).toHaveProperty('generatedAt');
+    expect(res.body).toHaveProperty('period');
+    expect(res.body).toHaveProperty('checks');
+    expect(res.body).toHaveProperty('overallScore');
+    expect(Array.isArray(res.body.checks)).toBe(true);
+  });
+
+  it('GET /api/reports/weekly returns a WeeklyReport shape', async () => {
+    const res = await request(app).get('/api/reports/weekly');
+    expect(res.status).toBe(200);
+    expect(res.body).toHaveProperty('generatedAt');
+    expect(res.body).toHaveProperty('week');
+    expect(res.body).toHaveProperty('overview');
+    // overview should at least exist as an object with numeric fields
+    expect(typeof res.body.overview).toBe('object');
+  });
+
+  it('GET /api/insights returns insights summary + patterns array', async () => {
+    const res = await request(app).get('/api/insights');
+    expect(res.status).toBe(200);
+    expect(res.body).toHaveProperty('generatedAt');
+    expect(res.body).toHaveProperty('windowDays');
+    expect(res.body).toHaveProperty('summary');
+    expect(res.body).toHaveProperty('patterns');
+    expect(Array.isArray(res.body.patterns)).toBe(true);
+    expect(res.body.summary).toHaveProperty('total');
+  });
+
+  // ── H2 Phase 1 value-level safety-net ────────────────────────────────────
+
+  it('GET /api/reports/weekly reflects seeded events in overview.totalEvents', async () => {
+    seedFixtureData(storage);
+    const res = await request(app).get('/api/reports/weekly').query({ weekOffset: 0 });
+    expect(res.status).toBe(200);
+    // overview is aggregated from events within the active ISO week. The
+    // seed inserts 4 events on the current timestamp → they MUST be inside
+    // the current week range. activeProjects MUST include the fixture path.
+    expect(res.body.overview.totalEvents).toBe(4);
+    expect(res.body.overview.totalSessions).toBe(1);
+    expect(res.body.overview.activeProjects).toContain(FIXTURE_PROJECT);
+    // Tools section: 1x Bash + 1x Edit (PreToolUse aggregation)
+    expect(res.body.tools.totalCalls).toBeGreaterThanOrEqual(2);
+    const toolNames = res.body.tools.topTools.map((t: { name: string }) => t.name);
+    expect(toolNames).toContain('Bash');
+    expect(toolNames).toContain('Edit');
+  });
+
+  it('GET /api/insights summary.total equals patterns.length', async () => {
+    seedFixtureData(storage);
+    const res = await request(app).get('/api/insights').query({ days: 7 });
+    expect(res.status).toBe(200);
+    // Whatever patterns the detector returns, summary.total MUST match the
+    // patterns array length (locks the route's summarisation logic).
+    expect(res.body.summary.total).toBe(res.body.patterns.length);
+    // Severity buckets MUST exist as numeric fields.
+    expect(typeof res.body.summary.critical).toBe('number');
+    expect(typeof res.body.summary.warn).toBe('number');
+    expect(typeof res.body.summary.info).toBe('number');
+  });
+});

package/tests/integration/web-stats.integration.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Integration safety-net for /api/stats.
+ *
+ * H2 Phase 1: lock the shape and baseline aggregation behaviour of the
+ * dashboard stats endpoint before migrating its inline SQL into the
+ * EventOperations / SessionOperations / SkillOperations layers.
+ *
+ * Coverage:
+ *   - Status 200 + presence of totalEvents / totalSessions / toolUsage /
+ *     dailyActivity / skillInvocations fields
+ *   - dailyActivity entry shape (date / eventCount / sessionCount)
+ *   - Tool usage aggregation with fixture data
+ *   - Skill invocation count with fixture data
+ *
+ * If this test fails, the H2 refactor commit must be reverted.
+ */
+
+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 { registerStatsRoutes } from '../../src/web/routes/stats.js';
+
+const SESSION = 'sess-stats-int';
+const PROJECT = '/tmp/proj-stats-int';
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+describe('GET /api/stats (safety-net)', () => {
+  let app: Application;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    app = express();
+    app.use(express.json());
+    registerStatsRoutes(app, { storage });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  it('returns the expected response shape with empty database', async () => {
+    const res = await request(app).get('/api/stats');
+    expect(res.status).toBe(200);
+
+    expect(res.body).toHaveProperty('totalEvents');
+    expect(res.body).toHaveProperty('totalSessions');
+    expect(res.body).toHaveProperty('toolUsage');
+    expect(res.body).toHaveProperty('dailyActivity');
+    expect(res.body).toHaveProperty('skillInvocations');
+
+    expect(typeof res.body.totalEvents).toBe('number');
+    expect(typeof res.body.totalSessions).toBe('number');
+    expect(typeof res.body.toolUsage).toBe('object');
+    expect(Array.isArray(res.body.dailyActivity)).toBe(true);
+    expect(typeof res.body.skillInvocations).toBe('number');
+
+    expect(res.body.totalEvents).toBe(0);
+    expect(res.body.totalSessions).toBe(0);
+    expect(res.body.skillInvocations).toBe(0);
+  });
+
+  it('aggregates totalEvents, totalSessions and toolUsage from events', async () => {
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'UserPromptSubmit', user_prompt: 'hi',
+    });
+    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 res = await request(app).get('/api/stats');
+    expect(res.status).toBe(200);
+
+    expect(res.body.totalEvents).toBe(4);
+    expect(res.body.totalSessions).toBe(1);
+    expect(res.body.toolUsage.Bash).toBe(2);
+    expect(res.body.toolUsage.Edit).toBe(1);
+    expect(res.body.toolUsage).not.toHaveProperty('UserPromptSubmit');
+  });
+
+  it('dailyActivity entries have date / eventCount / sessionCount fields', async () => {
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Read',
+    });
+
+    const res = await request(app).get('/api/stats');
+    expect(res.status).toBe(200);
+    expect(res.body.dailyActivity.length).toBeGreaterThanOrEqual(1);
+
+    const entry = res.body.dailyActivity[0];
+    expect(entry).toHaveProperty('date');
+    expect(entry).toHaveProperty('eventCount');
+    expect(entry).toHaveProperty('sessionCount');
+    expect(typeof entry.date).toBe('string');
+    expect(typeof entry.eventCount).toBe('number');
+    expect(typeof entry.sessionCount).toBe('number');
+    expect(entry.eventCount).toBeGreaterThanOrEqual(1);
+  });
+
+  it('counts skill invocations independently of events', async () => {
+    storage.writeSkillInvocation({
+      id: 'si-int-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-int-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 res = await request(app).get('/api/stats');
+    expect(res.status).toBe(200);
+    expect(res.body.skillInvocations).toBe(2);
+  });
+});