dominds 1.20.3 → 1.20.4

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,10 +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));
@@ -233,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` / `never_mind`：少量新增用 `mind_more` 追加（默认 progress），需要删除陈旧项、重排或压缩时用 `change_mind` 整章替换，确需删除整章文件时用 `never_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` / `never_mind`: 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.',
+        '- 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\` 整章替换并先对照“上下文中注入的当前内容”做合并；需要删除整章文件时用 \`never_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\` / \`never_mind\`。当你判断需要更新差遣牒（尤其是 progress 公告牌）时，请在合适时机直接诉请差遣牒维护人 \`@${ctx.taskdocMaintainerId}\` 执行更新，并给出要追加的条目、已合并好的“新全文/替换稿”，或要删除的章节。不要声称已更新，除非看到回执。`
+                ? `你当前处于支线对话：此处不允许 \`do_mind\` / \`mind_more\` / \`change_mind\` / \`never_mind\`。当你判断需要更新差遣牒（尤其是 progress 公告牌）时，请在合适时机直接诉请差遣牒维护人 \`@${ctx.taskdocMaintainerId}\` 执行更新，并给出要新增的章节、要追加的条目、已合并好的“新全文/替换稿”，或要删除的章节。不要声称已更新，除非看到回执。`
                 : '你当前处于支线对话，且上下文已进入吃紧/告急处置态：本程不要维护差遣牒，也不要整理差遣牒更新提案。请把下一程需要恢复的讨论细节、定位、验证方式和临时信息写入足够详尽的接续包提醒项。',
             mainDialogDutyLine: '你当前处于主线对话：你负责综合维护全队共享差遣牒（尤其是 progress 公告牌）。当队友/支线对话提出更新建议时，及时合并、压缩并保持清晰。',
             teammateTellaskRoundDoneLine: `队友诉请重要语义：当你在诉请者上下文中收到带${runtimeMarkers.finalCompleted}标记的回贴，表示该轮诉请已经结束；对方不会继续执行同一轮诉请。此时如果目标未达成，“等待”是错误的：必须显式发起新一轮 tellask 才能继续推进。`,
@@ -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; 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, 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,7 +227,7 @@ 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\` / \`never_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, 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: \`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.`,

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/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.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;

package/dist/server.js

@@ -42,7 +42,7 @@ exports.startServer = startServer;
  * - Provides `/api/*` endpoints and `/ws` WebSocket communication
  * - CLI bootstrap with optional cwd/port/host/mode parameters
  * - Development mode: `tsx --watch src/server.ts -p <port> --mode dev`
- * - Production mode: `node dist/server.js` (default port 5666)
+ * - Production mode: `node dist/server.js` (default port behavior: 5666-)
  */
 const path = __importStar(require("path"));
 const runtime_1 = require("./apps/runtime");
@@ -54,6 +54,7 @@ const reply_special_1 = require("./recovery/reply-special");
 const work_language_1 = require("./runtime/work-language");
 const auth_1 = require("./server/auth");
 const dominds_self_update_1 = require("./server/dominds-self-update");
+const port_selection_1 = require("./server/port-selection");
 const server_core_1 = require("./server/server-core");
 const websocket_handler_1 = require("./server/websocket-handler");
 require("./tools/builtins");
@@ -87,74 +88,131 @@ function parseArgs(argv) {
             i++;
             continue;
         }
+        if (a.startsWith('--port=')) {
+            out['p'] = a.slice('--port='.length);
+            continue;
+        }
         if (a === '-H' || a === '--host') {
             out['H'] = argv[i + 1];
             i++;
             continue;
         }
+        if (a.startsWith('--host=')) {
+            out['H'] = a.slice('--host='.length);
+            continue;
+        }
         if (a === '--mode') {
             out['mode'] = argv[i + 1];
             i++;
             continue;
         }
+        if (a.startsWith('--mode=')) {
+            out['mode'] = a.slice('--mode='.length);
+            continue;
+        }
     }
     return out;
 }
