@winspan/claude-forge 8.54.4 → 9.12.0

package/dist/core/storage/events.js

@@ -10,7 +10,15 @@
  */
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
+import { extractSpawnFields } from '../event-fields.js';
 import { logger } from '../utils/logger.js';
+import { encodeToolInput, decodeToolInput, encodeToolOutput, decodeToolOutput, } from './codec/tool-input-codec.js';
+/**
+ * Per-row cap on backfilled `ai_response` text (spec 1446). Mirrors the
+ * event-parser MAX_PROMPT_CHARS magnitude (100 K chars) so a pathological
+ * violation window can't write a multi-MB string into one row.
+ */
+export const MAX_AI_RESPONSE_CHARS = 100 * 1024;
 // Zod schema for runtime validation
 const ForgeEventSchema = z.object({
     event_id: z.string().uuid().optional(),
@@ -30,6 +38,10 @@ const ForgeEventSchema = z.object({
     user_prompt: z.string().optional(),
     ai_response: z.string().optional(),
 });
+// `tool_input` and `tool_output` are validated as permissive unions: legacy
+// rows hold plain JSON text; new rows may hold either UTF-8 bytes (tiny-input
+// skip) or gzip Buffer bytes. Zod can't usefully introspect binary, so we
+// accept any Buffer/Uint8Array via `z.any()` and let the codec parse it.
 const DatabaseRowSchema = z.object({
     event_id: z.string(),
     session_id: z.string(),
@@ -37,17 +49,39 @@ const DatabaseRowSchema = z.object({
     timestamp: z.string(),
     hook_type: z.string(),
     tool_name: z.union([z.string(), z.null()]),
-    tool_input: z.union([z.string(), z.null()]),
-    tool_output: z.union([z.string(), z.null()]),
+    tool_input: z.union([z.string(), z.null(), z.any()]),
+    // tool_output is now codec-encoded for new rows (2026-05-26 perf PR).
+    // Legacy rows remain plain JSON text — magic-byte sniff handles both.
+    tool_output: z.union([z.string(), z.null(), z.any()]),
     user_prompt: z.union([z.string(), z.null()]),
     ai_response: z.union([z.string(), z.null()]),
 });
+// TODO (storage-perf follow-up, 2026-05-26): the remaining un-cached
+// `this.db.prepare(...)` callsites in EventOperations are listed here so a
+// future sweep can promote them to constructor-time Statement fields.
+// Hot-path (writeEvent) is already cached below.
+//
+//   - queryEvents                (line ~167) — variable WHERE, harder to cache
+//   - queryEventsTimeline        (line ~221)
+//   - countEvents                (lines ~262, ~284) — variable WHERE
+//   - searchEvents               (multiple)
+//   - all aggregate*/queryDistinct* analytics queries (~lines 480-635)
+//   - expireToolInputBatch / deleteEventsByCutoff (TTL sweep)
+//
+// Cached now: writeEvent INSERT (hottest — fires per event/day).
 export class EventOperations {
     db;
     emitter;
+    writeEventStmt;
     constructor(db, emitter) {
         this.db = db;
         this.emitter = emitter;
+        this.writeEventStmt = db.prepare(`
+      INSERT INTO events (event_id, session_id, project_path, timestamp, hook_type,
+                          tool_name, tool_input, tool_output, user_prompt, ai_response,
+                          decision_id, subagent_type, distilled)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+    `);
     }
     writeEvent(event) {
         // Runtime validation
@@ -59,13 +93,21 @@ export class EventOperations {
             throw new Error(`Invalid event data: ${err instanceof Error ? err.message : String(err)}`);
         }
         const eventId = event.event_id || randomUUID();
-        const stmt = this.db.prepare(`
-      INSERT INTO events (event_id, session_id, project_path, timestamp, hook_type,
-                          tool_name, tool_input, tool_output, user_prompt, ai_response, distilled)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
-    `);
+        // decision c425f26f (spec 1544 § 1.2): extract decision_id + subagent_type
+        // into PLAINTEXT columns for Task/Agent spawn rows. CRITICAL: we read the
+        // STILL-DECODED `event.tool_input` (a JS object) HERE — BEFORE the codec
+        // encodes/gzip-compresses it below — and write the extracted strings as
+        // plain TEXT. These two columns NEVER flow through encodeToolInput / gzip
+        // (gzip one-way-door landmine). Non-spawn rows → both NULL.
+        const { decisionId, subagentType } = extractSpawnFields(event.tool_name, event.tool_input);
         try {
-            stmt.run(eventId, event.session_id, event.project_path, event.timestamp, event.hook_type, event.tool_name ?? null, event.tool_input ? JSON.stringify(event.tool_input) : null, event.tool_output ? JSON.stringify(event.tool_output) : null, event.user_prompt ?? null, event.ai_response ?? null);
+            // tool_input + tool_output flow through the gzip codec (encodeToolInput
+            // / encodeToolOutput). The codec returns null for null/undefined, a
+            // plain UTF-8 Buffer for payloads under TINY_INPUT_BYTES, and gzipped
+            // Buffer otherwise. better-sqlite3 binds Buffer as binary; SQLite
+            // stores it verbatim in the TEXT column. Read path uses
+            // decodeToolInput / decodeToolOutput (rowToEvent).
+            this.writeEventStmt.run(eventId, event.session_id, event.project_path, event.timestamp, event.hook_type, event.tool_name ?? null, encodeToolInput(event.tool_input), encodeToolOutput(event.tool_output), event.user_prompt ?? null, event.ai_response ?? null, decisionId, subagentType);
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -88,6 +130,49 @@ export class EventOperations {
         }
         this.emitter.emit('event', { ...event, event_id: eventId });
     }
+    /**
+     * Backfill the `ai_response` column for one event row with PLAIN TEXT
+     * (spec 1446 / decision 0df5271f).
+     *
+     * CRITICAL: `ai_response` is a plain-text TEXT column and MUST NOT flow
+     * through the gzip codec (encodeToolOutput) — gzip-stored content is silently
+     * invisible to SQL LIKE / raw reads (project gzip landmine). We write the
+     * string verbatim so `getEventById(id).ai_response` reads back identically and
+     * `searchEvents`' LIKE on ai_response keeps working.
+     *
+     * Idempotent: re-callable, overwrites. Truncated to MAX_AI_RESPONSE_CHARS to
+     * bound a single row's size.
+     */
+    updateEventAiResponse(eventId, text) {
+        if (!eventId)
+            return;
+        const truncated = text.length > MAX_AI_RESPONSE_CHARS
+            ? text.slice(0, MAX_AI_RESPONSE_CHARS)
+            : text;
+        this.db
+            .prepare('UPDATE events SET ai_response = ? WHERE event_id = ?')
+            .run(truncated, eventId);
+    }
+    /**
+     * Inline-edit events (PostToolUse Edit/Write/NotebookEdit) for one session
+     * within an inclusive ISO time window, ascending by timestamp (spec 1446).
+     *
+     * Reads only tool_name / timestamp (plain columns) so it never touches the
+     * gzip tool_input blob. Used by the Stop handler to locate the earliest
+     * inline-edit row of a violation window to backfill its ai_response.
+     */
+    queryInlineEditEvents(opts) {
+        const rows = this.db
+            .prepare(`SELECT * FROM events
+          WHERE session_id = ?
+            AND hook_type = 'PostToolUse'
+            AND tool_name IN ('Edit', 'Write', 'NotebookEdit')
+            AND timestamp >= ?
+            AND timestamp <= ?
+          ORDER BY timestamp ASC`)
+            .all(opts.session_id, opts.since_iso, opts.until_iso);
+        return rows.map((row) => this.rowToEvent(row));
+    }
     queryEvents(filter) {
         const conditions = [];
         const params = [];
@@ -103,6 +188,10 @@ export class EventOperations {
             conditions.push('hook_type = ?');
             params.push(filter.hook_type);
         }
+        if (filter.since !== undefined) {
+            conditions.push('timestamp >= ?');
+            params.push(filter.since);
+        }
         const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
         const limit = filter.limit ?? 1000;
         const offset = filter.offset ?? 0;
@@ -111,6 +200,79 @@ export class EventOperations {
         const rows = this.db.prepare(sql).all(...params);
         return rows.map((row) => this.rowToEvent(row));
     }
+    /**
+     * Fetch a single event by its primary key (`event_id`), or null when absent.
+     *
+     * Unlike {@link queryEvents}, this does a point lookup (`WHERE event_id = ?`)
+     * so it never depends on a `limit` window — the pipeline drawer's
+     * `?event_id=<id>` branch needs to locate an arbitrarily-old prompt that may
+     * be far beyond the most-recent-N set the default rollup scans.
+     */
+    getEventById(eventId) {
+        if (!eventId)
+            return null;
+        const row = this.db
+            .prepare('SELECT * FROM events WHERE event_id = ? LIMIT 1')
+            .get(eventId);
+        return row ? this.rowToEvent(row) : null;
+    }
+    /**
+     * Slim variant of queryEvents used by `/api/insights/timeline` (audit F5).
+     *
+     * Drops `tool_output` and `ai_response` from the SELECT — those columns
+     * dominate row size on tool-heavy sessions (PostToolUse rows can carry
+     * MB-scale JSON each), so omitting them cuts both transport bytes and the
+     * per-row JSON.parse cost handled inside this method.
+     *
+     * Adds an optional `before_ts` cursor (exclusive, `timestamp < ?`) for
+     * descending pagination — keeps the existing `limit` semantics and is
+     * additive so callers that don't pass it behave exactly like before.
+     *
+     * NOT a generic queryEvents overload: dropping output columns would
+     * silently break any caller that relies on `tool_output` / `ai_response`.
+     */
+    queryEventsTimeline(filter) {
+        const conditions = ['session_id = ?'];
+        const params = [filter.session_id];
+        if (filter.hook_type) {
+            conditions.push('hook_type = ?');
+            params.push(filter.hook_type);
+        }
+        if (filter.before_ts) {
+            conditions.push('timestamp < ?');
+            params.push(filter.before_ts);
+        }
+        const limit = Math.min(Math.max(filter.limit ?? 500, 1), 2000);
+        const sql = `SELECT event_id, session_id, project_path, timestamp, hook_type,
+                        tool_name, tool_input, user_prompt
+                 FROM events
+                 WHERE ${conditions.join(' AND ')}
+                 ORDER BY timestamp DESC
+                 LIMIT ?`;
+        params.push(limit);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((row) => {
+            let toolInput;
+            if (row.tool_input) {
+                try {
+                    toolInput = decodeToolInput(row.tool_input);
+                }
+                catch {
+                    toolInput = undefined;
+                }
+            }
+            return {
+                event_id: row.event_id,
+                session_id: row.session_id,
+                project_path: row.project_path,
+                timestamp: row.timestamp,
+                hook_type: row.hook_type,
+                tool_name: row.tool_name ?? undefined,
+                tool_input: toolInput,
+                user_prompt: row.user_prompt ?? undefined,
+            };
+        });
+    }
     countEvents(filter) {
         if (!filter || (!filter.session_id && !filter.project_path && !filter.hook_type)) {
             const result = this.db.prepare('SELECT COUNT(*) as count FROM events').get();
@@ -140,8 +302,23 @@ export class EventOperations {
      * Reduces data transfer by filtering events before sending to client.
      */
     searchEvents(filter) {
-        const conditions = ['session_id = ?'];
-        const params = [filter.session_id];
+        const conditions = [];
+        const params = [];
+        if (filter.session_id) {
+            conditions.push('session_id = ?');
+            params.push(filter.session_id);
+        }
+        // gzip codec: `tool_input` is gzip bytes for new rows so a raw LIKE on
+        // it can never match. Strategy:
+        //   1) SQL pre-filter: LIKE on `user_prompt` / `ai_response` / `tool_input`
+        //      gets the plain-text hits (covers legacy 42k rows + the two plain
+        //      columns on all rows).
+        //   2) When `filter.query` is set, also fetch rows that DIDN'T match the
+        //      LIKE but have a gzipped `tool_input`, decode them in JS, and union
+        //      in the ones whose decoded content matches. Bounded by `limit` so
+        //      we don't decompress an arbitrary scan.
+        // The two-phase union preserves the pre-codec behaviour exactly (callers
+        // get the same set of events back).
         if (filter.query) {
             conditions.push('(user_prompt LIKE ? OR ai_response LIKE ? OR tool_input LIKE ?)');
             const pattern = `%${filter.query}%`;
@@ -157,10 +334,68 @@ export class EventOperations {
         }
         const limit = filter.limit ?? 100;
         const offset = filter.offset ?? 0;
-        const sql = `SELECT * FROM events WHERE ${conditions.join(' AND ')} ORDER BY timestamp DESC LIMIT ? OFFSET ?`;
-        params.push(limit, offset);
-        const rows = this.db.prepare(sql).all(...params);
-        return rows.map((row) => this.rowToEvent(row));
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const sql = `SELECT * FROM events ${where} ORDER BY timestamp DESC LIMIT ? OFFSET ?`;
+        const sqlParams = [...params, limit, offset];
+        const rows = this.db.prepare(sql).all(...sqlParams);
+        const sqlMatches = rows.map((row) => this.rowToEvent(row));
+        // Phase 2: when query is set, look for gzipped-row tool_input matches that
+        // SQL LIKE necessarily missed. Scope: same session/tool/hook filters as
+        // the SQL above, but restricted to rows where tool_input is gzipped (i.e.
+        // length > 0 AND it didn't match the LIKE). We bound the scan by `limit`.
+        if (filter.query) {
+            const codecConditions = ['tool_input IS NOT NULL'];
+            const codecParams = [];
+            if (filter.session_id) {
+                codecConditions.push('session_id = ?');
+                codecParams.push(filter.session_id);
+            }
+            if (filter.tool_name) {
+                codecConditions.push('tool_name = ?');
+                codecParams.push(filter.tool_name);
+            }
+            if (filter.hook_type) {
+                codecConditions.push('hook_type = ?');
+                codecParams.push(filter.hook_type);
+            }
+            // Skip rows that already matched SQL LIKE — they're already in sqlMatches.
+            // Cheaper to scan a slightly bigger candidate set and de-dup by event_id.
+            const scanLimit = Math.min(limit * 5, 2000);
+            const codecSql = `SELECT * FROM events WHERE ${codecConditions.join(' AND ')} ORDER BY timestamp DESC LIMIT ?`;
+            const candidateRows = this.db
+                .prepare(codecSql)
+                .all(...codecParams, scanLimit);
+            const queryLower = filter.query.toLowerCase();
+            const seenIds = new Set(sqlMatches.map(e => e.event_id));
+            const extraMatches = [];
+            for (const raw of candidateRows) {
+                const id = String(raw.event_id);
+                if (seenIds.has(id))
+                    continue;
+                // Only inspect gzipped rows — plain rows already had a chance via LIKE.
+                const ti = raw.tool_input;
+                const isBinary = Buffer.isBuffer(ti) || ArrayBuffer.isView(ti);
+                if (!isBinary)
+                    continue;
+                try {
+                    const decoded = decodeToolInput(ti);
+                    const haystack = JSON.stringify(decoded ?? '').toLowerCase();
+                    if (haystack.includes(queryLower)) {
+                        extraMatches.push(this.rowToEvent(raw));
+                        seenIds.add(id);
+                    }
+                }
+                catch {
+                    // Skip malformed gzip rows silently — they're already broken.
+                }
+            }
+            if (extraMatches.length === 0)
+                return sqlMatches;
+            const combined = [...sqlMatches, ...extraMatches];
+            combined.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+            return combined.slice(0, limit);
+        }
+        return sqlMatches;
     }
     // ── H2: 聚合 / 计数方法（消除 routes / handlers / analytics 越权 SQL）─────
     /** Total event row count. */
@@ -211,12 +446,290 @@ export class EventOperations {
         return this.db.prepare(`SELECT hook_type, COUNT(*) as count FROM events
        WHERE session_id = ? GROUP BY hook_type`).all(session_id);
     }
-    /** Agent/Task subagent_type distribution for a single session (json_extract from tool_input). */
+    /**
+     * Agent/Task subagent_type distribution for a single session.
+     *
+     * Was a single SQL with `json_extract(tool_input, '$.subagent_type')` —
+     * incompatible with the gzip codec. Refactored to: SELECT raw tool_input
+     * for matching events, JS-decode each row via the codec, bucket in JS.
+     * Per-session scan is tiny (≤ a few hundred Task/Agent rows in practice).
+     */
     aggregateAgentTypeBySession(session_id) {
-        return this.db.prepare(`SELECT json_extract(tool_input, '$.subagent_type') as agent_type, COUNT(*) as count
-       FROM events
-       WHERE session_id = ? AND tool_name IN ('Agent', 'Task') AND tool_input IS NOT NULL
-       GROUP BY agent_type`).all(session_id);
+        const rows = this.db.prepare(`SELECT tool_input FROM events
+       WHERE session_id = ? AND tool_name IN ('Agent', 'Task') AND tool_input IS NOT NULL`).all(session_id);
+        const counts = new Map();
+        for (const row of rows) {
+            let agentType = null;
+            try {
+                const decoded = decodeToolInput(row.tool_input);
+                if (decoded && typeof decoded === 'object' && !Array.isArray(decoded)) {
+                    const v = decoded.subagent_type;
+                    agentType = typeof v === 'string' ? v : null;
+                }
+            }
+            catch {
+                // Malformed row — count under null bucket (matches SQL's NULL semantics).
+            }
+            counts.set(agentType, (counts.get(agentType) ?? 0) + 1);
+        }
+        return Array.from(counts.entries()).map(([agent_type, count]) => ({ agent_type, count }));
+    }
+    /**
+     * Cross-task agent-delegation aggregation, grouped by subagent_type
+     * (Arco Phase 2d — Agent 委托 list/detail, decision 29688066).
+     *
+     * Pairs Pre/Post `Task`/`Agent` tool events within [since, until) per
+     * session (same one-post-per-pre consumption rule the task-timeline route
+     * uses) to derive each delegation's duration. Then LEFT JOINs the *task*
+     * that the spawn fell inside (same session, spawn timestamp ∈ [task.start,
+     * task.end]) to attribute an outcome (success / partial / failed / other /
+     * unrated) per spawn. Aggregates per subagent_type:
+     *   - delegations            : paired spawn count (one per Pre)
+     *   - success/partial/failed : containing-task outcome buckets
+     *   - unrated                : spawns whose task has no outcome (active / null)
+     *   - avg_duration_ms        : mean of paired (or task_end-fallback) durations
+     *   - last_ts                : most-recent spawn epoch-ms
+     *   - recent[]               : newest `recentLimit` spawns (task_id / title /
+     *                              outcome / duration_ms / ts / session_id)
+     *
+     * gzip note: `subagent_type` lives in the gzip `tool_input` blob, so we
+     * decode each Task/Agent row in JS (same as aggregateAgentTypeBySession).
+     * Window-scoped + Task/Agent-only keeps the scan small.
+     */
+    aggregateAgentSpawns(opts) {
+        const recentLimit = opts.recentLimit ?? 5;
+        const conditions = ["timestamp >= ?", "tool_name IN ('Task','Agent')"];
+        const params = [opts.since];
+        if (opts.until !== undefined) {
+            conditions.push('timestamp < ?');
+            params.push(opts.until);
+        }
+        // Additive project filter (decision dd79010a): scope the spawn scan to one
+        // project's events. Omit (or '') → all projects (legacy back-compat with
+        // cf agent retro / callers that never pass it). events.project_path is a
+        // plaintext TEXT column (NOT gzip), so a direct equality predicate is safe.
+        if (opts.projectPath) {
+            conditions.push('project_path = ?');
+            params.push(opts.projectPath);
+        }
+        const rows = this.db.prepare(`SELECT event_id, session_id, timestamp, hook_type, tool_input
+         FROM events
+        WHERE ${conditions.join(' AND ')}
+        ORDER BY timestamp ASC`).all(...params);
+        const spawns = [];
+        // Pre/Post pairing per session (mirror task-timeline's consume-as-paired).
+        const bySession = new Map();
+        for (const r of rows) {
+            const arr = bySession.get(r.session_id) ?? [];
+            arr.push(r);
+            bySession.set(r.session_id, arr);
+        }
+        const decodeAgent = (ti) => {
+            try {
+                const decoded = decodeToolInput(ti);
+                if (decoded && typeof decoded === 'object' && !Array.isArray(decoded)) {
+                    const v = decoded.subagent_type;
+                    return typeof v === 'string' && v.length > 0 ? v : null;
+                }
+            }
+            catch {
+                /* malformed — skip */
+            }
+            return null;
+        };
+        for (const sessionRows of bySession.values()) {
+            const pres = sessionRows.filter((e) => e.hook_type === 'PreToolUse');
+            const posts = sessionRows.filter((e) => e.hook_type === 'PostToolUse');
+            const consumed = new Set();
+            for (const pre of pres) {
+                const agent = decodeAgent(pre.tool_input);
+                if (!agent)
+                    continue; // built-in calls without subagent_type → skip
+                const preMs = new Date(pre.timestamp).getTime();
+                const post = posts.find((p) => {
+                    const key = p.event_id ?? p.timestamp;
+                    if (consumed.has(key))
+                        return false;
+                    if (new Date(p.timestamp).getTime() < preMs)
+                        return false;
+                    const pAgent = decodeAgent(p.tool_input);
+                    return pAgent === null || pAgent === agent;
+                });
+                let durationMs = null;
+                if (post) {
+                    consumed.add(post.event_id ?? post.timestamp);
+                    durationMs = new Date(post.timestamp).getTime() - preMs;
+                    if (durationMs < 0)
+                        durationMs = null;
+                }
+                spawns.push({ agent, session_id: pre.session_id, ts: preMs, duration_ms: durationMs });
+            }
+        }
+        if (spawns.length === 0)
+            return [];
+        // Attribute each spawn to the containing task (same session, ts in window).
+        // Load candidate tasks once per touched session.
+        const taskStmt = this.db.prepare(`SELECT id, title, start_time, end_time, outcome
+         FROM tasks WHERE session_id = ? ORDER BY start_time ASC`);
+        const tasksBySession = new Map();
+        const taskFor = (sessionId, ts) => {
+            let cand = tasksBySession.get(sessionId);
+            if (!cand) {
+                const trows = taskStmt.all(sessionId);
+                cand = trows.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    startMs: new Date(t.start_time).getTime(),
+                    endMs: t.end_time ? new Date(t.end_time).getTime() : null,
+                    outcome: t.outcome,
+                }));
+                tasksBySession.set(sessionId, cand);
+            }
+            // newest task whose [start, end] (open-ended end → now) contains ts
+            let best = null;
+            for (const t of cand) {
+                if (ts < t.startMs)
+                    continue;
+                if (t.endMs !== null && ts > t.endMs)
+                    continue;
+                if (!best || t.startMs > best.startMs)
+                    best = t;
+            }
+            return best;
+        };
+        const buckets = new Map();
+        for (const s of spawns) {
+            let b = buckets.get(s.agent);
+            if (!b) {
+                b = { agent: s.agent, delegations: 0, success: 0, partial: 0, failed: 0, unrated: 0, durSum: 0, durCount: 0, last_ts: 0, recent: [] };
+                buckets.set(s.agent, b);
+            }
+            b.delegations++;
+            const task = taskFor(s.session_id, s.ts);
+            const outcome = task?.outcome ?? null;
+            if (outcome === 'success')
+                b.success++;
+            else if (outcome === 'partial')
+                b.partial++;
+            else if (outcome === 'failed')
+                b.failed++;
+            else
+                b.unrated++;
+            if (s.duration_ms !== null) {
+                b.durSum += s.duration_ms;
+                b.durCount++;
+            }
+            if (s.ts > b.last_ts)
+                b.last_ts = s.ts;
+            b.recent.push({ task_id: task?.id ?? null, title: task?.title ?? null, outcome, duration_ms: s.duration_ms, ts: s.ts, session_id: s.session_id });
+        }
+        return Array.from(buckets.values())
+            .map((b) => ({
+            agent: b.agent,
+            delegations: b.delegations,
+            success: b.success,
+            partial: b.partial,
+            failed: b.failed,
+            unrated: b.unrated,
+            avg_duration_ms: b.durCount > 0 ? Math.round(b.durSum / b.durCount) : null,
+            last_ts: b.last_ts,
+            recent: b.recent.sort((a, c) => c.ts - a.ts).slice(0, recentLimit),
+        }))
+            .sort((a, b) => b.delegations - a.delegations || a.agent.localeCompare(b.agent));
+    }
+    /**
+     * Cross-task workflow spawn aggregation, grouped by decision_id (decision
+     * c425f26f, spec 1544 § 1.4).
+     *
+     * Returns every Task/Agent spawn event (both Pre and Post hooks) that carries
+     * the given `decision_id` in its PLAINTEXT `decision_id` column — across ALL
+     * tasks that share that decision (the whole logical workflow), ordered by
+     * timestamp ASC. This is the read primitive the timeline route uses to refill
+     * the implement/verify segments that the single-task window misses when a
+     * workflow is fragmented across per-prompt tasks.
+     *
+     * Key design points (spec § 1.4 / R5):
+     *   - Filters STRICTLY on the spawn row's own `decision_id` column — NEVER
+     *     groups by whole task — so a task that mixes two decision_ids does not
+     *     cross-contaminate (R5).
+     *   - `subagent_type` is read from the new PLAINTEXT column (no gzip decode).
+     *   - `task_id` is attributed via LEFT JOIN task_events (precise, user
+     *     ruling #2): the task each spawn event was linked into. NULL when the
+     *     spawn was never linked to a task.
+     *   - `task_count` = distinct non-null task_ids = the "跨 N 轮工作流" N.
+     *
+     * gzip note: reads only plaintext columns + the `prompt`/`tool_output` via the
+     * codec for previews. Walks O(10) spawns per workflow — well under the <200ms
+     * timeline budget; the idx_events_decision_spawn covering index serves the WHERE.
+     */
+    queryWorkflowSpawnsByDecisionId(decisionId) {
+        if (!decisionId)
+            return { spawns: [], task_count: 0 };
+        const rows = this.db.prepare(`SELECT e.event_id, e.session_id, e.timestamp, e.hook_type, e.subagent_type,
+              e.tool_input, e.tool_output, te.task_id AS task_id
+         FROM events e
+         LEFT JOIN task_events te ON te.event_id = e.event_id
+        WHERE e.decision_id = ?
+          AND e.tool_name IN ('Task','Agent')
+          AND e.hook_type IN ('PreToolUse','PostToolUse')
+        ORDER BY e.timestamp ASC`).all(decisionId);
+        const taskIds = new Set();
+        const spawns = rows.map((row) => {
+            if (row.task_id)
+                taskIds.add(row.task_id);
+            let toolInput;
+            if (row.tool_input) {
+                try {
+                    toolInput = decodeToolInput(row.tool_input);
+                }
+                catch {
+                    toolInput = undefined;
+                }
+            }
+            let toolOutput;
+            if (row.tool_output) {
+                try {
+                    toolOutput = decodeToolOutput(row.tool_output);
+                }
+                catch {
+                    toolOutput = undefined;
+                }
+            }
+            return {
+                event_id: row.event_id,
+                session_id: row.session_id,
+                task_id: row.task_id ?? null,
+                timestamp: row.timestamp,
+                hook_type: row.hook_type,
+                subagent_type: row.subagent_type,
+                tool_input: toolInput,
+                tool_output: toolOutput,
+            };
+        });
+        return { spawns, task_count: taskIds.size };
+    }
+    /**
+     * Resolve the decision_id that a single task belongs to (decision c425f26f,
+     * spec 1544 § 1.5). Reads the PLAINTEXT `decision_id` column off the task's
+     * own spawn rows (linked via task_events) — no gzip decode. Returns the most
+     * common non-null decision_id among the task's spawns (a task occasionally
+     * mixes two decision_ids — R5 — so we pick the dominant one as the task's
+     * "home" workflow; the aggregation query itself still filters strictly per
+     * spawn row, so a minority decision_id is not lost). NULL when the task has no
+     * spawn carrying a decision_id (e.g. the magic comment was omitted).
+     */
+    queryTaskDecisionId(taskId) {
+        const rows = this.db.prepare(`SELECT e.decision_id AS decision_id, COUNT(*) AS n
+         FROM events e
+         JOIN task_events te ON te.event_id = e.event_id
+        WHERE te.task_id = ?
+          AND e.tool_name IN ('Task','Agent')
+          AND e.hook_type = 'PreToolUse'
+          AND e.decision_id IS NOT NULL
+        GROUP BY e.decision_id
+        ORDER BY n DESC, e.decision_id ASC
+        LIMIT 1`).get(taskId);
+        return rows?.decision_id ?? null;
     }
     /** Tool usage distribution for a single session (non-null tool_name only). */
     aggregateToolUsageBySession(session_id) {
@@ -256,34 +769,76 @@ export class EventOperations {
          AND project_path IS NOT NULL AND project_path != ''`).all(opts.since, opts.until);
         return rows.map(r => r.project_path);
     }
+    /**
+     * Outcome classifier (spec 1100 v2): count a SESSION's Edit/Write intent
+     * events. Reads only `tool_name` (never the gzip `tool_input`), so it is
+     * always correct. Drives the session-level `edit_intent_count` signal
+     * (>0 → success, ==0 → answered). PreToolUse only, so a single logical edit
+     * (Pre+Post) counts once.
+     */
+    countEditIntentEventsBySession(sessionId) {
+        const row = this.db.prepare(`SELECT COUNT(*) AS n FROM events
+        WHERE session_id = ?
+          AND hook_type = 'PreToolUse'
+          AND tool_name IN ('Edit', 'Write', 'MultiEdit', 'NotebookEdit')`).get(sessionId);
+        return row?.n ?? 0;
+    }
     /**
      * PostToolUse failure rate within [since, until).
      *
-     * Failure detection uses three LIKE branches on tool_output (preserved from
-     * weekly-report.ts original SQL):
-     *   - '%"error"%'
-     *   - '%"is_error":true%'
-     *   - '%"isError":true%'
+     * Was three SQL `LIKE` branches on `tool_output` — incompatible with the gzip
+     * codec: any tool_output >= TINY_INPUT_BYTES is stored as gzip bytes, so the
+     * LIKE could never match and failures buried in large (stack-trace) outputs
+     * were silently dropped, deflating the weekly-report failure rate. Refactored
+     * to "decode at read time": SELECT raw tool_output for the PostToolUse rows,
+     * `decodeToolOutput` each via the codec (transparently handles gzip Buffer,
+     * tiny-UTF-8 Buffer, and legacy plain text — `JSON.parse` fallback covers
+     * pre-codec plain rows), then apply the same three-marker heuristic in JS.
+     * Same pattern as `aggregateAgentTypeBySession` (:483).
+     *
+     * Failure markers (semantically equivalent to the original LIKE branches):
+     *   - top-level `error` key present  (was `'%"error"%'`)
+     *   - `is_error === true`            (was `'%"is_error":true%'`)
+     *   - `isError === true`             (was `'%"isError":true%'`)
+     *
+     * Non-hot path (weekly-report generation, user-triggered), so the per-row
+     * decode cost is acceptable.
      */
     aggregateToolFailureRate(opts) {
-        const totalRow = this.db.prepare(`SELECT COUNT(*) as total FROM events
+        const rows = this.db.prepare(`SELECT tool_output FROM events
        WHERE timestamp >= ? AND timestamp < ?
-         AND hook_type = 'PostToolUse'`).get(opts.since, opts.until);
-        const failRow = this.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(opts.since, opts.until);
+         AND hook_type = 'PostToolUse'`).all(opts.since, opts.until);
+        let failed = 0;
+        for (const row of rows) {
+            if (row.tool_output === null || row.tool_output === undefined)
+                continue;
+            let decoded;
+            try {
+                decoded = decodeToolOutput(row.tool_output);
+            }
+            catch {
+                // Undecodable row — can't inspect; treat as non-failure. Matches the
+                // old LIKE behaviour where a malformed gzip row never matched.
+                continue;
+            }
+            if (isFailureToolOutput(decoded))
+                failed++;
+        }
         return {
-            post_total: totalRow?.total ?? 0,
-            failed: failRow?.failed ?? 0,
+            post_total: rows.length,
+            failed,
         };
     }
     /**
      * Raw tool_input JSON strings for file-edit tools within [since, until).
-     * Caller is responsible for JSON.parse / file_path extraction.
+     *
+     * gzip codec note: the on-disk column is now binary for new rows. To
+     * preserve the existing caller contract (caller does `JSON.parse(row.tool_input)`),
+     * we decode each row via the codec inside this method and re-stringify back
+     * to JSON text on the way out. Net: callers see the same `Array<{tool_input: string}>`
+     * shape as before. Bytes-per-row pays the gzip → JSON.stringify cost but
+     * the row counts here are small (weekly anti-pattern-detector ≈ a few thousand).
+     *
      * Internal IN-list expansion of `tool_names`.
      */
     queryFileEditInputs(opts) {
@@ -295,7 +850,81 @@ export class EventOperations {
                    AND hook_type = 'PreToolUse'
                    AND tool_name IN (${placeholders})
                    AND tool_input IS NOT NULL`;
-        return this.db.prepare(sql).all(opts.since, opts.until, ...opts.tool_names);
+        const rawRows = this.db.prepare(sql).all(opts.since, opts.until, ...opts.tool_names);
+        const out = [];
+        for (const raw of rawRows) {
+            try {
+                const decoded = decodeToolInput(raw.tool_input);
+                // Caller expects a string; re-stringify so JSON.parse on their side works.
+                out.push({ tool_input: JSON.stringify(decoded ?? null) });
+            }
+            catch {
+                // Skip malformed rows — caller already has a try/catch.
+            }
+        }
+        return out;
+    }
+    // ── TTL sweep operations (Phase: db-size optimization) ─────────────────
+    //
+    // Two-tier expiry policy for events:
+    //   - warm TTL: rows older than this get `tool_input = NULL` (frees the
+    //     dominant column without dropping the row, so analytics/queries
+    //     still see hook_type/tool_name/timestamps).
+    //   - cold TTL: rows older than this are DELETEd outright (and orphan
+    //     task_events rows pruned, mirroring `cleanOldData`).
+    //
+    // Caller is the daemon's event-ttl-sweep service. Both operations are
+    // capped to keep the SQLite writer lock short — if a pass hits the cap,
+    // the daemon logs and waits for the next sweep tick (default 6h).
+    /**
+     * NULL out `tool_input` for events older than `cutoffIso` in batches.
+     *
+     * Only touches rows where `tool_input IS NOT NULL` so repeat-runs are
+     * idempotent. Returns the row count that was updated this pass.
+     *
+     * `maxRows` bounds the SQL UPDATE via a LIMIT-style sub-SELECT — SQLite
+     * doesn't support `UPDATE ... LIMIT` without compile-time flag, so we
+     * use `WHERE event_id IN (SELECT event_id FROM events WHERE ... LIMIT ?)`.
+     */
+    expireToolInputBatch(cutoffIso, maxRows) {
+        const result = this.db
+            .prepare(`UPDATE events SET tool_input = NULL
+         WHERE event_id IN (
+           SELECT event_id FROM events
+           WHERE timestamp < ? AND tool_input IS NOT NULL
+           LIMIT ?
+         )`)
+            .run(cutoffIso, maxRows);
+        return result.changes;
+    }
+    /**
+     * DELETE events older than `cutoffIso`, plus orphan task_events rows, in
+     * one transaction. Returns counters per table for logging.
+     *
+     * `maxRows` caps the events delete to keep writer lock short. task_events
+     * pruning is bounded by the events delete via the IN-subquery.
+     */
+    deleteEventsByCutoff(cutoffIso, maxRows) {
+        // Run in a transaction so the orphan-pruning matches the same set of
+        // event_ids the events DELETE removed. We capture the doomed ids first
+        // to keep task_events bound to that exact set.
+        const tx = this.db.transaction(() => {
+            const doomed = this.db
+                .prepare(`SELECT event_id FROM events WHERE timestamp < ? LIMIT ?`)
+                .all(cutoffIso, maxRows);
+            if (doomed.length === 0)
+                return { events: 0, taskEvents: 0 };
+            const placeholders = doomed.map(() => '?').join(',');
+            const ids = doomed.map(d => d.event_id);
+            const teResult = this.db
+                .prepare(`DELETE FROM task_events WHERE event_id IN (${placeholders})`)
+                .run(...ids);
+            const evResult = this.db
+                .prepare(`DELETE FROM events WHERE event_id IN (${placeholders})`)
+                .run(...ids);
+            return { events: evResult.changes, taskEvents: teResult.changes };
+        });
+        return tx();
     }
     /** Full events in [since, until?), ascending by timestamp (used by anti-pattern-detector). */
     queryEventsByTimeRange(opts) {
@@ -313,6 +942,13 @@ export class EventOperations {
         // Runtime validation of database row
         try {
             const validatedRow = DatabaseRowSchema.parse(row);
+            // tool_input + tool_output flow through the codec: handles gzip Buffer
+            // (new large rows), plain UTF-8 Buffer (new tiny rows), and plain JSON
+            // text (legacy rows). decodeTool* returns undefined for null/empty,
+            // throws on malformed payloads — caught by the outer try/catch which
+            // returns a defaulted ForgeEvent.
+            const toolInput = decodeToolInput(validatedRow.tool_input);
+            const toolOutput = decodeToolOutput(validatedRow.tool_output);
             return {
                 event_id: validatedRow.event_id,
                 session_id: validatedRow.session_id,
@@ -320,8 +956,8 @@ export class EventOperations {
                 timestamp: validatedRow.timestamp,
                 hook_type: validatedRow.hook_type,
                 tool_name: validatedRow.tool_name || undefined,
-                tool_input: validatedRow.tool_input ? JSON.parse(validatedRow.tool_input) : undefined,
-                tool_output: validatedRow.tool_output ? JSON.parse(validatedRow.tool_output) : undefined,
+                tool_input: toolInput,
+                tool_output: toolOutput,
                 user_prompt: validatedRow.user_prompt || undefined,
                 ai_response: validatedRow.ai_response || undefined,
             };
@@ -344,4 +980,34 @@ export class EventOperations {
         }
     }
 }
+/**
+ * Decide whether a decoded tool_output represents a tool failure, for
+ * `aggregateToolFailureRate`. Semantically equivalent to the three SQL `LIKE`
+ * branches the aggregator used before the gzip-codec migration:
+ *
+ *   - '%"error"%'           → a JSON `"error"` key appears anywhere
+ *   - '%"is_error":true%'   → a `"is_error":true` pair appears anywhere
+ *   - '%"isError":true%'    → a `"isError":true` pair appears anywhere
+ *
+ * The original LIKE matched substrings of the stored JSON *text* (and matched
+ * nested keys, not just top-level). To preserve that breadth exactly we
+ * re-stringify the decoded value and test the same substrings — JSON.stringify
+ * emits the canonical `"key":value` form the LIKE patterns assumed.
+ */
+function isFailureToolOutput(decoded) {
+    if (decoded === null || decoded === undefined)
+        return false;
+    let json;
+    try {
+        json = typeof decoded === 'string' ? decoded : JSON.stringify(decoded);
+    }
+    catch {
+        return false;
+    }
+    if (json === undefined)
+        return false;
+    return (json.includes('"error"') ||
+        json.includes('"is_error":true') ||
+        json.includes('"isError":true'));
+}
 //# sourceMappingURL=events.js.map