dsh-llm-workbuddy 0.1.9 → 0.1.12

package/README.md

@@ -199,6 +199,7 @@ Web 登录后终端脚本也读得到同一份会话。
 | `GET /api/workbuddy/status` | 读取会话文件（默认 `~/.codebuddy-session.json`，或配置的 `sessionFile`）的 `auth.expiresAt` 判断会话是否有效，并 `fetch` 代理 `/health` 判断 `proxyUp`；返回 JSON：`{ sessionFile, authenticated, expiresAt, account, proxyUp, tokenValid, loginScriptAvailable }`；非 GET 返回 405 |
 | `POST /api/workbuddy/login` | 若已有有效会话则直接返回 `alreadyLoggedIn`；否则用系统 `python3` `spawn` 包内 `login_workbuddy.py --session-file <sessionFile>`，从子进程 stdout 解析出 `authUrl` 立即返回 `{ authUrl, pending:true }`（设备流在后台继续，前端轮询 status 感知完成）；非 POST 返回 405 |
 | `POST /api/workbuddy/diagnose` | **一键诊断**：真实探测健康状态，返回 `{ ok, session, health, chat, loginScriptAvailable, restartCommand }`。与 `/status` 不同，它除了探 `/health`，还会**真实发一次最小模型请求**（`chat.chatWorking`），能戳穿"胶囊显示成功但模型全 500"的假象；`ok:false` 时附带 `restartCommand`（自动区分本地 monorepo 布局与标准安装）；非 POST 返回 405 |
+| `GET /api/workbuddy/usage` | **用量统计**：读取本地 token 用量台账（`$DSH_HOME/llm-workbuddy/usage.jsonl`），返回 `{ today, byModel, total }`（今日/按模型/累计的 input/output tokens 与请求次数）；非 GET 返回 405 |
 
 > 会话文件与登录脚本路径的解析顺序：
 > 1. 配置里显式指定的 `sessionFile` / `loginScript`；
@@ -214,6 +215,9 @@ Web 登录后终端脚本也读得到同一份会话。
 - 胶囊里有个 **🔍 诊断** 按钮：点它 `POST /api/workbuddy/diagnose`，弹出一个面板
   显示**真实健康状态**（登录、会话文件、代理进程、登录令牌、模型能否出字），
   发现问题时附带**可复制的重启命令**（一键复制到终端执行）。
+- 胶囊里有个 **📊 用量** 按钮：点它 `GET /api/workbuddy/usage`，弹出一个面板
+  显示**今日/累计 token 用量**与**按模型明细**（数据来自本地台账
+  `$DSH_HOME/llm-workbuddy/usage.jsonl`）。
 - 状态映射：
   - `authenticated && proxyUp` → 🟢 绿，显示 `WorkBuddy · <昵称>`
   - 否则 → 🔴 红，显示「登录」按钮；`proxyUp` 为 false 时额外提示 `代理未运行`
@@ -280,8 +284,10 @@ DSH 的 `dsh.client` 机制只要求 `package.json` 里：
 
 模型列表默认取插件内置目录；代理可达时改为实时拉取 `/v1/models`（支持
 `{"models": [...]}` / `{"data": [...]}` 两种返回），未列出的模型 id 仍可原样
-传递。每个模型的推理等级（`reasoningEffort`）默认来自内置目录，代理可达时优先
-沿用目录值（代理 `/v1/models` 当前只上报 `High`，不区分模型）。
+传递。**内置目录充当白名单**：代理返回的已下架/不可用模型（如 glm-4.6v、
+glm-5.0、minimax-m2.5 等，上游返回 `service info not found`）会被过滤，不显示
+在 UI 中。每个模型的推理等级（`reasoningEffort`）默认来自内置目录，代理可达时
+优先沿用目录值（代理 `/v1/models` 当前只上报 `High`，不区分模型）。
 
 ---
 

package/lib/client.js

@@ -107,6 +107,18 @@ function runWidget() {
     }
     // 诊断按钮始终显示，便于随时自查真实健康状态。
     html += '<button class="wb-btn wb-diagnose" id="wb-diagnose" title="一键诊断">🔍</button>';
+    // 用量按钮：查看今日/累计 token 用量与模型明细。
+    html += '<button class="wb-btn wb-usage" id="wb-usage" title="用量统计">📊</button>';
+    // 签到按钮：✅ 今日已处理 / 🎁 今日未处理（点击立即领取；10 点后也会自动领取）。
+    var ck = status.checkin;
+    if (ck) {
+      var ckMsg = ck.lastResult && ck.lastResult.message ? "\n" + ck.lastResult.message : "";
+      var ckTitle = ck.handledToday ? "今日已处理签到" + ckMsg : "今日还没签到（每天 10 点后自动领取）\n点击立即领取";
+      var ckIcon = ck.handledToday && ck.lastResult && ck.lastResult.ok ? "✅" : "🎁";
+      html += '<button class="wb-btn wb-checkin" id="wb-checkin" title="' + esc(ckTitle) + '">' + ckIcon + "</button>";
+    }
+    // 刷新模型按钮：从代理重读模型列表（跟随 WorkBuddy 应用更新）并让模型选择器立即重载。
+    html += '<button class="wb-btn wb-models" id="wb-models" title="刷新模型列表">🔄</button>';
     if (!status.proxyUp) html += '<span class="wb-warn">代理未运行</span>';
     html += "</div>";
     host.innerHTML = html;
