@winspan/claude-forge 8.50.6 → 8.51.0

package/src/core/storage/sqlite.ts

@@ -83,6 +83,7 @@ export class SQLiteStorage extends EventEmitter {
   }
 
   // ── Database accessors ─────────────────────────────────────────────────
+  /** @internal 见 SQLiteBase.getDatabase 注释。Routes/Handlers/Analytics 禁止调用。 */
   getDatabase(): Database.Database { return this.base.getDatabase(); }
   getDbPath(): string { return this.base.getDbPath(); }
 
@@ -96,11 +97,58 @@ export class SQLiteStorage extends EventEmitter {
     return this.events.searchEvents(filter);
   }
 
+  // ── H2: Event aggregates (前 routes/handlers/analytics 越权 SQL) ──
+  countAllEvents(): number { return this.events.countAllEvents(); }
+  aggregateToolUsage(opts?: Parameters<EventOperations['aggregateToolUsage']>[0]): ReturnType<EventOperations['aggregateToolUsage']> {
+    return this.events.aggregateToolUsage(opts);
+  }
+  aggregateDailyEventCounts(opts: Parameters<EventOperations['aggregateDailyEventCounts']>[0]): ReturnType<EventOperations['aggregateDailyEventCounts']> {
+    return this.events.aggregateDailyEventCounts(opts);
+  }
+  aggregateHookTypeBySession(session_id: string): ReturnType<EventOperations['aggregateHookTypeBySession']> {
+    return this.events.aggregateHookTypeBySession(session_id);
+  }
+  aggregateAgentTypeBySession(session_id: string): ReturnType<EventOperations['aggregateAgentTypeBySession']> {
+    return this.events.aggregateAgentTypeBySession(session_id);
+  }
+  aggregateToolUsageBySession(session_id: string): ReturnType<EventOperations['aggregateToolUsageBySession']> {
+    return this.events.aggregateToolUsageBySession(session_id);
+  }
+  countActiveDays(opts: Parameters<EventOperations['countActiveDays']>[0]): number {
+    return this.events.countActiveDays(opts);
+  }
+  aggregateOverviewByRange(opts: Parameters<EventOperations['aggregateOverviewByRange']>[0]): ReturnType<EventOperations['aggregateOverviewByRange']> {
+    return this.events.aggregateOverviewByRange(opts);
+  }
+  queryDistinctProjects(opts: Parameters<EventOperations['queryDistinctProjects']>[0]): string[] {
+    return this.events.queryDistinctProjects(opts);
+  }
+  aggregateToolFailureRate(opts: Parameters<EventOperations['aggregateToolFailureRate']>[0]): ReturnType<EventOperations['aggregateToolFailureRate']> {
+    return this.events.aggregateToolFailureRate(opts);
+  }
+  queryFileEditInputs(opts: Parameters<EventOperations['queryFileEditInputs']>[0]): ReturnType<EventOperations['queryFileEditInputs']> {
+    return this.events.queryFileEditInputs(opts);
+  }
+  queryEventsByTimeRange(opts: Parameters<EventOperations['queryEventsByTimeRange']>[0]): ForgeEvent[] {
+    return this.events.queryEventsByTimeRange(opts);
+  }
+
   // ── Session operations ─────────────────────────────────────────────────
   upsertSession(event: ForgeEvent): void { this.sessions.upsertSession(event); }
   querySessions(filter: Parameters<SessionOperations['querySessions']>[0] = {}): SessionSummary[] {
     return this.sessions.querySessions(filter);
   }
