@chengzhao-dev/dsh-quarto-book 0.3.5 → 0.4.1

package/lib/tools/pass-report.js

@@ -0,0 +1,332 @@
+// `quarto_pass_report`：把一次写作或主题润色的结果压成固定行数的卡片。
+//
+// 入参是闭集：模式、文件、步骤、未改项、检查状态都只能取登记过的值。
+// 卡片由工具自己拼接，返回的文本就是卡片本身，不附章节原文，也不贴改写后的句子。
+// 没改也要出卡，这样「插件没跑」和「跑了但没改」在会话里分得开。
+export const PASS_SKILLS = ['writing-quarto', 'designing-theme'];
+export const PASS_MODES = ['polish', 'rewrite', 'theme', 'skipped'];
+export const HELD_ITEMS = ['fences', 'facts', 'css', 'prose'];
+export const CHECK_NAMES = ['content', 'html', 'layout'];
+export const CHECK_STATUSES = ['pass', 'fail', 'skip'];
+export const MAX_FILES = 8;
+export const MAX_SKIP_REASON = 40;
+/** 写作九步的短名，与 `skills/writing-quarto/SKILL.md` 的「九步」逐字对应。 */
+export const WRITING_STEPS = {
+    '1': '定任务',
+    '2': '定结构',
+    '3': '排列内容块',
+    '4': '定段落',
+    '5': '定句子',
+    '6': '定用词',
+    '7': '定版式',
+    '8': '回读并退回',
+    '9': '检查与渲染',
+};
+/** 主题步骤表的名字，与 `skills/designing-theme/references/theme-spine.md` 逐字对应。 */
+export const THEME_STEPS = ['定表面', '定字体', '定尺度', '定颜色', '定组件', '通过检查'];
+const MODE_LABELS = {
+    polish: '增量润色',
+    rewrite: '全章重构',
+    theme: '主题',
+    skipped: '未执行',
+};
+const HELD_LABELS = {
+    fences: '围栏',
+    facts: '事实',
+    css: '样式',
+    prose: '正文',
+};
+const CHECK_LABELS = {
+    content: '内容',
+    html: 'HTML',
+    layout: '版式',
+};
+const PASS_VERDICTS = {
+    content: '通过',
+    html: '可用',
+    layout: '通过',
+};
+const FAIL_VERDICTS = {
+    content: '未通过',
+    html: '不可用',
+    layout: '未通过',
+};
+const TOP_LEVEL_KEYS = ['skill', 'executed', 'mode', 'files', 'steps', 'held', 'checks', 'skip_reason'];
+function fail(message) {
+    throw new Error(message);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isPlainCount(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+}
+function allowedSteps(skill) {
+    return skill === 'writing-quarto' ? Object.keys(WRITING_STEPS) : [...THEME_STEPS];
+}
+function stepLabel(skill, name) {
+    return skill === 'writing-quarto' ? (WRITING_STEPS[name] ?? name) : name;
+}
+function normalizeFiles(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        fail('files 必须是数组');
+    if (value.length > MAX_FILES)
+        fail(`files 最多 ${MAX_FILES} 个路径`);
+    return value.map((item) => {
+        if (!isRecord(item))
+            fail('files 的每一项必须是 { path, edits }');
+        const keys = Object.keys(item);
+        if (keys.some((key) => key !== 'path' && key !== 'edits'))
+            fail('files 的每一项只允许 path 和 edits');
+        const filePath = item.path;
+        if (typeof filePath !== 'string' || filePath.trim() === '')
+            fail('files 的 path 必须是非空字符串');
+        if (!isPlainCount(item.edits))
+            fail('files 的 edits 必须是非负整数');
+        return { path: filePath.trim(), edits: item.edits };
+    });
+}
+function normalizeSteps(value, skill) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        fail('steps 必须是数组');
+    const allowed = allowedSteps(skill);
+    const seen = new Set();
+    return value.map((item) => {
+        if (!isRecord(item))
+            fail('steps 的每一项必须是 { name, edits }');
+        const keys = Object.keys(item);
+        if (keys.some((key) => key !== 'name' && key !== 'edits'))
+            fail('steps 的每一项只允许 name 和 edits');
+        const name = item.name;
+        if (typeof name !== 'string' || !allowed.includes(name)) {
+            fail(`steps 的 name 只能是：${allowed.join('、')}`);
+        }
+        if (seen.has(name))
+            fail(`steps 的 name 重复：${name}`);
+        seen.add(name);
+        if (typeof item.edits !== 'number' || !Number.isInteger(item.edits) || item.edits < 1) {
+            fail('steps 的 edits 必须是正整数');
+        }
+        return { name, edits: item.edits };
+    });
+}
+function normalizeHeld(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        fail('held 必须是数组');
+    const seen = new Set();
+    return value.map((item) => {
+        if (typeof item !== 'string' || !HELD_ITEMS.includes(item)) {
+            fail(`held 只能是：${HELD_ITEMS.join('、')}`);
+        }
+        if (seen.has(item))
+            fail(`held 重复：${item}`);
+        seen.add(item);
+        return item;
+    });
+}
+function normalizeChecks(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        fail('checks 必须是数组');
+    const seen = new Set();
+    return value.map((item) => {
+        if (!isRecord(item))
+            fail('checks 的每一项必须是 { name, status }');
+        const keys = Object.keys(item);
+        if (keys.some((key) => key !== 'name' && key !== 'status'))
+            fail('checks 的每一项只允许 name 和 status');
+        const name = item.name;
+        if (typeof name !== 'string' || !CHECK_NAMES.includes(name)) {
+            fail(`checks 的 name 只能是：${CHECK_NAMES.join('、')}`);
+        }
+        if (seen.has(name))
+            fail(`checks 的 name 重复：${name}`);
+        seen.add(name);
+        const status = item.status;
+        if (typeof status !== 'string' || !CHECK_STATUSES.includes(status)) {
+            fail(`checks 的 status 只能是：${CHECK_STATUSES.join('、')}`);
+        }
+        return { name: name, status: status };
+    });
+}
+function checkLine(checks) {
+    const ordered = CHECK_NAMES.map((name) => checks.find((check) => check.name === name)).filter((check) => check !== undefined && check.status !== 'skip');
+    if (ordered.length === 0)
+        return undefined;
+    return '检查：' + ordered.map((check) => {
+        const label = CHECK_LABELS[check.name];
+        const verdict = check.status === 'pass' ? PASS_VERDICTS[check.name] : FAIL_VERDICTS[check.name];
+        // 中文标签直接接结论，英文标签（HTML）前面留一个空格。
+        return `${label}${/[A-Za-z]$/.test(label) ? ' ' : ''}${verdict}`;
+    }).join('；');
+}
+/** 校验入参并生成卡片；入参不合格时抛错，不猜测默认值。 */
+export function buildPassReport(input) {
+    if (!isRecord(input))
+        fail('回执入参必须是对象');
+    const unknownKey = Object.keys(input).find((key) => !TOP_LEVEL_KEYS.includes(key));
+    if (unknownKey)
+        fail(`未知字段：${unknownKey}`);
+    const skill = input.skill;
+    if (typeof skill !== 'string' || !PASS_SKILLS.includes(skill)) {
+        fail(`skill 只能是：${PASS_SKILLS.join('、')}`);
+    }
+    const typedSkill = skill;
+    if (typeof input.executed !== 'boolean')
+        fail('executed 必须是布尔值');
+    const mode = input.mode;
+    if (typeof mode !== 'string' || !PASS_MODES.includes(mode)) {
+        fail(`mode 只能是：${PASS_MODES.join('、')}`);
+    }
+    const typedMode = mode;
+    if (!input.executed) {
+        if (typedMode !== 'skipped')
+            fail('executed 为 false 时 mode 必须是 skipped');
+        const reason = input.skip_reason;
+        if (typeof reason !== 'string' || reason.trim() === '')
+            fail('未执行时必须给出 skip_reason');
+        if ([...reason.trim()].length > MAX_SKIP_REASON)
+            fail(`skip_reason 最多 ${MAX_SKIP_REASON} 个字`);
+        if (input.files !== undefined && Array.isArray(input.files) && input.files.length > 0) {
+            fail('未执行时 files 必须为空');
+        }
+        if (input.steps !== undefined && Array.isArray(input.steps) && input.steps.length > 0) {
+            fail('未执行时 steps 必须为空');
+        }
+        if (input.held !== undefined && Array.isArray(input.held) && input.held.length > 0) {
+            fail('未执行时 held 必须为空');
+        }
+        if (input.checks !== undefined && Array.isArray(input.checks) && input.checks.length > 0) {
+            fail('未执行时 checks 必须为空');
+        }
+        return { receipt: `未执行 ${typedSkill}：${reason.trim()}` };
+    }
+    if (typedMode === 'skipped')
+        fail('executed 为 true 时 mode 不能是 skipped');
+    if (typedSkill === 'designing-theme' && typedMode !== 'theme')
+        fail('designing-theme 只接受 mode: theme');
+    if (typedSkill === 'writing-quarto' && typedMode === 'theme')
+        fail('writing-quarto 不接受 mode: theme');
+    const files = normalizeFiles(input.files);
+    if (files.length === 0)
+        fail('已执行时 files 至少给 1 个路径');
+    const steps = normalizeSteps(input.steps, typedSkill);
+    const held = normalizeHeld(input.held);
+    const checks = normalizeChecks(input.checks);
+    const fileEdits = files.reduce((sum, file) => sum + file.edits, 0);
+    const stepEdits = steps.reduce((sum, step) => sum + step.edits, 0);
+    if (fileEdits !== stepEdits)
+        fail(`files 的改动合计 ${fileEdits} 与 steps 的合计 ${stepEdits} 不一致`);
+    const lines = [`已执行 ${typedSkill} · ${MODE_LABELS[typedMode]}`, files.map((file) => file.path).join('、')];
+    if (fileEdits === 0) {
+        lines.push('改了 0 处');
+    }
+    else {
+        lines.push(`改了 ${fileEdits} 处：` + steps.map((step) => `${stepLabel(typedSkill, step.name)} ${step.edits}`).join('，'));
+    }
+    if (held.length > 0)
+        lines.push('未改：' + held.map((item) => HELD_LABELS[item]).join('、'));
+    const checksText = checkLine(checks);
+    if (checksText)
+        lines.push(checksText);
+    return { receipt: lines.join('\n') };
+}
+const RESULT_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    properties: { receipt: { type: 'string' } },
+    required: ['receipt'],
+};
+export function registerPassReportTool(tools) {
+    tools.register({
+        name: 'quarto_pass_report',
+        description: '一次写作或主题润色收尾时调用一次，出一张短回执卡片：执行了哪个技能、什么模式、改了哪些文件与步骤、未改项、检查结论。入参是闭集：skill、mode、files（最多 8 个，每条带 path 与 edits）、steps（写作 1-9，主题用定表面/定字体/定尺度/定颜色/定组件/通过检查，各带 edits，合计必须等于 files 的 edits 合计）、held、checks、skip_reason。没改也传 0；不适用时 executed:false、mode:skipped、给 skip_reason。卡片就是回执，不要在回复里再复述。',
+        parameters: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                skill: { type: 'string', enum: [...PASS_SKILLS] },
+                executed: { type: 'boolean' },
+                mode: { type: 'string', enum: [...PASS_MODES] },
+                files: {
+                    type: 'array',
+                    maxItems: MAX_FILES,
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            path: { type: 'string' },
+                            edits: { type: 'integer', minimum: 0 },
+                        },
+                        required: ['path', 'edits'],
+                    },
+                },
+                steps: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            name: { type: 'string' },
+                            edits: { type: 'integer', minimum: 1 },
+                        },
+                        required: ['name', 'edits'],
+                    },
+                },
+                held: { type: 'array', items: { type: 'string', enum: [...HELD_ITEMS] } },
+                checks: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            name: { type: 'string', enum: [...CHECK_NAMES] },
+                            status: { type: 'string', enum: [...CHECK_STATUSES] },
+                        },
+                        required: ['name', 'status'],
+                    },
+                },
+                skip_reason: { type: 'string', maxLength: MAX_SKIP_REASON },
+            },
+            required: ['skill', 'executed', 'mode'],
+        },
+        output: {
+            schema: RESULT_SCHEMA,
+            render: (_args, value) => [{ type: 'text', text: value.receipt }],
+            presentationMeta: (_args, value) => ({ summary: value.receipt.split('\n')[0], lines: value.receipt.split('\n') }),
+        },
+        async execute(args) {
+            return buildPassReport(args);
+        },
+        presentCall(args) {
+            const files = Array.isArray(args.files) ? args.files : [];
+            return {
+                card: 'generic',
+                title: '写作回执',
+                kind: 'execute',
+                locations: files.map((file) => ({ path: String(file.path) })),
+                rawInput: `${args.skill} · ${args.mode}`,
+                content: [
+                    {
+                        type: 'text',
+                        text: args.executed === false ? `${args.skill}：未执行` : `${args.skill} · ${args.mode}（${files.length} 个文件）`,
+                    },
+                ],
+            };
+        },
+        presentResult(_args, result) {
+            return {
+                card: 'generic',
+                title: '写作回执',
+                content: result.content,
+            };
+        },
+    });
+}