@@ -114,6 +126,12 @@ function runWidget() {
     if (btn) btn.addEventListener("click", onLogin);
     var dg = host.querySelector("#wb-diagnose");
     if (dg) dg.addEventListener("click", onDiagnose);
+    var us = host.querySelector("#wb-usage");
+    if (us) us.addEventListener("click", onUsage);
+    var ckBtn = host.querySelector("#wb-checkin");
+    if (ckBtn) ckBtn.addEventListener("click", onCheckin);
+    var mdBtn = host.querySelector("#wb-models");
+    if (mdBtn) mdBtn.addEventListener("click", onRefreshModels);
   }
 
   function refresh() {
@@ -206,12 +224,92 @@ function runWidget() {
       });
   }
 
+  /** 用量统计：读取 /api/workbuddy/usage 并展示今日/累计/模型明细。 */
+  function onUsage() {
+    var panel = document.getElementById("wb-usage-panel");
+    if (panel) { panel.remove(); return; }
+    var el = document.createElement("div");
+    el.id = "wb-usage-panel";
+    el.style.cssText =
+      "position:fixed;right:12px;bottom:44px;z-index:2147483647;width:340px;max-height:340px;overflow:auto;" +
+      "background:#0f172a;color:#e2e8f0;border:1px solid #334155;border-radius:8px;" +
+      "padding:10px;font:12px/1.5 system-ui,sans-serif;box-shadow:0 6px 20px rgba(0,0,0,.5);";
+    el.innerHTML = '<div class="wb-usage-title" style="font-weight:700;margin-bottom:6px">WorkBuddy 用量统计</div>' +
+      '<div class="wb-usage-body" style="color:#94a3b8">加载中…</div>';
+    document.body.appendChild(el);
+
+    fetch("/api/workbuddy/usage")
+      .then(function (r) { return r.ok ? r.json() : null; })
+      .then(function (d) {
+        if (!d) throw new Error("空响应");
+        var lines = [];
+        lines.push("今日：输入 " + d.today.inputTokens + " / 输出 " + d.today.outputTokens + " tokens（" + d.today.requests + " 次请求）");
+        lines.push("累计：输入 " + d.total.inputTokens + " / 输出 " + d.total.outputTokens + " tokens（" + d.total.requests + " 次请求）");
+        lines.push("");
+        lines.push("按模型明细：");
+        if (d.byModel.length === 0) lines.push("  暂无数据");
+        for (var i = 0; i < d.byModel.length; i += 1) {
+          var m = d.byModel[i];
+          lines.push("  " + m.model + "：输入 " + m.inputTokens + " / 输出 " + m.outputTokens + "（" + m.requests + " 次）");
+        }
+        el.innerHTML = '<div class="wb-usage-title" style="font-weight:700;margin-bottom:6px">WorkBuddy 用量统计</div>' +
+          '<div class="wb-usage-body" style="white-space:pre-wrap;word-break:break-word">' + esc(lines.join("\n")) + "</div>" +
+          '<div style="margin-top:8px;color:#64748b;font-size:11px">数据来源：本地 token 用量台账（' + esc(d.total.requests) + " 次累计）</div>";
+      })
+      .catch(function (err) {
+        el.innerHTML = '<div class="wb-usage-title" style="font-weight:700;color:#f87171">用量加载失败</div>' +
+          '<div class="wb-usage-body">' + esc(String(err && err.message || err)) + "</div>";
+      });
+  }
+
   function esc(s) {
     return String(s == null ? "" : s).replace(/[&<>"']/g, function (c) {
       return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c];
     });
   }
 
+  /** 手动领取今日签到（幂等：官方对已签到返回业务拒绝，不会出错）。 */
+  function onCheckin() {
+    var btn = host.querySelector("#wb-checkin");
+    if (!btn || btn.dataset.busy) return;
+    btn.dataset.busy = "1";
+    btn.textContent = "⏳";
+    fetch("/api/workbuddy/checkin", { method: "POST" })
+      .then(function (r) { return r.json(); })
+      .then(function (d) {
+        btn.textContent = d && d.ok ? "✅" : "🎁";
+        btn.title = (d && d.message) || "签到结果未知";
+        refresh();
+      })
+      .catch(function () {
+        btn.textContent = "🎁";
+        btn.title = "签到请求失败（代理未运行？）";
+      })
+      .then(function () { delete btn.dataset.busy; });
+  }
+
+  /** 刷新模型列表：清插件发现缓存 + 触发模型选择器立即重载。 */
+  function onRefreshModels() {
+    var btn = host.querySelector("#wb-models");
+    if (!btn || btn.dataset.busy) return;
+    btn.dataset.busy = "1";
+    btn.textContent = "…";
+    fetch("/api/workbuddy/refresh-models", { method: "POST" })
+      .then(function (r) { return r.json(); })
+      .then(function (d) {
+        btn.textContent = d && typeof d.count === "number" ? d.count + "✓" : "✓";
+        btn.title = d && d.announced
+          ? "已刷新：" + d.count + " 个模型（模型选择器已更新）"
+          : "已刷新模型缓存（事件通知失败，重开设置页可见新列表）";
+        setTimeout(function () { btn.textContent = "🔄"; }, 2000);
+      })
+      .catch(function () {
+        btn.textContent = "🔄";
+        btn.title = "刷新失败（代理未运行？）";
+      })
+      .then(function () { delete btn.dataset.busy; });
+  }
+
   refresh();
   timer = setInterval(refresh, POLL_MS);
 }

