dominds 1.23.0 → 1.23.1

package/dist/access-control.js

@@ -311,13 +311,13 @@ function getAccessDeniedMessage(operation, targetPath, language = 'en') {
         lines.push('');
         if (language === 'zh') {
             lines.push(`- 说明：\`*.tsk/\` 是封装差遣牒。通用文件工具无法读/写/列目录/删除其中内容（硬编码无条件拒绝）。`);
-            lines.push(`- 提示：新增章节请使用 \`do_mind\`；少量追加请使用 \`mind_more\`（默认 progress：\`mind_more({\"items\":[\"...\"]})\`）；改写已有整章请使用带当前内容哈希的 \`change_mind\`（顶层：\`change_mind({\"selector\":\"goals|constraints|progress\",\"content\":\"...\",\"previous_content_hash\":\"sha256:...\"})\`；额外章节：先 \`recall_taskdoc\` 取得 \`content_hash\`，再 \`change_mind({\"category\":\"<category>\",\"selector\":\"<selector>\",\"content\":\"...\",\"previous_content_hash\":\"sha256:...\"})\`）。`);
-            lines.push(`- 提示：读取额外章节请使用函数工具 \`recall_taskdoc\`：\`recall_taskdoc({\"category\":\"<category>\",\"selector\":\"<selector>\"})\`。`);
+            lines.push(`- 提示：新增章节请使用 \`do_mind\`；少量追加请使用 \`mind_more\`（默认 progress：\`mind_more({\"items\":[\"...\"]})\`）；改写已有整章请先用 \`recall_taskdoc\` 取得当前内容哈希，再使用带 \`previous_content_hash\` 的 \`change_mind\`（顶层示例：先 \`recall_taskdoc({\"selector\":\"progress\"})\`，再 \`change_mind({\"selector\":\"progress\",\"content\":\"...\",\"previous_content_hash\":\"crc32:...\"})\`；额外章节：先 \`recall_taskdoc({\"category\":\"<category>\",\"selector\":\"<selector>\"})\`，再 \`change_mind({\"category\":\"<category>\",\"selector\":\"<selector>\",\"content\":\"...\",\"previous_content_hash\":\"crc32:...\"})\`）。`);
+            lines.push(`- 提示：读取章节或取得 content_hash 请使用函数工具 \`recall_taskdoc\`：顶层 \`recall_taskdoc({\"selector\":\"progress\"})\`；额外章节 \`recall_taskdoc({\"category\":\"<category>\",\"selector\":\"<selector>\"})\`。`);
         }
         else {
             lines.push(`- Note: \`*.tsk/\` is an encapsulated Taskdoc. It is hard-denied for all general file tools.`);
-            lines.push(`- Hint: To create a section, use \`do_mind\`; for small append-only updates, use \`mind_more\` (defaults to progress: \`mind_more({\"items\":[\"...\"]})\`); for full-section replacements, use \`change_mind\` with the current content hash (top-level: \`change_mind({\"selector\":\"goals|constraints|progress\",\"content\":\"...\",\"previous_content_hash\":\"sha256:...\"})\`; extra sections: call \`recall_taskdoc\` for \`content_hash\` first, then \`change_mind({\"category\":\"<category>\",\"selector\":\"<selector>\",\"content\":\"...\",\"previous_content_hash\":\"sha256:...\"})\`).`);
-            lines.push(`- Hint: To read extra sections, use \`recall_taskdoc({\"category\":\"<category>\",\"selector\":\"<selector>\"})\`.`);
+            lines.push(`- Hint: To create a section, use \`do_mind\`; for small append-only updates, use \`mind_more\` (defaults to progress: \`mind_more({\"items\":[\"...\"]})\`); for full-section replacements, call \`recall_taskdoc\` for the current content hash first, then use \`change_mind\` with \`previous_content_hash\` (top-level example: first \`recall_taskdoc({\"selector\":\"progress\"})\`, then \`change_mind({\"selector\":\"progress\",\"content\":\"...\",\"previous_content_hash\":\"crc32:...\"})\`; extra sections: first \`recall_taskdoc({\"category\":\"<category>\",\"selector\":\"<selector>\"})\`, then \`change_mind({\"category\":\"<category>\",\"selector\":\"<selector>\",\"content\":\"...\",\"previous_content_hash\":\"crc32:...\"})\`).`);
+            lines.push(`- Hint: To read a section or get content_hash, use \`recall_taskdoc\`: top-level \`recall_taskdoc({\"selector\":\"progress\"})\`; extra section \`recall_taskdoc({\"category\":\"<category>\",\"selector\":\"<selector>\"})\`.`);
         }
     }
     if (isMindsPath(targetPath)) {

package/dist/docs/encapsulated-taskdoc.md

@@ -149,7 +149,7 @@ Below is the canonical copy. If you need to rephrase it for UI layout, you MUST
 
 - Any `.tsk/` directory and its subpaths (`**/*.tsk/**`) are encapsulated state: general file tools MUST NOT read/write/list them (e.g. `read_file` / `write_file` / `list_dir`).
 - Taskdoc updates MUST go through explicit Taskdoc function tools: `do_mind` creates a new section, `mind_more` appends small entries to an existing section, `change_mind` replaces an existing section, and `never_mind` deletes a section.
-- To read extra sections that are NOT auto-injected, use the function tool `recall_taskdoc({ category, selector })`.
+- To read any Taskdoc section or get its `content_hash`, use the function tool `recall_taskdoc({ selector, category? })`.
 
 **Taskdoc auto-injection rules (system prompt)**
 
@@ -219,25 +219,25 @@ Hard prohibitions:
 - `contracts|acceptance|grants|runbook|decisions|risks` MUST NOT be written outside `category="bearinmind"`.
 - No other category is auto-injected into the system prompt (only an index may be shown).
 
-`previous_content_hash` is the `sha256:...` hash of the current section content after Dominds' canonical Markdown file-ending normalization. It is not stored as extra state.
+`previous_content_hash` is the `crc32:...` checksum of the current section content after Dominds' canonical Markdown file-ending normalization. It is not stored as extra state.
 
-- For auto-injected top-level sections (`goals`, `constraints`, `progress`), the injected Taskdoc status block shows each current `content_hash`.
-- For non-auto-injected sections, call `recall_taskdoc({ category, selector })`; its result includes `content_hash`.
+- For top-level sections (`goals`, `constraints`, `progress`), call `recall_taskdoc({ selector })`; its result includes `content_hash`.
+- For extra non-auto-injected sections, call `recall_taskdoc({ category, selector })`; its result includes `content_hash`.
 - On hash mismatch, the write MUST fail. The agent must re-read/review the current section and retry only after fully merging existing content.
 - If the proposed replacement would overwrite, delete, or materially replace existing content, the agent must have either direct human confirmation for that replacement, or a human-approved explicit SOP/acceptance standard that authorizes the replacement after considering the existing content.
 
-### `recall_taskdoc` (read-only; for non-auto-injected sections)
+### `recall_taskdoc` (read-only; for Taskdoc sections and content_hash)
 
 Because general file tools cannot read anything under `*.tsk/`, Dominds provides a dedicated read tool:
 
 ```
-recall_taskdoc({ category, selector })
+recall_taskdoc({ selector, category? })
 ```
 
 Behavior:
 
 - Reads `bearinmind/<whitelisted>.md` or `<category>/<selector>.md`.
-- The top-level three sections (`goals` / `constraints` / `progress`) are already auto-injected, so `recall_taskdoc` does not read them.
+- The top-level three sections (`goals` / `constraints` / `progress`) are auto-injected as content, but their `content_hash` is only returned by `recall_taskdoc`.
 - Returns the section `content_hash` for use as `change_mind.previous_content_hash`.
 
 Example (bearinmind):
@@ -257,8 +257,11 @@ Call the function tool `recall_taskdoc` with:
 Example:
 
 ```text
+Call the function tool `recall_taskdoc` with:
+{ "selector": "constraints" }
+
 Call the function tool `change_mind` with:
-{ "selector": "constraints", "content": "- MUST not browse the web.\n- MUST keep responses under 10 lines unless asked otherwise.\n", "previous_content_hash": "sha256:..." }
+{ "selector": "constraints", "content": "- MUST not browse the web.\n- MUST keep responses under 10 lines unless asked otherwise.\n", "previous_content_hash": "crc32:..." }
 ```
 
 ### Behavioral rules

package/dist/docs/encapsulated-taskdoc.zh.md

@@ -148,7 +148,7 @@ Dominds 必须从任务包构造一个**有效差遣牒**用于提示词和 UI
 
 - 任何 `.tsk/` 目录及其子路径（`**/*.tsk/**`）都是封装状态：禁止使用任何通用文件工具读取/写入/列目录（例如 `read_file` / `write_file` / `list_dir` 等）。
 - 更新差遣牒只能使用显式差遣牒函数工具：`do_mind` 创建新章节，`mind_more` 向已有章节追加少量条目，`change_mind` 替换已有章节，`never_mind` 删除章节。
-- 读取"不会自动注入上下文"的额外章节，只能使用函数工具 `recall_taskdoc({ category, selector })`。
+- 读取任意差遣牒章节或取得其 `content_hash`，只能使用函数工具 `recall_taskdoc({ selector, category? })`。
 
 **差遣牒自动注入规则（系统提示）**
 
@@ -164,7 +164,7 @@ Dominds 必须从任务包构造一个**有效差遣牒**用于提示词和 UI
 
 - Any `.tsk/` directory and its subpaths (`**/*.tsk/**`) are encapsulated state: general file tools MUST NOT read/write/list them (e.g. `read_file` / `write_file` / `list_dir`).
 - Taskdoc updates MUST go through explicit Taskdoc function tools: `do_mind` creates a new section, `mind_more` appends small entries to an existing section, `change_mind` replaces an existing section, and `never_mind` deletes a section.
-- To read extra sections that are NOT auto-injected, use the function tool `recall_taskdoc({ category, selector })`.
+- To read any Taskdoc section or get its `content_hash`, use the function tool `recall_taskdoc({ selector, category? })`.
 
 **Taskdoc auto-injection rules (system prompt)**
 
@@ -230,25 +230,25 @@ Dominds 必须从任务包构造一个**有效差遣牒**用于提示词和 UI
 - `contracts|acceptance|grants|runbook|decisions|risks` 不得在 `category="bearinmind"` 之外编写。
 - 没有其他类别会自动注入系统提示（只会显示一个索引）。
 
-`previous_content_hash` 是当前章节内容在 Dominds 规范化 Markdown 文件结尾之后得到的 `sha256:...` 哈希；它不是额外持久状态。
+`previous_content_hash` 是当前章节内容在 Dominds 规范化 Markdown 文件结尾之后得到的 `crc32:...` 校验值；它不是额外持久状态。
 
-- 顶层自动注入章节（`goals`、`constraints`、`progress`）的当前 `content_hash` 会显示在注入的差遣牒状态块中。
-- 非自动注入章节需要先调用 `recall_taskdoc({ category, selector })`；返回结果会包含 `content_hash`。
+- 顶层章节（`goals`、`constraints`、`progress`）需要调用 `recall_taskdoc({ selector })`；返回结果会包含 `content_hash`。
+- 额外非自动注入章节需要调用 `recall_taskdoc({ category, selector })`；返回结果会包含 `content_hash`。
 - 哈希不匹配时写入必须失败。智能体必须重新读取/回顾当前章节，并且只在充分合并原有内容后重试。
 - 如果拟替换内容会冲掉、删除或实质替换原有内容，智能体必须已获得该替换的直接人类确认，或存在人类认可的明确 SOP/验收标准，并且已按该标准考虑过原有内容。
 
-### `recall_taskdoc`（只读；用于非自动注入的部分）
+### `recall_taskdoc`（只读；用于差遣牒章节与 content_hash）
 
 因为通用文件工具无法读取 `*.tsk/` 下的任何内容，Dominds 提供了一个专门的读取工具：
 
 ```
-recall_taskdoc({ category, selector })
+recall_taskdoc({ selector, category? })
 ```
 
 行为：
 
 - 读取 `bearinmind/<whitelisted>.md` 或 `<category>/<selector>.md`。
-- 顶层三段（`goals` / `constraints` / `progress`）已经自动注入，因此 `recall_taskdoc` 不会读取它们。
+- 顶层三段（`goals` / `constraints` / `progress`）会自动注入正文，但其 `content_hash` 只通过 `recall_taskdoc` 返回。
 - 返回章节 `content_hash`，供 `change_mind.previous_content_hash` 使用。
 
 示例（bearinmind）：
@@ -268,8 +268,11 @@ recall_taskdoc({ category, selector })
 示例：
 
 ```text
+使用函数工具 `recall_taskdoc` 调用：
+{ "selector": "constraints" }
+
 使用函数工具 `change_mind` 调用：
-{ "selector": "constraints", "content": "- MUST not browse the web.\n- MUST keep responses under 10 lines unless asked otherwise.\n" }
+{ "selector": "constraints", "content": "- MUST not browse the web.\n- MUST keep responses under 10 lines unless asked otherwise.\n", "previous_content_hash": "crc32:..." }
 ```
 
 ### 行为规则

package/dist/minds/minds-i18n.js

@@ -55,7 +55,7 @@ function taskdocCanonicalCopy(language) {
             '',
             '- 任何 `.tsk/` 目录及其子路径（`**/*.tsk/**`）都是封装状态：禁止使用任何通用文件工具读取/写入/列目录（例如 `read_file` / `write_file` / `list_dir` 等）。',
             '- 更新 Taskdoc 只能使用函数工具 `do_mind` / `mind_more` / `change_mind` / `never_mind`：缺失章节用 `do_mind` 创建；少量新增用 `mind_more` 追加（默认 progress）；需要删除陈旧项、重排或压缩时用 `change_mind` 整章替换；确需删除整章文件时用 `never_mind`。',
-            '- 读取“不会自动注入上下文”的额外章节，只能使用函数工具 `recall_taskdoc({ category, selector })`。',
+            '- 读取章节或取得 `change_mind.previous_content_hash` 需要使用函数工具 `recall_taskdoc({ selector, category? })`；顶层三段省略 `category`，额外章节传入 `category`。',
             '',
             '**Taskdoc 自动注入规则（系统提示）**',
             '',
@@ -71,7 +71,7 @@ function taskdocCanonicalCopy(language) {
         '',
         '- Any `.tsk/` directory and its subpaths (`**/*.tsk/**`) are encapsulated state: general file tools MUST NOT read/write/list them (e.g. `read_file` / `write_file` / `list_dir`).',
         '- Taskdoc updates MUST go through `do_mind` / `mind_more` / `change_mind` / `never_mind`: use `do_mind` to create missing sections, use `mind_more` for small append-only additions (defaults to progress), use `change_mind` for full-section replacement when cleanup, reordering, or compression is needed, and use `never_mind` when a whole section file should be deleted.',
-        '- To read extra sections that are NOT auto-injected, use the function tool `recall_taskdoc({ category, selector })`.',
+        '- To read a section or get `change_mind.previous_content_hash`, use the function tool `recall_taskdoc({ selector, category? })`; omit `category` for top-level sections and pass it for extra sections.',
         '',
         '**Taskdoc auto-injection rules (system prompt)**',
         '',

package/dist/minds/system-prompt-parts.js

@@ -148,11 +148,11 @@ function getMemoryPromptCopy(ctx) {
     const taskdocLogLineZh = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
             ? '当前是告急处置态：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前对话历史中下一程需要知道的讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入接续包提醒项。提醒项长度没有技术限制，宁可完整一些；允许多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
-            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是告急处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并且能带上当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是告急处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并并先调用 `recall_taskdoc` 取得当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
                 ? '当前是吃紧处置态：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前对话历史中下一程需要知道的讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入接续包提醒项。提醒项长度没有技术限制，宁可完整一些；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
-                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是吃紧处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并且能带上当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是吃紧处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并并先调用 `recall_taskdoc` 取得当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
             : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步；提醒项也只留可扫读摘录。接续包提醒项默认应保持结构化、便于快速恢复。';
     const contextHealthLineEn = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
@@ -166,11 +166,11 @@ function getMemoryPromptCopy(ctx) {
     const taskdocLogLineEn = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
             ? 'Current mode is critical remediation: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into continuation-package reminders. Reminder length has no technical limit, so prefer being complete. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
-            : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is critical remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you can pass the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
+            : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is critical remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you have first called `recall_taskdoc` to get the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
                 ? 'Current mode is caution remediation: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into continuation-package reminders. Reminder length has no technical limit, so prefer being complete. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
-                : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is caution remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you can pass the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
+                : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is caution remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you have first called `recall_taskdoc` to get the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
             : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps; reminders should also keep only scannable excerpts. Keep continuation-package reminders structured and fast to resume from by default.';
     if (ctx.language === 'zh') {
         return {
@@ -181,7 +181,7 @@ function getMemoryPromptCopy(ctx) {
             taskdocSemanticsLine: '- 章节语义约定：`progress` 是全队共享、准实时、可扫读的任务公告牌，用来记录当前有效状态、关键决策、下一步与仍成立阻塞；不是流水账，也不是个人工作记录。`goals` / `constraints` 是较稳定的任务契约；每次更新都必须保留仍然有效的他人条目。',
             taskdocSectionReplaceLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
                 ? '- 当前处于支线对话的上下文健康处置态：本程不要维护差遣牒，也不要整理差遣牒更新提案；把下一程需要恢复的细节写入足够详尽的接续包提醒项。'
-                : `- 更新差遣牒时：少量新增条目可用 \`mind_more\` 追加（默认 progress）；缺失章节用 \`do_mind\` 创建；需要删除陈旧项、重排结构或压缩时，用 \`change_mind\` 整章替换并先对照“上下文中注入的当前内容”做合并，同时带上当前 \`content_hash\` 作为 \`previous_content_hash\`；需要删除整章文件时用 \`never_mind\`；禁止覆盖/抹掉他人条目；自己负责维护的条目必须标注责任人（例如 \`- [owner:@${ctx.agentId}] ...\` 或用 \`### @${ctx.agentId}\` 分块）。`,
+                : `- 更新差遣牒时：少量新增条目可用 \`mind_more\` 追加（默认 progress）；缺失章节用 \`do_mind\` 创建；需要删除陈旧项、重排结构或压缩时，先对照上下文中注入的当前内容完成合并，再调用 \`recall_taskdoc\` 取得当前 \`content_hash\`，然后用带 \`previous_content_hash\` 的 \`change_mind\` 整章替换；需要删除整章文件时用 \`never_mind\`；禁止覆盖/抹掉他人条目；自己负责维护的条目必须标注责任人（例如 \`- [owner:@${ctx.agentId}] ...\` 或用 \`### @${ctx.agentId}\` 分块）。`,
             progressLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
                 ? '- 当前处于支线对话的上下文健康处置态：本程不更新 `progress`；只把下一程接续所需信息写入提醒项。'
                 : '- 更新 `progress` 时：它必须始终是可供全队扫读的完整当前快照，而不是只追加自己这一轮的零散笔记。',
@@ -202,7 +202,7 @@ function getMemoryPromptCopy(ctx) {
             sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'
                 ? `工作流：先做事 → 再提炼（\`update_reminder\`；必要时整理差遣牒追加条目/更新提案并诉请 \`@${ctx.taskdocMaintainerId}\` 合并写入）→ 然后 \`clear_mind\` 清空噪音。`
                 : '工作流：停止扩张上下文 → 维护足够详尽的接续包提醒项（`add_reminder` 或 `update_reminder`，长度没有技术限制）→ 然后 `clear_mind` 开启新一程。',
-            mainDialogWorkflowLine: '工作流：先做事 -> 再提炼（`update_reminder` + `mind_more(progress)`；需要压缩/删旧时用带 `previous_content_hash` 的 `change_mind`；要删除整章文件时用 `never_mind`）-> 然后 `clear_mind` 清空噪音。',
+            mainDialogWorkflowLine: '工作流：先做事 -> 再提炼（`update_reminder` + `mind_more(progress)`；需要压缩/删旧时先 `recall_taskdoc` 取得 `content_hash`，再用带 `previous_content_hash` 的 `change_mind`；要删除整章文件时用 `never_mind`）-> 然后 `clear_mind` 清空噪音。',
             contextHealthLine: contextHealthLineZh,
             taskdocLogLine: taskdocLogLineZh,
         };
@@ -215,7 +215,7 @@ function getMemoryPromptCopy(ctx) {
         taskdocSemanticsLine: '- Section semantics: `progress` is the team-shared, quasi-real-time, scannable task bulletin board for current effective state, key decisions, next steps, and still-active blockers; it is not a raw log or personal work record. `goals` / `constraints` are the more stable task contract; every update must preserve still-valid entries from others.',
         taskdocSectionReplaceLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
             ? '- Current mode is context-health remediation in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals in this course; put resume-critical details into sufficiently detailed continuation-package reminders.'
-            : `- When updating Taskdoc: use \`mind_more\` for small append-only additions (defaults to progress); create missing sections with \`do_mind\`; when stale entries must be removed, reordered, or compressed, use \`change_mind\` for a full-section replacement based on the current injected content and include the current \`content_hash\` as \`previous_content_hash\`; when a whole section file should be removed, use \`never_mind\`; do not overwrite other contributors; add an explicit owner tag for entries you maintain (e.g., \`- [owner:@${ctx.agentId}] ...\` or a \`### @${ctx.agentId}\` block).`,
+            : `- When updating Taskdoc: use \`mind_more\` for small append-only additions (defaults to progress); create missing sections with \`do_mind\`; when stale entries must be removed, reordered, or compressed, first merge against the current injected content, then call \`recall_taskdoc\` to get the current \`content_hash\`, then use \`change_mind\` for a full-section replacement with that value as \`previous_content_hash\`; when a whole section file should be removed, use \`never_mind\`; do not overwrite other contributors; add an explicit owner tag for entries you maintain (e.g., \`- [owner:@${ctx.agentId}] ...\` or a \`### @${ctx.agentId}\` block).`,
         progressLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
             ? '- Current mode is context-health remediation in a Side Dialog: do not update `progress` in this course; put resume-critical information into reminders only.'
             : '- When updating `progress`, keep it as a complete, team-scannable current snapshot instead of appending only your own latest notes.',
@@ -236,7 +236,7 @@ function getMemoryPromptCopy(ctx) {
         sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'
             ? `Workflow: do work → distill (\`update_reminder\`; when Taskdoc needs updates, draft append entries, a merged replacement, or a section deletion and ask \`@${ctx.taskdocMaintainerId}\`) → then \`clear_mind\` to drop noise.`
             : 'Workflow: stop expanding context → maintain sufficiently detailed continuation-package reminders (`add_reminder` or `update_reminder`, with no technical length limit) → then `clear_mind` to start a new course.',
-        mainDialogWorkflowLine: 'Workflow: do work -> distill (`update_reminder` + `mind_more(progress)`; use `change_mind` with `previous_content_hash` when compression/deletion is needed; use `never_mind` when removing a whole section file) -> then `clear_mind` to drop noise.',
+        mainDialogWorkflowLine: 'Workflow: do work -> distill (`update_reminder` + `mind_more(progress)`; when compression/deletion is needed, first use `recall_taskdoc` to get `content_hash`, then use `change_mind` with `previous_content_hash`; use `never_mind` when removing a whole section file) -> then `clear_mind` to drop noise.',
         contextHealthLine: contextHealthLineEn,
         taskdocLogLine: taskdocLogLineEn,
     };

package/dist/runtime/driver-messages.js

@@ -407,7 +407,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
                 '',
                 '操作：',
                 '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
-                '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并并带上 `previous_content_hash` 时，才更新：change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})',
+                '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并时，才先调用 recall_taskdoc({"selector":"<selector>"}) 取得 content_hash，再更新：change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})',
                 '- 优先新增过桥提醒项：add_reminder({ "content": "..." })',
                 '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
             ].join('\n');
@@ -443,7 +443,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '',
             '操作：',
             '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
-            '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并并带上 `previous_content_hash` 时，才更新：change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})',
+            '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并时，才先调用 recall_taskdoc({"selector":"<selector>"}) 取得 content_hash，再更新：change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})',
             '- 优先新增过桥提醒项：add_reminder({ "content": "..." })',
             '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
             '- clear_mind({})',
@@ -484,7 +484,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '',
             'Operations:',
             '- Prefer creating a new Taskdoc section for discussion details: do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
-            '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content and can provide `previous_content_hash`: change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})',
+            '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content: first call recall_taskdoc({"selector":"<selector>"}) for content_hash, then change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})',
             '- Prefer adding a bridge reminder first: add_reminder({ "content": "..." })',
             '- Only if an existing reminder is clearly the right place, and updating it would not add extra cognitive load in the current course: update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
         ].join('\n');
@@ -520,7 +520,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
         '',
         'Operations:',
         '- Prefer creating a new Taskdoc section for discussion details: do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
-        '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content and can provide `previous_content_hash`: change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})',
+        '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content: first call recall_taskdoc({"selector":"<selector>"}) for content_hash, then change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})',
         '- Prefer adding a bridge reminder first: add_reminder({ "content": "..." })',
         '- Only if an existing reminder is clearly the right place, and updating it would not add extra cognitive load in the current course: update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
         '- clear_mind({})',

package/dist/tools/ctrl.d.ts

@@ -17,7 +17,7 @@
  * - change_mind: Main Dialog only; update a `.tsk/` Taskdoc section without starting a new course
  * - mind_more: Main Dialog only; append entries to a `.tsk/` Taskdoc section without starting a new course
  * - never_mind: Main Dialog only; delete a `.tsk/` Taskdoc section file without starting a new course
- * - recall_taskdoc: Read a Taskdoc section from `*.tsk/` by (category, selector)
+ * - recall_taskdoc: Read a Taskdoc section from `*.tsk/` by selector and optional category
  *
  * USAGE CONTEXT:
  * Can both be triggered by an agent autonomously, or by human with role='user' msg,

package/dist/tools/ctrl.js

@@ -18,7 +18,7 @@
  * - change_mind: Main Dialog only; update a `.tsk/` Taskdoc section without starting a new course
  * - mind_more: Main Dialog only; append entries to a `.tsk/` Taskdoc section without starting a new course
  * - never_mind: Main Dialog only; delete a `.tsk/` Taskdoc section file without starting a new course
- * - recall_taskdoc: Read a Taskdoc section from `*.tsk/` by (category, selector)
+ * - recall_taskdoc: Read a Taskdoc section from `*.tsk/` by selector and optional category
  *
  * USAGE CONTEXT:
  * Can both be triggered by an agent autonomously, or by human with role='user' msg,
@@ -372,8 +372,8 @@ function getCtrlMessages(language) {
             invalidFormatDoMind: '参数格式不对。用法：do_mind({ selector: string, category?: string, content: string })',
             invalidFormatChangeMind: '参数格式不对。用法：change_mind({ selector: string, category?: string, content: string, previous_content_hash: string })',
             tooManyArgsChangeMind: '参数格式不对。用法：change_mind({ selector: string, category?: string, content: string, previous_content_hash: string })',
-            taskDocPreviousContentHashRequired: '错误：change_mind 需要 previous_content_hash。请先基于已注入的顶层差遣牒内容或 recall_taskdoc 返回的 content_hash，合并原有内容后再整段替换；没有把握时用 mind_more 追加小条目。',
-            taskDocPreviousContentHashInvalid: '错误：previous_content_hash 格式无效。它必须是 recall_taskdoc 或已注入差遣牒状态中显示的 sha256:<64位十六进制> content_hash。',
+            taskDocPreviousContentHashRequired: '错误：change_mind 需要 previous_content_hash。请先调用 recall_taskdoc 显式取得当前章节的 content_hash，合并原有内容后再整段替换；没有把握时用 mind_more 追加小条目。',
+            taskDocPreviousContentHashInvalid: '错误：previous_content_hash 格式无效。它必须是 recall_taskdoc 返回的 crc32:<8位十六进制> content_hash。',
             taskDocContentHashMismatch: (relativePath, currentContentHash) => `错误：${relativePath} 的内容哈希不匹配，说明该章节已变化或你没有基于当前内容改写。\n` +
                 `当前 content_hash：${currentContentHash}\n\n` +
                 `请重新读取/回顾当前章节内容，并只在已充分合并原有内容后重试。若新内容会冲掉、删除或实质替换原有内容，必须满足其一：\n` +
@@ -384,7 +384,7 @@ function getCtrlMessages(language) {
             invalidFormatNeverMind: '参数格式不对。用法：never_mind({ selector: string, category?: string })',
             mindMoreItemsRequired: '需要提供要追加的条目（items），且每一项都必须是非空字符串。\n' +
                 '示例：mind_more({"items":["- 下一步：复核验证结果（详见 <文档路径>#<章节>）","- 阻塞：等待 API 验收口径确认"]})',
-            invalidFormatRecallTaskdoc: '参数格式不对。用法：recall_taskdoc({ category: string, selector: string })',
+            invalidFormatRecallTaskdoc: '参数格式不对。用法：recall_taskdoc({ selector: string, category?: string })',
             taskDocContentRequired: '需要提供差遣牒内容（content）。\n' +
                 '示例：\n' +
                 '```json\n' +
@@ -397,15 +397,14 @@ function getCtrlMessages(language) {
             pathMustBeWithinWorkspace: '路径必须位于 rtws（运行时工作区）内',
             invalidTaskDocPath: (taskDocPath) => `差遣牒路径 '${taskDocPath}' 无效。应为 *.tsk/ 目录。`,
             selectorRequired: '需要提供选择器（selector）。',
-            categoryRequired: '需要提供章节目录（category）。',
             invalidSelector: (selector) => `选择器 '${selector}' 无效。可用：顶层 goals | constraints | progress；bearinmind 下 contracts | acceptance | grants | runbook | decisions | risks；或任意标识符（如 ux.checklist）。`,
             invalidCategory: (category) => `目录名 '${category}' 无效。需匹配 ^[a-zA-Z][a-zA-Z0-9_-]*(\\.[a-zA-Z0-9_-]*)*$。`,
             invalidCategorySelector: (selector) => `选择器 '${selector}' 无效。需匹配 ^[a-zA-Z][a-zA-Z0-9_-]*(\\.[a-zA-Z0-9_-]*)*$。`,
             topLevelSelectorRequiresNoCategory: (category, selector) => `选择器 '${selector}' 是顶层保留分段（goals/constraints/progress），不能与 category='${category}' 一起用。`,
             bearInMindSelectorRequiresBearInMindCategory: (category, selector) => `选择器 '${selector}' 只能在 category='bearinmind' 下用（当前 category='${category}'）。`,
-            taskDocSectionAlreadyExists: (relativePath) => `无法新增：${relativePath} 已存在。若确有把握要改写已有章节，请先取得当前 content_hash，再使用 change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})。`,
+            taskDocSectionAlreadyExists: (relativePath) => `无法新增：${relativePath} 已存在。若确有把握要改写已有章节，请先用 recall_taskdoc 取得当前 content_hash，再使用 change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})。`,
             taskDocSectionChangeMissing: (relativePath) => `无法修改：${relativePath} 不存在。若要新增章节，请使用 do_mind({ ... })。`,
-            taskDocSectionMissing: (relativePath) => `未找到：${relativePath}。\n\n新增章节请使用 do_mind；已有章节追加小条目用 mind_more；改写已有章节用 change_mind 并带上当前 content_hash：\n- do_mind({"category":"<category>","selector":"<selector>","content":"..."})\n- mind_more({"category":"<category>","selector":"<selector>","items":["..."]})\n- change_mind({"category":"<category>","selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})`,
+            taskDocSectionMissing: (relativePath) => `未找到：${relativePath}。\n\n新增章节请使用 do_mind；已有章节追加小条目用 mind_more；改写已有章节时先用 recall_taskdoc 取得当前 content_hash，再用 change_mind 带上它：\n- do_mind({"category":"<category>","selector":"<selector>","content":"..."})\n- mind_more({"category":"<category>","selector":"<selector>","items":["..."]})\n- recall_taskdoc({"category":"<category>","selector":"<selector>"})\n- change_mind({"category":"<category>","selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})`,
             taskDocSectionDeleteMissing: (relativePath) => `无法删除：${relativePath} 不存在。请先确认要删除的差遣牒章节。`,
             clearedCoursePrompt: (nextCourse) => (0, driver_messages_1.formatNewCourseStartPrompt)('zh', { nextCourse, source: 'clear_mind' }),
         };
@@ -422,8 +421,8 @@ function getCtrlMessages(language) {
         invalidFormatDoMind: 'Error: Invalid args. Use: do_mind({ selector: string, category?: string, content: string })',
         invalidFormatChangeMind: 'Error: Invalid args. Use: change_mind({ selector: string, category?: string, content: string, previous_content_hash: string })',
         tooManyArgsChangeMind: 'Error: Invalid args. Use: change_mind({ selector: string, category?: string, content: string, previous_content_hash: string })',
-        taskDocPreviousContentHashRequired: 'Error: change_mind requires previous_content_hash. Use the content_hash from the injected top-level Taskdoc section or recall_taskdoc result, merge the existing content, then replace the full section. If unsure, use mind_more for small append-only updates.',
-        taskDocPreviousContentHashInvalid: 'Error: invalid previous_content_hash. It must be the sha256:<64 hex chars> content_hash shown by recall_taskdoc or the injected Taskdoc status block.',
+        taskDocPreviousContentHashRequired: 'Error: change_mind requires previous_content_hash. Call recall_taskdoc first to get the current section content_hash, merge the existing content, then replace the full section. If unsure, use mind_more for small append-only updates.',
+        taskDocPreviousContentHashInvalid: 'Error: invalid previous_content_hash. It must be the crc32:<8 hex chars> content_hash returned by recall_taskdoc.',
         taskDocContentHashMismatch: (relativePath, currentContentHash) => `Error: content hash mismatch for \`${relativePath}\`; the section changed or your replacement was not based on the current content.\n` +
             `Current content_hash: ${currentContentHash}\n\n` +
             `Re-read/review the current section and retry only after fully merging existing content. If the new content would overwrite, delete, or materially replace existing content, one of these must be true:\n` +
@@ -434,7 +433,7 @@ function getCtrlMessages(language) {
         invalidFormatNeverMind: 'Error: Invalid args. Use: never_mind({ selector: string, category?: string })',
         mindMoreItemsRequired: 'Error: items are required, and every item must be a non-empty string.\n' +
             'Example: mind_more({"items":["- Next: review verification results (details: <doc-path>#<section>)","- Blocker: API acceptance criteria pending"]})',
-        invalidFormatRecallTaskdoc: 'Error: Invalid args. Use: recall_taskdoc({ category: string, selector: string })',
+        invalidFormatRecallTaskdoc: 'Error: Invalid args. Use: recall_taskdoc({ selector: string, category?: string })',
         taskDocContentRequired: 'Error: Taskdoc content is required (content).\n' +
             'Copy/paste example:\n' +
             '```json\n' +
@@ -447,15 +446,14 @@ function getCtrlMessages(language) {
         pathMustBeWithinWorkspace: 'Error: Path must be within rtws (runtime workspace)',
         invalidTaskDocPath: (taskDocPath) => `Error: Invalid Taskdoc path '${taskDocPath}'. Expected a \`*.tsk/\` directory.`,
         selectorRequired: 'Error: selector is required.',
-        categoryRequired: 'Error: category is required.',
         invalidSelector: (selector) => `Error: Invalid selector '${selector}'. Use: top-level goals|constraints|progress; under bearinmind: contracts|acceptance|grants|runbook|decisions|risks; or any identifier (e.g. \`ux.checklist\`).`,
         invalidCategory: (category) => `Error: Invalid category '${category}'. Must match \`^[a-zA-Z][a-zA-Z0-9_-]*(\\.[a-zA-Z0-9_-]+)*$\`.`,
         invalidCategorySelector: (selector) => `Error: Invalid category selector '${selector}'. Must match \`^[a-zA-Z][a-zA-Z0-9_-]*(\\.[a-zA-Z0-9_-]+)*$\`.`,
         topLevelSelectorRequiresNoCategory: (category, selector) => `Error: Selector '${selector}' is reserved for top-level sections (goals/constraints/progress) and must not be used with category='${category}'.`,
         bearInMindSelectorRequiresBearInMindCategory: (category, selector) => `Error: Selector '${selector}' is only valid under category='bearinmind' (got category='${category}').`,
-        taskDocSectionAlreadyExists: (relativePath) => `Cannot add: \`${relativePath}\` already exists. If you are sure you need to rewrite an existing section, get the current content_hash first, then use \`change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})\`.`,
+        taskDocSectionAlreadyExists: (relativePath) => `Cannot add: \`${relativePath}\` already exists. If you are sure you need to rewrite an existing section, call \`recall_taskdoc\` for the current content_hash first, then use \`change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})\`.`,
         taskDocSectionChangeMissing: (relativePath) => `Cannot change: \`${relativePath}\` does not exist. To create a new section, use \`do_mind({ ... })\`.`,
-        taskDocSectionMissing: (relativePath) => `Not found: \`${relativePath}\`.\n\nUse \`do_mind\` to create a section, \`mind_more\` for small append-only updates to existing sections, and \`change_mind\` with the current content_hash to rewrite existing sections:\n- \`do_mind({\"category\":\"<category>\",\"selector\":\"<selector>\",\"content\":\"...\"})\`\n- \`mind_more({\"category\":\"<category>\",\"selector\":\"<selector>\",\"items\":[\"...\"]})\`\n- \`change_mind({\"category\":\"<category>\",\"selector\":\"<selector>\",\"content\":\"...\",\"previous_content_hash\":\"sha256:...\"})\``,
+        taskDocSectionMissing: (relativePath) => `Not found: \`${relativePath}\`.\n\nUse \`do_mind\` to create a section, \`mind_more\` for small append-only updates to existing sections, and \`recall_taskdoc\` then \`change_mind\` with the current content_hash to rewrite existing sections:\n- \`do_mind({\"category\":\"<category>\",\"selector\":\"<selector>\",\"content\":\"...\"})\`\n- \`mind_more({\"category\":\"<category>\",\"selector\":\"<selector>\",\"items\":[\"...\"]})\`\n- \`recall_taskdoc({\"category\":\"<category>\",\"selector\":\"<selector>\"})\`\n- \`change_mind({\"category\":\"<category>\",\"selector\":\"<selector>\",\"content\":\"...\",\"previous_content_hash\":\"crc32:...\"})\``,
         taskDocSectionDeleteMissing: (relativePath) => `Cannot delete: \`${relativePath}\` does not exist. Check the Taskdoc section target first.`,
         clearedCoursePrompt: (nextCourse) => (0, driver_messages_1.formatNewCourseStartPrompt)('en', { nextCourse, source: 'clear_mind' }),
     };
@@ -750,7 +748,7 @@ exports.changeMindTool = {
             content: { type: 'string', description: 'New section content.' },
             previous_content_hash: {
                 type: 'string',
-                description: 'Content hash of the current section being replaced. Use the content_hash shown in the injected Taskdoc for top-level sections or returned by recall_taskdoc for extra sections.',
+                description: 'Content hash of the current section being replaced. Call recall_taskdoc first and use the returned content_hash.',
             },
         },
     },
@@ -784,7 +782,7 @@ exports.changeMindTool = {
         const previousContentHash = typeof previousContentHashValue === 'string' ? previousContentHashValue.trim() : '';
         if (!previousContentHash)
             return (0, tool_1.toolFailure)(t.taskDocPreviousContentHashRequired);
-        if (!/^sha256:[0-9a-f]{64}$/u.test(previousContentHash)) {
+        if (!/^crc32:[0-9a-f]{8}$/u.test(previousContentHash)) {
             return (0, tool_1.toolFailure)(t.taskDocPreviousContentHashInvalid);
         }
         // Taskdoc path is immutable for the dialog lifecycle.
@@ -1166,18 +1164,24 @@ exports.mindMoreTool = {
 exports.recallTaskdocTool = {
     type: 'func',
     name: 'recall_taskdoc',
-    description: 'Read one Taskdoc section by (category, selector).',
+    description: 'Read one Taskdoc section and return its content_hash.',
     descriptionI18n: {
-        en: 'Read one Taskdoc section by (category, selector).',
-        zh: '按 (category, selector) 读取一段差遣牒章节。',
+        en: 'Read one Taskdoc section and return its content_hash.',
+        zh: '读取一段差遣牒章节并返回 content_hash。',
     },
     parameters: {
         type: 'object',
         additionalProperties: false,
-        required: ['category', 'selector'],
+        required: ['selector'],
         properties: {
-            category: { type: 'string', description: 'Category directory within the Taskdoc.' },
-            selector: { type: 'string', description: 'Section selector within the category.' },
+            category: {
+                type: 'string',
+                description: 'Optional category directory within the Taskdoc. Omit for top-level goals|constraints|progress.',
+            },
+            selector: {
+                type: 'string',
+                description: 'Section selector. Top-level: goals|constraints|progress. With category: selector within that category.',
+            },
         },
     },
     argsValidation: 'dominds',
@@ -1185,9 +1189,10 @@ exports.recallTaskdocTool = {
         const language = (0, work_language_1.getWorkLanguage)();
         const t = getCtrlMessages(language);
         const categoryValue = args['category'];
-        const category = typeof categoryValue === 'string' ? categoryValue.trim() : '';
-        if (category === '')
-            return (0, tool_1.toolFailure)(t.categoryRequired);
+        if (categoryValue !== undefined && typeof categoryValue !== 'string') {
+            return (0, tool_1.toolFailure)(t.invalidFormatRecallTaskdoc);
+        }
+        const category = typeof categoryValue === 'string' ? categoryValue.trim() : undefined;
         const selectorValue = args['selector'];
         const selector = typeof selectorValue === 'string' ? selectorValue.trim() : '';
         if (selector === '')
@@ -1228,9 +1233,6 @@ exports.recallTaskdocTool = {
             }
         }
         const target = parsed.target;
-        if (target.kind === 'top_level') {
-            return (0, tool_1.toolFailure)(t.invalidFormatRecallTaskdoc);
-        }
         const relPath = (0, task_package_1.taskPackageRelativePathForChangeMindTarget)(target);
         const sectionPath = path.resolve(fullPath, relPath);
         if (!isPathWithinDirectory(sectionPath, fullPath)) {

package/dist/tools/prompts/control/en/principles.md

@@ -132,7 +132,7 @@ Taskdoc is a **task contract** and the task's **team-shared source of current tr
 
 - Keep concise: reminders are often 1-3 items; prefer `update_reminder` to compress/merge
 - Separate carriers: information that must synchronize the team's current effective state, key decisions, next steps, or still-active blockers belongs in `progress`, the quasi-real-time task bulletin board; reminders keep local resume details
-- Team-facing: keep `progress` scannable and centered on what is still effective now; do not let it degrade into a personal log, raw chronology, scratchpad, or stale history pile. Use `mind_more` for small additions and `change_mind` with the current `content_hash` as `previous_content_hash` when cleanup/reordering/compression is needed
+- Team-facing: keep `progress` scannable and centered on what is still effective now; do not let it degrade into a personal log, raw chronology, scratchpad, or stale history pile. Use `mind_more` for small additions; when cleanup/reordering/compression is needed, call `recall_taskdoc` first and then use `change_mind` with the returned `content_hash` as `previous_content_hash`
 - Condense when needed: `mind_more` is not the default bookkeeping move. If one topic already has several phase notes, prefer `change_mind` to merge them into the current summary; put the detailed expansion in formal rtws documentation and keep a document pointer in Taskdoc. If the replacement would overwrite existing content, proceed only with direct human confirmation or after applying a human-approved SOP/acceptance standard that considers the existing content
 - Collapse before clearing: the Main Dialog first records undocumented discussion details the next course needs to know into the appropriate Taskdoc sections, then creates a structured continuation-package reminder; a Side Dialog must not maintain Taskdoc or draft Taskdoc update proposals, and should directly maintain sufficiently detailed continuation-package reminders. If the current course is already under system remediation, rough multi-reminder carry-over is acceptable but must be reconciled first in the new course
 - Avoid raw-material dumps: do not paste long logs or large tool outputs into reminders
@@ -156,7 +156,7 @@ Taskdoc is a **task contract** and the task's **team-shared source of current tr
 ## Limitations and Notes
 
 1. `dialog` reminders end with the dialog; `personal` reminders stay visible in all later dialogs you lead
-2. Use `do_mind` to create missing Taskdoc sections; use `mind_more` for small Taskdoc additions; use `change_mind` for full-section replacement of existing sections after merging existing content and include the current `content_hash` as `previous_content_hash`; use `never_mind` when a whole section file should be deleted. Do not treat `mind_more` as a chronology tool; when cleanup, stale-entry removal, or same-topic consolidation is needed, use `change_mind`
+2. Use `do_mind` to create missing Taskdoc sections; use `mind_more` for small Taskdoc additions; use `change_mind` for full-section replacement of existing sections only after merging existing content and calling `recall_taskdoc` for the current `content_hash`; use `never_mind` when a whole section file should be deleted. Do not treat `mind_more` as a chronology tool; when cleanup, stale-entry removal, or same-topic consolidation is needed, use `recall_taskdoc` then `change_mind`
 3. `do_mind` / `mind_more` / `change_mind` / `never_mind` do not start a new course
 4. A continuation-package reminder should keep only details still not covered by Taskdoc but easy to lose during resume; in the Main Dialog, undocumented discussion details from current dialog history that the next course needs to know should be written to the appropriate Taskdoc sections first; in a Side Dialog under caution/critical remediation, maintain sufficiently detailed continuation-package reminders only
 5. Do not turn `personal` reminders into a long-term fact dump; move durable knowledge into `personal_memory`

package/dist/tools/prompts/control/en/scenarios.md

@@ -130,11 +130,15 @@ mind_more({
 });
 
 // Full-section replacement when cleanup, reordering, same-topic consolidation, or chronology compression is needed
+recall_taskdoc({
+  selector: 'progress',
+});
+
 change_mind({
   selector: 'progress',
   content:
     '## Progress\n\n### Current Effective State\n- The memory-carrier boundary cleanup is complete; next we strengthen the Taskdoc bulletin-board semantics; details: <doc-path>#<section>\n\n### Decisions In Effect\n- `personal_memory` is no longer treated as a short-term junk drawer\n- `team_memory` now carries only long-lived team conventions and invariants\n\n### Next Step\n- Add stronger `progress` bulletin-board guidance in control / team_mgmt manuals\n\n### Still-Active Blockers\n- None',
-  previous_content_hash: 'sha256:...',
+  previous_content_hash: 'crc32:...',
 });
 ```
 
@@ -147,11 +151,15 @@ Update task objectives.
 ### Example
 
 ```typescript
+recall_taskdoc({
+  selector: 'goals',
+});
+
 change_mind({
   selector: 'goals',
   content:
     '## Goals\n\n- [ ] Create all toolset manuals\n  - [x] ws_mod\n  - [x] team_mgmt\n  - [x] personal_memory\n  - [ ] control (In Progress)\n- [ ] Write tool descriptions',
-  previous_content_hash: 'sha256:...',
+  previous_content_hash: 'crc32:...',
 });
 ```
 
@@ -164,11 +172,15 @@ Update task constraints.
 ### Example
 
 ```typescript
+recall_taskdoc({
+  selector: 'constraints',
+});
+
 change_mind({
   selector: 'constraints',
   content:
     '## Constraints\n\n- man function must dynamically filter toolsets based on team.yaml\n- Runtime effective: Changes to team.yaml immediately visible\n- Toolset names use underscore format\n- New constraint: Each toolset needs 5 topics × 2 languages',
-  previous_content_hash: 'sha256:...',
+  previous_content_hash: 'crc32:...',
 });
 ```
 
@@ -181,6 +193,11 @@ Read taskdoc chapter content.
 ### Example
 
 ```typescript
+// Top-level sections are injected as content, but recall_taskdoc returns their content_hash
+recall_taskdoc({
+  selector: 'progress',
+});
+
 // Read bearinmind runbook
 recall_taskdoc({
   category: 'bearinmind',
@@ -204,10 +221,14 @@ Maintain taskdoc integrity and consistency, and keep `progress` as a team-scanna
 
 ```typescript
 // Update progress (keep goals / constraints / progress consistent)
+recall_taskdoc({
+  selector: 'progress',
+});
+
 change_mind({
   selector: 'progress',
   content:
     '## Progress\n\n### Current Effective State\n- The boundary wording has been propagated into handbook sources and tests; details: <doc-path>#<section>\n\n### Decisions In Effect\n- role assets / personal_memory / team_memory / Taskdoc-progress / reminders now have separated responsibilities\n\n### Next Step\n- Re-verify control manual wording, Taskdoc display text, and boundary tests\n\n### Still-Active Blockers\n- None',
-  previous_content_hash: 'sha256:...',
+  previous_content_hash: 'crc32:...',
 });
 ```