dominds 1.20.2 → 1.20.4

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

@@ -147,7 +147,7 @@ Dominds 必须从任务包构造一个**有效差遣牒**用于提示词和 UI
 **差遣牒封装与访问限制**
 
 - 任何 `.tsk/` 目录及其子路径（`**/*.tsk/**`）都是封装状态：禁止使用任何通用文件工具读取/写入/列目录（例如 `read_file` / `write_file` / `list_dir` 等）。
-- 更新差遣牒只能使用函数工具 `change_mind`（按章节整段替换；顶层用 `selector`，额外章节用 `category + selector`）。
+- 更新差遣牒只能使用显式差遣牒函数工具：`do_mind` 创建新章节，`mind_more` 向已有章节追加少量条目，`change_mind` 替换已有章节，`never_mind` 删除章节。
 - 读取"不会自动注入上下文"的额外章节，只能使用函数工具 `recall_taskdoc({ category, selector })`。
 
 **差遣牒自动注入规则（系统提示）**
@@ -163,7 +163,7 @@ Dominds 必须从任务包构造一个**有效差遣牒**用于提示词和 UI
 **Taskdoc encapsulation & access restrictions**
 
 - 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 the function tool `change_mind` (whole-section replace; use top-level `selector`, or `category + selector` for extra sections).
+- 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 })`.
 
 **Taskdoc auto-injection rules (system prompt)**
@@ -179,21 +179,26 @@ Dominds 必须从任务包构造一个**有效差遣牒**用于提示词和 UI
 - 有效差遣牒必须是确定性的（除了上述框架之外没有隐藏的重新格式化）。
 - 允许空部分，但文件仍然存在。
 
-## `change_mind` 语义（不开启新一程对话）
+## 差遣牒变更语义（不开启新一程对话）
 
-函数工具 `change_mind` 通过**替换其整个内容**来更新任务包的**恰好一个**部分文件。
+差遣牒变更函数工具每次只影响任务包的**恰好一个**章节文件：
+
+- `do_mind` 创建新章节文件；如果目标已存在，必须失败。
+- `mind_more` 追加条目，不会自动去重或改写旧内容。
+- `change_mind` 替换已有章节文件；如果目标不存在，必须失败。
+- `never_mind` 删除已有章节文件。
 
 关键点：
 
-- `change_mind` 不开启新一程对话。
+- 差遣牒变更工具不开启新一程对话。
 - 如需开启新一程对话，请单独调用函数工具 `clear_mind({ "reminder_content": "<接续包>" })`（或其他对话过程控制机制）。
   - 建议：包含一个有效的接续包，以便智能体在下一程对话流畅接续。
 
 ### 参数（当前）
 
-`change_mind` 通过**替换其整个内容**来更新**恰好一个**差遣牒分段。
+`do_mind` 和 `change_mind` 都定位**恰好一个**差遣牒分段。
 
-它接受：
+它们接受：
 
 - `selector`（必需）
 - `content`（必需）
@@ -240,7 +245,7 @@ recall_taskdoc({ category, selector })
 示例（bearinmind）：
 
 ```text
