@winspan/claude-forge 8.54.4 → 9.12.0

package/dist/core/storage/tasks.js

@@ -3,15 +3,237 @@
  *
  * 拆分自 sqlite.ts。
  */
+import { decodeToolInput, decodeToolOutput } from './codec/tool-input-codec.js';
+import { DAY_MS } from '../utils/time.js';
+const ALL_TASK_KINDS = ['user', 'agent-callback', 'image', 'system'];
 export class TaskOperations {
     db;
     constructor(db) {
         this.db = db;
     }
+    /**
+     * Insert a task row.
+     *
+     * `is_noise` (deprecated since 2026-06-01, spec b1480935) is still accepted
+     * for back-compat — callers that haven't been migrated to `task_kind` will
+     * keep working; new writers should pass `task_kind` directly.
+     *
+     * `task_kind` (spec b1480935 Option A): when omitted, defaults to `'user'`
+     * via the schema DEFAULT. TaskSegmenter passes the classified kind from
+     * `classifyPromptKind()` so envelope rows surface in Web with a muted
+     * `agent-callback`/`image`/`system` chip instead of being hidden.
+     */
     writeTask(task) {
+        // Default kind to 'user' — matches the schema CHECK and the read-side
+        // assumption that pre-classification rows ARE user-driven work.
+        const kind = task.task_kind ?? 'user';
         this.db.prepare(`
-      INSERT INTO tasks (id, session_id, title, start_time) VALUES (?, ?, ?, ?)
-    `).run(task.id, task.session_id, task.title, task.start_time);
+      INSERT INTO tasks (id, session_id, title, start_time, is_noise, task_kind, parent_task_id)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(task.id, task.session_id, task.title, task.start_time, task.is_noise ? 1 : 0, kind, task.parent_task_id ?? null);
+    }
+    /**
+     * decision f47c2c90 (二期B, spec 1711 § Phase 2): link a task to its parent
+     * user task, but ONLY when no parent is set yet (idempotent — never overwrites
+     * an existing link). Also refuses to self-link (parentTaskId === taskId). This
+     * is the resume-path补链 hook; go-forward创建路径 passes parent_task_id directly
+     * to writeTask instead. Defense-in-depth for R4 (no cycles / no self-link).
+     */
+    setTaskParent(taskId, parentTaskId) {
+        if (!taskId || !parentTaskId || taskId === parentTaskId)
+            return;
+        this.db.prepare(`UPDATE tasks SET parent_task_id = ? WHERE id = ? AND parent_task_id IS NULL`).run(parentTaskId, taskId);
+    }
+    /**
+     * decision f47c2c90 (二期B, spec 1711 § Phase 2): find the most recent prior
+     * user task in the same session for the triple-gate parent linkage.
+     *
+     * Conservative selection (mirrors the backfill heuristic):
+     *   - same session, task_kind='user'
+     *   - start_time STRICTLY earlier than `beforeIso` (parent must precede child)
+     *   - start_time within `windowMs` of `beforeIso` (default 30min)
+     *   - PREFERS a non-ack-titled task as the substantive originator; falls back
+     *     to the most recent qualifying user task if none is non-ack.
+     *
+     * Returns the task id, or null when no qualifying prior task exists.
+     * Time math uses ISO lexical comparison (start_time is ISO TEXT — no numeric
+     * probe, DB column type landmine). `ackTitles` is the lowercase ack-token set
+     * supplied by the caller (single source of truth lives in the segmenter).
+     */
+    getMostRecentUserTaskBefore(opts) {
+        const sinceIso = new Date(Date.parse(opts.beforeIso) - opts.windowMs).toISOString();
+        const ackPh = opts.ackTitles.length > 0 ? opts.ackTitles.map(() => '?').join(',') : `''`;
+        // Prefer a non-ack-titled originator (avoid ack→ack chains).
+        const nonAckSql = `
+      SELECT id FROM tasks
+       WHERE session_id = ?
+         AND task_kind = 'user'
+         AND start_time < ?
+         AND start_time >= ?
+         ${opts.ackTitles.length > 0 ? `AND LOWER(trim(title)) NOT IN (${ackPh})` : ''}
+       ORDER BY start_time DESC
+       LIMIT 1`;
+        const nonAckParams = [opts.session_id, opts.beforeIso, sinceIso];
+        if (opts.ackTitles.length > 0)
+            nonAckParams.push(...opts.ackTitles);
+        const nonAck = this.db.prepare(nonAckSql).get(...nonAckParams);
+        if (nonAck?.id)
+            return nonAck.id;
+        // Fallback: most recent qualifying user task regardless of title.
+        const any = this.db.prepare(`
+      SELECT id FROM tasks
+       WHERE session_id = ?
+         AND task_kind = 'user'
+         AND start_time < ?
+         AND start_time >= ?
+       ORDER BY start_time DESC
+       LIMIT 1
+    `).get(opts.session_id, opts.beforeIso, sinceIso);
+        return any?.id ?? null;
+    }
+    /**
+     * decision f47c2c90 (二期B, spec 1711 § Phase 3.1): aggregate ALL Task/Agent
+     * spawns across the parent_task_id chain that `anchorTaskId` belongs to —
+     * the timeline's fallback for workflows that have NO decision_id.
+     *
+     * Algorithm (two bounded recursive CTEs, R4 cycle-safe):
+     *   1. 向上找根: walk parent_task_id up from the anchor to the root
+     *      (parent_task_id IS NULL), depth ≤ 8.
+     *   2. 向下收子: from that root, collect all descendants (depth ≤ 8).
+     *   The union of both walks is the chain's task-id set. SQLite recursive CTEs
+     *   with UNION (set semantics) dedup automatically; the explicit depth column
+     *   guard caps a pathological cycle (a.parent=b, b.parent=a) at 8 hops so the
+     *   query always terminates with a finite result.
+     *
+     * Output shape is IDENTICAL to EventOperations.queryWorkflowSpawnsByDecisionId
+     * so task-timeline.ts can feed both through the same buildAgentSpawnEvents
+     * helper. subagent_type is read from the PLAINTEXT column (no gzip);
+     * tool_input / tool_output are decoded via the codec (same path as the A query)
+     * for the prompt / output previews. task_count = distinct chain task ids that
+     * actually carry ≥1 spawn (the "跨 N 轮" N for the B path).
+     *
+     * gzip note: only tool_input/tool_output flow through the codec; the chain walk
+     * itself touches plaintext tasks columns only (R7-safe).
+     */
+    queryParentTaskChainSpawns(anchorTaskId) {
+        if (!anchorTaskId)
+            return { spawns: [], task_count: 0 };
+        // Collect the full chain id-set (up to root + down to descendants), depth≤8,
+        // cycle-safe via the depth guard + UNION dedup.
+        const chainRows = this.db.prepare(`
+      WITH RECURSIVE
+        ancestors(id, depth) AS (
+          SELECT id, 0 FROM tasks WHERE id = ?
+          UNION
+          SELECT t.parent_task_id, a.depth + 1
+            FROM tasks t JOIN ancestors a ON t.id = a.id
+           WHERE t.parent_task_id IS NOT NULL AND a.depth < 8
+        ),
+        root(id) AS (
+          -- the topmost ancestor reached (smallest remaining parent); we take
+          -- ALL ancestors as roots-of-subtree to be safe, then collect descendants
+          SELECT id FROM ancestors
+        ),
+        descendants(id, depth) AS (
+          SELECT id, 0 FROM root
+          UNION
+          SELECT t.id, d.depth + 1
+            FROM tasks t JOIN descendants d ON t.parent_task_id = d.id
+           WHERE d.depth < 8
+        )
+      SELECT DISTINCT id FROM (
+        SELECT id FROM ancestors
+        UNION
+        SELECT id FROM descendants
+      ) WHERE id IS NOT NULL
+    `).all(anchorTaskId);
+        const chainIds = chainRows.map((r) => r.id);
+        if (chainIds.length === 0)
+            return { spawns: [], task_count: 0 };
+        const ph = chainIds.map(() => '?').join(',');
+        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 task_events te
+        JOIN events e ON e.event_id = te.event_id
+       WHERE te.task_id IN (${ph})
+         AND e.tool_name IN ('Task','Agent')
+         AND e.hook_type IN ('PreToolUse','PostToolUse')
+       ORDER BY e.timestamp ASC
+    `).all(...chainIds);
+        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 };
+    }
+    /**
+     * Read the plaintext `user_prompt` of every `UserPromptSubmit` event linked to
+     * any task in `taskIds` (decision ed5c3e93, spec 0909 per-turn-human-input).
+     *
+     * Used by the timeline route's two cross-task aggregation arms to collect the
+     * per-turn human inputs that live in OTHER per-prompt tasks of the same
+     * workflow (the originating task only sees its own first turn). The caller
+     * passes the distinct task_id set already computed from the spawn rows.
+     *
+     * CRITICAL (gzip event-content landmine, MEMORY note): `events.user_prompt` is
+     * a PLAINTEXT TEXT column — read it directly. It is NOT a gzip blob; do NOT run
+     * it through `decodeToolInput`/`decodeToolOutput` (those are for tool_input /
+     * tool_output only).
+     *
+     * Ordering: `ORDER BY e.timestamp ASC` — timestamp is ISO TEXT, lexically
+     * sortable (DB time-column-type landmine: do not treat it as ms INTEGER).
+     * Empty `taskIds` → `[]` (avoid an empty `IN ()` clause).
+     */
+    queryUserPromptsByTaskIds(taskIds) {
+        if (!taskIds || taskIds.length === 0)
+            return [];
+        const ph = taskIds.map(() => '?').join(',');
+        const rows = this.db.prepare(`
+      SELECT e.event_id, e.timestamp, e.user_prompt, te.task_id AS task_id
+        FROM task_events te
+        JOIN events e ON e.event_id = te.event_id
+       WHERE te.task_id IN (${ph})
+         AND e.hook_type = 'UserPromptSubmit'
+         AND e.user_prompt IS NOT NULL
+       ORDER BY e.timestamp ASC
+    `).all(...taskIds);
+        return rows.map((row) => ({
+            event_id: row.event_id,
+            timestamp: row.timestamp,
+            // Plaintext column — direct read, never decoded.
+            user_prompt: row.user_prompt,
+            task_id: row.task_id ?? null,
+        }));
     }
     updateTask(taskId, updates) {
         const sets = [];
@@ -32,6 +254,30 @@ export class TaskOperations {
             sets.push('title = ?');
             params.push(updates.title);
         }
+        if (updates.outcome !== undefined) {
+            sets.push('outcome = ?');
+            params.push(updates.outcome);
+        }
+        if (updates.outcome_reason !== undefined) {
+            sets.push('outcome_reason = ?');
+            params.push(updates.outcome_reason);
+        }
+        if (updates.commit_count !== undefined) {
+            sets.push('commit_count = ?');
+            params.push(updates.commit_count);
+        }
+        if (updates.reverted_commits !== undefined) {
+            sets.push('reverted_commits = ?');
+            params.push(updates.reverted_commits);
+        }
+        if (updates.user_violation_count !== undefined) {
+            sets.push('user_violation_count = ?');
+            params.push(updates.user_violation_count);
+        }
+        if (updates.classified_at !== undefined) {
+            sets.push('classified_at = ?');
+            params.push(updates.classified_at);
+        }
         if (sets.length === 0)
             return;
         params.push(taskId);
@@ -41,6 +287,88 @@ export class TaskOperations {
         this.db.prepare(`INSERT OR IGNORE INTO task_events (task_id, event_id) VALUES (?, ?)`).run(taskId, eventId);
         this.db.prepare(`UPDATE tasks SET event_count = event_count + 1, end_time = (SELECT timestamp FROM events WHERE event_id = ?) WHERE id = ?`).run(eventId, taskId);
     }
+    /**
+     * Task-tracking overhaul (2026-05-27 spec §3.3 Q3): pure-attachment variant
+     * of linkEventToTask. Inserts the task_events row + increments event_count
+     * BUT does NOT advance task.end_time. Used by the orphan-recovery fallback
+     * in TaskSegmenter.linkEvent so attaching a late-arriving sub-agent event
+     * to a recently-completed task doesn't stretch its duration KPI.
+     *
+     * Tradeoff: KPIs that count events get the orphan back, KPIs that read
+     * end_time stay honest. Outcome / commit_count rollups already ran at Stop
+     * time so they're unaffected either way.
+     */
+    attachEventToTask(taskId, eventId) {
+        this.db.prepare(`INSERT OR IGNORE INTO task_events (task_id, event_id) VALUES (?, ?)`).run(taskId, eventId);
+        this.db.prepare(`UPDATE tasks SET event_count = event_count + 1 WHERE id = ?`).run(taskId);
+    }
+    /**
+     * Orphan-event robustness fix (2026-06-01): direct lookup of a session's
+     * single active *user* task.
+     *
+     * Replaces the old `queryTasks(limit:5).find(...)` heuristic in
+     * TaskSegmenter.recoverActiveTask, which broke on high-task-count sessions:
+     * the active user task could be pushed out of the most-recent-5 window by a
+     * burst of newer agent-callback / completed rows, so `.find()` returned null
+     * and every subsequent event orphaned.
+     *
+     * SQL pins the predicate at the DB layer (no LIMIT truncation):
+     *   WHERE session_id = ? AND status = 'active'
+     *     AND (task_kind = 'user' OR (task_kind IS NULL AND is_noise = 0))
+     *   ORDER BY start_time DESC LIMIT 1
+     *
+     * The `task_kind IS NULL AND is_noise = 0` arm preserves backward compat for
+     * legacy rows written before the task_kind backfill (spec b1480935).
+     */
+    /**
+     * decision c6613590 P0 缺陷 B: cheap PK existence check for status='active'.
+     *
+     * Used by TaskSegmenter.getTrustedCurrent to PK-recheck a map hit before
+     * trusting it, so a task the stale-GC already flipped to 'completed' can't
+     * keep absorbing new events via a dangling in-memory pointer. Returns false
+     * for unknown / completed / abandoned ids.
+     */
+    isTaskActive(taskId) {
+        const row = this.db.prepare(`SELECT 1 FROM tasks WHERE id = ? AND status = 'active' LIMIT 1`).get(taskId);
+        return row !== undefined;
+    }
+    getActiveUserTask(sessionId) {
+        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.session_id = ?
+         AND t.status = 'active'
+         AND (t.task_kind = 'user' OR (t.task_kind IS NULL AND t.is_noise = 0))
+       ORDER BY t.start_time DESC
+       LIMIT 1
+    `).get(sessionId);
+        if (!row)
+            return null;
+        return this.mapRow(row);
+    }
+    /**
+     * Orphan-event robustness fix (2026-06-01): every session that currently has
+     * at least one active *user* task, with that task's id + start_time anchor.
+     *
+     * Drives TaskSegmenter.hydrateActiveTasks() so a freshly-restarted daemon can
+     * re-populate its in-memory `currentTasks` map up-front, instead of relying
+     * on per-event lazy recovery (which misses buffered/replayed events whose
+     * recovery heuristic doesn't fire).
+     *
+     * One row per session (the most recently started active user task wins) —
+     * mirrors getActiveUserTask's tie-break so hydrate and lazy-recover agree.
+     */
+    queryActiveUserTaskSessions() {
+        const rows = this.db.prepare(`
+      SELECT t.session_id AS session_id, t.id AS task_id, MAX(t.start_time) AS start_time
+        FROM tasks t
+       WHERE t.status = 'active'
+         AND (t.task_kind = 'user' OR (t.task_kind IS NULL AND t.is_noise = 0))
+       GROUP BY t.session_id
+    `).all();
+        return rows;
+    }
     /** Legacy simple query — returns bare array (used by detail route internally) */
     queryTasks(filter = {}) {
         const conditions = [];
@@ -109,21 +437,229 @@ export class TaskOperations {
         const rows = this.db.prepare(`SELECT event_id FROM task_events WHERE task_id = ?`).all(taskId);
         return rows.map(r => r.event_id);
     }
+    /**
+     * 批量把 event_id 反查到 task_id（用 task_events 关联表）。
+     *
+     * 场景：pipeline 视图想为每个 prompt 行附上 task_id（让用户点 prompt 直接
+     * 跳 task drawer 看"这个任务实际干了什么"，而不是噪音重的 session 视图）。
+     *
+     * 实现：一条 IN(...) 查询，event_id 通常 ≤ pipeline limit（默认 50，
+     * 上限 200）— 远低于 SQLite 单语句参数限制 (999)，无需分批。
+     */
+    queryTaskIdsByEventIds(eventIds) {
+        const out = new Map();
+        if (eventIds.length === 0)
+            return out;
+        const placeholders = eventIds.map(() => '?').join(',');
+        const rows = this.db
+            .prepare(`SELECT event_id, task_id FROM task_events WHERE event_id IN (${placeholders})`)
+            .all(...eventIds);
+        for (const r of rows) {
+            // 一个 event 理论上只 link 到一个 task（PRIMARY KEY (task_id, event_id) +
+            // TaskSegmenter 单分配语义）。万一重复以最先看到的为准。
+            if (!out.has(r.event_id))
+                out.set(r.event_id, r.task_id);
+        }
+        return out;
+    }
+    /**
+     * Task-tracking overhaul (2026-05-27 spec §3.3): orphan-event recovery.
+     *
+     * After StopHandler completes the current task, late-arriving sub-agent
+     * PostToolUse events (the spawn's Bash/Read/etc tool calls that fire
+     * AFTER Stop closes the parent task) used to orphan because
+     * TaskSegmenter.linkEvent could not find an active task. Spec § 3.3
+     * Option C: when no active task exists, attach the event to the most
+     * recently completed task on the same session if it's within
+     * `sinceMs` of the event timestamp.
+     *
+     * Q3 (spec § 11): we do NOT update `task.end_time` here — the fallback
+     * is pure attachment (event_count grows by the linkEventToTask path in
+     * the caller). Updating end_time would stretch the duration KPI for
+     * every orphan that lands inside the recovery window and corrupt the
+     * outcome / task duration analytics.
+     *
+     * Order: most-recently-ended task first. event_time bound via SQLite
+     * julianday() — sinceMs is the look-back window in ms (typically 5 min).
+     * Returns null if no candidate within the window.
+     */
+    findRecentCompletedTaskForOrphan(opts) {
+        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.session_id = ?
+         AND t.status = 'completed'
+         AND t.end_time IS NOT NULL
+         AND (julianday(?) - julianday(t.end_time)) * 86400000 <= ?
+       ORDER BY t.end_time DESC
+       LIMIT 1
+    `).get(opts.session_id, opts.event_ts_iso, opts.sinceMs);
+        if (!row)
+            return null;
+        return this.mapRow(row);
+    }
+    /**
+     * Task-tracking deep fix (2026-05-27 spec §3.A): smart orphan-recovery helper.
+     *
+     * Finds the most recently completed task on the same session whose end_time
+     * is before the event timestamp AND there is no other task that started
+     * between that completed task's end_time and the event timestamp.
+     *
+     * Algorithm (plain English):
+     *   - candidate: status='completed', end_time IS NOT NULL, end_time <= event_ts
+     *   - guard: NOT EXISTS t2 where t2.session_id = t.session_id
+     *            AND t2.start_time > t.end_time AND t2.start_time <= event_ts
+     *   - if multiple candidates, take end_time DESC (most recent)
+     *   - returns null if no qualifying candidate
+     *
+     * Unlike findRecentCompletedTaskForOrphan (5-min window), this function has
+     * NO time-window cap. If the idle gap is 2h and no new task started during
+     * that gap, the event still attaches to the completed task. The "newer task
+     * block" guard prevents cross-task mis-attribution.
+     */
+    findCompletedTaskForOrphanSmart(opts) {
+        try {
+            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.session_id = ?
+           AND t.status = 'completed'
+           AND t.end_time IS NOT NULL
+           AND t.end_time <= ?
+           AND NOT EXISTS (
+             SELECT 1 FROM tasks t2
+              WHERE t2.session_id = t.session_id
+                AND t2.start_time > t.end_time
+                AND t2.start_time <= ?
+           )
+         ORDER BY t.end_time DESC
+         LIMIT 1
+      `).get(opts.session_id, opts.event_ts_iso, opts.event_ts_iso);
+            if (!row)
+                return null;
+            return this.mapRow(row);
+        }
+        catch (err) {
+            // Defensive: log and return null so callers can fall back to legacy window
+            // method rather than crashing the daemon event pipeline.
+            // eslint-disable-next-line no-console
+            console.warn('[TaskOperations] findCompletedTaskForOrphanSmart SQL error:', err);
+            return null;
+        }
+    }
+    /**
+     * Task-tracking deep fix (2026-05-27 spec §5.C): UNION fallback query.
+     *
+     * Returns all events associated with the task via two sources:
+     *   1. linked (linked=1): events directly linked via task_events JOIN
+     *   2. fallback (linked=0): events in the same session+time window that are
+     *      NOT in task_events for this task AND NOT linked to any OTHER task
+     *      on the same session (prevents event theft across tasks)
+     *
+     * The `linked` field lets callers (web timeline) badge unlinked events.
+     */
+    queryEventsByTaskIdWithFallback(taskId, opts = {}) {
+        const limit = opts.limit ?? 5000;
+        // We need the task's session_id + time window first
+        const taskRow = this.db.prepare(`
+      SELECT session_id, start_time, end_time FROM tasks WHERE id = ?
+    `).get(taskId);
+        if (!taskRow)
+            return [];
+        const { session_id, start_time, end_time } = taskRow;
+        // Active tasks: end_time IS NULL → use current time as upper bound
+        const endTimeBound = end_time ?? new Date().toISOString();
+        const rows = this.db.prepare(`
+      SELECT e.*, 1 AS linked
+        FROM events e
+        JOIN task_events te ON te.event_id = e.event_id
+       WHERE te.task_id = ?
+
+      UNION
+
+      SELECT e.*, 0 AS linked
+        FROM events e
+       WHERE e.session_id = ?
+         AND e.timestamp >= ?
+         AND e.timestamp <= ?
+         AND e.event_id NOT IN (
+           SELECT event_id FROM task_events WHERE task_id = ?
+         )
+         AND e.event_id NOT IN (
+           SELECT event_id FROM task_events
+            WHERE task_id IN (
+              SELECT id FROM tasks
+               WHERE session_id = ?
+                 AND id != ?
+            )
+         )
+
+       ORDER BY timestamp ASC
+       LIMIT ?
+    `).all(taskId, session_id, start_time, endTimeBound, taskId, session_id, taskId, limit);
+        return rows.map(r => ({
+            ...this.rowToEvent(r),
+            linked: r.linked === 1 ? 1 : 0,
+        }));
+    }
+    /**
+     * B+ spec: 30min smart window 续命 helper.
+     *
+     * Reactivates a previously completed task so that a new UserPromptSubmit
+     * that arrives within TASK_RESUME_WINDOW_MS of its end_time can continue
+     * the same task instead of creating a new one.
+     *
+     * Mutations:
+     *   - status  → 'active'
+     *   - end_time → NULL  (cleared; duration KPI will re-anchor at Stop time)
+     *
+     * start_time is intentionally left untouched (spec §B+: "不改 start_time").
+     * Outcome / commit_count / classified_at columns are not touched here — they
+     * would have been NULL anyway (no outcome had landed in a gap of < 30min).
+     */
+    resumeTask(taskId) {
+        this.db.prepare(`
+      UPDATE tasks SET status = 'active', end_time = NULL WHERE id = ?
+    `).run(taskId);
+    }
     /**
      * 将 idle 超过阈值的 active task 批量转为 completed。
      * 条件：status='active' AND end_time IS NOT NULL
      *       AND (now - end_time) > idleMinutes 分钟。
-     * 返回：受影响行数。
+     *
+     * 返回：被关闭的 task id 列表（decision c6613590 P0 缺陷 B）。
+     *
+     * 此前返回行数（number），调用方拿不到具体被关的 task id，导致
+     * daemon 的 GC 把任务在 DB 标 completed 后，TaskSegmenter.currentTasks
+     * 内存 map 仍留着指向这些已关任务的悬空指针——后续事件经
+     * linkEventToTask 推进其 end_time，骗过 30min resume 窗，把多条独立
+     * prompt 错并进陈旧任务。改为返回 id 列表后，daemon 可据此从内存
+     * map 驱逐这些 entry，使 GC 与内存 map 保持一致。
+     *
+     * 实现：先 SELECT 出符合条件的 id（带 task_kind / session 信息以便
+     * 调用方按 session 驱逐），再用同一谓词 UPDATE。两步在 better-sqlite3
+     * 同步事务语义下原子。
      */
     completeStaleActiveTasks(idleMinutes) {
-        const result = this.db.prepare(`
+        const stale = this.db.prepare(`
+      SELECT id, session_id
+        FROM tasks
+       WHERE status = 'active'
+         AND end_time IS NOT NULL
+         AND (julianday('now') - julianday(end_time)) * 24 * 60 > ?
+    `).all(idleMinutes);
+        if (stale.length === 0)
+            return [];
+        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;
+        return stale;
     }
     // ── H1: detail route 用的 PK 直查 / JOIN 接口 ──────────────────────
     /**
@@ -177,6 +713,7 @@ export class TaskOperations {
             source_handler: r.source_handler,
             injection_type: r.injection_type,
             content: r.content,
+            metadata_json: r.metadata_json || undefined,
         }));
     }
     /**
@@ -204,20 +741,1073 @@ export class TaskOperations {
     `).all(taskId, nowMs);
         return rows;
     }
