@dijkspicy/opencode-stats-reporter 0.1.5 → 0.1.6

package/contrib/opencode-session-reporter/README.md

@@ -65,7 +65,7 @@ config.json 不存在、JSON 非法、字段缺失或 URL 非法时一律静默
 {
   "schema_version": 1,
   "install_id": "0b3f7e6a-....",
-  "reporter": { "client": "opencode", "version": "0.1.5" },
+  "reporter": { "client": "opencode", "version": "0.1.6" },
   "sessions": [
     {
       "session_id": "ses_...",

package/contrib/opencode-session-reporter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-session-reporter",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "private": true,
   "type": "module",
   "description": "opencode 客户端插件：在会话空闲时聚合各会话（含子代理会话）的 token 用量快照，经有界队列 + 指数退避非阻塞上报；载荷不含消费者身份字段。",

package/contrib/opencode-session-reporter/session-usage-reporter.ts

@@ -46,7 +46,7 @@ import { dirname, join } from "node:path"
 // ---------------------------------------------------------------------------
 
 const SCHEMA_VERSION = 1
-const PLUGIN_VERSION = "0.1.5"
+const PLUGIN_VERSION = "0.1.6"
 /** 队列容量：最多积压 500 条会话快照，溢出丢最旧 */
 const QUEUE_CAP = 500
 /** 单次上报请求超时（AbortSignal.timeout） */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dijkspicy/opencode-stats-reporter",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "本地一体化 MaaS 用量看板：托管静态面板、反代用量接口、本地存储会话用量",
   "type": "module",
   "main": "./contrib/opencode-session-reporter/plugin-server.ts",

package/panel/css/style.css

@@ -537,9 +537,9 @@ body {
   white-space: nowrap;
   vertical-align: bottom;
   font-weight: 600;
-  cursor: pointer;
 }
-.sess-title:hover { color: var(--accent-hover); text-decoration: underline; }
+.sess-title.is-link { cursor: pointer; }
+.sess-title.is-link:hover { color: var(--accent-hover); text-decoration: underline; }
 .sess-sub-line {
   display: flex;
   align-items: center;
@@ -562,7 +562,7 @@ body {
   .sess-dir { max-width: 120px; }
 }
 
-/* 任务分组：顶层会话行充当组头（徽标 + 组间留白），子会话缩进并以左侧竖线挂在任务下 */
+/* 任务行：箭头展开控件 + 「任务」徽标 + 会话数徽标；token 列为任务合计，模型/代理/消息数留 '--' */
 #session-table tr.sess-task > td { padding-top: 14px; }
 tr.sess-task .sess-title-line { display: flex; align-items: center; gap: 6px; }
 .sess-task-badge {
@@ -575,6 +575,61 @@ tr.sess-task .sess-title-line { display: flex; align-items: center; gap: 6px; }
   font-weight: 600;
   line-height: 16px;
 }
+.sess-count-chip {
+  flex: none;
+  padding: 0 7px;
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  background: var(--bg);
+  color: var(--text-secondary);
+  font-size: 10px;
+  line-height: 16px;
+  font-variant-numeric: tabular-nums;
+}
+
+/* 展开/收起箭头：独立点击区，与标题（进详情）互不误触；加载中转圈 */
+.sess-expand {
+  flex: none;
+  width: 18px;
+  height: 18px;
+  padding: 0;
+  border: none;
+  background: transparent;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+}
+.sess-expand:focus-visible { outline: 1px solid var(--accent); }
+.sess-expand .tri {
+  width: 0;
+  height: 0;
+  border-left: 5px solid var(--text-secondary);
+  border-top: 4px solid transparent;
+  border-bottom: 4px solid transparent;
+  transition: transform .15s;
+}
+.sess-expand:hover .tri { border-left-color: var(--accent); }
+.sess-expand .tri.is-open { transform: rotate(90deg); }
+.sess-expand .spin {
+  width: 10px;
+  height: 10px;
+  border: 2px solid var(--border);
+  border-top-color: var(--accent);
+  border-radius: 50%;
+  animation: sess-spin .8s linear infinite;
+}
+@keyframes sess-spin { to { transform: rotate(360deg); } }
+
+/* 任务展开区的加载 / 错误通栏行：与子会话行同缩进 */
+#session-table tr.sess-expand-state > td {
+  font-size: 12px;
+  color: var(--text-secondary);
+  padding-left: 30px;
+}
+#session-table tr.sess-expand-state > td .btn { margin-left: 10px; }
+#session-table tbody tr.sess-expand-state:hover { background: transparent; }
+
 #session-table tr.sess-child .sess-cell { position: relative; padding-left: 30px; }
 #session-table tr.sess-child .sess-cell::before {
   content: "";
@@ -586,10 +641,6 @@ tr.sess-task .sess-title-line { display: flex; align-items: center; gap: 6px; }
   background: var(--border);
 }
 
-/* 根会话不在已加载结果中时的合成组头：只声明归属，不虚构任务名 */
-tr.sess-orphan-head > td { font-size: 11px; color: var(--text-secondary); padding-top: 14px; }
-#session-table tbody tr.sess-orphan-head:hover { background: transparent; }
-
 /* 会话 ID：默认弱化（有标题时），等宽头尾截断，完整值在 title，点击进详情 */
 .sess-id-btn {
   display: inline-block;

package/panel/index.html

@@ -280,7 +280,7 @@
       <!-- 会话列表 -->
       <section id="card-session-list" class="card">
         <div class="table-head">
-          <h2 class="card-title">会话列表 <span class="src-badge" title="数据来自客户端上报，可能延迟或遗漏">客户端上报</span></h2>
+          <h2 class="card-title">任务列表 <span class="src-badge" title="数据来自客户端上报，可能延迟或遗漏">客户端上报</span></h2>
           <div class="sess-filter">
             <label class="sess-filter-item">模型
               <select id="sess-filter-model" aria-label="按模型筛选">
@@ -296,16 +296,16 @@
           <table id="session-table" class="session-table">
             <thead>
               <tr>
-                <th title="同一顶层任务的会话归为一组：顶层会话标「任务」，子会话缩进挂在其下；组按最近活动排序，根会话不在当前结果时以灰字注明">会话</th>
-                <th>模型</th>
-                <th>代理</th>
-                <th class="num" title="输入总量 = 输入 + 缓存读 + 缓存写">输入总量</th>
-                <th class="num" title="输出总量 = 输出 + 推理">输出总量</th>
-                <th class="num">推理</th>
-                <th class="num">缓存读</th>
-                <th class="num">缓存写</th>
-                <th class="num">消息数</th>
-                <th>最后活动</th>
+                <th title="每行一个顶层任务（token 为任务合计）；点箭头展开/收起子会话，点标题查看根会话详情">任务</th>
+                <th title="会话级属性；任务行不显示，展开子会话查看">模型</th>
+                <th title="会话级属性；任务行不显示，展开子会话查看">代理</th>
+                <th class="num" title="输入总量 = 输入 + 缓存读 + 缓存写；任务行 = 该任务全部会话合计">输入总量</th>
+                <th class="num" title="输出总量 = 输出 + 推理；任务行 = 该任务全部会话合计">输出总量</th>
+                <th class="num" title="任务行 = 该任务全部会话合计">推理</th>
+                <th class="num" title="任务行 = 该任务全部会话合计">缓存读</th>
+                <th class="num" title="任务行 = 该任务全部会话合计">缓存写</th>
+                <th class="num" title="会话级属性；任务行不聚合消息数">消息数</th>
+                <th title="任务行 = 该任务最近一次会话活动">最后活动</th>
               </tr>
             </thead>
             <tbody id="session-tbody"></tbody>

package/panel/js/api.js

@@ -89,7 +89,9 @@
   }
 
   // ---- 会话用量接口（自建会话服务，经同一网关地址访问；数据为客户端上报口径，非网关权威） ----
-  /** 会话列表：window / model / agent / install_id / limit / cursor（游标分页） */
+  /** 任务聚合：/v1/tasks，按顶层会话聚合的 token 合计 + 会话数（服务端口径），window/model/agent/limit/cursor */
+  function tasks(cfg, params) { return get(cfg, '/v1/tasks', params || {}); }
+  /** 会话列表：window / model / agent / root_session_id / install_id / limit / cursor（游标分页） */
   function sessions(cfg, params) { return get(cfg, '/v1/sessions', params || {}); }
   /** 单会话详情：不存在或不属于当前消费者时返回 404 */
   function sessionDetail(cfg, id) { return get(cfg, '/v1/sessions/' + encodeURIComponent(id)); }
@@ -144,6 +146,7 @@
     byModel: byModel,
     byProvider: byProvider,
     performance: performance,
+    tasks: tasks,
     sessions: sessions,
     sessionDetail: sessionDetail,
     sessionsSummary: sessionsSummary,

package/panel/js/sessions.js

@@ -1,8 +1,10 @@
 /**
- * 会话视图：客户端上报的会话级 token 用量
- * 数据源：/v1/sessions*（客户端上报，可能延迟/遗漏，非网关权威数据）
+ * 会话视图：以顶层任务为主维度的 token 用量
+ * 数据源：/v1/tasks（任务级聚合，含 token 合计与会话数）+ /v1/sessions?root_session_id=（展开时按需拉取子会话）
+ *         均为客户端上报口径，可能延迟/遗漏，非网关权威数据
  * token 口径（已实测验证）：输入总量 = 输入 + 缓存读 + 缓存写；输出总量 = 输出 + 推理（推理单列，不并入输出）
- * 结构：来源声明 → 用量对账（网关权威总量 − 会话上报合计 = 未归属用量）→ 会话列表（按顶层任务分组 + 窗口/模型/代理筛选 + 游标分页）→ 会话详情
+ *   任务行直接展示服务端 tokens_input_total / tokens_output_total（与子会话行同口径），客户端不做页内相加
+ * 结构：来源声明 → 用量对账（网关权威总量 − 会话上报合计 = 未归属用量）→ 任务列表（子会话默认收起、点击展开 + 窗口/模型/代理筛选 + 游标分页）→ 会话详情
  * 由 app.js 初始化：BRU.sessions.init({ getCfg, getPeriod, getModelCatalog, onUnauthorized })，并经 BRU.sessions.load() 触发拉取
  */
 (function () {
@@ -20,11 +22,13 @@
   var st = {
     seq: 0,               // 请求代次：响应到达时核对，过期响应（切窗/切筛选后）直接丢弃
     period: 'today',
-    rows: [],             // 已加载会话（分页累积）
-    nextCursor: null,     // 下一页游标（null = 没有更多）
+    tasks: [],            // 已加载任务（/v1/tasks 分页累积，服务端按任务级 last_activity_at 倒序）
+    taskCursor: null,     // 下一页游标（null = 没有更多）
+    expanded: {},         // root_session_id -> { status: 'loading'|'open'|'closed'|'error', rows: []|null, error, pending }
+                          // 子会话拉取后缓存于 rows：重复展开不再请求；切窗/切筛选（load）时整体重置
     filters: { model: '', agent: '' },
-    modelSet: {},         // 模型筛选项（模型目录 + 已见会话模型）
-    agentSet: {},         // 代理筛选项（已见会话代理）
+    modelSet: {},         // 模型筛选项（模型目录 + 已展开子会话模型）
+    agentSet: {},         // 代理筛选项（已展开子会话代理）
     selectedId: null      // 当前打开详情的会话 ID
   };
 
@@ -77,7 +81,7 @@
   }
 
   // ---------- 加载编排 ----------
-  /** 整页加载：列表重置到第一页 + 对账聚合；seq 保证切窗/切筛选后的旧响应不回写 */
+  /** 整页加载：任务列表重置到第一页 + 对账聚合；seq 保证切窗/切筛选后的旧响应不回写；展开态与子会话缓存一并重置 */
   function load() {
     var cfg = deps && deps.getCfg();
     if (!cfg) return Promise.resolve();
@@ -85,34 +89,34 @@
     st.period = deps.getPeriod();
     setCardState(el.coverageCard, 'loading');
     setCardState(el.listCard, 'loading');
-    st.rows = [];
-    st.nextCursor = null;
+    st.tasks = [];
+    st.taskCursor = null;
+    st.expanded = {};
     el.tbody.innerHTML = '';
     el.count.textContent = '';
     hide(el.btnMore);
     closeDetail();
     var w = st.period;
     return Promise.all([
-      fetchPage(cfg, w, null, true, seq),
+      fetchTasks(cfg, w, null, true, seq),
       fetchCoverage(cfg, w, seq)
     ]);
   }
 
-  /** 拉取一页会话：isReset=true 首页（覆盖），false 追加（加载更多）；失败走卡片错误层 + 重试 */
-  function fetchPage(cfg, window_, cursor, isReset, seq) {
+  /** 拉取一页任务：isReset=true 首页（覆盖），false 追加（加载更多）；失败走卡片错误层 + 重试 */
+  function fetchTasks(cfg, window_, cursor, isReset, seq) {
     var params = { window: window_, limit: PAGE_SIZE };
     if (st.filters.model) params.model = st.filters.model;
     if (st.filters.agent) params.agent = st.filters.agent;
     if (cursor) params.cursor = cursor;
-    return API.sessions(cfg, params).then(function (res) {
+    return API.tasks(cfg, params).then(function (res) {
       if (seq !== st.seq) return;
       var rows = (res && res.data) || [];
-      st.rows = isReset ? rows : st.rows.concat(rows);
-      st.nextCursor = (res && res.next_cursor) || null;
-      absorbOptions(rows);
-      renderRows();
-      el.count.textContent = '已加载 ' + st.rows.length + ' 个会话' + (st.nextCursor ? '（还有更多）' : '');
-      if (st.nextCursor) show(el.btnMore); else hide(el.btnMore);
+      st.tasks = isReset ? rows : st.tasks.concat(rows);
+      st.taskCursor = (res && res.next_cursor) || null;
+      renderTasks();
+      el.count.textContent = '已加载 ' + st.tasks.length + ' 个任务' + (st.taskCursor ? '（还有更多）' : '');
+      if (st.taskCursor) show(el.btnMore); else hide(el.btnMore);
       if (isReset && !rows.length) {
         setCardState(el.listCard, 'empty', null, null,
           (st.filters.model || st.filters.agent) ? '当前筛选条件下暂无会话上报' : null);
@@ -124,7 +128,7 @@
       if (seq !== st.seq) return;
       if (err && err.code === 'unauthorized') { deps.onUnauthorized(UNAUTH_MSG); return; }
       setCardState(el.listCard, 'error', (err && err.message) || '加载失败', function () {
-        fetchPage(deps.getCfg(), deps.getPeriod(), cursor, isReset, st.seq);
+        fetchTasks(deps.getCfg(), deps.getPeriod(), cursor, isReset, st.seq);
       });
     });
   }
@@ -189,60 +193,191 @@
     el.covNote.textContent = note;
   }
 
-  // ---------- 会话列表 ----------
+  // ---------- 任务列表 ----------
   /**
-   * 按顶层任务组织页内呈现（不改变拉取与游标逻辑，服务端排序保持 last_activity_at 倒序）：
-   * - root_session_id 为空或等于自身 → 独立任务行（契约：顶层会话 root 等于自身；旧数据为 null 时同样按顶层处理）
-   * - 子会话按 root_session_id 归组；根已加载则根行充当组头，根不在已加载行中则落合成组头（orphanHeadRow）
-   * - 组间按组内最近活动倒序；组内根在前，子会话保持服务端返回顺序（即最近活动倒序）
+   * 默认只渲染任务行（/v1/tasks，服务端已按任务级 last_activity_at 倒序，客户端不再重排）。
+   * 子会话默认收起：展开态的任务行下方按需插入「加载中 / 错误可重试 / 子会话行」。
+   * root_session_id 为空的任务（旧数据无血缘）按单会话任务降级：无展开控件、标题缺失时降级 '--'。
    */
-  function renderRows() {
+  function renderTasks() {
     var tbody = el.tbody;
     tbody.innerHTML = '';
-    buildGroups(st.rows).forEach(function (g) {
-      if (g.rootRow) tbody.appendChild(sessionRow(g.rootRow, 'task'));
-      else tbody.appendChild(orphanHeadRow(g.key));
-      g.children.forEach(function (r) { tbody.appendChild(sessionRow(r, 'child')); });
+    st.tasks.forEach(function (t) {
+      var rootId = nonEmpty(t.root_session_id);
+      tbody.appendChild(taskRow(t, rootId));
+      var s = rootId ? st.expanded[rootId] : null;
+      if (!s) return;
+      if (s.status === 'loading') tbody.appendChild(stateRow('正在加载子会话…'));
+      else if (s.status === 'error') tbody.appendChild(stateRow('子会话加载失败：' + (s.error || '加载失败'), rootId));
+      else if (s.status === 'open') (s.rows || []).forEach(function (r) { tbody.appendChild(sessionRow(r)); });
     });
   }
 
-  function buildGroups(rows) {
-    var map = {};
-    var list = [];
-    function group(key, idx) {
-      if (!map[key]) { map[key] = { key: key, rootRow: null, children: [], newest: -Infinity, idx: idx }; list.push(map[key]); }
-      return map[key];
-    }
-    rows.forEach(function (r, i) {
-      var sid = nonEmpty(r.session_id);
-      var rootId = nonEmpty(r.root_session_id);
-      var isTop = !sid || !rootId || rootId === sid;
-      var g = group(isTop ? (sid || '\u0000' + i) : rootId, i);
-      if (isTop) g.rootRow = r;
-      else g.children.push(r);
-      var act = Number(r.last_activity_at);
-      if (isFinite(act) && act > g.newest) g.newest = act;
+  /** 展开/收起：已拉取的子会话缓存复用（重复展开不再请求）；加载中点击 = 收起并丢弃未返回的结果 */
+  function toggleTask(rootId) {
+    var s = st.expanded[rootId];
+    if (s && s.status === 'open') { s.status = 'closed'; renderTasks(); return; }
+    if (s && s.status === 'loading') { s.pending = false; s.status = 'closed'; renderTasks(); return; }
+    if (s && s.rows) { s.status = 'open'; renderTasks(); return; }   // 收起后再展开：用缓存
+    st.expanded[rootId] = { status: 'loading', rows: null, pending: true };
+    renderTasks();
+    fetchChildren(rootId);
+  }
+
+  /** 拉取单个任务的全部会话（根自身 + 全部子会话，limit=200 上限）；pending 防止已收起后迟到响应回写 */
+  function fetchChildren(rootId) {
+    var cfg = deps.getCfg();
+    if (!cfg) return;
+    var seq = st.seq;
+    API.sessions(cfg, { root_session_id: rootId, limit: 200 }).then(function (res) {
+      if (seq !== st.seq) return;
+      var s = st.expanded[rootId];
+      if (!s || !s.pending) return;
+      s.rows = (res && res.data) || [];
+      s.status = 'open';
+      s.pending = false;
+      absorbOptions(s.rows);   // 子会话的模型/代理补进筛选项
+      renderTasks();
+    }, function (err) {
+      if (seq !== st.seq) return;
+      var s = st.expanded[rootId];
+      if (!s || !s.pending) return;
+      s.pending = false;
+      if (err && err.code === 'unauthorized') { deps.onUnauthorized(UNAUTH_MSG); return; }
+      s.status = 'error';
+      s.error = (err && err.message) || '加载失败';
+      renderTasks();
     });
-    list.sort(function (a, b) { return b.newest - a.newest || a.idx - b.idx; });
-    return list;
   }
 
-  /** 根会话不在已加载行中（分页未到 / 窗口或筛选未含根 / 旧数据）时的合成组头：只声明归属，不虚构任务名 */
-  function orphanHeadRow(rootId) {
+  /** 展开控件：箭头按钮，独立于标题的点击区；状态（开/合/加载中）每次渲染时按 st 重建 */
+  function expandButton(rootId) {
+    var b = document.createElement('button');
+    b.type = 'button';
+    b.className = 'sess-expand';
+    var tri = document.createElement('span');
+    var s = st.expanded[rootId];
+    if (s && s.status === 'open') { tri.className = 'tri is-open'; b.title = '收起子会话'; b.setAttribute('aria-label', '收起子会话'); }
+    else if (s && s.status === 'loading') { tri.className = 'spin'; b.title = '正在加载子会话'; b.setAttribute('aria-label', '正在加载子会话'); }
+    else { tri.className = 'tri'; b.title = '展开子会话'; b.setAttribute('aria-label', '展开子会话'); }
+    b.appendChild(tri);
+    b.addEventListener('click', function () { toggleTask(rootId); });
+    return b;
+  }
+
+  /** 任务行展开区的状态行：colspan 通栏；error 态带重试按钮 */
+  function stateRow(text, errorRootId) {
     var tr = document.createElement('tr');
-    tr.className = 'sess-orphan-head';
+    tr.className = 'sess-expand-state';
     var c = document.createElement('td');
     c.colSpan = 10;
-    c.textContent = '所属顶层会话不在当前列表 · ';
-    var id = document.createElement('span');
-    id.className = 'mono';
-    id.textContent = shortId(rootId);
-    id.title = rootId + '\n根会话 ID（未在当前结果中）';
-    c.appendChild(id);
+    c.textContent = text;
+    if (errorRootId) {
+      var btn = document.createElement('button');
+      btn.className = 'btn btn-sm';
+      btn.textContent = '重试';
+      btn.addEventListener('click', function () {
+        st.expanded[errorRootId] = { status: 'loading', rows: null, pending: true };
+        renderTasks();
+        fetchChildren(errorRootId);
+      });
+      c.appendChild(btn);
+    }
     tr.appendChild(c);
     return tr;
   }
 
+  /**
+   * 任务行：与子会话行共用同一套列（token 各列同口径），仅「模型 / 代理 / 消息数」为会话级属性，
+   * 任务行显示 '--' 并在悬浮说明，不用某个子会话的值冒充任务值。
+   * token 合计取服务端 tokens_input_total / tokens_output_total（契约与客户端派生公式一致），缺失时才退回客户端派生。
+   */
+  function taskRow(t, rootId) {
+    var tr = document.createElement('tr');
+    tr.className = 'sess-task';
+    var rawTitle = nonEmpty(t.session_title);
+    var dir = nonEmpty(t.session_directory);
+
+    var cell = document.createElement('td');
+    cell.className = 'sess-cell';
+
+    var line1 = document.createElement('div');
+    line1.className = 'sess-title-line';
+    var cnt = Number(t.session_count);
+    var hasCount = isFinite(cnt) && cnt > 0;
+    // 单会话任务（session_count<=1）没有可展开的子会话，不提供展开控件，避免展开后空组
+    var expandable = rootId && (!hasCount || cnt > 1);
+    if (expandable) line1.appendChild(expandButton(rootId));
+
+    var badge = document.createElement('span');
+    badge.className = 'sess-task-badge';
+    badge.textContent = '任务';
+    line1.appendChild(badge);
+
+    var titleEl = document.createElement('span');
+    titleEl.className = 'sess-title' + (rootId ? ' is-link' : '');
+    titleEl.textContent = rawTitle || (rootId ? shortId(rootId) : '--');
+    if (rootId) {
+      titleEl.title = (rawTitle || rootId) + '\n点击查看根会话详情';
+      titleEl.addEventListener('click', function () { openDetail(rootId); });
+    } else if (rawTitle) {
+      titleEl.title = rawTitle;
+    }
+    line1.appendChild(titleEl);
+
+    if (hasCount) {
+      var chip = document.createElement('span');
+      chip.className = 'sess-count-chip';
+      chip.textContent = F.fullNumber(cnt) + ' 个会话';
+      chip.title = '该任务共 ' + F.fullNumber(cnt) + ' 个会话（含顶层会话与子会话）';
+      line1.appendChild(chip);
+    }
+    cell.appendChild(line1);
+
+    var line2 = document.createElement('div');
+    line2.className = 'sess-sub-line';
+    if (dir) {
+      var d = document.createElement('span');
+      d.className = 'sess-dir mono';
+      d.textContent = shortDir(dir);
+      d.title = '目录：' + dir;
+      line2.appendChild(d);
+    }
+    if (rootId) {
+      if (dir) {
+        var sep = document.createElement('span');
+        sep.className = 'sess-sub-sep';
+        sep.textContent = '·';
+        line2.appendChild(sep);
+      }
+      line2.appendChild(idButton(rootId, !rawTitle));
+    }
+    if (line2.childNodes.length) cell.appendChild(line2);
+
+    tr.appendChild(cell);
+
+    tr.appendChild(td('--', null, '任务行不显示会话级模型，展开查看各子会话'));
+    tr.appendChild(td('--', null, '任务行不显示会话级代理，展开查看各子会话'));
+    tr.appendChild(td(F.fullNumber(taskTotal(t, 'tokens_input_total', inputTotal)), 'num', '输入总量 = 输入 + 缓存读 + 缓存写'));
+    tr.appendChild(td(F.fullNumber(taskTotal(t, 'tokens_output_total', outputTotal)), 'num', '输出总量 = 输出 + 推理'));
+    tr.appendChild(td(F.fullNumber(t.tokens_reasoning), 'num'));
+    tr.appendChild(td(F.fullNumber(t.tokens_cache_read), 'num'));
+    tr.appendChild(td(F.fullNumber(t.tokens_cache_write), 'num'));
+    tr.appendChild(td('--', null, '任务级不聚合消息数，展开查看各子会话'));
+    var lastFull = F.dateTime(t.last_activity_at);
+    var firstFull = F.dateTime(t.first_activity_at);
+    var tip = lastFull === '--' ? '' : '最后活动：' + lastFull;
+    if (tip && firstFull !== '--') tip += '\n首次活动：' + firstFull;
+    tr.appendChild(td(F.shortDateTime(t.last_activity_at), null, tip));
+    return tr;
+  }
+
+  /** 任务级合计：优先服务端聚合字段，缺失时退回与子会话行相同的客户端派生口径 */
+  function taskTotal(t, serverField, derive) {
+    var v = t[serverField];
+    return (typeof v === 'number' && isFinite(v)) ? v : derive(t);
+  }
+
   /** 空值守卫：非字符串或空白串返回 null，避免把 null/undefined/空串渲染到页面 */
   function nonEmpty(v) {
     return (typeof v === 'string' && v.trim()) ? v.trim() : null;
@@ -283,15 +418,14 @@
   }
 
   /**
-   * 首列「会话」：两行结构
+   * 子会话行（任务展开后插入）：两行结构
    *   主行：会话标题（加粗）；无标题时降级为会话 ID（等宽、高亮、可点）
    *   次行：项目目录（末两级压缩，悬浮显全路径）· 会话 ID（弱化；ID 已作主标识时不重复）
-   * role：task = 顶层任务行（带「任务」徽标，作为组头）；child = 子会话（CSS 缩进 + 挂线）；其余 = 独立行
+   * token 各列与任务行同列同口径（会话级分量）。
    */
-  function sessionRow(r, role) {
+  function sessionRow(r) {
     var tr = document.createElement('tr');
-    if (role === 'task') tr.className = 'sess-task';
-    else if (role === 'child') tr.className = 'sess-child';
+    tr.className = 'sess-child';
     var title = nonEmpty(r.session_title);
     var dir = nonEmpty(r.session_directory);
     var sid = nonEmpty(r.session_id) || '--';
@@ -301,15 +435,9 @@
 
     var line1 = document.createElement('div');
     line1.className = 'sess-title-line';
-    if (role === 'task') {
-      var badge = document.createElement('span');
-      badge.className = 'sess-task-badge';
-      badge.textContent = '任务';
-      line1.appendChild(badge);
-    }
     if (title) {
       var t = document.createElement('span');
-      t.className = 'sess-title';
+      t.className = 'sess-title is-link';
       t.textContent = displayTitle(title, nonEmpty(r.agent));
       t.title = title + '\n点击查看详情';
       t.addEventListener('click', function () { openDetail(sid); });
@@ -518,11 +646,11 @@
     };
 
     el.btnMore.addEventListener('click', function () {
-      if (!st.nextCursor) return;
+      if (!st.taskCursor) return;
       el.btnMore.disabled = true;
       el.btnMore.textContent = '加载中…';
-      // fetchPage 内部消化错误，此处仅恢复按钮状态
-      fetchPage(deps.getCfg(), deps.getPeriod(), st.nextCursor, false, st.seq)
+      // fetchTasks 内部消化错误，此处仅恢复按钮状态
+      fetchTasks(deps.getCfg(), deps.getPeriod(), st.taskCursor, false, st.seq)
         .then(function () {
           el.btnMore.disabled = false;
           el.btnMore.textContent = '加载更多';

package/src/server.js

@@ -1,7 +1,7 @@
 import http from "node:http"
 import fs from "node:fs"
 import path from "node:path"
-import { ApiError, report, listSessions, sessionDetail, sessionsSummary } from "./session-api.js"
+import { ApiError, report, listSessions, sessionDetail, sessionsSummary, listTasks } from "./session-api.js"
 import { createProxy } from "./proxy.js"
 import { createIdentityResolver } from "./identity.js"
 
@@ -102,7 +102,11 @@ export function createServer({ config, store, panelDir, mode = "local", consumer
       }
 
       // 会话类 → 本地存储；托管模式需网关注入身份，本地模式归入单一本地用户
-      const isSessionRoute = p === "/v1/session-usage/report" || p === "/v1/sessions" || p.startsWith("/v1/sessions/")
+      const isSessionRoute =
+        p === "/v1/session-usage/report" ||
+        p === "/v1/sessions" ||
+        p === "/v1/tasks" ||
+        p.startsWith("/v1/sessions/")
       if (isSessionRoute) {
         const consumer = resolveConsumer(req)
         if (!consumer) {
@@ -132,6 +136,11 @@ export function createServer({ config, store, panelDir, mode = "local", consumer
           sendJson(res, 200, sessionsSummary(store, consumer, url.searchParams))
           return
         }
+        // /v1/tasks 必须先于任何 :id 形式的捕获
+        if (p === "/v1/tasks" && req.method === "GET") {
+          sendJson(res, 200, listTasks(store, consumer, url.searchParams))
+          return
+        }
         if (p.startsWith("/v1/sessions/") && req.method === "GET") {
           const id = decodeURIComponent(p.slice("/v1/sessions/".length))
           if (!id || id.includes("/")) {

package/src/session-api.js

@@ -80,6 +80,22 @@ export function listSessions(store, consumer, params) {
   return { object: "list", window: window || null, as_of: iso(), data, next_cursor: nextCursor ? encodeCursor(nextCursor) : null }
 }
 
+/** GET /v1/tasks —— 顶层任务聚合（分组键 COALESCE(root_session_id, session_id)） */
+export function listTasks(store, consumer, params) {
+  const window = params.get("window") || undefined
+  if (window && !WINDOWS.includes(window)) throw new ApiError(400, "window 必须是: today, week, month", "invalid_window")
+  const limit = boundedInt(params.get("limit"), "limit", 50, 1, 200)
+  const cursorRaw = params.get("cursor")
+  const { data, nextCursor } = store.listTasks(consumer, {
+    window,
+    model: params.get("model") || undefined,
+    agent: params.get("agent") || undefined,
+    limit,
+    cursor: cursorRaw ? decodeCursor(cursorRaw) : null,
+  })
+  return { object: "list", window: window || null, as_of: iso(), data, next_cursor: nextCursor ? encodeCursor(nextCursor) : null }
+}
+
 /** GET /v1/sessions/{id} */
 export function sessionDetail(store, consumer, sessionId, params) {
   const row = store.getSession(consumer, sessionId, params.get("install_id") || undefined)

package/src/store.js

@@ -246,9 +246,14 @@ export class Store {
       args.push(installId)
     }
     if (rootSessionId) {
-      // 按顶层任务筛选：同一 root 下的全部会话（含根自身）
-      where.push("root_session_id=?")
-      args.push(rootSessionId)
+      // 顶层任务标识的定义 = COALESCE(root_session_id, session_id)（与 listTasks 的分组表达式严格一致）。
+      // 这里写成语义等价的 OR 展开：root 非空 → root_session_id = X；root 为 NULL（旧数据/孤儿）→
+      // 回退到 session_id = X。若直接写 COALESCE(...) = ? 则该谓词不可走索引；OR 展开后
+      // 第二个分支可用 idx_su_consumer_session(consumer_id, session_id)，第一个分支
+      // （root_session_id = X）无专用索引，但 consumer_id 前置条件仍可借
+      // idx_su_consumer_activity 收敛范围——当前单机个人数据量（千级行）下成本可忽略。
+      where.push("(root_session_id=? OR (root_session_id IS NULL AND session_id=?))")
+      args.push(rootSessionId, rootSessionId)
     }
     if (cursor) {
       where.push("(last_activity_at < ? OR (last_activity_at = ? AND session_id < ?))")
@@ -262,6 +267,80 @@ export class Store {
     return { data, nextCursor }
   }
 
+  /**
+   * 顶层任务聚合：按 COALESCE(root_session_id, session_id) 分组（无血缘的行各自成任务）。
+   *
+   * 语义选择：window / model / agent 过滤施加在「会话行」上（先过滤、后聚合）——
+   * 任务内只计入匹配的会话行，任务级 last_activity_at 为组内匹配行的 MAX。
+   *
+   * 根会话元数据（title/directory）用「相关子查询 + LIMIT 1」取标量：同一 consumer 下同一
+   * session_id 可能来自多个 install_id，JOIN 会造成行数膨胀；标量子查询每组恰好贡献一个值。
+   * 子查询额外要求 r.root_session_id = 根 id（即该行确实是根行），孤儿组（无血缘/根行缺失）
+   * 因此得到 null，与契约一致。
+   *
+   * 游标 [last_activity_at, root_session_id] 作用在聚合结果之后（外层 WHERE），排序键为
+   * 任务级 MAX(last_activity_at) DESC, root_session_id DESC。
+   */
+  listTasks(consumerId, { window, model, agent, limit = 50, cursor = null } = {}) {
+    const where = ["consumer_id=?"]
+    const args = [consumerId]
+    const start = windowStartMs(window)
+    if (start !== null) {
+      where.push("last_activity_at>=?")
+      args.push(start)
+    }
+    if (model) {
+      where.push("model=?")
+      args.push(model)
+    }
+    if (agent) {
+      where.push("agent=?")
+      args.push(agent)
+    }
+    const cursorWhere = []
+    const cursorArgs = []
+    if (cursor) {
+      cursorWhere.push("(t.last_activity_at < ? OR (t.last_activity_at = ? AND t.root_session_id < ?))")
+      cursorArgs.push(cursor[0], cursor[0], cursor[1])
+    }
+    const sql = `SELECT
+      t.root_session_id,
+      (SELECT r.session_title FROM session_usage r
+        WHERE r.consumer_id = t.consumer_id AND r.session_id = t.root_session_id AND r.root_session_id = t.root_session_id
+        ORDER BY r.last_reported_at DESC LIMIT 1) AS session_title,
+      (SELECT r.session_directory FROM session_usage r
+        WHERE r.consumer_id = t.consumer_id AND r.session_id = t.root_session_id AND r.root_session_id = t.root_session_id
+        ORDER BY r.last_reported_at DESC LIMIT 1) AS session_directory,
+      t.session_count, t.tokens_input, t.tokens_output, t.tokens_reasoning,
+      t.tokens_cache_read, t.tokens_cache_write,
+      t.first_activity_at, t.last_activity_at
+    FROM (
+      SELECT consumer_id,
+        COALESCE(root_session_id, session_id) AS root_session_id,
+        COUNT(*) AS session_count,
+        SUM(tokens_input) AS tokens_input,
+        SUM(tokens_output) AS tokens_output,
+        SUM(tokens_reasoning) AS tokens_reasoning,
+        SUM(tokens_cache_read) AS tokens_cache_read,
+        SUM(tokens_cache_write) AS tokens_cache_write,
+        MIN(last_activity_at) AS first_activity_at,
+        MAX(last_activity_at) AS last_activity_at
+      FROM session_usage
+      WHERE ${where.join(" AND ")}
+      GROUP BY consumer_id, COALESCE(root_session_id, session_id)
+    ) AS t
+    ${cursorWhere.length ? "WHERE " + cursorWhere.join(" AND ") : ""}
+    ORDER BY t.last_activity_at DESC, t.root_session_id DESC
+    LIMIT ?`
+    const rows = this.db.prepare(sql).all(...args, ...cursorArgs, limit + 1)
+    const hasNext = rows.length > limit
+    const data = rows.slice(0, limit).map(withDerived)
+    const nextCursor = hasNext && data.length
+      ? [data[data.length - 1].last_activity_at, data[data.length - 1].root_session_id]
+      : null
+    return { data, nextCursor }
+  }
+
   getSession(consumerId, sessionId, installId) {
     const where = ["consumer_id=?", "session_id=?"]
     const args = [consumerId, sessionId]