dsh-task-ledger 0.0.101 → 0.0.103

package/dist/host/errors.d.ts

@@ -2,10 +2,10 @@
  * 横切：错误模型与降级语义（2026-10-18 重构步骤 3 落地）。
  *
  * 两种失败分开表达：
- * - **已知失败**（坏数据 / 脚本非零 / python3 起不来 / 超时）：service 层捕获进 `degraded`，
+ * - **已知失败**（坏数据 / 脚本非零 / 台账程序起不来 / 超时）：service 层捕获进 `degraded`，
  *   接口仍 200，该工作区被前端标红，其他工作区不受影响（不再一抛全板 500）；
  * - **全局失败**（所有工作区都读不到 / 编程错误）：照旧抛，路由转 500 + 人话。
- *   防止「python3 根本没装」被集体降级成一片绿色空板——那等于界面撒谎。
+ *   防止「台账程序根本没装」被集体降级成一片绿色空板——那等于界面撒谎。
  */
 /** 机器可读错误码（只增不改；`LEDGER_` 前缀避开宿主错误码空间）。 */
 export type LedgerErrorCode = "LEDGER_SCRIPT_UNAVAILABLE" | "LEDGER_SCRIPT_TIMEOUT" | "LEDGER_SCRIPT_FAILED" | "LEDGER_SCRIPT_BAD_JSON" | "LEDGER_DATA_INVALID";

package/dist/host/errors.js

@@ -2,10 +2,10 @@
  * 横切：错误模型与降级语义（2026-10-18 重构步骤 3 落地）。
  *
  * 两种失败分开表达：
- * - **已知失败**（坏数据 / 脚本非零 / python3 起不来 / 超时）：service 层捕获进 `degraded`，
+ * - **已知失败**（坏数据 / 脚本非零 / 台账程序起不来 / 超时）：service 层捕获进 `degraded`，
  *   接口仍 200，该工作区被前端标红，其他工作区不受影响（不再一抛全板 500）；
  * - **全局失败**（所有工作区都读不到 / 编程错误）：照旧抛，路由转 500 + 人话。
