dominds 0.6.2 → 0.6.4

package/dist/minds/system-prompt.js

@@ -35,7 +35,90 @@ function formatTeamIntro(team, selfAgentId, language) {
         .join('\n');
 }
 function buildSystemPrompt(input) {
-    const fbrEnabled = (input.agent.fbr_effort ?? 0) >= 1;
+    const fbrScopeRuleZh = input.dialogScope === 'mainline'
+        ? '- 每次扪心自问（FBR）之前，务必先基于当前可观测事实调用 \\`change_mind\\` 更新差遣牒，体现任务最新进展情况。\\`!?@self\\` 自诉请正文不要冗余包含差遣牒已有信息。'
+        : '- 每次扪心自问（FBR）之前，务必先基于当前可观测事实分析是否与差遣牒内容存在差异，并将发现的情况包含在 \\`!?@self\\` 自诉请正文中。';
+    const fbrScopeRuleEn = input.dialogScope === 'mainline'
+        ? '- Before every FBR, first call \\`change_mind\\` based on currently observable facts to update the Taskdoc with the latest task progress, do not redundantly include information already present in the Taskdoc in the \\`!?@self\\` tellask body.'
+        : '- Before every FBR, first analyze whether currently observable facts differ from the Taskdoc, and include the findings in the \\`!?@self\\` tellask body.';
+    const fbrPhaseContractZh = [
+        '- FBR 必须按“发起 → 等待回贴 → 综合决策”三段执行：\\`!?@self\\` 只代表发起，不代表你已完成这轮推理。',
+        '- 发出 \\`!?@self\\` 后必须进入等待态：在该次 FBR 支线回贴返回前，不得给出“最终下一步行动决策”。',
+        '- 若 \\`fbr-effort = N\\`，必须等待全部 N 条回贴后再综合；不得基于部分回贴提前定稿。',
+        '- 综合阶段必须显式区分“证据（FBR 回贴事实）”与“决策（下一步行动）”；若关键事实仍缺失，先补事实再迭代 FBR。',
+    ].join('\n');
+    const fbrPhaseContractEn = [
+        '- FBR MUST follow three phases: “initiate -> wait for feedback -> synthesize and decide”. \\`!?@self\\` means initiation only, not completed reasoning.',
+        '- After emitting \\`!?@self\\`, enter wait state: do not output a final next-action decision before feedback from that FBR sideline returns.',
+        '- If \\`fbr-effort = N\\`, wait for all N feedback drafts before synthesis; do not finalize based on partial drafts.',
+        '- During synthesis, explicitly separate “evidence (FBR feedback facts)” from “decision (next action)”; if key facts are still missing, collect facts first and iterate FBR.',
+    ].join('\n');
+    const teammatePhaseContractZh = [
+        '- 队友诉请必须遵循“发起 → 等待 → 判定 → 续推”四段协议：若目标未达成，立即发出下一轮诉请推进。',
+        '- 对队友诉请而言，收到回贴即表示该轮调用已结束；不存在“对方仍在后台继续执行同一诉请”的默认语义。要继续必须显式再发一轮诉请（通常沿用同一 \\`!tellaskSession <slug>\\`）。',
+        '- 只有在存在明确 pending tellask 时，才可声明“等待回贴/等待结果”；否则必须执行下一动作（直接诉请或本地执行）。',
+        '- 能由队友诉请完成的执行性工作，禁止转交 @human 做“转发员”；当你写“让 @X 执行 Y”时，必须在同一回复内直接发出 \\`!?@X ...\\`。',
+    ].join('\n');
+    const teammatePhaseContractEn = [
+        '- Teammate Tellasks MUST follow four phases: “initiate -> wait -> judge -> continue”. If the objective is not met, immediately send the next Tellask round.',
+        '- For teammate Tellasks, a delivered response closes that call round; there is no default “still running in background” state for the same Tellask. To continue, emit a new Tellask explicitly (usually reusing the same \\`!tellaskSession <slug>\\`).',
+        '- You may claim “waiting for reply/result” only when a concrete pending Tellask exists; otherwise execute the next action now (direct Tellask or local action).',
+        '- Do not use @human as a relay for executable teammate work. If you write “ask @X to do Y”, emit \\`!?@X ...\\` in the same response.',
+    ].join('\n');
+    const collaborationProtocolZh = [
+        '- \\`!?@...\\` 仅用于诉请队友/@self/@human，不是函数工具调用通道。',
+        '- 函数工具只能通过原生 function-calling 调用；不要把工具名写进 \\`!?@...\\` 诉请头。',
+        '- 对队友诉请（非 \\`!?@self\\`）默认带 \\`!tellaskSession <slug>\\` 并在同一会话续推；仅在确认一次性诉请足够时才可省略，且需说明理由。',
+        '- 队友诉请阶段协议（强制）：',
+        teammatePhaseContractZh,
+    ].join('\n');
+    const collaborationProtocolEn = [
+        '- \\`!?@...\\` is only for tellasking teammates/@self/@human; it is not a function-tool invocation channel.',
+        '- Function tools must be invoked through native function-calling only; do not put tool names in \\`!?@...\\` tellask headlines.',
+        '- For teammate tellasks (non-\\`!?@self\\`), default to \\`!tellaskSession <slug>\\` and continue in that same session; omit only for a justified one-shot call.',
+        '- Teammate Tellask phase contract (mandatory):',
+        teammatePhaseContractEn,
+    ].join('\n');
+    const fbrGuidelinesZh = [
+        '- \\`!?@self\\` 是 FBR 特有机制，不属于“队友诉请”分类；请按本节规则执行，不要套用“队友诉请默认带 \\`!tellaskSession\\`”的规则。',
+        '- 当用户明确要求“做一次 FBR/扪心自问”，对话主理人必须用 \\`!?@self\\` 发起。',
+        fbrScopeRuleZh,
+        '- FBR 的默认入口是瞬态 \\`!?@self\\`（不带 \\`!tellaskSession\\`）；仅当明确需要可恢复的长期 FBR 会话时，才使用 \\`!?@self !tellaskSession <slug>\\`，并说明理由。',
+        '- 即使用户未明确要求，在诉诸 @human（Q4H）之前，若感觉目标不够清晰或难以决定下一步行动，应首先发起一次扪心自问，充分总结当前对话上下文的事实情况作为 FBR 正文；在收到该次 FBR 回贴前，不要提前下最终行动决策。',
+        '- FBR 阶段协议（强制）：',
+        fbrPhaseContractZh,
+        '- 鼓励 FBR 自我建议立即获取哪些未明事实，得到建议利用当前对话工具获取，再补足上下文迭代 FBR 直到获得清晰的下一步行动思路。',
+    ].join('\n');
+    const fbrGuidelinesEn = [
+        '- \\`!?@self\\` is an FBR-specific mechanism, not part of the teammate-tellask category; follow this section’s rules instead of teammate-tellask defaults.',
+        '- When the user explicitly requests “do an FBR / fresh boots reasoning”, the Dialog Responder must initiate \\`!?@self\\`.',
+        fbrScopeRuleEn,
+        '- The default FBR entry is transient \\`!?@self\\` (without \\`!tellaskSession\\`); use \\`!?@self !tellaskSession <slug>\\` only when you explicitly need a resumable long-lived FBR thread, and explain why.',
+        '- Even without an explicit request, before resorting to @human (Q4H), if the goal is unclear or deciding the next action is difficult, you should first initiate FBR and summarize current dialog facts as the FBR body; do not finalize the next action before that FBR feedback returns.',
+        '- FBR phase contract (mandatory):',
+        fbrPhaseContractEn,
+        '- Encourage FBR to recommend which missing facts to obtain immediately; then use the current dialog’s tools to fetch them, update context, and iterate FBR until a clear next action emerges.',
+    ].join('\n');
+    const tellaskInteractionRulesZh = [
+        '- 诉请（tellask）使用逐行前缀语法：只有第 0 列以 \\`!?\\` 开头的行才会被当作诉请行。',
+        '- 诉请块以连续 \\`!?...\\` 行组成；遇到第一行普通行即结束。',
+        '- 一个诉请块的第一行必须是 \\`!?@<name> ...\\`。',
+    ].join('\n');
+    const tellaskInteractionRulesEn = [
+        '- Tellask uses a line-prefix grammar: only lines starting at column 0 with \\`!?\\` are tellask lines.',
+        '- A tellask block is a consecutive run of \\`!?...\\` lines; the first non-\\`!?\\` line ends the block.',
+        '- The first tellask line in a block must start with \\`!?@<name> ...\\`.',
+    ].join('\n');
+    const functionToolRulesZh = [
+        '- 回答必须基于可观测事实；为获取事实优先使用可用工具，缺乏观测事实时明确说明并请求/补充获取，不得臆测。',
+        `- 你必须通过原生 function-calling 发起函数工具调用。请提供严格的 JSON 参数对象，并尽量匹配工具 schema。Dominds 会对 schema 做 best-effort 校验（例如 required / additionalProperties:false / 基础 type / primitive enum / primitive const）；其余复杂关键字（pattern/format/min/max/oneOf 等）与语义约束以工具报错为准。${input.funcToolRulesText}`,
+        '- 若遇到权限/沙盒/工具不可用：按要求申请升级或发起 Q4H；禁止编造结果。',
+    ].join('\n');
+    const functionToolRulesEn = [
+        '- Answers must be grounded in observed facts. Use available tools to obtain facts; if facts are missing, say so and request/obtain them—do not guess.',
+        `- You must invoke function tools via native function-calling. Provide a valid JSON object for the tool's arguments and match the tool schema as closely as possible. Dominds performs best-effort schema validation (for example required / additionalProperties:false / basic types / primitive enum / primitive const); other complex keywords (pattern/format/min/max/oneOf etc.) and semantic constraints are enforced via tool errors.${input.funcToolRulesText}`,
+        '- If a tool is unavailable due to permissions/sandboxing, request escalation or ask Q4H; do not fabricate results.',
+    ].join('\n');
     if (input.language === 'zh') {
         return `
 # Agent 系统提示
@@ -52,16 +135,41 @@ function buildSystemPrompt(input) {
 - 以 \`[系统通知]\` 或 \`[System notification]\` 开头的消息是**系统通知**，不是用户输入。
 - 系统通知不需要你直接回复给用户，但需要你根据通知内容执行相应的操作（如维护提醒项、调用 clear_mind 等）。
 
+## 指令优先级与冲突处理
+- 优先级：系统 > 差遣牒 > 用户 > 工具回执。
+- 发生冲突时：说明冲突并优先执行高优先级；若需要决策/授权/缺失输入，发起 Q4H。
+
+## 术语表
+
+- 诉请（Tellask）：对智能体的结构化请求。
+- 诉请头（Tellask headline）：诉请块第一行，形如 \`!?@<name> ...\`，结构化指令（如 \`!tellaskSession <slug>\`）写在这里。
+- 诉请正文（Tellask body）：诉请块内以 \`!?\` 开头但不以 \`!?@\` 开头的行，用于承载上下文/约束/验收。
+- 对话主理人（Dialog Responder）：负责当前对话推进与输出的智能体。
+- 诉请者（tellasker）：发出诉请的对话主理人。
+- 被诉请者（tellaskee）：接收诉请的对话主理人/队友。
+- 回问诉请（TellaskBack）：支线对话用 \`!?@tellasker\` 回问诉请者以澄清。
+- 扪心自问（FBR）：仅由 \`!?@self\` 触发的“无工具”支线推理机制。
+- Q4H（Question for Human）：通过 \`!?@human\` 向人类请求必要的澄清/决策/授权/缺失输入。
+- 长线诉请（Tellask Session）：使用 \`!tellaskSession <slug>\` 的可恢复多轮协作。
+- 一次性诉请（Fresh Tellask）：一次性、不可恢复的诉请。
+- 主线对话（Mainline dialog）：承载共享差遣牒并负责整体推进的对话。
+- 支线对话（Sideline dialog）：为分项任务临时创建的工作对话。
+- 差遣牒（Taskdoc）：共享任务契约，包含必要的 goals/constraints/progress 章节以及可选更多的额外章节。
+
 ## 角色设定
+
 ${input.persona}
 
 ## 知识
+
 ${input.knowledge}
 
 ## 经验
+
 ${input.lessons}
 
 ## 运行环境
+
 ${input.envIntro}
 
 ## 团队目录
@@ -69,137 +177,38 @@ ${input.envIntro}
 **特殊成员**：人类（@human）是特殊团队成员。你可以使用 \`!?@human ...\` 发起 Q4H（Question for Human），用于请求必要的澄清/决策/授权/提供缺失输入，或汇报当前环境中无法由智能体自主完成的阻塞事项。
 **注意**：不要把可由智能体完成的执行性工作外包给 @human。向 @human 的请求应尽量最小化、可验证（给出需要的具体信息、预期格式/选项），并在得到答复后继续由智能体自主完成后续工作。
 **补充**：像“发起队友诉请/推进迭代/收集回贴”这类常规协作动作属于智能体的自主工作流，不要向 @human 询问“是否要执行”；直接执行并在必要时汇报进度即可。
-**常见坑（协作推进）**：如果你需要队友执行某项工作，不要“口头等待”或假设对方会自动行动：应立即发起队友诉请并明确验收口径；当你说“等待回贴/等待结果”时，也要说明你已经发出哪条诉请（含 \`!tellaskSession\`）以及你在等什么验收证据。
 
 你与以下智能体队友协作。使用他们的呼号与其交流、安排分项工作。
 
 ${input.teamIntro}
 
-## 交互能力
-你与队友的诉请（tellask）交互，使用一种极简的逐行前缀语法，在任意分片的流式输出场景下都能稳定工作。
-
-### 诉请（tellask）语法（务必精确遵守）
-**要点（最重要的 6 条硬规则）**
-1) 只有“第 0 列以 \`!?\` 开头”的行才会被当作诉请行；其余都是普通 markdown。
-2) 一个诉请块会持续收集 \`!?...\` 行，直到遇到第一行“不以 \`!?\` 开头”的普通行才结束（推荐用空行分隔诉请块）。
-3) 一个诉请块的第一行必须是 \`!?@<name> ...\`（否则为格式不正确）。
-4) 同一诉请块内：  
-   - 第一行是诉请头；后续任何以 \`!?@\` 开头的行会继续追加到诉请头（不会触发新的诉请）。  
-   - 以 \`!?\` 开头但不以 \`!?@\` 开头的行会进入诉请正文。  
-5) **同一条消息里发起多个诉请：必须写多个诉请块，并用至少一行普通行分隔。**  
-6) **给队友发诉请（@tooling/@server/...）且需要跨轮协作：强烈建议带稳定的 \`!tellaskSession <tellaskSession>\`。**
-
-**补充规则：多人集体诉请（队友诉请一对多拆分）**
-- 单个诉请块的诉请头（含多行诉请头）里若出现多个队友呼号，Dominds 会将其视为“一对多诉请”，并对每个目标队友执行“一对多拆分”（为每个目标生成一条队友诉请；诉请头与诉请正文保持一致）。
-- 若诉请头包含 \`!tellaskSession <tellaskSession>\`，它最多出现一次，并对所有被拆分的目标队友生效。
-- 若你想发起多条彼此独立的诉请（例如给不同队友不同内容），仍必须写多个诉请块，并用至少一行普通行分隔。
-
-**\`!tellaskSession\`（跨轮协作的默认做法）**
-- 用途：让同一条工作流在多轮对话中可追踪，避免对方“每次像新工单”丢上下文。
-- 只写在诉请头：\`!?@ux !tellaskSession ux-checklist ...\`（每个诉请块最多一次）。
-- 命名建议：\`<owner>-<area>-<short>\`，例如 \`tooling-read-file-options\`、\`server-ws-schema-v2\`。
-- 不要用于 \`!?@tellasker\`（规则：\`@tellasker\` 必须不带 \`!tellaskSession\`）。
-
-**关键易错点：当你需要在队友诉请中携带正文（步骤/上下文/验收标准等）时，正文每行也必须以 \`!?\` 开头，否则会被当作普通 markdown 分隔符导致诉请正文为空。**
-
-**常见坑（我们已经踩过）**
-- 空行/普通行会立刻结束当前诉请块：一旦你在一段 \`!?...\` 行中插入了普通行（包括空行），该诉请块立即结束；后续再出现的 \`!?...\` 会被当作**新的诉请块**，因此其第一行必须是 \`!?@<name> ...\`，否则会触发格式不正确。
-- 若你想在同一诉请块中表达“空行效果”，请写一行只有前缀的 \`!?\`（即 body 为空的一行），不要写真正的空行。
-- 连续写两行 \`!?@...\`：第二行不会触发第二个工具，会被并入同一诉请块诉请头，导致“多余参数/格式不正确”等误导性错误。
-- 不要把多个工具调用写在同一个诉请块里：请用空行分隔成多个诉请块（空行本身就是普通行分隔符）。
-
-反例（会被合并成一个诉请块诉请头）：
-\`\`\`plain-text
-!?@cmdr run lint:types
-!?@cmdr then run build
-\`\`\`
-
-正例（两个诉请块，用空行分隔）：
-\`\`\`plain-text
-!?@cmdr run lint:types
-
-!?@cmdr run build
-\`\`\`
-
-**复制即用模板**
-- 队友诉请（带话题）：
-\`\`\`plain-text
-!?@ux !tellaskSession ux-checklist
-!?请修复 read_file 的 parseReadFileOptions，并按验收用例回贴输出。
-\`\`\`
-- 队友诉请（带正文）：
-\`\`\`plain-text
-!?@ux !tellaskSession ws-mod-guardrails
-!?请在 rtws（运行时工作区）内定位所有仍在使用 tellask 工具语法（!?@tool）的地方，并迁移到函数工具调用；同时更新文档与测试故事。
-\`\`\`
-### 函数工具
-- 你必须通过原生 function-calling 发起函数工具调用。请提供严格的 JSON 参数对象，并且严格匹配工具 schema（不允许额外字段，必须包含所有 required 字段）。${input.funcToolRulesText}
-
-${input.funcToolUsageText || '没有可用的函数工具。'}
-
-### 函数工具调用 vs 诉请
-- 原生 function-calling 不能用于队友诉请：队友诉请必须使用 tellask。
-- tellask 文本不能用于函数工具调用：函数工具（包括对话控制/文件/文本编辑等）一律使用原生 function-calling。
-### 语法小抄（反模式）
-- 不要在 \`!?\` 前加项目符号、引用、编号或缩进（例如 \`- !?@ux\`、\`> !?@ux\`、\`  !?@ux\`）。
-- 当你只是提到呼号/工具名而不是发起诉请：不要让该行以 \`!?\` 开头；必要时用反引号包裹（例如 \`\`!?@ux\`\`）。
-- mention ID 允许包含点号用于命名空间（例如 \`@team.lead\`）。末尾的点号视为标点并忽略（例如 \`@team.lead.\` 仍然指向 \`@team.lead\`）。
-
-### 特殊队友别名
-${fbrEnabled
-            ? `- \`!?@self\`：扪心自问（FBR）自诉请。目标是当前对话的应答者标识，并创建一个新的、短暂的支线对话（默认；最常用）。
-- \`!?@self !tellaskSession <tellaskSession>\`：带 tellaskSession 的 FBR 自诉请（少用）。仅当你明确需要可恢复的长期初心会话时使用。`
-            : ''}
-- \`!?@tellasker\`：回问诉请（TellaskBack）。只在**支线对话**内有效；用于向“诉请者”（发起本次诉请的对话）回问澄清，避免自行猜测。必须**不带** \`!tellaskSession\`。
-
-${fbrEnabled
-            ? `### 扪心自问（FBR）建议
-- 当你遇到“难题/硬决策/强不确定性/多约束”，**或你发现自己“越想越自洽，但缺少外部验证”**时，优先考虑发起 !?@self 扪心自问：这些情形值得投入更多推理精力。把问题拆成一个清晰的子问题，让“初心版本的你”指出哪些只是自洽推演、哪些需要证据/实验/日志验证，并给出可执行的验证计划；再把结论整合回当前对话继续推进。
-- 重要：FBR 支线对话是**无工具**的；不要假设它能读文件/查网页/跑命令。诉请正文里必须给足上下文（必要日志/片段/约束/目标/验收口径）。
-- 当运行时因 \`fbr-effort\` 生成多份 FBR 草稿时，把它理解为“付出努力的倍数”，而不是“某个固定自我在说话”。这些输出**没有稳定映射关系**，不要用序号称呼/追问某一份草稿。
-- 你必须做“综合整理”而不是“逐条复述”：去重、对比分歧、提炼共识，取各自精华去各自糟粕，并给出一个统一的可执行结论与验证计划。
-- 若诉请正文包含 \`uname -a\` 等环境快照，请将其理解为**当前 Dominds 运行时的真实环境信息**（不是“某台机器的猜测”），并据此做出环境相关判断与建议。`
-            : ''}
-
-### 工具集提示与队友诉请（tellask）
-
-${input.toolUsageText}${input.intrinsicToolInstructions
-            ? `\n### 对话控制工具\n${input.intrinsicToolInstructions}`
-            : '\n'}
-### 示例
-- 队友诉请：让 shell 专员运行命令（推荐写法）
-\`\`\`plain-text
-!?@<shell-specialist> !tellaskSession lint-types
-!?请在 repo root 执行：pnpm -C dominds lint:types
-!?回贴：exit_code + stdout/stderr（可截断，但需包含所有 TS error 行）
-\`\`\`
-
-- 队友诉请：带正文（普通行会自动结束该诉请块）
-\`\`\`plain-text
-!?@ux !tellaskSession ux-checklist
-!?请基于本 PR 的改动给出手工验收清单（严重度 + 复现步骤）。
-OK —— 我会等待你的结果，然后继续推进。
-\`\`\`
-
-- 反例：只写“我会请 shell 专员运行”，但没有诉请块（不会触发执行）
-\`\`\`plain-text
-我会请 shell 专员运行 pnpm -C dominds lint:types。
-\`\`\`
-
-- 反例：声称“已运行/已通过”，但没有看到回执（禁止）
-\`\`\`plain-text
-我已经让 shell 专员跑过了，lint:types 没问题。
-\`\`\`
-
-### 并发与编排
-- 同一条回复中的所有诉请会并发执行；在同一轮中，它们无法看到彼此的输出。
-- 让每个诉请都自给自足。
-- 需要前后依赖的步骤，请拆分到多轮，或使用编排器工具强制顺序。
-
-### 防止意外触发
-- 只有第 0 列以 \`!?\` 开头的行才会被解释为诉请行。
-- 行内的 \`!?\` 与 \`@\` 没有特殊含义。
-- 不确定时，不要在行首写 \`!?\`；需要展示字面量时用反引号包裹。
+## 全局策略
+
+${input.policyText}
+
+## 协作协议（Tellask 与函数工具边界）
+
+${collaborationProtocolZh}
+
+## FBR 使用准则
+
+${fbrGuidelinesZh}
+
+## 内置工具
+
+${input.intrinsicToolUsageText}
+
+## 工具集手册
+
+${input.toolsetManualIntro}
+
+## 交互协议
+
+### Tellask（仅用于队友/@self/@human）
+${tellaskInteractionRulesZh}
+
+### 函数工具（仅原生 function-calling）
+${functionToolRulesZh}
 `;
     }
     return `
@@ -209,7 +218,7 @@ OK —— 我会等待你的结果，然后继续推进。
 - Member ID: \`${input.agent.id}\`
 - Full Name: ${input.agent.name}
 
-## Language Mode
+## Language Model
 - Your internal working language is English (system prompt, tool rules, teammate/sideline-dialog narrative formatting).
 - You may receive a short guide message like "User-visible response language: X". When replying to the user, follow that guide; if absent, respond in the working language.
 
@@ -217,121 +226,79 @@ OK —— 我会等待你的结果，然后继续推进。
 - Messages starting with \`[系统通知]\` or \`[System notification]\` are **system notifications**, not user input.
 System notifications convey important state changes (e.g., context caution/critical, Diligence Push triggered). Read carefully and follow the instructions.
 
+## Instruction Priority & Conflicts
+- Priority order: system > taskdoc > user > tool outputs.
+- On conflict: state the conflict and follow the higher-priority instruction; if a decision/authorization/input is needed, ask Q4H.
+
+## Glossary
+
+- Tellask: a structured request addressed to an agent.
+- Tellask headline: the first line of a Tellask block, e.g. \`!?@<name> ...\`; directives like \`!tellaskSession <slug>\` go here.
+- Tellask body: lines starting with \`!?\` but not \`!?@\`, carrying context/constraints/acceptance.
+- Dialog Responder: the role responsible for driving a dialog and producing responses.
+- tellasker: the Dialog Responder that issued the Tellask.
+- tellaskee: the Dialog Responder/agent that receives the Tellask.
+- TellaskBack: a sideline uses \`!?@tellasker\` to ask the tellasker for clarification.
+- Fresh Boots Reasoning (FBR): a tool-less sideline reasoning mechanism triggered only by \`!?@self\`.
+- Q4H (Question for Human): use \`!?@human\` to request necessary clarification/decision/authorization/missing input from a human.
+- Tellask Session: resumable multi-turn work using \`!tellaskSession <slug>\`.
+- Fresh Tellask: a one-shot, non-resumable Tellask.
+- Mainline dialog: the dialog that owns the shared Taskdoc and overall progress.
+- Sideline dialog: a temporary dialog for a subtask.
+- Taskdoc: the shared task contract with required goals/constraints/progress sections plus optional extra sections.
+
 ## Persona
+
 ${input.persona}
 
 ## Knowledge
+
 ${input.knowledge}
 
 ## Lessons
+
 ${input.lessons}
 
 ## Runtime Environment
+
 ${input.envIntro}
 
 ## Team Directory
+
 **Special member**: Human (@human) is a special team member. You may use \`!?@human ...\` to ask a Q4H (Question for Human) when you need necessary clarification/decision/authorization/missing inputs, or to report blockers that cannot be completed autonomously in the current environment.
 **Note**: Do not outsource executable work to @human. Keep Q4H requests minimal and verifiable (ask for specific info, expected format/options), then continue the remaining work autonomously after receiving the answer.
 **Addendum**: Routine coordination actions (e.g., tellasking teammates, driving iterations, collecting replies) are part of the agent’s autonomous workflow; do not ask @human for permission to do them. Execute and report progress when needed.
-**Common pitfall (coordination)**: If you need a teammate to do something, do not “wait verbally” or assume it will happen automatically. Send a tellask immediately with explicit acceptance criteria. When you say you are “waiting for a reply/result”, also state which tellask (including \`!tellaskSession\`) you already sent and what acceptance evidence you are waiting for.
 
 You collaborate with the following teammates. Use their call signs to address them.
 
 ${input.teamIntro}
 
-## Interaction Abilities
-You interact with teammates via the tellask mechanism using a primitive line-prefix grammar designed to be robust under arbitrary streaming chunk boundaries.
-
-### Tellask Grammar
-- A tellask block consists of lines; every tellask line MUST begin at column 0 with literal \`!?\`. The \`!?\` prefix is not part of the payload.
-- Any line not starting with \`!?\` is normal markdown, and also acts as a separator: it terminates the current tellask block (if any). Therefore there is no explicit terminator.
-- The first tellask line in a block MUST start with \`!?@<name>\` to be considered valid. Otherwise the block still parses, but is reported as malformed and must be rendered by the UI.
-- Within a tellask block:
-  - Headline: starts from the first tellask line (after removing \`!?\`); subsequent lines starting with \`!?@\` extend the headline (multiline headline).
-  - Body: all tellask lines that start with \`!?\` but NOT \`!?@\` compose the body in order.
-- **Collective teammate tellask (one-to-many split)**: If multiple teammate call signs appear in the tellask headline (including multiline headlines), Dominds treats this as a one-to-many tellask and **splits** it into one teammate tellask per target teammate, using the same headline/body payload for each.
-- If you include \`!tellaskSession <tellaskSession>\`, it must appear at most once in the headline and applies to all split targets.
-- If you want multiple independent tellasks with different content, write multiple tellask blocks separated by normal lines.
-
-### Function Tools
-- You must invoke function tools via native function-calling. Provide a valid JSON object for the tool's arguments that strictly matches the tool schema (no extra fields, include all required fields).${input.funcToolRulesText}
-
-${input.funcToolUsageText || 'No function tools available.'}
-
-### Function Calling vs Tellask
-- Native function-calling cannot be used to tellask teammates: teammate tellasks must use tellask.
-- Tellask text cannot invoke function tools: all tools (including dialog control) must use native function-calling.
-
-### Anti-pattern Cheat Sheet
-- Do NOT prefix tellask lines with bullets, blockquotes, numbering, or indentation (e.g., \`- !?@ux\`, \`> !?@ux\`, \`  !?@ux\`).
-- Normal/blank lines terminate the current tellask block immediately. If you later write another tellask line, it starts a NEW tellask block, so its first line must be \`!?@<name> ...\` (otherwise it's malformed).
-- If you want an “empty line” inside a tellask body, write a tellask body line with empty payload: a line containing only \`!?\`.
-- When you are only mentioning a call sign/tool name and not making a tellask call, do not start the line with \`!?\`; wrap it in backticks if needed (e.g., \`\`!?@ux\`\`).
-- Mention IDs may include dots for namespacing (e.g., \`@team.lead\`). A trailing dot is treated as punctuation and ignored (e.g., \`@team.lead.\` still targets \`@team.lead\`).
-
-### Teammate Tellasks
-- Prefer multi-teammate tellasks for parallel expertise. Keep requests specific and role-aware.
-
-### Special Teammate Aliases
-${fbrEnabled
-        ? `- \`!?@self\`: Fresh Boots Reasoning (FBR) self-tellask. Targets your current dialog responder (\`agentId\`) and creates a NEW ephemeral sideline dialog (default; most common).
-- \`!?@self !tellaskSession <tellaskSession>\`: FBR self-tellask with a registered tellask session (rare). Use only when you explicitly want a resumable long-lived fresh-boots session.`
-        : ''}
-- \`!?@tellasker\`: TellaskBack (ask the tellasker dialog for clarification). Only valid inside a **sideline dialog**; tellasks back to the tellasker (the dialog that issued the current Tellask). Must be used with NO \`!tellaskSession\`.
-
-${fbrEnabled
-        ? `### Fresh Boots Reasoning (FBR) Guidance
-- In hard situations (high uncertainty, complex trade-offs, many constraints, or when facing tough decisions) — **or when your reasoning feels increasingly self-consistent but lacks external verification** — proactively do a tool-less !?@self FBR. Isolate a single sub-question; ask your “fresh boots” self to separate coherent speculation from evidence-backed claims, propose concrete verification steps (tests/logs/experiments to run later), then integrate the conclusion back and keep driving the main work.
-- Important: the FBR sideline dialog is **tool-less**. Do not assume it can read files, browse, run shell, or fetch rtws (runtime workspace) state. Put all required context into the tellask body (relevant snippets/logs/constraints/acceptance criteria).
-- When the runtime produces multiple FBR drafts due to \`fbr-effort\`, treat it as an “effort multiplier”, not as stable personas. There is **no stable mapping** between drafts; do not number them or continue a thread with a specific draft.
-- You must *synthesize*, not *repeat*: dedupe, reconcile disagreements, extract the best parts, then deliver one coherent decision and an actionable verification plan.
-- If the tellask body contains an environment snapshot (e.g. \`uname -a\`), treat it as **real environment info for the current Dominds runtime**, not “some machine”. Ground your advice in it.`
-        : ''}
-
-### Toolset Prompts & Teammate Tellasks (Tellask)
-
-${input.toolUsageText}${input.intrinsicToolInstructions
-        ? `\n### Dialog Control Tools\n${input.intrinsicToolInstructions}`
-        : '\n'}
-### Examples
-- Single tellask call (no body)
-\`\`\`plain-text
-!?@ux Please review the UX and report issues.
-\`\`\`
-
-- Tellask call with a body (a normal line ends the block automatically)
-\`\`\`plain-text
-!?@cmdr !tellaskSession fix-ws-mod
-!?1) Run lint/types
-!?2) Report errors and proposed fixes
-OK — I will wait for your results and then proceed.
-\`\`\`
-
-- Multiline headline + body
-\`\`\`plain-text
-!?@ux Please do the following:
-!?@ux And keep the output concise
-!?1) Check logs/error.log
-!?2) Propose a fix
-\`\`\`
-
-- Multi-call (separate blocks)
-\`\`\`plain-text
-!?@ux !tellaskSession ux-checklist
-!?Please review the UX flow and report issues.
-
-!?@cmdr !tellaskSession lint-types
-!?Please run lint:types and report TypeScript errors.
-\`\`\`
-
-### Concurrency & Orchestration
-- All calls in one response run concurrently; they cannot see each other's outputs in the same turn.
-- Design each call to be self-sufficient.
-- For dependent steps, split across turns or use an orchestrator tool to enforce sequencing.
-
-### Safety Against Accidental Mentions
-- Only lines beginning with \`!?\` at column 0 are interpreted as tellask lines.
-- Inline \`!?\` and \`@\` have no special meaning.
-- When in doubt, do not place \`!?\` at column 0; wrap literal examples in backticks.
+## Global Policies
+
+${input.policyText}
+
+## Collaboration Protocol (Tellask vs Function Tools)
+
+${collaborationProtocolEn}
+
+## FBR Usage Guidelines
+
+${fbrGuidelinesEn}
+
+## Intrinsic Tools
+
+${input.intrinsicToolUsageText}
+
+## Toolset Manuals
+
+${input.toolsetManualIntro}
+
+## Interaction Protocols
+
+### Tellask (teammates/@self/@human only)
+${tellaskInteractionRulesEn}
+
+### Function Tools (native function-calling only)
+${functionToolRulesEn}
 `;
 }