-使用函数工具 `change_mind` 调用：
+使用函数工具 `do_mind` 调用：
 { "selector": "grants", "category": "bearinmind", "content": "- Allowed: ...\n- Disallowed: ...\n" }
 ```
 
@@ -262,18 +267,20 @@ recall_taskdoc({ category, selector })
 
 - `(category, selector)` 对必须根据上述保留选择器规则有效；其他任何内容都是错误。
 - 正文被视为不透明的 markdown 文本；不暗示部分修补/差异语义。
-- 成功的 `change_mind` 会立即更新任务包，并对以下内容可见：
+- 成功的差遣牒变更会立即更新任务包，并对以下内容可见：
   - 当前对话
   - 对话树中的所有支线对话/队友
   - 任何观察的 WebUI 客户端
 
 ### 失败情况（非穷尽）
 
-如果满足以下条件，`change_mind` 必须被拒绝：
+如果满足以下条件，差遣牒变更必须被拒绝：
 
 - 选择器缺失或无效。
 - 正文缺失（仅当明确支持时才允许空正文；v1 应拒绝空正文以防止错误）。
 - 调用尝试定位定义集之外的文件。
+- `do_mind` 指向已存在的章节。
+- `change_mind` 指向不存在的章节。
 
 ## 文件工具封装策略（`**/*.tsk/`）
 
@@ -286,7 +293,7 @@ recall_taskdoc({ category, selector })
 理由：
 
 - 防止通过通用文件操作进行意外编辑。
-- 强制通过明确的、有语义的操作（`change_mind`）进行差遣牒变更。
+- 强制通过明确的、有语义的操作（`do_mind`、`mind_more`、`change_mind`、`never_mind`）进行差遣牒变更。
 - 避免智能体"好心"地在没有明确意图的情况下重写任务约束这类提示词/控制流陷阱。
 
 系统提示词（和向智能体展示的任何工具文档）必须明确说明此限制。

package/dist/minds/load.js

@@ -26,6 +26,12 @@ const toolset_manual_1 = require("../tools/toolset-manual");
 const minds_i18n_1 = require("./minds-i18n");
 const system_prompt_1 = require("./system-prompt");
 const system_prompt_parts_1 = require("./system-prompt-parts");
+const TASKDOC_MUTATION_TOOL_NAMES = new Set([
+    ctrl_1.doMindTool.name,
+    ctrl_1.mindMoreTool.name,
+    ctrl_1.changeMindTool.name,
+    ctrl_1.neverMindTool.name,
+]);
 async function readAgentMindResult(id, fn, source) {
     const mindFn = source === 'rtws'
         ? path_1.default.join('.minds', 'team', id, fn)
@@ -190,8 +196,8 @@ async function loadAgentMinds(agentId, dialog, options) {
     });
     // Introduction of all team members (mark "(self)" for the current agent)
     const teamIntro = (0, system_prompt_1.formatTeamIntro)(team, agent.id, workingLanguage);
-    // Compose tool list from member's resolved toolsets and tools + built-in human tool
-    // Get base tools from agent (excluding intrinsic dialog control tools which are always injected)
+    // Compose tool list from member's resolved toolsets and tools + built-in human tool.
+    // Get base tools from agent; runtime injects allowed intrinsic dialog-control tools afterward.
     // shell_specialists is intended for visible teammates only. Hidden members are exempt from this
     // policy and may carry shell tools.
     const agentIsShellSpecialist = team.shellSpecialists.includes(agent.id) || agent.hidden === true;
@@ -210,7 +216,7 @@ async function loadAgentMinds(agentId, dialog, options) {
             return tools;
         return tools.filter((t) => !(t.type === 'func' && typeof t.name === 'string' && (0, shell_tools_1.isShellToolName)(t.name)));
     })();
-    // Inject intrinsic dialog control tools as function tools (available to all agents).
+    // Inject intrinsic dialog-control tools as function tools according to dialog scope.
     const intrinsicFuncTools = [
         ctrl_1.addReminderTool,
         ctrl_1.deleteReminderTool,
@@ -220,9 +226,12 @@ async function loadAgentMinds(agentId, dialog, options) {
     ];
     // Taskdoc mutation tools are only available in main dialogs (not sideDialogs).
     if (dialog === undefined || dialog.askerDialog === undefined) {
+        intrinsicFuncTools.push(ctrl_1.doMindTool);
         intrinsicFuncTools.push(ctrl_1.mindMoreTool);
         intrinsicFuncTools.push(ctrl_1.changeMindTool);
+        intrinsicFuncTools.push(ctrl_1.neverMindTool);
     }
+    const shouldHideTaskdocMutationTools = dialog !== undefined && dialog.askerDialog !== undefined;
     const agentTools = (() => {
         const out = [...baseAgentTools];
         const seenNames = new Set(out.map((t) => t.name));
@@ -232,7 +241,9 @@ async function loadAgentMinds(agentId, dialog, options) {
                 seenNames.add(t.name);
             }
         }
-        return out;
+        if (!shouldHideTaskdocMutationTools)
+            return out;
+        return out.filter((t) => !TASKDOC_MUTATION_TOOL_NAMES.has(t.name));
     })();
     const toolsetNames = agent
         .listResolvedToolsetNames({

package/dist/minds/minds-i18n.js

@@ -54,7 +54,7 @@ function taskdocCanonicalCopy(language) {
             '**Taskdoc 封装与访问限制**',
             '',
             '- 任何 `.tsk/` 目录及其子路径（`**/*.tsk/**`）都是封装状态：禁止使用任何通用文件工具读取/写入/列目录（例如 `read_file` / `write_file` / `list_dir` 等）。',
-            '- 更新 Taskdoc 只能使用函数工具 `mind_more` / `change_mind`：少量新增用 `mind_more` 追加（默认 progress），需要删除陈旧项、重排或压缩时用 `change_mind` 整章替换。',
+            '- 更新 Taskdoc 只能使用函数工具 `do_mind` / `mind_more` / `change_mind` / `never_mind`：缺失章节用 `do_mind` 创建；少量新增用 `mind_more` 追加（默认 progress）；需要删除陈旧项、重排或压缩时用 `change_mind` 整章替换；确需删除整章文件时用 `never_mind`。',
             '- 读取“不会自动注入上下文”的额外章节，只能使用函数工具 `recall_taskdoc({ category, selector })`。',
             '',
             '**Taskdoc 自动注入规则（系统提示）**',
@@ -70,7 +70,7 @@ function taskdocCanonicalCopy(language) {
         '**Taskdoc encapsulation & access restrictions**',
         '',
         '- 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 `mind_more` / `change_mind`: use `mind_more` for small append-only additions (defaults to progress), and use `change_mind` for full-section replacement when cleanup, reordering, or compression is needed.',
+        '- 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 })`.',
         '',
         '**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 直接塞进差遣牒；差遣牒只写结论+下一步。当前是告急处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线直接用 `mind_more`/`change_mind` 写入差遣牒合适章节。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是告急处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、且已完成合并时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
                 ? '当前是吃紧处置态：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前对话历史中下一程需要知道的讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入接续包提醒项。提醒项长度没有技术限制，宁可完整一些；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
-                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是吃紧处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线直接用 `mind_more`/`change_mind` 写入差遣牒合适章节。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是吃紧处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、且已完成合并时，才用 `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, write them to the appropriate Taskdoc section with `mind_more`/`change_mind`. 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 and you have merged against the current content. 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, write them to the appropriate Taskdoc section with `mind_more`/`change_mind`. 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 and you have merged against the current content. 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）；需要删除陈旧项、重排结构或压缩时，用 \`change_mind\` 整章替换并先对照“上下文中注入的当前内容”做合并；禁止覆盖/抹掉他人条目；自己负责维护的条目必须标注责任人（例如 \`- [owner:@${ctx.agentId}] ...\` 或用 \`### @${ctx.agentId}\` 分块）。`,
+                : `- 更新差遣牒时：少量新增条目可用 \`mind_more\` 追加（默认 progress）；缺失章节用 \`do_mind\` 创建；需要删除陈旧项、重排结构或压缩时，用 \`change_mind\` 整章替换并先对照“上下文中注入的当前内容”做合并；需要删除整章文件时用 \`never_mind\`；禁止覆盖/抹掉他人条目；自己负责维护的条目必须标注责任人（例如 \`- [owner:@${ctx.agentId}] ...\` 或用 \`### @${ctx.agentId}\` 分块）。`,
             progressLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
                 ? '- 当前处于支线对话的上下文健康处置态：本程不更新 `progress`；只把下一程接续所需信息写入提醒项。'
                 : '- 更新 `progress` 时：它必须始终是可供全队扫读的完整当前快照，而不是只追加自己这一轮的零散笔记。',
@@ -193,7 +193,7 @@ function getMemoryPromptCopy(ctx) {
             teamMemoryLine: '- 团队记忆：稳定的团队约定/工程规约（跨任务共享）。',
             personalMemoryLine: '- 个人记忆：稳定的个人习惯/偏好与职责域知识；记忆会在每次生成时自动注入上下文，应保持少量且准确（关键文档/代码的精确路径 + 最小必要事实）。不要记录具体任务状态。',
             sideDialogDutyLine: ctx.contextHealthPromptMode === 'normal'
-                ? `你当前处于支线对话：此处不允许 \`mind_more\` / \`change_mind\`。当你判断需要更新差遣牒（尤其是 progress 公告牌）时，请在合适时机直接诉请差遣牒维护人 \`@${ctx.taskdocMaintainerId}\` 执行更新，并给出要追加的条目或已合并好的“新全文/替换稿”。不要声称已更新，除非看到回执。`
+                ? `你当前处于支线对话：此处不允许 \`do_mind\` / \`mind_more\` / \`change_mind\` / \`never_mind\`。当你判断需要更新差遣牒（尤其是 progress 公告牌）时，请在合适时机直接诉请差遣牒维护人 \`@${ctx.taskdocMaintainerId}\` 执行更新，并给出要新增的章节、要追加的条目、已合并好的“新全文/替换稿”，或要删除的章节。不要声称已更新，除非看到回执。`
                 : '你当前处于支线对话，且上下文已进入吃紧/告急处置态：本程不要维护差遣牒，也不要整理差遣牒更新提案。请把下一程需要恢复的讨论细节、定位、验证方式和临时信息写入足够详尽的接续包提醒项。',
             mainDialogDutyLine: '你当前处于主线对话：你负责综合维护全队共享差遣牒（尤其是 progress 公告牌）。当队友/支线对话提出更新建议时，及时合并、压缩并保持清晰。',
             teammateTellaskRoundDoneLine: `队友诉请重要语义：当你在诉请者上下文中收到带${runtimeMarkers.finalCompleted}标记的回贴，表示该轮诉请已经结束；对方不会继续执行同一轮诉请。此时如果目标未达成，“等待”是错误的：必须显式发起新一轮 tellask 才能继续推进。`,
@@ -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)`；需要压缩/删旧时用 `change_mind(progress)`）→ 然后 `clear_mind` 清空噪音。',
+            mainDialogWorkflowLine: '工作流：先做事 → 再提炼（`update_reminder` + `mind_more(progress)`；需要压缩/删旧时用 `change_mind(progress)`；要删除整章文件时用 `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); when stale entries must be removed, reordered, or compressed, use \`change_mind\` for a full-section replacement based on the current injected content; 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, use \`change_mind\` for a full-section replacement based on the current injected content; 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.',
@@ -227,16 +227,16 @@ function getMemoryPromptCopy(ctx) {
         teamMemoryLine: '- Team memory: stable shared conventions (cross-task).',
         personalMemoryLine: '- Personal memory: stable personal habits/preferences and responsibility-scope knowledge. Memory is automatically injected into context on each generation: keep it small and accurate (exact key doc/code paths + minimal key facts); do not store per-task state.',
         sideDialogDutyLine: ctx.contextHealthPromptMode === 'normal'
-            ? `You are currently in a Side Dialog: \`mind_more\` / \`change_mind\` are not allowed here. When Taskdoc should be updated (especially the shared progress bulletin board), tellask the Taskdoc maintainer \`@${ctx.taskdocMaintainerId}\` with entries to append or a fully merged replacement draft. Do not claim it is updated until you see a receipt.`
+            ? `You are currently in a Side Dialog: \`do_mind\` / \`mind_more\` / \`change_mind\` / \`never_mind\` are not allowed here. When Taskdoc should be updated (especially the shared progress bulletin board), tellask the Taskdoc maintainer \`@${ctx.taskdocMaintainerId}\` with the new section to create, entries to append, a fully merged replacement draft, or the section to delete. Do not claim it is updated until you see a receipt.`
             : 'You are currently in a Side Dialog under caution/critical context-health remediation: do not maintain Taskdoc and do not draft Taskdoc update proposals in this course. Put discussion details, pointers, verification method, and volatile resume information into sufficiently detailed continuation-package reminders.',
         mainDialogDutyLine: 'You are currently in the Main Dialog: you are responsible for keeping the team-shared Taskdoc coherent and up to date (especially the progress bulletin board). Merge proposals from teammates/Side Dialogs promptly and keep it concise.',
         teammateTellaskRoundDoneLine: `Teammate Tellask semantics: when you receive a tellasker reply with the ${runtimeMarkers.finalCompleted} marker, that Tellask round is finished; the tellaskee will not keep executing the same call in the background. If the objective is not met, “waiting” is wrong: you must explicitly start a new Tellask round to continue.`,
         teamMemoryHintLine: 'Hint: you have team-memory tools (`add_team_memory` / `replace_team_memory` / `drop_team_memory` / `clear_team_memory`) and may maintain team memory when it is truly stable and worth sharing.',
         personalMemoryHintLine: `Hint: you have personal-memory tools (\`add_personal_memory\` / \`replace_personal_memory\` / \`drop_personal_memory\` / \`clear_personal_memory\`). Personal memory is private to the current agent and is automatically isolated under \`.minds/memory/individual/<member-id>/...\`; therefore \`path\` MUST NOT include your member id (do not write \`${ctx.agentId}/...\`). For first-time setup, just call \`add_personal_memory\`—the directory will be created automatically. Memory is automatically injected into context on each generation: keep it small, keep it accurate, and group facts that are updated together. Store stable facts (exact key paths + minimal contracts), not daily state/progress. If you changed those files or detect staleness/conflicts, immediately \`replace_personal_memory\` to keep it accurate.`,
         sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'
-            ? `Workflow: do work → distill (\`update_reminder\`; when Taskdoc needs updates, draft append entries or a merged replacement and ask \`@${ctx.taskdocMaintainerId}\`) → then \`clear_mind\` to drop noise.`
+            ? `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(progress)` when compression/deletion is needed) → then `clear_mind` to drop noise.',
+        mainDialogWorkflowLine: 'Workflow: do work → distill (`update_reminder` + `mind_more(progress)`; use `change_mind(progress)` when compression/deletion is needed; 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

@@ -406,7 +406,8 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
                 '当前已处于吃紧处置阶段：不要继续扩张上下文，也不要提前进入“按接续包做清醒复核”的模式；那是系统真正开启新一程后的第一步。当前程的目标是先把未落文档的讨论细节补进差遣牒，再把差遣牒仍未覆盖、但恢复工作会丢的信息带过桥；真正清理冗余、合并提醒项，放到新一程再做。然后主动 clear_mind，开启新一程对话继续工作。',
                 '',
                 '操作：',
-                '- 先写差遣牒：mind_more({ "items": ["..."] })；需要删旧/重排/压缩时改用 change_mind({ ... })',
+                '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
+                '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并时，才更新：change_mind({ ... })',
                 '- 优先新增过桥提醒项：add_reminder({ "content": "..." })',
                 '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
             ].join('\n');
@@ -441,7 +442,8 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '行动：你当前处于主线对话。尽快保住易丢信息，然后 clear_mind。当前处于告急处置阶段时，先把当前对话历史中尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节。然后再把差遣牒仍未覆盖、但恢复工作会丢的信息新增提醒项带过桥；允许先保留多条粗略提醒项，甚至带一定冗余也可以，不必在当前程强行整理干净。',
             '',
             '操作：',
-            '- 先写差遣牒：mind_more({ "items": ["..."] })；需要删旧/重排/压缩时改用 change_mind({ ... })',
+            '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
+            '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并时，才更新：change_mind({ ... })',
             '- 优先新增过桥提醒项：add_reminder({ "content": "..." })',
             '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
             '- clear_mind({})',
@@ -481,7 +483,8 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             'You are already in caution remediation for the current course, so do not keep expanding context and do not switch early into “clear-headed continuation-package review” mode; that is the first step only after the system actually starts the new course. In the current course, the goal is to first fill Taskdoc with undocumented discussion details, then carry forward details still not covered by Taskdoc; reminder cleanup and dedup belong to the new course. Then proactively clear_mind to start a new dialog course.',
             '',
             'Operations:',
-            '- First write Taskdoc: mind_more({ "items": ["..."] }); use change_mind({ ... }) instead when deletion/reordering/compression is needed',
+            '- 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: change_mind({ ... })',
             '- 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');
@@ -516,7 +519,8 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
         'Action: you are in the Main Dialog. Preserve easy-to-lose information, then clear_mind. In critical remediation, first record current-dialog discussion details that are not yet documented but the next course needs to know into the appropriate Taskdoc sections. Then add bridge reminders for information still not covered by Taskdoc but easy to lose. Multiple rough reminders, including some redundancy, are acceptable as a bridge; do not spend the current course forcing them into a clean final package.',
         '',
         'Operations:',
-        '- First write Taskdoc: mind_more({ "items": ["..."] }); use change_mind({ ... }) instead when deletion/reordering/compression is needed',
+        '- 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: change_mind({ ... })',
         '- 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/server/api-routes.js

@@ -45,6 +45,7 @@ exports.handleApiRoute = handleApiRoute;
  */
 const diligence_1 = require("@longrun-ai/kernel/diligence");
 const language_1 = require("@longrun-ai/kernel/types/language");
