dsh-task-ledger 0.0.74 → 0.0.75

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

@@ -4,10 +4,10 @@
  * （20 万条量级实测：527ms vs 合并端点 4.4s，见 docs/design/host-data-plane.md §四）。
  * 慢路径（趋势）在 ./trend.service.ts；组合入口（/board 兼容全量）在 ../board.ts。
  */
-import { readTasks } from '../repositories/ledger.repository.js';
-import { getCurrentIdentity } from '../repositories/identity.repository.js';
-import { settleWorkspaces } from '../errors.js';
-import { daysSince } from './dates.js';
+import { settleWorkspaces } from "../errors.js";
+import { getCurrentIdentity } from "../repositories/identity.repository.js";
+import { readTasks } from "../repositories/ledger.repository.js";
+import { daysSince } from "./dates.js";
 /** 停滞阈值：进行中且 updated 至今满这么多天没更新（2026-10-19 拍板，显示级）。 */
 export const STALE_DAYS = 3;
 /** 逾期阈值：进行中且 started 至今满这么多天还没做完——中途更新不影响（2026-10-19 拍板 7 → 14 天）。 */
@@ -16,18 +16,25 @@ export const OVERDUE_DAYS = 14;
 export const BACKLOG_DAYS = 30;
 /** 快路径读法：单工作区 readTasks + git 身份（并行；供 settle 逐工作区调）。 */
 export async function readTaskScope(workspace) {
-    const [tasks, identity] = await Promise.all([readTasks(workspace), getCurrentIdentity(workspace)]);
+    const [tasks, identity] = await Promise.all([
+        readTasks(workspace),
+        getCurrentIdentity(workspace),
+    ]);
     return { workspace, tasks, identity };
 }
 /** 在办行加工 + 六个统计面 + identities（纯函数；`now` 显式传入）。 */
 export function computeSnapshot(scopes, now) {
     const withMeta = scopes.flatMap((scope) => scope.tasks.map((task) => {
         // blocked 只是旧数据（新任务不可能再有）；读侧一律当进行中
-        const working = task.status === 'doing' || task.status === 'blocked';
-        const ageDays = working ? daysSince(task.started ?? task.created, now) : null;
+        const working = task.status === "doing" || task.status === "blocked";
+        const ageDays = working
+            ? daysSince(task.started ?? task.created, now)
+            : null;
         // 停滞看「最后更新」，逾期看「接任务至今」，积压看「创建至今还没人认领」——三个不同的问题，互不覆盖
-        const idleDays = working ? daysSince(task.updated ?? task.started ?? task.created, now) : null;
-        const idleOpen = task.status === 'open' ? daysSince(task.created, now) : null;
+        const idleDays = working
+            ? daysSince(task.updated ?? task.started ?? task.created, now)
+            : null;
+        const idleOpen = task.status === "open" ? daysSince(task.created, now) : null;
         return {
             ...task,
             ageDays,
@@ -39,8 +46,10 @@ export function computeSnapshot(scopes, now) {
             backlog: idleOpen !== null && idleOpen >= BACKLOG_DAYS,
         };
     }));
-    const openTasks = withMeta.filter((task) => task.status === 'open');
-    const myActive = scopes.reduce((sum, scope) => sum + scope.tasks.filter((task) => task.owner === scope.identity && (task.status === 'doing' || task.status === 'blocked')).length, 0);
+    const openTasks = withMeta.filter((task) => task.status === "open");
+    const myActive = scopes.reduce((sum, scope) => sum +
+        scope.tasks.filter((task) => 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;
@@ -53,7 +62,7 @@ export function computeSnapshot(scopes, now) {
         myOverdue: overdueTasks.filter(mine).length,
         myStale: staleTasks.filter(mine).length,
         open: openTasks.length,
-        doing: withMeta.filter((task) => task.status === 'doing' || task.status === 'blocked').length,
+        doing: withMeta.filter((task) => task.status === "doing" || task.status === "blocked").length,
         overdue: overdueTasks.length,
         stale: staleTasks.length,
         backlog: backlogTasks.length,
@@ -64,10 +73,16 @@ export function computeSnapshot(scopes, now) {
             ? null
             : openTasks.reduce((max, task) => Math.max(max, daysSince(task.created, now) ?? 0), 0),
     };
-    return { at: now.toISOString(), workspaces: scopes.map((scope) => scope.workspace), tasks: withMeta, stats, identities };
+    return {
+        at: now.toISOString(),
+        workspaces: scopes.map((scope) => scope.workspace),
+        tasks: withMeta,
+        stats,
+        identities,
+    };
 }
 /** 快路径端点：在办快照（统计卡 + 身份 + 行加工）。单工作区坏 ⇒ 进 degraded，其余照常。 */
 export async function getSnapshot(workspaces) {
-    const { data: scopes, degraded } = await settleWorkspaces(workspaces, 'list', readTaskScope, (rows) => rows);
+    const { data: scopes, degraded } = await settleWorkspaces(workspaces, "list", readTaskScope, (rows) => rows);
     return { snapshot: computeSnapshot(scopes, new Date()), degraded };
 }

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

@@ -1,5 +1,10 @@
-import type { LedgerWorkspace } from '../types.js';
-/** 认领：只有 open 且无人认领才能接（脚本内判定），owner = 当前工作区的 git 身份。 */
+import type { LedgerWorkspace } from "../types.js";
+/** 认领：只有 open 且无人认领才能接（脚本内判定），owner = 工作区的 git 邮箱。 */
 export declare function claimTask(workspace: LedgerWorkspace, taskId: string): Promise<string>;
-/** 释放：退回待认领（owner / started 清空），只许当前 owner 本人（脚本内判定）。 */
+/**
+ * 释放：写回公共池（owner / started 清空、status 回 open），只许当前 owner 本人（脚本内判定）。
+ *
+ * 走 `set --owner ''`（空 owner = 释放）而不是 `set --status open`：后者只改状态，
+ * 分片里那行不会回到公共池，别人永远看不到这条待认领。
+ */
 export declare function releaseTask(workspace: LedgerWorkspace, taskId: string): Promise<string>;

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

@@ -1,27 +1,32 @@
 /**
  * 台账写方法（2026-10-18 拍板 B 混合制）：认领 / 释放没有判断量，host 直跑 skill 脚本，**不开会话**。
  *
- * 唯一要点：子进程 cwd 必须是工作区 —— `progress.py` 的 owner 取 `git config user.name`，
- * 走的是进程 cwd，`--repo` 只解决路径、不解决身份（2026-10-18 核实结论）。
+ * 身份：脚本按 `--repo`（= 工作区路径）读该仓库的 `git config user.email` 作为 owner，
+ * 与宿主进程自己的 cwd / 身份无关。
  *
  * 校验全在脚本里（认领要求 open 且无 owner；释放要求是当前 owner），本层不重复实现。
  */
-import { WRITE_TIMEOUT_MS, runLedgerCommand } from '../repositories/runner.js';
+import { runLedgerCommand, WRITE_TIMEOUT_MS } from "../repositories/runner.js";
 /** 返回脚本在退出码 0 时打到 stderr 的提示（同步失败等）；没有提示就是空串。 */
 async function run(workspace, sub, args) {
-    const result = await runLedgerCommand(sub, [...args, '--repo', workspace.path], {
+    const result = await runLedgerCommand(sub, [...args, "--repo", workspace.path], {
         cwd: workspace.path,
         timeoutMs: WRITE_TIMEOUT_MS,
     });
     if (!result.ok)
         throw new Error(`${workspace.title}：${result.error}`);
-    return result.notice ?? '';
+    return result.notice ?? "";
 }
-/** 认领：只有 open 且无人认领才能接（脚本内判定），owner = 当前工作区的 git 身份。 */
+/** 认领：只有 open 且无人认领才能接（脚本内判定），owner = 工作区的 git 邮箱。 */
 export function claimTask(workspace, taskId) {
-    return run(workspace, 'claim', ['--id', taskId]);
+    return run(workspace, "claim", ["--id", taskId]);
 }
-/** 释放：退回待认领（owner / started 清空），只许当前 owner 本人（脚本内判定）。 */
+/**
+ * 释放：写回公共池（owner / started 清空、status 回 open），只许当前 owner 本人（脚本内判定）。
+ *
+ * 走 `set --owner ''`（空 owner = 释放）而不是 `set --status open`：后者只改状态，
+ * 分片里那行不会回到公共池，别人永远看不到这条待认领。
+ */
 export function releaseTask(workspace, taskId) {
-    return run(workspace, 'set', ['--id', taskId, '--status', 'open']);
+    return run(workspace, "set", ["--id", taskId, "--owner", ""]);
 }

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

@@ -1,4 +1,4 @@
-import type { LedgerWorkspace } from '../types.js';
+import type { LedgerWorkspace } from "../types.js";
 /** 模型路由：provider 与 model 必须成对。 */
 export interface ModelRoute {
     readonly provider: string;
@@ -7,9 +7,9 @@ export interface ModelRoute {
 /** 会话首条 user 消息（`@deepseek-ai/dsh-llm` UserMessage 的最小同形面）。 */
 export interface UserMessageLike {
     readonly id: string;
-    readonly role: 'user';
+    readonly role: "user";
     readonly content: readonly {
-        readonly type: 'text';
+        readonly type: "text";
         readonly text: string;
     }[];
     /**
@@ -18,7 +18,7 @@ export interface UserMessageLike {
      */
     readonly source: {
         readonly kind: string;
-        readonly form: 'notice';
+        readonly form: "notice";
         readonly summary: string;
     };
 }
@@ -37,7 +37,7 @@ export interface AgentsLike {
         readonly setup?: (agentCtx: unknown) => void | Promise<void>;
     }): Promise<{
         readonly agent: {
-            send(message: UserMessageLike, target: 'next-turn' | 'next-step', wakeup: boolean): void;
+            send(message: UserMessageLike, target: "next-turn" | "next-step", wakeup: boolean): void;
         };
     }>;
 }
@@ -53,7 +53,7 @@ export interface DefaultModelLike {
     currentSelection(): ModelRoute;
 }
 /** 交接失败的原因码（路由层据此给状态码，文案在这里写成能直接上界面的）。 */
-export type HandoffErrorCode = 'no-agents' | 'no-preset' | 'no-model' | 'task-missing' | 'create-failed' | 'send-failed';
+export type HandoffErrorCode = "no-agents" | "no-preset" | "no-model" | "task-missing" | "create-failed" | "send-failed";
 export declare class HandoffError extends Error {
     readonly code: HandoffErrorCode;
     constructor(code: HandoffErrorCode, message: string);

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

@@ -14,15 +14,15 @@
  * 本文件只管「结束任务」这一条（2026-10-18 用户拍板：认领 / 释放由 host 直写、不开会话；
  * 结束要走会话，因为要带用户留言、要模型读过程文档后写摘要）。
  */
-import { randomUUID } from 'node:crypto';
-import { getTask } from '../repositories/ledger.repository.js';
-import { SKILL_SCRIPT } from '../skill/registration.js';
+import { randomUUID } from "node:crypto";
+import { getTask } from "../repositories/ledger.repository.js";
+import { SKILL_SCRIPT } from "../skill/registration.js";
 export class HandoffError extends Error {
     code;
     constructor(code, message) {
         super(message);
         this.code = code;
-        this.name = 'HandoffError';
+        this.name = "HandoffError";
     }
 }
 /**
@@ -35,31 +35,33 @@ export class HandoffError extends Error {
  * ③ 写台账只经 skill 脚本（插件不手改文件，close 由模型执行）。
  */
 export function buildClosePrompt(input) {
-    const worklog = input.worklogPath === null || input.worklogPath === ''
-        ? '（这条任务没有登记过程文档）'
+    const worklog = input.worklogPath === null || input.worklogPath === ""
+        ? "（这条任务没有登记过程文档）"
         : `${input.workspacePath}/ledger/${input.worklogPath}`;
-    const message = input.message.trim() === '' ? '（用户没有留具体内容）' : input.message.trim();
+    const message = input.message.trim() === ""
+        ? "（用户没有留具体内容）"
+        : input.message.trim();
     return [
         `用户从任务台账看板点了「结束」，要把任务「${input.title}」（任务号 ${input.taskId}）结案。`,
-        '',
+        "",
         `工作区：${input.workspacePath}`,
         `过程文档：${worklog}`,
-        '',
-        '请按顺序做完这三件，然后停下：',
-        '1. 读过程文档的「背景 / 待办 / 下一步」，核对这次到底做了什么、还留了什么坑。',
+        "",
+        "请按顺序做完这三件，然后停下：",
+        "1. 读过程文档的「背景 / 待办 / 下一步」，核对这次到底做了什么、还留了什么坑。",
         `2. 用 task-ledger skill 的脚本结案（在工作区目录下、原样执行这一条命令）：`,
         `   python3 ${SKILL_SCRIPT} close --id ${input.taskId} --repo ${input.workspacePath} --summary "<一句话说清做成了什么、留了什么坑>"`,
-        '   `--summary` 是必填参数，不许编套话；命令报错就原样报告错误，不要自己绕过、不要手改台账文件。',
-        '3. 收尾即结束——这就是本条消息的全部要求。',
-        '',
-        '【硬约束】',
-        '- 不要在会话里继续派活，**不要新建会话或子 agent**：这是收尾动作，不是新任务的开始。',
-        '- 用户已经明确要结束，不会再回答提问：信息不足就按留言与过程文档如实写进摘要/结论，**不要停下来反问**。',
-        '- 只动这一个任务，不顺带改别的记录；写台账只经上面那个 skill 脚本。',
-        '',
-        '用户现在处理结束，以下是用户的留言：',
+        "   `--summary` 是必填参数，不许编套话；命令报错就原样报告错误，不要自己绕过、不要手改台账文件。",
+        "3. 收尾即结束——这就是本条消息的全部要求。",
+        "",
+        "【硬约束】",
+        "- 不要在会话里继续派活，**不要新建会话或子 agent**：这是收尾动作，不是新任务的开始。",
+        "- 用户已经明确要结束，不会再回答提问：信息不足就按留言与过程文档如实写进摘要/结论，**不要停下来反问**。",
+        "- 只动这一个任务，不顺带改别的记录；写台账只经上面那个 skill 脚本。",
+        "",
+        "用户现在处理结束，以下是用户的留言：",
         message,
-    ].join('\n');
+    ].join("\n");
 }
 /**
  * 起一个「结束任务」会话并发出首条提示词。
@@ -68,24 +70,24 @@ export function buildClosePrompt(input) {
 export async function startCloseSession(deps, request) {
     const agents = deps.agents;
     if (agents === undefined) {
-        throw new HandoffError('no-agents', '宿主未暴露 agents 服务，起不了会话（按钮交接暂不可用）');
+        throw new HandoffError("no-agents", "宿主未暴露 agents 服务，起不了会话（按钮交接暂不可用）");
     }
     const presets = deps.presets;
     if (presets === undefined) {
-        throw new HandoffError('no-preset', '宿主未暴露 agentPresets 服务：起出来的会话没有 fs / bash 工具，模型跑不了 close');
+        throw new HandoffError("no-preset", "宿主未暴露 agentPresets 服务：起出来的会话没有 fs / bash 工具，模型跑不了 close");
     }
     const route = resolveModelRoute(deps.defaultModel, request.model);
     // 任务此刻必须还在在办里（刚被别处结案 ⇒ 明确告知，不拿空标题去建会话）。
     const task = await getTask(request.workspace, request.taskId);
     if (task === null) {
-        throw new HandoffError('task-missing', `任务 ${request.taskId} 不在「${request.workspace.title}」的在办列表里（可能已被结案）`);
+        throw new HandoffError("task-missing", `任务 ${request.taskId} 不在「${request.workspace.title}」的在办列表里（可能已被结案）`);
     }
     let presetId;
     try {
         presetId = (await presets.resolve()).id;
     }
     catch (error) {
-        throw new HandoffError('no-preset', `解析默认 preset 失败：${error instanceof Error ? error.message : String(error)}`);
+        throw new HandoffError("no-preset", `解析默认 preset 失败：${error instanceof Error ? error.message : String(error)}`);
     }
     const sessionId = randomUUID();
     let handle;
@@ -96,11 +98,13 @@ export async function startCloseSession(deps, request) {
             meta: { cwd: request.workspace.path, agentPreset: presetId },
             agentOptions: { provider: route.provider, model: route.model },
             // setup 是发布前唯一能挂工具 / prompt sections / skill 的时机；抛错则整个作用域回滚。
-            setup: async (agentCtx) => { await presets.mount(agentCtx, presetId); },
+            setup: async (agentCtx) => {
+                await presets.mount(agentCtx, presetId);
+            },
         });
     }
     catch (error) {
-        throw new HandoffError('create-failed', `会话没建起来（preset=${presetId}）：${error instanceof Error ? error.message : String(error)}`);
+        throw new HandoffError("create-failed", `会话没建起来（preset=${presetId}）：${error instanceof Error ? error.message : String(error)}`);
     }
     const prompt = buildClosePrompt({
         title: task.title ?? request.taskId,
@@ -112,13 +116,17 @@ export async function startCloseSession(deps, request) {
     try {
         handle.agent.send({
             id: randomUUID(),
-            role: 'user',
-            content: [{ type: 'text', text: prompt }],
-            source: { kind: 'task-ledger', form: 'notice', summary: `结束任务 · ${task.title ?? request.taskId}` },
-        }, 'next-turn', true);
+            role: "user",
+            content: [{ type: "text", text: prompt }],
+            source: {
+                kind: "task-ledger",
+                form: "notice",
+                summary: `结束任务 · ${task.title ?? request.taskId}`,
+            },
+        }, "next-turn", true);
     }
     catch (error) {
-        throw new HandoffError('send-failed', `会话已建（${sessionId}）但首条消息没发出去：${error instanceof Error ? error.message : String(error)}`);
+        throw new HandoffError("send-failed", `会话已建（${sessionId}）但首条消息没发出去：${error instanceof Error ? error.message : String(error)}`);
     }
     return { sessionId };
 }
@@ -128,18 +136,20 @@ export async function startCloseSession(deps, request) {
  */
 export function resolveModelRoute(defaultModel, explicit) {
     if (explicit !== undefined) {
-        if (explicit.provider === '' || explicit.model === '') {
-            throw new HandoffError('no-model', 'provider 与 model 必须成对给出（只给一半会被拒，不做猜测）');
+        if (explicit.provider === "" || explicit.model === "") {
+            throw new HandoffError("no-model", "provider 与 model 必须成对给出（只给一半会被拒，不做猜测）");
         }
         return explicit;
     }
     if (defaultModel !== undefined) {
         try {
             const route = defaultModel.currentSelection();
-            if (route.provider !== '' && route.model !== '')
+            if (route.provider !== "" && route.model !== "")
                 return { provider: route.provider, model: route.model };
         }
-        catch { /* 读不到就往下走，报同一句人话 */ }
+        catch {
+            /* 读不到就往下走，报同一句人话 */
+        }
     }
-    throw new HandoffError('no-model', '宿主没有可用的默认模型：请在请求里给出 provider + model');
+    throw new HandoffError("no-model", "宿主没有可用的默认模型：请在请求里给出 provider + model");
 }

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

@@ -1,5 +1,12 @@
-import { type DegradedInfo } from '../errors.js';
-import type { ClosedSummary, LedgerFilter, LedgerWorkspace, TrendPeriods, TrendScope } from '../types.js';
+/**
+ * 首页**慢路径**用例：近 8 周趋势 + 四个自然周期。
+ * 读 history（months=RECENT_MONTHS）+ 在办 + git 身份——首屏不等它（异步/按需拉）。
+ *
+ * ⚠️ 窗口必须是 13 个月而不是 2：8 周桶在月初会横跨 3 个自然月（如 10 月第 1 周回溯到 8 月），
+ * `--months` 是**文件级**过滤，缩到 2 会静默漏掉 8 月结案记录、趋势少算（2026-10-18 架构评审结论）。
+ */
+import { type DegradedInfo } from "../errors.js";
+import type { ClosedSummary, LedgerFilter, LedgerWorkspace, TrendPeriods, TrendScope } from "../types.js";
 /** 历史窗口：只读最近 13 个月的文件（2026-10-17 拍板；脚本默认读全部，窗口由插件显式传）。 */
 export declare const RECENT_MONTHS = 13;
 /** 趋势图桶数：近 8 周（2026-10-17 定稿）。 */

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

@@ -5,10 +5,10 @@
  * ⚠️ 窗口必须是 13 个月而不是 2：8 周桶在月初会横跨 3 个自然月（如 10 月第 1 周回溯到 8 月），
  * `--months` 是**文件级**过滤，缩到 2 会静默漏掉 8 月结案记录、趋势少算（2026-10-18 架构评审结论）。
  */
-import { readHistory, readTasks } from '../repositories/ledger.repository.js';
-import { getCurrentIdentity } from '../repositories/identity.repository.js';
-import { settleWorkspaces } from '../errors.js';
-import { buildWeeks, dayOf, inWindow, monthWindow, mondayOf, weekWindow, ymd } from './dates.js';
+import { settleWorkspaces } from "../errors.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 个月的文件（2026-10-17 拍板；脚本默认读全部，窗口由插件显式传）。 */
 export const RECENT_MONTHS = 13;
 /** 趋势图桶数：近 8 周（2026-10-17 定稿）。 */
@@ -44,7 +44,8 @@ export function computeClosedSummary(scopes, now) {
         if (createdDay === null)
             return;
         for (let i = 0; i < weeks.length; i += 1) {
-            if (createdDay <= weekEnds[i] && (closeDay === null || closeDay > weekEnds[i])) {
+            if (createdDay <= weekEnds[i] &&
+                (closeDay === null || closeDay > weekEnds[i])) {
                 const bucket = map.get(weeks[i].week);
                 if (bucket !== undefined)
                     bucket.remaining += 1;
@@ -59,9 +60,9 @@ export function computeClosedSummary(scopes, now) {
                 continue;
             const week = ymd(mondayOf(created));
             const createdMine = identity !== null && (task.creator ?? null) === identity;
-            bump(bucketsAll, week, 'created');
+            bump(bucketsAll, week, "created");
             if (createdMine)
-                bump(bucketsMine, week, 'created');
+                bump(bucketsMine, week, "created");
             const ownedMine = identity !== null && (task.owner ?? null) === identity;
             bumpRemaining(bucketsAll, created, null);
             if (ownedMine)
@@ -71,19 +72,21 @@ export function computeClosedSummary(scopes, now) {
             const closed = dayOf(record.time);
             if (closed !== null) {
                 const week = ymd(mondayOf(closed));
-                bump(bucketsAll, week, 'done');
+                bump(bucketsAll, week, "done");
                 if (identity !== null && (record.owner ?? null) === identity)
-                    bump(bucketsMine, week, 'done');
+                    bump(bucketsMine, week, "done");
             }
             const created = dayOf(record.created);
             if (created !== null) {
                 const week = ymd(mondayOf(created));
-                bump(bucketsAll, week, '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 = identity !== null &&
+                    ((record.creator ?? null) === identity ||
+                        ((record.creator ?? null) === null &&
+                            (record.owner ?? null) === identity));
                 if (createdMine)
-                    bump(bucketsMine, week, 'created');
+                    bump(bucketsMine, week, "created");
             }
             const ownedMine = identity !== null && (record.owner ?? null) === identity;
             bumpRemaining(bucketsAll, created, closed);
@@ -92,9 +95,13 @@ export function computeClosedSummary(scopes, now) {
         }
     }
     const toBuckets = (map) => weeks.map((slot, i) => ({
-        week: slot.week, end: weekEnds[i], ...(map.get(slot.week) ?? { done: 0, created: 0, remaining: 0 }),
+        week: slot.week,
+        end: weekEnds[i],
+        ...(map.get(slot.week) ?? { done: 0, created: 0, remaining: 0 }),
     }));
-    return { weekly: { all: toBuckets(bucketsAll), mine: toBuckets(bucketsMine) } };
+    return {
+        weekly: { all: toBuckets(bucketsAll), mine: toBuckets(bucketsMine) },
+    };
 }
 /** 四个自然周期（只算「全部工作区」范围；图表切换不带动卡片）——纯函数。 */
 export function computeTrendPeriods(scopes, now) {
@@ -104,14 +111,24 @@ export function computeTrendPeriods(scopes, now) {
         thisMonth: monthWindow(0, now),
         lastMonth: monthWindow(-1, now),
     };
-    const doneEntries = scopes.flatMap((scope) => scope.history.map((record) => ({ day: dayOf(record.time), owner: record.owner ?? null })));
+    const doneEntries = scopes.flatMap((scope) => scope.history.map((record) => ({
+        day: dayOf(record.time),
+        owner: record.owner ?? null,
+    })));
     const createdEntries = scopes.flatMap((scope) => [
-        ...scope.tasks.map((task) => ({ day: dayOf(task.created), owner: task.owner ?? null })),
-        ...scope.history.map((record) => ({ day: dayOf(record.created), owner: record.owner ?? null })),
+        ...scope.tasks.map((task) => ({
+            day: dayOf(task.created),
+            owner: task.owner ?? null,
+        })),
+        ...scope.history.map((record) => ({
+            day: dayOf(record.created),
+            owner: record.owner ?? null,
+        })),
     ]);
     const period = (window) => ({
         done: doneEntries.filter((entry) => inWindow(entry.day, window)).length,
-        created: createdEntries.filter((entry) => inWindow(entry.day, window)).length,
+        created: createdEntries.filter((entry) => inWindow(entry.day, window))
+            .length,
         from: window.from,
         to: window.to,
     });
@@ -125,8 +142,12 @@ export function computeTrendPeriods(scopes, now) {
 /** 慢路径端点：趋势 + 周期（读 history）。异步加载，首屏不等。单工作区坏 ⇒ 进 degraded。 */
 export async function getTrend(workspaces) {
     const now = new Date();
-    const { data: scopes, degraded } = await settleWorkspaces(workspaces, 'history', readTrendScope, (rows) => rows);
-    return { closed: computeClosedSummary(scopes, now), trend: computeTrendPeriods(scopes, now), degraded };
+    const { data: scopes, degraded } = await settleWorkspaces(workspaces, "history", readTrendScope, (rows) => rows);
+    return {
+        closed: computeClosedSummary(scopes, now),
+        trend: computeTrendPeriods(scopes, now),
+        degraded,
+    };
 }
 /** 趋势端点用的历史 filter（窗口由本模块策略决定，repository 零默认值注入）。 */
 export function trendHistoryFilter(extra = {}) {

package/dist/host/skill/registration.d.ts

@@ -9,7 +9,7 @@ export interface SkillRegistration {
     path?: string;
     source?: string;
     resourceBase?: {
-        kind: 'directory';
+        kind: "directory";
         path: string;
     };
     metadata?: Record<string, unknown>;

package/dist/host/skill/registration.js

@@ -2,27 +2,32 @@
  * 内嵌 skill 的注册体组装（任务 2「skill 注册最小闭环」）。
  * 宿主事实（0.2.0-rc.2 npm pack 亲验）：external/dsh-skill-registration.md。
  */
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 /** 内嵌 skill 目录：dist/host/skill/registration.js → 包根 skill/（copy-skill 产物；
  *  比原 host/skill-registration.js 深一层 ⇒ 相对路径多一级 `../`）。 */
-const SKILL_DIR = fileURLToPath(new URL('../../../skill', import.meta.url));
+const SKILL_DIR = fileURLToPath(new URL("../../../skill", import.meta.url));
 /** SKILL.md 里指示脚本位置的占位符（注册时替换为绝对路径，模型据此找到脚本）。 */
-const SKILL_DIR_TOKEN = '<本 SKILL.md 所在目录>';
+const SKILL_DIR_TOKEN = "<本 SKILL.md 所在目录>";
 /** skill 脚本绝对路径（提示词里直接给「原样执行这一条」的命令用；与注册共用同一份目录知识）。 */
 export const SKILL_SCRIPT = `${SKILL_DIR}/scripts/progress.py`;
 /** frontmatter 最小解析：只取 name / description（不引 YAML 库；值去首尾引号）。 */
 function parseFrontmatter(text) {
     const match = /^---\n([\s\S]*?)\n---/.exec(text);
     if (match === null)
-        throw new Error('SKILL.md 缺 frontmatter（--- 包裹的头）');
+        throw new Error("SKILL.md 缺 frontmatter（--- 包裹的头）");
     const field = (key) => {
-        const line = (match[1] ?? '').split('\n').find((item) => item.startsWith(`${key}:`));
+        const line = (match[1] ?? "")
+            .split("\n")
+            .find((item) => item.startsWith(`${key}:`));
         if (line === undefined)
             throw new Error(`SKILL.md frontmatter 缺 ${key}`);
-        return line.slice(key.length + 1).trim().replace(/^["']|["']$/g, '');
+        return line
+            .slice(key.length + 1)
+            .trim()
+            .replace(/^["']|["']$/g, "");
     };
-    return { name: field('name'), description: field('description') };
+    return { name: field("name"), description: field("description") };
 }
 /**
  * 组装注册体：读内嵌 SKILL.md → 取 name / description → 正文里的脚本路径占位符
@@ -33,14 +38,14 @@ function parseFrontmatter(text) {
  * 拍板后如改走 resourceBase，只动本函数，调用方无感。
  */
 export function buildSkillRegistration(skillDir = SKILL_DIR) {
-    const text = readFileSync(`${skillDir}/SKILL.md`, 'utf-8');
+    const text = readFileSync(`${skillDir}/SKILL.md`, "utf-8");
     const { name, description } = parseFrontmatter(text);
     const content = text.split(SKILL_DIR_TOKEN).join(skillDir);
     if (content.includes(SKILL_DIR_TOKEN)) {
-        throw new Error('占位符替换失败：SKILL.md 里仍残留脚本路径占位符');
+        throw new Error("占位符替换失败：SKILL.md 里仍残留脚本路径占位符");
     }
     if (!content.includes(`${skillDir}/scripts/progress.py`)) {
-        throw new Error('占位符替换异常：替换后找不到脚本路径');
+        throw new Error("占位符替换异常：替换后找不到脚本路径");
     }
     return { name, description, content, path: `${skillDir}/SKILL.md` };
 }

package/dist/host/workspace.d.ts

@@ -1,4 +1,4 @@
-import type { LedgerWorkspace } from './types.js';
+import type { LedgerWorkspace } from "./types.js";
 /** 宿主 workspaceRegistry.list() 条目的最小面（结构声明；事实与坐标见 external/dsh-workspace-registry.md）。 */
 export interface RegistryWorkspace {
     readonly id: string;

package/dist/host/workspace.js

@@ -1,4 +1,4 @@
-import { hasLedger } from './repositories/ledger.repository.js';
+import { hasLedger } from "./repositories/ledger.repository.js";
 /**
  * 工作区发现：宿主 registry 全量 → 逐个查 <path>/ledger/progress.json，只返回有的。
  * 未初始化（有 ledger/ 无 progress.json）= 隐藏，后端无此概念（2026-10-17 拍板）。
@@ -9,5 +9,9 @@ import { hasLedger } from './repositories/ledger.repository.js';
 export function resolveWorkspaces(registryList) {
     return registryList
         .filter((workspace) => hasLedger(workspace.path))
-        .map((workspace) => ({ id: workspace.id, title: workspace.title, path: workspace.path }));
+        .map((workspace) => ({
+        id: workspace.id,
+        title: workspace.title,
+        path: workspace.path,
+    }));
 }