@dog_world/dak 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zyZ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,142 @@
+# dak — Dog Agents Kit CLI
+
+## 这是什么 / 做什么用
+
+`dak` 是一个本机命令行小工具,帮你**把同一批 skills / hooks / agents 同时接到多个 AI 工具(Codex、Claude Code 等)上,还不用每个工具都复制一份**。
+
+**怎么做到的**:你把 skill / hook / agent 的源文件集中放进一个文件夹(store)。dak 在各工具目录里建「软链接」(快捷方式)指回 store 里的源文件,不复制实体文件。于是:
+
+- 一份源文件,多个工具共用;
+- 改 store 里这一份,所有工具立刻看到新内容;
+- 新加工具,跑一下 `dak link` 就接上,不用再复制。
+
+**解决的痛点**:同一 skill 想给 Codex 和 Claude Code 用,以前得复制两份(`~/.codex/skills/foo` 和 `~/.claude/skills/foo`),改了 foo 得记着改两处,漏一处就不同步。用 dak 只存一份,两边都生效。
+
+## 安装
+
+```bash
+git clone <repo> && cd dog-agents-kit
+npm install
+npm run build      # 产物在 dist/
+npm link           # 注册全局命令 dak（或直接 node dist/cli.js）
+```
+
+## 创建的目录与结构
+
+`dak init` 后在 `~/.dog-agents-kit/`（默认 store）生成：
+
+```
+~/.dog-agents-kit/
+├── dak.config.json   # 配置：store 路径 + 目标工具映射
+├── .dak-state.json   # 链接状态（dak 自维护，别手改）
+├── skills/           # 你的 skills 源文件
+├── hooks/            # 你的 hooks 源文件
+└── agents/           # 你的 agents 源文件
+```
+
+默认配置两个目标工具（`dak init` 自动写入）：
+
+| 目标名 | 工具根目录 |
+|--------|-----------|
+| `codex` | `~/.codex` |
+| `claudecode` | `~/.claude` |
+
+> 目标名是自己起的 key，不是写死的。想加 Cursor/Windsurf 等工具，直接编辑 `dak.config.json` 的 `targets` 加一行即可。换 store 位置用 `dak init --store <path>`，多 store 并存互不干扰。
+
+## 指令大集合
+
+### 用法示例
+
+| 指令 | 示例 |
+|------|------|
+| 初始化 store | `dak init` |
+| 初始化到自定义位置 | `dak init --store ~/my-dak-store` |
+| 列出 store 资源 | `dak list` |
+| 列出指定 store | `dak list --store ~/my-dak-store` |
+| 链接到 Codex | `dak link codex` |
+| 链接到 Claude Code | `dak link claudecode` |
+| 一次性链全部目标 | `dak link all` |
+| 只链 hooks | `dak link codex -r hooks` |
+| 只链 skills | `dak link codex -r skills` |
+| 只链 agents | `dak link codex -r agents` |
+| 冲突时备份旧文件再链 | `dak link codex --on-conflict backup` |
+| 冲突时直接覆盖 | `dak link all --on-conflict overwrite` |
+| 查看链接状态 | `dak status` |
+| 只看 skills 状态 | `dak status -r skills` |
+| 同步：补新链、清失效链 | `dak update` |
+| 只同步 hooks | `dak update -r hooks` |
+| 同步时冲突先备份 | `dak update --on-conflict backup` |
+| 取消 Codex 全部链接 | `dak unlink codex` |
+| 取消所有目标链接 | `dak unlink all` |
+| 只取消 agents 链接 | `dak unlink codex -r agents` |
+| 取消所有目标的 hooks | `dak unlink all -r hooks` |
+
+### 指令解释
+
+| 指令 | 解释 |
+|------|------|
+| `init` | 首次使用跑。建 store 目录、生成默认配置 `dak.config.json` 和空状态文件。配置已存在则不覆盖。 |
+| `list` | 列出 store 里现有的 skills / hooks / agents（标注 `[dir]` 文件夹、`[link]` 软链）。不碰任何链接。 |
+| `link <目标>` | 把 store 资源软链接到指定目标工具目录。`all` = 配置里所有目标。冲突按 `--on-conflict` 处理。 |
+| `status` | 查看每个资源在目标里的链接状态（`linked`/`missing`/`stale`/`broken`/`conflict`）。只读，不改东西。 |
+| `update` | 对齐 store 与已链接目标：store 新增的资源自动补链、store 删掉的资源自动清链。 |
+| `unlink <目标>` | 取消链接，只删目标里的软链，**不删 store 源文件**。`all` = 取消所有目标。 |
+
+### 通用参数
+
+| 参数 | 说明 | 适用命令 |
+|------|------|---------|
+| `--store <path>` | 指定 store 路径（须与配置里 `store` 一致，否则报 `config store mismatch`） | 全部 |
+| `-r` / `--resource <类型>` | 只处理某一类资源（`skills`/`hooks`/`agents` 或 config 声明的自定义类型），不传则三类全处理 | `link` / `unlink` / `status` / `update` |
+| `--on-conflict <skip\|backup\|overwrite>` | 冲突处理策略：跳过 / 备份旧的 / 覆盖旧的 | `link` / `update` |
+
+> 冲突策略没传时：交互式终端（TTY）里 dak 逐个问你 `[s]kip/[b]ackup/[o]verwrite`（默认 skip）；非交互（脚本/管道）直接 skip。
+> **保护规则**：真实文件、其他 store 的链接、手动改过的链接，在 `update`/`unlink` 里永远受保护（`conflict` 状态），传 `--on-conflict overwrite` 也不会删。
+
+## 快速上手
+
+```bash
+dak init                  # 1. 建默认 store
+# 2. 把你的 skill/hook/agent 源文件丢进 ~/.dog-agents-kit/{skills,hooks,agents}/
+dak link all              # 3. 一键链到 codex + claudecode
+dak status                # 4. 看状态确认
+# 之后改了 store 里的源文件 → 所有工具立即可见；
+# 新增/删除资源后跑 dak update 对齐。
+```
+
+## 配置文件
+
+`<store>/dak.config.json`，结构：
+
+```jsonc
+{
+  "store": "~/.dog-agents-kit",        // store 路径，须与 --store 解析后一致
+  "resourceTypes": ["skills", "hooks", "agents"],  // 受管理资源类型，可加自定义
+  "targets": {
+    "codex": {
+      "path": "~/.codex",              // 工具根目录（支持 ~ 或绝对路径）
+      "resources": {                   // 各资源在目标里的子路径；缺哪类就跳过哪类
+        "skills": "skills",
+        "hooks": "hooks",
+        "agents": "agents"
+      }
+    },
+    "claudecode": { "path": "~/.claude", "resources": { "skills": "skills", "hooks": "hooks", "agents": "agents" } }
+    // 加新工具：在这加一行 "cursor": { "path": "...", "resources": { "skills": "skills" } }
+  }
+}
+```
+
+改完配置后跑 `dak link` / `dak update` 生效（`init` 不会覆盖已存在的配置）。
+
+## 状态字段（`status` / `unlink` 输出）
+
+| 状态 | 含义 |
+|------|------|
+| `linked` | 软链存在且指向当前 store 源 |
+| `created` / `backed-up` / `overwritten` | 本次新建 / 备份后新建 / 覆盖后新建 |
+| `missing` | store 有此资源，但目标路径不存在 |
+| `stale` | state 有记录，但 store 源已删（`update` 会清掉） |
+| `broken` | 软链指向不存在的目标 |
+| `conflict` | 目标位置是真实文件或外部软链（受保护，不删） |
+| `deleted` | 本次安全删除链接 |

