dsh-task-ledger 0.0.125 → 0.0.127

package/dist/host/repositories/runner.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { IdentityMissingError } from "../errors.js";
 /**
  * 内嵌 skill 入口的默认路径：dist/host/repositories/runner.js → 包根 skill/scripts/progress
  * （比原 host/script.js 深一层 ⇒ 相对路径多一级 `../`）。
@@ -11,6 +12,32 @@ 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;
+/** 脚本绝对路径（界面上要写给用户复制的命令用；别在别处再拼一份）。 */
+export function scriptPath() {
+    return DEFAULT_SCRIPT_PATH;
+}
+/**
+ * 脚本失败的统一出口：**没身份单独成类**（→ `LEDGER_IDENTITY_MISSING`），其余照旧是普通 Error。
+ * 各处别自己 `new Error(result.error)` —— 那样「没身份」就淹进「台账坏了」里，界面分不出来。
+ */
+export function failureOf(result, prefix = "", workspaceId = null) {
+    const message = `${prefix}${result.error}`;
+    return result.identityMissing === true
+        ? new IdentityMissingError(message, workspaceId)
+        : new Error(message);
+}
+/** skill 侧 `ExitIdentityMissing`（`packages/skill/src/internal/shell/runner.go`）。 */
+const IDENTITY_MISSING_EXIT = 100;
+/** skill 过程标记的行前缀（`shell/render.go` 的 stepf）。 */
+const STEP_PREFIX = "#step ";
+/** 去掉 stderr 里的过程标记行：报错文案只留人话，别把 `#step` 漏到界面上。 */
+function withoutSteps(stderr) {
+    return stderr
+        .split("\n")
+        .filter((line) => !line.startsWith(STEP_PREFIX))
+        .join("\n")
+        .trim();
+}
 /**
  * 起一次台账程序、收 stdout / stderr。出错一律归一成人话（起不了程序 / 超时 / 非零退出）。
  * 解析留给调用方：读命令要 JSON，写命令要原文。
@@ -18,12 +45,18 @@ const DEFAULT_TIMEOUT_MS = 10_000;
 function exec(sub, args, opts) {
     const scriptPath = opts?.scriptPath ?? DEFAULT_SCRIPT_PATH;
     const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const onStep = opts?.onStep;
     return new Promise((resolve) => {
         const child = spawn(scriptPath, [sub, ...args], {
             stdio: ["ignore", "pipe", "pipe"],
+            env: onStep === undefined
+                ? process.env
+                : { ...process.env, TASK_LEDGER_STEPS: "1" },
         });
         let stdout = "";
         let stderr = "";
+        /** 未收完的一行（stderr 是流，标记可能被切在两个 chunk 里）。 */
+        let stderrRest = "";
         let settled = false;
         const timer = setTimeout(() => {
             child.kill();
@@ -43,7 +76,17 @@ function exec(sub, args, opts) {
             stdout += chunk.toString();
         });
         child.stderr.on("data", (chunk) => {
-            stderr += chunk.toString();
+            const text = chunk.toString();
+            stderr += text;
+            if (onStep === undefined)
+                return;
+            stderrRest += text;
+            const lines = stderrRest.split("\n");
+            stderrRest = lines.pop() ?? "";
+            for (const line of lines) {
+                if (line.startsWith(STEP_PREFIX))
+                    onStep(line.slice(STEP_PREFIX.length));
+            }
         });
         child.on("error", (error) => {
             settle({
@@ -52,14 +95,16 @@ function exec(sub, args, opts) {
             });
         });
         child.on("close", (code) => {
+            const message = withoutSteps(stderr);
             if (code !== 0) {
                 settle({
                     ok: false,
-                    error: stderr.trim() || `台账程序退出码 ${String(code)}`,
+                    error: message || `台账程序退出码 ${String(code)}`,
+                    exitCode: code ?? undefined,
                 });
                 return;
             }
-            settle({ ok: true, stdout, stderr: stderr.trim() });
+            settle({ ok: true, stdout, stderr: message });
         });
     });
 }