+const html_1 = require("@longrun-ai/kernel/utils/html");
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const promises_1 = __importDefault(require("fs/promises"));
 const path = __importStar(require("path"));
@@ -62,6 +63,7 @@ const team_1 = require("../team");
 const tool_availability_1 = require("../tool-availability");
 const id_1 = require("../utils/id");
 const taskdoc_search_1 = require("../utils/taskdoc-search");
+const taskdoc_search_worker_client_1 = require("../utils/taskdoc-search-worker-client");
 const create_dialog_contract_1 = require("./create-dialog-contract");
 const dominds_self_update_1 = require("./dominds-self-update");
 const mime_types_1 = require("./mime-types");
@@ -1300,6 +1302,9 @@ async function handleApiRoute(req, res, pathname, context) {
             return await handleGetDialogArtifact(req, res, { rootId, selfId }, status);
         }
         // Taskdocs endpoint
+        if (pathname === '/api/task-documents/suggestions' && req.method === 'GET') {
+            return await handleGetTaskDocumentSuggestions(req, res);
+        }
         if (pathname === '/api/task-documents' && req.method === 'GET') {
             return await handleGetTaskDocuments(res);
         }
@@ -2869,6 +2874,66 @@ async function handleGetTaskDocuments(res) {
         return true;
     }
 }