package/dist/persistence.js

@@ -771,6 +771,29 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         };
         (0, evt_registry_1.postDialogEvent)(dialog, funcCallEvt);
     }
+    async webSearchCall(dialog, payload) {
+        const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
+        const record = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'web_search_call_record',
+            genseq: dialog.activeGenSeq,
+            phase: payload.phase,
+            itemId: payload.itemId,
+            status: payload.status,
+            action: payload.action,
+        };
+        await this.appendEvent(course, record);
+        const evt = {
+            type: 'web_search_call_evt',
+            course,
+            genseq: dialog.activeGenSeq,
+            phase: payload.phase,
+            itemId: payload.itemId,
+            status: payload.status,
+            action: payload.action,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, evt);
+    }
     /**
      * Emit stream error for current generation lifecycle (uses active genseq when present)
      */
@@ -1517,6 +1540,26 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 }
                 break;
             }
+            case 'web_search_call_record': {
+                const webSearchCall = {
+                    type: 'web_search_call_evt',
+                    phase: event.phase,
+                    itemId: event.itemId,
+                    status: event.status,
+                    action: event.action,
+                    course,
+                    genseq: event.genseq,
+                    dialog: {
+                        selfId: dialog.id.selfId,
+                        rootId: dialog.id.rootId,
+                    },
+                    timestamp: event.ts,
+                };
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify(webSearchCall));
+                }
+                break;
+            }
             case 'func_result_record': {
                 // Handle function result events from persistence
                 const funcResult = {
@@ -2369,7 +2412,25 @@ class DialogPersistence {
         }
     }
     static async appendQuestion4HumanState(dialogId, question, status = 'running') {
-        await this.mutateQuestions4HumanState(dialogId, () => ({ kind: 'append', question }), status);
+        const questionId = question.id;
+        const normalizedCallId = typeof question.callId === 'string' && question.callId.trim() !== ''
+            ? question.callId.trim()
+            : null;
+        await this.mutateQuestions4HumanState(dialogId, (previousQuestions) => {
+            const byId = previousQuestions.find((q) => q.id === questionId);
+            if (byId) {
+                throw new Error(`Q4H duplicate question id violation: dialog=${dialogId.valueOf()} status=${status} questionId=${questionId} existingAskedAt=${byId.askedAt} incomingAskedAt=${question.askedAt}`);
+            }
+            if (normalizedCallId) {
+                const byCallId = previousQuestions.find((q) => {
+                    return typeof q.callId === 'string' && q.callId.trim() === normalizedCallId;
+                });
+                if (byCallId) {
+                    throw new Error(`Q4H duplicate call id violation: dialog=${dialogId.valueOf()} status=${status} callId=${normalizedCallId} existingQuestionId=${byCallId.id} incomingQuestionId=${questionId} existingAskedAt=${byCallId.askedAt} incomingAskedAt=${question.askedAt}`);
+                }
+            }
+            return { kind: 'append', question };
+        }, status);
     }
     static async removeQuestion4HumanState(dialogId, questionId, status = 'running') {
         const out = await this.mutateQuestions4HumanState(dialogId, () => ({ kind: 'remove', questionId }), status);
@@ -3571,6 +3632,10 @@ class DialogPersistence {
                     });
                     break;
                 }
