dsh-task-ledger 0.0.78 → 0.0.80

package/dist/host/board.d.ts

@@ -1,5 +1,5 @@
 /**
- * 首页**组合入口**（`/board` 兼容全量端点用）：一次读全（tasks + history + git 身份），
+ * 首页**组合入口**（`/board` 兼容全量端点用）：一次读全（tasks + history + 本机身份），
  * 喂快 / 慢两条纯计算——**读一次算两样，不重复 IO**。
  *
  * 拆端点后（host-data-plane §五 A）首屏走 `services/home.service.ts::getSnapshot()`（不碰 history），
@@ -9,7 +9,7 @@ import { type DegradedInfo } from "./errors.js";
 import type { HomeAggregate, LedgerWorkspace } from "./types.js";
 /**
  * 首页一次拿全：在办快照（含停滞 / 天数 / 身份）+ 近 8 周趋势（完成 / 新增 × 所有 / 我的）
- * + 四个自然周期计数。**每个工作区只读一次**（list + history + git 身份），
+ * + 四个自然周期计数。**每个工作区只读一次**（list + history + 本机身份），
  * 避免「快照读一遍、统计再读一遍」把 5 万行级工作区的 history 解析翻倍。
  * 单工作区坏 ⇒ 进 degraded（其余照常）；全坏 ⇒ 抛（路由转 500 + 人话）。
  */

package/dist/host/board.js

@@ -1,5 +1,5 @@
 /**
- * 首页**组合入口**（`/board` 兼容全量端点用）：一次读全（tasks + history + git 身份），
+ * 首页**组合入口**（`/board` 兼容全量端点用）：一次读全（tasks + history + 本机身份），
  * 喂快 / 慢两条纯计算——**读一次算两样，不重复 IO**。
  *
  * 拆端点后（host-data-plane §五 A）首屏走 `services/home.service.ts::getSnapshot()`（不碰 history），
@@ -10,7 +10,7 @@ import { computeSnapshot } from "./services/home.service.js";
 import { computeClosedSummary, computeTrendPeriods, readTrendScope, } from "./services/trend.service.js";
 /**
  * 首页一次拿全：在办快照（含停滞 / 天数 / 身份）+ 近 8 周趋势（完成 / 新增 × 所有 / 我的）
- * + 四个自然周期计数。**每个工作区只读一次**（list + history + git 身份），
+ * + 四个自然周期计数。**每个工作区只读一次**（list + history + 本机身份），
  * 避免「快照读一遍、统计再读一遍」把 5 万行级工作区的 history 解析翻倍。
  * 单工作区坏 ⇒ 进 degraded（其余照常）；全坏 ⇒ 抛（路由转 500 + 人话）。
  */

package/dist/host/repositories/cache.js

@@ -16,6 +16,12 @@ const SEP = "\u0000";
 const settled = new Map();
 /** 在途单飞：key → 正在跑的 Promise（同 key 并发只跑一次）。 */
 const inflight = new Map();