+function getErrnoCode(error) {
+    if (!(error instanceof Error))
+        return undefined;
+    const withCode = error;
+    return typeof withCode.code === 'string' ? withCode.code : undefined;
+}
 async function startServer(opts = {}) {
     const { language: resolvedLanguage, source } = (0, work_language_1.resolveWorkLanguage)({ env: process.env });
     (0, work_language_1.setWorkLanguage)(resolvedLanguage);
     // Get port and host from options
     const mode = opts.mode || 'prod';
-    const port = opts.port ?? 5666;
+    const preferredPort = opts.port ?? port_selection_1.DEFAULT_WEBUI_PORT;
+    const strictPort = opts.strictPort ?? opts.port !== undefined;
+    const portAutoDirection = opts.portAutoDirection ?? 'down';
     const host = opts.host || '127.0.0.1';
     const startBackendDriver = opts.startBackendDriver ?? true;
-    log.info(`Starting server in ${mode} mode on ${host}:${port} (working language: ${(0, work_language_1.getWorkLanguage)()} from ${source})`);
+    const portCandidates = (0, port_selection_1.buildWebuiPortCandidates)({
+        preferredPort,
+        strictPort,
+        direction: portAutoDirection,
+    });
+    log.info(`Starting server in ${mode} mode on ${host}:${preferredPort} (${strictPort ? 'strict port' : `auto port ${portAutoDirection}`}; working language: ${(0, work_language_1.getWorkLanguage)()} from ${source})`);
     // WebSocket clients set
     const clients = new Set();
-    // Create server configuration
-    const config = {
-        mode: mode === 'dev' ? 'development' : 'production',
-        staticRoot: 'webapp/dist',
-        host,
-        port,
-        clients,
-        auth: (0, auth_1.computeAuthConfig)({
-            mode: mode === 'dev' ? 'development' : 'production',
-            env: process.env,
-        }),
-    };
-    const auth = config.auth ?? { kind: 'disabled' };
-    // Create HTTP server
-    const httpServer = (0, server_core_1.createHttpServer)(config);
-    (0, dominds_self_update_1.configureDomindsSelfUpdate)({
-        host,
-        port,
-        mode: config.mode,
-        stopServer: async () => {
-            await httpServer.stop();
-        },
+    const serverMode = mode === 'dev' ? 'development' : 'production';
+    const auth = (0, auth_1.computeAuthConfig)({
+        mode: serverMode,
+        env: process.env,
     });
-    // Setup WebSocket server
-    (0, websocket_handler_1.setupWebSocketServer)(httpServer.getHttpServer(), clients, config.auth ?? { kind: 'disabled' }, (0, work_language_1.getWorkLanguage)(), config.mode);
-    // MCP is best-effort: startup must not be blocked by MCP config/server issues.
-    (0, supervisor_1.startMcpSupervisor)();
-    // Apps host is optional for server boot: app failures must stay loud, but they must not block WebUI startup.
+    let startedCore = null;
+    let boundPort = null;
+    for (const candidatePort of portCandidates) {
+        const config = {
+            mode: serverMode,
+            staticRoot: 'webapp/dist',
+            host,
+            port: candidatePort,
+            clients,
+            auth,
+        };
+        const candidateServer = (0, server_core_1.createHttpServer)(config);
+        try {
+            boundPort = await candidateServer.start();
+            (0, websocket_handler_1.setupWebSocketServer)(candidateServer.getHttpServer(), clients, auth, (0, work_language_1.getWorkLanguage)(), config.mode);
+            startedCore = candidateServer;
+            break;
+        }
+        catch (error) {
+            if (!strictPort && getErrnoCode(error) === 'EADDRINUSE') {
+                const nextDirection = portAutoDirection === 'down' ? 'lower' : 'higher';
+                log.warn(`WebUI port ${candidatePort} is already in use; trying the next ${nextDirection} port`);
+                continue;
+            }
+            if (boundPort !== null && startedCore === null) {
+                await candidateServer.stop();
+            }
+            throw error;
+        }
+    }
+    if (startedCore === null || boundPort === null) {
+        const boundText = (0, port_selection_1.formatWebuiPortScanBound)({
+            preferredPort,
+            direction: portAutoDirection,
+        });
+        throw new Error(`Failed to start WebUI: no available port found from ${preferredPort} ${boundText}`);
+    }
+    if (!strictPort && boundPort !== preferredPort) {
+        log.warn(`WebUI preferred port ${preferredPort} was unavailable; listening on ${boundPort}`);
+    }
     try {
-        await (0, runtime_1.initAppsRuntime)({ rtwsRootAbs: process.cwd(), kernel: { host, port } });
+        (0, dominds_self_update_1.configureDomindsSelfUpdate)({
+            host,
+            port: boundPort,
+            mode: serverMode,
+            stopServer: async () => {
+                await startedCore.stop();
+            },
+        });
+        // MCP is best-effort: startup must not be blocked by MCP config/server issues.
+        (0, supervisor_1.startMcpSupervisor)();
+        // Apps host is optional for server boot: app failures must stay loud, but they must not block WebUI startup.
+        try {
+            await (0, runtime_1.initAppsRuntime)({ rtwsRootAbs: process.cwd(), kernel: { host, port: boundPort } });
+        }
+        catch (error) {
+            log.warn('Apps runtime initialization failed during server startup; continuing without app runtime capabilities until the app issue is fixed', error instanceof Error ? error : new Error(String(error)));
+        }
+        // Crash recovery: any dialogs left in "proceeding" state are surfaced as interrupted/resumable.
+        await (0, dialog_display_state_1.reconcileDisplayStatesAfterRestart)();
+        await (0, reply_special_1.recoverPendingReplyTellaskCallsAfterRestart)();
+        // Tests may opt out so the process can shut down cleanly without a driver stop API.
+        if (startBackendDriver) {
+            void (0, kernel_driver_1.runBackendDriver)();
+        }
     }
     catch (error) {
-        log.warn('Apps runtime initialization failed during server startup; continuing without app runtime capabilities until the app issue is fixed', error instanceof Error ? error : new Error(String(error)));
+        await startedCore.stop();
+        throw error;
     }
-    // Crash recovery: any dialogs left in "proceeding" state are surfaced as interrupted/resumable.
-    await (0, dialog_display_state_1.reconcileDisplayStatesAfterRestart)();
-    await (0, reply_special_1.recoverPendingReplyTellaskCallsAfterRestart)();
-    // Tests may opt out so the process can shut down cleanly without a driver stop API.
-    if (startBackendDriver) {
-        void (0, kernel_driver_1.runBackendDriver)();
-    }
-    // Start listening
-    await httpServer.start();
-    return { httpServer, auth, host, port, mode };
+    return { httpServer: startedCore, auth, host, port: boundPort, mode };
 }
 // Main function for CLI execution
 async function main() {
@@ -172,10 +230,17 @@ async function main() {
         }
     }
     // Get port, host, and mode from CLI args
-    const port = cliArgs['p'] ? Number(cliArgs['p']) : undefined;
+    const portSpecRaw = cliArgs['p'];
+    const parsedPort = typeof portSpecRaw === 'string' ? (0, port_selection_1.parseWebuiPortSpec)(portSpecRaw) : undefined;
+    if (portSpecRaw !== undefined && parsedPort === null) {
+        throw new Error('Invalid --port value: expected a port number, optionally suffixed with + or -');
+    }
+    const port = parsedPort?.port;
+    const strictPort = parsedPort?.strictPort;
+    const portAutoDirection = parsedPort?.portAutoDirection;
     const host = cliArgs['H'] || undefined;
     const mode = cliArgs['mode'] || undefined;
-    await startServer({ port, host, mode });
+    await startServer({ port, host, mode, strictPort, portAutoDirection });
 }
 // Start server if this file is run directly
 if (require.main === module) {

package/dist/team.d.ts

@@ -152,9 +152,8 @@ export declare namespace Team {
         setStreaming(streaming: boolean | undefined): void;
         setHidden(hidden: boolean | undefined): void;
         /**
-         * Returns a flat list of Tool objects by resolving toolsets and merging with individual tools.
-         * Honors declaration order of toolsets and tools. Logs warnings for duplicate tool names
-         * that resolve to different Tool objects. Returns no duplicate tools per name.
+         * Returns a flat list of assignable toolset names after expanding wildcards and exclusions.
+         * Honors declaration order and returns each toolset at most once.
          */
         listResolvedToolsetNames(options?: {
             onMissing?: 'warn' | 'silent';