+function renderTaskDocumentSuggestionHtml(suggestions) {
+    return suggestions
+        .map((doc, index) => {
+        const showName = doc.name.trim() !== '' && doc.name !== doc.relativePath;
+        const nameHtml = showName ? `<div class="suggestion-name">${(0, html_1.escapeHtml)(doc.name)}</div>` : '';
+        return `<div class="suggestion" data-index="${String(index)}"><div class="suggestion-path">${(0, html_1.escapeHtml)(doc.relativePath)}</div>${nameHtml}</div>`;
+    })
+        .join('');
+}
+async function handleGetTaskDocumentSuggestions(req, res) {
+    try {
+        const urlObj = new URL(req.url ?? '', 'http://127.0.0.1');
+        const query = (urlObj.searchParams.get('q') ?? '').trim();
+        const workerPayload = {
+            rootDir: '.',
+            query,
+            limit: 50,
+        };
+        const requestKey = (0, taskdoc_search_worker_client_1.buildTaskDocumentSuggestionRequestKey)(workerPayload);
+        const abortController = new AbortController();
+        res.once('close', () => {
+            if (!res.writableEnded)
+                abortController.abort();
+        });
+        const result = await (0, taskdoc_search_worker_client_1.searchTaskDocumentSuggestionsInWorker)(workerPayload, {
+            signal: abortController.signal,
+        });
+        if (abortController.signal.aborted || res.writableEnded)
+            return true;
+        if (result.kind === 'error') {
+            log.error('Failed to search taskdoc suggestions', new Error(result.errorText), {
+                query,
+            });
+            const payload = {
+                success: false,
+                error: result.errorText,
+            };
+            respondJson(res, 500, payload);
+            return true;
+        }
+        const payload = {
+            success: true,
+            query,
+            requestKey,
+            suggestions: result.suggestions,
+            html: renderTaskDocumentSuggestionHtml(result.suggestions),
+        };
+        respondJson(res, 200, payload);
+        return true;
+    }
+    catch (error) {
+        log.error('Failed to search taskdoc suggestions', error);
+        const payload = {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to search taskdoc suggestions',
+        };
+        respondJson(res, 500, payload);
+        return true;
+    }
+}
 /**
  * Helper function to read request body
  */

