@winspan/claude-forge 8.50.6 → 8.51.0

package/src/{daemon/services → web/analytics}/anti-pattern-detector.ts

@@ -55,8 +55,8 @@ export class AntiPatternDetector {
     const detectedAt = new Date(now).toISOString();
 
     // 一次性拉取窗口内事件 + 会话，4 条规则共用
-    const events = this.fetchEventsSince(sinceISO);
-    const sessions = this.fetchSessionsSince(sinceISO);
+    const events = this.queryEventsSince(sinceISO);
+    const sessions = this.querySessionsSince(sinceISO);
 
     const patterns: AntiPattern[] = [
       ...this.detectEditLoop(events, detectedAt),
@@ -76,50 +76,14 @@ export class AntiPatternDetector {
   /**
    * 拉取窗口内全部事件。
    *
-   * queryEvents 没有时间过滤参数，因此使用 getDatabase 直接窗口查询。
-   * 这是 daemon/services 层的既定做法（见 DriftDetector）。
+   * H2 Phase 3: 改用 facade 聚合方法。
    */
-  private fetchEventsSince(sinceISO: string): ForgeEvent[] {
-    const db = this.storage.getDatabase();
-    const rows = db.prepare(
-      `SELECT * FROM events WHERE timestamp >= ? ORDER BY timestamp ASC`
-    ).all(sinceISO) as Array<Record<string, unknown>>;
-
-    return rows.map((row) => ({
-      event_id: row.event_id as string,
-      session_id: row.session_id as string,
-      project_path: row.project_path as string,
-      timestamp: row.timestamp as string,
-      hook_type: row.hook_type as ForgeEvent['hook_type'],
-      tool_name: (row.tool_name as string) || undefined,
-      tool_input: row.tool_input ? safeParse(row.tool_input as string) : undefined,
-      tool_output: row.tool_output ? safeParse(row.tool_output as string) : undefined,
-      user_prompt: (row.user_prompt as string) || undefined,
-      ai_response: (row.ai_response as string) || undefined,
-    }));
+  private queryEventsSince(sinceISO: string): ForgeEvent[] {
+    return this.storage.queryEventsByTimeRange({ since: sinceISO });
   }
 
-  private fetchSessionsSince(sinceISO: string): SessionSummary[] {
-    const db = this.storage.getDatabase();
-    const rows = db.prepare(
-      `SELECT
-         session_id,
-         first_prompt,
-         event_count,
-         start_time,
-         COALESCE(end_time, last_event_time, start_time) AS end_time
-       FROM sessions
-       WHERE start_time >= ?
-       ORDER BY start_time DESC`
-    ).all(sinceISO) as Array<Record<string, unknown>>;
-
-    return rows.map((r) => ({
-      session_id: r.session_id as string,
-      first_prompt: (r.first_prompt as string) || '',
-      event_count: (r.event_count as number) ?? 0,
-      start_time: r.start_time as string,
-      end_time: r.end_time as string,
-    }));
+  private querySessionsSince(sinceISO: string): SessionSummary[] {
+    return this.storage.querySessionsByTimeRange({ since: sinceISO });
   }
 
   // ── Rule 1: edit_loop ─────────────────────────────────────────────────
@@ -342,23 +306,14 @@ export class AntiPatternDetector {
 
 // ── helpers ─────────────────────────────────────────────────────────────
 
-function safeParse(json: string): Record<string, unknown> | undefined {
-  try {
-    const v = JSON.parse(json);
-    return v && typeof v === 'object' ? (v as Record<string, unknown>) : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function extractFilePath(input: Record<string, unknown> | undefined): string | undefined {
+function extractFilePath(input: ForgeEvent['tool_input']): string | undefined {
   if (!input) return undefined;
   const fp = input.file_path;
   if (typeof fp === 'string' && fp.length > 0) return fp;
   return undefined;
 }
 
-function extractBashCommand(input: Record<string, unknown> | undefined): string | undefined {
+function extractBashCommand(input: ForgeEvent['tool_input']): string | undefined {
   if (!input) return undefined;
   const cmd = input.command;
   return typeof cmd === 'string' ? cmd : undefined;

package/src/{daemon/services → web/analytics}/drift-detector.ts

@@ -121,12 +121,8 @@ export class DriftDetector {
    * 预期: 至少 3 个不同 Skill 被调用
    */
   private checkActiveSkillCoverage(since: number): DriftCheck {
-    const db = this.storage.getDatabase();
-    const row = db.prepare(
-      `SELECT COUNT(DISTINCT skill_id) as cnt FROM skill_invocations
-       WHERE timestamp >= ?`
-    ).get(since) as { cnt: number } | undefined;
-    const distinctCount = row?.cnt ?? 0;
+    // H2 Phase 3: 改用 facade。countDistinctSkillsSince 接收 unix ms。
+    const distinctCount = this.storage.countDistinctSkillsSince(since);
 
     let status: DriftCheck['status'];
     if (distinctCount >= 3) {
@@ -150,12 +146,11 @@ export class DriftDetector {
    * 预期: 最近 7 天中至少 5 天有事件（工作日）
    */
   private checkEventContinuity(): DriftCheck {
-    const db = this.storage.getDatabase();
-    const row = db.prepare(
-      `SELECT COUNT(DISTINCT date(timestamp)) as cnt FROM events
-       WHERE timestamp >= date('now', '-7 days')`
-    ).get() as { cnt: number } | undefined;
-    const activeDays = row?.cnt ?? 0;
+    // H2 Phase 3: 改用 facade。
+    // 旧 SQL: timestamp >= date('now', '-7 days')
+    // 新口径：调用方计算 ISO 字符串。
+    const sevenDaysAgoIso = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+    const activeDays = this.storage.countActiveDays({ since: sevenDaysAgoIso });
 
     let status: DriftCheck['status'];
     if (activeDays >= 5) {
@@ -179,18 +174,10 @@ export class DriftDetector {
    * 预期: 每个 session 至少有 1 个 task (tasks/sessions >= 0.8)
    */
   private checkTaskSegmentation(since: number): DriftCheck {
-    const db = this.storage.getDatabase();
+    // H2 Phase 3: 改用 facade。
     const sinceISO = new Date(since).toISOString();
-
-    const sessionRow = db.prepare(
-      `SELECT COUNT(*) as cnt FROM sessions WHERE start_time >= ?`
-    ).get(sinceISO) as { cnt: number } | undefined;
-    const sessionCount = sessionRow?.cnt ?? 0;
-
-    const taskRow = db.prepare(
-      `SELECT COUNT(*) as cnt FROM tasks WHERE start_time >= ?`
-    ).get(sinceISO) as { cnt: number } | undefined;
-    const taskCount = taskRow?.cnt ?? 0;
+    const sessionCount = this.storage.countSessionsByRange({ since: sinceISO });
+    const taskCount = this.storage.countTasksByRange({ since: sinceISO });
 
     const ratio = sessionCount > 0
       ? Math.round((taskCount / sessionCount) * 100) / 100

package/src/{daemon/services → web/analytics}/weekly-report.ts

@@ -95,38 +95,26 @@ export class WeeklyReportGenerator {
   // ── Aggregation methods ──────────────────────────────────────────────
 
   private aggregateOverview(week: WeekRange): WeeklyReport['overview'] {
-    const db = this.storage.getDatabase();
-
-    const eventsRow = db.prepare(
-      `SELECT COUNT(*) as cnt, COUNT(DISTINCT session_id) as sessionCount,
-              COUNT(DISTINCT date(timestamp)) as dayCount
-         FROM events
-        WHERE timestamp >= ? AND timestamp < ?`,
-    ).get(week.startISO, week.endISO) as {
-      cnt: number;
-      sessionCount: number;
-      dayCount: number;
-    };
-
-    const projectRows = db.prepare(
-      `SELECT DISTINCT project_path
-         FROM events
-        WHERE timestamp >= ? AND timestamp < ?
-              AND project_path IS NOT NULL AND project_path != ''`,
-    ).all(week.startISO, week.endISO) as Array<{ project_path: string }>;
-
-    const tasksRow = db.prepare(
-      `SELECT COUNT(*) as cnt
-         FROM tasks
-        WHERE start_time >= ? AND start_time < ?`,
-    ).get(week.startISO, week.endISO) as { cnt: number };
+    // H2 Phase 3: 改用 facade 聚合方法。
+    const overview = this.storage.aggregateOverviewByRange({
+      since: week.startISO,
+      until: week.endISO,
+    });
+    const activeProjects = this.storage.queryDistinctProjects({
+      since: week.startISO,
+      until: week.endISO,
+    });
+    const totalTasks = this.storage.countTasksByRange({
+      since: week.startISO,
+      until: week.endISO,
+    });
 
     return {
-      totalSessions: eventsRow.sessionCount || 0,
-      totalEvents: eventsRow.cnt || 0,
-      totalTasks: tasksRow.cnt || 0,
-      activeProjects: projectRows.map(r => r.project_path),
-      activeDays: eventsRow.dayCount || 0,
+      totalSessions: overview.session_count || 0,
+      totalEvents: overview.event_count || 0,
+      totalTasks: totalTasks || 0,
+      activeProjects,
+      activeDays: overview.day_count || 0,
     };
   }
 
@@ -209,42 +197,36 @@ export class WeeklyReportGenerator {
   }
 
   private aggregateTools(week: WeekRange): WeeklyReport['tools'] {
-    const db = this.storage.getDatabase();
-
-    const toolRows = db.prepare(
-      `SELECT tool_name, COUNT(*) as cnt
-         FROM events
-        WHERE timestamp >= ? AND timestamp < ?
-              AND tool_name IS NOT NULL AND tool_name != ''
-              AND hook_type = 'PreToolUse'
-        GROUP BY tool_name
-        ORDER BY cnt DESC`,
-    ).all(week.startISO, week.endISO) as Array<{ tool_name: string; cnt: number }>;
+    // H2 Phase 3: 改用 facade。
+    // Phase 2 偏差：spec 列出的 aggregateToolUsage({ since, until, ... }) 实际只实现了
+    // since/limit/hook_type，缺 until。这里用 queryEventsByTimeRange + 内存聚合保留
+    // 旧 SQL 的 [since, until) 半开区间语义（changelog 已记）。
+    const preEvents = this.storage.queryEventsByTimeRange({
+      since: week.startISO,
+      until: week.endISO,
+    }).filter(e => e.hook_type === 'PreToolUse' && e.tool_name);
+
+    const toolCount = new Map<string, number>();
+    for (const ev of preEvents) {
+      const name = ev.tool_name as string;
+      if (!name) continue;
+      toolCount.set(name, (toolCount.get(name) || 0) + 1);
+    }
+    const toolRows = Array.from(toolCount.entries())
+      .map(([tool_name, cnt]) => ({ tool_name, cnt }))
+      .sort((a, b) => b.cnt - a.cnt);
 
     const totalCalls = toolRows.reduce((sum, r) => sum + r.cnt, 0);
     const topTools = toolRows.slice(0, 5).map(r => ({ name: r.tool_name, count: r.cnt }));
 
-    // Failure detection: PostToolUse with error keyword in tool_output
-    const failureRow = db.prepare(
-      `SELECT COUNT(*) as failed
-         FROM events
-        WHERE timestamp >= ? AND timestamp < ?
-              AND hook_type = 'PostToolUse'
-              AND tool_output IS NOT NULL
-              AND (tool_output LIKE '%"error"%'
-                OR tool_output LIKE '%"is_error":true%'
-                OR tool_output LIKE '%"isError":true%')`,
-    ).get(week.startISO, week.endISO) as { failed: number };
-
-    const postCallRow = db.prepare(
-      `SELECT COUNT(*) as total
-         FROM events
-        WHERE timestamp >= ? AND timestamp < ?
-              AND hook_type = 'PostToolUse'`,
-    ).get(week.startISO, week.endISO) as { total: number };
-
-    const failureRate = postCallRow.total > 0
-      ? `${((failureRow.failed / postCallRow.total) * 100).toFixed(1)}%`
+    // Failure rate: facade 提供 [since, until) 半开区间精确计算。
+    const failure = this.storage.aggregateToolFailureRate({
+      since: week.startISO,
+      until: week.endISO,
+    });
+
+    const failureRate = failure.post_total > 0
+      ? `${((failure.failed / failure.post_total) * 100).toFixed(1)}%`
       : '0.0%';
 
     return {
@@ -255,17 +237,12 @@ export class WeeklyReportGenerator {
   }
 
   private aggregateFiles(week: WeekRange): WeeklyReport['files'] {
-    const db = this.storage.getDatabase();
-
-    const placeholders = Array.from(FILE_EDIT_TOOLS).map(() => '?').join(',');
-    const rows = db.prepare(
-      `SELECT tool_input
-         FROM events
-        WHERE timestamp >= ? AND timestamp < ?
-              AND hook_type = 'PreToolUse'
-              AND tool_name IN (${placeholders})
-              AND tool_input IS NOT NULL`,
-    ).all(week.startISO, week.endISO, ...Array.from(FILE_EDIT_TOOLS)) as Array<{ tool_input: string }>;
+    // H2 Phase 3: 改用 facade 聚合方法。
+    const rows = this.storage.queryFileEditInputs({
+      since: week.startISO,
+      until: week.endISO,
+      tool_names: Array.from(FILE_EDIT_TOOLS),
+    });
 
     const fileMap = new Map<string, number>();
     let totalEdits = 0;
@@ -291,8 +268,8 @@ export class WeeklyReportGenerator {
   }
 
   private aggregateAnomalies(_week: WeekRange): WeeklyReport['anomalies'] {
-    // anti-pattern-detector.ts is being implemented by another agent.
-    // Return empty array until it's available.
+    // Anomaly aggregation is delegated to AntiPatternDetector
+    // (exposed separately via /api/insights). Keep empty here.
     return [];
   }
 

package/src/web/auth-middleware.ts

@@ -11,11 +11,10 @@
  */
 
 import fs from 'fs';
-import path from 'path';
 import type { Request, Response, NextFunction } from 'express';
 import { FORGE_PATHS } from '../core/constants.js';
 
-const TOKEN_FILE = path.join(FORGE_PATHS.home(), 'daemon.token');
+const TOKEN_FILE = FORGE_PATHS.daemonToken();
 
 /** 读取当前 daemon auth token，不存在或读取失败返回 null */
 export function readAuthToken(): string | null {

package/src/web/routes/_helpers.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared helpers for web routes.
+ */
+
+/**
+ * Recursively truncate string/array fields inside an arbitrary value so the
+ * serialised JSON payload stays bounded. Used to keep tool input/output
+ * previews small in /api/tasks and /api/sessions.
+ *
+ * - strings longer than `maxLen` are sliced and suffixed with "..."
+ * - arrays are sliced to the first `arrayLimit` elements (NOT recursed into,
+ *   matching the original call sites' behaviour)
+ * - objects are walked recursively
+ * - everything else is returned as-is (including null/undefined)
+ */
+export function truncateField(
+  obj: unknown,
+  maxLen = 300,
+  arrayLimit = 10,
+): unknown {
+  if (!obj) return obj;
+  if (typeof obj === 'string') {
+    return obj.length > maxLen ? obj.slice(0, maxLen) + '...' : obj;
+  }
+  if (Array.isArray(obj)) return obj.slice(0, arrayLimit);
+  if (typeof obj === 'object') {
+    const result: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {
+      result[k] = truncateField(v, maxLen, arrayLimit);
+    }
+    return result;
+  }
+  return obj;
+}

package/src/web/routes/drift.ts

@@ -1,6 +1,6 @@
 import type { Application } from 'express';
 import type { RouteContext } from './types.js';
-import { DriftDetector } from '../../daemon/services/drift-detector.js';
+import { DriftDetector } from '../analytics/drift-detector.js';
 
 /**
  * /api/drift/* — CLAUDE.md 漂移检测 API

package/src/web/routes/insights.ts

@@ -4,7 +4,7 @@ import {
   AntiPatternDetector,
   type AntiPattern,
   type AntiPatternSeverity,
-} from '../../daemon/services/anti-pattern-detector.js';
+} from '../analytics/anti-pattern-detector.js';
 
 /**
  * /api/insights — 工作流反模式检测 API

package/src/web/routes/reports.ts

@@ -7,7 +7,7 @@
 
 import type { Application } from 'express';
 import type { RouteContext } from './types.js';
-import { WeeklyReportGenerator } from '../../daemon/services/weekly-report.js';
+import { WeeklyReportGenerator } from '../analytics/weekly-report.js';
 
 export function registerReportsRoutes(app: Application, ctx: RouteContext): void {
   const { storage, skillRegistry } = ctx;

package/src/web/routes/rules.ts

@@ -7,11 +7,19 @@
  *   - Per-skill breakdown
  *   - Per-agent breakdown
  *   - Never-triggered skills
+ *
+ * H1 refactor: pushed GROUP BY into SQL via storage.aggregateRoutingStats /
+ * aggregateSkillInvocationsBySkill — no more 100k-row JS scans.
  */
 
 import type { Application } from 'express';
 import type { RouteContext } from './types.js';
 
+function pct(num: number, denom: number): string {
+  if (denom <= 0) return '0%';
+  return `${(num / denom * 100).toFixed(1)}%`;
+}
+
 export function registerRulesRoutes(app: Application, ctx: RouteContext): void {
   const { storage, skillRegistry } = ctx;
 
@@ -20,68 +28,35 @@ export function registerRulesRoutes(app: Application, ctx: RouteContext): void {
     const since = Date.now() - days * 24 * 3600 * 1000;
     const sinceISO = new Date(since).toISOString();
 
-    // Query routing events
-    const routingEvents = storage.queryRoutingEvents({ since_ts: since, limit: 100000 });
-    const totalPrompts = routingEvents.length;
-
-    // Agent delegations: obeyed=1 means the routing was followed
-    const agentDelegations = routingEvents.filter(e => e.obeyed === 1).length;
-    const agentRate = totalPrompts > 0
-      ? `${(agentDelegations / totalPrompts * 100).toFixed(1)}%`
-      : '0%';
-
-    // Skill invocations
-    const skillInvocations = storage.querySkillInvocations({ since, limit: 100000 });
-    const skillTotal = skillInvocations.length;
-    const skillRate = totalPrompts > 0
-      ? `${(skillTotal / totalPrompts * 100).toFixed(1)}%`
-      : '0%';
-
-    // Per-skill aggregation
-    const skillMap = new Map<string, { total: number; success: number; failed: number }>();
-    for (const inv of skillInvocations) {
-      const cur = skillMap.get(inv.skill_id) || { total: 0, success: 0, failed: 0 };
-      cur.total++;
-      if (inv.success === 1) cur.success++;
-      else cur.failed++;
-      skillMap.set(inv.skill_id, cur);
-    }
+    // SQL-side aggregates (replaces 2 × 100k-row scans + JS reduce)
+    const routing = storage.aggregateRoutingStats({ since_ts: since });
+    const skillsAgg = storage.aggregateSkillInvocationsBySkill({ since });
 
-    const skills = Array.from(skillMap.entries())
-      .map(([skill_id, s]) => ({
-        skill_id,
-        total: s.total,
-        success: s.success,
-        failed: s.failed,
-        rate: totalPrompts > 0
-          ? `${(s.total / totalPrompts * 100).toFixed(1)}%`
-          : '0%',
-      }))
-      .sort((a, b) => b.total - a.total);
+    const totalPrompts = routing.total;
+    const agentDelegations = routing.obeyed;
 
-    // Per-agent aggregation (only obeyed delegations)
-    const agentMap = new Map<string, number>();
-    for (const e of routingEvents) {
-      if (e.obeyed === 1 && e.routed_to_name) {
-        agentMap.set(e.routed_to_name, (agentMap.get(e.routed_to_name) || 0) + 1);
-      }
-    }
+    // Skills frequency (sorted by total desc — SQL ORDER BY total DESC)
+    const skillTotal = skillsAgg.reduce((acc, s) => acc + s.total, 0);
+    const skills = skillsAgg.map(s => ({
+      skill_id: s.skill_id,
+      total: s.total,
+      success: s.success,
+      failed: s.failed,
+      rate: pct(s.total, totalPrompts),
+    }));
 
-    const agents = Array.from(agentMap.entries())
-      .map(([agent, count]) => ({
-        agent,
-        count,
-        rate: totalPrompts > 0
-          ? `${(count / totalPrompts * 100).toFixed(1)}%`
-          : '0%',
-      }))
-      .sort((a, b) => b.count - a.count);
+    // Agents breakdown (already obeyed=1, sorted by count desc in SQL)
+    const agents = routing.by_agent.map(a => ({
+      agent: a.agent,
+      count: a.count,
+      rate: pct(a.count, totalPrompts),
+    }));
 
     // Never-triggered skills
+    const triggeredSkillIds = new Set(skillsAgg.map(s => s.skill_id));
     const allSkillIds = skillRegistry
       ? skillRegistry.getAll().map(s => s.id)
       : [];
-    const triggeredSkillIds = new Set(skillMap.keys());
     const neverTriggered = allSkillIds.filter(id => !triggeredSkillIds.has(id));
 
     res.json({
@@ -89,9 +64,9 @@ export function registerRulesRoutes(app: Application, ctx: RouteContext): void {
       summary: {
         totalPrompts,
         agentDelegations,
-        agentRate,
+        agentRate: pct(agentDelegations, totalPrompts),
         skillInvocations: skillTotal,
-        skillRate,
+        skillRate: pct(skillTotal, totalPrompts),
       },
       skills,
       agents,

package/src/web/routes/sessions.ts

@@ -1,5 +1,7 @@
 import type { Application } from 'express';
 import type { RouteContext } from './types.js';
+import { truncateField } from './_helpers.js';
+import { getCommand, getFilePath, getUserPrompt } from '../../core/event-fields.js';
 
 /**
  * /api/sessions* — session lists, per-session detail, timeline.
@@ -78,22 +80,22 @@ export function registerSessionsRoutes(app: Application, ctx: RouteContext): voi
 
     const buildTaskDetail = (events: typeof allEvents, injections: typeof allInjections) => {
       const prompts = events
-        .filter(e => e.hook_type === 'UserPromptSubmit' && (e.user_prompt || (e.tool_input as any)?.user_prompt))
-        .map(e => ({ timestamp: e.timestamp, content: e.user_prompt || (e.tool_input as any)?.user_prompt }));
+        .filter(e => e.hook_type === 'UserPromptSubmit' && getUserPrompt(e))
+        .map(e => ({ timestamp: e.timestamp, content: getUserPrompt(e) }));
 
       const toolUsage: Record<string, number> = {};
       events.forEach(e => { if (e.tool_name) toolUsage[e.tool_name] = (toolUsage[e.tool_name] || 0) + 1; });
 
       const filesChanged = [...new Set(
         events
-          .filter(e => (e.tool_name === 'Edit' || e.tool_name === 'Write') && (e.tool_input as any)?.file_path)
-          .map(e => (e.tool_input as any).file_path),
+          .filter(e => (e.tool_name === 'Edit' || e.tool_name === 'Write') && getFilePath(e))
+          .map(e => getFilePath(e)!),
       )];
 
       const commits = events
-        .filter(e => e.tool_name === 'Bash' && (e.tool_input as any)?.command?.includes('git commit'))
+        .filter(e => e.tool_name === 'Bash' && getCommand(e)?.includes('git commit'))
         .map(e => {
-          const cmd = (e.tool_input as any)?.command || '';
+          const cmd = getCommand(e) || '';
           const match = cmd.match(/git commit.*-m\s+["']([^"']+)["']/);
           return { timestamp: e.timestamp, message: match ? match[1] : 'commit' };
         });
@@ -155,12 +157,12 @@ export function registerSessionsRoutes(app: Application, ctx: RouteContext): voi
 
     // User inputs
     events
-      .filter(e => e.hook_type === 'UserPromptSubmit' && (e.user_prompt || (e.tool_input as any)?.user_prompt))
+      .filter(e => e.hook_type === 'UserPromptSubmit' && getUserPrompt(e))
       .forEach(e => {
         timeline.push({
           timestamp: e.timestamp,
           type: 'user_input',
-          data: { content: e.user_prompt || (e.tool_input as any)?.user_prompt },
+          data: { content: getUserPrompt(e) },
         });
       });
 
@@ -183,30 +185,16 @@ export function registerSessionsRoutes(app: Application, ctx: RouteContext): voi
     events
       .filter(e => e.tool_name && e.hook_type === 'PreToolUse')
       .forEach(e => {
-        const toolInput = e.tool_input as any;
-        const toolOutput = e.tool_output as any;
-
-        const truncateField = (obj: any, maxLen = 200): any => {
-          if (!obj) return obj;
-          if (typeof obj === 'string') return obj.length > maxLen ? obj.slice(0, maxLen) + '...' : obj;
-          if (Array.isArray(obj)) return obj.slice(0, 5);
-          if (typeof obj === 'object') {
-            const result: any = {};
-            for (const [k, v] of Object.entries(obj)) {
-              result[k] = truncateField(v, maxLen);
-            }
-            return result;
-          }
-          return obj;
-        };
+        const toolInput = e.tool_input;
+        const toolOutput = e.tool_output;
 
         timeline.push({
           timestamp: e.timestamp,
           type: 'tool_call',
           data: {
             tool: e.tool_name,
-            input: truncateField(toolInput),
-            output: truncateField(toolOutput),
+            input: truncateField(toolInput, 200, 5),
+            output: truncateField(toolOutput, 200, 5),
             success: !toolOutput?.error,
           },
         });
@@ -233,17 +221,17 @@ export function registerSessionsRoutes(app: Application, ctx: RouteContext): voi
 
     // Summary
     const commits = events
-      .filter(e => e.tool_name === 'Bash' && (e.tool_input as any)?.command?.includes('git commit'))
+      .filter(e => e.tool_name === 'Bash' && getCommand(e)?.includes('git commit'))
       .map(e => {
-        const cmd = (e.tool_input as any)?.command || '';
+        const cmd = getCommand(e) || '';
         const match = cmd.match(/git commit.*-m\s+["']([^"']+)["']/);
         return { message: match ? match[1] : 'commit' };
       });
 
     const filesChanged = [...new Set(
       events
-        .filter(e => (e.tool_name === 'Edit' || e.tool_name === 'Write') && (e.tool_input as any)?.file_path)
-        .map(e => (e.tool_input as any).file_path),
+        .filter(e => (e.tool_name === 'Edit' || e.tool_name === 'Write') && getFilePath(e))
+        .map(e => getFilePath(e)!),
     )];
 
     res.json({