@@ -73,9 +118,26 @@ function exec(sub, args, opts) {
  * @param opts.timeoutMs - 覆盖超时
  */
 export async function runLedgerScript(sub, args, opts) {
+    return parseScriptResult(await exec(sub, args, opts));
+}
+/** 写命令：认领 / 释放 / 结案这类改台账的动作走它（读命令走 `runLedgerScript`）。 */
+export async function runLedgerCommand(sub, args, opts) {
     const result = await exec(sub, args, opts);
     if (!result.ok)
-        return result;
+        return {
+            ok: false,
+            error: result.error,
+            identityMissing: result.exitCode === IDENTITY_MISSING_EXIT,
+        };
+    return { ok: true, output: result.stdout.trim() };
+}
+function parseScriptResult(result) {
+    if (!result.ok)
+        return {
+            ok: false,
+            error: result.error,
+            identityMissing: result.exitCode === IDENTITY_MISSING_EXIT,
+        };
     try {
         return { ok: true, data: JSON.parse(result.stdout) };
     }

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

@@ -10,7 +10,7 @@
  */
 import { LedgerDataError } from "../errors.js";
 import { cached, cacheKey } from "./cache.js";
-import { runLedgerScript } from "./runner.js";
+import { failureOf, runLedgerScript } from "./runner.js";
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -29,7 +29,7 @@ export async function readStats(workspace) {
             "--json",
         ]);
         if (!result.ok)
-            throw new Error(`${workspace.title}: ${result.error}`);
+            throw failureOf(result, `${workspace.title}: `, workspace.id);
         return parseStats(result.data, workspace.title);
     });
 }

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

@@ -0,0 +1,12 @@
+/** 界面行内按钮对应的动作：认领 / 释放 / 取消归档 / 正常结案。 */
+export type TaskAction = "claim" | "release" | "cancel" | "close";
+/** 写命令的阶段 key（与 skill `runner.go` 里的 `stepf(...)` 一一对应）。 */
+export type TaskActionStep = "check" | "sync" | "write" | "commit" | "push";
+/**
+ * 跑一条任务写命令。
+ *
+ * @param summary - 「取消」与「结案」都用：一句话理由 / 结案摘要，写进历史行与执行记录。
+ *   留空就不传 `--summary`（skill 允许取消不带摘要；正常结案由界面强制填）。
+ * @param onStep - 过程步骤回调（逐条转发给界面做进度翻牌），不传就不让 skill 打标记。
+ */
+export declare function runTaskAction(repo: string, id: string, action: TaskAction, summary?: string, onStep?: (step: TaskActionStep) => void): Promise<void>;

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

@@ -0,0 +1,63 @@
+import { failureOf, runLedgerCommand, } from "./runner.js";
+/**
+ * 任务写动作（认领 / 释放 / 取消归档）—— 一律走 skill，插件不碰台账文件。
+ *
+ * 写命令只回人话（`shell/render.go` 的 RenderResult），**不认 --json** ⇒ 走 `runLedgerCommand`
+ * 而不是 `runLedgerScript`。每条写命令内部都是「取最新 → 改 → 提交 → 推送」，
+ * 默认 10s 会被判超时（脚本被 kill 时可能改到一半）⇒ 与 rename / forget 同档给足时间。
+ */
+const WRITE_TIMEOUT_MS = 120_000;
+const ACTION_NAME = {
+    claim: "认领",
+    release: "释放",
+    cancel: "取消",
+    close: "结案",
+};
+/**
+ * 跑一条任务写命令。
+ *
+ * @param summary - 「取消」与「结案」都用：一句话理由 / 结案摘要，写进历史行与执行记录。
+ *   留空就不传 `--summary`（skill 允许取消不带摘要；正常结案由界面强制填）。
+ * @param onStep - 过程步骤回调（逐条转发给界面做进度翻牌），不传就不让 skill 打标记。
+ */
+export async function runTaskAction(repo, id, action, summary = "", onStep) {
+    const opts = {
+        timeoutMs: WRITE_TIMEOUT_MS,
+        ...(onStep === undefined
+            ? {}
+            : {
+                // skill 侧 key 是字符串，这里收窄成阶段联合类型（多一个 key 也不该让整条命令失败）
+                onStep: (step) => onStep(step),
+            }),
+    };
+    let result;
+    switch (action) {
+        case "claim":
+            result = await runLedgerCommand("claim", ["--id", id, "--repo", repo], opts);
+            break;
+        case "release":
+            result = await runLedgerCommand("set", ["--id", id, "--release", "--repo", repo], opts);
+            break;
+        case "close":
+            result = await runLedgerCommand("close", [
+                "--id",
+                id,
+                ...(summary === "" ? [] : ["--summary", summary]),
+                "--repo",
+                repo,
+            ], opts);
+            break;
+        case "cancel":
+            result = await runLedgerCommand("close", [
+                "--id",
+                id,
+                "--cancel",
+                ...(summary === "" ? [] : ["--summary", summary]),
+                "--repo",
+                repo,
+            ], opts);
+            break;
+    }
+    if (!result.ok)
+        throw failureOf(result, `${ACTION_NAME[action]}失败：`);
+}

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