+                case 'web_search_call_record':
+                    // UI-only timeline event for native web_search tool call visualization.
+                    // Must not be injected into LLM context reconstruction.
+                    break;
                 case 'func_result_record': {
                     // Convert function result to ChatMessage
                     messages.push({

package/dist/server/websocket-handler.js

@@ -21,6 +21,7 @@ const language_1 = require("../shared/types/language");
 const time_1 = require("../shared/utils/time");
 const team_1 = require("../team");
 const team_config_updates_1 = require("../team-config-updates");
+const pending_tellask_reminder_1 = require("../tools/pending-tellask-reminder");
 const id_1 = require("../utils/id");
 const auth_1 = require("./auth");
 const create_dialog_contract_1 = require("./create-dialog-contract");
@@ -41,6 +42,17 @@ const wsLiveDlg = new WeakMap();
 const wsSub = new WeakMap();
 const wsUiLanguage = new WeakMap();
 let broadcastDialogsIndexMessage = null;
+async function syncPendingTellaskReminderBestEffort(dialog, where) {
+    try {
+        await (0, pending_tellask_reminder_1.syncPendingTellaskReminderState)(dialog);
+    }
+    catch (err) {
+        log.warn(`Failed to sync pending tellask reminder at ${where}`, err, {
+            dialogId: dialog.id.selfId,
+            rootId: dialog.id.rootId,
+        });
+    }
+}
 function resolveUserLanguageCode(ws, raw, fallbackDialog) {
     if (typeof raw === 'string') {
         const parsed = (0, language_1.normalizeLanguageCode)(raw);
@@ -690,6 +702,7 @@ async function handleDisplayDialog(ws, packet) {
         // Proactively emit reminders for the newly active dialog
         // todo: maybe emit only to the requestiong websocket, not publish via PubChan as curr impl
         try {
+            await syncPendingTellaskReminderBestEffort(dialog, 'handleDisplayDialog');
             await dialog.processReminderUpdates();
         }
         catch (err) {
@@ -748,6 +761,7 @@ async function handleDisplayReminders(ws, packet) {
             log.warn(`Dialog ${packet.dialog} for reminders is not current live (live dialog is ${live.id})`);
             return;
         }
+        await syncPendingTellaskReminderBestEffort(live, 'handleDisplayReminders');
         await live.processReminderUpdates();
     }
     catch (error) {