dsh-desktop-statusbar 2.1.2 → 2.2.0

package/lib/index.js

@@ -143,10 +143,29 @@ const sessionCapacityProjection = {
 
 /* -------------------------------------------------------- sessionProgress */
 
-/** 一次压缩落在哪一轮哪一步（压缩事件只带轮号，步号取压缩前最后一步；取不到给 null）。 */
+/**
+ * 一次**成功**压缩落在哪一轮哪一步。
+ * turn 允许 null：用户手动 /compact 是「轮间压缩」（standalone），真实日志里 turn 就是 null
+ *（见 ~/.dsh/sessions 的 cmd-* 事务）；自动压缩才带当前轮号。
+ * step 取压缩前最后一步；取不到（轮间压缩 / 轮首）给 null。
+ * afterTurn：只有轮间压缩才有值 —— 压缩发生时最后已知的轮号，客户端据此显示「第 N 轮后」，
+ * 不用再把 turn=null 显示成孤零零的横杠；自动压缩有自己的轮号，afterTurn 恒为 null。
+ * manual：用户手动（斜杠命令）触发；自动压缩没有 sourceCommandId。
+ * 成功/失败**只**看 compaction/end 的 data.error：带 error 是失败，不带就是成功。
+ * 不要去数 compaction/summary —— summary 缺失不能反过来否决一次没有 error 的 end
+ *（宿主 invariant 会把「成功 end 没有 summary」当成日志损坏拒绝，那是宿主的事，投影不承担）。
+ */
 const compactMark = z.object({
-  turn: z.number(),
+  turn: z.number().nullable(),
   step: z.number().nullable(),
+  afterTurn: z.number().nullable(),
+  manual: z.boolean(),
+}).strict()
+
+/** 一次技能注入：名字 + 是不是用户手动（斜杠命令）触发。重复注入也各记一条，客户端自己聚合。 */
+const skillMark = z.object({
+  name: z.string(),
+  manual: z.boolean(),
 }).strict()
 
 const sessionProgressSchema = z.object({
@@ -155,13 +174,14 @@ const sessionProgressSchema = z.object({
   toolCalls: z.number(),
   /* 工具名 → 调用次数：气泡里「工具调用」那一行点开要逐个列出来 */
   toolCounts: z.record(z.string(), z.number()),
-  skills: z.array(z.string()),
+  /* 每次注入一条，按发生顺序；manual 区分斜杠命令注入与 skill 工具调用 */
+  skills: z.array(skillMark),
   /* 注入进会话的全局提示词文件名（~/.dsh/AGENTS.md → 'AGENTS.md'）；没注入给 null */
   globalInstruction: z.string().nullable(),
   compactCount: z.number(),
   compactTurn: z.number().nullable(),
   compactStep: z.number().nullable(),
-  /* 每一次压缩的落点，按发生顺序排：气泡里「上下文压缩」那一行点开逐条列 */
+  /* 只列成功压缩，按发生顺序：气泡里「上下文压缩」那一行点开逐条列；失败的不进来 */
   compacts: z.array(compactMark),
 }).strict()
 
@@ -219,12 +239,18 @@ function globalInstructionOf(data) {
  * 所以在 host 侧按事件折一份：
  *   step/start       → 本轮走到第几步（轮号一变就归零，step 是轮内序号不是会话累计）
  *   tool/call        → 整个会话的工具调用次数 + 每个工具名各自的次数；
- *                      工具名是 skill 的那种再把技能名按注入顺序记进 skills
+ *                      工具名是 skill 的那种再把技能名（manual:false）按注入顺序记进 skills
  *   user/message     → 全局提示词（agent-instructions 注入的那种）的文件名；
- *                      斜杠命令注入的技能（skill-invocation）也补进 skills
- *   compaction/start → 压缩次数 + 这一次的落点；压缩事件只带轮号，
- *                      压缩发生在哪一步取压缩前最后一条同轮 step/start
- * 这几种事件在真实日志里都齐（75 个会话：11208 次工具调用、22 个压缩事件）。
+ *                      斜杠命令注入的技能（skill-invocation）以 manual:true 补进 skills
+ *   compaction/end   → 只认**成功**的压缩：判定只看 end 的 data.error（有 error=失败，无 error=成功）。
+ *                      宿主语义（app.asar 里 dsh-compaction 的 invariant）：成功时 end 不带 error，
+ *                      且日志里会有一条 compaction/summary；失败（模型 400/429 等）只发 end + error、
+ *                      没有 summary。**但不数 summary**：没 summary 的 end 也不能反过来判失败，
+ *                      否则就成了「压缩后没有 summary 就算失败」这种没验证过的启发式。
+ *                      轮号取 end.data.turn（用户手动 /compact 是轮间压缩，turn=null），
+ *                      步号取压缩前最后一条同轮 step/start；手动触发看 end.data.sourceCommandId
+ *                      （start/summary/end 三个事件都带同一个命令 id，自动压缩没有）。
+ * 这几种事件在真实日志里都齐（62 个会话：17 次压缩事务，其中成功 4、失败 13，手动 11）。
  */
 const sessionProgressProjection = {
   key: 'desktopStatusbarProgress',
@@ -252,7 +278,8 @@ const sessionProgressProjection = {
     }
     if (event.type === 'user/message') {
       const skill = skillInvocationOf(event.data)
-      if (skill !== null) return { ...state, skills: state.skills.concat([skill]) }
+      /* 用户输入 /技能名 走的就是这条：算手动触发 */
+      if (skill !== null) return { ...state, skills: state.skills.concat([{ name: skill, manual: true }]) }
       const name = globalInstructionOf(event.data)
       if (name === null || state.globalInstruction === name) return state
       return { ...state, globalInstruction: name }
@@ -269,29 +296,41 @@ const sessionProgressProjection = {
         ...state,
         toolCalls: state.toolCalls + 1,
         toolCounts: counts,
-        /* 技能有两种注入来源：调 skill 工具（这里）与斜杠命令（user/message 分支）；
-           名字按注入顺序排，重复注入也照记（数量 = 数组长度） */
-        skills: skill === null ? state.skills : state.skills.concat([skill]),
+        /* 技能有两种注入来源：调 skill 工具（这里，自动/模型触发）与斜杠命令（user/message 分支，
+           用户手动触发）；名字按注入顺序排，重复注入也照记（数量 = 数组长度） */
+        skills: skill === null ? state.skills : state.skills.concat([{ name: skill, manual: false }]),
       }
     }
-    if (event.type === 'compaction/start') {
+    if (event.type === 'compaction/end') {
       const data = event.data === undefined || event.data === null ? {} : event.data
-      const turn = typeof data.turn === 'number' ? data.turn : state.turn
-      /* 压缩前没有同轮的步（压缩落在轮首）时给 null，客户端那一格显示横杠 */
-      const step = turn === state.turn && state.turnSteps > 0 ? state.turnSteps : null
+      /* 失败压缩不发 summary、end 带 error：不计次数、不落档，客户端只显示成功的那些 */
+      if (data.error !== undefined && data.error !== null) return state
+      /* 轮间压缩（用户手动 /compact）turn=null；自动压缩用事件自己的轮号 */
+      const hasTurn = typeof data.turn === 'number'
+      const turn = hasTurn ? data.turn : null
+      /* 轮间压缩没有轮号，但客户端要显示「第 N 轮后」：N 取压缩发生时最后已知的轮号。
+         state.turn 初值是 0（还没跑过任何轮），这时没有「第 N 轮后」可讲，给 null。 */
+      const afterTurn = hasTurn ? null : (typeof state.turn === 'number' && state.turn > 0 ? state.turn : null)
+      /* 步号取压缩前最后一条同轮 step/start：压缩事务中间不会插 step/start（真实日志里
+         成功事务中间只有一条 compact-checkpoint 的 user/message），end 到达时 turnSteps 仍是压缩前步数 */
+      const step = turn !== null && turn === state.turn && state.turnSteps > 0 ? state.turnSteps : null
+      /* 手动 /compact 的三个压缩事件都带 sourceCommandId（命令 id），自动压缩没有 */
+      const manual = data.sourceCommandId !== undefined && data.sourceCommandId !== null
       return {
         ...state,
         compactCount: state.compactCount + 1,
         compactTurn: turn,
         compactStep: step,
-        compacts: state.compacts.concat([{ turn: turn, step: step }]),
+        compacts: state.compacts.concat([{ turn: turn, step: step, afterTurn: afterTurn, manual: manual }]),
       }
     }
     return state
   },
   wire: { viewSchema: sessionProgressSchema, view: (state) => state },
-  // 字段变了（加 globalInstruction、技能多一条斜杠命令来源），提升版本重建旧状态
-  stateVersion: 6,
+  // 字段变了（skills 变成 {name, manual}、compacts 加 manual 且只记成功、压缩 turn 可为 null），提升版本重建旧状态
+  // 7 → 8：compacts 新增 afterTurn（轮间/手动压缩显示「第 N 轮后」，替代原来的横杠）。
+  // 旧缓存里每条压缩记录没有这个字段，必须重放才能补出来。
+  stateVersion: 8,
 }
 
 /* ------------------------------------------------------------ sessionUsage */
@@ -328,8 +367,11 @@ function findUsageInStream(stream) {
 }
 
 function usageOf(event) {
-  if (event.type !== 'assistant/message' && event.type !== 'assistant/attempt') return undefined
+  if (event.type !== 'assistant/message' && event.type !== 'assistant/attempt' && event.type !== 'compaction/summary') return undefined
   const data = event.data === null || event.data === undefined ? {} : event.data
+  /* compaction/summary 是压缩引擎自己发起的一次摘要调用：data.usage 就是它的用量（没有 stream）。
+     真实会话里这 4 笔摘要都是带用量的，漏掉会让「本轮/总计费用」都比实际少。 */
+  if (event.type === 'compaction/summary') return data.usage
   let usage = event.type === 'assistant/message' ? data.usage : undefined
   const fromStream = findUsageInStream(data.stream)
   if (fromStream !== undefined) usage = fromStream
@@ -441,6 +483,38 @@ function addOverflow(overflow, model, parts, peak) {
   }
 }
 
+/**
+ * 把一笔调用并进总计：models 按模型累加、calls 追加，
+ * 超过 MAX_CALLS 被挤掉的最老几条按「模型 + 峰谷档」补进 overflow。
+ * 正常 assistant 调用与 compaction/summary 两处共用一份实现 —— 两条路各写一遍迟早对不齐口径。
+ */
+function addCallTotals(base, one) {
+  const calls = Array.isArray(base.calls) ? base.calls : []
+  const prevModel = base.models[one.model]
+  const bucket = {
+    input: (prevModel === undefined ? 0 : prevModel.input) + one.input,
+    cacheRead: (prevModel === undefined ? 0 : prevModel.cacheRead) + one.cacheRead,
+    cacheWrite: (prevModel === undefined ? 0 : prevModel.cacheWrite) + one.cacheWrite,
+    output: (prevModel === undefined ? 0 : prevModel.output) + one.output,
+  }
+  /* 追加后若超过 MAX_CALLS，最前面那几条会被丢掉。丢掉的是**真实用过的 token**，
+     必须把它们按档累计进 overflow，否则客户端逐条计价时会少算（见 addOverflow 说明）。
+     用合并前后的长度差算出丢了几条 —— 它们一定是最老的，也就是 calls 队首那几条。 */
+  const merged = appendCalls(calls, [one])
+  const droppedCount = calls.length + 1 - merged.length
+  let overflow = typeof base.overflow === 'object' && base.overflow !== null ? base.overflow : {}
+  for (let i = 0; i < droppedCount; i += 1) {
+    const gone = calls[i]
+    if (gone === undefined) break
+    overflow = addOverflow(overflow, gone.model, gone, isPeakTime(gone.at))
+  }
+  return {
+    calls: merged,
+    overflow,
+    models: { ...base.models, [one.model]: bucket },
+  }
+}
+
 const sessionUsageSchema = z.object({
   models: z.record(z.string(), usageBucket),
   calls: z.array(usageCall),
@@ -453,12 +527,27 @@ const sessionUsageSchema = z.object({
      可空且可选 —— 万一某条路径没带上这两个键，也不至于让整个 state 过不了校验。 */
   routeModel: z.string().nullable().optional(),
   routeProvider: z.string().nullable().optional(),
+  /* compactionId → 该次压缩的轮号与开始时刻。compaction/summary 没有 turn，只能靠 start 记下的映射
+     才能判断这笔摘要属于哪一轮；at 用来圈定「防双计」的时间窗。老缓存没有这个键，所以可选。 */
+  compactions: z.record(z.string(), z.object({
+    turn: z.number().nullable(),
+    at: z.number(),
+  }).strict()).optional(),
+  /* 已经计过费的 compactionId：同一笔摘要只计一次。老缓存没有这个键，所以可选。 */
+  countedCompactions: z.array(z.string()).optional(),
+  /* 压缩摘要**累计**的 token 四段（只含摘要、不含普通调用）。
+     为什么需要它：「总计用量」那一栏的数据来自官方 tokenUsage 投影，而官方只折
+     assistant 事件、**不含压缩摘要**；「总计费用」是我们自己逐条算的、**含摘要**。
+     同一面板里两个数字口径不一致（费用算进去了、用量没算）。用户拍板「官方投影继续用，
+     只把摘要这部分额外加上」—— 这份累计就是那个「额外加上」的部分。
+     老缓存没有这个键，所以可选。 */
+  summaryParts: usageBucket.optional(),
 }).strict()
 
 const sessionUsageProjection = {
   key: 'desktopStatusbarUsage',
   stateSchema: sessionUsageSchema,
-  init: () => ({ models: {}, calls: [], overflow: {}, current: null, last: null, turn: null, routeModel: null, routeProvider: null }),
+  init: () => ({ models: {}, calls: [], overflow: {}, current: null, last: null, turn: null, routeModel: null, routeProvider: null, compactions: {}, countedCompactions: [], summaryParts: { input: 0, cacheRead: 0, cacheWrite: 0, output: 0 } }),
   apply: (state, event) => {
     const calls = Array.isArray(state.calls) ? state.calls : []
     const turnOf = (event) => {
@@ -472,6 +561,20 @@ const sessionUsageProjection = {
       if (state.current === null) return { ...state, turn: started }
       return { ...state, calls, current: null, last: state.current, turn: started }
     }
+    /* 压缩事务开始时先记下 compactionId → 轮号：compaction/summary 事件本身没有 turn，
+       只能靠这条映射判断这笔摘要费用算不算「本轮」。turn 允许 null（轮间/手动压缩）。 */
+    if (event.type === 'compaction/start') {
+      const data = event.data === null || event.data === undefined ? {} : event.data
+      if (typeof data.compactionId !== 'string' || data.compactionId.length === 0) return state
+      const compactions = typeof state.compactions === 'object' && state.compactions !== null ? state.compactions : {}
+      return {
+        ...state,
+        compactions: {
+          ...compactions,
+          [data.compactionId]: { turn: typeof data.turn === 'number' ? data.turn : null, at: event.time },
+        },
+      }
+    }
     // 先记下"这次请求用的是哪个模型"：没有 message 的事件（assistant/attempt）靠它补型号
     const routed = routedModelOf(event)
     const base = routed === null ? state : {
@@ -482,23 +585,24 @@ const sessionUsageProjection = {
     const usage = usageOf(event)
     if (usage === undefined || usage === null) return base
     // 型号两条路：常规事件从 message.source 取；没有 message 的用上面记下的最近一次请求
-    const message = event.data === null || event.data === undefined ? null : event.data.message
+    const data = event.data === null || event.data === undefined ? {} : event.data
+    const message = data.message
     const source = message === null || message === undefined ? null : message.source
     const fromMessage = source !== null && source.kind === 'model' && typeof source.model === 'string'
-    const model = fromMessage ? source.model : (typeof base.routeModel === 'string' ? base.routeModel : '')
-    // 两条路都拿不到型号：放弃这一笔，好过抛错把整条投影（以及同一次驱动的其它投影）带停
+    /* 摘要调用是压缩引擎自己发起的（没有 message），型号只认 summary 自己的 data.model；
+       不能退回 routeModel —— 那是用户上一轮对话的模型，摘要往往跑在另一个模型上。 */
+    const isCompactionSummary = event.type === 'compaction/summary'
+    const model = isCompactionSummary
+      ? (typeof data.model === 'string' && data.model.length > 0 ? data.model : '')
+      : (fromMessage ? source.model : (typeof base.routeModel === 'string' ? base.routeModel : ''))
+    // 拿不到型号：放弃这一笔，好过抛错把整条投影（以及同一次驱动的其它投影）带停
     if (model.length === 0) return base
-    const provider = fromMessage && typeof source.provider === 'string'
-      ? source.provider
-      : (typeof base.routeProvider === 'string' ? base.routeProvider : '')
-    const currentModel = base.models[model]
+    const provider = isCompactionSummary
+      ? (typeof data.provider === 'string' ? data.provider : '')
+      : (fromMessage && typeof source.provider === 'string'
+        ? source.provider
+        : (typeof base.routeProvider === 'string' ? base.routeProvider : ''))
     const parts = usageParts(usage)
-    const bucket = {
-      input: (currentModel === undefined ? 0 : currentModel.input) + parts.input,
-      cacheRead: (currentModel === undefined ? 0 : currentModel.cacheRead) + parts.cacheRead,
-      cacheWrite: (currentModel === undefined ? 0 : currentModel.cacheWrite) + parts.cacheWrite,
-      output: (currentModel === undefined ? 0 : currentModel.output) + parts.output,
-    }
     const one = {
       at: event.time,
       model,
@@ -507,13 +611,102 @@ const sessionUsageProjection = {
       cacheWrite: parts.cacheWrite,
       output: parts.output,
     }
+    /* 摘要事件走单独的归轮路径：它没有 turn，绝不能套用下面"轮次变化就重开 current"的逻辑，
+       否则上一轮/轮间压缩的摘要会并进当前轮，或者把 current/last 打乱。 */
+    if (isCompactionSummary) {
+      /* 摘要的去重身份：正常情况下用 upstream 给的 compactionId；
+         拿不到时退回 `event.seq`（**与本文件 usageEventKey 的既有做法一致**，见
+         `'compact:' + (compactionId ?? event.seq)`）。为什么不直接跳过空 id：
+         那会把一笔真实用量彻底丢掉（费用和用量都少算），而重复计费比漏算更糟但
+         两者都有代价 —— 用 seq 兜底能做到"同一事件重复到达只计一次"，
+         因为同一事件的 seq 相同、不同事件必然不同。 */
+      const rawId = typeof data.compactionId === 'string' ? data.compactionId : ''
+      const compactionId = rawId.length > 0
+        ? rawId
+        : (typeof event.seq === 'number' ? 'seq:' + event.seq : '')
+      const counted = Array.isArray(base.countedCompactions) ? base.countedCompactions : []
+      // 同一笔压缩只计一次：重放或重复事件不能让费用翻倍
+      if (compactionId.length > 0 && counted.includes(compactionId)) return base
+      const compactions = typeof base.compactions === 'object' && base.compactions !== null ? base.compactions : {}
+      /* 只有 upstream 真的给了 id 时才有 start 映射可查（空 id 的 start 在更早的分支就被丢弃了） */
+      const opened = rawId.length > 0 ? compactions[rawId] : undefined
+      /* 防旧宿主双计：旧版本可能把同一笔用量既落成 assistant/message 又落成 summary。
+         窗口 = compaction/start 到本 summary 之间；四条用量分量完全相同才算同一笔
+         （token 数精确到个位，不同请求撞上的概率可以忽略）。 */
+      const duplicate = opened !== undefined && calls.some((call) =>
+        call.at >= opened.at && call.at <= event.time
+        && call.input === one.input && call.cacheRead === one.cacheRead
+        && call.cacheWrite === one.cacheWrite && call.output === one.output)
+      if (duplicate) return base
+      const totals = addCallTotals(base, one)
+      /* 摘要用量单独累计一份（与按模型的 models 那份分开）：
+         客户端「总计用量」用官方 tokenUsage 投影（不含摘要），需要这一份把摘要补回去，
+         才能让「总计用量」与「总计费用」口径一致。老 state 没有这个键，按 0 起算。 */
+      const prevSummary = base.summaryParts !== undefined && base.summaryParts !== null
+        && typeof base.summaryParts === 'object' ? base.summaryParts : null
+      const summaryParts = {
+        input: (prevSummary === null ? 0 : Number(prevSummary.input) || 0) + one.input,
+        cacheRead: (prevSummary === null ? 0 : Number(prevSummary.cacheRead) || 0) + one.cacheRead,
+        cacheWrite: (prevSummary === null ? 0 : Number(prevSummary.cacheWrite) || 0) + one.cacheWrite,
+        output: (prevSummary === null ? 0 : Number(prevSummary.output) || 0) + one.output,
+      }
+      /* 轮归属三条规则：
+         ① 映射到数字 turn 且等于当前 turn → 同时进总计与本轮；
+         ② 映射到数字 turn 但不等当前轮 → 只进总计；
+         ③ 映射为 null（**轮间压缩**，手动 / 自动都是 null）→ 只进总计，
+            **并把「本轮」刷新成这一笔**；
+            没有映射（日志截断/旧版本）→ 兜底归当前轮，不抛错。
+
+         为什么叫「轮间压缩」而不是「手动压缩」：宿主语义上两者是同一件事 ——
+         手动 `/compact` 必须等这一轮回复结束、用户才能输入，所以它**必然**是轮间压缩，
+         `compaction/start` 的 turn 就是 null（见 tests/verify-host.js 里「用户手动 /compact：
+         轮间压缩（start/summary/end 都带 sourceCommandId，turn=null）」那条夹具）。
+
+         反过来说：**自动压缩**（对话进行中达到阈值时触发）的 turn 是当前轮号，
+         所以它根本不会走到这个分支 —— 它由上面的 `belongsToCurrent` 命中、
+         **累加进当前轮**（那笔费用属于本轮，用户明确要求过）。
+
+         用户对这一条的原话：「手动压缩的时候，上一轮对话明显已经结束了，此时本轮显示的
+         数字依旧是上一轮对话产生的费用，而不是本次手动压缩产生的费用。」 */
+      const mappedTurn = opened === undefined ? undefined : opened.turn
+      const isInterTurnCompaction = mappedTurn === null
+      const belongsToCurrent = mappedTurn === undefined
+        ? base.current !== null
+        : (mappedTurn !== null && stateTurn !== null && mappedTurn === stateTurn)
+      let current = base.current
+      if (belongsToCurrent || isInterTurnCompaction) {
+        /* belongsToCurrent：并进当前轮（累加）—— 自动压缩走这条；
+           isInterTurnCompaction：**替换**（不累加）—— 手动 /compact 走这条，
+           它代表"上一轮已结束，现在这笔是本轮"。 */
+        const prev = belongsToCurrent && base.current !== null && Array.isArray(base.current.calls)
+          ? base.current
+          : null
+        current = {
+          provider,
+          model,
+          time: event.time,
+          input: (prev === null ? 0 : prev.input) + one.input,
+          cacheRead: (prev === null ? 0 : prev.cacheRead) + one.cacheRead,
+          cacheWrite: (prev === null ? 0 : prev.cacheWrite) + one.cacheWrite,
+          output: (prev === null ? 0 : prev.output) + one.output,
+          calls: (prev === null ? [] : prev.calls).concat([one]),
+        }
+      }
+      return {
+        ...base,
+        ...totals,
+        current,
+        summaryParts,
+        countedCompactions: compactionId.length > 0 ? counted.concat([compactionId]) : counted,
+      }
+    }
     const turn = turnOf(event)
     // 轮次变化就重开本轮汇总：不能假设一定有 turn/start
     const sameTurn = base.current !== null && Array.isArray(base.current.calls)
       && (turn === null || stateTurn === null || turn === stateTurn)
     const prev = sameTurn ? base.current : null
     const callsForTurn = prev === null ? [] : prev.calls
-    const summary = {
+    const turnSummary = {
       provider,
       model,
       time: event.time,
@@ -522,27 +715,14 @@ const sessionUsageProjection = {
       cacheWrite: (prev === null ? 0 : prev.cacheWrite) + one.cacheWrite,
       output: (prev === null ? 0 : prev.output) + one.output,
     }
-    const current = { ...summary, calls: callsForTurn.concat([one]) }
-    /* 追加后若超过 MAX_CALLS，最前面那几条会被丢掉。丢掉的是**真实用过的 token**，
-       必须把它们按档累计进 overflow，否则客户端逐条计价时会少算（见 addOverflow 说明）。
-       用合并前后的长度差算出丢了几条 —— 它们一定是最老的，也就是 calls 队首那几条。 */
-    const merged = appendCalls(calls, [one])
-    const droppedCount = calls.length + 1 - merged.length
-    let overflow = typeof base.overflow === 'object' && base.overflow !== null ? base.overflow : {}
-    for (let i = 0; i < droppedCount; i += 1) {
-      const gone = calls[i]
-      if (gone === undefined) break
-      overflow = addOverflow(overflow, gone.model, gone, isPeakTime(gone.at))
-    }
+    const current = { ...turnSummary, calls: callsForTurn.concat([one]) }
     return {
       ...base,
+      ...addCallTotals(base, one),
       turn: turn === null ? stateTurn : turn,
-      calls: merged,
-      overflow,
       current,
       // 轮次变化时把上一轮结算进 last
       last: prev === null && base.current !== null ? base.current : base.last,
-      models: { ...base.models, [model]: bucket },
     }
   },
   wire: {
@@ -556,7 +736,14 @@ const sessionUsageProjection = {
   // 整条投影抛错、该会话的账从此停摆。提升版本强制重放，把这些笔补回账本。
   // 5 → 6：新增 overflow（被 MAX_CALLS 截掉那段的按档累计）。旧缓存里这个字段不存在，
   // 长会话的费用会一直少算截掉的部分，必须重放才能补出来。
-  stateVersion: 6,
+  // 6 → 7：compaction/summary 的摘要调用（真实会话里有 4 笔带用量）以前整笔漏掉，
+  // 「本轮/总计费用」都比实际少。新增 compactions/countedCompactions 两个字段做归轮与防双计，
+  // 旧缓存里没有它们，必须重放才会把这 4 笔补进账本。
+  // 7 → 8：新增 summaryParts（压缩摘要的 token 累计），供客户端把它加到「总计用量」上 ——
+  // 官方 tokenUsage 投影不含摘要，导致「总计费用」含摘要而「总计用量」不含，同一面板两个口径。
+  // 旧缓存没有这个字段，不重放的话历史会话的「总计用量」会永远少那几笔摘要。
+  // 同一次 bump 也覆盖「轮间/手动压缩刷新本轮」的新语义（current 的重建规则变了）。
+  stateVersion: 8,
 }
 
 /* -------------------------------------------------------- sessionTimeRange */
@@ -1327,6 +1514,10 @@ async function queryLocalAdapter(ctx, adapter, now, provider) {
       isCredits: parsed.isCredits === true,
       isPercent: parsed.isPercent === true,
       parts: parsed.parts,
+      /* 积分套餐明细（workbuddy 新插件的 credits.packages 投影，见 balance-api.js 的 parse）。
+         字段名固定 rewards；**只有适配器真的给了才带上** —— 老插件/非积分平台没有这个键，
+         客户端据此走原来的纯总数显示。失败态（上面几个分支）一律不带。 */
+      ...(parsed.rewards === undefined ? {} : { rewards: parsed.rewards }),
       toppedUp: partAmount(parsed.parts, 'toppedUp'),
       granted: partAmount(parsed.parts, 'granted'),
       spent: partAmount(parsed.parts, 'spent'),
@@ -2339,23 +2530,48 @@ async function subagentIndexSnapshot(files) {
 }
 
 /**
- * 一段父会话日志里的"本轮起点"：最后一条 `turn/start` 的时间 —— 但**和最后一条
- * `user/message` 取较大的那个**。都找不到就返回 null（调用方据此判 sinceSource='none'）。
+ * 一段父会话日志里的"本轮起点"。三条时间取 max，规则见下：
+ *   ① 最后一条 `turn/start`；
+ *   ② 最后一条**真实用户输入**的 `user/message` —— 但**只有**它落在
+ *      「最后一条 `turn/end` 之后、且最后一条 `turn/end` 晚于最后一条 `turn/start`」
+ *      这一段里，才算"新一轮已经开始、而它的 `turn/start` 还没落盘"的候选；
+ *   ③ 日志里完全没有 `turn/start` 时，退回用最后一条真实用户消息（老兜底）。
+ * 都找不到就返回 null（调用方据此判 sinceSource='none'）。
+ *
+ * **为什么只认 `source.kind === 'user'` 的 `user/message`**（2026-10-17 修复）：
+ * 同一轮里 DSH 会往父会话日志注入很多**不是用户输入**的 `user/message` ——
+ * 子代理结算（`subagent-settled`）、队友消息转发（`team-message` / `agent-message`）、
+ * 后台任务完成（`tool-jobs`）、技能目录刷新（`skill-catalog`）、审批回答
+ * （`user-approval`）、运行时上下文（`runtime-context`）……它们**都不改轮次**。
+ * 旧实现把所有 `user/message` 都算进来，于是"最后一条"常常是这些通知：本轮窗口
+ * 起点被推到**子代理结算那一刻**，队友在本轮已经花掉的钱整段被排除（用户实测
+ * 「所有子代理运行完之后『本轮』卡住不涨」；本机真实日志复现：本轮应 ¥34.62 →
+ * 实际 ¥10.58）。只认真实用户输入才能既保住"新一轮已开始"的兜底，又不被注入
+ * 通知推进起点。
+ *
+ * **为什么真人中途插话（steering）也不能算新轮起点**（2026-10-17 补边界）：
+ * DSH 支持同一轮里用户再发消息（本轮日志里就有：唯一一条 `turn/start` 之后 7 分钟
+ * 又来了一条 `source.kind='user'` 的消息，`turn/end` 还没出现）。这种消息只改变
+ * 这一轮的上下文、**不开新轮**；若把它当起点，「本轮」会从插话那一刻重新算，把插话
+ * 之前子代理在本轮花掉的钱再次抹掉（实测：本轮 ¥4.06，而总计 ¥5.03，残差 ¥0.97）。
+ * 所以判据是"**轮已经关了**"才认用户消息：看 `turn/end` 是否晚于最后一条
+ * `turn/start`（关轮 = 上一轮已结束，此时新 USER 消息代表新轮已起、`turn/start`
+ * 还没落盘）；turn 还开着就只认 `turn/start`。
  *
- * 为什么不是"有 turn/start 就优先用它"：用户消息比最后一条 turn/start 还新，说明
- * **新一轮已经开始、而它的 `turn/start` 还没落盘**；此时沿用旧的 turn/start 会把
- * **上一轮**的队友用量算进"本轮"，方向正是用户不允许的"偏大"。取较新的那个时间
- * 只会把窗口往回收（宁少不多），符合"本轮只能小不能大"。
  * 取**最大值**而不是"文件里最后一行"：正常日志是追加写的，两者一致；万一有乱序行，
  * 取最大值更稳。
  */
 function lastTurnStartOfText(text) {
   if (typeof text !== 'string' || text.length === 0) return null
-  let at = null
+  let lastTurnStart = null
+  let lastTurnEnd = null
+  let lastUser = null
   const lines = text.split('\n')
   for (let i = 0; i < lines.length; i += 1) {
     const line = lines[i]
-    if (line.indexOf('"turn/start"') < 0 && line.indexOf('"user/message"') < 0) continue
+    /* 便宜的预筛：只解析可能相关的三种事件 */
+    if (line.indexOf('"turn/start"') < 0 && line.indexOf('"turn/end"') < 0
+      && line.indexOf('"user/message"') < 0) continue
     let event
     try {
       event = JSON.parse(line)
@@ -2363,10 +2579,29 @@ function lastTurnStartOfText(text) {
       continue
     }
     if (event === null || typeof event !== 'object' || typeof event.time !== 'number') continue
-    if (event.type !== 'turn/start' && event.type !== 'user/message') continue
-    if (at === null || event.time > at) at = event.time
+    if (event.type === 'turn/start') {
+      if (lastTurnStart === null || event.time > lastTurnStart) lastTurnStart = event.time
+      continue
+    }
+    if (event.type === 'turn/end') {
+      if (lastTurnEnd === null || event.time > lastTurnEnd) lastTurnEnd = event.time
+      continue
+    }
+    if (event.type !== 'user/message') continue
+    /* 只认真实用户输入：source 缺失（老日志/坏行）也宁可不当成新轮 —— 少算一侧
+       的代价是多算上一轮末的队友用量（偏大），比"整轮花费被抹掉"可接受。 */
+    const data = event.data !== null && event.data !== undefined && typeof event.data === 'object' ? event.data : {}
+    const source = data.source !== null && data.source !== undefined && typeof data.source === 'object' ? data.source : null
+    if (source === null || source.kind !== 'user') continue
+    if (lastUser === null || event.time > lastUser) lastUser = event.time
   }
-  return at
+  /* 完全没有 turn/start：老日志/异常日志的兜底 —— 用最后一条真实用户消息（原来就是这样） */
+  if (lastTurnStart === null) return lastUser
+  /* 用户消息只有在"上一轮已结束（turn/end 晚于 turn/start）、且消息晚于那个 turn/end"
+     时才是"新轮已开始、turn/start 还没落盘"的证据；turn 还开着就只是本轮插话，不算 */
+  const turnClosed = lastTurnEnd !== null && lastTurnEnd > lastTurnStart
+  const userStartedNewTurn = turnClosed === true && lastUser !== null && lastUser > lastTurnEnd
+  return userStartedNewTurn === true && lastUser > lastTurnStart ? lastUser : lastTurnStart
 }
 
 /**
@@ -2607,9 +2842,11 @@ function subagentFileUsage(one, fromMs, fingerprint) {
  *     （只收紧、不放大；`since=0` 是显式整会话，不收敛）；真收敛了会带
  *     `sinceClamped: true`（`sinceSource` 仍是 `client`）；
  *   · `host`：没传 → host 读**父会话自己**的日志推一个起点（最后一条 `turn/start`，
- *     但和最后一条 `user/message` 取较新的那个 —— 后者更新说明新一轮已开始、其
- *     `turn/start` 还没落盘，沿用旧起点会把上一轮算进来）；而且**推出来的起点之后
- *     必须真的有用量事件**，否则说明起点无从验证，同样当 `none`（宁少不多）；
+ *     但和最后一条**真实用户输入**的 `user/message` 取较新的那个 —— 后者更新说明新一轮
+ *     已开始、其 `turn/start` 还没落盘，沿用旧起点会把上一轮算进来；同轮注入的
+ *     subagent-settled / team-message / tool-jobs 等通知不算，见 lastTurnStartOfText）；
+ *     而且**推出来的起点之后必须真的有用量事件**，否则说明起点无从验证，同样当
+ *     `none`（宁少不多）；
  *   · `none`：父会话日志缺失/读不出，或推出来的起点事后没有事件 → 本轮**什么都不并**
  *     （整条返回零值），绝不退回整会话 —— 用户规则：本轮只能小不能大；
  *     要整会话（「总计」那一项）就显式传 `since=0`。
@@ -2656,8 +2893,9 @@ async function collectSubagentUsageNow(sessionId, sinceMs) {
 
   /* 窗口起点从哪来：① 客户端给了（它精确知道自己那一轮）→ `client`；
      ② 没给就问 host 自己 —— 读**父会话自己**的日志取最后一条 turn/start（或更新的
-     user/message，见 lastTurnStartOfText）→ `host`；③ 两者都没有（父会话文件缺失/读不出）
-     → `none`：**本轮什么都不并**（用户规则：本轮只能小不能大，绝不能拿整会话的量顶上）。
+     真实用户 user/message，见 lastTurnStartOfText；同轮注入的通知不算）→ `host`；
+     ③ 两者都没有（父会话文件缺失/读不出）→ `none`：**本轮什么都不并**
+     （用户规则：本轮只能小不能大，绝不能拿整会话的量顶上）。
      另外 host 推的起点还要过一道"事后有事件"的验证（见下面聚合之后的那段）。 */
   const parentEntry = index.byId.get(sessionId)
   let sinceSource = 'none'
@@ -2739,7 +2977,9 @@ async function collectSubagentUsageNow(sessionId, sinceMs) {
     total.stats.ttftSteps += agg.stats.ttftSteps
     total.stats.decodeMs += agg.stats.decodeMs
     total.stats.decodeTokens += agg.stats.decodeTokens
-    if (i % 4 === 3) await new Promise((resolve) => setImmediate(resolve))
+    /* 每 16 个让出一次事件循环：146+ 个队友时 4 个一让太碎，宿主每秒都在被问，
+       让出次数少一点能明显压低单次聚合的调度开销（文件用量已按文件缓存，重算只是少数）。 */
+    if (i % 16 === 15) await new Promise((resolve) => setImmediate(resolve))
   }
   /* host 推出来的起点必须有"事后证据"才算有效。**证据有两条，任一条成立即可**：
      ① 父会话**自己**在窗口内有用量事件（fromMs 之后有 assistant/message 或
@@ -3424,6 +3664,44 @@ function appendTipDiag(body) {
   }
 }
 
+/**
+ * 把客户端上报的「更新失败」描述成一条能直接拿去问 AI 的日志文本。
+ *
+ * 字段都是**客户端自己知道、宿主不知道**的：它在哪个环节失败、目标版本是谁、
+ * 浏览器抛了什么异常。刻意不在这里做任何判断或修复 —— 只把事实摊平成一行，
+ * 让用户把日志贴给 AI 时信息是完整的（这是用户提「补日志」的原始诉求）。
+ *
+ * 只取有限长度的字符串，避免恶意/异常的超长 body 把日志撑爆。
+ *
+ * @param {object|null} body 客户端 POST 上来的 JSON
+ * @returns {string}
+ */
+function describeClientUpdateFailure(body) {
+  const src = body !== null && body !== undefined && typeof body === 'object' ? body : {}
+  const text = (value, max) => {
+    if (value === null || value === undefined) return null
+    const raw = typeof value === 'string' ? value : String(value)
+    const limit = max === undefined ? 200 : max
+    return raw.length > limit ? raw.slice(0, limit) + '…' : raw
+  }
+  const parts = []
+  const reason = text(src.reason, 60)
+  parts.push('reason=' + (reason === null ? 'unknown' : reason))
+  parts.push('target=' + (text(src.target, 40) ?? 'null'))
+  parts.push('current=' + (text(src.current, 40) ?? 'null'))
+  /* 时间戳取客户端那一刻：宿主收到的时间可能晚很多（比如用户在断网时才点） */
+  parts.push('at=' + (typeof src.at === 'number' && Number.isFinite(src.at) ? new Date(src.at).toISOString() : 'null'))
+  const stage = text(src.stage, 60)
+  if (stage !== null) parts.push('stage=' + stage)
+  /* HTTP 状态码：fetch 对 4xx/5xx 是 resolve 不是 reject，必须单独记 */
+  if (typeof src.httpStatus === 'number' && Number.isFinite(src.httpStatus)) parts.push('http=' + String(src.httpStatus))
+  const detail = text(src.detail, 300)
+  if (detail !== null && detail.length > 0) parts.push('detail=' + detail)
+  /* 失败那一次尝试了多久：能区分"秒失败（被拒/被拦）"与"等很久才超时" */
+  if (typeof src.elapsedMs === 'number' && Number.isFinite(src.elapsedMs)) parts.push('elapsed=' + String(Math.round(src.elapsedMs)) + 'ms')
+  return parts.join(' ')
+}
+
 /* 台账只在「有新数据」时才重扫（文件 mtime+size 没变就跳过），因此这层只是省掉重复的 stat。
    不挂定时器：打开活跃总览面板时会带 force=1 现扫一次，数据只在被看的时候才需要最新。 */
 const WEEK_USAGE_CACHE_MS = 30000
@@ -3911,6 +4189,20 @@ async function handleApi(req, res, ctx) {
     sendJson(res, 200, { ok: true })
     return
   }
+  if (url.pathname === '/dsh-desktop-statusbar/api/update-failure') {
+    /* 客户端侧更新失败的上报口。为什么需要它：宿主侧失败已经在
+       `update: 结果 {...}` 那条日志里了，但**客户端自己**的失败（fetch 被代理拦、
+       响应解不出来、网络断）发生在浏览器里，宿主完全不知道 —— 用户点完只看到
+       「更新失败」，日志里查不到任何痕迹，想用 AI 排查也无从下手。
+       这里把它补成一条**结构化日志行**：既有给人看的中文摘要，也有完整 JSON。
+       不做任何状态变更、不重试安装，只落日志，所以是纯诊断面。 */
+    if (req.method === 'POST') {
+      const body = await readJsonBody(req)
+      logHost(ctx, 'update: 客户端失败 ' + describeClientUpdateFailure(body))
+    }
+    sendJson(res, 200, { ok: true })
+    return
+  }
   if (url.pathname !== '/dsh-desktop-statusbar/api/balance') {
     sendJson(res, 404, { ok: false, reason: 'not-found' })
     return