@@ -1,6 +1,10 @@
-import type { LedgerWorkspace } from "../types.js";
-/** 趋势图的窗口（周数）：与首页右侧卡位一致（2026-10-17 定稿「近 8 周」）。 */
-export declare const TREND_WEEKS = 8;
+import type { BoardTrendGran, LedgerWorkspace } from "../types.js";
+/**
+ * 趋势图的窗口（周数）：近半年。
+ * 2026-10-30 由 8 周放宽 —— 卡片按宽度能放几周就放几周（宽屏 12~14 周），
+ * 8 周不够铺满，也没得翻页；26 周 ≈ 4 屏，左右箭头一次翻 4 周。
+ */
+export declare const TREND_WEEKS = 26;
 /** 一个人在一个周桶里的三个数（skill 口径：新增按 creator、完成 / 未结按 owner）。 */
 export interface OwnerCounts {
     readonly added: number;
@@ -30,7 +34,13 @@ export interface WorkspaceTrend {
     readonly coverageFrom: string;
     readonly coverageTo: string;
 }
-/** 单工作区趋势（skill `stats --trend week --last 8w --by-owner`；过 1.5s 读缓存）。 */
-export declare function readTrend(workspace: LedgerWorkspace): Promise<WorkspaceTrend>;
+/** 单工作区趋势（skill `stats --trend <gran> --last <N> --by-owner`；过 1.5s 读缓存）。 */
+export declare function readBoardTrend(workspace: LedgerWorkspace, gran: BoardTrendGran): Promise<WorkspaceTrend>;
+/**
+ * 历史页趋势的取数：`stats --trend <gran> --since --until`（明确窗口 ⇒ 不受
+ * day 粒度 365 桶上限的 --last 换算影响）。桶的切分 / 新增口径 / 补空桶全在 skill
+ * （用户 2026-10-30 定：聚合算法不自己写，host 只做跨工作区求和）。
+ */
+export declare function readTrendGran(workspace: LedgerWorkspace, gran: "day" | "week" | "month", since: string, until: string): Promise<WorkspaceTrend>;
 /** `stats --trend` → {@link WorkspaceTrend}（容器级严格：缺字段即坏，不当 0）。 */
 export declare function parseTrend(raw: unknown, where: string): WorkspaceTrend;

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

@@ -1,5 +1,5 @@
 /**
- * 趋势面取数：近 8 周的「完成 / 未结 / 新增」，**整段桶序列一次拿回**（skill `stats --trend`）。
+ * 趋势面取数：近 26 周的「完成 / 未结 / 新增」，**整段桶序列一次拿回**（skill `stats --trend`）。
  *
  * 为什么不再拼现有方法：`history` 只给明细、且按**结案时间**过滤（新增取不到）；
  * 插件侧拉全量明细再聚合已被实测否决（20 万条 3s+、30MB 过进程边界）。
@@ -10,10 +10,21 @@
  */
 import { LedgerDataError } from "../errors.js";
 import { cached, cacheKey } from "./cache.js";
-import { runLedgerScript } from "./runner.js";
-/** 趋势图的窗口（周数）：与首页右侧卡位一致（2026-10-17 定稿「近 8 周」）。 */
-export const TREND_WEEKS = 8;
-const TREND_LAST = `${String(TREND_WEEKS)}w`;
+import { failureOf, runLedgerScript } from "./runner.js";
+/**
+ * 趋势图的窗口（周数）：近半年。
+ * 2026-10-30 由 8 周放宽 —— 卡片按宽度能放几周就放几周（宽屏 12~14 周），
+ * 8 周不够铺满，也没得翻页；26 周 ≈ 4 屏，左右箭头一次翻 4 周。
+ */
+export const TREND_WEEKS = 26;
+/**
+ * 首页趋势图按粒度的一次取数窗口：周 26 周、日 182 天（同一段时间 ⇒ 切档不换可翻范围）。
+ * skill 的 day 粒度上限是 365 桶（见 `TrendMaxDayBuckets`），182 天在线内。
+ */
+const TREND_LAST = {
+    day: `${String(TREND_WEEKS * 7)}d`,
+    week: `${String(TREND_WEEKS)}w`,
+};
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -48,18 +59,34 @@ function parseOwners(raw, where) {
     }
     return out;
 }
