dsh-task-ledger 0.0.126 → 0.0.127

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

@@ -0,0 +1,138 @@
+/**
+ * 「继续」：在**该台账所属的 DSH 工作区**里起一个新会话，把只读提示词作为首条 user message 注入。
+ *
+ * 为什么不塞进现有会话的输入框（2026-11-03 核实）：写草稿的 `setDraft` 只挂在会话作用域的门面上
+ * （`dsh-client-ui-conversation` `contract/input.d.ts:165`，经 `SessionInputResolver.for(actx)` 取），
+ * 根级 client 插件拿不到某个会话的 `actx`；按 id 取的 `input.shell()` 是包内部件。
+ * 且任务↔会话之间没有绑定字段 ⇒「往哪个会话塞」本身没有答案。链路事实见
+ * `docs/design/external/dsh-session-handoff.md`，兄弟插件实证 `dsh-task-dispatch-table/src/dispatch.ts:519/562/627`。
+ *
+ * 三条硬约束（宿主 rc 线的坑，缺一条就是"会话建了但没法干活"）：
+ *  1. `setup` 里必须 `agentPresets.mount()` —— 不挂 preset 的 agent 落到空的全局层，fs / bash 全无；
+ *  2. `agentOptions.provider/model` 必须成对显式给 —— 缺省**不等于**走宿主默认；
+ *  3. 建完必须 `attachSession(sessionId)` —— 只设 `meta.cwd` 不会把会话归进工作区。
+ */
+import { randomUUID } from "node:crypto";
+import { realpathSync } from "node:fs";
+/**
+ * 比较用的规范化路径：registry 里存的是建工作区时的 `fs.realpath`，
+ * 而台账目录可能是手工添加进来的（符号链接 / 相对写法）⇒ 直接用字符串比会误判成「非 DSH 工作区」。
+ * realpath 失败（目录不在了）就退回原串，交给后续步骤按真实情况报错。
+ */
+function canonical(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+}
+/**
+ * 判据：台账目录的 path 能不能在宿主工作区里找到实体。
+ *
+ * 「继续」和「完成」两条链都先过这一关 —— 非 DSH 工作区**起不了会话**，
+ * 只能退化成「把提示词复制给用户，让他去对应的 Agent 粘」。
+ */
+export function resolveWorkspace(registry, path) {
+    const list = registry.list();
+    const wanted = canonical(path);
+    const workspace = list.find((item) => item.path === path) ??
+        list.find((item) => canonical(item.path) === wanted);
+    return workspace === undefined ? { kind: "not-dsh" } : { kind: "dsh", workspace };
+}
+function continueMessage(id, prompt) {
+    return {
+        id: randomUUID(),
+        role: "user",
+        content: [{ type: "text", text: prompt }],
+        // source 的 kind 与别的插件不冲突（合并扩展的判别字段），form/summary 只影响气泡上那行小字。
+        source: { kind: "task-ledger", form: "notice", summary: `继续任务 ${id}` },
+    };
+}
+/** 模型必须成对给：宿主缺省不填 `{{model}}` 会让 deployment persona 取不到值直接报错。 */
+function resolveRoute(defaultModel) {
+    if (defaultModel === undefined)
+        return undefined;
+    try {
+        const route = defaultModel.currentSelection();
+        if (typeof route?.provider === "string" &&
+            route.provider !== "" &&
+            typeof route.model === "string" &&
+            route.model !== "")
+            return { provider: route.provider, model: route.model };
+    }
+    catch {
+        /* 宿主服务未挂载时读属性会抛：按"没有默认模型"处理，由调用方报人话 */
+    }
+    return undefined;
+}
+/** 部署默认 preset；解析不出按 rosterless 处理（那种部署的东西在全局层，不挂也看得见）。 */
+async function resolvePresetId(presets) {
+    if (presets === undefined)
+        return undefined;
+    try {
+        const { id } = await presets.resolve();
+        return id === "" ? undefined : id;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 起会话并注入只读提示词。
+ *
+ * @throws Error（人话直上界面）：宿主缺 agents 服务 / 没有可用默认模型 / 会话建不起来 /
+ *   建好了但归不进工作区（此时会话会被 dispose 掉，不留孤儿）。
+ */
+export async function continueTask(deps, input) {
+    // ① 判据：台账目录的 path 能不能在宿主工作区里找到实体 —— 找不到就是非 DSH 工作区。
+    const resolved = resolveWorkspace(deps.registry, input.workspaceId);
+    if (resolved.kind === "not-dsh")
+        return { kind: "not-dsh" };
+    const workspace = resolved.workspace;
+    const agents = deps.agents;
+    if (agents === undefined)
+        throw new Error("宿主没有提供 agents 服务，起不了会话（本环境无法继续任务）。");
+    const route = resolveRoute(deps.defaultModel);
+    if (route === undefined)
+        throw new Error("宿主没有可用的默认模型（provider + model 需成对），请先在宿主里选一个模型再继续。");
+    const presetId = await resolvePresetId(deps.presets);
+    // ② 建会话（禁止预建再驱动：撞 already exists）
+    const sessionId = randomUUID();
+    const handle = await agents.create({
+        sessionId,
+        meta: {
+            cwd: workspace.path,
+            ...(presetId === undefined ? {} : { agentPreset: presetId }),
+        },
+        agentOptions: route,
+        setup: async (agentCtx) => {
+            if (presetId === undefined || deps.presets === undefined)
+                return;
+            await deps.presets.mount(agentCtx, presetId);
+        },
+    });
+    // ③ 归组：不 attach 就只有 cwd，侧栏里找不到这个会话 ⇒ 宁可回滚也不留孤儿
+    try {
+        if (workspace.attachSession === undefined)
+            throw new Error(`宿主没有提供 attachSession，会话 ${sessionId} 无法归入工作区「${workspace.title}」，已放弃。`);
+        await workspace.attachSession(sessionId);
+    }
+    catch (error) {
+        await handle.dispose().catch(() => { });
+        throw error;
+    }
+    // ④ 命名：`sessionTitle.rename` 写的是「用户来源」标题（会锁定自动命名，正是我们要的稳定名字）。
+    // 服务缺席 / 写失败都只丢标题，不能连累已经建好并归组的会话。
+    if (deps.sessionTitle !== undefined) {
+        try {
+            deps.sessionTitle.rename(handle.agent.session, input.title);
+        }
+        catch {
+            /* 命名失败不阻断继续 */
+        }
+    }
+    // ⑤ 注入首条消息并唤醒 driver
+    handle.agent.send(continueMessage(input.id, input.prompt), "next-turn", true);
+    return { kind: "started", sessionId };
+}

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

@@ -0,0 +1,34 @@
+/**
+ * 台账目录清单（机器级；真源在 skill `dirs` + `~/.taskledger/ledgers.json`）。
+ *
+ * 写一律走 skill 命令，插件不碰那个文件 —— 既有规矩，见 dirs.repository.ts 头注。
+ */
+import { type LedgerDir } from "../repositories/dirs.repository.js";
+/** 设置页「台账目录」块要的清单：**含隐藏项**（关了显示还得能开回来）。 */
+export declare function listDirs(): Promise<{
+    readonly dirs: readonly LedgerDir[];
+}>;
+/** 一次目录写动作（登记 / 显示 / 改名 / 移除），返回改完之后的完整清单。 */
+export type DirWriteInput = {
+    readonly action: "hide" | "unhide" | "remove";
+    readonly path: string;
+} | {
+    readonly action: "rename";
+    readonly path: string;
+    readonly name: string;
+} | {
+    readonly action: "add";
+    readonly path: string;
+};
+/** 写动作回执；`added` / `reason` 只有「登记」会带（`added:false` 时 `reason` 是原因）。 */
+export interface DirWriteResult {
+    readonly dirs: readonly LedgerDir[];
+    /** 登记回执：`false` = 一个都没进清单（`reason` 是原因）。 */
+    readonly added?: boolean;
+    /** 这些目录**本来就在**清单里（界面据此提示「无需重复添加」）。 */
+    readonly existed?: boolean;
+    /** 这次涉及的台账根（新增的；全部已存在时是已存在的那些），界面列名字用。 */
+    readonly paths?: readonly string[];
+    readonly reason?: string;
+}
+export declare function writeDirs(input: DirWriteInput): Promise<DirWriteResult>;

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

@@ -0,0 +1,66 @@
+/**
+ * 台账目录清单（机器级；真源在 skill `dirs` + `~/.taskledger/ledgers.json`）。
+ *
+ * 写一律走 skill 命令，插件不碰那个文件 —— 既有规矩，见 dirs.repository.ts 头注。
+ */
+import { addDir, ledgerChildrenOf, readDirs, removeDir, renameDir, setDirHidden, } from "../repositories/dirs.repository.js";
+/** 设置页「台账目录」块要的清单：**含隐藏项**（关了显示还得能开回来）。 */
+export async function listDirs() {
+    return { dirs: await readDirs() };
+}
+/**
+ * 登记：选中的目录**自己**是台账根就登记它；不是的话，把它**一级子目录**里的台账根逐个登记
+ * （用户 2026-11-03：只知道「这项目有台账」的人会选它的直属父目录，这种也算有效）。
+ * 两样都没有 ⇒ 不落盘，把 skill 给的原因回给界面。
+ *
+ * 回执里**清单永远是完整的**：skill 在「不是台账根」时不回清单（`dirs` 为 null），
+ * 照它回执换表格会把界面清空（2026-11-03 真机踩过）⇒ 失败分支自己再读一次。
+ */
+async function addDirs(path) {
+    // 登记前先记一份：skill 的 `--add` 幂等，回执分不出「这次新增」和「本来就有」
+    const before = new Set((await readDirs()).map((dir) => dir.path));
+    const fresh = [];
+    const known = [];
+    let dirs = [];
+    const self = await addDir(path, "");
+    if (self.added) {
+        dirs = self.dirs;
+        (before.has(path) ? known : fresh).push(path);
+    }
+    else {
+        const children = await ledgerChildrenOf(path);
+        if (children.length === 0)
+            return { dirs: await readDirs(), added: false, reason: self.reason };
+        // 串行：读改写同一个清单文件，并发会互相覆盖
+        for (const child of children) {
+            const result = await addDir(child, "");
+            if (!result.added)
+                continue;
+            dirs = result.dirs;
+            (before.has(child) ? known : fresh).push(child);
+        }
+        if (fresh.length === 0 && known.length === 0)
+            return {
+                dirs: await readDirs(),
+                added: false,
+                reason: `${path} 下的台账登记失败`,
+            };
+    }
+    if (fresh.length > 0)
+        return { dirs, added: true, paths: fresh };
+    return { dirs, added: true, existed: true, paths: known };
+}
+export async function writeDirs(input) {
+    switch (input.action) {
+        case "hide":
+            return { dirs: await setDirHidden(input.path, true) };
+        case "unhide":
+            return { dirs: await setDirHidden(input.path, false) };
+        case "rename":
+            return { dirs: await renameDir(input.path, input.name) };
+        case "remove":
+            return { dirs: await removeDir(input.path) };
+        case "add":
+            return addDirs(input.path);
+    }
+}

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

@@ -1,2 +1,14 @@
-import type { HistoryGran, HistoryTrendPayload, LedgerWorkspace } from "../types.js";
+import type { HistoryGran, HistoryListPayload, HistoryTrendPayload, LedgerWorkspace } from "../types.js";
 export declare function getHistoryTrend(workspaces: readonly LedgerWorkspace[], gran?: HistoryGran): Promise<HistoryTrendPayload>;
+/** 历史列表的查询：**只取选中的那个月**（2026-11-01 用户拍板：取数按月，不再取一年再前端过滤）。 */
+export interface HistoryListQuery {
+    /** `YYYY-MM`；缺省或格式不对 ⇒ 当月。 */
+    readonly ym?: string;
+    /** 执行人 uuid。 */
+    readonly owner?: string;
+}
+/**
+ * 历史明细跨工作区合并：按结案时间正序、按 `key` 去重，整月一次下发。
+ * 分页不在这里做 —— 整月都在前端内存里，滚动由前端按行号开窗（不再按天切片翻页）。
+ */
+export declare function getHistoryList(workspaces: readonly LedgerWorkspace[], query: HistoryListQuery): Promise<HistoryListPayload>;

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

@@ -5,6 +5,7 @@
  * （用户 2026-10-30 定：聚合算法不自己写，本地只加总，免得与核心口径漂移）。
  */
 import { settleWorkspaces } from "../errors.js";
+import { readHistory } from "../repositories/history.repository.js";
 import { readTrendGran } from "../repositories/trend.repository.js";
 function pad2(n) {
     return String(n).padStart(2, "0");
@@ -128,3 +129,44 @@ export async function getHistoryTrend(workspaces, gran = "day") {
         degraded: settled.degraded,
     };
 }
+/** `YYYY-MM` → 该月首末时刻（与存盘同形的串，脚本直接字符串比较）。 */
+function monthRange(ym) {
+    const year = Number(ym.slice(0, 4));
+    const month = Number(ym.slice(5, 7));
+    // 0 基月份：传 month 就是「下个月 1 号」，退一秒即本月末
+    const end = new Date(new Date(year, month, 1).getTime() - 1000);
+    return { since: `${ym}-01 00:00:00`, until: `${ym}-${pad2(end.getDate())} 23:59:59` };
+}
+/**
+ * 历史明细跨工作区合并：按结案时间正序、按 `key` 去重，整月一次下发。
+ * 分页不在这里做 —— 整月都在前端内存里，滚动由前端按行号开窗（不再按天切片翻页）。
+ */
+export async function getHistoryList(workspaces, query) {
+    const today = ymdOf(new Date());
+    const ym = query.ym !== undefined && /^\d{4}-\d{2}$/.test(query.ym)
+        ? query.ym
+        : today.slice(0, 7);
+    const { since, until } = monthRange(ym);
+    const settled = await settleWorkspaces(workspaces, "history", (workspace) => readHistory(workspace, {
+        since,
+        until,
+        ...(query.owner === undefined ? {} : { owner: query.owner }),
+    }), (rows) => rows);
+    const seen = new Set();
+    const merged = [];
+    for (const page of settled.data) {
+        for (const record of page.records) {
+            if (seen.has(record.key))
+                continue;
+            seen.add(record.key);
+            merged.push(record);
+        }
+    }
+    merged.sort((a, b) => (a.finished < b.finished ? -1 : a.finished > b.finished ? 1 : 0));
+    return {
+        records: merged,
+        // 整月不再设条数上限（2026-11-01）⇒ 恒为 false；字段留着是为了不动下发形状
+        capped: false,
+        degraded: settled.degraded,
+    };
+}

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

@@ -0,0 +1,53 @@
+/**
+ * 机器身份（看板「设置页」用）：读是谁、换是谁、列出可以换成谁。
+ *
+ * 三条都走 skill 脚本，插件不碰 identity.json（布局知识只有 skill 一份）：
+ *  - `whoami --json` → 读；未初始化回双 null（退 0，不是错误）；
+ *  - `switch --json` → 写（隐藏命令，只给界面用；init 在非终端下仍拒写）；
+ *  - `owners --json` → 名册（2026-11-01 起放开，没身份也能读）。
+ */
+import type { LedgerWorkspace } from "../types.js";
+import { type IdentityView, type RenameView, type SwitchInput } from "../repositories/identity.repository.js";
+export type { IdentityView, RenameView, SwitchInput };
+export declare function getIdentity(): Promise<IdentityView>;
+export declare function switchIdentity(input: SwitchInput): Promise<IdentityView | RenameView>;
+/** 一个工作区里可以被认领的人（名册原样，去掉 uuid 为空的行）。 */
+export interface RosterWorkspace {
+    readonly id: string;
+    readonly title: string;
+    readonly owners: readonly {
+        readonly uuid: string;
+        readonly name: string;
+    }[];
+}
+/**
+ * 各工作区花名册。**读挂了的工作区直接跳过**——名册索引缺失（`owners.json` 还没被任何写命令建出来）
+ * 与新仓库本来就没人是同一件事：引导页要把它当「这里没人，只能新建」，不能当成故障。
+ */
+/** 摘人结果：删掉的、因为还有任务没删的、出错的，各按工作区列出来。 */
+export interface ForgetReport {
+    readonly removed: readonly string[];
+    readonly kept: readonly {
+        readonly workspace: string;
+        readonly tasks: number;
+    }[];
+    readonly failed: readonly {
+        readonly workspace: string;
+        readonly error: string;
+    }[];
+    /** 删的是本机身份、并且**每一本都删成了** ⇒ 顺手退出了登录。 */
+    readonly signedOut: boolean;
+}
+/**
+ * 把某个人从**所有登记过他的台账**里摘掉（用户 2026-11-02 定的口径）：
+ * 每本台账各删各的，分片里还有任务的那本不删、如实回报；历史记录与其他台账一概不动。
+ * 名册里没有他的台账直接跳过（不是失败）。
+ *
+ * **清本机身份必须是最后一步**：删的是自己时，每本台账都跑一次 forget，若让 forget 顺手
+ * 删 identity.json，先跑完的那本会让后面几本读不到身份（报「这台机器还没有初始化身份」）。
+ * 所以 forget 一律带 --keep-identity，全部跑完之后才按需要 logout。
+ */
+export declare function forgetOwner(workspaces: readonly LedgerWorkspace[], uuid: string): Promise<ForgetReport>;
+export declare function getRoster(workspaces: readonly LedgerWorkspace[]): Promise<{
+    readonly workspaces: readonly RosterWorkspace[];
+}>;

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

@@ -0,0 +1,89 @@
+import { forgetOwner as runForget, logout as runLogout, readIdentity, switchIdentity as runSwitch, } from "../repositories/identity.repository.js";
+import { readOwners } from "../repositories/ledger.repository.js";
+export async function getIdentity() {
+    return await readIdentity();
+}
+export async function switchIdentity(input) {
+    return await runSwitch(input);
+}
+/**
+ * 把某个人从**所有登记过他的台账**里摘掉（用户 2026-11-02 定的口径）：
+ * 每本台账各删各的，分片里还有任务的那本不删、如实回报；历史记录与其他台账一概不动。
+ * 名册里没有他的台账直接跳过（不是失败）。
+ *
+ * **清本机身份必须是最后一步**：删的是自己时，每本台账都跑一次 forget，若让 forget 顺手
+ * 删 identity.json，先跑完的那本会让后面几本读不到身份（报「这台机器还没有初始化身份」）。
+ * 所以 forget 一律带 --keep-identity，全部跑完之后才按需要 logout。
+ */
+export async function forgetOwner(workspaces, uuid) {
+    const key = uuid.trim().toLowerCase();
+    const removed = [];
+    const kept = [];
+    const failed = [];
+    const listed = await Promise.allSettled(workspaces.map(readOwners));
+    const targets = workspaces.filter((_workspace, index) => {
+        const result = listed[index];
+        if (result.status !== "fulfilled")
+            return false;
+        return result.value.owners.some((owner) => owner.uuid === key);
+    });
+    // 摘的是不是自己：只有「自己」才需要最后退出登录
+    const me = await readIdentity().catch(() => ({ uuid: null, name: null }));
+    const isSelf = me.uuid !== null && me.uuid === key;
+    const outcomes = await Promise.allSettled(targets.map((workspace) => runForget(workspace.path, key)));
+    outcomes.forEach((result, index) => {
+        const workspace = targets[index];
+        if (result.status === "rejected") {
+            const reason = result.reason;
+            failed.push({
+                workspace: workspace.title,
+                error: reason instanceof Error ? reason.message : String(reason),
+            });
+            return;
+        }
+        if (result.value.removed)
+            removed.push(workspace.title);
+        else
+            kept.push({ workspace: workspace.title, tasks: result.value.tasks });
+    });
+    // **全部成功才退登录**（用户 2026-11-02 拍板）：只要有一本还留着人（kept）或报错（failed），
+    // 本机身份就保住 —— 人还没从台账里清干净，机器先没了身份只会更乱。
+    let signedOut = false;
+    const allDone = removed.length > 0 && kept.length === 0 && failed.length === 0;
+    if (isSelf && allDone) {
+        const anchor = (targets[0] ?? workspaces[0])?.path;
+        if (anchor === undefined) {
+            failed.push({ workspace: me.name ?? key, error: "退出登录失败：没有可用的台账目录" });
+        }
+        else {
+            try {
+                await runLogout(anchor);
+                signedOut = true;
+            }
+            catch (error) {
+                failed.push({
+                    workspace: me.name ?? key,
+                    error: `退出登录失败：${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        }
+    }
+    return { removed, kept, failed, signedOut };
+}
+export async function getRoster(workspaces) {
+    const settled = await Promise.allSettled(workspaces.map(readOwners));
+    const rows = [];
+    settled.forEach((result, index) => {
+        if (result.status !== "fulfilled")
+            return;
+        const owners = result.value;
+        rows.push({
+            id: workspaces[index].id,
+            title: workspaces[index].title,
+            owners: owners.owners
+                .filter((owner) => owner.uuid !== "")
+                .map((owner) => ({ uuid: owner.uuid, name: owner.name })),
+        });
+    });
+    return { workspaces: rows };
+}

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

@@ -22,8 +22,8 @@ export declare function weekDoneFromTrend(trend: TrendView, fallback: {
     readonly to: string;
 }): WeekDone;
 /**
- * 首屏一次拿全：8 卡 + 在办列表 + 工作区 + 身份 + 各工作区花名册。
- * 三条读并行（`stats` / `list` / `owners`），各自缓存；一个工作区坏只进 degraded，其余照常。
+ * 首屏一次拿全：8 卡 + 在办列表 + 工作区 + 身份 + 各工作区花名册 + 趋势两档（周 / 日）。
+ * 四路并行（`stats` / `list` / `owners` / 趋势），各自缓存；一个工作区坏只进 degraded，其余照常。
  */
 export declare function getBoardHome(workspaces: readonly LedgerWorkspace[], now?: Date): Promise<BoardHomePayload>;
 export declare function getBoardStats(workspaces: readonly LedgerWorkspace[], now?: Date): Promise<StatsPayload>;

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

@@ -7,7 +7,7 @@
  */
 import { settleWorkspaces } from "../errors.js";
 import { getCurrentIdentity } from "../repositories/identity.repository.js";
-import { getBoardTrend } from "./trend.service.js";
+import { getBoardTrendGran } from "./trend.service.js";
 import { readOwners, readTasks } from "../repositories/ledger.repository.js";
 import { readStats } from "../repositories/stats.repository.js";
 import { weekWindow } from "./dates.js";
@@ -30,6 +30,14 @@ export function weekDoneFromTrend(trend, fallback, fallbackLast) {
         lastWeekTo: lastWeek?.to ?? fallbackLast.to,
     };
 }
+/** 趋势载荷 → 下发视图（`TrendPayload` 多带一份 degraded，界面不要）。 */
+function viewOf(trend) {
+    return {
+        buckets: trend.buckets,
+        coverageFrom: trend.coverageFrom,
+        coverageTo: trend.coverageTo,
+    };
+}
 /** 单工作区在办列表 + 本机身份（都经 skill：`list --json` / `whoami --json`）。 */
 async function readTaskScope(workspace) {
     const [tasks, identity] = await Promise.all([
@@ -50,16 +58,23 @@ function dedupe(rows) {
     });
 }
 /**
- * 首屏一次拿全：8 卡 + 在办列表 + 工作区 + 身份 + 各工作区花名册。
- * 三条读并行（`stats` / `list` / `owners`），各自缓存；一个工作区坏只进 degraded，其余照常。
+ * 首屏一次拿全：8 卡 + 在办列表 + 工作区 + 身份 + 各工作区花名册 + 趋势两档（周 / 日）。
+ * 四路并行（`stats` / `list` / `owners` / 趋势），各自缓存；一个工作区坏只进 degraded，其余照常。
  */
 export async function getBoardHome(workspaces, now = new Date()) {
-    const [statsPayload, taskScope, ownerScope, trend] = await Promise.all([
+    const [statsPayload, taskScope, ownerScope, trends] = await Promise.all([
         getBoardStats(workspaces, now),
         settleWorkspaces(workspaces, "list", readTaskScope, (rows) => rows),
         settleWorkspaces(workspaces, "owners", readOwners, (rows) => rows),
-        getBoardTrend(workspaces),
+        // 周 / 日两档：先周后日 —— 冷缓存时周档顺手把月度缓存写下去，日档再读就是命中。
+        // 两段窗口覆盖的是同一批月份，并行跑等于把同一批历史文件读两遍。
+        (async () => ({
+            week: await getBoardTrendGran(workspaces, "week"),
+            day: await getBoardTrendGran(workspaces, "day"),
+        }))(),
     ]);
+    const trend = trends.week;
+    const trendDay = trends.day;
     const identities = {};
     const tasks = [];
     for (const scope of taskScope.data) {
@@ -70,7 +85,8 @@ export async function getBoardHome(workspaces, now = new Date()) {
     return {
         ...statsPayload,
         stats: { ...statsPayload.stats, ...weeks },
-        trend: { buckets: trend.buckets, coverageFrom: trend.coverageFrom, coverageTo: trend.coverageTo },
+        trend: viewOf(trend),
+        trendDay: viewOf(trendDay),
         workspaces,
         tasks,
         identities,
@@ -80,6 +96,7 @@ export async function getBoardHome(workspaces, now = new Date()) {
             ...taskScope.degraded,
             ...ownerScope.degraded,
             ...trend.degraded,
+            ...trendDay.degraded,
         ]),
     };
 }

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

@@ -0,0 +1,15 @@
+import { type TaskAction, type TaskActionStep } from "../repositories/task.repository.js";
+export type { TaskAction, TaskActionStep };
+export interface TaskActionInput {
+    readonly action: TaskAction;
+    /** 任务所在工作区根（skill 定位台账用）。 */
+    readonly repo: string;
+    readonly id: string;
+    /** 取消时的一句话理由（可选；进历史摘要与执行记录）。 */
+    readonly summary?: string;
+}
+/**
+ * @param onStep - 过程步骤回调：路由把它写成 NDJSON 一行一行推给界面（进度翻牌）。
+ *   命令跑完 / 失败前都会先收到前面那几个阶段，界面据此换文案。
+ */
+export declare function actOnTask(input: TaskActionInput, onStep?: (step: TaskActionStep) => void): Promise<void>;

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

@@ -0,0 +1,15 @@
+/**
+ * 任务动作（界面行内按钮 → skill 写命令）：认领、释放。
+ *
+ * 写完必须清读缓存 —— 下一屏快照要看到刚改过的归属，不能吃 1.5s 的旧值。
+ */
+import { invalidate } from "../repositories/cache.js";
+import { runTaskAction, } from "../repositories/task.repository.js";
+/**
+ * @param onStep - 过程步骤回调：路由把它写成 NDJSON 一行一行推给界面（进度翻牌）。
+ *   命令跑完 / 失败前都会先收到前面那几个阶段，界面据此换文案。
+ */
+export async function actOnTask(input, onStep) {
+    await runTaskAction(input.repo, input.id, input.action, input.summary ?? "", onStep);
+    invalidate();
+}

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

@@ -1,5 +1,5 @@
 import { type TrendBucket } from "../repositories/trend.repository.js";
-import type { LedgerWorkspace, TrendPayload, TrendView } from "../types.js";
+import type { BoardTrendGran, LedgerWorkspace, TrendPayload, TrendView } from "../types.js";
 /**
  * 跨工作区求和：同一天起止的周桶相加。
  * 工作区之间周界一致（同机同时区、都由 skill 的周一起算），所以直接按 `from` 归并。
@@ -10,4 +10,4 @@ export declare function mergeTrend(rows: readonly {
     coverageTo: string;
 }[]): TrendView;
 /** 趋势图数据：逐工作区读、坏的进 degraded，全挂给空桶（不抛）。 */
-export declare function getBoardTrend(workspaces: readonly LedgerWorkspace[]): Promise<TrendPayload>;
+export declare function getBoardTrendGran(workspaces: readonly LedgerWorkspace[], gran: BoardTrendGran): Promise<TrendPayload>;

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

@@ -8,7 +8,7 @@
  * 全挂时返回空桶 + inherited degraded，界面显示空态（真源口径见 errors.ts 的 settleWorkspaces 注释）。
  */
 import { codeOf, messageOf } from "../errors.js";
-import { readTrend } from "../repositories/trend.repository.js";
+import { readBoardTrend } from "../repositories/trend.repository.js";
 const byFrom = (a, b) => a.from < b.from ? -1 : a.from > b.from ? 1 : 0;
 /**
  * 跨工作区求和：同一天起止的周桶相加。
@@ -63,8 +63,8 @@ export function mergeTrend(rows) {
     };
 }
 /** 趋势图数据：逐工作区读、坏的进 degraded，全挂给空桶（不抛）。 */
-export async function getBoardTrend(workspaces) {
-    const settled = await Promise.allSettled(workspaces.map((workspace) => readTrend(workspace)));
+export async function getBoardTrendGran(workspaces, gran) {
+    const settled = await Promise.allSettled(workspaces.map((workspace) => readBoardTrend(workspace, gran)));
     const rows = [];
     const degraded = [];
     settled.forEach((result, i) => {

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

@@ -0,0 +1,10 @@
+import type { LedgerWorkspace, RegistryWorkspace } from "../types.js";
+/**
+ * 台账目录发现（用户 2026-11-01 改口径）：**按机器级清单读**，不再按宿主工作区读。
+ *
+ * 宿主 registry 只剩一件事：替清单**补登记**（扫到的工作区里清单还没有的，加进去）。
+ * 补登记只在 `sync = true` 时做（用户 2026-11-03：进看板 + 手动刷新，一共两处；其余请求
+ * 一律只读清单 —— 每请求起一个进程只为对比工作区，纯浪费）。
+ * 隐藏 = 全局不看，过滤只在这里做一次 —— 下游（统计卡 / 趋势 / 列表 / 名册）全吃这个输出。
+ */
+export declare function resolveWorkspaces(registryList: readonly RegistryWorkspace[], sync?: boolean): Promise<LedgerWorkspace[]>;

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

@@ -0,0 +1,28 @@
+import { addDir, readDirs } from "../repositories/dirs.repository.js";
+/**
+ * 台账目录发现（用户 2026-11-01 改口径）：**按机器级清单读**，不再按宿主工作区读。
+ *
+ * 宿主 registry 只剩一件事：替清单**补登记**（扫到的工作区里清单还没有的，加进去）。
+ * 补登记只在 `sync = true` 时做（用户 2026-11-03：进看板 + 手动刷新，一共两处；其余请求
+ * 一律只读清单 —— 每请求起一个进程只为对比工作区，纯浪费）。
+ * 隐藏 = 全局不看，过滤只在这里做一次 —— 下游（统计卡 / 趋势 / 列表 / 名册）全吃这个输出。
+ */
+export async function resolveWorkspaces(registryList, sync = false) {
+    let dirs = await readDirs();
+    if (sync) {
+        const known = new Set(dirs.map((dir) => dir.path));
+        for (const workspace of registryList) {
+            if (known.has(workspace.path))
+                continue;
+            // 串行：读改写同一个文件，并发会互相覆盖（skill 侧虽有锁，最后写入者仍可能少几条）
+            const added = await addDir(workspace.path, workspace.title);
+            known.add(workspace.path);
+            if (added.added)
+                dirs = added.dirs;
+        }
+    }
+    return dirs.filter((dir) => !dir.hidden).map(toWorkspace);
+}
+function toWorkspace(dir) {
+    return { id: dir.path, title: dir.name, path: dir.path };
+}