@winspan/claude-forge 8.54.3 → 9.2.0

package/dist/core/storage/tasks.js

@@ -3,15 +3,33 @@
  *
  * 拆分自 sqlite.ts。
  */
+import { decodeToolInput, decodeToolOutput } from './codec/tool-input-codec.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)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(task.id, task.session_id, task.title, task.start_time, task.is_noise ? 1 : 0, kind);
     }
     updateTask(taskId, updates) {
         const sets = [];
@@ -32,6 +50,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 +83,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 +233,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 +509,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 +537,810 @@ 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 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 * 86400_000;
+        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 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 };
+    }
+    // ── 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 * 86400_000;
+        const since = new Date(sinceMs).toISOString();
+        const projectFilter = opts.projectPath ? 'AND s.project_path = ?' : '';
+        const { effectiveKinds, kindFilter } = this.resolveKindFilter(opts);
+        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
+      JOIN task_events te ON te.event_id = e.event_id
+      JOIN tasks t        ON t.id = te.task_id
+      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}
+      ORDER BY e.timestamp DESC
+      LIMIT ? OFFSET ?
+    `;
+        const params = [since];
+        if (opts.projectPath)
+            params.push(opts.projectPath);
+        if (kindFilter)
+            params.push(...effectiveKinds);
+        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 * 86400_000;
+        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 n
+      FROM events e
+      JOIN task_events te ON te.event_id = e.event_id
+      JOIN tasks t        ON t.id = te.task_id
+      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}
+    `;
+        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;
+    }
+    // ── 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 * 86400_000;
+        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 * 86400_000;
+        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 * 86400_000).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 +1348,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 +1377,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 +1403,71 @@ 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',
         };
     }
+    // ── 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).
+    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')
+      ORDER BY t.start_time ASC
+    `).all(sessionId);
+        return rows.map(r => this.mapRow(r));
+    }
 }
 //# sourceMappingURL=tasks.js.map