@winspan/claude-forge 9.2.0 → 9.12.0

package/dist/core/storage/tasks.js

@@ -4,6 +4,7 @@
  * 拆分自 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;
@@ -27,9 +28,212 @@ export class TaskOperations {
         // 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, is_noise, task_kind)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `).run(task.id, task.session_id, task.title, task.start_time, task.is_noise ? 1 : 0, kind);
+      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 = [];
@@ -537,6 +741,52 @@ export class TaskOperations {
     `).all(taskId, nowMs);
         return rows;
     }
+    /**
+     * 该任务执行窗内 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 切分）。
@@ -572,7 +822,7 @@ export class TaskOperations {
         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 sinceMs = nowMs - opts.windowDays * DAY_MS;
         const since = new Date(sinceMs).toISOString();
         const nowIso = new Date(nowMs).toISOString();
         let projectFilter = '';
@@ -643,7 +893,8 @@ export class TaskOperations {
         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
+        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
@@ -867,6 +1118,95 @@ export class TaskOperations {
             : `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
@@ -889,10 +1229,14 @@ export class TaskOperations {
         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 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,
@@ -915,14 +1259,25 @@ export class TaskOperations {
             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
+      -- 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 ?
     `;
@@ -931,6 +1286,9 @@ export class TaskOperations {
             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 => ({
@@ -957,30 +1315,139 @@ export class TaskOperations {
      */
     countAgentBoardPromptRows(opts) {
         const nowMs = opts.now_ms ?? Date.now();
-        const sinceMs = nowMs - opts.windowDays * 86400_000;
+        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
-      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
+      -- 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,
@@ -995,7 +1462,7 @@ export class TaskOperations {
     // 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 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
@@ -1059,7 +1526,7 @@ export class TaskOperations {
     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 sinceMs = nowMs - days * DAY_MS;
         const since = new Date(sinceMs).toISOString();
         const projectFilter = opts.projectPath ? 'AND s.project_path = ?' : '';
         const sql = `
@@ -1093,7 +1560,7 @@ export class TaskOperations {
         }
         const out = [];
         for (let i = days - 1; i >= 0; i--) {
-            const d = new Date(nowMs - i * 86400_000).toISOString().slice(0, 10);
+            const d = new Date(nowMs - i * DAY_MS).toISOString().slice(0, 10);
             const v = byDate.get(d);
             out.push({
                 date: d,
@@ -1416,6 +1883,8 @@ export class TaskOperations {
             // 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) ────────
@@ -1457,6 +1926,15 @@ export class TaskOperations {
     //
     // 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
@@ -1465,6 +1943,7 @@ export class TaskOperations {
       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));