package/dist/server/port-selection.d.ts

@@ -0,0 +1,19 @@
+export declare const DEFAULT_WEBUI_PORT = 5666;
+export declare const MIN_AUTO_WEBUI_PORT = 1024;
+export type WebuiPortAutoDirection = 'down' | 'up';
+export type ParsedPortSpec = {
+    port: number;
+    strictPort: boolean;
+    portAutoDirection: WebuiPortAutoDirection;
+};
+export declare function parseWebuiPortSpec(raw: string): ParsedPortSpec | null;
+export declare function validateWebuiPort(port: number, context: string): void;
+export declare function buildWebuiPortCandidates(params: {
+    preferredPort: number;
+    strictPort: boolean;
+    direction: WebuiPortAutoDirection;
+}): number[];
+export declare function formatWebuiPortScanBound(params: {
+    preferredPort: number;
+    direction: WebuiPortAutoDirection;
+}): string;

package/dist/server/port-selection.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_AUTO_WEBUI_PORT = exports.DEFAULT_WEBUI_PORT = void 0;
+exports.parseWebuiPortSpec = parseWebuiPortSpec;
+exports.validateWebuiPort = validateWebuiPort;
+exports.buildWebuiPortCandidates = buildWebuiPortCandidates;
+exports.formatWebuiPortScanBound = formatWebuiPortScanBound;
+exports.DEFAULT_WEBUI_PORT = 5666;
+exports.MIN_AUTO_WEBUI_PORT = 1024;
+function parseWebuiPortSpec(raw) {
+    let numericText = raw;
+    let strictPort = true;
+    let portAutoDirection = 'down';
+    if (raw.endsWith('+')) {
+        numericText = raw.slice(0, -1);
+        strictPort = false;
+        portAutoDirection = 'up';
+    }
+    else if (raw.endsWith('-')) {
+        numericText = raw.slice(0, -1);
+        strictPort = false;
+        portAutoDirection = 'down';
+    }
+    if (!/^[0-9]+$/.test(numericText))
+        return null;
+    const port = Number(numericText);
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        return null;
+    return { port, strictPort, portAutoDirection };
+}
+function validateWebuiPort(port, context) {
+    if (!Number.isInteger(port) || port < 0 || port > 65535) {
+        throw new Error(`${context} must be an integer in [0, 65535] (got ${String(port)})`);
+    }
+}
+function buildWebuiPortCandidates(params) {
+    validateWebuiPort(params.preferredPort, 'WebUI port');
+    if (params.strictPort || params.preferredPort === 0)
+        return [params.preferredPort];
+    const candidates = [params.preferredPort];
+    if (params.direction === 'down') {
+        for (let candidate = params.preferredPort - 1; candidate >= exports.MIN_AUTO_WEBUI_PORT; candidate -= 1) {
+            candidates.push(candidate);
+        }
+    }
+    else {
+        for (let candidate = params.preferredPort + 1; candidate <= 65535; candidate += 1) {
+            candidates.push(candidate);
+        }
+    }
+    return candidates;
+}
+function formatWebuiPortScanBound(params) {
+    return params.direction === 'down'
+        ? `down to ${Math.min(params.preferredPort, exports.MIN_AUTO_WEBUI_PORT)}`
+        : 'up to 65535';
+}