package/lib/index.js

@@ -17,8 +17,8 @@
  * to a shipped static catalog when the proxy is not running.
  */
 import { spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, appendFileSync, openSync, truncateSync, writeSync, closeSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import z from "@deepseek-ai/schemastery";
 import {
@@ -62,6 +62,12 @@ const DEFAULT_CONTEXT_WINDOW = 200_000;
 /** Default per-request output-token cap. */
 const DEFAULT_MAX_TOKENS = 32_000;
 
+/** Usage ledger: one JSONL line per completed request, under DSH_HOME. */
+const USAGE_DIR_NAME = "llm-workbuddy";
+const USAGE_FILE_NAME = "usage.jsonl";
+/** Cap on how many historical lines the ledger keeps (avoid unbounded growth). */
+const USAGE_MAX_LINES = 20_000;
+
 /** Live `/v1/models` discovery cache window and request timeout. */
 const DISCOVERY_TTL_MS = 30_000;
 const DISCOVERY_TIMEOUT_MS = 2_000;
@@ -75,19 +81,15 @@ const DISCOVERY_TIMEOUT_MS = 2_000;
 const DEFAULT_MODELS = [
   { id: "deepseek-v4-pro", name: "Deepseek-V4-Pro", contextWindow: 1_000_000, maxTokens: 50_000, inputModalities: ["text", "image"], reasoningEffort: "high" },
   { id: "deepseek-v4-flash", name: "Deepseek-V4-Flash", contextWindow: 1_000_000, maxTokens: 50_000, inputModalities: ["text", "image"], reasoningEffort: "high" },
+  { id: "deepseek-v3-2-volc", name: "DeepSeek-V3.2", contextWindow: 96_000, maxTokens: 32_000, reasoningEffort: "medium" },
   { id: "glm-5.2", name: "GLM-5.2", contextWindow: 1_000_000, maxTokens: 48_000, inputModalities: ["text", "image"], reasoningEffort: "medium" },
   { id: "glm-5.1", name: "GLM-5.1", contextWindow: 200_000, maxTokens: 48_000, reasoningEffort: "medium" },
-  { id: "glm-5.0", name: "GLM-5.0", contextWindow: 200_000, maxTokens: 48_000, reasoningEffort: "high" },
-  { id: "glm-4.7", name: "GLM-4.7", contextWindow: 200_000, maxTokens: 48_000, reasoningEffort: "high" },
-  { id: "glm-4.6", name: "GLM-4.6", contextWindow: 168_000, maxTokens: 32_000, reasoningEffort: "high" },
   { id: "glm-5v-turbo", name: "GLM-5v-Turbo", contextWindow: 200_000, maxTokens: 64_000, inputModalities: ["text", "image"], reasoningEffort: "medium" },
   { id: "kimi-k3-1", name: "Kimi-K3", contextWindow: 1_000_000, maxTokens: 32_000, inputModalities: ["text", "image"], reasoningEffort: "medium" },
   { id: "kimi-k2.7", name: "Kimi-K2.7-Code", contextWindow: 256_000, maxTokens: 32_000, inputModalities: ["text", "image"], reasoningEffort: "medium" },
   { id: "kimi-k2.6", name: "Kimi-K2.6", contextWindow: 256_000, maxTokens: 32_000, inputModalities: ["text", "image"], reasoningEffort: "medium" },
   { id: "kimi-k2.5", name: "Kimi-K2.5", contextWindow: 164_000, maxTokens: 32_000, inputModalities: ["text", "image"], reasoningEffort: "medium" },
-  { id: "kimi-k2-thinking", name: "Kimi-K2-Thinking", contextWindow: 164_000, maxTokens: 32_000, reasoningEffort: "medium" },
   { id: "minimax-m3", name: "MiniMax-M3", contextWindow: 512_000, maxTokens: 128_000, inputModalities: ["text", "image"], reasoningEffort: "medium" },
-  { id: "minimax-m2.5", name: "MiniMax-M2.5", contextWindow: 200_000, maxTokens: 48_000, reasoningEffort: "medium" },
   { id: "hy3", name: "Hy3", contextWindow: 192_000, maxTokens: 64_000, inputModalities: ["text", "image"], reasoningEffort: "high" },
   { id: "hunyuan-2.0-thinking", name: "Hunyuan-2.0-Thinking", contextWindow: 128_000, maxTokens: 24_000, reasoningEffort: "medium" },
   { id: "hunyuan-chat", name: "Hunyuan-Turbos", contextWindow: 200_000, maxTokens: 8_192 },
@@ -143,6 +145,17 @@ function liveReasoningEffort(entry, catalogEffort) {
   return lower === "low" || lower === "medium" || lower === "high" ? lower : undefined;
 }
 
+/**
+ * Extract validated input modalities from a live `/v1/models` entry
+ * (`input_modalities`, codex format). Unknown or missing values degrade to
+ * text-only, matching the official catalog's conservative default.
+ */
+function liveInputModalities(entry) {
+  const mods = Array.isArray(entry?.input_modalities) ? entry.input_modalities : [];
+  const valid = mods.filter((modality) => modality === "text" || modality === "image");
+  return valid.length > 0 ? [...new Set(valid)] : ["text"];
+}
+
 
 // #region serialize
 
@@ -183,7 +196,10 @@ async function serializeMessages(messages, attachments, signal) {
     if (attachments === undefined) {
       throw new LlmError("WorkBuddy image input requires the durable attachment service", "UNSUPPORTED_CONTENT");
     }
-    const policy = { maxPixels: 4_000_000, maxBytes: 20_000_000 };
+    // Keep images small enough for the upstream platform: the proxy relays the
+    // base64 body verbatim, and oversized payloads are dropped/ignored upstream
+    // (models reply "no image attached"). Mirror the official adapter budgets.
+    const policy = { maxPixels: 2048 * 2048, maxBytes: 1024 * 1024 };
     const ordered = [...refs.values()];
     const prepared = await Promise.all(ordered.map((ref) => attachments.readImageRequest(ref, policy, signal)));
     for (let index = 0; index < ordered.length; index += 1) {
@@ -346,6 +362,94 @@ function mapUsage(usage) {
   };
 }
 
+// #region usage ledger
+
+/** Resolve the usage ledger file under DSH_HOME (falls back to ~/.dsh). */
+function usageLedgerPath() {
+  const configured = process.env.DSH_HOME;
+  if (configured !== undefined && configured.trim().length > 0) {
+    return join(configured, USAGE_DIR_NAME, USAGE_FILE_NAME);
+  }
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
+  return join(home, ".dsh", USAGE_DIR_NAME, USAGE_FILE_NAME);
+}
+
+/** Append one completed request's token usage to the ledger (best-effort). */
+function recordUsage(model, usage) {
+  if (usage === undefined) return;
+  try {
+    const file = usageLedgerPath();
+    mkdirSync(dirname(file), { recursive: true });
+    const line = JSON.stringify({
+      ts: Date.now(),
+      model,
+      input: usage.inputTokens ?? 0,
+      output: usage.outputTokens ?? 0,
+      cacheRead: usage.cacheReadTokens ?? 0,
+      reasoning: usage.reasoningTokens ?? 0,
+    });
+    appendFileSync(file, `${line}\n`);
+    // Trim the ledger when it exceeds the cap: keep only the newest lines.
+    const size = existsSync(file) ? readFileSync(file, "utf8").split("\n").filter(Boolean).length : 0;
+    if (size > USAGE_MAX_LINES) {
+      const lines = readFileSync(file, "utf8").split("\n").filter(Boolean).slice(-USAGE_MAX_LINES);
+      const fd = openSync(file, "w");
+      try { writeSync(fd, `${lines.join("\n")}\n`); } finally { closeSync(fd); }
+    }
+  } catch {
+    // usage recording must never break the request path
+  }
+}
+
+/** Read the ledger and aggregate into daily/model breakdowns. */
+function readUsageLedger() {
+  const file = usageLedgerPath();
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  const todayMs = today.getTime();
+  const byModel = new Map();
+  let todayInput = 0;
+  let todayOutput = 0;
+  let todayRequests = 0;
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalRequests = 0;
+  if (!existsSync(file)) {
+    return { today: { inputTokens: 0, outputTokens: 0, requests: 0 }, byModel: [], total: { inputTokens: 0, outputTokens: 0, requests: 0 } };
+  }
+  const lines = readFileSync(file, "utf8").split("\n").filter(Boolean);
+  for (const line of lines) {
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+    const input = entry.input ?? 0;
+    const output = entry.output ?? 0;
+    totalInput += input;
+    totalOutput += output;
+    totalRequests += 1;
+    if ((entry.ts ?? 0) >= todayMs) {
+      todayInput += input;
+      todayOutput += output;
+      todayRequests += 1;
+    }
+    const model = String(entry.model ?? "unknown");
+    const agg = byModel.get(model) ?? { inputTokens: 0, outputTokens: 0, requests: 0 };
+    agg.inputTokens += input;
+    agg.outputTokens += output;
+    agg.requests += 1;
+    byModel.set(model, agg);
+  }
+  const byModelList = [...byModel.entries()]
+    .map(([model, agg]) => ({ model, ...agg }))
+    .sort((a, b) => b.inputTokens + b.outputTokens - (a.inputTokens + a.outputTokens));
+  return {
+    today: { inputTokens: todayInput, outputTokens: todayOutput, requests: todayRequests },
+    byModel: byModelList,
+    total: { inputTokens: totalInput, outputTokens: totalOutput, requests: totalRequests },
+  };
+}
+
+// #endregion
+
 /** Assemble the final ContentBlock for one open block. */
 function closeBlock(block) {
   switch (block.kind) {
@@ -444,7 +548,9 @@ async function* translate(payloads) {
           argumentsDelta: fragment,
         };
       }
-      if (typeof choice.finish_reason === "string") pendingFinish = mapFinishReason(choice.finish_reason);
+      // Hy (Hunyuan) models emit `"finish_reason": ""` on every intermediate
+      // chunk; only treat a non-empty vocabulary value as the real finish.
+      if (typeof choice.finish_reason === "string" && choice.finish_reason.length > 0) pendingFinish = mapFinishReason(choice.finish_reason);
     }
     if (chunk.usage) pendingUsage = mapUsage(chunk.usage);
   }
@@ -516,6 +622,12 @@ export class WorkBuddyAdapter extends LlmAdapter {
     return { id: provider, name: "WorkBuddy" };
   }
 
+  /** Drop the discovery cache so the next listModels re-fetches from the proxy. */
+  refreshModels() {
+    this._cache = undefined;
+    this._liveMeta = undefined;
+  }
+
   async listModels(provider) {
     const connection = this.config.options();
     if (!connection.discovery) return connection.models.map((model) => modelInfo(provider, model));
@@ -545,24 +657,45 @@ export class WorkBuddyAdapter extends LlmAdapter {
             : typeof entry.display_name === "string"
               ? entry.display_name
               : undefined,
+          description: typeof entry.description === "string" && entry.description.length > 0
+            ? entry.description
+            : undefined,
+          modalities: liveInputModalities(entry),
+          contextWindow: Number.isInteger(entry.context_window) && entry.context_window > 0
+            ? entry.context_window
+            : undefined,
+          maxTokens: Number.isInteger(entry.max_context_window) && entry.max_context_window > 0
+            ? entry.max_context_window
+            : undefined,
         }))
         .filter((entry) => entry.id.length > 0);
       const merged = [];
       const seen = new Set();
+      const liveMeta = new Map();
       for (const entry of live) {
         if (seen.has(entry.id)) continue;
         seen.add(entry.id);
         const catalog = byId.get(entry.id);
+        // The static catalog doubles as a whitelist. The proxy still announces
+        // retired/legacy models (deepseek-v3-1, glm-4.6, glm-4.6v, kimi-k2,
+        // kimi-k2-thinking, minimax-m2.5, hunyuan-image-v3.0, ...) that the
+        // upstream rejects with `service info not found`. Drop any live entry
+        // that is not in the catalog so those never reach the UI; the catalog
+        // is the curated set that matches what the official client shows.
+        if (catalog === undefined) continue;
         const effort = liveReasoningEffort(entry, catalog?.reasoningEffort);
         const reasoning = modelReasoningInfo(effort);
         merged.push({
           provider,
           id: entry.id,
           name: entry.name ?? catalog?.name ?? entry.id,
-          ...(catalog?.description !== undefined ? { description: catalog.description } : {}),
-          inputModalities: catalog?.inputModalities ?? ["text"],
+          ...(catalog?.description !== undefined || entry.description !== undefined
+            ? { description: catalog?.description ?? entry.description }
+            : {}),
+          inputModalities: catalog?.inputModalities ?? entry.modalities,
           ...(reasoning === undefined ? {} : { reasoning }),
         });
+        liveMeta.set(entry.id, { contextWindow: entry.contextWindow, maxTokens: entry.maxTokens });
       }
       // Catalog entries the proxy did not announce (e.g. unauthenticated or
       // partial listing) stay selectable.
@@ -572,6 +705,7 @@ export class WorkBuddyAdapter extends LlmAdapter {
       }
       const result = merged.length > 0 ? merged : connection.models.map((model) => modelInfo(provider, model));
       this._cache = { at: now, models: result };
+      this._liveMeta = liveMeta;
       return result;
     } catch {
       return connection.models.map((model) => modelInfo(provider, model));
@@ -581,13 +715,18 @@ export class WorkBuddyAdapter extends LlmAdapter {
   resolveModel(provider, model, _signal) {
     const connection = this.config.options();
     const configured = connection.models.find((entry) => entry.id === model);
+    // Models discovered live (proxy-announced, not in the configured catalog)
+    // still get their platform-declared capacity from the last discovery.
+    const live = this._liveMeta?.get(model);
     const base = configured === undefined
       ? { provider, id: model, name: model, inputModalities: ["text"] }
       : modelInfo(provider, configured);
     return Promise.resolve({
       ...base,
-      context: { contextWindow: configured?.contextWindow ?? connection.defaultContextWindow },
-      defaultMaxTokens: configured?.maxTokens ?? connection.maxTokens,
+      context: {
+        contextWindow: configured?.contextWindow ?? live?.contextWindow ?? connection.defaultContextWindow,
+      },
+      defaultMaxTokens: configured?.maxTokens ?? live?.maxTokens ?? connection.maxTokens,
     });
   }
 
@@ -601,13 +740,16 @@ export class WorkBuddyAdapter extends LlmAdapter {
     );
     const iterator = this.request(options, watchdog.signal, connection, () => watchdog.pulse())[Symbol.asyncIterator]();
     let exhausted = false;
+    let usage;
     try {
       while (true) {
         const result = await watchdog.next(iterator);
         if (result.done) {
           exhausted = true;
+          if (usage !== undefined) recordUsage(options.model, usage);
           return;
         }
+        if (result.value?.type === "usage") usage = result.value.usage;
         yield result.value;
       }
     } catch (error) {
@@ -698,6 +840,10 @@ export const Config = z.object({
   models: z.array(catalogModel).default(DEFAULT_MODELS),
   streamIdleTimeoutMs: z.number().min(Number.MIN_VALUE).max(MAX_TIMER_DELAY_MS).default(DEFAULT_STREAM_IDLE_TIMEOUT_MS),
   discovery: z.boolean().default(true),
+  // Daily checkin: after `checkinAfterHour` local time, claim once per day if
+  // the official activity says today is unclaimed. Disable to check in manually.
+  autoCheckin: z.boolean().default(true),
+  checkinAfterHour: z.number().step(1).min(0).max(23).default(10),
   // Optional path overrides for the login helper. When unset, the plugin uses
   // the login_workbuddy.py bundled with this package and the default session
   // file location (~/.codebuddy-session.json).
@@ -760,6 +906,10 @@ export function resolveAdapterOptions(config) {
   if (!Number.isFinite(streamIdleTimeoutMs) || streamIdleTimeoutMs <= 0 || streamIdleTimeoutMs > MAX_TIMER_DELAY_MS) {
     throw new Error(`dsh-llm-workbuddy: streamIdleTimeoutMs must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
   }
+  const checkinAfterHour = config.checkinAfterHour ?? 10;
+  if (!Number.isInteger(checkinAfterHour) || checkinAfterHour < 0 || checkinAfterHour > 23) {
+    throw new Error("dsh-llm-workbuddy: checkinAfterHour must be an integer between 0 and 23");
+  }
   return {
     baseURL,
     apiKey: config.apiKey,
@@ -768,6 +918,8 @@ export function resolveAdapterOptions(config) {
     models: resolveModels(config.models),
     streamIdleTimeoutMs,
     discovery: config.discovery ?? true,
+    autoCheckin: config.autoCheckin ?? true,
+    checkinAfterHour,
     loginScript: config.loginScript,
     sessionFile: config.sessionFile,
   };
@@ -775,6 +927,176 @@ export function resolveAdapterOptions(config) {
 
 // #endregion
 
+// #region daily checkin
+
+/** Checkin state file under DSH_HOME (same ledger dir as usage). */
+const CHECKIN_FILE_NAME = "checkin.json";
+/** How often the auto-claim scheduler wakes up. */
+const CHECKIN_INTERVAL_MS = 30 * 60_000;
+/** Request timeout for the proxy checkin endpoints. */
+const CHECKIN_TIMEOUT_MS = 10_000;
+
+/** Resolve the checkin state file path (same convention as usageLedgerPath). */
+function checkinStatePath() {
+  const configured = process.env.DSH_HOME;
+  if (configured !== undefined && configured.trim().length > 0) {
+    return join(configured, USAGE_DIR_NAME, CHECKIN_FILE_NAME);
+  }
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
+  return join(home, ".dsh", USAGE_DIR_NAME, CHECKIN_FILE_NAME);
+}
+
+/** Read the persisted checkin state. Never throws. */
+function readCheckinState() {
+  try {
+    return JSON.parse(readFileSync(checkinStatePath(), "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+/** Persist the checkin state (best-effort; failure must not break the caller). */
+function writeCheckinState(state) {
+  try {
+    const file = checkinStatePath();
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`);
+  } catch {
+    // persistence is advisory
+  }
+}
+
+/** Local calendar date (`YYYY-MM-DD`) for "did we already handle today". */
+function localDateStr(date = new Date()) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+
+/**
+ * Call a proxy checkin endpoint. `method` defaults to GET (status probe);
+ * claiming passes "POST". Returns the parsed body or an error shape.
+ */
+async function proxyCheckinCall(baseURL, path, method = "GET") {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), CHECKIN_TIMEOUT_MS);
+  try {
+    const response = await fetch(`${baseURL.replace(/\/$/, "")}${path}`, {
+      method,
+      ...(method === "POST" ? { headers: { "content-type": "application/json" }, body: "{}" } : {}),
+      signal: controller.signal,
+    });
+    const body = await response.json().catch(() => null);
+    if (!response.ok) {
+      return { error: `HTTP ${response.status} (${method} ${path})`, ...(body ? { body } : {}) };
+    }
+    return body ?? { error: "empty response" };
+  } catch (error) {
+    return { error: String(error?.cause?.message ?? error?.message ?? error) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** Whether an upstream claim rejection means "already claimed today". */
+function alreadyClaimedMessage(msg) {
+  return typeof msg === "string" && /(已签到|已经签到|already)/i.test(msg);
+}
+
+/**
+ * Run one auto-claim pass. Idempotent per local calendar day:
+ * - before `checkinAfterHour` (default 10:00) local time: no-op;
+ * - already handled today (persisted state): no-op;
+ * - official status says already checked in: mark handled, done;
+ * - activity not open (no status data): mark handled so we stop retrying today;
+ * - otherwise claim, persisting the reward (credit, streak) on success.
+ * Concurrent invocations collapse into the first caller via `inFlight`.
+ * @returns the resulting state snapshot, or undefined when skipped/in-flight.
+ */
+async function runCheckinOnce(baseURL, config, logger) {
+  if (!config.autoCheckin) return undefined;
+  const now = new Date();
+  if (now.getHours() < config.checkinAfterHour) return undefined;
+  const today = localDateStr(now);
+  const state = readCheckinState();
+  if (state.handledDate === today) return state;
+  if (runCheckinOnce._inFlight) return undefined;
+  runCheckinOnce._inFlight = true;
+  try {
+    const status = await proxyCheckinCall(baseURL, "/checkin-status");
+    const data = status?.upstream?.data;
+    if (!data) {
+      // Activity closed / proxy unreachable / not authenticated: stop for today.
+      const next = {
+        ...state,
+        handledDate: today,
+        lastResult: { ok: false, message: status?.error ?? status?.upstream?.msg ?? "签到活动不可用", at: now.getTime() },
+      };
+      writeCheckinState(next);
+      logger?.debug?.(`dsh-llm-workbuddy: checkin skipped today (${next.lastResult.message})`);
+      return next;
+    }
+    if (data.today_checked_in) {
+      const next = {
+        ...state,
+        handledDate: today,
+        lastResult: { ok: true, message: "今日已签到（官方确认）", streakDays: data.streak_days, at: now.getTime() },
+      };
+      writeCheckinState(next);
+      return next;
+    }
+    const claim = await proxyCheckinCall(baseURL, "/checkin", "POST");
+    const payload = claim?.upstream?.data;
+    // "Already claimed" rejections count as handled (the goal is covered).
+    const ok = Boolean(payload) || alreadyClaimedMessage(claim?.upstream?.msg);
+    const failureDetail = [claim?.upstream?.msg, claim?.error, claim?.body?.detail]
+      .filter(Boolean).join(" ") || "签到失败";
+    const next = {
+      ...state,
+      handledDate: today,
+      lastResult: {
+        ok,
+        message: ok
+          ? payload?.credit !== undefined
+            ? `自动签到成功：+${payload.credit} 积分`
+            : "今日已签到"
+          : failureDetail,
+        ...(payload?.credit !== undefined ? { credit: payload.credit } : {}),
+        ...(payload?.streak_days !== undefined ? { streakDays: payload.streak_days } : {}),
+        at: now.getTime(),
+      },
+    };
+    writeCheckinState(next);
+    logger?.info?.(`dsh-llm-workbuddy: ${next.lastResult.message}`);
+    return next;
+  } finally {
+    runCheckinOnce._inFlight = false;
+  }
+}
+
+/**
+ * Start the auto-claim scheduler: one immediate pass plus a low-frequency
+ * interval. The interval survives plugin-lifetime only (disposed with the
+ * fiber), and every pass re-reads the live config so settings hot-edit
+ * (autoCheckin / checkinAfterHour) applies to the very next pass.
+ */
+function startCheckinScheduler(ctx, options) {
+  const tick = () => {
+    const connection = options();
+    runCheckinOnce(connection.baseURL, connection, ctx.logger).catch((error) => {
+      ctx.logger.warn("dsh-llm-workbuddy: auto checkin pass failed");
+      ctx.logger.warn(error);
+    });
+  };
+  tick();
+  const timer = setInterval(tick, CHECKIN_INTERVAL_MS);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}
+
+// #endregion
+
 // #region login status web API
 
 /**
@@ -944,14 +1266,18 @@ function diagnoseRestartCommand() {
 }
 
 /**
- * Register `GET /api/workbuddy/status`, `POST /api/workbuddy/login`, and
- * `POST /api/workbuddy/diagnose` on the DSH web server. The login route spawns
- * `login_workbuddy.py`, parses the device-flow `authUrl` it prints to stdout,
- * and returns it so the browser can open it in a new tab. The widget then
- * polls `/status` until the session file appears and reports
- * `authenticated: true`.
+ * Register the WorkBuddy web API routes on the DSH web server:
+ * - `GET  /api/workbuddy/status`         login/proxy health + checkin digest;
+ * - `POST /api/workbuddy/login`          device-flow login kick-off;
+ * - `POST /api/workbuddy/diagnose`       real end-to-end health probe;
+ * - `GET  /api/workbuddy/usage`          token usage ledger;
+ * - `POST /api/workbuddy/refresh-models` drop the discovery cache, re-read the
+ *   proxy model list (which tracks the official WorkBuddy app), and announce
+ *   `llm/adapters-updated` so open model pickers reload immediately;
+ * - `GET  /api/workbuddy/checkin`        today's checkin state (official query);
+ * - `POST /api/workbuddy/checkin`        claim now (idempotent upstream).
  */
-function registerWorkbuddyRoutes(ctx, config) {
+function registerWorkbuddyRoutes(ctx, config, adapter, providersHandle) {
   // Delay registration until the webServer service exists. The plugin keeps
   // `webServer` OUT of `inject` so headless profiles (no HTTP surface) still
   // load — but a synchronous `ctx.get("webServer")` probe at apply time races
@@ -979,11 +1305,20 @@ function registerWorkbuddyRoutes(ctx, config) {
         }
         const session = readSessionStatus(sessionFile);
         const proxy = await probeProxy(baseURL);
+        // Checkin digest comes from the persisted state only — never block the
+        // 5s status poll with an upstream call.
+        const checkinState = readCheckinState();
+        const today = localDateStr();
         res.writeHead(200, { "content-type": "application/json" });
         res.end(JSON.stringify({
           ...session,
           ...proxy,
           loginScriptAvailable: existsSync(loginScript),
+          checkin: {
+            autoEnabled: config?.autoCheckin ?? true,
+            handledToday: checkinState.handledDate === today,
+            lastResult: checkinState.lastResult ?? null,
+          },
         }));
       },
     }));
@@ -1054,6 +1389,101 @@ function registerWorkbuddyRoutes(ctx, config) {
         }));
       },
     }));