-    /** Map a raw events row to ForgeEvent (parses JSON columns). */
-    rowToEvent(row) {
-        const parseJson = (val) => {
-            if (val == null)
-                return undefined;
-            if (typeof val !== 'string')
-                return val;
+    /**
+     * 该任务执行窗内 agent 主动 pull 的 KB（decision 93b3075b）—— 任务详情页右栏
+     * 「用了什么 → KB 主动 pull」从「无主动 pull」降级占位接成真实数据。
+     *
+     * scope 口径（与 querySkillInvocationsByTaskWindow 同思路，但 kb_query_log
+     * **没有 session_id 列**，故纯按时间窗 + project 圈到具体任务）：
+     *   - 时间窗：kb_query_log.ts(INTEGER ms) BETWEEN task.start_time(→ms) 和
+     *     COALESCE(task.end_time→ms+999, now_ms)。task.start/end 是 ISO TEXT，
+     *     用 strftime('%s', ...)*1000 转 ms 比较（kb_query_log.ts 地雷：是 ms 整数，
+     *     别打成 1970）。end_time IS NULL（active task）→ 取 now_ms 兜底。
+     *   - **project 圈定**：JOIN tasks t LEFT JOIN sessions s 取 project_path，
+     *     仅取 kb_query_log.project_path = 该任务 project 的 pull。本 session 多任务
+     *     共享 session_id，且同一时间窗可能并发别项目的 pull（实测 64d37b1d 窗内有
+     *     /prm 项目的 coder pull），故 project 过滤 + 时间窗一起把 pull 圈到本任务
+     *     的本项目，不串别项目/别任务。project_path 为 NULL（孤儿 task）→ 不串任何
+     *     pull（IS NOT NULL guard）。
+     *   - **只取真实 agent pull**：reason LIKE '%kb-precedent%'（coder/verify/
+     *     safetynet/decision 的 pull-reason 约定），与 countAgentKbPulls 同口径，
+     *     排掉 `cf knowledge query foo` 探针（同时 NULL-safe 排 sentinel
+     *     agent_id='cli-no-session'，decision 2d6d59b0）。
+     *
+     * `now_ms` 通过参数注入（end_time IS NULL 时取此值），便于测试 mock。
+     */
+    queryTaskKbPulls(taskId, opts = {}) {
+        const nowMs = opts.now_ms ?? Date.now();
+        const rows = this.db.prepare(`
+      SELECT k.ts AS ts, k.query AS query, k.reason AS reason,
+             k.workflow AS workflow, k.phase AS phase,
+             k.usefulness AS usefulness, k.usefulness_note AS usefulness_note,
+             k.result_count AS result_count
+      FROM kb_query_log k
+      JOIN tasks t ON t.id = ?
+      LEFT JOIN sessions s ON s.session_id = t.session_id
+      WHERE s.project_path IS NOT NULL
+        AND k.project_path = s.project_path
+        AND k.reason LIKE '%kb-precedent%'
+        AND (k.agent_id IS NULL OR k.agent_id != 'cli-no-session')
+        AND k.ts >= CAST(strftime('%s', t.start_time) AS INTEGER) * 1000
+        AND k.ts <= COALESCE(
+              CAST(strftime('%s', t.end_time) AS INTEGER) * 1000 + 999,
+              ?
+            )
+      ORDER BY k.ts ASC
+    `).all(taskId, nowMs);
+        return rows;
+    }
+    // ── Agent Board v3 (task-centric, 2026-05-22) ─────────────────────────
+    //
+    // 每张卡片 = 一个 task 行（TaskSegmenter 自动按 user prompt 切分）。
+    // 替换 v2 的 session-centric 视图（session 是执行痕迹，不是工作项）。
+    //
+    // v3.1 (2026-05-25, perf P0.3) — N+1 → batched fetch:
+    //   - 旧版：1 SELECT × 40 rows × 7 内嵌相关子查询 = ~280 隐式子查询，
+    //     线性 scaling（10 行=308ms / 40 行=1.2s / 120 行=3.6s）。
+    //   - 新版：1 SQL 拿基础行（含 ids），7 个批量聚合 SQL 用 `WHERE ... IN (?,?,..)`
+    //     一次性取所有 aggregate，JS 内存 merge 回每行。
+    //
+    // SQL 设计：
+    //   - 主表 tasks t JOIN sessions s（取 project_path）
+    //   - 噪音过滤：title 长度 / task-notification 前缀 / 纯应答词 / 单 word slash command
+    //   - 批量聚合（按维度）：
+    //       top_tools / spawned / files_changed / last_file → events JOIN task_events on task_id
+    //                                                          GROUP BY task_id
+    //       intercepts (deny/warn)                          → tool_intercepts WHERE session_id IN (...)
+    //                                                          AND timestamp >= min(start_time)
+    //                                                          JS 内按 task 时间窗口 bucket
+    //       kb_meta_concat                                  → injections WHERE session_id IN (...)
+    //                                                          AND source_handler='UserPromptSubmitHandler:kb'
+    //                                                          JS 内按 task 时间窗口 bucket
+    //   - 时间窗口 + project filter 作用在 tasks.start_time
+    //
+    // Notes：
+    //   - tool_intercepts / injections 按 session+timestamp 窗口过滤而非 task_events 关联，
+    //     因为这两张表不一定 link 到 task_events（intercept 在 PreToolUse 阶段，
+    //     injection 在 UserPromptSubmit 阶段）。用时间窗口可覆盖 task 范围。
+    //   - 噪音过滤 case-insensitive：title 经 LOWER() 比较 ('approve','停' 等)。
+    //   - now_ms 可注入便于测试（mock end_time IS NULL 的情况）。
+    queryAgentBoardTasks(opts) {
+        const limit = Math.min(Math.max(opts.limit ?? 120, 1), 300);
+        const offset = Math.max(opts.offset ?? 0, 0);
+        const nowMs = opts.now_ms ?? Date.now();
+        const sinceMs = nowMs - opts.windowDays * DAY_MS;
+        const since = new Date(sinceMs).toISOString();
+        const nowIso = new Date(nowMs).toISOString();
+        let projectFilter = '';
+        if (opts.projectPath) {
+            projectFilter = 'AND s.project_path = ?';
+        }
+        // spec b1480935 (2026-06-01 Option A): SQL filter switched from
+        // `t.is_noise = 0` to `t.task_kind IN (...)`. is_noise is deprecated;
+        // the kind enum is more expressive (callback / image / system distinct).
+        //
+        // Filter resolution order:
+        //   1) opts.includeKinds explicit          → use as-is
+        //   2) opts.includeNoise=true (legacy)     → all 4 kinds
+        //   3) default                              → ['user'] only
+        const effectiveKinds = opts.includeKinds
+            ?? (opts.includeNoise ? ALL_TASK_KINDS : ['user']);
+        const kindFilter = effectiveKinds.length === ALL_TASK_KINDS.length
+            ? '' // no filter needed when caller wants everything
+            : `AND t.task_kind IN (${effectiveKinds.map(() => '?').join(',')})`;
+        // ── Step 1: 基础查询（无内嵌子查询，毫秒级） ──────────────────────
+        const baseSql = `
+      SELECT
+        t.id                          AS id,
+        t.session_id                  AS session_id,
+        s.project_path                AS project_path,
+        t.title                       AS title,
+        t.description                 AS description,
+        t.start_time                  AS start_time,
+        t.end_time                    AS end_time,
+        t.status                      AS status,
+        t.event_count                 AS event_count,
+        t.outcome                     AS outcome,
+        t.outcome_reason              AS outcome_reason,
+        t.commit_count                AS commit_count,
+        t.reverted_commits            AS reverted_commits,
+        t.user_violation_count        AS user_violation_count,
+        t.task_kind                   AS task_kind,
+        (CASE
+          WHEN t.end_time IS NOT NULL THEN
+            CAST(strftime('%s', t.end_time) AS INTEGER) - CAST(strftime('%s', t.start_time) AS INTEGER)
+          ELSE
+            CAST(strftime('%s', 'now') AS INTEGER) - CAST(strftime('%s', t.start_time) AS INTEGER)
+        END)                          AS duration_sec
+      FROM tasks t
+      JOIN sessions s ON s.session_id = t.session_id
+      WHERE t.start_time >= ?
+        ${projectFilter}
+        ${kindFilter}
+      ORDER BY t.start_time DESC
+      LIMIT ? OFFSET ?
+    `;
+        const baseParams = [since];
+        if (opts.projectPath)
+            baseParams.push(opts.projectPath);
+        if (kindFilter)
+            baseParams.push(...effectiveKinds);
+        baseParams.push(limit, offset);
+        const baseRows = this.db.prepare(baseSql).all(...baseParams);
+        if (baseRows.length === 0)
+            return [];
+        // (count companion lives in countAgentBoardTasks below — same WHERE clauses
+        //  minus LIMIT/ORDER, so the KPI "总任务数 (7d)" doesn't get clipped by
+        //  the lane render cap. Added 2026-05-26 to fix "stuck at 40" bug.)
+        const taskIds = baseRows.map(r => r.id);
+        const sessionIdSet = new Set(baseRows.map(r => r.session_id));
+        const sessionIds = Array.from(sessionIdSet);
+        const taskPh = taskIds.map(() => '?').join(',');
+        const sessionPh = sessionIds.map(() => '?').join(',');
+        const toolRows = this.db.prepare(`
+      SELECT te.task_id AS task_id, e.tool_name AS tool, COUNT(*) AS cnt
+        FROM task_events te INDEXED BY idx_task_events_task
+        JOIN events e ON e.event_id = te.event_id
+       WHERE te.task_id IN (${taskPh})
+         AND e.hook_type = 'PostToolUse'
+         AND e.tool_name IS NOT NULL
+       GROUP BY te.task_id, e.tool_name
+    `).all(...taskIds);
+        const rawRows = this.db.prepare(`
+      SELECT te.task_id AS task_id,
+             e.tool_name AS tool_name,
+             e.tool_input AS tool_input,
+             e.timestamp AS ts
+        FROM task_events te JOIN events e ON e.event_id = te.event_id
+       WHERE te.task_id IN (${taskPh})
+         AND e.hook_type = 'PostToolUse'
+         AND e.tool_input IS NOT NULL
+         AND e.tool_name IN ('Task', 'Agent', 'Edit', 'Write', 'NotebookEdit')
+    `).all(...taskIds);
+        const spawnAggMap = new Map(); // task_id → (sub_type → cnt)
+        const filesByTaskSet = new Map(); // task_id → distinct file_paths
+        const lastFileRowsRaw = [];
+        for (const raw of rawRows) {
+            let decoded = null;
             try {
-                return JSON.parse(val);
+                const d = decodeToolInput(raw.tool_input);
+                if (d && typeof d === 'object' && !Array.isArray(d)) {
+                    decoded = d;
+                }
             }
             catch {
-                return val;
+                continue; // skip malformed rows
+            }
+            if (!decoded)
+                continue;
+            if (raw.tool_name === 'Task' || raw.tool_name === 'Agent') {
+                const subType = decoded.subagent_type;
+                if (typeof subType === 'string' && subType.length > 0) {
+                    let inner = spawnAggMap.get(raw.task_id);
+                    if (!inner) {
+                        inner = new Map();
+                        spawnAggMap.set(raw.task_id, inner);
+                    }
+                    inner.set(subType, (inner.get(subType) ?? 0) + 1);
+                }
+            }
+            else if (raw.tool_name === 'Edit' || raw.tool_name === 'Write' || raw.tool_name === 'NotebookEdit') {
+                const filePath = decoded.file_path;
+                if (typeof filePath === 'string' && filePath.length > 0) {
+                    let set = filesByTaskSet.get(raw.task_id);
+                    if (!set) {
+                        set = new Set();
+                        filesByTaskSet.set(raw.task_id, set);
+                    }
+                    set.add(filePath);
+                    lastFileRowsRaw.push({ task_id: raw.task_id, file_path: filePath, ts: raw.ts });
+                }
+            }
+        }
+        const spawnRows = [];
+        for (const [task_id, subMap] of spawnAggMap) {
+            for (const [sub_type, cnt] of subMap) {
+                spawnRows.push({ task_id, sub_type, cnt });
+            }
+        }
+        const filesRows = [];
+        for (const [task_id, set] of filesByTaskSet) {
+            filesRows.push({ task_id, n: set.size });
+        }
+        // 2e + 2f. intercepts (deny/warn) per session — fetch all rows in window,
+        // JS buckets by task time range. We bound the timestamp scan with the
+        // earliest task start_time to keep the scan tight.
+        const earliestStart = baseRows.reduce((min, r) => (r.start_time < min ? r.start_time : min), baseRows[0].start_time);
+        const interceptRows = sessionIds.length === 0 ? [] : this.db.prepare(`
+      SELECT ti.session_id AS session_id, ti.timestamp AS timestamp, ti.decision AS decision
+        FROM tool_intercepts ti
+       WHERE ti.session_id IN (${sessionPh})
+         AND ti.timestamp >= ?
+         AND ti.decision IN ('deny','warn')
+    `).all(...sessionIds, earliestStart);
+        const injectionRows = sessionIds.length === 0 ? [] : this.db.prepare(`
+      SELECT i.session_id AS session_id, i.timestamp AS timestamp, i.metadata_json AS metadata_json
+        FROM injections i
+       WHERE i.session_id IN (${sessionPh})
+         AND i.source_handler = 'UserPromptSubmitHandler:kb'
+         AND i.timestamp >= ?
+    `).all(...sessionIds, earliestStart);
+        // ── Step 3: JS merge ────────────────────────────────────────────────
+        // 3a/b/c. Bucket by task_id
+        const toolsByTask = new Map();
+        for (const r of toolRows) {
+            const list = toolsByTask.get(r.task_id);
+            if (list)
+                list.push(r);
+            else
+                toolsByTask.set(r.task_id, [r]);
+        }
+        const spawnByTask = new Map();
+        for (const r of spawnRows) {
+            const list = spawnByTask.get(r.task_id);
+            if (list)
+                list.push(r);
+            else
+                spawnByTask.set(r.task_id, [r]);
+        }
+        const filesByTask = new Map();
+        for (const r of filesRows)
+            filesByTask.set(r.task_id, r.n);
+        // 3d. last_file: pick most recent ts per task
+        const lastFileByTask = new Map();
+        for (const r of lastFileRowsRaw) {
+            const cur = lastFileByTask.get(r.task_id);
+            if (!cur || r.ts > cur.ts)
+                lastFileByTask.set(r.task_id, r);
+        }
+        // 3e/f/g. For per-task time-window aggregates we group source rows by
+        // session first, then scan only that session's rows for each task — keeps
+        // it O(per-task scan over session subset) rather than O(tasks * all rows).
+        const interceptsBySession = new Map();
+        for (const r of interceptRows) {
+            const list = interceptsBySession.get(r.session_id);
+            if (list)
+                list.push(r);
+            else
+                interceptsBySession.set(r.session_id, [r]);
+        }
+        const injectionsBySession = new Map();
+        for (const r of injectionRows) {
+            const list = injectionsBySession.get(r.session_id);
+            if (list)
+                list.push(r);
+            else
+                injectionsBySession.set(r.session_id, [r]);
+        }
+        // ── Step 4: build final rows in AgentBoardTaskRow shape ─────────────
+        return baseRows.map(b => {
+            // top_tools_json (top 3 desc by cnt, matches old SQL semantic)
+            const toolsRaw = (toolsByTask.get(b.id) ?? [])
+                .slice()
+                .sort((a, c) => c.cnt - a.cnt)
+                .slice(0, 3)
+                .map(r => ({ tool: r.tool, n: r.cnt }));
+            // spawned_json (top 5 desc by cnt)
+            const spawnedRaw = (spawnByTask.get(b.id) ?? [])
+                .slice()
+                .sort((a, c) => c.cnt - a.cnt)
+                .slice(0, 5)
+                .map(r => ({ type: r.sub_type, n: r.cnt }));
+            // intercepts: scan session rows within [start_time, end_time||now]
+            const endIso = b.end_time ?? nowIso;
+            let deny = 0;
+            let warn = 0;
+            const sessIntercepts = interceptsBySession.get(b.session_id);
+            if (sessIntercepts) {
+                for (const r of sessIntercepts) {
+                    if (r.timestamp < b.start_time || r.timestamp > endIso)
+                        continue;
+                    if (r.decision === 'deny')
+                        deny += 1;
+                    else if (r.decision === 'warn')
+                        warn += 1;
+                }
             }
+            // kb_meta_concat: '||' join the metadata_json fields in window
+            const sessInjections = injectionsBySession.get(b.session_id);
+            let kbConcat = null;
+            if (sessInjections) {
+                const parts = [];
+                for (const r of sessInjections) {
+                    if (r.timestamp < b.start_time || r.timestamp > endIso)
+                        continue;
+                    if (r.metadata_json)
+                        parts.push(r.metadata_json);
+                }
+                if (parts.length > 0)
+                    kbConcat = parts.join('||');
+            }
+            return {
+                id: b.id,
+                session_id: b.session_id,
+                project_path: b.project_path,
+                title: b.title,
+                description: b.description,
+                start_time: b.start_time,
+                end_time: b.end_time,
+                status: b.status,
+                event_count: b.event_count,
+                outcome: b.outcome,
+                outcome_reason: b.outcome_reason,
+                commit_count: b.commit_count,
+                reverted_commits: b.reverted_commits,
+                user_violation_count: b.user_violation_count,
+                task_kind: b.task_kind ?? 'user',
+                duration_sec: b.duration_sec,
+                top_tools_json: toolsRaw.length > 0 ? JSON.stringify(toolsRaw) : '[]',
+                spawned_json: spawnedRaw.length > 0 ? JSON.stringify(spawnedRaw) : '[]',
+                files_changed: filesByTask.get(b.id) ?? 0,
+                last_file: lastFileByTask.get(b.id)?.file_path ?? null,
+                deny_count: deny,
+                warn_count: warn,
+                kb_meta_concat: kbConcat,
+            };
+        });
+    }
+    /**
+     * Shared task_kind filter resolution (decision b509fd91, 2026-06-08).
+     *
+     * Extracted so queryAgentBoardTasks / countAgentBoardTasks /
+     * queryAgentBoardPromptRows / countAgentBoardPromptRows all resolve the
+     * effective kind whitelist identically — no copy-paste drift. Resolution
+     * order matches the pre-existing inline logic:
+     *   1) explicit includeKinds      → use as-is
+     *   2) includeNoise=true (legacy) → all 4 kinds
+     *   3) default                     → ['user'] only
+     *
+     * Returns { effectiveKinds, kindFilter } where kindFilter is the SQL
+     * fragment (empty string when the caller wants all kinds — no filter needed).
+     */
+    resolveKindFilter(opts) {
+        const effectiveKinds = opts.includeKinds
+            ?? (opts.includeNoise ? ALL_TASK_KINDS : ['user']);
+        const kindFilter = effectiveKinds.length === ALL_TASK_KINDS.length
+            ? ''
+            : `AND t.task_kind IN (${effectiveKinds.map(() => '?').join(',')})`;
+        return { effectiveKinds, kindFilter };
+    }
+    /**
+     * Shared outcome-bucket filter resolution (decision 0c1549ec, 2026-06-11).
+     *
+     * The TasksHub「我的任务」list view's outcome chips push their selection to
+     * the backend so filtering happens over the WHOLE window (not the page-local
+     * ~120 rows). The bucket classification here MUST mirror the CASE expression
+     * in queryAgentBoardPromptWindowAggregates so the chip COUNTS and the chip
+     * FILTER agree exactly — otherwise we re-introduce the count/filter 口径
+     * split that commit 40e03283 caused.
+     *
+     * Bucket → predicate over the `t` (tasks) alias:
+     *   - 'all' / undefined → '' (no filter, backward compatible)
+     *   - 'success'|'partial'|'failed' → t.outcome = '<bucket>'
+     *   - 'abandoned' → t.outcome='abandoned' OR (t.outcome IS NULL AND status='abandoned')
+     *   - 'answered'  → t.outcome='answered'
+     *   - 'none'      → residual catch-all (the in-progress / no-terminal-outcome
+     *                   bucket + any unknown/legacy outcome string), exactly the
+     *                   complement of the five buckets above.
+     * Returns the bare predicate (no leading AND); caller wraps in `AND (...)`.
+     * The `t` alias is parameterless (no bind values), so callers don't push args.
+     */
+    resolveOutcomeFilter(outcome) {
+        switch (outcome) {
+            case 'success':
+            case 'partial':
+            case 'failed':
+                return `t.outcome = '${outcome}'`;
+            case 'abandoned':
+                return `(t.outcome = 'abandoned' OR (t.outcome IS NULL AND t.status = 'abandoned'))`;
+            case 'answered':
+                return `t.outcome = 'answered'`;
+            case 'none':
+                // Complement of the five named buckets: NULL-and-not-abandoned (active /
+                // pending / in-progress) plus any unknown/legacy outcome string.
+                return `(
+          t.outcome NOT IN ('success','partial','failed','abandoned','answered')
+          OR (t.outcome IS NULL AND t.status <> 'abandoned')
+          OR (t.outcome IS NULL AND t.status IS NULL)
+        )`;
+            case 'all':
+            case undefined:
+            default:
+                return '';
+        }
+    }
+    /**
+     * Shared free-text search filter for the TasksHub「我的任务」list view
+     * (decision 540ed063, 2026-06-11). Same downsink shape as resolveOutcomeFilter
+     * above: the search box pushes its term to the backend so matching happens
+     * over the WHOLE window (every page), not just the page-local ~120 rows a
+     * client `.filter` could see.
+     *
+     * Matching 口径 (must stay in lockstep between query and count):
+     *   - case-insensitive substring (`LIKE '%term%'`, LOWER on both sides);
+     *   - OR'd across two PLAINTEXT columns — `e.user_prompt` (the prompt text)
+     *     and `t.title` (the task title).
+     *
+     * ⚠️ gzip One-way Door (KB landmine): `events.tool_input` / `tool_output` hold
+     * GZIP-compressed blobs (declared TEXT but binary content) — a bare SQL LIKE
+     * over them silently matches nothing. This predicate therefore touches ONLY
+     * the two plaintext columns above and NEVER tool_input/tool_output.
+     *
+     * Empty / whitespace-only term → '' (no predicate), so absent or blank search
+     * is backward-compatible (= no filter). Returns { predicate, params }: the
+     * predicate has two `?` placeholders, so unlike resolveOutcomeFilter the caller
+     * MUST push the two bind values in clause order.
+     */
+    resolveSearchFilter(search) {
+        const term = (search ?? '').trim();
+        if (!term)
+            return { predicate: '', params: [] };
+        // LIKE-metacharacter hardening (decision 540ed063 follow-up): a user typing a
+        // literal `%` or `_` must NOT get wildcard behavior (`%` matches everything,
+        // `_` matches any single char). Escape the escape char FIRST (so `\` → `\\`),
+        // then `%` and `_`, with backslash as the ESCAPE char declared on each LIKE.
+        // The escaped term is still a bound `?` param (never string-concatenated into
+        // SQL), so this is injection-safe and behavior-preserving for ordinary words
+        // (terms with no `%`/`_`/`\` are unaffected by the replaces).
+        const escaped = term
+            .toLowerCase()
+            .replace(/\\/g, '\\\\')
+            .replace(/%/g, '\\%')
+            .replace(/_/g, '\\_');
+        const like = `%${escaped}%`;
+        return {
+            predicate: "(LOWER(e.user_prompt) LIKE ? ESCAPE '\\' OR LOWER(t.title) LIKE ? ESCAPE '\\')",
+            params: [like, like],
+        };
+    }
+    // ── Agent Board prompt-rows projection (decision b509fd91, 2026-06-08) ───
+    //
+    // "一行 = 一条 user prompt" view (P1 方案 B, zero schema). Each row is one
+    // UserPromptSubmit event; its `group_id` reuses the existing `task_id` so a
+    // task is the group. No new columns, no migration — events.user_prompt is a
+    // plaintext column (only tool_input/tool_output are gzip), so prompt text is
+    // read with a bare SQL substr, never decoding gzip.
+    //
+    // Contrast with queryAgentBoardTasks (one row = one task): this query does NOT
+    // run the 7 per-task aggregations (top_tools / spawned / kb / intercepts). Each
+    // prompt row carries only lightweight fields + its group(task)'s lane metadata,
+    // which is cheap and keeps the (potentially 100+) prompt rows fast to render.
+    //
+    // SQL: events e JOIN task_events te JOIN tasks t JOIN sessions s, filtered to
+    // UserPromptSubmit events with non-null user_prompt, within the window and the
+    // same task_kind whitelist as the task-row query. ORDER BY e.timestamp DESC.
+    //
+    // MUST keep the WHERE filter in sync with countAgentBoardPromptRows below.
+    queryAgentBoardPromptRows(opts) {
+        const limit = Math.min(Math.max(opts.limit ?? 120, 1), 300);
+        const offset = Math.max(opts.offset ?? 0, 0);
+        const nowMs = opts.now_ms ?? Date.now();
+        const sinceMs = nowMs - opts.windowDays * DAY_MS;
+        const since = new Date(sinceMs).toISOString();
+        const projectFilter = opts.projectPath ? 'AND s.project_path = ?' : '';
+        const { effectiveKinds, kindFilter } = this.resolveKindFilter(opts);
+        const outcomePred = this.resolveOutcomeFilter(opts.outcome);
+        const outcomeFilter = outcomePred ? `AND ${outcomePred}` : '';
+        const searchClause = this.resolveSearchFilter(opts.search);
+        const searchFilter = searchClause.predicate ? `AND ${searchClause.predicate}` : '';
+        const sql = `
+      SELECT
+        e.event_id                    AS event_id,
+        substr(e.user_prompt, 1, 300) AS prompt_text,
+        e.timestamp                   AS prompt_ts,
+        e.session_id                  AS session_id,
+        s.project_path                AS project_path,
+        t.id                          AS group_id,
+        t.title                       AS group_title,
+        t.status                      AS group_status,
+        t.outcome                     AS group_outcome,
+        t.task_kind                   AS group_task_kind,
+        t.start_time                  AS group_start_time,
+        t.end_time                    AS group_end_time,
+        t.event_count                 AS group_event_count,
+        (CASE
+          WHEN t.end_time IS NOT NULL THEN
+            CAST(strftime('%s', t.end_time) AS INTEGER) - CAST(strftime('%s', t.start_time) AS INTEGER)
+          ELSE
+            CAST(strftime('%s', 'now') AS INTEGER) - CAST(strftime('%s', t.start_time) AS INTEGER)
+        END)                          AS group_duration_sec
+      FROM events e
+      -- perf (decision 2f05b0bf, 2026-06-13): CROSS JOIN pins the join ORDER so
+      -- the small, selective UserPromptSubmit set on events
+      -- (idx_events_hook_type, ~hundreds of rows) drives the join. Without it the
+      -- optimizer picks tasks USING idx_tasks_kind as the outer loop and fans
+      -- out across EVERY task_events row (tens of thousands), ~90ms PER query,
+      -- linear in window. CROSS JOIN is a pure join-order hint (SQLite keeps the
+      -- written table order); the ON/WHERE predicates are unchanged so the result
+      -- set is byte-identical. Profiled 30d window: q1 91ms to under 2ms, +project
+      -- 48ms to 0.7ms, +search 320ms to 0.8ms (all rowsets verified identical).
+      CROSS JOIN task_events te ON te.event_id = e.event_id
+      CROSS JOIN tasks t        ON t.id = te.task_id
+      CROSS JOIN sessions s     ON s.session_id = t.session_id
+      WHERE e.hook_type = 'UserPromptSubmit'
+        AND e.user_prompt IS NOT NULL
+        AND t.start_time >= ?
+        ${projectFilter}
+        ${kindFilter}
+        ${outcomeFilter}
+        ${searchFilter}
+      ORDER BY e.timestamp DESC
+      LIMIT ? OFFSET ?
+    `;
+        const params = [since];
+        if (opts.projectPath)
+            params.push(opts.projectPath);
+        if (kindFilter)
+            params.push(...effectiveKinds);
+        // search placeholders come after kind, before LIMIT/OFFSET — clause order.
+        if (searchClause.params.length)
+            params.push(...searchClause.params);
+        params.push(limit, offset);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => ({
+            event_id: r.event_id,
+            prompt_text: r.prompt_text ?? '',
+            prompt_ts: r.prompt_ts,
+            session_id: r.session_id,
+            project_path: r.project_path,
+            group_id: r.group_id,
+            group_title: r.group_title,
+            group_status: r.group_status,
+            group_outcome: r.group_outcome,
+            group_task_kind: r.group_task_kind ?? 'user',
+            group_start_time: r.group_start_time,
+            group_end_time: r.group_end_time,
+            group_event_count: r.group_event_count ?? 0,
+            group_duration_sec: r.group_duration_sec,
+        }));
+    }
+    /**
+     * Unbounded count companion for queryAgentBoardPromptRows — the number of
+     * prompt rows (not tasks) in the window, for the list paginator's
+     * total-pages math. Same WHERE clause minus LIMIT/ORDER (decision b509fd91).
+     */
+    countAgentBoardPromptRows(opts) {
+        const nowMs = opts.now_ms ?? Date.now();
+        const sinceMs = nowMs - opts.windowDays * DAY_MS;
+        const since = new Date(sinceMs).toISOString();
+        const projectFilter = opts.projectPath ? 'AND s.project_path = ?' : '';
+        const { effectiveKinds, kindFilter } = this.resolveKindFilter(opts);
+        const outcomePred = this.resolveOutcomeFilter(opts.outcome);
+        const outcomeFilter = outcomePred ? `AND ${outcomePred}` : '';
+        // Same predicate + same bind values as queryAgentBoardPromptRows — count and
+        // query MUST share one 口径 or the paginator denominator diverges from the rows.
+        const searchClause = this.resolveSearchFilter(opts.search);
+        const searchFilter = searchClause.predicate ? `AND ${searchClause.predicate}` : '';
+        const sql = `
+      SELECT COUNT(*) AS n
+      FROM events e
+      -- perf (decision 2f05b0bf): CROSS JOIN pins events-first join order — see
+      -- queryAgentBoardPromptRows for the full rationale (90ms → <2ms; pure
+      -- join-order hint, result count unchanged).
+      CROSS JOIN task_events te ON te.event_id = e.event_id
+      CROSS JOIN tasks t        ON t.id = te.task_id
+      CROSS JOIN sessions s     ON s.session_id = t.session_id
+      WHERE e.hook_type = 'UserPromptSubmit'
+        AND e.user_prompt IS NOT NULL
+        AND t.start_time >= ?
+        ${projectFilter}
+        ${kindFilter}
+        ${outcomeFilter}
+        ${searchFilter}
+    `;
+        const params = [since];
+        if (opts.projectPath)
+            params.push(opts.projectPath);
+        if (kindFilter)
+            params.push(...effectiveKinds);
+        if (searchClause.params.length)
+            params.push(...searchClause.params);
+        const row = this.db.prepare(sql).get(...params);
+        return row?.n ?? 0;
+    }
+    /**
+     * Window-level task aggregates for the prompt-rows list view (2026-06-10).
+     *
+     * Why: the list view's KPI bar ("总任务数 / 失败 / 平均时长") and outcome tab
+     * counts were derived client-side from `queryAgentBoardPromptRows` groups —
+     * i.e. from ONE PAGE (LIMIT default 120) — so they showed page-local numbers
+     * (e.g. 34) instead of true window totals (e.g. 709). This method runs the
+     * SAME WHERE 口径 as countAgentBoardPromptRows (window / project / kind
+     * whitelist, prompt-bearing tasks only) but dedupes to distinct tasks and
+     * aggregates outcome distribution + average duration in SQL.
+     *
+     * Semantics intentionally mirror the page's previous client-side math:
+     *   - task_total        = COUNT(DISTINCT task) — a task with N prompts counts once.
+     *   - outcome_abandoned = outcome='abandoned' OR (outcome IS NULL AND
+     *                         status='abandoned') — same fold the outcome chips did.
+     *   - outcome_answered  = outcome='answered' (spec 1100 Option C, 2026-06-02 —
+     *                         a first-class fifth value; no UI tab, but live data
+     *                         has hundreds of these so it must not vanish).
+     *   - outcome_none      = residual catch-all: outcome IS NULL with a
+     *                         non-abandoned status, OR any unknown/legacy outcome
+     *                         string (the column CHECK only enforces non-empty).
+     *   - avg_duration_sec  = AVG over tasks with duration > 0, where duration is
+     *                         the same CASE expression queryAgentBoardPromptRows
+     *                         computes for group_duration_sec (end-start, or
+     *                         now-start while active). Rounded to whole seconds.
+     *
+     * Invariant (tested, holds for ARBITRARY outcome strings thanks to the
+     * catch-all): success+partial+failed+abandoned+answered+none == task_total.
+     * MUST keep the inner WHERE in sync with queryAgentBoardPromptRows /
+     * countAgentBoardPromptRows above.
+     */
+    queryAgentBoardPromptWindowAggregates(opts) {
+        const nowMs = opts.now_ms ?? Date.now();
+        const sinceMs = nowMs - opts.windowDays * DAY_MS;
+        const since = new Date(sinceMs).toISOString();
+        const projectFilter = opts.projectPath ? 'AND s.project_path = ?' : '';
+        const { effectiveKinds, kindFilter } = this.resolveKindFilter(opts);
+        const sql = `
+      SELECT
+        COUNT(*)                                                   AS task_total,
+        SUM(CASE WHEN g.outcome = 'success' THEN 1 ELSE 0 END)     AS outcome_success,
+        SUM(CASE WHEN g.outcome = 'partial' THEN 1 ELSE 0 END)     AS outcome_partial,
+        SUM(CASE WHEN g.outcome = 'failed'  THEN 1 ELSE 0 END)     AS outcome_failed,
+        SUM(CASE WHEN g.outcome = 'abandoned'
+                  OR (g.outcome IS NULL AND g.status = 'abandoned')
+                 THEN 1 ELSE 0 END)                                AS outcome_abandoned,
+        SUM(CASE WHEN g.outcome = 'answered' THEN 1 ELSE 0 END)    AS outcome_answered,
+        SUM(CASE
+              WHEN g.outcome IN ('success','partial','failed','abandoned','answered') THEN 0
+              WHEN g.outcome IS NULL AND g.status = 'abandoned' THEN 0
+              ELSE 1
+            END)                                                   AS outcome_none,
+        AVG(CASE WHEN g.duration_sec > 0 THEN g.duration_sec END)  AS avg_duration_sec
+      FROM (
+        SELECT
+          t.id      AS id,
+          t.outcome AS outcome,
+          t.status  AS status,
+          (CASE
+            WHEN t.end_time IS NOT NULL THEN
+              CAST(strftime('%s', t.end_time) AS INTEGER) - CAST(strftime('%s', t.start_time) AS INTEGER)
+            ELSE
+              CAST(strftime('%s', 'now') AS INTEGER) - CAST(strftime('%s', t.start_time) AS INTEGER)
+          END)      AS duration_sec
+        FROM events e
+        -- perf (decision 2f05b0bf): CROSS JOIN pins events-first join order — see
+        -- queryAgentBoardPromptRows for the full rationale (90ms → <2ms; pure
+        -- join-order hint, aggregate result unchanged).
+        CROSS JOIN task_events te ON te.event_id = e.event_id
+        CROSS JOIN tasks t        ON t.id = te.task_id
+        CROSS JOIN sessions s     ON s.session_id = t.session_id
+        WHERE e.hook_type = 'UserPromptSubmit'
+          AND e.user_prompt IS NOT NULL
+          AND t.start_time >= ?
+          ${projectFilter}
+          ${kindFilter}
+        GROUP BY t.id
+      ) g
+    `;
+        const params = [since];
+        if (opts.projectPath)
+            params.push(opts.projectPath);
+        if (kindFilter)
+            params.push(...effectiveKinds);
+        const row = this.db.prepare(sql).get(...params);
+        return {
+            task_total: row?.task_total ?? 0,
+            outcome_success: row?.outcome_success ?? 0,
+            outcome_partial: row?.outcome_partial ?? 0,
+            outcome_failed: row?.outcome_failed ?? 0,
+            outcome_abandoned: row?.outcome_abandoned ?? 0,
+            outcome_answered: row?.outcome_answered ?? 0,
+            outcome_none: row?.outcome_none ?? 0,
+            avg_duration_sec: row?.avg_duration_sec != null ? Math.round(row.avg_duration_sec) : null,
         };
+    }
+    // ── Agent Board v3 — count companion (2026-05-26) ─────────────────────
+    //
+    // Why a separate method: queryAgentBoardTasks() applies a LIMIT (default 40,
+    // perf cap from 2026-05-25 — each card runs ~7 follow-up aggregations). The
+    // Web KPI "总任务数 (7d)" needs the UNBOUNDED count for the window, so we
+    // run the same WHERE clauses (start_time + project + noise filter) without
+    // the aggregates / LIMIT / ORDER BY. Cheap: tasks ⨯ sessions JOIN is index
+    // covered and the COUNT(*) returns one row.
+    //
+    // MUST stay in sync with the WHERE filter in queryAgentBoardTasks above.
+    // Tested by web-insights-agent-board.integration.test.ts (4 cases incl.
+    // noise filter + project filter + cap-vs-total invariant).
+    countAgentBoardTasks(opts) {
+        const nowMs = opts.now_ms ?? Date.now();
+        const sinceMs = nowMs - opts.windowDays * DAY_MS;
+        const since = new Date(sinceMs).toISOString();
+        const projectFilter = opts.projectPath ? 'AND s.project_path = ?' : '';
+        // spec b1480935: same resolution order as queryAgentBoardTasks so the
+        // count is always consistent with the row set.
+        const effectiveKinds = opts.includeKinds
+            ?? (opts.includeNoise ? ALL_TASK_KINDS : ['user']);
+        const kindFilter = effectiveKinds.length === ALL_TASK_KINDS.length
+            ? ''
+            : `AND t.task_kind IN (${effectiveKinds.map(() => '?').join(',')})`;
+        const sql = `
+      SELECT COUNT(*) AS n
+        FROM tasks t
+        JOIN sessions s ON s.session_id = t.session_id
+       WHERE t.start_time >= ?
+         ${projectFilter}
+         ${kindFilter}
+    `;
+        const params = [since];
+        if (opts.projectPath)
+            params.push(opts.projectPath);
+        if (kindFilter)
+            params.push(...effectiveKinds);
+        const row = this.db.prepare(sql).get(...params);
+        return row?.n ?? 0;
+    }
+    /**
+     * Count "trivial" tasks since `sinceIso` — driven by DaemonObserverBadge's
+     * `trivial_passed_7d` field (spec 1750 § B1-3).
+     *
+     * Definition: tasks the task-segmenter marked as `is_noise=1` AT INSERT TIME
+     * (single-char prompt / single-word slash command / envelope task title). This
+     * is the closest server-side proxy for "daemon never engaged" — the trivial
+     * filter in `task-segmenter.ts` runs at write time using the same heuristics
+     * that gate decision-hint emission. Frontend's `isTrivialPath()` uses a finer
+     * signal (all daemon-intervention sections empty) but we don't have that
+     * aggregated; this proxy is good enough for the weekly counter chip.
+     *
+     * `datetime()` wrap normalises ISO 'T' vs SQLite default ' ' separator
+     * (see DecisionsOperations.countDecisionsSince for the reasoning).
+     */
+    countTrivialTasksSince(sinceIso) {
+        const row = this.db
+            .prepare(`SELECT COUNT(*) AS n FROM tasks
+         WHERE datetime(start_time) >= datetime(?) AND is_noise = 1`)
+            .get(sinceIso);
+        return row?.n ?? 0;
+    }
+    /**
+     * Daily commit + task activity over a window (default 30 days).
+     *
+     * Used by `/api/insights/commit-activity` to drive the HealthHomePage
+     * 30d "Commit calendar" without the lane LIMIT undercount that the
+     * agent-board path suffered. Aggregates straight off the `tasks` table
+     * by `DATE(start_time)` so the result is unbounded by perf caps.
+     *
+     * The day buckets are filled with zeros for days with no tasks so the
+     * caller doesn't have to fill gaps client-side. Days ordered oldest→newest.
+     *
+     * Added 2026-05-26 — see docs/implementation changelog.
+     */
+    queryCommitActivityDaily(opts) {
+        const days = Math.min(Math.max(opts.days, 1), 365);
+        const nowMs = opts.now_ms ?? Date.now();
+        const sinceMs = nowMs - days * DAY_MS;
+        const since = new Date(sinceMs).toISOString();
+        const projectFilter = opts.projectPath ? 'AND s.project_path = ?' : '';
+        const sql = `
+      SELECT
+        DATE(t.start_time)                                     AS date,
+        COUNT(*)                                               AS total,
+        SUM(CASE WHEN t.outcome = 'success' THEN 1 ELSE 0 END) AS succeeded,
+        SUM(CASE WHEN t.outcome = 'failed'  THEN 1 ELSE 0 END) AS failed,
+        COALESCE(SUM(t.commit_count), 0)                       AS commits
+      FROM tasks t
+      JOIN sessions s ON s.session_id = t.session_id
+      WHERE t.start_time >= ?
+        ${projectFilter}
+      GROUP BY DATE(t.start_time)
+      ORDER BY DATE(t.start_time) ASC
+    `;
+        const params = [since];
+        if (opts.projectPath)
+            params.push(opts.projectPath);
+        const rows = this.db.prepare(sql).all(...params);
+        // Fill gaps so days with 0 activity still appear (matches CommitCalendarCard
+        // contract — it expects a contiguous day array indexed by date).
+        const byDate = new Map();
+        for (const r of rows) {
+            byDate.set(r.date, {
+                total: Number(r.total) || 0,
+                succeeded: Number(r.succeeded) || 0,
+                failed: Number(r.failed) || 0,
+                commits: Number(r.commits) || 0,
+            });
+        }
+        const out = [];
+        for (let i = days - 1; i >= 0; i--) {
+            const d = new Date(nowMs - i * DAY_MS).toISOString().slice(0, 10);
+            const v = byDate.get(d);
+            out.push({
+                date: d,
+                total: v?.total ?? 0,
+                succeeded: v?.succeeded ?? 0,
+                failed: v?.failed ?? 0,
+                commits: v?.commits ?? 0,
+            });
+        }
+        return out;
+    }
+    /**
+     * Task-tracking deep fix (spec 1551 §6.D): Dry-run query for backfill-orphans CLI.
+     *
+     * Returns stats about how many orphan events can be attached via the smart-window
+     * algorithm. No writes are performed.
+     */
+    queryOrphanStats() {
+        const row = this.db.prepare(`
+      WITH orphans AS (
+        SELECT e.event_id, e.session_id, e.timestamp AS ev_ts
+          FROM events e
+          LEFT JOIN task_events te ON te.event_id = e.event_id
+         WHERE te.event_id IS NULL
+      ),
+      attachable AS (
+        SELECT o.event_id, o.session_id, o.ev_ts,
+          (SELECT t.id FROM tasks t
+            WHERE t.session_id = o.session_id
+              AND t.status = 'completed'
+              AND t.end_time IS NOT NULL
+              AND t.end_time <= o.ev_ts
+              AND NOT EXISTS (
+                SELECT 1 FROM tasks t2
+                 WHERE t2.session_id = t.session_id
+                   AND t2.start_time > t.end_time
+                   AND t2.start_time <= o.ev_ts
+              )
+            ORDER BY t.end_time DESC LIMIT 1) AS task_id
+          FROM orphans o
+      )
+      SELECT
+        COUNT(*) AS total_orphans,
+        SUM(CASE WHEN task_id IS NOT NULL THEN 1 ELSE 0 END) AS attachable,
+        SUM(CASE WHEN task_id IS NULL THEN 1 ELSE 0 END) AS unattachable
+      FROM attachable
+    `).get();
+        const total = row?.total_orphans ?? 0;
+        const attachable = row?.attachable ?? 0;
+        const unattachable = row?.unattachable ?? 0;
+        const pct = total > 0 ? `${((attachable / total) * 100).toFixed(1)}%` : '0.0%';
+        return { total_orphans: total, attachable, unattachable, pct };
+    }
+    /**
+     * Task-tracking deep fix (spec 1551 §6.D): Sample orphan→task pairs for dry-run display.
+     *
+     * Returns up to `limit` (default 5) sample pairs showing which events would be attached.
+     */
+    sampleAttachablePairs(limit = 5) {
+        const rows = this.db.prepare(`
+      WITH orphans AS (
+        SELECT e.event_id, e.session_id, e.timestamp AS ev_ts
+          FROM events e
+          LEFT JOIN task_events te ON te.event_id = e.event_id
+         WHERE te.event_id IS NULL
+      ),
+      attachable AS (
+        SELECT o.event_id, o.session_id, o.ev_ts,
+          (SELECT t.id FROM tasks t
+            WHERE t.session_id = o.session_id
+              AND t.status = 'completed'
+              AND t.end_time IS NOT NULL
+              AND t.end_time <= o.ev_ts
+              AND NOT EXISTS (
+                SELECT 1 FROM tasks t2
+                 WHERE t2.session_id = t.session_id
+                   AND t2.start_time > t.end_time
+                   AND t2.start_time <= o.ev_ts
+              )
+            ORDER BY t.end_time DESC LIMIT 1) AS task_id
+          FROM orphans o
+      )
+      SELECT
+        a.event_id,
+        a.task_id,
+        t.title AS task_title,
+        CAST((julianday(a.ev_ts) - julianday(t.end_time)) * 1440 AS INTEGER) AS gap_min
+      FROM attachable a
+      JOIN tasks t ON t.id = a.task_id
+      WHERE a.task_id IS NOT NULL
+      LIMIT ?
+    `).all(limit);
+        return rows;
+    }
+    /**
+     * Task-tracking deep fix (spec 1551 §6.D.3): Apply backfill in a single atomic transaction.
+     *
+     * Inserts orphan→task links using INSERT OR IGNORE (idempotent).
+     * Then synchronizes event_count on updated tasks.
+     *
+     * Returns the number of rows inserted.
+     */
+    backfillOrphans() {
+        const insertStmt = this.db.prepare(`
+      INSERT OR IGNORE INTO task_events (task_id, event_id)
+      SELECT cand.task_id, cand.event_id
+        FROM (
+          SELECT o.event_id, o.session_id, o.ev_ts,
+            (SELECT t.id FROM tasks t
+              WHERE t.session_id = o.session_id
+                AND t.status = 'completed'
+                AND t.end_time IS NOT NULL
+                AND t.end_time <= o.ev_ts
+                AND NOT EXISTS (
+                  SELECT 1 FROM tasks t2
+                   WHERE t2.session_id = t.session_id
+                     AND t2.start_time > t.end_time
+                     AND t2.start_time <= o.ev_ts
+                )
+              ORDER BY t.end_time DESC LIMIT 1) AS task_id
+            FROM (
+              SELECT e.event_id, e.session_id, e.timestamp AS ev_ts
+                FROM events e
+                LEFT JOIN task_events te ON te.event_id = e.event_id
+               WHERE te.event_id IS NULL
+            ) o
+        ) cand
+       WHERE cand.task_id IS NOT NULL
+    `);
+        const updateCountStmt = this.db.prepare(`
+      UPDATE tasks
+         SET event_count = (SELECT COUNT(*) FROM task_events WHERE task_id = tasks.id)
+    `);
+        let inserted = 0;
+        this.db.transaction(() => {
+            const result = insertStmt.run();
+            inserted = result.changes;
+            updateCountStmt.run();
+        })();
+        return inserted;
+    }
+    // ── decision 265f59d5: LLM task-boundary re-attribution helpers ──────────
+    //
+    // Data-safety contract (spec Option A): re-attribution NEVER deletes events
+    // and NEVER mutates event content. The only write is moving a single prompt
+    // event's `task_events.task_id` foreign key onto a freshly-created task, and
+    // stamping `llm_classified_at` for idempotency.
+    /**
+     * The first `limit` user-prompt texts of a task, oldest-first. Feeds the
+     * classifier the "what was the previous task about" context. Reads only the
+     * plaintext `user_prompt` column (never gzip tool_input).
+     */
+    getTaskUserPrompts(taskId, limit = 3) {
+        const rows = this.db.prepare(`
+      SELECT e.user_prompt AS user_prompt
+        FROM task_events te
+        JOIN events e ON e.event_id = te.event_id
+       WHERE te.task_id = ?
+         AND e.hook_type = 'UserPromptSubmit'
+         AND e.user_prompt IS NOT NULL
+       ORDER BY e.timestamp ASC
+       LIMIT ?
+    `).all(taskId, limit);
+        return rows.map(r => r.user_prompt).filter((p) => !!p);
+    }
+    /** True once the async boundary classifier has stamped this task. */
+    isLlmClassified(taskId) {
+        const row = this.db.prepare(`SELECT llm_classified_at FROM tasks WHERE id = ? LIMIT 1`).get(taskId);
+        return !!row?.llm_classified_at;
+    }
+    /** Stamp the idempotency marker without re-attributing (CONTINUATION verdict). */
+    markLlmClassified(taskId, atIso) {
+        this.db.prepare(`UPDATE tasks SET llm_classified_at = ? WHERE id = ?`).run(atIso, taskId);
+    }
+    /**
+     * Re-attribute a single prompt event off `fromTaskId` onto a brand-new task,
+     * because the async classifier judged it NEW_TASK. Atomic + idempotent.
+     *
+     * Safety / idempotency guards (spec OQ #3 "re-check"):
+     *   1. `fromTaskId` must not already be llm_classified (double-write guard).
+     *   2. the event must STILL be linked to `fromTaskId` (no other path moved it
+     *      during the LLM delay window).
+     *   3. all writes run in ONE better-sqlite3 transaction.
+     *
+     * On success: creates the new task row, moves ONLY this event's
+     * task_events.task_id FK, decrements the old task's event_count / increments
+     * the new one, and stamps `llm_classified_at` on BOTH rows. Returns the new
+     * task id. On any guard failure returns null and writes nothing.
+     *
+     * Explicitly NOT done: deleting events, editing event content, closing or
+     * reactivating the source task (its lifecycle is owned by the segmenter /
+     * stop handler). OQ1 = "trust the LLM": no conservative event-count/time guard.
+     */
+    reattributePromptToNewTask(opts) {
+        const { fromTaskId, eventId, newTask, atIso } = opts;
+        const txn = this.db.transaction(() => {
+            // Guard 1: idempotency — already classified, do nothing.
+            const fromRow = this.db.prepare(`SELECT llm_classified_at FROM tasks WHERE id = ? LIMIT 1`).get(fromTaskId);
+            if (!fromRow)
+                return null;
+            if (fromRow.llm_classified_at)
+                return null;
+            // Guard 2: re-check the event still belongs to fromTaskId.
+            const link = this.db.prepare(`SELECT task_id FROM task_events WHERE event_id = ? LIMIT 1`).get(eventId);
+            if (!link || link.task_id !== fromTaskId) {
+                // Someone else moved it (or it was never linked). Still stamp the
+                // source so we never retry this prompt, but do not re-attribute.
+                this.db.prepare(`UPDATE tasks SET llm_classified_at = ? WHERE id = ?`).run(atIso, fromTaskId);
+                return null;
+            }
+            // Create the new task row (kind defaults to 'user').
+            this.db.prepare(`
+        INSERT INTO tasks (id, session_id, title, start_time, is_noise, task_kind, llm_classified_at)
+        VALUES (?, ?, ?, ?, 0, ?, ?)
+      `).run(newTask.id, newTask.session_id, newTask.title, newTask.start_time, newTask.task_kind ?? 'user', atIso);
+            // Move ONLY this event's FK. PK is (task_id, event_id), so UPDATE the row.
+            this.db.prepare(`UPDATE task_events SET task_id = ? WHERE event_id = ? AND task_id = ?`).run(newTask.id, eventId, fromTaskId);
+            // Keep event_count honest on both rows (best-effort; floor at 0).
+            this.db.prepare(`UPDATE tasks SET event_count = MAX(event_count - 1, 0) WHERE id = ?`).run(fromTaskId);
+            this.db.prepare(`UPDATE tasks SET event_count = event_count + 1 WHERE id = ?`).run(newTask.id);
+            // Stamp the source task so a replayed event never re-classifies it.
+            this.db.prepare(`UPDATE tasks SET llm_classified_at = ? WHERE id = ?`).run(atIso, fromTaskId);
+            return newTask.id;
+        });
+        try {
+            return txn();
+        }
+        catch (err) {
+            // Defensive: never crash the daemon's async classifier path.
+            // eslint-disable-next-line no-console
+            console.warn('[TaskOperations] reattributePromptToNewTask failed:', err);
+            return null;
+        }
+    }
+    /** Map a raw events row to ForgeEvent (parses JSON columns). */
+    rowToEvent(row) {
+        // tool_output flows through decodeToolOutput so this rowToEvent reads
+        // both legacy plain rows and new codec-encoded rows (gzip / tiny utf8).
+        // Wrapped in try/catch so a malformed payload returns undefined rather
+        // than crashing the whole row map. Matches EventOperations.rowToEvent.
+        let toolOutput = undefined;
+        try {
+            toolOutput = decodeToolOutput(row.tool_output);
+        }
+        catch {
+            toolOutput = undefined;
+        }
         return {
             event_id: row.event_id,
             session_id: row.session_id,
@@ -225,8 +1815,8 @@ export class TaskOperations {
             timestamp: row.timestamp,
             hook_type: row.hook_type,
             tool_name: row.tool_name || undefined,
-            tool_input: parseJson(row.tool_input),
-            tool_output: parseJson(row.tool_output),
+            tool_input: decodeToolInput(row.tool_input),
+            tool_output: toolOutput,
             user_prompt: row.user_prompt || undefined,
             ai_response: row.ai_response || undefined,
         };
@@ -254,10 +1844,18 @@ export class TaskOperations {
         }
         if (filter.search) {
             // M3/L2: 当前 LIKE '%search%' 全表扫描；行数 < 10w 时延迟可接受。
-            // TODO: 加 FTS5 索引（行数 > 10w 时上 FTS 才能避免线性扫描）。
+            // Note: 加 FTS5 索引（触发条件：tasks 表行数 > 10w 时 LIKE 线性扫描 > 100ms）。
             conditions.push('t.title LIKE ?');
             params.push(`%${filter.search}%`);
         }
+        // spec b1480935 (2026-06-01 Option A): task_kind whitelist. Always
+        // applied — when undefined the caller (route) defaults to ['user'] so
+        // /api/tasks stays clean by default. Pass all four kinds to disable.
+        if (filter.include_kinds && filter.include_kinds.length > 0) {
+            const placeholders = filter.include_kinds.map(() => '?').join(', ');
+            conditions.push(`t.task_kind IN (${placeholders})`);
+            params.push(...filter.include_kinds);
+        }
         return { conditions, params };
     }
     mapRow(r) {
@@ -272,7 +1870,83 @@ export class TaskOperations {
             event_count: r.event_count || 0,
             project_path: r.project_path || undefined,
             first_prompt: r.first_prompt !== undefined ? r.first_prompt : undefined,
+            // Outcome columns may be NULL (not yet classified) — pass through verbatim.
+            outcome: r.outcome ?? null,
+            outcome_reason: r.outcome_reason ?? null,
+            commit_count: r.commit_count == null ? null : r.commit_count,
+            reverted_commits: r.reverted_commits == null ? null : r.reverted_commits,
+            user_violation_count: r.user_violation_count == null ? null : r.user_violation_count,
+            classified_at: r.classified_at ?? null,
+            llm_classified_at: r.llm_classified_at ?? null,
+            is_noise: r.is_noise == null ? null : r.is_noise,
+            // spec b1480935: task_kind exposed verbatim. Legacy rows (column missing
+            // for some edge cases mid-migration) read as undefined → callers treat
+            // as 'user' via the TaskRecord default contract.
+            task_kind: r.task_kind ?? 'user',
+            // decision f47c2c90: self-FK passthrough (NULL on legacy / non-linked rows).
+            parent_task_id: r.parent_task_id ?? null,
         };
     }
+    // ── Outcome classifier (spec 1100 v2 — edit-intent signal) ────────
+    //
+    // The single signal powering the success-vs-answered verdict: did this task
+    // change code? Reads ONLY `tool_name` (never the gzip `tool_input`), so it is
+    // always correct. Sub-agent Edit/Write events are linked to the parent task's
+    // task_events, so "did this task (incl. its sub-agents) edit code?" is
+    // captured. The previous file→task commit-attribution map was deleted — it
+    // decoded gzip tool_input for file paths and silently failed, corrupting the
+    // verdict.
+    /**
+     * Count this task's Edit/Write intent events. Drives the `edit_intent_count`
+     * signal: a task with >0 edit-intent → `success`, one with 0 edit-intent is a
+     * pure Q&A / research task → `answered`.
+     *
+     * `tool_name` is NOT gzip-compressed (only `tool_input` is), so this is a
+     * pure SQL COUNT — no decode needed. We count PreToolUse so a single logical
+     * edit (Pre + Post) is counted once; multi-edit / notebook variants included.
+     */
+    countEditIntentEventsByTask(taskId) {
+        const row = this.db.prepare(`
+      SELECT COUNT(*) AS n
+        FROM task_events te
+        JOIN events e ON e.event_id = te.event_id
+       WHERE te.task_id = ?
+         AND e.hook_type = 'PreToolUse'
+         AND e.tool_name IN ('Edit', 'Write', 'MultiEdit', 'NotebookEdit')
+    `).get(taskId);
+        return row?.n ?? 0;
+    }
+    // ── P1: Idle unclassified tasks (e2e link fix 2026-05-25) ──────────
+    //
+    // TaskSegmenter marks tasks completed when a new prompt switches off the
+    // current task, but does NOT run outcome-classifier. Result: most
+    // `tasks.outcome` rows are NULL even after Stop. This helper lets the
+    // Stop handler sweep all completed/abandoned tasks on the session whose
+    // outcome hasn't been stamped yet.
+    //
+    // Includes both 'completed' and 'abandoned' statuses (never 'active' —
+    // the current task gets classified separately by stop.ts existing path).
+    //
+    // task_kind gate (fix 2026-06-17): only real user tasks get an outcome.
+    // Without this filter the idle sweep stamped outcome on agent-callback
+    // (`<task-notification>`), image, and system-envelope rows, e.g. a callback
+    // notification was wrongly labelled `success`/`answered` (128/133 rows
+    // polluted). Mirrors getActiveUserTask's predicate exactly so the idle sweep
+    // and the active-task path agree on what "a user task" is. The
+    // `task_kind IS NULL AND is_noise = 0` arm preserves legacy rows written
+    // before the task_kind backfill (spec b1480935).
+    queryIdleUnclassifiedTasks(sessionId) {
+        const rows = this.db.prepare(`
+      SELECT t.*, s.project_path
+      FROM tasks t
+      LEFT JOIN sessions s ON s.session_id = t.session_id
+      WHERE t.session_id = ?
+        AND t.outcome IS NULL
+        AND t.status IN ('completed', 'abandoned')
+        AND (t.task_kind = 'user' OR (t.task_kind IS NULL AND t.is_noise = 0))
+      ORDER BY t.start_time ASC
+    `).all(sessionId);
+        return rows.map(r => this.mapRow(r));
+    }
 }
 //# sourceMappingURL=tasks.js.map