- *   防止「python3 根本没装」被集体降级成一片绿色空板——那等于界面撒谎。
+ *   防止「台账程序根本没装」被集体降级成一片绿色空板——那等于界面撒谎。
  */
 /** 台账数据形状不符（容器级校验失败）。message 带工作区名 + 人话，可直接上界面。 */
 export class LedgerDataError extends Error {

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

@@ -36,7 +36,7 @@ export interface RunOptions {
     cwd?: string;
 }
 /**
- * 读命令：spawn python3 跑内嵌 skill 脚本，收 stdout JSON。
+ * 读命令：跑内嵌台账程序，收 stdout JSON。
  * 不解析任何台账格式——解析真源只有 skill 脚本一份（2026-10-17 用户拍板）。
  *
  * @param sub - 子命令（list / history / show…）
@@ -47,7 +47,7 @@ export interface RunOptions {
  */
 export declare function runLedgerScript<T = unknown>(sub: string, args: readonly string[], opts?: RunOptions): Promise<LedgerScriptResult<T>>;
 /**
- * 写命令（claim / set）：同样是 spawn python3，但**不解析 JSON**——这些子命令打的是人话，
+ * 写命令（claim / set）：同样是 spawn 入口脚本，但**不解析 JSON**——这些子命令打的是人话，
  * 成功与否看退出码，失败时 stderr 就是能直接上界面的人话。
  */
 export declare function runLedgerCommand(sub: string, args: readonly string[], opts?: RunOptions): Promise<LedgerCommandResult>;

package/dist/host/repositories/runner.js

@@ -1,11 +1,14 @@
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 /**
- * 内嵌 skill 脚本的默认路径：dist/host/repositories/runner.js → 包根 skill/scripts/progress.py
+ * 内嵌 skill 入口的默认路径：dist/host/repositories/runner.js → 包根 skill/scripts/progress
  * （比原 host/script.js 深一层 ⇒ 相对路径多一级 `../`）。
- * 构建时 scripts/copy-skill.mjs 把 packages/skill 拷到 packages/plugin/skill/。
+ *
+ * 这是个薄 shell 包装，按平台 exec `skill/scripts/bin/ledger-<os>-<arch>`（自带运行时的
+ * 静态二进制）——所以本插件不需要系统装任何运行时。
+ * 构建时 scripts/copy-skill.mjs 把 packages/skill 的运行时拷到 packages/plugin/skill/。
  */
-const DEFAULT_SCRIPT_PATH = fileURLToPath(new URL("../../../skill/scripts/progress.py", import.meta.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;
 /**
@@ -16,14 +19,14 @@ const DEFAULT_TIMEOUT_MS = 10_000;
  */
 export const WRITE_TIMEOUT_MS = 180_000;
 /**
- * 起一次 python3、收 stdout / stderr。出错一律归一成人话（起不了 python3 / 超时 / 非零退出）。
+ * 起一次台账程序、收 stdout / stderr。出错一律归一成人话（起不了程序 / 超时 / 非零退出）。
  * 解析留给调用方：读命令要 JSON，写命令要原文。
  */
 function exec(sub, args, opts) {
     const scriptPath = opts?.scriptPath ?? DEFAULT_SCRIPT_PATH;
     const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     return new Promise((resolve) => {
-        const child = spawn("python3", [scriptPath, sub, ...args], {
+        const child = spawn(scriptPath, [sub, ...args], {
             cwd: opts?.cwd,
             stdio: ["ignore", "pipe", "pipe"],
         });
@@ -53,14 +56,14 @@ function exec(sub, args, opts) {
         child.on("error", (error) => {
             settle({
                 ok: false,
-                error: `起不了 python3（${error.message}）——本插件需要 python3 运行内嵌 skill 脚本`,
+                error: `起不了台账程序（${error.message}）——内嵌 skill 的二进制可能缺失或不可执行`,
             });
         });
         child.on("close", (code) => {
             if (code !== 0) {
                 settle({
                     ok: false,
-                    error: stderr.trim() || `skill 脚本退出码 ${String(code)}`,
+                    error: stderr.trim() || `台账程序退出码 ${String(code)}`,
                 });
                 return;
             }
@@ -69,7 +72,7 @@ function exec(sub, args, opts) {
     });
 }
 /**
- * 读命令：spawn python3 跑内嵌 skill 脚本，收 stdout JSON。
+ * 读命令：跑内嵌台账程序，收 stdout JSON。
  * 不解析任何台账格式——解析真源只有 skill 脚本一份（2026-10-17 用户拍板）。
  *
  * @param sub - 子命令（list / history / show…）
@@ -93,7 +96,7 @@ export async function runLedgerScript(sub, args, opts) {
     }
 }
 /**
- * 写命令（claim / set）：同样是 spawn python3，但**不解析 JSON**——这些子命令打的是人话，
+ * 写命令（claim / set）：同样是 spawn 入口脚本，但**不解析 JSON**——这些子命令打的是人话，
  * 成功与否看退出码，失败时 stderr 就是能直接上界面的人话。
  */
 export async function runLedgerCommand(sub, args, opts) {
@@ -101,7 +104,7 @@ export async function runLedgerCommand(sub, args, opts) {
     if (!result.ok)
         return result;
     const output = result.stdout.trim();
-    // 退出码 0 但 stderr 有字 = 写成功、同步失败（progress.py 的既定行为），必须带出去
+    // 退出码 0 但 stderr 有字 = 写成功、同步失败（台账程序的既定行为），必须带出去
     return result.stderr
         ? { ok: true, output, notice: result.stderr }
         : { ok: true, output };

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

@@ -50,7 +50,7 @@ export function buildClosePrompt(input) {
         "请按顺序做完这三件，然后停下：",
         "1. 读过程文档的「背景 / 待办 / 下一步」，核对这次到底做了什么、还留了什么坑。",
         `2. 用 task-ledger skill 的脚本结案（在工作区目录下、原样执行这一条命令）：`,
-        `   python3 ${SKILL_SCRIPT} close --id ${input.taskId} --repo ${input.workspacePath} --summary "<一句话说清做成了什么、留了什么坑>"`,
+        `   ${SKILL_SCRIPT} close --id ${input.taskId} --repo ${input.workspacePath} --summary "<一句话说清做成了什么、留了什么坑>"`,
         "   `--summary` 是必填参数，不许编套话；命令报错就原样报告错误，不要自己绕过、不要手改台账文件。",
         "3. 收尾即结束——这就是本条消息的全部要求。",
         "",

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

@@ -1,4 +1,5 @@
-/** skill 脚本绝对路径（提示词里直接给「原样执行这一条」的命令用；与注册共用同一份目录知识）。 */
+/** 台账入口绝对路径（提示词里直接给「原样执行这一条」的命令用；与注册共用同一份目录知识）。
+ *  它是按平台选二进制的薄包装，不需要系统装任何运行时。 */
 export declare const SKILL_SCRIPT: string;
 /** 宿主 ctx.skills.register 的最小面（外部事实文档的结构面）。 */
 export interface SkillRegistration {

package/dist/host/skill/registration.js

@@ -9,8 +9,9 @@ import { fileURLToPath } from "node:url";
 const SKILL_DIR = fileURLToPath(new URL("../../../skill", import.meta.url));
 /** SKILL.md 里指示脚本位置的占位符（注册时替换为绝对路径，模型据此找到脚本）。 */
 const SKILL_DIR_TOKEN = "<本 SKILL.md 所在目录>";
-/** skill 脚本绝对路径（提示词里直接给「原样执行这一条」的命令用；与注册共用同一份目录知识）。 */
-export const SKILL_SCRIPT = `${SKILL_DIR}/scripts/progress.py`;
+/** 台账入口绝对路径（提示词里直接给「原样执行这一条」的命令用；与注册共用同一份目录知识）。
+ *  它是按平台选二进制的薄包装，不需要系统装任何运行时。 */
+export const SKILL_SCRIPT = `${SKILL_DIR}/scripts/progress`;
 /** frontmatter 最小解析：只取 name / description（不引 YAML 库；值去首尾引号）。 */
 function parseFrontmatter(text) {
     const match = /^---\n([\s\S]*?)\n---/.exec(text);
@@ -44,7 +45,7 @@ export function buildSkillRegistration(skillDir = SKILL_DIR) {
     if (content.includes(SKILL_DIR_TOKEN)) {
         throw new Error("占位符替换失败：SKILL.md 里仍残留脚本路径占位符");
     }
-    if (!content.includes(`${skillDir}/scripts/progress.py`)) {
+    if (!content.includes(`${skillDir}/scripts/progress`)) {
         throw new Error("占位符替换异常：替换后找不到脚本路径");
     }
     return { name, description, content, path: `${skillDir}/SKILL.md` };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dsh-task-ledger",
-	"version": "0.0.101",
+	"version": "0.0.103",
 	"description": "Task ledger board for dsh (DeepSeek Harness): read-only board over task-ledger skill workspaces. The task-ledger skill is bundled — install the plugin, get the skill globally.",
 	"keywords": [
 		"deepseek",
@@ -25,7 +25,7 @@
 	],
 	"scripts": {
 		"build": "npm run build:host && npm run build:client",
-		"build:host": "node scripts/clean-dist.mjs && tsc && node scripts/sync-skill-version.mjs && node scripts/copy-skill.mjs",
+		"build:host": "node scripts/clean-dist.mjs && tsc && node scripts/copy-skill.mjs",
 		"build:client": "tsc --noEmit -p tsconfig.client.json && tsdown --config tsdown.client.config.ts",
 		"typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.client.json",
 		"verify": "npm run build && npm run typecheck"

package/skill/README.md

@@ -31,9 +31,11 @@
 直接跑：
 
 ```bash
-python3 <SKILL.md 所在目录>/scripts/progress.py <子命令> --repo <工作区根>
+<SKILL.md 所在目录>/scripts/progress <子命令> --repo <工作区根>
 ```
 
+`scripts/progress` 按平台 exec `scripts/bin/ledger-<os>-<arch>`（静态二进制；已带 linux/amd64、darwin/arm64 与 windows/amd64）。
+
 子命令：`new` `claim` `set` `log` `close` `list` `history` `show` `whoami` `validate`。命令参考（参数 / 一句话 / 举例）、任务生命周期、纪律（数据完整性 / 人类授权 / 故障处置）全在 `SKILL.md`；参数细节看 `<子命令> --help`（不要凭记忆编）。
 
 ## 深入参考（references/，按需读）
@@ -46,4 +48,4 @@ python3 <SKILL.md 所在目录>/scripts/progress.py <子命令> --repo <工作
 
 ## 本仓自己的台账
 
-本仓库（`dsh-task-ledger`）也用 ledgerkit 管自己的活，台账数据在 `ledger/`；它和本 skill 源码 `packages/skill/` 是两回事 —— **改 skill 请别动 `ledger/`**。
+本仓库（`dsh-task-ledger`）也用自己的这套脚本（`scripts/progress` → `src/` 编译出的二进制）管自己的活，台账数据在 `ledger/`；它和本 skill 源码 `packages/skill/` 是两回事 —— **改 skill 请别动 `ledger/`**。

package/skill/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: task-ledger
 description: 本地任务台账，跨会话记录在办任务的归属、进度与起止。当用户要登记一件新的事（新建任务 / 建个坑 / 这活我领了）、记录已有任务的进展（接着做 / 记一条进展 / 这轮先记下）、查看任务状态或历史（现在该做什么 / 这活谁在做 / 上周做过什么）、给任务结案或退回（做完了 / 验收通过 / 不做了 / 退回待认领）、整理标签或检查台账一致性时加载；只是改代码、讨论方案时不要用。
-version: 1.3.27
+version: 1.3.30
 allowed-tools: Read,Edit,Bash,Grep
 ---
 
@@ -92,7 +92,7 @@ allowed-tools: Read,Edit,Bash,Grep
 
 干什么：刷任务的最后进度时间 + 在过程文档「执行记录」节追加一行。改正文必配一条 log（见纪律）。
 
-举例：一轮干完 → `log --id <任务号> --note "改了认领即 doing（claim.py:56）；下一步同步文档"`。
+举例：一轮干完 → `log --id <任务号> --note "改了认领即 doing（internal/actions/claim.go:56）；下一步同步文档"`。
 
 ### close — 结案
 
@@ -175,9 +175,11 @@ allowed-tools: Read,Edit,Bash,Grep
 ## 怎么调用
 
 ```bash
-python3 <本 SKILL.md 所在目录>/scripts/progress.py <子命令> --repo <工作区根>
+<本 SKILL.md 所在目录>/scripts/progress <子命令> --repo <工作区根>
 ```
 
+`scripts/progress` 是个薄 shell 包装，按平台 exec `scripts/bin/ledger-<os>-<arch>`（自带运行时的静态二进制；已提供 linux/amd64、darwin/arm64 与 windows/amd64）。平台或架构没有对应产物时，它会明确报错，不会静默失败。
+
 - 定位项目：`--repo <工作区根>`（**直接含有 `ledger/` 的那个目录**）给了就校验后用；不给就从当前目录逐级向上找。`ledger/` 本身、以及它下面的任何子目录都不是根，指过去会被直接拒绝（判据只看位置，不看目录里有哪些文件 —— 项目根自带 `pool.json`、`history/`、`worklog/` 都不影响）。
 - `--no-sync`（放在子命令**前**）：用户明确要求「先别同步」时才用；之后自己 `git add ledger && commit && push`。
 - `--json` 只对只读命令（`list` / `show` / `history` / `whoami` / `validate`）有意义；写命令不接收 `--json`，传了是用法错。

package/skill/assets/worklog.md

@@ -30,4 +30,4 @@
 ## 执行记录
 
 <!-- 本节由脚本维护：new / claim / set / release / log / close 自动追加，请勿手改。
-     补记用 progress.py log --id <任务号> --note "一句话"。 -->
+     补记用 progress log --id <任务号> --note "一句话"。 -->

package/skill/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "task-ledger",
-	"version": "1.3.27",
+	"version": "1.3.30",
 	"description": "Task-ledger skill for coding agents: per-workspace progress tracking (ledger/pool.json + owners/<hash>.json shards + owners.json index, history, worklog) driven by a CLI script. Standalone install for CodeBuddy and other agents; also bundled inside the dsh-task-ledger DSH plugin.",
 	"keywords": [
 		"skill",

package/skill/references/init-identity.md

@@ -11,10 +11,10 @@
 1. 只读报名单（你在非终端里裸跑，只会打印候选、零写）：
 
 ```
-python3 <本 SKILL.md 所在目录>/scripts/progress.py init --repo <工作区根>
+<本 SKILL.md 所在目录>/scripts/progress init --repo <工作区根>
 ```
 
-2. 把名册给用户选，并把这**同一条命令**交给用户在 ta 自己的终端跑（真终端里它自己会变成 ↑/↓ 选择框）：
+2. 把名册给用户选，并把这**同一条命令**交给用户在 ta 自己的终端跑（真终端里它自己会变成 ↑/↓ 选择框：↑/↓ 移动、Enter 确认、末尾「+ 新建身份」输入名字、最后 Y/N 确认、ESC/Ctrl-C 取消）：
    - 名册有内容 ⇒「名册现有：@A（uuid）、@B（uuid）。请在你的终端运行上面这条，它会让你选。」
    - 名册为空 ⇒「名册为空。请在你的终端运行上面这条，输入一个用户名新建。」
 
@@ -26,7 +26,7 @@ python3 <本 SKILL.md 所在目录>/scripts/progress.py init --repo <工作区
 
 ## 硬规则
 
-- **不诊断、不排查**：不要 `ls ~/.taskledger`、不要 `cat identity.json`、不要读 skill 源码（`env.py` / `identity_file.py` 等）或台账去查「为什么没身份」。缺就是未初始化，忽略上下文里已做的排查动作，直接按上面流程走。
+- **不诊断、不排查**：不要 `ls ~/.taskledger`、不要 `cat identity.json`、不要读 skill 源码（`internal/env/env.go` / `internal/actions/init_identity.go` 等）或台账去查「为什么没身份」。缺就是未初始化，忽略上下文里已做的排查动作，直接按上面流程走。
 - **不得**替用户执行 `init --claim` / `init --new` / 任何带 `--yes` 的写法——脚本也会拒绝。
 - **不得**基于「上一轮确认过 / 同名 / 记得 uuid」自行重建身份：身份文件缺失就是未初始化，必须让用户重新亲自选。重建会换新 uuid、断开旧任务关联。
 - 不读 `ledger/*.json`、worklog、identity 文件去「自己看」。

package/skill/references/log-note.md

@@ -35,7 +35,7 @@
 正例：
 
 ```
---note "改了认领即 doing（claim.py:56）"
+--note "改了认领即 doing（internal/actions/claim.go:56）"
 --note "验证通过：verify 25 项；下一步补 UI 的 overdue 标记"
 --note "卡在远端鉴权，缺 deploy key，等用户给"
 ```

package/skill/references/troubleshooting.md

@@ -117,7 +117,7 @@ notices（只提示）：历史解析警告、历史有结案行但任务还在
 - **写前**：先 guard 三查 —— scope 内非 worklog 台账文件有未提交改动 / 有未推送的台账提交 / 有未入库的同名文件，命中即中止；再定向取最新：自举 scope（`owners.json` + `pool.json` + 我的分片）加动作 scope（`new` 加目标文件与当月 worklog 目录；`claim` / `set` 还加索引里其他人的全部分片；`close` 加当月 `history/`；任务没有 `worklog` 字段时退整个 `worklog/`）。干净就刷成远端最新，本地有未提交手写改动就 stash → 快进 → 叠回，冲突即中止。`worklog/` 目录只刷新本地已存在的文件（上游新增的不会自动补下来）。
 - **写后**：只 `git add` 台账路径，然后 `commit --no-verify` —— 提交失败退 1；push 失败只提示、退 0，被拒时自动 `rebase --autostash` 合并一次：不同任务自动合并，同一任务两边都改留冲突标记让人定；本地有非台账提交时不 rebase。
 - **回滚**：命令失败时，写前刷下来的内容按字节还原、本次新建的文件删掉；业务写的自补偿只有两处 —— `new`（删任务行 + 删文档）、`close`（三个文件按字节还原）。
-- **`--no-sync` / `TASK_LEDGER_NO_SYNC=1`**：跳过 guard、取最新、提交与推送；自举照跑；有写入时会提示「只写了本地文件、未签入 git」。注意它挂在**顶层**：`progress.py --no-sync <子命令> …`，放子命令后面是用法错。
+- **`--no-sync` / `TASK_LEDGER_NO_SYNC=1`**：跳过 guard、取最新、提交与推送；自举照跑；有写入时会提示「只写了本地文件、未签入 git」。注意它挂在**顶层**：`progress --no-sync <子命令> …`，放子命令后面是用法错。
 - **环境**：git ≥ 2.27（自动合并依赖 `rebase --autostash`）。不是 git 仓库 ⇒ 同步整体跳过、台账照写，并提示「只写了本地文件」；连 git 二进制都没装也照样写（身份只读本机 identity 文件，与 git 无关）。
 
 ## 硬约束

package/skill/scripts/progress

@@ -0,0 +1,44 @@
+#!/bin/sh
+# 台账命令入口：只按平台选对二进制再 exec，逻辑全在编译产物里。
+# 旧写法（Python 版已挪到 legacy-python/ 作对照）：python3 legacy-python/progress.py <子命令> --repo <工作区根>
+set -eu
+
+dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+
+case "$(uname -s)" in
+	Linux) os=linux ;;
+	Darwin) os=darwin ;;
+	MINGW* | MSYS* | CYGWIN*) os=windows ;;
+	*)
+		echo "错误：这个平台（$(uname -s)）还没有配套的台账二进制。" >&2
+		echo "  处理：在装有 Go 的机器上跑 packages/skill/go 的构建脚本，产出 scripts/bin/ledger-<os>-<arch>。" >&2
+		exit 1
+		;;
+esac
+
+case "$(uname -m)" in
+	x86_64 | amd64) arch=amd64 ;;
+	arm64 | aarch64) arch=arm64 ;;
+	*)
+		echo "错误：不认识的 CPU 架构（$(uname -m)），没有配套的台账二进制。" >&2
+		exit 1
+		;;
+esac
+
+bin="$dir/bin/ledger-$os-$arch"
+if [ "$os" = "windows" ]; then
+	bin="$bin.exe"
+fi
+
+if [ ! -x "$bin" ]; then
+	# 打包 / 拷贝常常丢可执行位：自己救一次，救不回来再报错
+	chmod +x "$bin" 2>/dev/null || true
+fi
+
+if [ ! -x "$bin" ]; then
+	echo "错误：找不到可执行的 $bin" >&2
+	echo "  处理：在装有 Go 的机器上跑 packages/skill/go 的构建脚本重新产出产物。" >&2
+	exit 1
+fi
+
+exec "$bin" "$@"

package/skill/scripts/ledgerkit/actions/atom.py

@@ -1,154 +0,0 @@
-"""事务的唯一入口，20 行：把这次要碰的文件按固定顺序一次锁住。
-
-只加锁，不管写盘、不碰 git、不打印。
-
-三条硬约束：
-1. 锁集**只许宽不许窄**；锁集以外的文件一个字节都不许写。
-2. **所有判定依据必须在锁内重读** —— 锁外读到的快照只能用来决定"锁多宽"。
-3. **任何失败补偿都不许再开一个 `atom`**（文件锁不可重入），只能在同一事务内做完。
-"""
-
-from __future__ import annotations
-
-import contextlib
-from collections.abc import Iterator
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-
-from ..core.identity import Identity, normalize
-from ..core.paths import (
-    HISTORY_DIR,
-    OWNERS_REL,
-    POOL_REL,
-    WORKLOG_DIR,
-    history_path_for,
-    shard_rel,
-    worklog_dir_for,
-    worklog_rel,
-)
-from ..store.locks import ledger_lock
-from ..store.owners_index import OwnersIndex
-from ..store.task_store import TaskStore
-
-ACTIONS = ("bootstrap", "new", "claim", "set", "log", "close", "tags")
-
-
-@dataclass(frozen=True)
-class Scope:
-    """这次要碰哪些文件。`files` 加锁（也逐个刷），`dirs` 只刷盘（展开成已存在的文件）。"""
-
-    files: tuple[Path, ...] = ()
-    dirs: tuple[Path, ...] = ()
-
-    def __or__(self, other: Scope) -> Scope:
-        return Scope(
-            files=_merge(self.files, other.files),
-            dirs=_merge(self.dirs, other.dirs),
-        )
-
-
-def _merge(a: tuple[Path, ...], b: tuple[Path, ...]) -> tuple[Path, ...]:
-    out: list[Path] = []
-    for item in (*a, *b):
-        if item not in out:
-            out.append(item)
-    return tuple(out)
-
-
-def _pool(repo: Path) -> Path:
-    return POOL_REL
-
-
-def _shard(repo: Path, me: Identity) -> Path:
-    return shard_rel(me.uuid)
-
-
-def _other_shards(repo: Path, me: Identity) -> tuple[Path, ...]:
-    """索引里除我之外的分片（宁宽：认领的前置要查、交接要写对方那份）。"""
-    index = OwnersIndex(repo)
-    me_key = normalize(me.uuid)
-    out: list[Path] = []
-    for key, record in index.all().items():
-        if key == me_key:
-            continue
-        name = (record or {}).get("file")
-        if name:
-            out.append(Path("owners") / str(name))
-    return tuple(out)
-
-
-def _worklog_of(
-    repo: Path, params: dict[str, Any]
-) -> tuple[tuple[Path, ...], tuple[Path, ...]]:
-    """这条任务的过程文档：查得到给文件，查不到退回整个 `worklog/` 目录（宁宽）。"""
-    tid = params.get("tid")
-    if not tid:
-        return (), (WORKLOG_DIR,)
-    pool = TaskStore(repo, POOL_REL)
-    task = pool.get(str(tid))
-    if task is None:
-        index = OwnersIndex(repo)
-        for path in index.shards().values():
-            rel = Path(path).relative_to(repo / "ledger")
-            task = TaskStore(repo, rel).get(str(tid))
-            if task is not None:
-                break
-    worklog = (task or {}).get("worklog")
-    if worklog:
-        return (Path(worklog),), ()
-    return (), (WORKLOG_DIR,)
-
-
-def lock_scope(repo: Path, me: Identity, action: str, params: dict[str, Any]) -> Scope:
-    """算出这次可能碰哪些文件（**在锁外跑**，宁可算宽）。七个分支与 §四 的表逐行对应。"""
-    if action not in ACTIONS:
-        raise ValueError(f"未知的 lock_scope action：{action!r}")
-    mine = _shard(repo, me)
-    pool = _pool(repo)
-    index = OWNERS_REL
-    others = _other_shards(repo, me)
-
-    if action == "bootstrap":
-        return Scope(files=(index, pool, mine))
-
-    if action == "new":
-        mine_flag = bool(params.get("mine"))
-        target = mine if mine_flag else pool
-        created = params.get("created") or ""
-        tid = params.get("tid")
-        # 本次要新建那篇文档：路径算得出来（锁集允许含不存在的路径），不放进去写集就超出锁集
-        doc = (
-            (Path(worklog_rel(str(tid), created)),) if tid and len(created) >= 7 else ()
-        )
-        month_dir = worklog_dir_for(created) if len(created) >= 7 else WORKLOG_DIR
-        return Scope(files=(target, *doc), dirs=(month_dir,))
-
-    if action == "claim":
-        wfiles, wdirs = _worklog_of(repo, params)
-        return Scope(files=(pool, mine, *others, *wfiles), dirs=wdirs)
-
-    if action == "set":
-        wfiles, wdirs = _worklog_of(repo, params)
-        # 分支取并集：release 写池、handoff 写对方分片、指向自己且未认领先认领（写我的分片）；已在名下则空转不写盘
-        return Scope(files=(mine, pool, *others, *wfiles), dirs=wdirs)
-
-    if action == "log":
-        wfiles, wdirs = _worklog_of(repo, params)
-        return Scope(files=(mine, *wfiles), dirs=wdirs)
-
-    if action == "close":
-        wfiles, wdirs = _worklog_of(repo, params)
-        finished = params.get("finished") or ""
-        history = history_path_for(finished) if len(finished) >= 7 else HISTORY_DIR
-        return Scope(files=(mine, history, *wfiles), dirs=wdirs)
-
-    # 六个分支已覆盖 ACTIONS 全集（入口校验在前），走到这里说明表与分支不同步
-    raise ValueError(f"lock_scope 没有处理 {action!r}")
-
-
-@contextlib.contextmanager
-def atom(repo: Path, *rels: Path) -> Iterator[None]:
-    """按路径排序后依次加锁，退出即完成。不建记账本、不写盘、不提交、不打印。"""
-    with ledger_lock(repo, *rels):
-        yield

package/skill/scripts/ledgerkit/actions/bootstrap.py

@@ -1,37 +0,0 @@
-"""开工前的自举：台账文件不存在就建，没登记过就把自己登记进去、建自己的分片。
-
-这三份由**外壳**单独一个 `atom` 包住，它自己不开事务、不拿锁。
-不参与「提交说明 / where / 打印」。
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..core.identity import Identity
-from ..core.paths import LEDGER_DIR, OWNERS_DIR, POOL_REL, shard_rel, to_repo_rel
-from ..core.roots import as_root
-from ..store.atomic import ensure_dir
-from ..store.owners_index import OwnersIndex
-from ..store.task_store import TaskStore
-
-
-def bootstrap(repo: Path, me: Identity) -> Identity:
-    """写序：`owners/` 目录 → 池 → **我的分片 → 索引（登记自己）**。已登记 ⇒ 零写。
-
-    分片必须排在登记之**前**：反过来的话，硬崩（SIGKILL / 断电）正好落在两步之间，
-    会留下「索引里有我、磁盘上没有我的分片」——此后**所有人**的 list / show 都在
-    `assert_present` 处报「登记的任务文件找不到了」，而 `ensure` 看到记录已存在就零写，
-    这个坏状态永远不自愈。按现在的顺序崩，最多留一份孤儿分片（`validate` 会报出来），
-    下一条写命令 bootstrap 时会把它登记回去。
-    """
-    repo = as_root(
-        repo, source="工作区根"
-    )  # 门 3：写前最后确认，绝不在 ledger/ 里再套一层
-    ensure_dir(repo / LEDGER_DIR)  # 曾是 to_repo_rel(LEDGER_DIR) ⇒ 会拼出 ledger/ledger
-    ensure_dir(repo / to_repo_rel(OWNERS_DIR))
-    TaskStore(repo, POOL_REL).ensure_file()
-    TaskStore(repo, shard_rel(me.uuid), identity=me).ensure_file()
-    index = OwnersIndex(repo)
-    _, _ = index.ensure(me)  # 登记自己（已登记则零写）
-    return me

package/skill/scripts/ledgerkit/actions/claim.py

@@ -1,88 +0,0 @@
-"""认领：先写进我的分片，再删池里那行。**顺序反了任务会凭空消失**。"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..core.identity import Identity, normalize
-from ..core.paths import POOL_REL, shard_rel
-from ..core.time import now
-from ..core.worklog_md import StatusLine, exec_line
-from ..errors import Fail
-from ..store.owners_index import OwnersIndex
-from ..store.task_store import TaskStore
-from ..store.worklog_store import WorklogStore
-from .result import Result, rel
-
-
-def claim(repo: Path, me: Identity, tid: str) -> Result:
-    """写序：我的分片 → 删池里那行 → 过程文档记一笔。"""
-    pool = TaskStore(repo, POOL_REL)
-    mine = TaskStore(repo, shard_rel(me.uuid), identity=me)
-    me_key = normalize(me.uuid)
-
-    # 前置：别人正在改它（他的分片里已有这个号）⇒ 拒绝
-    for key, path in OwnersIndex(repo).shards().items():
-        if key == me_key:
-            continue
-        other = TaskStore(repo, Path(path).relative_to(repo / "ledger"))
-        if other.get(tid) is not None:
-            raise Fail(f"任务 {tid} 已在 {key} 的分片里（别人正在做），不能认领。")
-
-    task = pool.get(tid)  # 锁内重读
-    if task is None:
-        already = mine.get(tid)
-        if already is not None:
-            # 重跑：分片里已有这个号（上次崩了一半）⇒ 只补删池里那行
-            pool.drop(tid)
-            logs = WorklogStore(repo)
-            path = logs.find(tid, already.get("worklog"))
-            if path is not None:
-                logs.append_exec(
-                    path,
-                    exec_line(now(), me.uuid, "claim", "认领（补齐上次未完成的清理）"),
-                    status=StatusLine("doing", me.name, me.uuid, now()),
-                )
-            return Result(
-                already_done=True,
-                where=rel(repo, mine.path),
-                message=f"认领 {tid}：补齐上次未完成的清理",
-                notices=(f"任务 {tid} 已经在我的分片里，本次只补删公共池那行。",),
-            )
-        raise Fail(f"公共池里没有任务 {tid}（已经被人认领或不存在）。")
-
-    current = task.get("status")
-    if current != "open":
-        raise Fail(
-            f"任务 {tid} 在公共池里但状态是 {current}（应为 open）—— "
-            "先跑 validate 看台账是不是乱了。"
-        )
-
-    moved = dict(task)
-    moved["owner"] = me.uuid
-    moved["owner_name"] = me.name
-    # 认领即在做：看板把 doing 当「我的在办」算（home.service.ts），置 open 会让
-    # 认领后的任务看起来仍没人领。旧版 progress.py 置 doing，分片重构时丢了。
-    moved["status"] = "doing"
-    moved["started"] = moved.get("started") or now()
-    moved["updated"] = now()
-    mine.put(tid, moved)
-    pool.drop(tid)
-
-    note = f"任务 {tid} 已记到我的分片，过程文档没找到，跳过执行记录。"
-    logs = WorklogStore(repo)
-    path = logs.find(tid, moved.get("worklog"))
-    if path is not None:
-        logs.append_exec(
-            path,
-            exec_line(now(), me.stamp(), "claim", "认领 → doing"),
-            status=StatusLine("doing", me.name, me.uuid, now()),
-        )
-        note = None
-    return Result(
-        changed=("owner", "started", "updated"),
-        where=rel(repo, mine.path),
-        message=f"认领 {tid}：{moved.get('title') or ''}".strip(),
-        payload={},
-        notices=(note,) if note else (),
-    )