-/** 单工作区趋势（skill `stats --trend week --last 8w --by-owner`；过 1.5s 读缓存）。 */
-export async function readTrend(workspace) {
+/** 单工作区趋势（skill `stats --trend <gran> --last <N> --by-owner`；过 1.5s 读缓存）。 */
+export async function readBoardTrend(workspace, gran) {
+    const last = TREND_LAST[gran];
     // 缓存 op 仍记 "stats"（脚本子命令就是 stats），detail 里写清是哪个窗口的趋势
-    return await cached(cacheKey(workspace.id, "stats", `trend:${TREND_LAST}`), async () => {
+    return await cached(cacheKey(workspace.id, "stats", `trend:${gran}:${last}`), async () => {
         // 趋势自带 JSON 输出，**不能**再传 --json（skill 那边是用法错）
         const result = await runLedgerScript("stats", 
         // --by-owner：一次就把「全部」与「按人」两套数都拿回来 ⇒ 勾「只看我的」零请求
-        ["--repo", workspace.path, "--trend", "week", "--last", TREND_LAST, "--by-owner"], 
-        // 8 周窗口最坏要读 3 个历史文件，比单月读重：给到 20s 再判超时
+        ["--repo", workspace.path, "--trend", gran, "--last", last, "--by-owner"], 
+        // 半年窗口最坏要读 7 个历史文件（skill 有月度缓存），比单月读重：给到 20s 再判超时
+        { timeoutMs: 20_000 });
+        if (!result.ok)
+            throw failureOf(result, `${workspace.title}: `, workspace.id);
+        return parseTrend(result.data, workspace.title);
+    });
+}
+/**
+ * 历史页趋势的取数：`stats --trend <gran> --since --until`（明确窗口 ⇒ 不受
+ * day 粒度 365 桶上限的 --last 换算影响）。桶的切分 / 新增口径 / 补空桶全在 skill
+ * （用户 2026-10-30 定：聚合算法不自己写，host 只做跨工作区求和）。
+ */
+export async function readTrendGran(workspace, gran, since, until) {
+    return await cached(cacheKey(workspace.id, "stats", `trend:${gran}:${since}:${until}`), async () => {
+        const result = await runLedgerScript("stats", ["--repo", workspace.path, "--trend", gran, "--since", since, "--until", until], 
+        // 与周趋势同档：整年窗口最坏要读十几个历史文件
         { timeoutMs: 20_000 });
         if (!result.ok)
-            throw new Error(`${workspace.title}: ${result.error}`);
+            throw failureOf(result, `${workspace.title}: `, workspace.id);
         return parseTrend(result.data, workspace.title);
     });
 }

package/dist/host/routes.d.ts

@@ -8,7 +8,8 @@
  * 详情 / 历史 / 筛选项 / 趋势 / 写动作的端点与实现已删除（要接回按 skill 方法重写，不复用旧直读逻辑）。
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { type RegistryWorkspace } from "./workspace.js";
+import { type AgentDefaultModelLike, type AgentPresetsLike, type AgentsLike, type SessionTitleLike } from "./services/continue.service.js";
+import type { RegistryWorkspace } from "./types.js";
 /** 宿主 webServer.register 的最小面（WebRoute 形状见 external/host-webserver.md）。 */
 export interface WebServerLike {
     register(route: {
@@ -23,5 +24,16 @@ export interface WorkspaceRegistryLike {
 }
 export interface RouteDeps {
     readonly registry: WorkspaceRegistryLike;
+    /**
+     * 「继续」要用的宿主面：**按需现取**（服务可能晚于路由就位）。
+     * 取不到就返回 undefined，由 service 报人话 —— 不写进上面那个 inject 依赖表，
+     * 否则任一服务缺席都会让整块数据面永远 pending（入口注释里的那条老坑）。
+     */
+    readonly agents?: () => AgentsLike | undefined;
+    readonly presets?: () => AgentPresetsLike | undefined;
+    readonly defaultModel?: () => AgentDefaultModelLike | undefined;
+    readonly sessionTitle?: () => SessionTitleLike | undefined;
 }
+/** 核心 explorer 的只读文件路由（`serveFsRoute` 挂这里，client 的 `connectFs` 用同一个值）。 */
+export declare const FS_ROUTE = "/api/task-ledger/fs";
 export declare function registerRoutes(webServer: WebServerLike, deps: RouteDeps): void;