package/lib/workspace.js

@@ -10,17 +10,7 @@ export const BOOK_PROJECT_RE = /^(?![\t ]*#)[\t ]*type:[\t ]*['"]?book['"]?[\t ]
 const MAX_SCAN_ENTRIES = 4000;
 const MAX_SCAN_DEPTH = 12;
 const BOOK_SOURCE_EXTENSIONS = new Set(['.qmd', '.md']);
-const NON_CHAPTER_FILES = new Set([
-    'readme.md',
-    'changelog.md',
-    'license.md',
-    'contributing.md',
-    'code_of_conduct.md',
-    'security.md',
-    'support.md',
-    'authors.md',
-    'contributors.md',
-]);
+const NON_CHAPTER_FILE_RE = /^(?:readme|changelog|license|licence|contributing|code[_-]of[_-]conduct|security|support|authors|contributors|agents|claude)(?:[.-][a-z0-9_-]+)*\.(?:md|markdown|qmd)$/i;
 const IGNORED_DIRECTORIES = new Set([
     '.git',
     '.quarto',
@@ -103,7 +93,7 @@ export async function hasBookSource(root) {
             const extension = path.extname(entry.name).toLowerCase();
             if (!BOOK_SOURCE_EXTENSIONS.has(extension))
                 continue;
-            if (extension === '.md' && current.depth === 0 && NON_CHAPTER_FILES.has(entry.name.toLowerCase())) {
+            if (current.depth === 0 && NON_CHAPTER_FILE_RE.test(entry.name)) {
                 continue;
             }
             return true;
@@ -113,7 +103,7 @@ export async function hasBookSource(root) {
 }
 /**
  * 在 cwd 与所属 git 根之间寻找最近的合法书根。
- * 声明了 book 却没有任何章节源的 `_quarto.yml` 不算工作区；搜索停在该目录，
+ * 最近一个 `_quarto.yml` 决定结果：它不是书、或没有章节源文件时直接判否，
  * 不再向上爬进无关的父项目。
  */
 export async function findBookRoot(cwd) {
@@ -131,7 +121,9 @@ export async function findBookRoot(cwd) {
         return undefined;
     let cursor = start;
     for (let depth = 0; depth < MAX_ASCENT; depth += 1) {
-        if (await declaresBookProject(cursor)) {
+        if (await exists(path.join(cursor, '_quarto.yml'))) {
+            if (!(await declaresBookProject(cursor)))
+                return undefined;
             return (await hasBookSource(cursor)) ? cursor : undefined;
         }
         if (cursor === gitRoot)

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Quarto Book Writing",
-    "description": "Author Chinese Quarto Book chapters and maintain a reusable book theme: structure checks, prose conventions, Mermaid and typography assets."
+    "description": "Write Quarto Book chapters, check their structure, and maintain the theme."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Quarto 图书写作",
-    "description": "编写中文 Quarto Book 章节并维护可复用主题：结构校验、行文约定、Mermaid 与版式资产。"
+    "description": "为 Quarto Book 写章节、检查结构并维护主题。"
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@chengzhao-dev/dsh-quarto-book",
-  "version": "0.3.5",
-  "description": "Quarto Book 写作与主题技能包：章节写作、结构校验与可复用主题 · Quarto Book authoring and theme skills for DeepSeek Harness",
+  "version": "0.4.1",
+  "description": "为 Quarto Book 写章节、检查结构并维护主题。 · Write Quarto Book chapters, check their structure, and maintain the theme.",
   "type": "module",
   "main": "./lib/index.js",
   "exports": {
@@ -19,9 +19,7 @@
     "README.md",
     "README.en.md",
     "LICENSE",
-    "templates",
-    "docs",
-    "scripts"
+    "templates"
   ],
   "engines": {
     "node": ">=22",
@@ -30,6 +28,14 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "catalog": {
+      "category": "skill",
+      "summary": {
+        "zh": "为 Quarto Book 写章节、检查结构并维护主题。",
+        "en": "Write Quarto Book chapters, check their structure, and maintain the theme."
+      },
+      "capabilities": ["skills", "tools"]
     }
   },
   "icon": "./icon.svg",
@@ -37,6 +43,7 @@
     "build": "tsc -p tsconfig.json",
     "test": "npm run build && node --test tests/*.test.mjs",
     "check": "tsc --noEmit -p tsconfig.json && node scripts/checking-skill-links.mjs",
+    "pack": "node -e \"require('fs').mkdirSync('temp',{recursive:true})\" && npm pack --pack-destination temp",
     "pack:check": "npm pack --dry-run"
   },
   "keywords": [

package/skills/designing-theme/SKILL.md

@@ -40,3 +40,4 @@ metadata:
 - [ ] `quarto render` 通过，明暗主题下页面无错位或对比度问题；`scripts/checking-layout.py` 通过。
 - [ ] 代码块 filename 标题在长路径输入下不撑破容器，窄屏仍可读；超长代码在块内横向滚动，不出整页横向滚动条。
 - [ ] 若项目内有主题副本，已在交付说明中写清改动是否同步，以及以哪一份为准。
+- [ ] 收尾调用一次 `quarto_pass_report`：`skill` 填 `designing-theme`，`mode` 填 `theme`，`steps` 用主题步骤表的名字（`定表面`、`定字体`、`定尺度`、`定颜色`、`定组件`、`通过检查`），检查结论照实填。卡片就是回执，回复里不再复述。

package/skills/designing-theme/references/theme-system.md

@@ -59,7 +59,7 @@
 - 正文与代码行高 1.75（CJK 阅读舒适带）；章节分隔靠 H2 的 `margin-top`，无通栏底线。
 - `grid.body-width` 是正文列上限（现 300+872+272+2×16=1476 封顶）；Quarto 会从 body-width 中减去两侧各 1rem 的栅格内边距，正文内容列 = body-width − 32px（现 840px）。取 872px 是让 16px Bright Code 下 100 列代码块（834px 内容宽）不换行的最小配置。取值只在 `_quarto.yml`，`--content-width` 只限正文容器；禁止 `75ch` 二次限宽。
 - 代码块不折行：`white-space: pre` + 块内横向滚动（`_quarto.yml` 的 `code-overflow: scroll`）；窄视口整页不出横向滚动条，打印时恢复折行（`code.css` 的打印规则）。
-- ≤991.98px 左栏浮层必须不透明实底（见 `cpp-quarto-sidebar-overlay-v1`）。
+- ≤991.98px 左栏浮层必须不透明实底（规则在 `assets/theme/css/sidebar.css` 的 991.98px 媒体查询）。
 
 ## 组件约定（定组件）
 

package/skills/writing-quarto/SKILL.md

@@ -39,5 +39,6 @@ metadata:
 ## 完成判据
 
 - [ ] 九步走完，每一步的产出都落在正文里。
-- [ ] 内容与链接核对通过：项目技能存在时跑它列出的 `run.ps1 verify --changed`，否则跑本技能 `scripts/verifying-content.py` 与 `checking-links.py`。
+- [ ] 内容与链接核对通过：项目技能列了检查命令时按它执行，否则跑本技能 `scripts/verifying-content.py` 与 `checking-links.py`。
 - [ ] 调 `quarto_render_check`：`dry_run: true` 最多 2 次，确认 `safe_to_render`；`dry_run: false` 最多 1 次，确认 `html_report.usable` 为 true。不手跑 `quarto render`，也不截图 PNG。
+- [ ] 收尾调用一次 `quarto_pass_report`：`skill` 填 `writing-quarto`，`mode` 填 `polish` 或 `rewrite`，文件与步骤的改动次数、未改项、检查结论照实填。卡片就是回执，回复里不再复述；没改也传 0，当前文件不是章节时传 `executed: false`。

package/skills/writing-quarto/steps/09-check.md

@@ -2,11 +2,13 @@
 
 产出：内容核对结果、一次渲染检查和 HTML 可用性报告。这一步只跑命令，不按报告改写法。
 
+内容与链接检查需要 Python 3；`dry_run: false` 的渲染还需要 Quarto CLI。缺少依赖时停住并报告，不改回手跑 `quarto render`。
+
 ## 通用情况
 
 ### 内容与链接
 
-项目技能存在时，只跑它列出的内容命令，通常是 `run.ps1 verify --changed`。没有项目技能时，在书根跑本技能 `scripts/` 下的 `verifying-content.py` 与 `checking-links.py`。
+项目技能列了内容检查命令时，只跑它列出的命令。没有项目技能时，在书根跑本技能 `scripts/` 下的 `verifying-content.py` 与 `checking-links.py`。
 
 `verifying-content.py` 查章节表、YAML 标题、标题层级、句段长度、围栏语言、Mermaid 围栏、占位文字和本地链接。项目专属检查只在书的 `.agents/skills/quarto-book-project/` 存在时启用。
 
@@ -43,6 +45,18 @@
 
 不手跑 `quarto render`，也不手跑 `checking-output.py`、`checking-callouts.py`、`checking-dom.py`。工具已经按当前书配置调用它们。
 
+### 执行回执
+
+检查结论确定后，调用一次 `quarto_pass_report`，把这次执行的结论压成一张卡片：
+
+- `skill` 填 `writing-quarto`，`mode` 填 `polish` 或 `rewrite`。
+- `files` 写这次动过的章节路径和改动次数（最多 8 个）；`steps` 只列有改动的步骤编号（1–9）与次数，两者合计必须一致。
+- `held` 写围栏、事实这类明确没有改动的地方；没改就传 0。
+- `checks` 抄内容与渲染的结论，名字只取 `content`、`html`、`layout`，状态只取 `pass`、`fail`、`skip`。
+- 当前文件不是章节时传 `executed: false`、`mode: skipped`，并给一句 `skip_reason`。
+
+卡片就是回执，回复里不再复述；回执不保存到磁盘，也不贴改写后的句子，不根据回执改文章。
+
 ## 情况
 
 ### 情况：全仓重构
@@ -55,7 +69,7 @@
 
 ## 完成判据
 
-内容命令通过，`dry_run: false` 返回 `render_result.ok: true`，且 `html_report.usable: true`，才算完成。任一条件不满足，回到报告指向的步骤。
+内容命令通过，`dry_run: false` 返回 `render_result.ok: true`，且 `html_report.usable: true`，并调用一次 `quarto_pass_report` 出回执，才算完成。任一条件不满足，回到报告指向的步骤。
 
 ## 正反例
 

package/templates/quarto-book-project/SKILL.md

@@ -38,7 +38,7 @@ description: 记录某一本 Quarto Book 的项目级约定：书名、读者、
 - HTML 可用性：只调 `quarto_render_check`，`qmd_path` 传当前章节；`dry_run: true` 最多 2 次，`dry_run: false` 最多 1 次。
 - 不手跑 `quarto render`，也不手跑 `checking-output.py` 或 `checking-callouts.py`；这些检查由工具按书配置调用。
 - 项目专属词表：同目录 `checks.json`（`forbidden_terms`、`fragment_prefixes`、`chapter_titles`）；不写就只跑通用规则。
-- 项目自己的封装命令（如 `run.ps1 verify --changed`）与它覆盖的 profile：
+- 项目自己的检查命令（如有）与它覆盖的 profile：
 - 命令在哪个环境执行（本机 / WSL / 容器）：
 
 ## 主题与过滤器路径

package/docs/creation-references.md

@@ -1,76 +0,0 @@
-# 创建参考
-
-本插件不是从零设计的。它从 DSH 官方文档、下载量靠前的社区插件和六个同类写作参考中取形状；下面记录每个来源被采用的部分，便于后续维护时判断哪些设计是借来的、哪些是本仓自己的约束。
-
-## 官方文档
-
-- 发布与 bundle 形状：<https://deepseek-harness.github.io/deepseek-harness/en/develop/basic/publish>
-  - 采用：`type: module` + `main` 入口、`dsh.bundle.patch`、`engines.dsh`、`files` 白名单、peer/dev 双声明。
-  - 采用：入口只导出 `name`、`inject` 与 `apply()`，不 import 宿主实现；补丁只 `insert` 一行。
-- 包展示元数据（中文）：<https://deepseek-harness.github.io/deepseek-harness/zh/develop/basic/adding-a-package>
-  - 采用：`locale/en.json` 与 `locale/zh.json` 的 `meta.title`、`meta.description`；`icon.svg` 自包含且不超过 256 KiB。
-- 技能子系统：<https://deepseek-harness.github.io/deepseek-harness/en/reference/subsystems/skills>
-  - 采用：提供者接口 `{ name, list, get }`、候选字段 `rank` / `locator` / `resourceBase`、目录型资源基址。
-  - 采用：包内 rank 550，数字大于项目 `.dsh/skills`（100）与 `.agents/skills`（200），优先级更低，同名项目技能可以覆盖。
-
-## 前 20 下载插件的共同形状
-
-数据快照：<https://www.dsh.so/data/npm-downloads.json>（2026-10-17 周榜，来源标注 dsh.so，CC-BY-4.0）。对 20 个包逐一读取 npm 元数据与 README 后得到：
-
-- 20/20 声明 `dsh` bundle；`lib/index.js` + `cordis.patch.yml` 是主流入口组合。
-- README 以中文为主：17/20 的正文主要是中文，3/20 是英文（`dsh-better-sidebar`、`dsh-context`、`@nanmicoder/dsh-agent-teams`）。
-- 18/20 的 README 提供 `English` 入口，8/20 同时给出 `简体中文` 入口；切换链接通常在标题或 badge 之后，不在首行。
-- 10/20 的包描述含中文，常见写法是中文在前、` · ` 后接英文；其余为纯英文描述。
-- 6/20 声明 `icon`（`dshmarket`、`dsh-better-sidebar`、`dsh-context`、`dsh-plugin-wallpaper-engine`、`dsh-pet`、`@xmanrui/dsh-im`）；本插件补上 `icon.svg` 与双语 `locale`，以改善插件市场展示。
-
-结论：README 以中文为主、按需提供英文切换；包描述中英并列或纯英文；安装命令只写官方 `dsh plugin add` 一种。
-
-## 同类写作插件
-
-### lunheng-article-pipeline
-
-- 仓库：<https://github.com/zuoyunlai/lunheng-article-pipeline-dsh>，默认分支 `master`
-- npm：`lunheng-article-pipeline@19.18.1`
-- 采用的形状：`skills/<name>/SKILL.md` 一层目录；`files` 同时包含 `skills` 与 `lib`；`exports` 暴露入口、补丁与 `package.json`；入口用 `ctx.skills` 注册并给每个技能独立的目录 `resourceBase`；补丁注释说明技能不再依赖旧的 skill-filesystem mount。
-- 保留的能力：技能正文与参考文件分离、按需加载；未采用其九角色长流程、子代理编排与插图交付。
-
-### dsh-plugin-writing-guard
-
-- 仓库：<https://github.com/xmutfyh/dsh-plugin-writing-guard>，默认分支 `master`
-- npm：`dsh-plugin-writing-guard@2.0.1`
-- 采用的形状：确定性检查放在独立 Python 脚本中，技能正文只写判断标准与调用方式；`files` 明确列出脚本目录，避免打包遗漏。
-- 保留的能力：把可机器判定的规则（词表、结构、命名）与需要判断的行文规则分开；未采用其论文投稿与 Word 包校验部分。
-
-### @waterwx/dsh-novel-forge
-
-- 仓库：<https://github.com/watersxya/dsh-novel-forge>，默认分支 `main`
-- npm：`@waterwx/dsh-novel-forge@2.5.1`
-- 采用的形状：`keywords` 同时写 `dsh`、`dsh-plugin`、`deepseek-harness`；样式检查拆成独立脚本；`files` 只列真正要发布的目录。
-- 保留的能力：CSS 变量、对比度、类名与回退检查各自独立；未采用其侧栏、章节生成和 `src/` 运行时。
-
-### @max-null/dsh-draft-polish
-
-- 仓库：<https://github.com/Max-Null/dsh-draft-polish>，默认分支 `main`
-- npm：`@max-null/dsh-draft-polish@0.2.5`
-- 采用的形状：`README.md` 与 `README_EN.md` 双语镜像；入口与补丁保持最小；设置只存在插件配置里。
-- 保留的能力：双语 README 的交叉链接；未采用其输入框润色按钮与会话草稿回填。
-
-### DEEP-IOS/dsh-humanizer
-
-- 仓库：<https://github.com/DEEP-IOS/dsh-humanizer>，默认分支 `main`
-- npm：`dsh-humanizer`（`latest` 与 `next` 通道并存，实际版本以仓库 README 为准）
-- 采用的形状：把「保留作者声音、事实与进度」写成技能正文的硬约束；对「为了人味过度改写」用原文锚点对照检查，而不是只做风格评分；理论材料按需返回，不要求每次读完整套。
-- 保留的能力：只取这些约束与对照思路。未采用其 SQLite 记忆、21 章理论、21 个工具和常驻写作引导；本插件不持久化任何写作状态。
-
-### op7418/Humanizer-zh
-
-- 仓库：<https://github.com/op7418/Humanizer-zh>，默认分支 `main`
-- 来源：blader/humanizer v3.0.0 的汉化版，MIT。
-- 采用的形状：31 个检查点分 A–F 六类的组织方式；把「假对比、起跑式铺垫、意义拔高、空泛高频词、客服腔、编辑过程残留」写进第 5、6 步的「情况：」；文件模式不改代码、命令、路径、链接、YAML、标题与锚点。
-- 保留的能力：每条规则带修改条件、前后示例与保留边界；没有问题的句子不改，不要求每次调用都产生修改。未采用其独立的 `/humanizer-zh` 技能入口和 AI 检测叙述。
-
-## 本仓自己的约束
-
-- 技能只从 `skills/*/SKILL.md` 发现，不递归扫描；模板放在 `templates/`，不会被注册。
-- 主题资产是本插件的一部分，不声称与任何外部仓库共享；项目若复制主题，以项目 `_quarto.yml` 的路径为准。
-- 所有项目专属内容（章节表、术语、命令、专属校验）留在项目的 `quarto-book-project` 技能里，插件正文不写死。