package/dist/cli.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+/** dak CLI 入口 */
+import { runInit, runList, runLink, runStatus, runUpdate, runUnlink } from './commands.js';
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { assertSafeItemName } from './paths.js';
+/** 解析命令行参数（不引入额外依赖） */
+export function parseArgv(argv) {
+    const result = { command: 'list' };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--store') {
+            const val = argv[i + 1];
+            if (!val)
+                throw new Error('--store requires a value');
+            result.store = val;
+            i++;
+            continue;
+        }
+        if (arg === '--on-conflict') {
+            const val = argv[i + 1];
+            if (!val)
+                throw new Error('--on-conflict requires a value');
+            if (!['skip', 'backup', 'overwrite'].includes(val)) {
+                throw new Error('Invalid conflict policy');
+            }
+            result.onConflict = val;
+            i++;
+            continue;
+        }
+        // 限定单资源类型：-r / --resource <name>（自定义类型需在 config.resourceTypes 声明）
+        if (arg === '--resource' || arg === '-r') {
+            const val = argv[i + 1];
+            if (!val)
+                throw new Error('--resource requires a value');
+            try {
+                assertSafeItemName(val);
+            }
+            catch {
+                throw new Error('Invalid resource type');
+            }
+            result.resource = val;
+            i++;
+            continue;
+        }
+        // 第一个非 flag 参数为命令或 target
+        if (!arg.startsWith('--')) {
+            const cmd = arg;
+            if (['init', 'list', 'link', 'status', 'update', 'unlink'].includes(cmd)) {
+                result.command = cmd;
+                // link/unlink 后跟 target
+                if (cmd === 'link' || cmd === 'unlink') {
+                    const next = argv[i + 1];
+                    if (!next || next.startsWith('--')) {
+                        throw new Error(`${cmd} target is required`);
+                    }
+                    result.target = next;
+                    i++;
+                }
+            }
+            else {
+                throw new Error(`Unknown command: ${arg}`);
+            }
+        }
+    }
+    // link/unlink 必须有 target
+    if ((result.command === 'link' || result.command === 'unlink') && !result.target) {
+        throw new Error(`${result.command} target is required`);
+    }
+    return result;
+}
+/**
+ * 交互式询问冲突策略（readline/promises）。
+ * 仅在 TTY 下由 main 注入。输入无效时默认 skip。
+ */
+async function chooseConflictInteractive(target, resource, item) {
+    const rl = createInterface({ input, output });
+    try {
+        const prompt = `Conflict at ${target} ${resource}/${item}. Choose [s]kip/[b]ackup/[o]verwrite (default skip): `;
+        const answer = (await rl.question(prompt)).trim().toLowerCase();
+        if (answer === 'b' || answer === 'backup')
+            return 'backup';
+        if (answer === 'o' || answer === 'overwrite')
+            return 'overwrite';
+        return 'skip';
+    }
+    finally {
+        rl.close();
+    }
+}
+/** 主入口 */
+export async function main(args = process.argv.slice(2)) {
+    const homeDir = process.env.HOME ?? '';
+    const interactive = process.stdin.isTTY && process.stdout.isTTY;
+    try {
+        const parsed = parseArgv(args);
+        const opts = { store: parsed.store, homeDir };
+        if (parsed.resource)
+            opts.resource = parsed.resource;
+        // 冲突策略
+        if (parsed.onConflict) {
+            opts.conflictPolicy = parsed.onConflict;
+        }
+        else if (interactive) {
+            opts.interactive = true;
+            opts.chooseConflict = (target, resource, item) => {
+                return chooseConflictInteractive(target, resource, item);
+            };
+        }
+        switch (parsed.command) {
+            case 'init':
+                console.log(await runInit(opts));
+                break;
+            case 'list':
+                console.log(await runList(opts));
+                break;
+            case 'link':
+                console.log(await runLink(parsed.target, opts));
+                break;
+            case 'status':
+                console.log(await runStatus(opts));
+                break;
+            case 'update':
+                console.log(await runUpdate(opts));
+                break;
+            case 'unlink':
+                console.log(await runUnlink(parsed.target, opts));
+                break;
+        }
+        return 0;
+    }
+    catch (e) {
+        console.error(`Error: ${e.message}`);
+        return 1;
+    }
+}
+// 直接运行时执行 main
+import { fileURLToPath } from 'node:url';
+import { realpathSync } from 'node:fs';
+const __filename = fileURLToPath(import.meta.url);
+// process.argv[1] 在通过 bin 软链接调用时仍是软链接路径，
+// 而 import.meta.url 会被 Node 解析为真实路径。
+// 用 realpathSync 把 argv[1] 也解析到真身后再比较，否则软链接调用时 main() 永不执行。
+const invokedFrom = process.argv[1] ? realpathSync(process.argv[1]) : '';
+if (invokedFrom === __filename) {
+    (async () => {
+        const code = await main();
+        process.exit(code);
+    })();
+}