+    webCtx.effect(() => webServer.register({
+      kind: "exact",
+      path: "/api/workbuddy/usage",
+      async handler(req, res) {
+        if (req.method !== "GET") {
+          res.writeHead(405, { "content-type": "application/json" });
+          res.end(JSON.stringify({ error: "method not allowed" }));
+          return;
+        }
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify(readUsageLedger()));
+      },
+    }));
+    webCtx.effect(() => webServer.register({
+      kind: "exact",
+      path: "/api/workbuddy/refresh-models",
+      async handler(req, res) {
+        if (req.method !== "POST") {
+          res.writeHead(405, { "content-type": "application/json" });
+          res.end(JSON.stringify({ error: "method not allowed" }));
+          return;
+        }
+        // Drop the discovery cache so listModels re-reads the proxy, then
+        // re-commit the (unchanged) configurable-provider entries: commit is
+        // the one mutation point that publishes `llm/adapters-updated`, which
+        // makes every open model picker reload immediately.
+        adapter.refreshModels();
+        let announced = true;
+        try {
+          providersHandle?.replace?.([{ provider: PROVIDER, displayName: "WorkBuddy", settingsNs: NS, settingsPath: [] }]);
+        } catch (error) {
+          announced = false;
+          ctx.logger.warn("dsh-llm-workbuddy: failed to announce adapters-updated");
+          ctx.logger.warn(error);
+        }
+        const models = await adapter.listModels(PROVIDER).catch(() => []);
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ ok: true, announced, count: models.length, models }));
+      },
+    }));
+    webCtx.effect(() => webServer.register({
+      kind: "exact",
+      path: "/api/workbuddy/checkin",
+      async handler(req, res) {
+        // GET: today's persisted state plus a fresh official status probe.
+        if (req.method === "GET") {
+          const state = readCheckinState();
+          const upstream = await proxyCheckinCall(baseURL, "/checkin-status");
+          const data = upstream?.upstream?.data ?? null;
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(JSON.stringify({
+            handledToday: state.handledDate === localDateStr(),
+            lastResult: state.lastResult ?? null,
+            official: data === null ? null : {
+              active: Boolean(data.active),
+              todayCheckedIn: Boolean(data.today_checked_in),
+              streakDays: data.streak_days ?? null,
+              todayCredit: data.today_credit ?? null,
+              streakBonusDays: data.streak_bonus_days ?? null,
+              streakBonusCredit: data.streak_bonus_credit ?? null,
+            },
+            ...(upstream?.error ? { error: upstream.error } : {}),
+          }));
+          return;
+        }
+        // POST: claim now. Idempotent — upstream reports "already checked in"
+        // as a business result rather than an error.
+        if (req.method !== "POST") {
+          res.writeHead(405, { "content-type": "application/json" });
+          res.end(JSON.stringify({ error: "method not allowed" }));
+          return;
+        }
+        const claim = await proxyCheckinCall(baseURL, "/checkin", "POST");
+        const payload = claim?.upstream?.data;
+        const ok = Boolean(payload) || alreadyClaimedMessage(claim?.upstream?.msg);
+        const result = {
+          ok,
+          message: ok
+            ? payload?.credit !== undefined
+              ? `签到成功：+${payload.credit} 积分`
+              : "今日已签到"
+            : claim?.upstream?.msg ?? claim?.error ?? "签到失败",
+          ...(payload ?? {}),
+        };
+        if (ok || claim?.upstream?.msg) {
+          writeCheckinState({
+            ...readCheckinState(),
+            handledDate: ok ? localDateStr() : readCheckinState().handledDate,
+            lastResult: { ok, message: result.message, at: Date.now() },
+          });
+        }
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify(result));
+      },
+    }));
   });
 }
 
@@ -1100,14 +1530,15 @@ export function apply(ctx, config) {
     options,
     resolveAttachments: () => ctx.get("attachments"),
   });
-  ctx.llm.registerConfigurableProviders([{
+  const providersHandle = ctx.llm.registerConfigurableProviders([{
     provider: PROVIDER,
     displayName: "WorkBuddy",
     settingsNs: NS,
     settingsPath: [],
   }]);
   ctx.llm.registerAdapter([PROVIDER], adapter);
-  registerWorkbuddyRoutes(ctx, config);
+  registerWorkbuddyRoutes(ctx, config, adapter, providersHandle);
+  ctx.effect(() => startCheckinScheduler(ctx, options));
   installSettingsSection(ctx, NS, Config, config, {
     setSource: (source) => {
       current = source;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-llm-workbuddy",
-  "version": "0.1.9",
+  "version": "0.1.12",
   "description": "WorkBuddy (via the local workbuddy2api proxy) LLM provider adapter for DeepSeek Harness, with a Web login-status widget",
   "type": "module",
   "main": "lib/index.js",