+/**
+ * 失效代次：`invalidate()` 递增一次。
+ * 在飞的 Promise 落地时若代次变了就不写回 `settled`——否则「清缓存 → 旧读回来又填上」，
+ * 手动刷新 / 写完立刻刷新都会看到旧数据。
+ */
+let epoch = 0;
 /** 缓存键：`op:workspace:filter` 三条信息都要，否则不同筛选 / 不同工作区会串味。 */
 export function cacheKey(workspaceId, op, detail) {
     return `${op}${SEP}${workspaceId}${SEP}${detail}`;
@@ -31,14 +37,17 @@ export function cached(key, load, now = Date.now()) {
     const pending = inflight.get(key);
     if (pending !== undefined)
         return pending;
+    const issued = epoch;
     const task = Promise.resolve()
         .then(load)
         .then((value) => {
-        settled.set(key, { at: Date.now(), value });
+        if (issued === epoch)
+            settled.set(key, { at: Date.now(), value });
         return value;
     })
         .finally(() => {
-        inflight.delete(key);
+        if (inflight.get(key) === task)
+            inflight.delete(key);
     });
     inflight.set(key, task);
     return task;
@@ -48,12 +57,19 @@ export function cached(key, load, now = Date.now()) {
  * 写路径（任务 4，未拍板）落地后在其成功后调本函数；现在只有手动刷新这一处用。
  */
 export function invalidate(workspaceId) {
+    // 代次一律递增：在飞的结果落地时不再写回（按工作区区分度太细，多跑一次脚本不心疼）
+    epoch += 1;
     if (workspaceId === undefined) {
         settled.clear();
+        inflight.clear();
         return;
     }
     for (const key of settled.keys()) {
         if (key.split(SEP)[1] === workspaceId)
             settled.delete(key);
     }
+    for (const key of inflight.keys()) {
+        if (key.split(SEP)[1] === workspaceId)
+            inflight.delete(key);
+    }
 }

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

@@ -1,9 +1,4 @@
 import type { LedgerWorkspace } from "../types.js";
-/**
- * 当前 git 身份（cwd = 该工作区）——「我的待办」判定源。
- * 与 agent 在会话里跑 skill 时的取值环境一致；取不到回 null（非 git 目录 / 没配身份），
- * 该工作区的「我的」统计按 0 计（不谎报）。
- *
- * 全 host 唯一 spawn git 的地方（python3 的唯一出口在 ./runner.ts）。
- */
-export declare function getCurrentIdentity(workspace: LedgerWorkspace): Promise<string | null>;
+/** 机器级身份文件路径（与 skill 侧 `env.identity_file()` 同一口径）。 */
+export declare function identityPath(): string;
+export declare function getCurrentIdentity(_workspace?: LedgerWorkspace): Promise<string | null>;

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

@@ -1,27 +1,36 @@
-import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 /**
- * 当前 git 身份（cwd = 该工作区）——「我的待办」判定源。
- * 与 agent 在会话里跑 skill 时的取值环境一致；取不到回 null（非 git 目录 / 没配身份），
- * 该工作区的「我的」统计按 0 计（不谎报）。
+ * 本机身份 uuid —— 「我的待办 / 我的结案」判定的**唯一**来源。
  *
- * 全 host 唯一 spawn git 的地方（python3 的唯一出口在 ./runner.ts）。
+ * 身份是**机器级**的：skill 的 `init` 把 `{uuid, name}` 写进
+ * `$TASK_LEDGER_HOME/.taskledger/identity.json`（默认 `~/.taskledger/identity.json`），
+ * 与工作区、git 配置都无关；任务与历史里的 `owner` / `creator` 存的正是这个 uuid。
+ * 参数保留是为了与其它 per-workspace 读法同形（同一个 uuid 对所有工作区都成立）。
+ *
+ * **只取 `uuid`**：`name` 是冗余显示字段，不参与任何判定（按名字比 owner 永远比不到）。
+ * 读不到回 null（没 init / 文件坏 / 没 home 目录），该工作区的「我的」统计按 0 计（不谎报）。
  */
-export function getCurrentIdentity(workspace) {
-    return new Promise((resolve) => {
-        const child = spawn("git", ["config", "user.name"], {
-            cwd: workspace.path,
-            stdio: ["ignore", "pipe", "ignore"],
-        });
-        let stdout = "";
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk.toString();
-        });
-        child.on("error", () => {
-            resolve(null);
-        });
-        child.on("close", (code) => {
-            const name = stdout.trim();
-            resolve(code === 0 && name !== "" ? name : 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 {
+        return null;
+    }
 }

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

@@ -2,11 +2,15 @@ import type { HistoryRecord, LedgerFilter, LedgerWorkspace, TaskRow } from "../t
 /**
  * LedgerFilter → skill 脚本参数（只拼调用方给了的；undefined 一律不拼，
  * 让脚本走自己的默认——插件不替脚本决定默认值）。
+ *
+ * **按子命令裁参数**：`list` 不认 `--limit` / `--months`，`history` 不认 `--status`，
+ * 拼错一个就让 argparse 退 2、整块列表 500。口径以 `skill/shell/cli.py` 为准。
  */
-export declare function filterArgs(filter: LedgerFilter): string[];
+export declare function filterArgs(filter: LedgerFilter, sub: "list" | "history"): string[];
 /**
- * 台账工作区探测：`<path>/ledger/progress.json` 在才算（未初始化 = 后端不可见，
- * 2026-10-17 拍板）。全 host 对台账目录的 IO 只在本文件——别处再写 existsSync 即为分层倒退。
+ * 台账工作区探测：`<path>/ledger/pool.json` 在才算（分片布局的初始化标志；
+ * 未初始化 = 后端不可见，2026-10-17 拍板）。全 host 对台账目录的 IO 只在本文件
+ * ——别处再写 existsSync 即为分层倒退。
  */
 export declare function hasLedger(workspacePath: string): boolean;
 /**

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

@@ -9,13 +9,19 @@ const LEDGER_DIR = "ledger";
 /**
  * LedgerFilter → skill 脚本参数（只拼调用方给了的；undefined 一律不拼，
  * 让脚本走自己的默认——插件不替脚本决定默认值）。
+ *
+ * **按子命令裁参数**：`list` 不认 `--limit` / `--months`，`history` 不认 `--status`，
+ * 拼错一个就让 argparse 退 2、整块列表 500。口径以 `skill/shell/cli.py` 为准。
  */
-export function filterArgs(filter) {
+export function filterArgs(filter, sub) {
     const args = [];
-    if (filter.status !== undefined)
+    if (sub === "list" && filter.status !== undefined)
         args.push("--status", filter.status);
+    // 身份只收 uuid（脚本同样口径）；按名字模糊筛走 --owner-name
     if (filter.owner !== undefined)
         args.push("--owner", filter.owner);
+    if (filter.ownerName !== undefined)
+        args.push("--owner-name", filter.ownerName);
     if (filter.category !== undefined)
         args.push("--category", filter.category);
     if (filter.tag !== undefined)
@@ -24,15 +30,18 @@ export function filterArgs(filter) {
         args.push("--since", filter.since);
     if (filter.until !== undefined)
         args.push("--until", filter.until);
-    if (filter.limit !== undefined)
-        args.push("--limit", String(filter.limit));
-    if (filter.months !== undefined)
-        args.push("--months", String(filter.months));
+    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/progress.json` 在才算（未初始化 = 后端不可见，
- * 2026-10-17 拍板）。全 host 对台账目录的 IO 只在本文件——别处再写 existsSync 即为分层倒退。
+ * 台账工作区探测：`<path>/ledger/pool.json` 在才算（分片布局的初始化标志；
+ * 未初始化 = 后端不可见，2026-10-17 拍板）。全 host 对台账目录的 IO 只在本文件
+ * ——别处再写 existsSync 即为分层倒退。
  */
 export function hasLedger(workspacePath) {
     // 分片布局（2026-10-23）：公共池 pool.json 在才算初始化；各人分片 owners/*.json 由脚本维护。
@@ -44,12 +53,12 @@ export function hasLedger(workspacePath) {
  * 不静默返空（空 = 撒谎）。**过 1.5s 读缓存**（同屏多端点会反复读同一份在办）。
  */
 export async function readTasks(workspace, filter = {}) {
-    return await cached(cacheKey(workspace.id, "list", argsKey(filter)), async () => {
+    return await cached(cacheKey(workspace.id, "list", argsKey(filter, "list")), async () => {
         const result = await runLedgerScript("list", [
             "--repo",
             workspace.path,
             "--json",
-            ...filterArgs(filter),
+            ...filterArgs(filter, "list"),
         ]);
         if (!result.ok)
             throw new Error(`${workspace.title}: ${result.error}`);
@@ -58,12 +67,12 @@ export async function readTasks(workspace, filter = {}) {
 }
 /** 已结案记录（包 `history --json`；`records` 必须存在且为数组，缺了即坏数据）。同样过读缓存。 */
 export async function readHistory(workspace, filter = {}) {
-    return await cached(cacheKey(workspace.id, "history", argsKey(filter)), async () => {
+    return await cached(cacheKey(workspace.id, "history", argsKey(filter, "history")), async () => {
         const result = await runLedgerScript("history", [
             "--repo",
             workspace.path,
             "--json",
-            ...filterArgs(filter),
+            ...filterArgs(filter, "history"),
         ]);
         if (!result.ok)
             throw new Error(`${workspace.title}: ${result.error}`);
@@ -71,8 +80,8 @@ export async function readHistory(workspace, filter = {}) {
     });
 }
 /** 缓存键的 filter 段：脚本参数原样序列化（分隔符取不可见字符，值里带空格也不会串）。 */
-function argsKey(filter) {
-    return filterArgs(filter).join("\u0001");
+function argsKey(filter, sub) {
+    return filterArgs(filter, sub).join("\u0001");
 }
 /** 单条在办（展开行 / 详情用）。取不到回 null，不抛。 */
 export async function getTask(workspace, taskId) {

package/dist/host/repositories/records.js

@@ -42,7 +42,26 @@ export function parseHistoryRecords(raw, workspace) {
     for (const record of records) {
         if (!isPlainObject(record))
             continue; // 元素级宽松：坏行跳过，不整板炸
-        rows.push({ ...record, workspace });
+        rows.push(toHistoryRecord(record, workspace));
     }
     return rows;
 }
+/**
+ * 脚本 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;
+    return {
+        ...source,
+        // 脚本里的列名是真源；领域字段名作为兼容保留
+        time: text(source.finished) ?? text(source.time),
+        workpackage: text(source.title) ?? text(source.workpackage),
+        log: text(source.worklog) ?? text(source.log),
+        workspace,
+    };
+}

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

@@ -31,7 +31,7 @@ export interface RunOptions {
     timeoutMs?: number;
     /**
      * 子进程 cwd。写命令（claim / set）必须落在工作区：
-     * 脚本内的 owner 取 `git config user.name`，走进程 cwd 而不是 `--repo`。
+     * 脚本按 cwd 逐级往上找 `ledger/`（或靠 `--repo` 指定），与身份无关。
      */
     cwd?: string;
 }
@@ -43,7 +43,7 @@ export interface RunOptions {
  * @param args - 参数数组，由调用方自拼（含 --repo / --json / --months 等）
  * @param opts.scriptPath - 测试用：覆盖脚本路径
  * @param opts.timeoutMs - 覆盖超时
- * @param opts.cwd - 子进程工作目录（写命令取 git 身份用）
+ * @param opts.cwd - 子进程工作目录（写命令按 cwd 定位台账用）
  */
 export declare function runLedgerScript<T = unknown>(sub: string, args: readonly string[], opts?: RunOptions): Promise<LedgerScriptResult<T>>;
 /**

package/dist/host/repositories/runner.js

@@ -76,7 +76,7 @@ function exec(sub, args, opts) {
  * @param args - 参数数组，由调用方自拼（含 --repo / --json / --months 等）
  * @param opts.scriptPath - 测试用：覆盖脚本路径
  * @param opts.timeoutMs - 覆盖超时
- * @param opts.cwd - 子进程工作目录（写命令取 git 身份用）
+ * @param opts.cwd - 子进程工作目录（写命令按 cwd 定位台账用）
  */
 export async function runLedgerScript(sub, args, opts) {
     const result = await exec(sub, args, opts);

package/dist/host/routes.js

@@ -12,7 +12,18 @@ function sendJson(res, status, body) {
     res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
     res.end(JSON.stringify(body));
 }
-/** URL query → LedgerFilter（只认白名单键；limit/months 非正数忽略）。 */
+/** 参数用错（不是台账坏）：回 400，不落到 500，也不下发给脚本去撞。 */
+class UsageError extends Error {
+}
+/** 身份形态（与脚本 `core/identity.UUID_RE` 同一口径）。 */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * URL query → LedgerFilter（只认白名单键；limit/months 非正数忽略）。
+ *
+ * 两条硬口径：
+ * - `owner` **只收 uuid**，传名字直接 400 —— 名字筛走 `owner_name=<片段>`（脚本同一条规则）；
+ * - `months` 与 `since/until` 互斥：给了 `months` 就忽略后两者（脚本会 Fail，别让 UI 一次踩两个）。
+ */
 function filterFromQuery(url) {
     const filter = {};
     const str = (key) => {
@@ -30,26 +41,36 @@ function filterFromQuery(url) {
     if (status !== null)
         filter.status = status;
     const owner = str("owner");
-    if (owner !== null)
-        filter.owner = owner;
+    if (owner !== null) {
+        const key = owner.trim();
+        if (!UUID_RE.test(key))
+            throw new UsageError("owner 只收身份 uuid；按显示名模糊筛请用 owner_name=<片段>");
+        filter.owner = key;
+    }
+    const ownerName = str("owner_name");
+    if (ownerName !== null)
+        filter.ownerName = ownerName;
     const category = str("category");
     if (category !== null)
         filter.category = category;
     const tag = str("tag");
     if (tag !== null)
         filter.tag = tag;
-    const since = str("since");
-    if (since !== null)
-        filter.since = since;
-    const until = str("until");
-    if (until !== null)
-        filter.until = until;
     const limit = int("limit");
     if (limit !== undefined)
         filter.limit = limit;
     const months = int("months");
-    if (months !== undefined)
+    if (months !== undefined) {
         filter.months = months;
+    }
+    else {
+        const since = str("since");
+        if (since !== null)
+            filter.since = since;
+        const until = str("until");
+        if (until !== null)
+            filter.until = until;
+    }
     return filter;
 }
 /** 每请求重新解析工作区（registry 可能刚变；探测走 hasLedger()，微秒级，不缓存）。 */
@@ -93,7 +114,7 @@ export function registerRoutes(webServer, deps) {
         }
     });
     // ── 拆端点（2026-10-18 步骤 4a：纯加法，旧 /board 全量原样保留）──
-    // 快路径：首屏。只读 progress.json + git 身份，**不碰 history** ⇒ 耗时与历史总量解耦
+    // 快路径：首屏。只读 progress.json + 本机身份，**不碰 history** ⇒ 耗时与历史总量解耦
     // （20 万条量级实测 527ms vs 合并端点 4.4s）。
     registerRead("/board/snapshot", async (_req, res) => {
         try {
@@ -129,6 +150,10 @@ export function registerRoutes(webServer, deps) {
             sendJson(res, 200, { tasks: perWorkspace.flat() });
         }
         catch (error) {
+            if (error instanceof UsageError) {
+                sendJson(res, 400, { error: error.message });
+                return;
+            }
             sendJson(res, 500, {
                 error: error instanceof Error ? error.message : String(error),
             });
@@ -167,6 +192,10 @@ export function registerRoutes(webServer, deps) {
             });
         }
         catch (error) {
+            if (error instanceof UsageError) {
+                sendJson(res, 400, { error: error.message });
+                return;
+            }
             sendJson(res, 500, {
                 error: error instanceof Error ? error.message : String(error),
             });

package/dist/host/services/home.service.d.ts

@@ -1,6 +1,6 @@
 /**
  * 首页**快路径**用例：在办快照 + 统计卡。
- * 只读 progress.json（list）+ git 身份，**不碰 history**——首屏耗时与历史总量解耦
+ * 只读 progress.json（list）+ 本机身份，**不碰 history**——首屏耗时与历史总量解耦
  * （20 万条量级实测：527ms vs 合并端点 4.4s，见 docs/design/host-data-plane.md §四）。
  * 慢路径（趋势）在 ./trend.service.ts；组合入口（/board 兼容全量）在 ../board.ts。
  */
@@ -12,7 +12,7 @@ export declare const STALE_DAYS = 3;
 export declare const OVERDUE_DAYS = 14;
 /** 积压阈值：待认领且 created 至今满这么多天还没人接（2026-10-19 拍板）。 */
 export declare const BACKLOG_DAYS = 30;
-/** 快路径读法：单工作区 readTasks + git 身份（并行；供 settle 逐工作区调）。 */
+/** 快路径读法：单工作区 readTasks + 本机身份（并行；供 settle 逐工作区调）。 */
 export declare function readTaskScope(workspace: LedgerWorkspace): Promise<TaskScope>;
 /** 在办行加工 + 六个统计面 + identities（纯函数；`now` 显式传入）。 */
 export declare function computeSnapshot(scopes: readonly TaskScope[], now: Date): BoardSnapshot;

package/dist/host/services/home.service.js

@@ -1,10 +1,11 @@
 /**
  * 首页**快路径**用例：在办快照 + 统计卡。
- * 只读 progress.json（list）+ git 身份，**不碰 history**——首屏耗时与历史总量解耦
+ * 只读 progress.json（list）+ 本机身份，**不碰 history**——首屏耗时与历史总量解耦
  * （20 万条量级实测：527ms vs 合并端点 4.4s，见 docs/design/host-data-plane.md §四）。
  * 慢路径（趋势）在 ./trend.service.ts；组合入口（/board 兼容全量）在 ../board.ts。
  */
 import { settleWorkspaces } from "../errors.js";
+import { sameUuid } from "./uuid.js";
 import { getCurrentIdentity } from "../repositories/identity.repository.js";
 import { readTasks } from "../repositories/ledger.repository.js";
 import { daysSince } from "./dates.js";
@@ -14,7 +15,7 @@ export const STALE_DAYS = 3;
 export const OVERDUE_DAYS = 14;
 /** 积压阈值：待认领且 created 至今满这么多天还没人接（2026-10-19 拍板）。 */
 export const BACKLOG_DAYS = 30;
-/** 快路径读法：单工作区 readTasks + git 身份（并行；供 settle 逐工作区调）。 */
+/** 快路径读法：单工作区 readTasks + 本机身份（并行；供 settle 逐工作区调）。 */
 export async function readTaskScope(workspace) {
     const [tasks, identity] = await Promise.all([
         readTasks(workspace),
@@ -48,12 +49,14 @@ export function computeSnapshot(scopes, now) {
     }));
     const openTasks = withMeta.filter((task) => task.status === "open");
     const myActive = scopes.reduce((sum, scope) => sum +
-        scope.tasks.filter((task) => task.owner === scope.identity &&
+        scope.tasks.filter((task) => 
+        // identity 为 null（本机没 init）时不许把 owner 为空的 doing 任务算成「我的」
+        sameUuid(task.owner, scope.identity) &&
             (task.status === "doing" || task.status === "blocked")).length, 0);
     const identities = {};
     for (const scope of scopes)
         identities[scope.workspace.id] = scope.identity;
-    const mine = (task) => task.owner != null && task.owner === identities[task.workspace.id];
+    const mine = (task) => sameUuid(task.owner, identities[task.workspace.id]);
     const backlogTasks = withMeta.filter((task) => task.backlog);
     const overdueTasks = withMeta.filter((task) => task.overdue);
     const staleTasks = withMeta.filter((task) => task.stale);

package/dist/host/services/ledger-write.service.d.ts

@@ -1,10 +1,10 @@
 import type { LedgerWorkspace } from "../types.js";
-/** 认领：只有 open 且无人认领才能接（脚本内判定），owner = 工作区的 git 邮箱。 */
+/** 认领：只有 open 且无人认领才能接（脚本内判定），owner = 本机 identity 文件里的 uuid。 */
 export declare function claimTask(workspace: LedgerWorkspace, taskId: string): Promise<string>;
 /**
- * 释放：写回公共池（owner / started 清空、status 回 open），只许当前 owner 本人（脚本内判定）。
+ * 释放：写回公共池（owner / owner_name 清空、status 回 open），只许当前 owner 本人（脚本内判定）。
  *
- * 走 `set --owner ''`（空 owner = 释放）而不是 `set --status open`：后者只改状态，
- * 分片里那行不会回到公共池，别人永远看不到这条待认领。
+ * 走 `set --release`。**不能用 `--owner ''`**：脚本不接受「空 owner = 释放」这种隐式语义，
+ * 空串会被当成非法 uuid 直接退 1（2026-10-25 修，此前这条路必失败）。
  */
 export declare function releaseTask(workspace: LedgerWorkspace, taskId: string): Promise<string>;

package/dist/host/services/ledger-write.service.js

@@ -1,8 +1,8 @@
 /**
  * 台账写方法（2026-10-18 拍板 B 混合制）：认领 / 释放没有判断量，host 直跑 skill 脚本，**不开会话**。
  *
- * 身份：脚本按 `--repo`（= 工作区路径）读该仓库的 `git config user.email` 作为 owner，
- * 与宿主进程自己的 cwd / 身份无关。
+ * 身份：脚本只读本机 identity 文件里的 uuid 作为 owner（机器级、与工作区和 git 配置无关），
+ * 宿主进程不传、也不推断身份。
  *
  * 校验全在脚本里（认领要求 open 且无 owner；释放要求是当前 owner），本层不重复实现。
  */
@@ -17,16 +17,16 @@ async function run(workspace, sub, args) {
         throw new Error(`${workspace.title}：${result.error}`);
     return result.notice ?? "";
 }
-/** 认领：只有 open 且无人认领才能接（脚本内判定），owner = 工作区的 git 邮箱。 */
+/** 认领：只有 open 且无人认领才能接（脚本内判定），owner = 本机 identity 文件里的 uuid。 */
 export function claimTask(workspace, taskId) {
     return run(workspace, "claim", ["--id", taskId]);
 }
 /**
- * 释放：写回公共池（owner / started 清空、status 回 open），只许当前 owner 本人（脚本内判定）。
+ * 释放：写回公共池（owner / owner_name 清空、status 回 open），只许当前 owner 本人（脚本内判定）。
  *
- * 走 `set --owner ''`（空 owner = 释放）而不是 `set --status open`：后者只改状态，
- * 分片里那行不会回到公共池，别人永远看不到这条待认领。
+ * 走 `set --release`。**不能用 `--owner ''`**：脚本不接受「空 owner = 释放」这种隐式语义，
+ * 空串会被当成非法 uuid 直接退 1（2026-10-25 修，此前这条路必失败）。
  */
 export function releaseTask(workspace, taskId) {
-    return run(workspace, "set", ["--id", taskId, "--owner", ""]);
+    return run(workspace, "set", ["--id", taskId, "--release"]);
 }

package/dist/host/services/trend.service.d.ts

@@ -1,6 +1,6 @@
 /**
  * 首页**慢路径**用例：近 8 周趋势 + 四个自然周期。
- * 读 history（months=RECENT_MONTHS）+ 在办 + git 身份——首屏不等它（异步/按需拉）。
+ * 读 history（months=RECENT_MONTHS）+ 在办 + 本机身份——首屏不等它（异步/按需拉）。
  *
  * ⚠️ 窗口必须是 13 个月而不是 2：8 周桶在月初会横跨 3 个自然月（如 10 月第 1 周回溯到 8 月），
  * `--months` 是**文件级**过滤，缩到 2 会静默漏掉 8 月结案记录、趋势少算（2026-10-18 架构评审结论）。
@@ -11,7 +11,7 @@ import type { ClosedSummary, LedgerFilter, LedgerWorkspace, TrendPeriods, TrendS
 export declare const RECENT_MONTHS = 13;
 /** 趋势图桶数：近 8 周（2026-10-17 定稿）。 */
 export declare const WEEKLY_WEEKS = 8;
-/** 慢路径读法：单工作区 readTasks + readHistory(months) + git 身份（并行；供 settle 逐工作区调）。 */
+/** 慢路径读法：单工作区 readTasks + readHistory(months) + 本机身份（并行；供 settle 逐工作区调）。 */
 export declare function readTrendScope(workspace: LedgerWorkspace): Promise<TrendScope>;
 /**
  * 近 N 周分组桶（完成按结案时间、新增按创建时间）× 所有 / 我的（纯函数）。

package/dist/host/services/trend.service.js

@@ -1,11 +1,12 @@
 /**
  * 首页**慢路径**用例：近 8 周趋势 + 四个自然周期。
- * 读 history（months=RECENT_MONTHS）+ 在办 + git 身份——首屏不等它（异步/按需拉）。
+ * 读 history（months=RECENT_MONTHS）+ 在办 + 本机身份——首屏不等它（异步/按需拉）。
  *
  * ⚠️ 窗口必须是 13 个月而不是 2：8 周桶在月初会横跨 3 个自然月（如 10 月第 1 周回溯到 8 月），
  * `--months` 是**文件级**过滤，缩到 2 会静默漏掉 8 月结案记录、趋势少算（2026-10-18 架构评审结论）。
  */
 import { settleWorkspaces } from "../errors.js";
+import { sameUuid } from "./uuid.js";
 import { getCurrentIdentity } from "../repositories/identity.repository.js";
 import { readHistory, readTasks } from "../repositories/ledger.repository.js";
 import { buildWeeks, dayOf, inWindow, mondayOf, monthWindow, weekWindow, ymd, } from "./dates.js";
@@ -13,7 +14,7 @@ import { buildWeeks, dayOf, inWindow, mondayOf, monthWindow, weekWindow, ymd, }
 export const RECENT_MONTHS = 13;
 /** 趋势图桶数：近 8 周（2026-10-17 定稿）。 */
 export const WEEKLY_WEEKS = 8;
-/** 慢路径读法：单工作区 readTasks + readHistory(months) + git 身份（并行；供 settle 逐工作区调）。 */
+/** 慢路径读法：单工作区 readTasks + readHistory(months) + 本机身份（并行；供 settle 逐工作区调）。 */
 export async function readTrendScope(workspace) {
     const [tasks, history, identity] = await Promise.all([
         readTasks(workspace),
@@ -59,11 +60,11 @@ export function computeClosedSummary(scopes, now) {
             if (created === null)
                 continue;
             const week = ymd(mondayOf(created));
-            const createdMine = identity !== null && (task.creator ?? null) === identity;
+            const createdMine = sameUuid(task.creator, identity);
             bump(bucketsAll, week, "created");
             if (createdMine)
                 bump(bucketsMine, week, "created");
-            const ownedMine = identity !== null && (task.owner ?? null) === identity;
+            const ownedMine = sameUuid(task.owner, identity);
             bumpRemaining(bucketsAll, created, null);
             if (ownedMine)
                 bumpRemaining(bucketsMine, created, null);
@@ -73,7 +74,7 @@ export function computeClosedSummary(scopes, now) {
             if (closed !== null) {
                 const week = ymd(mondayOf(closed));
                 bump(bucketsAll, week, "done");
-                if (identity !== null && (record.owner ?? null) === identity)
+                if (sameUuid(record.owner, identity))
                     bump(bucketsMine, week, "done");
             }
             const created = dayOf(record.created);
@@ -81,14 +82,12 @@ export function computeClosedSummary(scopes, now) {
                 const week = ymd(mondayOf(created));
                 bump(bucketsAll, week, "created");
                 // 新增（我的）= 我创建的（creator）；旧 8 列历史无 creator 列 ⇒ 兜底 owner
-                const createdMine = identity !== null &&
-                    ((record.creator ?? null) === identity ||
-                        ((record.creator ?? null) === null &&
-                            (record.owner ?? null) === identity));
+                const createdMine = sameUuid(record.creator, identity) ||
+                    ((record.creator ?? null) === null && sameUuid(record.owner, identity));
                 if (createdMine)
                     bump(bucketsMine, week, "created");
             }
-            const ownedMine = identity !== null && (record.owner ?? null) === identity;
+            const ownedMine = sameUuid(record.owner, identity);
             bumpRemaining(bucketsAll, created, closed);
             if (ownedMine)
                 bumpRemaining(bucketsMine, created, closed);

package/dist/host/services/uuid.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 身份比较的唯一口径：**两边都 trim + 小写再比**。
+ *
+ * 台账里的 owner / creator 存的是 uuid，本机身份也取 uuid；但两边来源不同
+ * （identity.json 可能是手写的、台账里可能是旧版本写的），大小写不一定一致。
+ * 脚本侧 `core/identity.normalize` 就是这么比的，这里必须同口径，
+ * 否则脚本说「是你的」，界面说「不是你的」。
+ *
+ * 空值一律不算相等（`"" === ""` 会让「没 init」被误判成「是我的」）。
+ */
+export declare function sameUuid(a: string | null | undefined, b: string | null | undefined): boolean;