package/dist/commands.js

@@ -0,0 +1,298 @@
+/** 命令工作流 */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { readConfig, createDefaultConfig, validateConfigStore, writeConfigIfMissing, resolveStorePath } from './config.js';
+import { readState, writeState, writeStateIfMissing, upsertLinkRecord, removeLinkRecord, removeTargetState } from './state.js';
+import { scanResources, formatResourceList, ensureStoreLayout } from './resources.js';
+import { classifyTarget, linkItem, safeDeleteManagedLink } from './linker.js';
+import { declaredResourceTypes } from './config.js';
+/**
+ * 加载上下文（store/config/state）。
+ */
+async function loadContext(opts) {
+    const homeDir = opts.homeDir ?? process.env.HOME ?? '';
+    const storePath = resolveStorePath(opts.store, homeDir);
+    const config = await readConfig(storePath);
+    validateConfigStore(config, storePath, homeDir);
+    const state = await readState(storePath);
+    return { storePath, config, state, homeDir };
+}
+/**
+ * 解析目标名称（支持 all）。
+ */
+function resolveTargetNames(target, config) {
+    if (target === 'all') {
+        return Object.keys(config.targets ?? {});
+    }
+    if (!config.targets?.[target]) {
+        throw new Error(`unknown target: ${target}`);
+    }
+    return [target];
+}
+/**
+ * 本次命令要处理的资源类型集合。
+ * 指定 --resource 时只跑该类型，否则跑 config 声明的全部资源类型。
+ */
+function effectiveResourceTypes(opts, config) {
+    if (opts.resource) {
+        const declared = declaredResourceTypes(config);
+        if (!declared.includes(opts.resource)) {
+            throw new Error(`unknown resource type: ${opts.resource}`);
+        }
+        return [opts.resource];
+    }
+    return declaredResourceTypes(config);
+}
+/**
+ * 获取目标 resource 路径（未配置则返回 null）。
+ */
+function targetResourcePath(config, targetName, resourceType) {
+    const t = config.targets?.[targetName];
+    if (!t?.resources?.[resourceType])
+        return null;
+    return join(t.path, t.resources[resourceType]);
+}
+/**
+ * 构造冲突解析器（仅真实 conflict/broken 时由 linkItem 回调）。
+ * 有静态 --on-conflict 时不问；否则 interactive 模式下委托 chooseConflict。
+ * 返回 undefined 表示无 resolver，linkItem 回退到 policy（默认 skip）。
+ */
+function resolveConflictFor(opts, target, resource, item) {
+    if (opts.conflictPolicy)
+        return undefined;
+    if (opts.interactive && opts.chooseConflict) {
+        return () => opts.chooseConflict(target, resource, item);
+    }
+    return undefined;
+}
+/** ─── Commands ─── **/
+/** 初始化 store */
+export async function runInit(opts) {
+    const homeDir = opts.homeDir ?? process.env.HOME ?? '';
+    const storePath = resolveStorePath(opts.store, homeDir);
+    const config = createDefaultConfig(storePath, homeDir);
+    await ensureStoreLayout(storePath, config);
+    await writeConfigIfMissing(storePath, config);
+    await writeStateIfMissing(storePath);
+    return `Initialized dak store at ${storePath}`;
+}
+/** 列出资源 */
+export async function runList(opts) {
+    const { storePath, config } = await loadContext(opts);
+    const resources = await scanResources(storePath, config);
+    return formatResourceList(resources);
+}
+/** 链接资源到目标 */
+export async function runLink(targetArg, opts) {
+    const { storePath, config, state } = await loadContext(opts);
+    const targetNames = resolveTargetNames(targetArg, config);
+    const lines = [];
+    let linked = 0, created = 0, conflicts = 0;
+    const items = await scanResources(storePath, config);
+    for (const tName of targetNames) {
+        for (const resourceType of effectiveResourceTypes(opts, config)) {
+            const targetPath = targetResourcePath(config, tName, resourceType);
+            if (!targetPath)
+                continue; // target 未配置此 resource，跳过
+            for (const item of items[resourceType]) {
+                const itemTargetPath = join(targetPath, item.name);
+                const outcome = await linkItem({
+                    sourcePath: item.path,
+                    targetPath: itemTargetPath,
+                    resourceType,
+                    itemName: item.name,
+                    storePath,
+                    policy: opts.conflictPolicy,
+                    resolveConflict: resolveConflictFor(opts, tName, resourceType, item.name),
+                    now: opts.now,
+                });
+                // 写 state
+                if (outcome.record) {
+                    upsertLinkRecord(state, tName, resourceType, item.name, outcome.record);
+                }
+                let status = '';
+                switch (outcome.status) {
+                    case 'linked':
+                        status = 'linked';
+                        linked++;
+                        break;
+                    case 'created':
+                        status = 'created';
+                        created++;
+                        break;
+                    case 'backed-up':
+                        status = 'backed-up';
+                        created++;
+                        break;
+                    case 'overwritten':
+                        status = 'overwritten';
+                        created++;
+                        break;
+                    case 'conflict':
+                        status = 'conflict';
+                        conflicts++;
+                        break;
+                }
+                lines.push(`${tName} ${resourceType}/${item.name} ${status} ${itemTargetPath}`);
+            }
+        }
+    }
+    await writeState(storePath, state);
+    lines.push(`Summary: linked=${linked} created=${created} conflicts=${conflicts}`);
+    return lines.join('\n');
+}
+/** 状态检查 */
+export async function runStatus(opts) {
+    const { storePath, config, state } = await loadContext(opts);
+    const storeItems = await scanResources(storePath, config);
+    const lines = [];
+    for (const [tName, tState] of Object.entries(state.targets)) {
+        for (const resourceType of effectiveResourceTypes(opts, config)) {
+            const targetPath = targetResourcePath(config, tName, resourceType);
+            if (!targetPath)
+                continue;
+            const records = tState[resourceType] ?? {};
+            const storeItemsForType = storeItems[resourceType] ?? [];
+            const storeItemMap = new Map(storeItemsForType.map(i => [i.name, i]));
+            // 当前 store 中的 items
+            for (const item of storeItemsForType) {
+                const itemTargetPath = join(targetPath, item.name);
+                const category = await classifyTarget(itemTargetPath, item.path);
+                lines.push(`${tName} ${resourceType}/${item.name} ${category} ${itemTargetPath}`);
+            }
+            // state 中已存在但 store 已删除（stale）
+            for (const [itemName, record] of Object.entries(records)) {
+                if (storeItemMap.has(itemName))
+                    continue;
+                const itemTargetPath = record.target;
+                lines.push(`${tName} ${resourceType}/${itemName} stale ${itemTargetPath}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+/** 更新（补链接 + 清理 stale） */
+export async function runUpdate(opts) {
+    const { storePath, config, state } = await loadContext(opts);
+    const lines = [];
+    let created = 0, deleted = 0, missingCount = 0, skipped = 0, conflicts = 0;
+    // target 集合只能来自 state.targets（已 link 过的 targets）
+    const targetNames = Object.keys(state.targets);
+    const storeItems = await scanResources(storePath, config);
+    for (const tName of targetNames) {
+        const tState = state.targets[tName];
+        for (const resourceType of effectiveResourceTypes(opts, config)) {
+            const targetPath = targetResourcePath(config, tName, resourceType);
+            if (!targetPath)
+                continue;
+            const records = { ...(tState[resourceType] ?? {}) };
+            // 1. 清理 stale
+            for (const [itemName, record] of Object.entries(records)) {
+                const sourcePath = record.source;
+                if (!existsSync(sourcePath)) {
+                    // stale：state 中有记录但 store 已无源
+                    const result = await safeDeleteManagedLink(record, storePath);
+                    switch (result) {
+                        case 'deleted':
+                            removeLinkRecord(state, tName, resourceType, itemName);
+                            deleted++;
+                            lines.push(`${tName} ${resourceType}/${itemName} deleted ${record.target}`);
+                            break;
+                        case 'missing':
+                            removeLinkRecord(state, tName, resourceType, itemName);
+                            missingCount++;
+                            lines.push(`${tName} ${resourceType}/${itemName} missing ${record.target}`);
+                            break;
+                        case 'conflict':
+                            conflicts++;
+                            lines.push(`${tName} ${resourceType}/${itemName} conflict ${record.target}`);
+                            break;
+                    }
+                }
+            }
+            // 2. 为当前 store item 补链接
+            for (const item of storeItems[resourceType]) {
+                const itemTargetPath = join(targetPath, item.name);
+                const outcome = await linkItem({
+                    sourcePath: item.path,
+                    targetPath: itemTargetPath,
+                    resourceType,
+                    itemName: item.name,
+                    storePath,
+                    policy: opts.conflictPolicy,
+                    resolveConflict: resolveConflictFor(opts, tName, resourceType, item.name),
+                    now: opts.now,
+                });
+                if (outcome.record) {
+                    upsertLinkRecord(state, tName, resourceType, item.name, outcome.record);
+                }
+                switch (outcome.status) {
+                    case 'linked':
+                        skipped++;
+                        lines.push(`${tName} ${resourceType}/${item.name} linked ${itemTargetPath}`);
+                        break;
+                    case 'created':
+                        created++;
+                        lines.push(`${tName} ${resourceType}/${item.name} created ${itemTargetPath}`);
+                        break;
+                    case 'backed-up':
+                        created++;
+                        lines.push(`${tName} ${resourceType}/${item.name} backed-up ${itemTargetPath}`);
+                        break;
+                    case 'overwritten':
+                        created++;
+                        lines.push(`${tName} ${resourceType}/${item.name} overwritten ${itemTargetPath}`);
+                        break;
+                    case 'conflict':
+                        conflicts++;
+                        lines.push(`${tName} ${resourceType}/${item.name} conflict ${itemTargetPath}`);
+                        break;
+                }
+            }
+        }
+    }
+    await writeState(storePath, state);
+    lines.push(`Summary: created=${created} deleted=${deleted} missing=${missingCount} skipped=${skipped} conflicts=${conflicts}`);
+    return lines.join('\n');
+}
+/** 取消链接 */
+export async function runUnlink(targetArg, opts) {
+    const { storePath, config, state } = await loadContext(opts);
+    const targetNames = resolveTargetNames(targetArg, config);
+    const lines = [];
+    let deleted = 0, missingCount = 0, conflicts = 0;
+    for (const tName of targetNames) {
+        const tState = state.targets[tName];
+        if (!tState)
+            continue;
+        for (const resourceType of effectiveResourceTypes(opts, config)) {
+            const records = { ...(tState[resourceType] ?? {}) };
+            for (const [itemName, record] of Object.entries(records)) {
+                const result = await safeDeleteManagedLink(record, storePath);
+                switch (result) {
+                    case 'deleted':
+                        removeLinkRecord(state, tName, resourceType, itemName);
+                        deleted++;
+                        lines.push(`${tName} ${resourceType}/${itemName} deleted ${record.target}`);
+                        break;
+                    case 'missing':
+                        removeLinkRecord(state, tName, resourceType, itemName);
+                        missingCount++;
+                        lines.push(`${tName} ${resourceType}/${itemName} missing ${record.target}`);
+                        break;
+                    case 'conflict':
+                        conflicts++;
+                        lines.push(`${tName} ${resourceType}/${itemName} conflict ${record.target}`);
+                        break;
+                }
+            }
+        }
+        // 如果 target 下所有 records 都已删完，移除 target state
+        if (tState && Object.values(tState).every(m => Object.keys(m).length === 0)) {
+            removeTargetState(state, tName);
+        }
+    }
+    await writeState(storePath, state);
+    lines.push(`Summary: deleted=${deleted} missing=${missingCount} conflicts=${conflicts}`);
+    return lines.join('\n');
+}