+  // ── H2: Session aggregates ──
+  countAllSessions(): number { return this.sessions.countAllSessions(); }
+  aggregateDailySessionCounts(opts: Parameters<SessionOperations['aggregateDailySessionCounts']>[0]): ReturnType<SessionOperations['aggregateDailySessionCounts']> {
+    return this.sessions.aggregateDailySessionCounts(opts);
+  }
+  querySessionsByTimeRange(opts: Parameters<SessionOperations['querySessionsByTimeRange']>[0]): SessionSummary[] {
+    return this.sessions.querySessionsByTimeRange(opts);
+  }
+  countSessionsByRange(opts: Parameters<SessionOperations['countSessionsByRange']>[0]): number {
+    return this.sessions.countSessionsByRange(opts);
+  }
 
   // ── Injection operations ───────────────────────────────────────────────
   writeInjection(injection: Injection): void { this.injections.writeInjection(injection); }
@@ -127,7 +175,29 @@ export class SQLiteStorage extends EventEmitter {
   queryTaskProjects(): string[] {
     return this.tasks.queryTaskProjects();
   }
+  // ── H2: Task counts ──
+  countTasksByRange(opts: Parameters<TaskOperations['countTasksByRange']>[0]): number {
+    return this.tasks.countTasksByRange(opts);
+  }
   getTaskEventIds(taskId: string): string[] { return this.tasks.getTaskEventIds(taskId); }
+  completeStaleActiveTasks(idleMinutes: number): number {
+    return this.tasks.completeStaleActiveTasks(idleMinutes);
+  }
+  getTask(taskId: string): TaskRecord | null {
+    return this.tasks.getTask(taskId);
+  }
+  queryEventsByTaskId(taskId: string, opts?: Parameters<TaskOperations['queryEventsByTaskId']>[1]): ForgeEvent[] {
+    return this.tasks.queryEventsByTaskId(taskId, opts);
+  }
+  queryInjectionsByTaskId(taskId: string): Injection[] {
+    return this.tasks.queryInjectionsByTaskId(taskId);
+  }
+  querySkillInvocationsByTaskWindow(
+    taskId: string,
+    opts?: Parameters<TaskOperations['querySkillInvocationsByTaskWindow']>[1],
+  ): SkillInvocationRow[] {
+    return this.tasks.querySkillInvocationsByTaskWindow(taskId, opts);
+  }
 
   // ── Routing events ─────────────────────────────────────────────────────
   writeRoutingEvent(record: RoutingEventRecord): number {
@@ -139,12 +209,25 @@ export class SQLiteStorage extends EventEmitter {
   queryRoutingEvents(filter: Parameters<RoutingOperations['queryRoutingEvents']>[0] = {}): RoutingEventRow[] {
     return this.routing.queryRoutingEvents(filter);
   }
-  findPendingRoutingEvents(ageMs: number): RoutingEventRow[] {
-    return this.routing.findPendingRoutingEvents(ageMs);
+  aggregateRoutingStats(
+    filter: Parameters<RoutingOperations['aggregateRoutingStats']>[0],
+  ): ReturnType<RoutingOperations['aggregateRoutingStats']> {
+    return this.routing.aggregateRoutingStats(filter);
+  }
+  aggregateRoutingTrendByDay(
+    filter: Parameters<RoutingOperations['aggregateRoutingTrendByDay']>[0],
+  ): ReturnType<RoutingOperations['aggregateRoutingTrendByDay']> {
+    return this.routing.aggregateRoutingTrendByDay(filter);
+  }
+  queryPendingRoutingEvents(ageMs: number): RoutingEventRow[] {
+    return this.routing.queryPendingRoutingEvents(ageMs);
   }
   getRecentRoutingEvent(sessionId: string): { id: number } | null {
     return this.routing.getRecentRoutingEvent(sessionId);
   }
+  getRecentPendingRoutingEvent(sessionId: string): { id: number } | null {
+    return this.routing.getRecentPendingRoutingEvent(sessionId);
+  }
 
   // ── Experiment assignments ─────────────────────────────────────────────
   getExperimentAssignment(sessionId: string, experimentId: string): string | null {
@@ -158,8 +241,8 @@ export class SQLiteStorage extends EventEmitter {
   }
 
   // ── Token usage ────────────────────────────────────────────────────────
-  recordTokenUsage(params: Parameters<TokenUsageOperations['recordTokenUsage']>[0]): void {
-    this.tokenUsage.recordTokenUsage(params);
+  writeTokenUsage(params: Parameters<TokenUsageOperations['writeTokenUsage']>[0]): void {
+    this.tokenUsage.writeTokenUsage(params);
   }
   getTokenUsageBySession(session_id: string): ReturnType<TokenUsageOperations['getTokenUsageBySession']> {
     return this.tokenUsage.getTokenUsageBySession(session_id);
@@ -175,9 +258,25 @@ export class SQLiteStorage extends EventEmitter {
   querySkillInvocations(filter: Parameters<SkillOperations['querySkillInvocations']>[0] = {}): SkillInvocationRow[] {
     return this.skills.querySkillInvocations(filter);
   }
+  aggregateSkillInvocationsBySkill(
+    filter: Parameters<SkillOperations['aggregateSkillInvocationsBySkill']>[0],
+  ): ReturnType<SkillOperations['aggregateSkillInvocationsBySkill']> {
+    return this.skills.aggregateSkillInvocationsBySkill(filter);
+  }
   queryWorkflowProgress(filter: Parameters<SkillOperations['queryWorkflowProgress']>[0] = {}): ReturnType<SkillOperations['queryWorkflowProgress']> {
     return this.skills.queryWorkflowProgress(filter);
   }
+  // ── H2: Skill counts ──
+  countAllSkillInvocations(): number { return this.skills.countAllSkillInvocations(); }
+  countSkillInvocationsBySession(session_id: string): number {
+    return this.skills.countSkillInvocationsBySession(session_id);
+  }
+  countDistinctSkillsSince(since_ms: number): number {
+    return this.skills.countDistinctSkillsSince(since_ms);
+  }
+  queryDistinctSkillIdsBySession(session_id: string): string[] {
+    return this.skills.queryDistinctSkillIdsBySession(session_id);
+  }
 
   // ── Maintenance ────────────────────────────────────────────────────────
   cleanOldEvents(daysToKeep: number = 30): number { return this.maintenance.cleanOldEvents(daysToKeep); }

package/src/core/storage/tasks.ts

@@ -5,6 +5,9 @@
  */
 
 import type Database from 'better-sqlite3';
+import type { ForgeEvent } from '../types.js';
+import type { SkillInvocationRow } from './rows.js';
+import type { Injection } from './injections.js';
 
 export interface TaskRecord {
   id: string;
@@ -16,6 +19,9 @@ export interface TaskRecord {
   status: 'active' | 'completed' | 'abandoned';
   event_count: number;
   project_path?: string;
+  /** First UserPromptSubmit user_prompt text for this task's session window.
+   *  Populated by queryTasksFiltered via correlated subquery on idx_events_session_hook. */
+  first_prompt?: string | null;
 }
 
 export interface TaskFilter {
@@ -92,7 +98,14 @@ export class TaskOperations {
     // Data query
     const dataParams = [...params, limit, offset];
     const rows = this.db.prepare(
-      `SELECT t.*, s.project_path
+      `SELECT t.*, s.project_path,
+              (SELECT e.user_prompt
+               FROM events e
+               WHERE e.session_id = t.session_id
+                 AND e.hook_type = 'UserPromptSubmit'
+                 AND e.timestamp >= t.start_time
+                 AND (t.end_time IS NULL OR e.timestamp <= t.end_time)
+               ORDER BY e.timestamp ASC LIMIT 1) AS first_prompt
        FROM tasks t
        JOIN sessions s ON t.session_id = s.session_id
        ${where}
@@ -104,6 +117,19 @@ export class TaskOperations {
     return { items, total, has_more: offset + items.length < total };
   }
 
+  /** Count of tasks with start_time in [since, until?). */
+  countTasksByRange(opts: { since: string; until?: string }): number {
+    const conditions: string[] = ['start_time >= ?'];
+    const params: unknown[] = [opts.since];
+    if (opts.until !== undefined) {
+      conditions.push('start_time < ?');
+      params.push(opts.until);
+    }
+    const sql = `SELECT COUNT(*) as cnt FROM tasks WHERE ${conditions.join(' AND ')}`;
+    const row = this.db.prepare(sql).get(...params) as { cnt: number } | undefined;
+    return row?.cnt ?? 0;
+  }
+
   /** Returns distinct project paths that have at least one task. */
   queryTaskProjects(): string[] {
     const rows = this.db.prepare(
@@ -120,6 +146,127 @@ export class TaskOperations {
     return rows.map(r => r.event_id);
   }
 
+  /**
+   * 将 idle 超过阈值的 active task 批量转为 completed。
+   * 条件：status='active' AND end_time IS NOT NULL
+   *       AND (now - end_time) > idleMinutes 分钟。
+   * 返回：受影响行数。
+   */
+  completeStaleActiveTasks(idleMinutes: number): number {
+    const result = this.db.prepare(`
+      UPDATE tasks
+      SET status = 'completed'
+      WHERE status = 'active'
+        AND end_time IS NOT NULL
+        AND (julianday('now') - julianday(end_time)) * 24 * 60 > ?
+    `).run(idleMinutes);
+    return result.changes as number;
+  }
+
+  // ── H1: detail route 用的 PK 直查 / JOIN 接口 ──────────────────────
+
+  /**
+   * 按 taskId 直查单个 task（LEFT JOIN sessions 取 project_path）。
+   * 替代旧 detail route 的「拉 5000 tasks 再 find(id)」。
+   */
+  getTask(taskId: string): TaskRecord | null {
+    const row = this.db.prepare(`
+      SELECT t.*, s.project_path
+      FROM tasks t
+      LEFT JOIN sessions s ON s.session_id = t.session_id
+      WHERE t.id = ?
+    `).get(taskId) as Record<string, unknown> | undefined;
+    if (!row) return null;
+    return this.mapRow(row);
+  }
+
+  /**
+   * 按 taskId JOIN task_events 拉关联事件，按 timestamp 升序。
+   * 默认 limit 5000（防御过大 task；前端不分页但要有上限）。
+   */
+  queryEventsByTaskId(taskId: string, opts: { limit?: number } = {}): ForgeEvent[] {
+    const limit = opts.limit ?? 5000;
+    const rows = this.db.prepare(`
+      SELECT e.*
+      FROM events e
+      JOIN task_events te ON te.event_id = e.event_id
+      WHERE te.task_id = ?
+      ORDER BY e.timestamp ASC
+      LIMIT ?
+    `).all(taskId, limit) as Array<Record<string, unknown>>;
+    return rows.map(r => this.rowToEvent(r));
+  }
+
+  /**
+   * 按 taskId JOIN task_events 拉关联 injections，按 timestamp 升序。
+   * 替代「拉 500 injections + JS Set.has 过滤」。
+   */
+  queryInjectionsByTaskId(taskId: string): Injection[] {
+    const rows = this.db.prepare(`
+      SELECT i.*
+      FROM injections i
+      JOIN task_events te ON te.event_id = i.event_id
+      WHERE te.task_id = ?
+      ORDER BY i.timestamp ASC
+    `).all(taskId) as Array<Record<string, unknown>>;
+    return rows.map(r => ({
+      id: r.id as string,
+      event_id: (r.event_id as string) || undefined,
+      session_id: r.session_id as string,
+      timestamp: r.timestamp as string,
+      source_handler: r.source_handler as string,
+      injection_type: r.injection_type as Injection['injection_type'],
+      content: r.content as string,
+    }));
+  }
+
+  /**
+   * 按 task 的时间窗口 + session_id 过滤 skill_invocations。
+   * 替代「拉 200 invocations + JS 时间比较」。
+   * `now_ms` 通过参数注入（end_time IS NULL 时取此值），便于测试时 mock。
+   *
+   * 时间转换：strftime('%s', ISO_TS) 返回 unix 秒（丢毫秒），× 1000 → ms。
+   * 与旧实现 `new Date(taskStart).getTime()` 相比可能损失最多 999ms，
+   * 但 task 时间窗口通常远大于秒级，对结果集影响可忽略。
+   */
+  querySkillInvocationsByTaskWindow(taskId: string, opts: { now_ms?: number } = {}): SkillInvocationRow[] {
+    const nowMs = opts.now_ms ?? Date.now();
+    const rows = this.db.prepare(`
+      SELECT si.*
+      FROM skill_invocations si
+      JOIN tasks t ON t.session_id = si.session_id
+      WHERE t.id = ?
+        AND si.timestamp >= CAST(strftime('%s', t.start_time) AS INTEGER) * 1000
+        AND si.timestamp <= COALESCE(
+              CAST(strftime('%s', t.end_time) AS INTEGER) * 1000 + 999,
+              ?
+            )
+      ORDER BY si.timestamp ASC
+    `).all(taskId, nowMs) as SkillInvocationRow[];
+    return rows;
+  }
+
+  /** Map a raw events row to ForgeEvent (parses JSON columns). */
+  private rowToEvent(row: Record<string, unknown>): ForgeEvent {
+    const parseJson = (val: unknown): unknown => {
+      if (val == null) return undefined;
+      if (typeof val !== 'string') return val;
+      try { return JSON.parse(val); } catch { return val; }
+    };
+    return {
+      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: parseJson(row.tool_input) as ForgeEvent['tool_input'],
+      tool_output: parseJson(row.tool_output) as ForgeEvent['tool_output'],
+      user_prompt: (row.user_prompt as string) || undefined,
+      ai_response: (row.ai_response as string) || undefined,
+    };
+  }
+
   private buildWhereConditions(filter: TaskFilter): { conditions: string[]; params: unknown[] } {
     const conditions: string[] = [];
     const params: unknown[] = [];
@@ -165,6 +312,7 @@ export class TaskOperations {
       status: (r.status as TaskRecord['status']) || 'active',
       event_count: (r.event_count as number) || 0,
       project_path: (r.project_path as string) || undefined,
+      first_prompt: r.first_prompt !== undefined ? (r.first_prompt as string | null) : undefined,
     };
   }
 }

package/src/core/storage/token-usage.ts

@@ -10,7 +10,7 @@ import { logger } from '../utils/logger.js';
 export class TokenUsageOperations {
   constructor(private db: Database.Database) {}
 
-  recordTokenUsage(params: {
+  writeTokenUsage(params: {
     session_id: string;
     input_tokens: number;
     output_tokens: number;

package/src/core/types.ts

@@ -21,17 +21,45 @@
  * (no more `event.tool_name!`) without forcing every caller of the wire
  * shape to do a 5-way switch.
  */
+/**
+ * Lenient bag of common tool_input fields across all Claude Code tools.
+ *
+ * Intentionally not a discriminated union — the tool set is open-ended and
+ * almost all access sites are defensive (`?.command ?? ''`). The index
+ * signature keeps forward compatibility with unknown tool kinds; prefer
+ * the typed getters in `core/event-fields.ts` over direct field access
+ * when the value is fed downstream as `string`.
+ */
+export interface ToolInputFields {
+  // Bash
+  command?: string;
+  description?: string;
+  // Edit / Write / Read / NotebookEdit
+  file_path?: string;
+  notebook_path?: string;
+  old_string?: string;
+  new_string?: string;
+  content?: string;
+  // Agent / Task
+  subagent_type?: string;
+  name?: string;
+  prompt?: string;
+  // UserPromptSubmit fallback envelope (some hook flows pack user_prompt here)
+  user_prompt?: string;
+  // Forward-compat for unknown tools / new Claude Code releases
+  [key: string]: unknown;
+}
+
 export interface ForgeEvent {
   session_id: string;
   project_path: string;
   timestamp: string;
   hook_type: 'PreToolUse' | 'PostToolUse' | 'UserPromptSubmit' | 'Notification' | 'Stop';
   tool_name?: string;
-  tool_input?: Record<string, unknown>;
+  tool_input?: ToolInputFields;
   tool_output?: Record<string, unknown>;
   user_prompt?: string;
   ai_response?: string;
-  pipeline_id?: string;
   event_id?: string;
 }
 
@@ -40,7 +68,6 @@ interface BaseEvent {
   project_path: string;
   timestamp: string;
   event_id?: string;
-  pipeline_id?: string;
 }
 
 export interface PreToolUseEvent extends BaseEvent {

package/src/core/utils/error-handler.ts

@@ -5,6 +5,7 @@
  */
 
 import { logger } from './logger.js';
+import { DEFAULTS } from '../constants.js';
 import chalk from 'chalk';
 
 export interface ErrorSolution {
@@ -221,7 +222,7 @@ export class ErrorHandler {
 
     // 根据错误类型自动识别并生成解决方案
     if (error.code === 'EADDRINUSE') {
-      const port = parseInt(error.message?.match(/:(\d+)/)?.[1] || '3721');
+      const port = parseInt(error.message?.match(/:(\d+)/)?.[1] || String(DEFAULTS.WEB_PORT));
       solution = this.handlePortInUse(port, error);
     } else if (error.code === 'EACCES' || error.code === 'EPERM') {
       const path = error.path || error.message?.match(/['"]([^'"]+)['"]/)?.[1] || 'unknown';
@@ -235,7 +236,7 @@ export class ErrorHandler {
       const dbPath = error.message?.match(/['"]([^'"]+\.db)['"]/)?.[1] || '~/.claude-forge/data.db';
       solution = this.handleDatabaseError(dbPath, error);
     } else if (error.code === 'ECONNREFUSED' || error.code === 'ENOENT') {
-      const socketPath = error.path || '~/.claude-forge/forge.sock';
+      const socketPath = error.path || '~/.claude-forge/daemon.sock';
       solution = this.handleSocketError(socketPath, error);
     } else {
       // 通用错误

package/src/core/utils/git.ts

@@ -0,0 +1,23 @@
+import { execSync } from 'node:child_process';
+
+/**
+ * Walk up the directory tree from `start` using `git rev-parse --show-toplevel`
+ * to find the git repository root.
+ *
+ * Fallback: returns `start` unchanged if:
+ *   - `start` is not inside a git repository
+ *   - the git command fails for any reason (git not on PATH, permission error, etc.)
+ */
+export function resolveGitRoot(start: string = process.cwd()): string {
+  try {
+    const result = execSync('git rev-parse --show-toplevel', {
+      cwd: start,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+      .toString()
+      .trim();
+    return result || start;
+  } catch {
+    return start;
+  }
+}

package/src/core/utils/logger.ts

@@ -12,7 +12,22 @@ export enum LogLevel {
   ERROR = 3,
 }
 
-let currentLevel = LogLevel.INFO;
+/**
+ * Parse log level from LOG_LEVEL env var.
+ * Accepts: debug, info, warn, error (case-insensitive). Falls back to INFO.
+ */
+function getLogLevelFromEnv(): LogLevel {
+  const envLevel = (process.env.LOG_LEVEL ?? '').toLowerCase();
+  const levelMap: Record<string, LogLevel> = {
+    debug: LogLevel.DEBUG,
+    info: LogLevel.INFO,
+    warn: LogLevel.WARN,
+    error: LogLevel.ERROR,
+  };
+  return levelMap[envLevel] ?? LogLevel.INFO;
+}
+
+let currentLevel: LogLevel = getLogLevelFromEnv();
 let logFilePath: string | null = null;
 let lastSizeCheck = 0;
 let cachedSize = 0;

package/src/core/utils/lru-cache.ts

@@ -40,6 +40,10 @@ export class LRUCache<K, V> {
     return this.cache.has(key);
   }
 
+  delete(key: K): boolean {
+    return this.cache.delete(key);
+  }
+
   clear(): void {
     this.cache.clear();
   }

package/src/core/utils/token-tracker.ts

@@ -33,7 +33,7 @@ export class TokenTracker {
    */
   record(params: TokenRecordParams): void {
     try {
-      this.storage.recordTokenUsage({
+      this.storage.writeTokenUsage({
         session_id: params.session_id,
         input_tokens: params.usage.input_tokens,
         output_tokens: params.usage.output_tokens,

package/src/daemon/event-parser.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { ForgeEvent } from '../core/types.js';
+import type { ForgeEvent, ToolInputFields } from '../core/types.js';
 import { randomUUID } from 'crypto';
 
 const RawHookEventSchema = z.object({
@@ -12,6 +12,7 @@ const RawHookEventSchema = z.object({
   tool_output: z.record(z.string(), z.unknown()).optional(),
   user_prompt: z.string().optional(),
   ai_response: z.string().optional(),
+  event_id: z.string().uuid().optional(),
 });
 
 export class EventParser {
@@ -20,13 +21,13 @@ export class EventParser {
     const validated = RawHookEventSchema.parse(json);
 
     return {
-      event_id: randomUUID(),
+      event_id: validated.event_id ?? randomUUID(),
       session_id: validated.session_id,
       project_path: validated.project_path,
       timestamp: validated.timestamp,
       hook_type: validated.hook_type,
       tool_name: validated.tool_name,
-      tool_input: validated.tool_input as Record<string, unknown> | undefined,
+      tool_input: validated.tool_input as ToolInputFields | undefined,
       tool_output: validated.tool_output as Record<string, unknown> | undefined,
       user_prompt: validated.user_prompt,
       ai_response: validated.ai_response,

package/src/daemon/handlers/history-exporter.ts

@@ -99,7 +99,7 @@ export class HistoryExporter {
       lines.push('');
       for (const t of toolCalls.slice(-30)) {
         const time = new Date(t.timestamp).toLocaleTimeString();
-        const input = t.tool_input as Record<string, unknown> | undefined;
+        const input = t.tool_input;
         const filePath = input?.file_path ?? input?.command ?? '';
         const summary =
           typeof filePath === 'string' ? filePath.slice(0, 80) : '';

package/src/daemon/handlers/post-tool-use.ts

@@ -9,6 +9,7 @@ import type { PostToolUseEvent, HookResult } from '../../core/types.js';
 import type { SQLiteStorage } from '../../core/storage/sqlite.js';
 import { logger } from '../../core/utils/logger.js';
 import { TokenTracker } from '../../core/utils/token-tracker.js';
+import { getSubagentType } from '../../core/event-fields.js';
 
 export class PostToolUseHandler {
   private tokenTracker: TokenTracker | null = null;
@@ -26,10 +27,13 @@ export class PostToolUseHandler {
     if (this.storage && event.tool_name === 'Agent') {
       try {
         // PostToolUseEvent.tool_input is already a Record (narrowed by type guard).
-        const agentType = (event.tool_input.subagent_type as string) || 'general-purpose';
+        const agentType = getSubagentType(event) ?? 'general-purpose';
 
-        // Find the most recent routing_event for this session
-        const recentEvent = this.storage.getRecentRoutingEvent(event.session_id);
+        // Find the most recent PENDING routing_event for this session
+        // (obeyed IS NULL). Filtering on pending prevents re-overwriting an
+        // already-completed event when 2+ Agents fire within the same prompt,
+        // or when an old obeyed=1 row leaks past a missed UserPromptSubmit.
+        const recentEvent = this.storage.getRecentPendingRoutingEvent(event.session_id);
         if (recentEvent) {
           this.storage.updateRoutingEvent(recentEvent.id, {
             routed_to_type: 'agent',