dsh-task-ledger 0.0.112 → 0.0.114

package/dist/host/errors.d.ts

@@ -20,7 +20,7 @@ export interface DegradedInfo {
     readonly workspaceId: string;
     readonly workspaceTitle: string;
     /** 哪个读挂了——trend 同时读 list + history，必须能区分。 */
-    readonly op: "list" | "history";
+    readonly op: "list" | "history" | "owners";
     readonly code: LedgerErrorCode;
     /** 人话，可直接上界面（真源：脚本 stderr / records 校验文案）。 */
     readonly message: string;
@@ -36,7 +36,7 @@ export declare function messageOf(error: unknown): string;
 export declare function settleWorkspaces<W extends {
     id: string;
     title: string;
-}, T, R>(workspaces: readonly W[], op: "list" | "history", read: (workspace: W) => Promise<T>, merge: (rows: readonly T[]) => R): Promise<{
+}, T, R>(workspaces: readonly W[], op: "list" | "history" | "owners", read: (workspace: W) => Promise<T>, merge: (rows: readonly T[]) => R): Promise<{
     data: R;
     degraded: readonly DegradedInfo[];
 }>;

package/dist/host/repositories/cache.d.ts

@@ -5,14 +5,13 @@
  * ② 命中且 1.5s 内直接返回、**不起进程**；同 key 并发**单飞**（只跑一次脚本，其余等同一个 Promise）；
  * ③ `fresh=1` 绕过（路由层先 `invalidate()` 再算）；写路径成功后 `invalidate(workspaceId)` 钩子。
  *
- * 边界：只缓存 skill 脚本的两读（在办 list / 历史 history）。worklog 正文不缓存——它会被
- * 会话里的 Agent 实时改写，缓存 1.5s 也会让用户看到上一版。**失败不入缓存**（错就是错，重试要能重新跑）。
+ * 边界：只缓存 skill 脚本的读命令结果。**失败不入缓存**（错就是错，重试要能重新跑）。
  * 命中返回的是**同一个引用**：调用方只许读（上层 service 全是纯计算，不原地改数组）。
  */
 /** 缓存有效期（2026-10-18 拍板 1.5s：够挡同一屏的重复读，短到不会让人看到旧数据）。 */
 export declare const CACHE_TTL_MS = 1500;
 /** 缓存的操作种类（= skill 脚本子命令；worklog 不进缓存故不在此列）。 */
-export type CacheOp = "list" | "history";
+export type CacheOp = "list" | "history" | "stats" | "owners";
 /** 缓存键：`op:workspace:filter` 三条信息都要，否则不同筛选 / 不同工作区会串味。 */
 export declare function cacheKey(workspaceId: string, op: CacheOp, detail: string): string;
 /**

package/dist/host/repositories/cache.js

@@ -5,8 +5,7 @@
  * ② 命中且 1.5s 内直接返回、**不起进程**；同 key 并发**单飞**（只跑一次脚本，其余等同一个 Promise）；
  * ③ `fresh=1` 绕过（路由层先 `invalidate()` 再算）；写路径成功后 `invalidate(workspaceId)` 钩子。
  *
- * 边界：只缓存 skill 脚本的两读（在办 list / 历史 history）。worklog 正文不缓存——它会被
- * 会话里的 Agent 实时改写，缓存 1.5s 也会让用户看到上一版。**失败不入缓存**（错就是错，重试要能重新跑）。
+ * 边界：只缓存 skill 脚本的读命令结果。**失败不入缓存**（错就是错，重试要能重新跑）。
  * 命中返回的是**同一个引用**：调用方只许读（上层 service 全是纯计算，不原地改数组）。
  */
 /** 缓存有效期（2026-10-18 拍板 1.5s：够挡同一屏的重复读，短到不会让人看到旧数据）。 */

package/dist/host/repositories/identity.repository.d.ts

@@ -1,4 +1,10 @@
 import type { LedgerWorkspace } from "../types.js";
-/** 机器级身份文件路径（与 skill 侧 `env.identity_file()` 同一口径）。 */
-export declare function identityPath(): string;
+/**
+ * 本机身份 uuid —— 走 skill `whoami --json`（**不再自己读 identity.json**：
+ * `$TASK_LEDGER_HOME` / 默认目录 / 文件格式都是 skill 的知识，插件不复制第二份）。
+ *
+ * **只取 `uuid`**：`name` 是冗余显示字段，不参与任何判定（按名字比 owner 永远比不到）。
+ * 未初始化时 skill 回 `{"uuid":null}`（退 0），这里同样回 null ⇒ 「我的」按 0 计（不谎报）。
+ * 程序起不来看不出身份，也只回 null。
+ */
 export declare function getCurrentIdentity(_workspace?: LedgerWorkspace): Promise<string | null>;

package/dist/host/repositories/identity.repository.js

@@ -1,36 +1,16 @@
-import { readFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
+import { runLedgerScript } from "./runner.js";
 /**
- * 本机身份 uuid —— 「我的待办 / 我的结案」判定的**唯一**来源。
- *
- * 身份是**机器级**的：skill 的 `init` 把 `{uuid, name}` 写进
- * `$TASK_LEDGER_HOME/.taskledger/identity.json`（默认 `~/.taskledger/identity.json`），
- * 与工作区、git 配置都无关；任务与历史里的 `owner` / `creator` 存的正是这个 uuid。
- * 参数保留是为了与其它 per-workspace 读法同形（同一个 uuid 对所有工作区都成立）。
+ * 本机身份 uuid —— 走 skill `whoami --json`（**不再自己读 identity.json**：
+ * `$TASK_LEDGER_HOME` / 默认目录 / 文件格式都是 skill 的知识，插件不复制第二份）。
  *
  * **只取 `uuid`**：`name` 是冗余显示字段，不参与任何判定（按名字比 owner 永远比不到）。
- * 读不到回 null（没 init / 文件坏 / 没 home 目录），该工作区的「我的」统计按 0 计（不谎报）。
+ * 未初始化时 skill 回 `{"uuid":null}`（退 0），这里同样回 null ⇒ 「我的」按 0 计（不谎报）。
+ * 程序起不来看不出身份，也只回 null。
  */
-const IDENTITY_HOME_ENV = "TASK_LEDGER_HOME";
-/** 机器级身份文件路径（与 skill 侧 `env.identity_file()` 同一口径）。 */
-export function identityPath() {
-    const base = process.env[IDENTITY_HOME_ENV];
-    // 空串按「没设」处理：否则 path.join("", …) 会变成跟着 host 进程 cwd 走的相对路径，
-    // 与脚本侧 `if base: … else Path.home()` 的口径就对不上了
-    const dir = base !== undefined && base.trim() !== "" ? base : os.homedir();
-    return path.join(dir, ".taskledger", "identity.json");
-}
 export async function getCurrentIdentity(_workspace) {
-    try {
-        const raw = await readFile(identityPath(), "utf-8");
-        const data = JSON.parse(raw);
-        const uuid = data !== null && typeof data === "object"
-            ? String(data.uuid ?? "").trim()
-            : "";
-        return uuid === "" ? null : uuid.toLowerCase();
-    }
-    catch {
+    const result = await runLedgerScript("whoami", ["--json"]);
+    if (!result.ok)
         return null;
-    }
+    const uuid = typeof result.data.uuid === "string" ? result.data.uuid.trim() : "";
+    return uuid === "" ? null : uuid.toLowerCase();
 }

package/dist/host/repositories/ledger.repository.d.ts

@@ -1,18 +1,18 @@
-import type { HistoryRecord, LedgerFilter, LedgerWorkspace, TaskRow } from "../types.js";
+import type { LedgerFilter, LedgerWorkspace, TaskRow, WorkspaceOwners } from "../types.js";
 /**
  * LedgerFilter → skill 脚本参数（只拼调用方给了的；undefined 一律不拼，
  * 让脚本走自己的默认——插件不替脚本决定默认值）。
- *
- * **按子命令裁参数**：`list` 不认 `--limit` / `--months`，`history` 不认 `--status`，
- * 拼错一个就让 argparse 退 2、整块列表 500。口径以 `skill/shell/cli.py` 为准。
+ * 参数名以 `skill/shell/cli.go` 的 `list` 白名单为准，拼错一个就让 argparse 退 2、整块列表 500。
  */
-export declare function filterArgs(filter: LedgerFilter, sub: "list" | "history"): string[];
+export declare function filterArgs(filter: LedgerFilter): string[];
 /**
- * 台账工作区探测：`<path>/ledger/pool.json` 在才算（分片布局的初始化标志；
- * 未初始化 = 后端不可见，2026-10-17 拍板）。全 host 对台账目录的 IO 只在本文件
- * ——别处再写 existsSync 即为分层倒退。
+ * 台账工作区探测：走 skill `root --json`（判据是「这个目录直接含 `ledger/`」，
+ * 与脚本定位工作区根同一口径；有没有 `pool.json` 不影响）。
+ *
+ * 曾经的 `<path>/ledger/pool.json` 直查已废——布局知识只留 skill 一份。
+ * 程序起不来时抛错（不静默把工作区藏掉）。
  */
-export declare function hasLedger(workspacePath: string): boolean;
+export declare function hasLedger(workspacePath: string): Promise<boolean>;
 /**
  * 在办任务（包 `list --json`；结果过 records 入口校验后打上 workspace）。
  * 脚本失败 / 形状不符抛错——由 service 层捕获进 degraded，路由层转 500 + 人话，
@@ -20,17 +20,7 @@ export declare function hasLedger(workspacePath: string): boolean;
  */
 export declare function readTasks(workspace: LedgerWorkspace, filter?: LedgerFilter): Promise<TaskRow[]>;
 /**
- * 已结案记录（包 `history --json`；`records` 必须存在且为数组，缺了即坏数据）。同样过读缓存。
- * 一并带回 `warnings`（被脚本整行跳过的坏行原因）——调用方必须展示，不许吞。
- */
-export declare function readHistory(workspace: LedgerWorkspace, filter?: LedgerFilter): Promise<{
-    records: HistoryRecord[];
-    warnings: string[];
-}>;
-/** 单条在办（展开行 / 详情用）。取不到回 null，不抛。 */
-export declare function getTask(workspace: LedgerWorkspace, taskId: string): Promise<TaskRow | null>;
-/**
- * 过程文档正文（`task.worklog` 相对 `ledger/` 的路径）。
- * 读不到回 null（文件被清 / 路径坏都不炸——由调用方展示「过程文档缺失」）。
+ * 工作区花名册（skill `owners --json`，只读、不改台账）。跨工作区由 service 扇出。
+ * 名册为空的工作区脚本会报错 ⇒ settle 收进 degraded，本工作区分组自然不出现。
  */
-export declare function readWorklog(workspace: LedgerWorkspace, task: TaskRow): Promise<string | null>;
+export declare function readOwners(workspace: LedgerWorkspace): Promise<WorkspaceOwners>;

package/dist/host/repositories/ledger.repository.js

@@ -1,21 +1,14 @@
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
 import { cached, cacheKey } from "./cache.js";
-import { parseHistoryRecords, parseTaskList } from "./records.js";
+import { parseTaskList } from "./records.js";
 import { runLedgerScript } from "./runner.js";
-/** 台账目录名（各工作区根下的这一个目录；布局知识只在本文件出现一次）。 */
-const LEDGER_DIR = "ledger";
 /**
  * LedgerFilter → skill 脚本参数（只拼调用方给了的；undefined 一律不拼，
  * 让脚本走自己的默认——插件不替脚本决定默认值）。
- *
- * **按子命令裁参数**：`list` 不认 `--limit` / `--months`，`history` 不认 `--status`，
- * 拼错一个就让 argparse 退 2、整块列表 500。口径以 `skill/shell/cli.py` 为准。
+ * 参数名以 `skill/shell/cli.go` 的 `list` 白名单为准，拼错一个就让 argparse 退 2、整块列表 500。
  */
-export function filterArgs(filter, sub) {
+export function filterArgs(filter) {
     const args = [];
-    if (sub === "list" && filter.status !== undefined)
+    if (filter.status !== undefined)
         args.push("--status", filter.status);
     // 身份只收 uuid（脚本同样口径）；按名字模糊筛走 --owner-name
     if (filter.owner !== undefined)
@@ -30,22 +23,24 @@ export function filterArgs(filter, sub) {
         args.push("--since", filter.since);
     if (filter.until !== undefined)
         args.push("--until", filter.until);
-    if (sub === "history") {
-        if (filter.limit !== undefined)
-            args.push("--limit", String(filter.limit));
-        if (filter.months !== undefined)
-            args.push("--months", String(filter.months));
-    }
     return args;
 }
 /**
- * 台账工作区探测：`<path>/ledger/pool.json` 在才算（分片布局的初始化标志；
- * 未初始化 = 后端不可见，2026-10-17 拍板）。全 host 对台账目录的 IO 只在本文件
- * ——别处再写 existsSync 即为分层倒退。
+ * 台账工作区探测：走 skill `root --json`（判据是「这个目录直接含 `ledger/`」，
+ * 与脚本定位工作区根同一口径；有没有 `pool.json` 不影响）。
+ *
+ * 曾经的 `<path>/ledger/pool.json` 直查已废——布局知识只留 skill 一份。
+ * 程序起不来时抛错（不静默把工作区藏掉）。
  */
-export function hasLedger(workspacePath) {
-    // 分片布局（2026-10-23）：公共池 pool.json 在才算初始化；各人分片 owners/*.json 由脚本维护。
-    return existsSync(path.join(workspacePath, LEDGER_DIR, "pool.json"));
+export async function hasLedger(workspacePath) {
+    const result = await runLedgerScript("root", [
+        "--dir",
+        workspacePath,
+        "--json",
+    ]);
+    if (!result.ok)
+        throw new Error(`台账根检测失败（${workspacePath}）：${result.error}`);
+    return result.data.root === true;
 }
 /**
  * 在办任务（包 `list --json`；结果过 records 入口校验后打上 workspace）。
@@ -53,12 +48,12 @@ export function hasLedger(workspacePath) {
  * 不静默返空（空 = 撒谎）。**过 1.5s 读缓存**（同屏多端点会反复读同一份在办）。
  */
 export async function readTasks(workspace, filter = {}) {
-    return await cached(cacheKey(workspace.id, "list", argsKey(filter, "list")), async () => {
+    return await cached(cacheKey(workspace.id, "list", argsKey(filter)), async () => {
         const result = await runLedgerScript("list", [
             "--repo",
             workspace.path,
             "--json",
-            ...filterArgs(filter, "list"),
+            ...filterArgs(filter),
         ]);
         if (!result.ok)
             throw new Error(`${workspace.title}: ${result.error}`);
@@ -66,43 +61,29 @@ export async function readTasks(workspace, filter = {}) {
     });
 }
 /**
- * 已结案记录（包 `history --json`；`records` 必须存在且为数组，缺了即坏数据）。同样过读缓存。
- * 一并带回 `warnings`（被脚本整行跳过的坏行原因）——调用方必须展示，不许吞。
+ * 工作区花名册（skill `owners --json`，只读、不改台账）。跨工作区由 service 扇出。
+ * 名册为空的工作区脚本会报错 ⇒ settle 收进 degraded，本工作区分组自然不出现。
  */
-export async function readHistory(workspace, filter = {}) {
-    return await cached(cacheKey(workspace.id, "history", argsKey(filter, "history")), async () => {
-        const result = await runLedgerScript("history", [
-            "--repo",
-            workspace.path,
-            "--json",
-            ...filterArgs(filter, "history"),
-        ]);
+export async function readOwners(workspace) {
+    return await cached(cacheKey(workspace.id, "owners", ""), async () => {
+        const result = await runLedgerScript("owners", ["--repo", workspace.path, "--json"]);
         if (!result.ok)
             throw new Error(`${workspace.title}: ${result.error}`);
-        return parseHistoryRecords(result.data, workspace);
+        const owners = Object.entries(result.data.owners ?? {}).map(([uuid, value]) => ({
+            uuid,
+            name: typeof value.name === "string" && value.name.trim() !== ""
+                ? value.name
+                : uuid,
+            mine: value.mine === true,
+        }));
+        return {
+            workspaceId: workspace.id,
+            workspaceTitle: workspace.title,
+            owners,
+        };
     });
 }
 /** 缓存键的 filter 段：脚本参数原样序列化（分隔符取不可见字符，值里带空格也不会串）。 */
-function argsKey(filter, sub) {
-    return filterArgs(filter, sub).join("\u0001");
-}
-/** 单条在办（展开行 / 详情用）。取不到回 null，不抛。 */
-export async function getTask(workspace, taskId) {
-    const rows = await readTasks(workspace);
-    return rows.find((row) => row.id === taskId) ?? null;
-}
-/**
- * 过程文档正文（`task.worklog` 相对 `ledger/` 的路径）。
- * 读不到回 null（文件被清 / 路径坏都不炸——由调用方展示「过程文档缺失」）。
- */
-export async function readWorklog(workspace, task) {
-    const relative = task.worklog;
-    if (relative === undefined || relative === null || relative === "")
-        return null;
-    try {
-        return await readFile(path.join(workspace.path, LEDGER_DIR, relative), "utf-8");
-    }
-    catch {
-        return null;
-    }
+function argsKey(filter) {
+    return filterArgs(filter).join("\u0001");
 }

package/dist/host/repositories/records.d.ts

@@ -1,13 +1,3 @@
-import type { HistoryRecord, LedgerWorkspace, TaskRow } from "../types.js";
+import type { LedgerWorkspace, TaskRow } from "../types.js";
 /** `list --json`（任务号为键的对象）→ TaskRow[]（打上 id 与 workspace）。 */
 export declare function parseTaskList(raw: unknown, workspace: LedgerWorkspace): TaskRow[];
-/**
- * `history --json`（`{count, filters, records, warnings}`）→ 记录 + 脚本警告（都打上 workspace）。
- *
- * ⚠️ `warnings` **必须带出去**：脚本只认十一列历史，列数不对 / 时间不合法的行会被
- * **整行跳过**（不是少几个字段）。丢掉 warnings 就是「趋势图少算一截还装作没发生」。
- */
-export declare function parseHistoryRecords(raw: unknown, workspace: LedgerWorkspace): {
-    records: HistoryRecord[];
-    warnings: string[];
-};

package/dist/host/repositories/records.js

@@ -2,10 +2,8 @@
  * 入口校验（纯函数）：skill 脚本 JSON → 领域对象。
  *
  * 口径：**容器级严格、元素级宽松**。
- * - 容器：`list --json` 顶层必须是 plain object（任务号为键）；`history --json` 的 `records`
- *   必须存在且为数组（现状 `records ?? []` 的容忍在脚本回归时会静默产出空历史 = 撒谎）；
- * - 元素：是 object 就收，字段缺失一律放行（TaskRecord 全字段可选是脚本既有契约，
- *   旧 8 列 history 不因此被误杀）。
+ * - 容器：`list --json` 顶层必须是 plain object（任务号为键）；
+ * - 元素：是 object 就收，字段缺失一律放行（TaskRecord 全字段可选是脚本既有契约）。
  * 失败抛 {@link LedgerDataError}——由 service 层捕获进 degraded，不静默。
  */
 import { LedgerDataError } from "../errors.js";
@@ -25,52 +23,28 @@ export function parseTaskList(raw, workspace) {
         if (id === "") {
             throw new LedgerDataError(workspace.id, `${workspace.title}: 台账存在空任务号，格式可能已变`);
         }
-        rows.push({ ...value, id, workspace });
+        rows.push(toTaskRow(value, id, workspace));
     }
     return rows;
 }
 /**
- * `history --json`（`{count, filters, records, warnings}`）→ 记录 + 脚本警告（都打上 workspace）。
+ * 脚本的 snake_case 派生字段 → 领域 camelCase。
  *
- * ⚠️ `warnings` **必须带出去**：脚本只认十一列历史，列数不对 / 时间不合法的行会被
- * **整行跳过**（不是少几个字段）。丢掉 warnings 就是「趋势图少算一截还装作没发生」。
+ * `stale` / `overdue` / `backlog` / `mine` 与三个天数**都是 skill 算好的**（阈值判定、
+ * 身份比较都在脚本侧），插件只搬字段，不重算一遍。缺字段一律 null / false（不编 0）。
  */
-export function parseHistoryRecords(raw, workspace) {
-    if (!isPlainObject(raw)) {
-        throw new LedgerDataError(workspace.id, `${workspace.title}: 台账 history 输出不是对象，拒绝当成空历史`);
-    }
-    const records = raw.records;
-    if (!Array.isArray(records)) {
-        throw new LedgerDataError(workspace.id, `${workspace.title}: 台账 history 输出缺 records 数组，格式可能已变`);
-    }
-    const rows = [];
-    for (const record of records) {
-        if (!isPlainObject(record))
-            continue; // 元素级宽松：坏行跳过，不整板炸
-        rows.push(toHistoryRecord(record, workspace));
-    }
-    const rawWarnings = raw.warnings;
-    const warnings = Array.isArray(rawWarnings)
-        ? rawWarnings.filter((item) => typeof item === "string")
-        : [];
-    return { records: rows, warnings };
-}
-/**
- * 脚本 9 列的键 → 领域字段名。
- *
- * 脚本（`history --json`）吐的是**列名**：`finished` / `title` / `worklog`；
- * 领域层用的是 `time` / `workpackage` / `log`。两个名字都得能用：
- * 不映射的话结案时间会落到 `created`、标题落到摘要、趋势图的「完成数」恒 0（`dayOf(undefined)`）。
- * 两边都给：脚本将来改回列名以外的实现也不会炸。
- */
-function toHistoryRecord(source, workspace) {
-    const text = (value) => typeof value === "string" && value !== "" ? value : undefined;
+function toTaskRow(source, id, workspace) {
+    const days = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
     return {
         ...source,
-        // 脚本里的列名是真源；领域字段名作为兼容保留
-        time: text(source.finished) ?? text(source.time),
-        workpackage: text(source.title) ?? text(source.workpackage),
-        log: text(source.worklog) ?? text(source.log),
+        id,
         workspace,
+        ageDays: days(source.age_days),
+        idleDays: days(source.idle_days),
+        waitingDays: days(source.waiting_days),
+        stale: source.stale === true,
+        overdue: source.overdue === true,
+        backlog: source.backlog === true,
+        mine: source.mine === true,
     };
 }

package/dist/host/repositories/runner.d.ts

@@ -1,10 +1,3 @@
-/**
- * 写命令的超时上限（ms）：脚本每条 git 调用各自 30s 超时，写前（fetch / ff / push /
- * rebase / push）与写后（push / fetch / rebase / push）串起来最坏约 270s。
- * 低到 120s 会在网络挂死时先报「超时失败」——台账其实已写入，用户一重试就是二次写入。
- * 180s 覆盖常见最坏组合，又不至于让真卡死的请求占着界面太久。
- */
-export declare const WRITE_TIMEOUT_MS = 180000;
 export type LedgerScriptResult<T> = {
     ok: true;
     data: T;
@@ -12,28 +5,11 @@ export type LedgerScriptResult<T> = {
     ok: false;
     error: string;
 };
-/**
- * 写命令的返回：stdout 原文（claim / set 打的是人话，不是 JSON）+ 退出码 0 时的 stderr。
- * `notice` 有值说明脚本写成功了、但同步（commit / push）没成功 —— 不能当失败抛，也不能吞掉。
- */
-export type LedgerCommandResult = {
-    ok: true;
-    output: string;
-    notice?: string;
-} | {
-    ok: false;
-    error: string;
-};
 export interface RunOptions {
     /** 测试用：覆盖脚本路径。 */
     scriptPath?: string;
     /** 覆盖超时。 */
     timeoutMs?: number;
-    /**
-     * 子进程 cwd。写命令（claim / set）必须落在工作区：
-     * 脚本按 cwd 逐级往上找 `ledger/`（或靠 `--repo` 指定），与身份无关。
-     */
-    cwd?: string;
 }
 /**
  * 读命令：跑内嵌台账程序，收 stdout JSON。
@@ -43,11 +19,5 @@ export interface RunOptions {
  * @param args - 参数数组，由调用方自拼（含 --repo / --json / --months 等）
  * @param opts.scriptPath - 测试用：覆盖脚本路径
  * @param opts.timeoutMs - 覆盖超时
- * @param opts.cwd - 子进程工作目录（写命令按 cwd 定位台账用）
  */
 export declare function runLedgerScript<T = unknown>(sub: string, args: readonly string[], opts?: RunOptions): Promise<LedgerScriptResult<T>>;
-/**
- * 写命令（claim / set）：同样是 spawn 入口脚本，但**不解析 JSON**——这些子命令打的是人话，
- * 成功与否看退出码，失败时 stderr 就是能直接上界面的人话。
- */
-export declare function runLedgerCommand(sub: string, args: readonly string[], opts?: RunOptions): Promise<LedgerCommandResult>;

package/dist/host/repositories/runner.js

@@ -11,13 +11,6 @@ import { fileURLToPath } from "node:url";
 const DEFAULT_SCRIPT_PATH = fileURLToPath(new URL("../../../skill/scripts/progress", import.meta.url));
 /** 单次脚本调用超时上限（ms）。实测单仓 5 万行全量 1.2s，10s 是宽松上限。 */
 const DEFAULT_TIMEOUT_MS = 10_000;
-/**
- * 写命令的超时上限（ms）：脚本每条 git 调用各自 30s 超时，写前（fetch / ff / push /
- * rebase / push）与写后（push / fetch / rebase / push）串起来最坏约 270s。
- * 低到 120s 会在网络挂死时先报「超时失败」——台账其实已写入，用户一重试就是二次写入。
- * 180s 覆盖常见最坏组合，又不至于让真卡死的请求占着界面太久。
- */
-export const WRITE_TIMEOUT_MS = 180_000;
 /**
  * 起一次台账程序、收 stdout / stderr。出错一律归一成人话（起不了程序 / 超时 / 非零退出）。
  * 解析留给调用方：读命令要 JSON，写命令要原文。
@@ -27,7 +20,6 @@ function exec(sub, args, opts) {
     const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     return new Promise((resolve) => {
         const child = spawn(scriptPath, [sub, ...args], {
-            cwd: opts?.cwd,
             stdio: ["ignore", "pipe", "pipe"],
         });
         let stdout = "";
@@ -79,7 +71,6 @@ function exec(sub, args, opts) {
  * @param args - 参数数组，由调用方自拼（含 --repo / --json / --months 等）
  * @param opts.scriptPath - 测试用：覆盖脚本路径
  * @param opts.timeoutMs - 覆盖超时
- * @param opts.cwd - 子进程工作目录（写命令按 cwd 定位台账用）
  */
 export async function runLedgerScript(sub, args, opts) {
     const result = await exec(sub, args, opts);
@@ -95,17 +86,3 @@ export async function runLedgerScript(sub, args, opts) {
         };
     }
 }
-/**
- * 写命令（claim / set）：同样是 spawn 入口脚本，但**不解析 JSON**——这些子命令打的是人话，
- * 成功与否看退出码，失败时 stderr 就是能直接上界面的人话。
- */
-export async function runLedgerCommand(sub, args, opts) {
-    const result = await exec(sub, args, opts);
-    if (!result.ok)
-        return result;
-    const output = result.stdout.trim();
-    // 退出码 0 但 stderr 有字 = 写成功、同步失败（台账程序的既定行为），必须带出去
-    return result.stderr
-        ? { ok: true, output, notice: result.stderr }
-        : { ok: true, output };
-}

package/dist/host/repositories/stats.repository.d.ts

@@ -0,0 +1,36 @@
+import type { LedgerWorkspace } from "../types.js";
+/** `stats --json` 的领域投影（只收界面用到的面）。 */
+export interface WorkspaceStats {
+    readonly total: number;
+    readonly open: number;
+    readonly doing: number;
+    readonly stale: number;
+    readonly overdue: number;
+    readonly backlog: number;
+    readonly mine: number;
+    readonly myDoing: number;
+    readonly myStale: number;
+    readonly myOverdue: number;
+    readonly oldestOpenDays: number | null;
+    readonly staleDays: number;
+    readonly overdueDays: number;
+    readonly backlogDays: number;
+}
+/** 一个时间窗口内的结案数（`history --count-only`）。 */
+export interface ClosedCount {
+    readonly count: number;
+    /** count 到了 skill 的封顶（10000）⇒ 真实值只多不少。 */
+    readonly capped: boolean;
+}
+/** 单工作区在办统计（skill `stats --json`；过 1.5s 读缓存，同屏多端点复用）。 */
+export declare function readStats(workspace: LedgerWorkspace): Promise<WorkspaceStats>;
+/** `stats --json` → {@link WorkspaceStats}（容器级严格：缺字段即坏，不当 0）。 */
+export declare function parseStats(raw: unknown, where: string): WorkspaceStats;
+/**
+ * 一个时间窗口内结案了多少条（skill `history --count-only`）。
+ * 区间写进缓存键：本周 / 上周两个窗口各算一次，别互相串味。
+ */
+export declare function countClosed(workspace: LedgerWorkspace, window: {
+    readonly from: string;
+    readonly to: string;
+}): Promise<ClosedCount>;

package/dist/host/repositories/stats.repository.js

@@ -0,0 +1,86 @@
+/**
+ * 统计面取数：8 个卡片的数字**全部**来自 skill 方法，插件不自己数。
+ *
+ * - 在办各面（待认领 / 进行中 / 积压 / 逾期 / 停滞 / 我的）→ `stats --json`；
+ *   阈值、mine 判定、最老待认领天数都由 skill 算好回显。
+ * - 本周 / 上周完成 → `history --count-only`（结案时间落在区间内；区间界线由插件算，日期窗口归插件）。
+ *
+ * 形状不符一律抛 {@link LedgerDataError}（不拿 0 充数）。
+ */
+import { LedgerDataError } from "../errors.js";
+import { cached, cacheKey } from "./cache.js";
+import { runLedgerScript } from "./runner.js";
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function num(source, key, where) {
+    const value = source[key];
+    if (typeof value !== "number" || !Number.isFinite(value))
+        throw new LedgerDataError(where, `${where}: stats 输出缺少数字字段 ${key}，格式可能已变`);
+    return value;
+}
+/** 单工作区在办统计（skill `stats --json`；过 1.5s 读缓存，同屏多端点复用）。 */
+export async function readStats(workspace) {
+    return await cached(cacheKey(workspace.id, "stats", ""), async () => {
+        const result = await runLedgerScript("stats", [
+            "--repo",
+            workspace.path,
+            "--json",
+        ]);
+        if (!result.ok)
+            throw new Error(`${workspace.title}: ${result.error}`);
+        return parseStats(result.data, workspace.title);
+    });
+}
+/** `stats --json` → {@link WorkspaceStats}（容器级严格：缺字段即坏，不当 0）。 */
+export function parseStats(raw, where) {
+    if (!isPlainObject(raw))
+        throw new LedgerDataError(where, `${where}: stats 输出不是对象，格式可能已变`);
+    const thresholds = raw.thresholds;
+    if (!isPlainObject(thresholds))
+        throw new LedgerDataError(where, `${where}: stats 输出缺 thresholds，阈值不许由插件硬编码`);
+    const oldest = raw.oldest_open_days;
+    if (oldest !== null && typeof oldest !== "number")
+        throw new LedgerDataError(where, `${where}: stats 的 oldest_open_days 既不是数字也不是 null`);
+    return {
+        total: num(raw, "total", where),
+        open: num(raw, "open", where),
+        doing: num(raw, "doing", where),
+        stale: num(raw, "stale", where),
+        overdue: num(raw, "overdue", where),
+        backlog: num(raw, "backlog", where),
+        mine: num(raw, "mine", where),
+        myDoing: num(raw, "my_doing", where),
+        myStale: num(raw, "my_stale", where),
+        myOverdue: num(raw, "my_overdue", where),
+        oldestOpenDays: oldest,
+        staleDays: num(thresholds, "stale_days", where),
+        overdueDays: num(thresholds, "overdue_days", where),
+        backlogDays: num(thresholds, "backlog_days", where),
+    };
+}
+/**
+ * 一个时间窗口内结案了多少条（skill `history --count-only`）。
+ * 区间写进缓存键：本周 / 上周两个窗口各算一次，别互相串味。
+ */
+export async function countClosed(workspace, window) {
+    return await cached(cacheKey(workspace.id, "history", `count:${window.from}~${window.to}`), async () => {
+        const result = await runLedgerScript("history", [
+            "--repo",
+            workspace.path,
+            "--count-only",
+            "--since",
+            window.from,
+            "--until",
+            window.to,
+        ]);
+        if (!result.ok)
+            throw new Error(`${workspace.title}: ${result.error}`);
+        if (!isPlainObject(result.data))
+            throw new LedgerDataError(workspace.title, `${workspace.title}: history --count-only 输出不是对象`);
+        const count = result.data.count;
+        if (typeof count !== "number" || !Number.isFinite(count))
+            throw new LedgerDataError(workspace.title, `${workspace.title}: history --count-only 缺 count 数字`);
+        return { count, capped: result.data.capped === true };
+    });
+}