dominds 1.28.0 → 1.29.0

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

@@ -139,39 +139,39 @@ function getMemoryPromptCopy(ctx) {
     const contextHealthLineZh = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
             ? 'Dominds 已提醒上下文告急：立即停止继续大实现/大阅读。你当前处于支线对话；本程不维护差遣牒，也不整理差遣牒更新提案，只维护足够详尽的当前对话范围（scope=dialog）接续包提醒项并写明本路任务目标，然后 `clear_mind`。提醒项没有固定长度限制。'
-            : 'Dominds 已提醒上下文告急：立即停止继续大实现/大阅读。本程只做保信息：先用当前对话范围（scope=dialog）接续包提醒项写明本路任务目标，再把确需共享给同一差遣牒其它对话的讨论事实落到差遣牒合适章节，最后提炼恢复本路对话容易丢的接续包提醒项并 `clear_mind`。'
+            : 'Dominds 已提醒上下文告急：立即停止继续大实现/大阅读。本程只做保信息：先按固定“本路主线目标”提醒处理目标；它要求先问人类就立即问，并用 `set_dialog_goal` 记录答案。再把确需共享给同一差遣牒其它对话的讨论事实落到差遣牒合适章节，最后提炼恢复本路对话容易丢的接续包提醒项并 `clear_mind`。'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
                 ? 'Dominds 已提醒上下文吃紧：不要继续扩张上下文。你当前处于支线对话；本程不维护差遣牒，也不整理差遣牒更新提案，优先维护足够详尽的当前对话范围（scope=dialog）接续包提醒项并写明本路任务目标，然后尽快 `clear_mind`。提醒项没有固定长度限制。'
-                : 'Dominds 已提醒上下文吃紧：不要继续扩张上下文。本程优先用当前对话范围（scope=dialog）接续包提醒项写明本路任务目标，再把确需共享给同一差遣牒其它对话的讨论事实落到差遣牒合适章节，最后提炼恢复本路对话容易丢的提醒项并尽快 `clear_mind`，不要继续大实现/大阅读。'
+                : 'Dominds 已提醒上下文吃紧：不要继续扩张上下文。本程先按固定“本路主线目标”提醒处理目标；它要求先问人类就立即问，并用 `set_dialog_goal` 记录答案。再把确需共享给同一差遣牒其它对话的讨论事实落到差遣牒合适章节，最后提炼恢复本路对话容易丢的提醒项并尽快 `clear_mind`，不要继续大实现/大阅读。'
             : '当前没有生效中的上下文保全提示，按正常工作流推进。';
     const taskdocLogLineZh = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
             ? 'Dominds 已提醒上下文告急：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前这一路支线对话的任务目标、讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入当前对话范围（scope=dialog）接续包提醒项。提醒项没有固定长度限制，宁可完整一些；允许多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。Dominds 真正开启新一程后，第一步按 scope=dialog 提醒项里的本路任务目标继续，再复核整理：删除冗余、纠正偏激/失真思路，收敛成高质量提醒项。'
-            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。Dominds 已提醒上下文告急：先确保当前对话范围（scope=dialog）接续包提醒项写明本路任务目标；再检查当前对话历史里尚未落文档的讨论细节，只有确需同一差遣牒其它对话/队友共享的状态/决策/约束/目标，主线才优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并并先调用 `recall_taskdoc` 取得当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复本路对话容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。Dominds 真正开启新一程后，第一步按 scope=dialog 提醒项里的本路任务目标继续，再复核整理：删除冗余、纠正偏激/失真思路，收敛成高质量提醒项。'
+            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。Dominds 已提醒上下文告急：先完整读取固定“本路主线目标”提醒；它要求先问人类就立即问，并用 `set_dialog_goal` 记录答案；它写“依差遣牒推进”但同时提示已有并行对话，也先问人类；只有没有并行确认提示时才按差遣牒继续；已有具体目标就按目标继续。再检查当前对话历史里尚未落文档的讨论细节，只有确需同一差遣牒其它对话/队友共享的状态/决策/约束/目标，主线才优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并并先调用 `recall_taskdoc` 取得当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复本路对话容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。Dominds 真正开启新一程后，第一步按固定“本路主线目标”提醒继续，再复核整理：删除冗余、纠正偏激/失真思路，收敛成高质量提醒项。'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
                 ? 'Dominds 已提醒上下文吃紧：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前这一路支线对话的任务目标、讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入当前对话范围（scope=dialog）接续包提醒项。提醒项没有固定长度限制，宁可完整一些；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。Dominds 真正开启新一程后，第一步按 scope=dialog 提醒项里的本路任务目标继续，再复核整理：删除冗余、纠正偏激/失真思路，收敛成高质量提醒项。'
-                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。Dominds 已提醒上下文吃紧：先确保当前对话范围（scope=dialog）接续包提醒项写明本路任务目标；再检查当前对话历史里尚未落文档的讨论细节，只有确需同一差遣牒其它对话/队友共享的状态/决策/约束/目标，主线才优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并并先调用 `recall_taskdoc` 取得当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复本路对话容易丢的细节；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。Dominds 真正开启新一程后，第一步按 scope=dialog 提醒项里的本路任务目标继续，再复核整理：删除冗余、纠正偏激/失真思路，收敛成高质量提醒项。'
-            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步；提醒项也只留可扫读摘录。准备 `clear_mind` 的接续包提醒项必须是当前对话范围（scope=dialog），写明本路任务目标，并保持结构化、便于快速恢复。';
+                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。Dominds 已提醒上下文吃紧：先完整读取固定“本路主线目标”提醒；它要求先问人类就立即问，并用 `set_dialog_goal` 记录答案；它写“依差遣牒推进”但同时提示已有并行对话，也先问人类；只有没有并行确认提示时才按差遣牒继续；已有具体目标就按目标继续。再检查当前对话历史里尚未落文档的讨论细节，只有确需同一差遣牒其它对话/队友共享的状态/决策/约束/目标，主线才优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并并先调用 `recall_taskdoc` 取得当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复本路对话容易丢的细节；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。Dominds 真正开启新一程后，第一步按固定“本路主线目标”提醒继续，再复核整理：删除冗余、纠正偏激/失真思路，收敛成高质量提醒项。'
+            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步；提醒项也只留可扫读摘录。主线目标看固定“本路主线目标”提醒，并用 `set_dialog_goal` 修改；准备 `clear_mind` 的普通接续包提醒项只写下一步、关键定位、运行/验证方式和容易丢的临时细节，并保持结构化、便于快速恢复。';
     const contextHealthLineEn = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
             ? 'Dominds has warned that context is critical: stop large implementations/reads immediately. You are in a Side Dialog; in this course, do not maintain Taskdoc and do not draft Taskdoc update proposals. Only maintain sufficiently detailed current-dialog scoped (scope=dialog) continuation-package reminders, state this dialog task goal, then `clear_mind`. Reminders have no fixed length limit.'
-            : 'Dominds has warned that context is critical: stop large implementations/reads immediately. In this course, only preserve information: first state this dialog task goal in a current-dialog scoped (scope=dialog) continuation-package reminder, then record only discussion facts that other dialogs/teammates sharing the same Taskdoc truly need to know, then distill details easy to lose when resuming this dialog into continuation-package reminders and `clear_mind`.'
+            : 'Dominds has warned that context is critical: stop large implementations/reads immediately. In this course, only preserve information: first follow the fixed Main Dialog goal reminder; if it says to ask the human, ask and record the answer with `set_dialog_goal`. Then record only discussion facts that other dialogs/teammates sharing the same Taskdoc truly need to know, then distill details easy to lose when resuming this dialog into continuation-package reminders and `clear_mind`.'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
                 ? 'Dominds has warned that context is tight: do not keep expanding context. You are in a Side Dialog; in this course, do not maintain Taskdoc and do not draft Taskdoc update proposals. Prioritize sufficiently detailed current-dialog scoped (scope=dialog) continuation-package reminders, state this dialog task goal, then `clear_mind`. Reminders have no fixed length limit.'
-                : 'Dominds has warned that context is tight: do not keep expanding context. In this course, first state this dialog task goal in a current-dialog scoped (scope=dialog) continuation-package reminder, then record only discussion facts that other dialogs/teammates sharing the same Taskdoc truly need to know, then distill details easy to lose when resuming this dialog into reminders and `clear_mind`; do not continue large implementations/reads.'
+                : 'Dominds has warned that context is tight: do not keep expanding context. In this course, first follow the fixed Main Dialog goal reminder; if it says to ask the human, ask and record the answer with `set_dialog_goal`. Then record only discussion facts that other dialogs/teammates sharing the same Taskdoc truly need to know, then distill details easy to lose when resuming this dialog into reminders and `clear_mind`; do not continue large implementations/reads.'
             : 'There is no active context-preservation notice in effect right now; proceed with the normal workflow.';
     const taskdocLogLineEn = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
             ? 'Dominds has warned that context is critical: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put this specific Side Dialog task goal, discussion details, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into current-dialog scoped (scope=dialog) continuation-package reminders. Reminders have no fixed length 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 Dominds actually starts the new course, first continue from the task goal in scope=dialog reminders, then review/rewrite them: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.'
-            : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Dominds has warned that context is critical: first make sure a current-dialog scoped (scope=dialog) continuation-package reminder states this dialog task goal. Then review current-dialog discussion details not yet written into documentation; only if they truly need to be shared with other dialogs/teammates on the same Taskdoc, 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 when resuming this dialog. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once Dominds actually starts the new course, first continue from the task goal in scope=dialog reminders, then review/rewrite them: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.'
+            : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Dominds has warned that context is critical: first read the full fixed Main Dialog goal reminder. If it says to ask the human, ask and record the answer with `set_dialog_goal`; if it says "proceed from the Taskdoc" but also says there is a parallel dialog, ask the human first; only proceed from the Taskdoc when there is no parallel-dialog note; if it already has a concrete goal, follow that goal. Then review current-dialog discussion details not yet written into documentation; only if they truly need to be shared with other dialogs/teammates on the same Taskdoc, 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 when resuming this dialog. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once Dominds actually starts the new course, first continue from the fixed Main Dialog goal reminder, then review/rewrite bridge reminders: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
                 ? 'Dominds has warned that context is tight: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put this specific Side Dialog task goal, discussion details, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into current-dialog scoped (scope=dialog) continuation-package reminders. Reminders have no fixed length 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 Dominds actually starts the new course, first continue from the task goal in scope=dialog reminders, then review/rewrite them: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.'
-                : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Dominds has warned that context is tight: first make sure a current-dialog scoped (scope=dialog) continuation-package reminder states this dialog task goal. Then review current-dialog discussion details not yet written into documentation; only if they truly need to be shared with other dialogs/teammates on the same Taskdoc, 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 when resuming this dialog. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once Dominds actually starts the new course, first continue from the task goal in scope=dialog reminders, then review/rewrite them: remove redundancy, correct biased or distorted bridge notes, and 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. Continuation-package reminders before `clear_mind` must be current-dialog scoped (scope=dialog), state this dialog task goal, and stay structured for fast resume.';
+                : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Dominds has warned that context is tight: first read the full fixed Main Dialog goal reminder. If it says to ask the human, ask and record the answer with `set_dialog_goal`; if it says "proceed from the Taskdoc" but also says there is a parallel dialog, ask the human first; only proceed from the Taskdoc when there is no parallel-dialog note; if it already has a concrete goal, follow that goal. Then review current-dialog discussion details not yet written into documentation; only if they truly need to be shared with other dialogs/teammates on the same Taskdoc, 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 when resuming this dialog. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once Dominds actually starts the new course, first continue from the fixed Main Dialog goal reminder, then review/rewrite bridge reminders: remove redundancy, correct biased or distorted bridge notes, and 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. Main Dialog goals come from the fixed goal reminder and are changed with `set_dialog_goal`; ordinary continuation-package reminders before `clear_mind` keep next steps, key pointers, run/verify notes, and volatile details for fast resume.';
     if (ctx.language === 'zh') {
         return {
             title: '### 记忆系统（重要）',
@@ -189,7 +189,7 @@ function getMemoryPromptCopy(ctx) {
             constraintsLine: '- 约定：`constraints` 只写任务特有的硬要求，不得写入系统提示/工具文档里已明确且由系统强制执行的通用规则（例如 `*.tsk/` 封装禁止通用文件工具）。一经发现重复，必须删除并告知用户。',
             remindersLine: ctx.isSideDialog
                 ? '- 提醒项（以 `reminder_id` 标识，手头工作）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。准备 `clear_mind` 开启新一程对话时，整理当前对话范围（scope=dialog）的“结构化接续包提醒项”，必须写明本路任务目标，并保留恢复工作容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。若 Dominds 已提醒当前程吃紧/告急，支线对话不要维护差遣牒，也不要整理差遣牒更新提案；只维护足够详尽的 scope=dialog 接续包提醒项，提醒项没有固定长度限制，允许先保留多条粗略提醒项把信息带过桥；当前程只做保信息 + clear_mind；只有 Dominds 实际开启新一程后，第一步才是按 scope=dialog 提醒项里的本路任务目标继续，再复核整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。'
-                : '- 提醒项（以 `reminder_id` 标识，手头工作）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。准备 `clear_mind` 开启新一程对话时，先用当前对话范围（scope=dialog）结构化接续包提醒项写明本路任务目标，再把尚未落实到文档、且下一程需要同一差遣牒其它对话/队友知会的讨论细节落到差遣牒合适章节；提醒项只保留差遣牒仍未覆盖、但恢复本路对话容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。若 Dominds 已提醒当前程吃紧/告急，则允许先保留多条粗略 scope=dialog 提醒项把信息带过桥；当前程只做落文档、保信息 + clear_mind；只有 Dominds 实际开启新一程后，第一步才是按 scope=dialog 提醒项里的本路任务目标继续，再复核整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。',
+                : '- 提醒项（以 `reminder_id` 标识，手头工作）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。主线目标看固定“本路主线目标”提醒，并用 `set_dialog_goal` 修改；普通 `dialog` 接续包只保留差遣牒仍未覆盖、但恢复本路对话容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。准备 `clear_mind` 开启新一程对话时，先按固定主线目标提醒处理目标，再把尚未落实到文档、且下一程需要同一差遣牒其它对话/队友知会的讨论细节落到差遣牒合适章节。若 Dominds 已提醒当前程吃紧/告急，则允许先保留多条粗略 scope=dialog 提醒项把信息带过桥；当前程只做落文档、保信息 + clear_mind；只有 Dominds 实际开启新一程后，第一步才是按固定“本路主线目标”提醒继续，再复核整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。',
             teamMemoryLine: '- 团队记忆：稳定的团队约定/工程规约（跨任务共享）。',
             personalMemoryLine: '- 个人记忆：稳定的个人习惯/偏好与职责域知识；记忆会在每次生成时自动注入上下文，应保持少量且准确（关键文档/代码的精确路径 + 最小必要事实）。不要记录具体任务状态。',
             skillsLine: '- Skills：可复用操作指引/检查清单/触发条件与边界。工作区关联强的事实、路径、局部契约进 memory/env；独立于工作区内容的“怎么做”进 skill。skill 不授予工具权限；需要脚本/MCP/外部能力时应配套 app/toolset/权限配置。',
@@ -203,7 +203,7 @@ function getMemoryPromptCopy(ctx) {
             sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'
                 ? `工作流：先做事 → 再提炼（\`update_reminder\`；必要时整理差遣牒追加条目/更新提案并诉请 \`@${ctx.taskdocMaintainerId}\` 合并写入）→ 然后 \`clear_mind\` 清空噪音。`
                 : '工作流：停止扩张上下文 → 维护足够详尽的当前对话范围（scope=dialog）接续包提醒项（`add_reminder` 或 `update_reminder`，必须写明本路任务目标，没有固定长度限制）→ 然后 `clear_mind` 开启新一程。',
-            mainDialogWorkflowLine: '工作流：先做事 -> 再提炼（`update_reminder` + `mind_more(progress)`；需要压缩/删旧时先 `recall_taskdoc` 取得 `content_hash`，再用带 `previous_content_hash` 的 `change_mind`；要删除整章文件时用 `never_mind`）-> 然后 `clear_mind` 清空噪音。',
+            mainDialogWorkflowLine: '工作流：先按固定“本路主线目标”提醒推进（需要时用 `set_dialog_goal` 记录人类确认的目标）-> 再提炼（`update_reminder` + `mind_more(progress)`；需要压缩/删旧时先 `recall_taskdoc` 取得 `content_hash`，再用带 `previous_content_hash` 的 `change_mind`；要删除整章文件时用 `never_mind`）-> 然后 `clear_mind` 清空噪音。',
             ...(ctx.isSideDialog
                 ? {}
                 : {
@@ -229,7 +229,7 @@ function getMemoryPromptCopy(ctx) {
         constraintsLine: '- Convention: Taskdoc `constraints` must contain task-specific requirements only; do not include global, system-enforced rules already stated in system prompt/tool docs (e.g. `.tsk/` encapsulation bans general file tools). If duplication is found, you MUST remove it and notify the user.',
         remindersLine: ctx.isSideDialog
             ? '- Reminders (addressed by `reminder_id`, current work): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. When preparing `clear_mind` to start a new course, create a current-dialog scoped (scope=dialog) structured continuation-package reminder, state this dialog task goal, and preserve details easy to lose during resume (first step, key pointers, run/verify info, volatile ids/paths). If Dominds has warned that the current course is tight/critical, you are in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals; only maintain sufficiently detailed scope=dialog continuation-package reminders. Reminders have no fixed length limit, rough multi-reminder bridge notes are acceptable, and in the current course you should only preserve volatile information and clear_mind. Only after Dominds actually starts the new course does the mandatory first step become continuing this dialog from the task goal in scope=dialog reminders, then reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.'
-            : '- Reminders (addressed by `reminder_id`, current work): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. When preparing `clear_mind` to start a new course, first state this dialog task goal in a current-dialog scoped (scope=dialog) structured continuation-package reminder, then record undocumented discussion details that other dialogs/teammates sharing the same Taskdoc truly need to know into the appropriate Taskdoc sections. Reminders should keep only details still not covered by Taskdoc but easy to lose when resuming this dialog (first step, key pointers, run/verify info, volatile ids/paths). If Dominds has warned that the current course is tight/critical, rough multi-reminder scope=dialog bridge notes are acceptable; in the current course, only document missing details, preserve volatile information, and clear_mind. Only after Dominds actually starts the new course does the mandatory first step become continuing this dialog from the task goal in scope=dialog reminders, then reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.',
+            : '- Reminders (addressed by `reminder_id`, current work): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. Main Dialog goals come from the fixed goal reminder and are changed with `set_dialog_goal`; ordinary `dialog` continuation packages keep only details still not covered by Taskdoc but easy to lose when resuming this dialog (first step, key pointers, run/verify info, volatile ids/paths). When preparing `clear_mind` to start a new course, first follow the fixed goal reminder, then record undocumented discussion details that other dialogs/teammates sharing the same Taskdoc truly need to know into the appropriate Taskdoc sections. If Dominds has warned that the current course is tight/critical, rough multi-reminder scope=dialog bridge notes are acceptable; in the current course, only document missing details, preserve volatile information, and clear_mind. Only after Dominds actually starts the new course does the mandatory first step become continuing this dialog from the fixed Main Dialog goal reminder, then reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.',
         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.',
         skillsLine: '- Skills: reusable operating guidance, checklists, triggers, and boundaries. Workspace-coupled facts, paths, and local contracts belong in memory/env; workspace-independent “how to do it” procedures belong in skills. Skills do not grant tool permissions; pair scripts/MCP/external capabilities with apps/toolsets/permission configuration.',
@@ -243,7 +243,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 current-dialog scoped (scope=dialog) continuation-package reminders (`add_reminder` or `update_reminder`, must state this dialog task goal, with no fixed length limit) → then `clear_mind` to start a new course.',
-        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.',
+        mainDialogWorkflowLine: 'Workflow: follow the fixed Main Dialog goal reminder first (use `set_dialog_goal` when a human-confirmed goal must be recorded) -> 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.',
         ...(ctx.isSideDialog
             ? {}
             : {

package/dist/runtime/driver-messages.js

@@ -135,18 +135,18 @@ function formatNewCourseStartPrompt(language, args) {
             : `Dominds 因上下文已告急而自动开启了第 ${args.nextCourse} 程对话。`;
         return (`${noticePrefix} ${prefix} ` +
             '这是 Dominds 的换程提示，不是新的用户诉求；不要把这条提示当成新的待办，也不要只回复“收到/好的/我会先整理提醒项”。' +
-            '现在已经进入新一程：如果见到上一程的上下文吃紧/告急状况记录，此时既已消除。第一步先读取当前对话范围（scope=dialog）的接续包提醒项，尤其是其中写明的当前对话任务目标，并按这个目标恢复当前这一路主线对话/支线对话，不要仅凭同一差遣牒里的其它主线或支线内容改道。' +
+            '现在已经进入新一程：如果见到上一程的上下文吃紧/告急状况记录，此时既已消除。第一步先看固定“本路主线目标”提醒（若当前是主线），或读取当前对话范围（scope=dialog）的支线接续包提醒项（若当前是支线），按其中写明的目标恢复当前这一路对话，不要仅凭同一差遣牒里的其它主线或支线内容改道。' +
             '随后复核并在必要时整理接续包提醒项，以清醒头脑删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项；若提醒项已经足够清晰，就不要为了整理而整理。' +
-            '完成这一步后，直接按照当前对话范围提醒项里的任务目标继续推进；除非任务自然需要对用户交付结果，否则不要为这条提示单独回复。');
+            '完成这一步后，直接按照固定主线目标提醒或支线接续包提醒项里的目标继续推进；除非任务自然需要对用户交付结果，否则不要为这条提示单独回复。');
     }
     const prefix = args.source === 'clear_mind'
         ? `This is dialog course #${args.nextCourse}. You just cleared your mind.`
         : `Dominds auto-started dialog course #${args.nextCourse} because context was critical.`;
     return (`${noticePrefix} ${prefix} ` +
         'This is a Dominds course-transition notice, not a new user request; do not treat it as a new to-do, and do not reply with a standalone "acknowledged/ok/I will reorganize the reminders first". ' +
-        'You are now in a new course: if you see records that the previous course was context-tight or context-critical, that condition is now resolved. First read the current-dialog scoped (scope=dialog) continuation-package reminders, especially the current dialog task goal written there, and resume this specific Main Dialog or Side Dialog from that goal instead of drifting into other Main/Side Dialog work that shares the same Taskdoc. ' +
+        'You are now in a new course: if you see records that the previous course was context-tight or context-critical, that condition is now resolved. First read the fixed Main Dialog goal reminder when this is a Main Dialog, or the current-dialog scoped (scope=dialog) Side Dialog continuation-package reminders when this is a Side Dialog, and resume this specific dialog from that goal instead of drifting into other Main/Side Dialog work that shares the same Taskdoc. ' +
         'Then review and, if needed, rewrite any continuation-package reminders with a clear head, remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders; if the reminders are already clear enough, do not churn on them. ' +
-        'After that, continue directly from the task goal in the current-dialog scoped reminders; unless the task naturally calls for a user-facing delivery, do not send a standalone reply just for this notice.');
+        'After that, continue directly from the fixed Main Dialog goal reminder or the Side Dialog continuation-package goal; unless the task naturally calls for a user-facing delivery, do not send a standalone reply just for this notice.');
 }
 function formatDiligenceAutoContinuePrompt(language, diligenceText) {
     const noticePrefix = formatSystemNoticePrefix(language);
@@ -817,12 +817,12 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
                 '',
                 '影响：对话历史中的工具调用/结果信息很多已经过时，成为你的思考负担。',
                 '',
-                '行动：你当前处于主线对话。先新增或更新当前对话范围（scope=dialog）接续包提醒项，并把当前这一路主线对话的任务目标写清楚。然后只把确实需要同一差遣牒下其它对话/队友知会的讨论事实落到差遣牒合适章节；再把差遣牒仍未覆盖、但恢复本路对话会丢的信息记进 scope=dialog 新提醒项过桥（任务目标 + 下一步行动 + 关键定位信息 + 运行/验证信息 + 容易丢的临时细节）；允许先带着一定冗余，也允许先写成多条粗略提醒项，不必在当前程强行压成单条。',
+                '行动：你当前处于主线对话。先完整读取固定“本路主线目标”提醒：它要求先问人类就立即问，并用 set_dialog_goal 记录答案；它写“依差遣牒推进”但同时提示已有并行对话，也先问人类；只有没有并行确认提示时才按差遣牒继续；已有具体目标就按目标继续。然后只把确实需要同一差遣牒下其它对话/队友知会的讨论事实落到差遣牒合适章节；再把差遣牒仍未覆盖、但恢复本路对话会丢的信息记进 scope=dialog 新提醒项过桥（下一步行动 + 关键定位信息 + 运行/验证信息 + 容易丢的临时细节）；允许先带着一定冗余，也允许先写成多条粗略提醒项，不必在当前程强行压成单条。',
                 '',
-                'Dominds 已提醒当前上下文吃紧：不要继续扩张上下文，也不要提前进入“按接续包做清醒复核”的模式；那是 Dominds 真正开启新一程后的第一步。当前程的目标是先用 scope=dialog 提醒项保住本路对话目标，再把需要共享的事实补进差遣牒，最后把差遣牒仍未覆盖、但恢复本路对话会丢的信息带过桥；真正清理冗余、合并提醒项，放到新一程再做。然后主动 clear_mind，开启新一程对话继续工作。',
+                'Dominds 已提醒当前上下文吃紧：不要继续扩张上下文，也不要提前进入“按接续包做清醒复核”的模式；那是 Dominds 真正开启新一程后的第一步。当前程的目标是先按固定“本路主线目标”提醒处理目标，再把需要共享的事实补进差遣牒，最后把差遣牒仍未覆盖、但恢复本路对话会丢的信息带过桥；真正清理冗余、合并提醒项，放到新一程再做。然后主动 clear_mind，开启新一程对话继续工作。',
                 '',
                 '操作：',
-                '- 必须确保当前对话范围提醒项写明本路任务目标：add_reminder({ "content": "...", "scope": "dialog" }) 或 update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
+                '- 若固定“本路主线目标”提醒要求先问人类：问清后调用 set_dialog_goal({ "mode": "goal", "goal": "..." })',
                 '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
                 '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并时，才先调用 recall_taskdoc({"selector":"<selector>"}) 取得 content_hash，再更新：change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})',
                 '- 优先新增当前对话 scope=dialog 过桥提醒项：add_reminder({ "content": "...", "scope": "dialog" })',
@@ -858,17 +858,17 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '',
             `Dominds 最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
             '',
-            '行动：你当前处于主线对话。尽快保住易丢信息，然后 clear_mind。Dominds 已提醒当前上下文告急：先新增或更新当前对话范围（scope=dialog）接续包提醒项，并把当前这一路主线对话的任务目标写清楚。然后只把确实需要同一差遣牒下其它对话/队友知会的讨论事实落到差遣牒合适章节；再把差遣牒仍未覆盖、但恢复本路对话会丢的信息新增 scope=dialog 提醒项带过桥；允许先保留多条粗略提醒项，甚至带一定冗余也可以，不必在当前程强行整理干净。',
+            '行动：你当前处于主线对话。尽快保住易丢信息，然后 clear_mind。Dominds 已提醒当前上下文告急：先完整读取固定“本路主线目标”提醒；它要求先问人类就立即问，并用 set_dialog_goal 记录答案；它写“依差遣牒推进”但同时提示已有并行对话，也先问人类；只有没有并行确认提示时才按差遣牒继续；已有具体目标就按目标继续。然后只把确实需要同一差遣牒下其它对话/队友知会的讨论事实落到差遣牒合适章节；再把差遣牒仍未覆盖、但恢复本路对话会丢的信息新增 scope=dialog 提醒项带过桥；允许先保留多条粗略提醒项，甚至带一定冗余也可以，不必在当前程强行整理干净。',
             '',
             '操作：',
-            '- 必须确保当前对话范围提醒项写明本路任务目标：add_reminder({ "content": "...", "scope": "dialog" }) 或 update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
+            '- 若固定“本路主线目标”提醒要求先问人类：问清后调用 set_dialog_goal({ "mode": "goal", "goal": "..." })',
             '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
             '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并时，才先调用 recall_taskdoc({"selector":"<selector>"}) 取得 content_hash，再更新：change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})',
             '- 优先新增当前对话 scope=dialog 过桥提醒项：add_reminder({ "content": "...", "scope": "dialog" })',
             '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
             '- clear_mind({})',
             '',
-            '接续包要点：当前对话任务目标 + 下一步行动 + 关键定位信息 + 运行验证方式 + 容易丢的临时细节；不要重复差遣牒已有内容，本程刚落入差遣牒的讨论细节只需提示下一程先查差遣牒。Dominds 已提醒当前上下文告急：不要提前做“新一程清醒复核”；Dominds 真正开启新一程后，第一步才是按当前对话范围提醒项里的任务目标继续本路对话，并重新审视整理：删除冗余、纠正偏激/失真思路、合并并压缩成高质量提醒项。',
+            '接续包要点：下一步行动 + 关键定位信息 + 运行验证方式 + 容易丢的临时细节；不要重复固定“本路主线目标”提醒和差遣牒已有内容，本程刚落入差遣牒的讨论细节只需提示下一程先查差遣牒。Dominds 已提醒当前上下文告急：不要提前做“新一程清醒复核”；Dominds 真正开启新一程后，第一步才是按固定“本路主线目标”提醒继续本路对话，并重新审视整理：删除冗余、纠正偏激/失真思路、合并并压缩成高质量提醒项。',
         ].join('\n');
     }
     if (args.kind === 'caution' && args.mode === 'soft') {
@@ -900,12 +900,12 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '',
             'Impact: stale call/results in dialog history are creating cognitive noise.',
             '',
-            'Action: you are in the Main Dialog. First add or update a current-dialog scoped (scope=dialog) continuation-package reminder and state this specific Main Dialog task goal clearly. Then record only discussion facts that other dialogs/teammates sharing the same Taskdoc truly need to know into the appropriate Taskdoc sections. After that, write information still not covered by Taskdoc but easy to lose for resuming this dialog into scope=dialog bridge reminders (task goal + next step + key pointers + run/verify info + easy-to-lose volatile details). Some redundancy is acceptable, and rough multi-reminder carry-over is acceptable too; do not force everything into one clean reminder in the current course.',
+            'Action: you are in the Main Dialog. First read the full fixed Main Dialog goal reminder. If it says to ask the human first, ask immediately and record the answer with set_dialog_goal; if it says "proceed from the Taskdoc" but also says there is a parallel dialog, ask the human first; only proceed from the Taskdoc when there is no parallel-dialog note; if it already has a concrete goal, follow that goal. Then record only discussion facts that other dialogs/teammates sharing the same Taskdoc truly need to know into the appropriate Taskdoc sections. After that, write information still not covered by Taskdoc but easy to lose for resuming this dialog into scope=dialog bridge reminders (next step + key pointers + run/verify info + easy-to-lose volatile details). Some redundancy is acceptable, and rough multi-reminder carry-over is acceptable too; do not force everything into one clean reminder in the current course.',
             '',
-            'Dominds has already warned that context is tight 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 Dominds actually starts the new course. In the current course, the goal is to first preserve this dialog goal in a scope=dialog reminder, then fill Taskdoc only with facts that need to be shared, and finally carry forward details still not covered by Taskdoc but needed to resume this dialog; reminder cleanup and dedup belong to the new course. Then proactively clear_mind to start a new dialog course.',
+            'Dominds has already warned that context is tight 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 Dominds actually starts the new course. In the current course, the goal is to follow the fixed Main Dialog goal reminder, then fill Taskdoc only with facts that need to be shared, and finally carry forward details still not covered by Taskdoc but needed to resume this dialog; reminder cleanup and dedup belong to the new course. Then proactively clear_mind to start a new dialog course.',
             '',
             'Operations:',
-            '- Ensure a current-dialog scoped reminder states this dialog task goal: add_reminder({ "content": "...", "scope": "dialog" }) or update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
+            '- If the fixed Main Dialog goal reminder says to ask the human first: ask, then call set_dialog_goal({ "mode": "goal", "goal": "..." })',
             '- 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: first call recall_taskdoc({"selector":"<selector>"}) for content_hash, then change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})',
             '- Prefer adding a current-dialog scope=dialog bridge reminder first: add_reminder({ "content": "...", "scope": "dialog" })',
@@ -941,17 +941,17 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
         '',
         `Dominds will remind you ${args.promptsRemainingAfterThis} more time(s), then automatically clear mind.`,
         '',
-        'Action: you are in the Main Dialog. Preserve easy-to-lose information, then clear_mind. Because Dominds has warned that context is critical, first add or update a current-dialog scoped (scope=dialog) continuation-package reminder and state this specific Main Dialog task goal clearly. Then record only discussion facts that other dialogs/teammates sharing the same Taskdoc truly need to know into the appropriate Taskdoc sections. After that, add scope=dialog bridge reminders for information still not covered by Taskdoc but easy to lose when resuming this dialog. Multiple rough reminders, including some redundancy, are acceptable as a bridge; do not spend the current course forcing them into a clean final package.',
+        'Action: you are in the Main Dialog. Preserve easy-to-lose information, then clear_mind. Because Dominds has warned that context is critical, first read the full fixed Main Dialog goal reminder. If it says to ask the human first, ask immediately and record the answer with set_dialog_goal; if it says "proceed from the Taskdoc" but also says there is a parallel dialog, ask the human first; only proceed from the Taskdoc when there is no parallel-dialog note; if it already has a concrete goal, follow that goal. Then record only discussion facts that other dialogs/teammates sharing the same Taskdoc truly need to know into the appropriate Taskdoc sections. After that, add scope=dialog bridge reminders for information still not covered by Taskdoc but easy to lose when resuming this dialog. 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:',
-        '- Ensure a current-dialog scoped reminder states this dialog task goal: add_reminder({ "content": "...", "scope": "dialog" }) or update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
+        '- If the fixed Main Dialog goal reminder says to ask the human first: ask, then call set_dialog_goal({ "mode": "goal", "goal": "..." })',
         '- 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: first call recall_taskdoc({"selector":"<selector>"}) for content_hash, then change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})',
         '- Prefer adding a current-dialog scope=dialog bridge reminder first: add_reminder({ "content": "...", "scope": "dialog" })',
         '- 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({})',
         '',
-        'Continuation package: current dialog task goal + next step + key pointers + run/verify info + easy-to-lose volatile details. Do not duplicate Taskdoc content; for discussion details just written into Taskdoc in this course, only remind the next course to review Taskdoc first. Because Dominds has warned that context is critical in the current course, do not start the new-course cleanup early; once Dominds actually starts the new course, the first step is to continue this dialog from the task goal in current-dialog scoped reminders and reconcile rough bridge reminders by removing redundancy, correcting biased or distorted bridge notes, and merging/compressing them into high-quality reminders.',
+        'Continuation package: next step + key pointers + run/verify info + easy-to-lose volatile details. Do not duplicate the fixed Main Dialog goal reminder or Taskdoc content; for discussion details just written into Taskdoc in this course, only remind the next course to review Taskdoc first. Because Dominds has warned that context is critical in the current course, do not start the new-course cleanup early; once Dominds actually starts the new course, the first step is to continue this dialog from the fixed Main Dialog goal reminder and reconcile rough bridge reminders by removing redundancy, correcting biased or distorted bridge notes, and merging/compressing them into high-quality reminders.',
     ].join('\n');
 }
 function formatAgentFacingCriticalUserInterjectionRemediationGuide(language, args) {

package/dist/server/setup-routes.js

@@ -357,6 +357,7 @@ function extractProminentModelParams(modelParamOptions) {
     addSection('openai-compatible', modelParamOptions['openai-compatible']);
     addSection('anthropic', modelParamOptions.anthropic);
     addSection('anthropic-compatible', modelParamOptions['anthropic-compatible']);
+    addSection('google', modelParamOptions.google);
     for (const [namespace, section] of sections) {
         for (const [key, optUnknown] of Object.entries(section)) {
             if (!optUnknown || typeof optUnknown !== 'object')
@@ -687,7 +688,8 @@ function parseOptionalTeamModelParams(value) {
             namespace !== 'openai' &&
             namespace !== 'openai-compatible' &&
             namespace !== 'anthropic' &&
-            namespace !== 'anthropic-compatible')
+            namespace !== 'anthropic-compatible' &&
+            namespace !== 'google')
             return null;
         if (!isRecord(nsUnknown))
             return null;

package/dist/team.d.ts

@@ -30,7 +30,7 @@ export declare namespace Team {
         temperature?: number;
         service_tier?: 'auto' | 'default' | 'flex' | 'scale' | 'priority';
         top_p?: number;
-        reasoning_effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+        reasoning_effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'ultra';
         reasoning_summary?: 'auto' | 'concise' | 'detailed' | 'none';
         verbosity?: 'low' | 'medium' | 'high';
         parallel_tool_calls?: boolean;
@@ -41,7 +41,7 @@ export declare namespace Team {
         temperature?: number;
         service_tier?: 'auto' | 'default' | 'flex' | 'scale' | 'priority';
         top_p?: number;
-        reasoning_effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+        reasoning_effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
         reasoning_summary?: 'auto' | 'concise' | 'detailed' | 'none';
         verbosity?: 'low' | 'medium' | 'high';
         parallel_tool_calls?: boolean;
@@ -91,6 +91,13 @@ export declare namespace Team {
     type AnthropicCompatibleModelParams = Omit<AnthropicModelParams, 'thinking'> & {
         thinking?: boolean;
     };
+    export type GoogleModelParams = {
+        thinking?: boolean;
+        thinking_budget?: number;
+        temperature?: number;
+        top_p?: number;
+        google_search_tool?: boolean;
+    };
     export interface ModelParams {
         json_response?: boolean;
         codex?: CodexModelParams;
@@ -98,6 +105,7 @@ export declare namespace Team {
         'openai-compatible'?: OpenAiCompatibleModelParams;
         anthropic?: AnthropicModelParams;
         'anthropic-compatible'?: AnthropicCompatibleModelParams;
+        google?: GoogleModelParams;
     }
     /**
      * Team.Member
@@ -204,7 +212,8 @@ export declare namespace Team {
     export function load(): Promise<Team>;
     export const TEAM_YAML_ROOT_KEYS: readonly ["member_defaults", "default_responder", "shell_specialists", "members"];
     export const TEAM_YAML_MEMBER_KEYS: readonly ["name", "from", "use", "import", "provider", "model", "gofor", "nogo", "toolsets", "tools", "model_params", "fbr-effort", "fbr_effort", "fbr_model_params", "diligence-push-max", "diligence_push_max", "read_dirs", "write_dirs", "no_read_dirs", "no_write_dirs", "read_file_ext_names", "write_file_ext_names", "no_read_file_ext_names", "no_write_file_ext_names", "icon", "streaming", "hidden"];
-    export const TEAM_YAML_MODEL_PARAMS_ROOT_KEYS: readonly ["json_response", "codex", "openai", "openai-compatible", "anthropic", "anthropic-compatible"];
+    export const TEAM_YAML_MODEL_PARAMS_ROOT_KEYS: readonly ["json_response", "codex", "openai", "openai-compatible", "anthropic", "anthropic-compatible", "google"];
+    export const TEAM_YAML_MODEL_PARAMS_GOOGLE_KEYS: readonly ["thinking", "thinking_budget", "temperature", "top_p", "google_search_tool"];
     export const TEAM_YAML_MODEL_PARAMS_OPENAI_KEYS: readonly ["temperature", "service_tier", "top_p", "reasoning_effort", "reasoning_summary", "verbosity", "parallel_tool_calls", "safety_identifier", "text_format", "text_format_json_schema_name", "text_format_json_schema", "text_format_json_schema_strict", "web_search_tool", "web_search_context_size", "web_search_allowed_domains", "web_search_include_sources"];
     export const TEAM_YAML_MODEL_PARAMS_OPENAI_COMPATIBLE_KEYS: readonly ["temperature", "service_tier", "top_p", "parallel_tool_calls", "safety_identifier", "text_format", "text_format_json_schema_name", "text_format_json_schema", "text_format_json_schema_strict", "reasoning_effort", "reasoning_split", "thinking"];
     export const TEAM_YAML_MODEL_PARAMS_CODEX_KEYS: readonly ["temperature", "service_tier", "top_p", "reasoning_effort", "reasoning_summary", "verbosity", "parallel_tool_calls", "web_search", "json_response"];

package/dist/team.js

@@ -1306,6 +1306,14 @@ exports.Team = Team;
         'openai-compatible',
         'anthropic',
         'anthropic-compatible',
+        'google',
+    ];
+    Team.TEAM_YAML_MODEL_PARAMS_GOOGLE_KEYS = [
+        'thinking',
+        'thinking_budget',
+        'temperature',
+        'top_p',
+        'google_search_tool',
     ];
     Team.TEAM_YAML_MODEL_PARAMS_OPENAI_KEYS = [
         'temperature',
@@ -1463,6 +1471,13 @@ exports.Team = Team;
                     pushIssue(`${idPrefix}/${issuePrefix}/anthropic-compatible/unknown_fields`, `Invalid .minds/team.yaml: ${modelParamsAt}.anthropic-compatible contains unknown fields.`, buildUnknownFieldErrorText(`${modelParamsAt}.anthropic-compatible`, unknownAtAnthropicCompatible, {}));
                 }
             }
+            const rawGoogle = rawModelParams.google;
+            if (rawGoogle !== undefined && isRecordValue(rawGoogle)) {
+                const unknownAtGoogle = listUnknownKeys(rawGoogle, Team.TEAM_YAML_MODEL_PARAMS_GOOGLE_KEYS);
+                if (unknownAtGoogle.length > 0) {
+                    pushIssue(`${idPrefix}/${issuePrefix}/google/unknown_fields`, `Invalid .minds/team.yaml: ${modelParamsAt}.google contains unknown fields.`, buildUnknownFieldErrorText(`${modelParamsAt}.google`, unknownAtGoogle, {}));
+                }
+            }
         };
         validateOptionalModelParamsField('model_params', 'model_params');
         validateOptionalModelParamsField('fbr_model_params', 'fbr_model_params');
@@ -2255,8 +2270,10 @@ exports.Team = Team;
                 reasoningEffort !== 'low' &&
                 reasoningEffort !== 'medium' &&
                 reasoningEffort !== 'high' &&
-                reasoningEffort !== 'xhigh') {
-                throw new Error(`Invalid ${at2}.reasoning_effort: expected none|minimal|low|medium|high|xhigh (got ${describeValueType(reasoningEffort)})`);
+                reasoningEffort !== 'xhigh' &&
+                reasoningEffort !== 'max' &&
+                reasoningEffort !== 'ultra') {
+                throw new Error(`Invalid ${at2}.reasoning_effort: expected none|minimal|low|medium|high|xhigh|max|ultra (got ${describeValueType(reasoningEffort)})`);
             }
             const reasoningSummary = params.reasoning_summary;
             if (reasoningSummary !== undefined &&
@@ -2308,8 +2325,9 @@ exports.Team = Team;
                 reasoningEffort !== 'low' &&
                 reasoningEffort !== 'medium' &&
                 reasoningEffort !== 'high' &&
-                reasoningEffort !== 'xhigh') {
-                throw new Error(`Invalid ${at2}.reasoning_effort: expected none|minimal|low|medium|high|xhigh (got ${describeValueType(reasoningEffort)})`);
+                reasoningEffort !== 'xhigh' &&
+                reasoningEffort !== 'max') {
+                throw new Error(`Invalid ${at2}.reasoning_effort: expected none|minimal|low|medium|high|xhigh|max (got ${describeValueType(reasoningEffort)})`);
             }
             const reasoningSummary = params.reasoning_summary;
             if (reasoningSummary !== undefined &&
@@ -2453,6 +2471,7 @@ exports.Team = Team;
         const anthropicCompatible = obj['anthropic-compatible'] === undefined
             ? undefined
             : asRecord(obj['anthropic-compatible'], `${at}.anthropic-compatible`);
+        const google = obj.google === undefined ? undefined : asRecord(obj.google, `${at}.google`);
         if (codex)
             validateCodexParams(codex, `${at}.codex`);
         if (openai)
@@ -2480,6 +2499,13 @@ exports.Team = Team;
             asOptionalBoolean(anthropicCompatible.thinking, `${at}.anthropic-compatible.thinking`);
             asOptionalBoolean(anthropicCompatible.json_response, `${at}.anthropic-compatible.json_response`);
         }
+        if (google) {
+            asOptionalBoolean(google.thinking, `${at}.google.thinking`);
+            asOptionalNumber(google.thinking_budget, `${at}.google.thinking_budget`);
+            asOptionalNumber(google.temperature, `${at}.google.temperature`);
+            asOptionalNumber(google.top_p, `${at}.google.top_p`);
+            asOptionalBoolean(google.google_search_tool, `${at}.google.google_search_tool`);
+        }
         asOptionalBoolean(obj.json_response, `${at}.json_response`);
         const out = {};
         if (obj.json_response !== undefined)
@@ -2513,6 +2539,12 @@ exports.Team = Team;
                     knownAnthropicCompatible;
             }
         }
+        if (google) {
+            const knownGoogle = pickKnownModelParams(google, Team.TEAM_YAML_MODEL_PARAMS_GOOGLE_KEYS);
+            if (Object.keys(knownGoogle).length > 0) {
+                out.google = knownGoogle;
+            }
+        }
         return Object.keys(out).length > 0 ? out : undefined;
     }
 })(Team || (exports.Team = Team = {}));

package/dist/tools/builtins.js

@@ -128,6 +128,7 @@ function manualSpecFor(toolsetId) {
 (0, registry_1.registerTool)(ctrl_1.deleteReminderTool);
 (0, registry_1.registerTool)(ctrl_1.updateReminderTool);
 (0, registry_1.registerTool)(ctrl_1.migrateReminderTool);
+(0, registry_1.registerTool)(ctrl_1.setDialogGoalTool);
 (0, registry_1.registerTool)(ctrl_1.clearMindTool);
 (0, registry_1.registerTool)(ctrl_1.doMindTool);
 (0, registry_1.registerTool)(ctrl_1.changeMindTool);
@@ -201,6 +202,7 @@ for (const tool of team_mgmt_1.teamMgmtTools) {
     ctrl_1.deleteReminderTool,
     ctrl_1.updateReminderTool,
     ctrl_1.migrateReminderTool,
+    ctrl_1.setDialogGoalTool,
     ctrl_1.clearMindTool,
     ctrl_1.doMindTool,
     ctrl_1.changeMindTool,

package/dist/tools/ctrl.d.ts

@@ -34,6 +34,7 @@ export declare const deleteReminderTool: FuncTool;
 export declare const addReminderTool: FuncTool;
 export declare const updateReminderTool: FuncTool;
 export declare const migrateReminderTool: FuncTool;
+export declare const setDialogGoalTool: FuncTool;
 export declare const clearMindTool: FuncTool;
 export declare const changeMindTool: FuncTool;
 export declare const doMindTool: FuncTool;

package/dist/tools/ctrl.js

@@ -64,10 +64,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.recallTaskdocTool = exports.mindMoreTool = exports.neverMindTool = exports.doMindTool = exports.changeMindTool = exports.clearMindTool = exports.migrateReminderTool = exports.updateReminderTool = exports.addReminderTool = exports.deleteReminderTool = void 0;
+exports.recallTaskdocTool = exports.mindMoreTool = exports.neverMindTool = exports.doMindTool = exports.changeMindTool = exports.clearMindTool = exports.setDialogGoalTool = exports.migrateReminderTool = exports.updateReminderTool = exports.addReminderTool = exports.deleteReminderTool = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const dialog_1 = require("../dialog");
+const main_dialog_goal_reminder_1 = require("../main-dialog-goal-reminder");
 const rtws_1 = require("../rtws");
 const driver_messages_1 = require("../runtime/driver-messages");
 const shared_reminder_update_impact_1 = require("../runtime/shared-reminder-update-impact");
@@ -409,6 +410,12 @@ function getCtrlMessages(language) {
             reminderContentEmpty: '提醒内容不能为空',
             invalidFormatUpdate: '参数格式不对。用法：update_reminder({ reminder_id: string, content: string })',
             invalidFormatMigrate: '参数格式不对。用法：migrate_reminder({ reminder_id: string, scope: "dialog" })',
+            invalidFormatSetDialogGoal: '参数格式不对。用法：set_dialog_goal({ mode: "goal", goal: string }) 或 set_dialog_goal({ mode: "follow_taskdoc" })',
+            setDialogGoalMainOnly: '错误：set_dialog_goal 只用于主线对话；支线对话按收到的诉请目标推进。',
+            setDialogGoalGoalRequired: '错误：mode="goal" 时必须提供非空 goal。',
+            setDialogGoalFollowTaskdocRejected: '错误：Dominds 已确认这个智能体现在有其它并行对话，不能只按“依差遣牒推进”继续。已保留“依差遣牒推进”，并在本路主线目标提醒中补充：立即问人类这一路主线接下来具体推进什么。',
+            setDialogGoalSetToGoal: '已记录本路主线目标。',
+            setDialogGoalSetToFollowTaskdoc: '已记录本路主线目标：依差遣牒推进。',
             reminderAlreadyDialogScope: (reminderId) => `reminder_id=${reminderId} 已经是当前对话范围提醒项，不需要迁移。`,
             reminderMigrateManagedBlocked: (managerTool) => `错误：该提醒项由工具 ${managerTool} 管理，不能用 migrate_reminder 迁移；请使用 ${managerTool} 更新。`,
             invalidFormatDoMind: '参数格式不对。用法：do_mind({ selector: string, category?: string, content: string })',
@@ -459,6 +466,12 @@ function getCtrlMessages(language) {
         reminderContentEmpty: 'Error: Reminder content cannot be empty',
         invalidFormatUpdate: 'Error: Invalid args. Use: update_reminder({ reminder_id: string, content: string })',
         invalidFormatMigrate: 'Error: Invalid args. Use: migrate_reminder({ reminder_id: string, scope: "dialog" })',
+        invalidFormatSetDialogGoal: 'Error: Invalid args. Use: set_dialog_goal({ mode: "goal", goal: string }) or set_dialog_goal({ mode: "follow_taskdoc" }).',
+        setDialogGoalMainOnly: 'Error: set_dialog_goal is only for Main Dialogs; Side Dialogs should follow the request they received.',
+        setDialogGoalGoalRequired: 'Error: mode="goal" requires a non-empty goal.',
+        setDialogGoalFollowTaskdocRejected: 'Error: Dominds has confirmed this agent now has another parallel dialog, so this one cannot proceed from the Taskdoc alone. The reminder keeps "proceed from the Taskdoc" and now adds: ask the human what this Main Dialog should work on next.',
+        setDialogGoalSetToGoal: 'Recorded the goal for this Main Dialog.',
+        setDialogGoalSetToFollowTaskdoc: 'Recorded the goal for this Main Dialog: proceed from the Taskdoc.',
         reminderAlreadyDialogScope: (reminderId) => `reminder_id=${reminderId} is already dialog-scope in the current dialog; no migration is needed.`,
         reminderMigrateManagedBlocked: (managerTool) => `Error: This reminder is managed by tool ${managerTool}. Do not migrate it via migrate_reminder; use ${managerTool} instead.`,
         invalidFormatDoMind: 'Error: Invalid args. Use: do_mind({ selector: string, category?: string, content: string })',
@@ -784,6 +797,57 @@ exports.migrateReminderTool = {
         return appendSharedReminderMigrationImpactToToolResult(baseOutput, language, dispatch);
     },
 };
+exports.setDialogGoalTool = {
+    type: 'func',
+    name: 'set_dialog_goal',
+    description: 'Record what this Main Dialog should work on next. Use mode="goal" for a concrete goal; use mode="follow_taskdoc" only when Dominds allows this dialog to simply proceed from the Taskdoc.',
+    descriptionI18n: {
+        en: 'Record what this Main Dialog should work on next. Use mode="goal" for a concrete goal; use mode="follow_taskdoc" only when Dominds allows this dialog to simply proceed from the Taskdoc.',
+        zh: '记录这一路主线接下来具体推进什么。mode="goal" 用于写清目标；只有 Dominds 允许时，才用 mode="follow_taskdoc" 表示依差遣牒推进。',
+    },
+    parameters: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['mode'],
+        properties: {
+            mode: {
+                type: 'string',
+                enum: ['goal', 'follow_taskdoc'],
+                description: 'goal = record a concrete goal; follow_taskdoc = proceed from the Taskdoc when Dominds allows it.',
+            },
+            goal: {
+                type: 'string',
+                description: 'Required when mode="goal"; ignored when mode="follow_taskdoc".',
+            },
+        },
+    },
+    argsValidation: 'dominds',
+    async call(dlg, _caller, args) {
+        const language = (0, work_language_1.getWorkLanguage)();
+        const t = getCtrlMessages(language);
+        if (dlg.id.selfId !== dlg.id.rootId) {
+            return (0, tool_1.toolFailure)(t.setDialogGoalMainOnly);
+        }
+        const modeValue = args['mode'];
+        if (modeValue !== 'goal' && modeValue !== 'follow_taskdoc') {
+            return (0, tool_1.toolFailure)(t.invalidFormatSetDialogGoal);
+        }
+        if (modeValue === 'follow_taskdoc') {
+            const result = await (0, main_dialog_goal_reminder_1.setMainDialogGoalReminder)(dlg, { mode: 'follow_taskdoc' });
+            if (result.kind === 'rejected_parallel_dialogs') {
+                return (0, tool_1.toolFailure)(t.setDialogGoalFollowTaskdocRejected);
+            }
+            return (0, tool_1.toolSuccess)(t.setDialogGoalSetToFollowTaskdoc);
+        }
+        const goalValue = args['goal'];
+        const goal = typeof goalValue === 'string' ? goalValue.trim() : '';
+        if (goal === '') {
+            return (0, tool_1.toolFailure)(t.setDialogGoalGoalRequired);
+        }
+        await (0, main_dialog_goal_reminder_1.setMainDialogGoalReminder)(dlg, { mode: 'goal', goal });
+        return (0, tool_1.toolSuccess)(t.setDialogGoalSetToGoal);
+    },
+};
 exports.clearMindTool = {
     type: 'func',
     name: 'clear_mind',

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

@@ -26,7 +26,7 @@
 
 control is Dominds' **dialog control toolset** for managing dialog state, reminders, taskdocs, and inter-dialog reply closure semantics:
 
-- **Reminder management**: Three reminder scopes: `dialog` / `task` / `agent`. Default to `task` for ordinary current work under the same Taskdoc; use `dialog` for truly dialog-local notes, and continuation packages before `clear_mind` must explicitly use `scope=dialog` and state this dialog task goal; use `agent` only for urgent, short-lived, globally visible cues
+- **Reminder management**: Main Dialogs always show a fixed "Goal for this Main Dialog" reminder. If it says to ask the human first, ask immediately and record the answer with `set_dialog_goal`. Ordinary reminders have three scopes: `dialog` / `task` / `agent`. Default to `task` for ordinary current work under the same Taskdoc; use `dialog` for truly dialog-local continuation details; use `agent` only for urgent, short-lived, globally visible cues
 - **Taskdoc operations**: Append to, replace, or delete task contract sections (goals/constraints/progress); within Taskdoc, `progress` is the team-shared, quasi-real-time, scannable task bulletin board
 - **Context maintenance**: Reduce cognitive load without losing key resume state
 - **Reply routing**: Separate asking the tellasker back, sending the final reply, and ordinary plain text in Side Dialog / ask-back flows
@@ -58,11 +58,13 @@ Reminders are temporary current-work information for:
 - Recording blocking issues
 - Holding current-dialog scoped continuation-package bridge notes before `clear_mind`
 
+Main Dialogs always carry a Dominds-managed "Goal for this Main Dialog" reminder. Read the whole reminder. If it says to ask the human first, ask what this Main Dialog should work on next, then record the answer with `set_dialog_goal`. If it says "proceed from the Taskdoc" and has no parallel-dialog note, continue from the Taskdoc; if the same reminder says Dominds has confirmed a parallel dialog, ask the human first.
+
 Reminders are not for manually copying environment state automatically maintained by Dominds, such as background process status, in-flight background asks/collaboration, or browser/session attachment state. Dominds-managed reminders, panels, and tool outputs are the authoritative place for that state; manual notes go stale easily and create cognitive noise.
 
 Scope rule:
 
-- `dialog`: current-dialog current work; continuation packages before `clear_mind` must explicitly use this scope and state this dialog task goal
+- `dialog`: current-dialog current work and continuation details. Main Dialog goals come from the fixed goal reminder; Side Dialog continuation packages must state this Side Dialog's task goal
 - `task`: current work under the current Taskdoc, and the default scope
 - `agent`: urgent, short-lived, globally visible cues you should keep seeing across later dialogs you lead