package/dist/server/server-core.d.ts

@@ -46,9 +46,9 @@ export declare class HttpServerCore {
     private sendError;
     private sendUnauthorized;
     /**
-     * Start the server - NO PORT FALLBACK, enforce specific port
+     * Start the server on the configured port.
      */
-    start(): Promise<void>;
+    start(): Promise<number>;
     /**
      * Stop the server
      */

package/dist/server/server-core.js

@@ -182,17 +182,31 @@ class HttpServerCore {
         res.end(JSON.stringify({ error: 'unauthorized' }));
     }
     /**
-     * Start the server - NO PORT FALLBACK, enforce specific port
+     * Start the server on the configured port.
      */
     start() {
         return new Promise((resolve, reject) => {
-            this.server.on('error', (error) => {
+            const cleanup = () => {
+                this.server.off('error', onError);
+                this.server.off('listening', onListening);
+            };
+            const onError = (error) => {
+                cleanup();
                 reject(error);
-            });
-            this.server.listen(this.config.port, this.config.host, () => {
-                log.debug(`Server listening on http://${this.config.host}:${this.config.port}`);
-                resolve();
-            });
+            };
+            const onListening = () => {
+                cleanup();
+                const address = this.server.address();
+                const actualPort = typeof address === 'object' && address !== null
+                    ? address.port
+                    : this.config.port;
+                this.config = { ...this.config, port: actualPort };
+                log.debug(`Server listening on http://${this.config.host}:${actualPort}`);
+                resolve(actualPort);
+            };
+            this.server.once('error', onError);
+            this.server.once('listening', onListening);
+            this.server.listen(this.config.port, this.config.host);
         });
     }
     /**

package/dist/server/static-server.js

@@ -42,6 +42,7 @@ Available API endpoints:
 • GET /api/dialogs/:root/sideDialogs/:self/list-node - Get one dialog-list sideDialog node
 • GET /api/dialogs/:root/hierarchy - Get dialog hierarchy
 • GET /api/task-documents - Taskdoc listing
+• GET /api/task-documents/suggestions?q=... - Worker-backed Taskdoc suggestions
 
 WebSocket endpoint: /ws
 Backend API endpoint: /api

package/dist/server.d.ts

@@ -1,4 +1,5 @@
 import { AuthConfig } from './server/auth';
+import { type WebuiPortAutoDirection } from './server/port-selection';
 import { HttpServerCore } from './server/server-core';
 import './tools/builtins';
 export type ServerOptions = {
@@ -6,6 +7,8 @@ export type ServerOptions = {
     host?: string;
     mode?: 'dev' | 'prod';
     startBackendDriver?: boolean;
+    strictPort?: boolean;
+    portAutoDirection?: WebuiPortAutoDirection;
 };
 export type StartedServer = {
     httpServer: HttpServerCore;