dominds 1.10.1 → 1.10.3

package/dist/docs/dialog-system.md

@@ -334,6 +334,9 @@ Result (second call):
 
 - **No registry lookup** - always creates a new subdialog
 - **Not registered** - no persistence across Tellasks
+- **No assignment-update channel** - once emitted, it cannot be updated in place like Type B
+- Another `tellaskSessionless` creates **another new transient subdialog**; it does not update, stop, or tell the earlier Type C sideline to stop
+- If later correction, scope change, or earlier wrap-up may be needed, choose Type B `tellask` with `sessionSlug` from the start
 - The subdialog itself is fully capable **except** for `freshBootsReasoning({ tellaskContent: "..." })` FBR, which is tool-less and tellask-free (see `fbr.md`).
 - Only difference from TYPE B: no registry lookup/resume capability
 - Used for one-off, independent tasks

package/dist/docs/dialog-system.zh.md

@@ -315,6 +315,9 @@ LLM 再次发出：tellask({ targetAgentId: "researcher", sessionSlug: "market-a
 
 - **无注册表查找** - 总是创建新的子对话
 - **不注册** - 在各次诉请之间不持久化
+- **无任务安排更新通道** - 发出后不能像 TYPE B 那样就地更新同一路诉请要求
+- 再次发起 `tellaskSessionless` 只会创建**另一条新的瞬态子对话**，不会更新、更不会要求先前那条 TYPE C 支线停止
+- 若你后续可能需要改要求、纠偏或提前收口，应该从一开始就选择带 `sessionSlug` 的 TYPE B `tellask`
 - 子对话本身一般是“完整能力”的；但 `freshBootsReasoning({ tellaskContent: "..." })` FBR 是特例：无工具且禁止任何诉请（见 `fbr.zh.md`）。
 - 与 TYPE B 的唯一区别：无注册表查找/恢复能力
 - 用于一次性的、独立的任务

package/dist/docs/dominds-terminology.md

@@ -196,6 +196,9 @@ tellask({
 - EN (key property): “Fresh/one-shot” is not only “new context”; it also means **no continuation semantics** — later Tellasks are not expected to resume the same session context.
 - ZH（关键性质）: “Fresh/一次性”不仅表示“新开上下文”，更表示：**没有后续续话语义** —— 后续诉请不应被期待能自动续接本次一次性诉请的上下文。
 
+- EN (operational consequence): A Fresh Tellask has **no assignment-update channel**. Another `tellaskSessionless` creates a new transient sideline; it does not update or tell the earlier one to stop.
+- ZH（操作后果）: 一次性诉请**没有任务安排更新通道**。再次发起 `tellaskSessionless` 只会新建另一条瞬态支线，不会更新、更不会要求先前那条支线停止。
+
 - EN (practical guidance): If you need a follow-up after a Fresh Tellask, treat it as a new request and restate necessary context; if you need iterative follow-ups, use `Tellask Session` with `sessionSlug`.
 - ZH（实践建议）: 如果你在一次性诉请后还要追问，应当把追问当作全新请求并补齐必要上下文；如果你需要可迭代的追问/推进，请使用 `Tellask Session` 并提供 `sessionSlug`。
 

package/dist/docs/tellask-collab.md

@@ -33,6 +33,12 @@ These points reflect current behavior in `dialog-system.md`, `fbr.md`, and `dili
 - `Tellask Session`: `tellask({ targetAgentId: "<teammate>", sessionSlug: "<slug>", tellaskContent: "..." })`
 - `Fresh Tellask`: `tellaskSessionless({ targetAgentId: "<teammate>", tellaskContent: "..." })`
 
+Important addition:
+
+- Only `Tellask Session` has an assignment-update channel.
+- `Fresh Tellask` has no such channel; another `tellaskSessionless` only creates another transient sideline and does not affect or tell the earlier owner to stop.
+- If later correction, earlier wrap-up, or scope change may be needed, do not choose `Fresh Tellask`; use `tellask` with `sessionSlug` from the start.
+
 ### 2.2 What `Tellask Session` really means
 
 - `sessionSlug` gives resumable addressing and reusable context.

package/dist/docs/tellask-collab.zh.md

@@ -33,6 +33,12 @@
 - 长线诉请：`tellask({ targetAgentId: "<teammate>", sessionSlug: "<slug>", tellaskContent: "..." })`，可恢复上下文的多轮协作。
 - 一次性诉请：`tellaskSessionless({ targetAgentId: "<teammate>", tellaskContent: "..." })`，一次性、不可恢复。
 
+关键补充：
+
+- 只有长线诉请有“更新任务安排”的通道。
+- 一次性诉请没有这个通道；后续再开一个 `tellaskSessionless` 只会创建新的瞬态支线，不会影响旧支线继续执行，更不能要求旧主理人停止。
+- 如果你后来可能需要改要求、提前收口或纠偏，就不该使用一次性诉请，而应从一开始就用带 `sessionSlug` 的长线诉请。
+
 ### 2.2 长线诉请的真实语义
 
 - `sessionSlug` 的作用是“会话寻址 + 历史复用”。

package/dist/docs/txt-editing-tools.md

@@ -82,6 +82,7 @@ Chinese version: [中文版](./txt-editing-tools.zh.md)
   使用建议：先用 `read_file` 获取 `total_lines/size_bytes` 作为 `known_old_total_lines/known_old_total_bytes` 的对账输入。  
   设计定位：用于“新内容很小（例如 <100 行）”或“明确为重置/生成物”的场景；其他情况优先 prepare/apply。  
   护栏（强制）：必须提供 `known_old_total_lines/known_old_total_bytes`（旧文件快照）才允许执行；若对账不匹配则拒绝覆盖。  
+  `content_format`：可选文本提示，任意非空字符串都可接受（例如 `yaml` / `toml` / `json` / `markdown`）。  
   护栏（默认拒绝）：若正文疑似 diff/patch，且未显式声明 `content_format=diff|patch`，则默认拒绝并引导改用 prepare/apply（避免把 patch 文本误写进文件）。  
   限制：不负责创建文件；创建空文件/新文件请用 `create_new_file`；创建“带非空初始内容”的新文件可用 `prepare_file_append create=true` → `apply_file_modification`。
 
@@ -136,7 +137,7 @@ Chinese version: [中文版](./txt-editing-tools.zh.md)
 > - `occurrence: ""` 或 `0`：不指定 occurrence。
 > - `match: ""`：使用默认 `contains`（注意：`match` 是 match mode，不是要匹配的文本/正则）。
 > - `read_file({ range: "", max_lines: 0 })`：分别表示“不指定范围 / 使用默认 500 行”。
-> - `overwrite_entire_file({ content_format: "" })`：表示“未显式声明内容格式”（此时若正文强特征疑似 diff/patch 将默认拒绝写入）。
+> - `overwrite_entire_file({ content_format: "" })`：表示“未显式声明内容格式”（此时若正文强特征疑似 diff/patch 将默认拒绝写入）；若显式提供任意非空标签（例如 `yaml`），工具会原样接受，但只有 `diff` / `patch` 具有放行 diff/patch 字面量的特殊语义。
 > - `ripgrep_*({ path: "", case: "", max_files: 0, max_results: 0 })`：分别表示“默认路径 '.' / 默认 smart-case / 使用默认上限”。
 
 ## 7. 规范化策略（当前实现）

package/dist/docs/txt-editing-tools.zh.md

@@ -82,6 +82,7 @@ updated: 2026-01-24
   使用建议：先用 `read_file` 获取 `total_lines/size_bytes` 作为 `known_old_total_lines/known_old_total_bytes` 的对账输入。  
   设计定位：用于"新内容很小（例如 <100 行）"或"明确为重置/生成物"的场景；其他情况优先 prepare/apply。  
   护栏（强制）：必须提供 `known_old_total_lines/known_old_total_bytes`（旧文件快照）才允许执行；若对账不匹配则拒绝覆盖。  
+  `content_format`：可选文本提示，任意非空字符串都可接受（例如 `yaml` / `toml` / `json` / `markdown`）。  
   护栏（默认拒绝）：若正文疑似 diff/patch，且未显式声明 `content_format=diff|patch`，则默认拒绝并引导改用 prepare/apply（避免把 patch 文本误写进文件）。  
   限制：不负责创建文件；创建空文件/新文件请用 `create_new_file`；创建"带非空初始内容"的新文件可用 `prepare_file_append create=true` → `apply_file_modification`。
 
@@ -136,7 +137,7 @@ updated: 2026-01-24
 > - `occurrence: ""` 或 `0`：不指定 occurrence。
 > - `match: ""`：使用默认 `contains`（注意：`match` 是 match mode，不是要匹配的文本/正则）。
 > - `read_file({ range: "", max_lines: 0 })`：分别表示"不指定范围 / 使用默认 500 行"。
-> - `overwrite_entire_file({ content_format: "" })`：表示"未显式声明内容格式"（此时若正文强特征疑似 diff/patch 将默认拒绝写入）。
+> - `overwrite_entire_file({ content_format: "" })`：表示"未显式声明内容格式"（此时若正文强特征疑似 diff/patch 将默认拒绝写入）；若显式提供任意非空标签（例如 `yaml`），工具会原样接受，但只有 `diff` / `patch` 具有放行 diff/patch 字面量的特殊语义。
 > - `ripgrep_*({ path: "", case: "", max_files: 0, max_results: 0 })`：分别表示"默认路径 '.' / 默认 smart-case / 使用默认上限"。
 
 ## 7. 规范化策略（当前实现）

package/dist/llm/kernel-driver/drive.js

@@ -253,7 +253,7 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
     {
         type: 'func',
         name: 'tellaskSessionless',
-        description: 'Create a one-shot teammate sideline dialog.',
+        description: 'Create a one-shot teammate sideline dialog with no assignment-update channel; later tellaskSessionless calls create new dialogs rather than updating or stopping this one.',
         parameters: {
             type: 'object',
             properties: {
@@ -637,6 +637,7 @@ async function emitAssistantSaying(dlg, content) {
     await dlg.sayingFinish();
 }
 function buildPromptContentWithExactReplyToolName(args) {
+    const isFbrSubdialog = args.dlg instanceof dialog_1.SubDialog && args.dlg.assignmentFromSup.callName === 'freshBootsReasoning';
     const noActivePrefix = args.language === 'zh'
         ? '[Dominds 当前无跨对话回复义务]'
         : '[Dominds no active inter-dialog reply]';
@@ -644,6 +645,9 @@ function buildPromptContentWithExactReplyToolName(args) {
     const reminderPrefixes = ['[Dominds replyTellask required]', '[Dominds 必须调用回复工具]'];
     const directive = args.activeReplyDirective;
     if (!directive) {
+        if (isFbrSubdialog) {
+            return args.prompt.content;
+        }
         if (!(args.dlg instanceof dialog_1.SubDialog)) {
             return args.prompt.content;
         }
@@ -686,11 +690,47 @@ function buildPromptContentWithExactReplyToolName(args) {
 function isReplyTellaskCallName(name) {
     return (name === 'replyTellask' || name === 'replyTellaskSessionless' || name === 'replyTellaskBack');
 }
+function isToolArgumentsObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function prepareFuncCallArguments(argumentsStr) {
+    if (argumentsStr.trim() === '') {
+        return {
+            ok: true,
+            raw: {},
+            contextArguments: '{}',
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(argumentsStr);
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: `Arguments must be valid JSON: ${err instanceof Error ? err.message : String(err)}`,
+            contextArguments: '{}',
+        };
+    }
+    if (!isToolArgumentsObject(parsed)) {
+        return {
+            ok: false,
+            error: 'Arguments must be an object',
+            contextArguments: '{}',
+        };
+    }
+    return {
+        ok: true,
+        raw: parsed,
+        contextArguments: argumentsStr,
+    };
+}
 async function executeFunctionCalls(args) {
     const functionPromises = args.funcCalls.map(async (func) => {
         throwIfAborted(args.abortSignal, args.dlg);
         const callGenseq = func.genseq;
         const argsStr = typeof func.arguments === 'string' ? func.arguments : JSON.stringify(func.arguments ?? {});
+        const preparedArgs = prepareFuncCallArguments(argsStr);
         const tool = args.agentTools.find((t) => t.type === 'func' && t.name === func.name);
         if (!tool) {
             const errorResult = {
@@ -704,25 +744,38 @@ async function executeFunctionCalls(args) {
             await args.dlg.receiveFuncResult(errorResult);
             return errorResult;
         }
-        let rawArgs = {};
-        if (typeof func.arguments === 'string' && func.arguments.trim()) {
-            try {
-                rawArgs = JSON.parse(func.arguments);
-            }
-            catch (parseErr) {
-                rawArgs = null;
-                log_1.log.warn('kernel-driver failed to parse function arguments as JSON', undefined, {
-                    funcName: func.name,
-                    arguments: func.arguments,
-                    error: parseErr,
-                });
-            }
-        }
         let result;
-        const argsValidation = (0, runtime_1.validateFuncToolArguments)(tool, rawArgs);
-        if (argsValidation.ok) {
+        if (!preparedArgs.ok) {
+            log_1.log.warn('kernel-driver rejected function call arguments before execution', undefined, {
+                funcName: func.name,
+                arguments: argsStr,
+                error: preparedArgs.error,
+            });
+            result = {
+                type: 'func_result_msg',
+                id: func.id,
+                name: func.name,
+                content: `Invalid arguments: ${preparedArgs.error}`,
+                role: 'tool',
+                genseq: callGenseq,
+            };
+        }
+        else {
+            const argsValidation = (0, runtime_1.validateFuncToolArguments)(tool, preparedArgs.raw);
+            if (!argsValidation.ok) {
+                result = {
+                    type: 'func_result_msg',
+                    id: func.id,
+                    name: func.name,
+                    content: `Invalid arguments: ${argsValidation.error}`,
+                    role: 'tool',
+                    genseq: callGenseq,
+                };
+                await args.dlg.receiveFuncResult(result);
+                return result;
+            }
             const argsObj = argsValidation.args;
-            await args.dlg.funcCallRequested(func.id, func.name, argsStr);
+            await args.dlg.funcCallRequested(func.id, func.name, preparedArgs.contextArguments);
             await args.dlg.persistFunctionCall(func.id, func.name, argsObj, callGenseq);
             try {
                 throwIfAborted(args.abortSignal, args.dlg);
@@ -759,16 +812,6 @@ async function executeFunctionCalls(args) {
                 }
             }
         }
-        else {
-            result = {
-                type: 'func_result_msg',
-                id: func.id,
-                name: func.name,
-                content: `Invalid arguments: ${argsValidation.error}`,
-                role: 'tool',
-                genseq: callGenseq,
-            };
-        }
         await args.dlg.receiveFuncResult(result);
         return result;
     });
@@ -899,14 +942,15 @@ async function executeFunctionRound(args) {
     }
     const pairedMessages = [];
     for (const call of args.funcCalls) {
-        const argsStr = typeof call.arguments === 'string' ? call.arguments : JSON.stringify(call.arguments ?? {});
+        const originalArgsStr = typeof call.arguments === 'string' ? call.arguments : JSON.stringify(call.arguments ?? {});
+        const preparedArgs = prepareFuncCallArguments(originalArgsStr);
         pairedMessages.push({
             type: 'func_call_msg',
             role: 'assistant',
             genseq: call.genseq,
             id: call.id,
             name: call.name,
-            arguments: argsStr,
+            arguments: preparedArgs.contextArguments,
         });
         const result = resultByCallId.get(call.id);
         if (result) {

package/dist/minds/system-prompt.js

@@ -6,32 +6,35 @@ const inter_dialog_format_1 = require("../runtime/inter-dialog-format");
 function formatTeamIntro(team, selfAgentId, language) {
     const callSignLabel = language === 'zh' ? '呼号' : 'Call Sign';
     const selfSuffix = language === 'zh' ? '（本人）' : ' (self)';
-    const focusLabel = language === 'zh' ? '关注' : 'Focus';
+    const goforLabel = language === 'zh' ? '对于以下事项应该找祂' : 'Go to them for';
+    const nogoLabel = language === 'zh' ? '对于以下事项不要找祂' : 'Do not go to them for';
     const visibleMembers = Object.values(team.members).filter((m) => m.hidden !== true);
     if (visibleMembers.length === 0) {
         return language === 'zh' ? '-（无可见队友）' : '- (no visible teammates)';
     }
+    const formatRoutingCard = (label, card) => {
+        if (card === undefined)
+            return '';
+        if (typeof card === 'string')
+            return `\n  - ${label}:\n    - ${card}`;
+        if (Array.isArray(card)) {
+            if (card.length === 0)
+                return '';
+            const list = card.map((t) => `    - ${t}`).join('\n');
+            return `\n  - ${label}:\n${list}`;
+        }
+        const entries = Object.entries(card);
+        if (entries.length === 0)
+            return '';
+        const list = entries.map(([k, v]) => `    - ${k}: ${v}`).join('\n');
+        return `\n  - ${label}:\n${list}`;
+    };
     return visibleMembers
         .map((m) => {
         const isSelf = m.id === selfAgentId ? selfSuffix : '';
-        const gofor = (() => {
-            if (m.gofor === undefined)
-                return '';
-            if (typeof m.gofor === 'string')
-                return `\n  - ${focusLabel}:\n    - ${m.gofor}`;
-            if (Array.isArray(m.gofor)) {
-                if (m.gofor.length === 0)
-                    return '';
-                const list = m.gofor.map((t) => `    - ${t}`).join('\n');
-                return `\n  - ${focusLabel}:\n${list}`;
-            }
-            const entries = Object.entries(m.gofor);
-            if (entries.length === 0)
-                return '';
-            const list = entries.map(([k, v]) => `    - ${k}: ${v}`).join('\n');
-            return `\n  - ${focusLabel}:\n${list}`;
-        })();
-        return `- ${callSignLabel}: @${m.id}${isSelf} - ${m.name}${gofor}`;
+        const gofor = formatRoutingCard(goforLabel, m.gofor);
+        const nogo = formatRoutingCard(nogoLabel, m.nogo);
+        return `- ${callSignLabel}: @${m.id}${isSelf} - ${m.name}${gofor}${nogo}`;
     })
         .join('\n');
 }
@@ -94,7 +97,9 @@ function buildTeammateTellaskPhaseContract(language) {
             '- 队友诉请必须遵循“发起 → 等待 → 判定 → 续推”四段协议：若目标未达成，立即发出下一轮诉请推进。',
             '- 对队友诉请而言，收到回贴即表示该轮调用已结束；不存在“回贴已送达后，对方仍在后台继续执行同一诉请”的默认语义。要继续必须显式再发一轮诉请函数（通常 `tellask` 复用同一 `sessionSlug`）。',
             '- 若被诉请者在回贴送达前因 `clear_mind` 开启新一程，同一进行中诉请默认继续有效；新一程会自然承接，直到产生回贴或明确失败。不要仅因对方换程就把该轮诉请当作失效重发。',
-            '- 只有在存在明确进行中诉请时，才可声明“等待回贴/等待结果”（通常应可在“⏳ 进行中诉请（共 N 路，自动添加，手动删除）”这类提醒项中观测到）；若该提醒项不存在，或提醒项已明确“当前没有执行中的诉请”，则“等待”是错误动作，必须执行下一动作（直接诉请或本地执行）。',
+            '- 只有在存在明确进行中诉请时，才可声明“等待回贴/等待结果”（通常应可在“⏳ 进行中诉请（共 N 路，自动维护；仅 0 路时可手动删除）”这类提醒项中观测到）；若该提醒项不存在，或提醒项已明确“当前没有执行中的诉请”，则“等待”是错误动作，必须执行下一动作（直接诉请或本地执行）。',
+            '- “⏳ 进行中诉请”提醒项只是系统状态窗，不是控制面：内容不可手改；当存在非 0 路进行中诉请时，不可删除，误删会被拒绝并返回引导文案。若某一路诉请需要改要求、提前收口或纠偏，只能更新那一路诉请的“任务安排”（对长线诉请通常复用同一 `sessionSlug` 再发 `tellask`），让对应主理人按最新安排自行最终回复并自然结束。',
+            '- 只有长线诉请（`tellask` + `sessionSlug`）才有“更新任务安排”的通道；一次性诉请（`tellaskSessionless`）没有这个通道。再次发起 `tellaskSessionless` 只会创建新的瞬态支线，不会更新、更不会要求旧支线主理人停止；若你后来发现可能需要改要求/提前收口，一开始就不该选择 `tellaskSessionless`。',
             '- 能由队友诉请完成的执行性工作，禁止转交 `askHuman` 做“转发员”；当你写“让 @X 执行 Y”时，必须在同一回复内直接发出 `tellask` 或 `tellaskSessionless`。',
             `- 当你在诉请正文里定义“回贴格式/交付格式”时，必须明确写入：\`Dominds 会自动注入回贴标记，禁止手写标记\`；不得要求被诉请者手写 \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR 标记（\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`）。`,
             '- 当你处于队友诉请触发的支线且需要澄清时，必须使用 `tellaskBack` 回问上游诉请者；`tellaskBack` 不携带 `sessionSlug`。',
@@ -104,7 +109,9 @@ function buildTeammateTellaskPhaseContract(language) {
             '- 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 after the reply is already delivered” state for the same Tellask. To continue, emit a new Tellask function call explicitly (usually `tellask` with the same `sessionSlug`).',
             '- If the callee starts a new course via `clear_mind` before delivering the reply, the same in-flight Tellask stays live by default; the new course naturally continues it until a reply is delivered or an explicit failure is returned. Do not re-tellask solely because the callee changed course.',
-            '- You may claim “waiting for reply/result” only when a concrete pending Tellask exists (normally observable in a “⏳ In-flight Tellasks (N total, auto-added, manually deleted)” reminder). If that reminder is absent, or it explicitly states there are no in-flight Tellasks, waiting is a wrong action; execute the next action now (direct Tellask or local action).',
+            '- You may claim “waiting for reply/result” only when a concrete pending Tellask exists (normally observable in a “⏳ In-flight Tellasks (N total, auto-maintained; manually deletable only at zero in-flight)” reminder). If that reminder is absent, or it explicitly states there are no in-flight Tellasks, waiting is a wrong action; execute the next action now (direct Tellask or local action).',
+            '- The “⏳ In-flight Tellasks” reminder is only a system status window, not a control surface: its content is not hand-editable; while any Tellask is still active, it is not deletable, and mistaken deletion will be rejected with guidance. If one Tellask needs a changed scope, earlier closure, or correction, update that Tellask’s assignment instead (for a sessioned Tellask, usually send another `tellask` with the same `sessionSlug`) so the responder can deliver a final reply naturally under the latest assignment.',
+            '- Only a sessioned Tellask (`tellask` + `sessionSlug`) has an assignment-update channel. A one-shot Tellask (`tellaskSessionless`) has no such channel: another `tellaskSessionless` creates a new transient sideline and does not update, stop, or instruct the earlier one to stop. If you may need later correction or earlier wrap-up, do not choose `tellaskSessionless` in the first place.',
             '- Do not use `askHuman` as a relay for executable teammate work. If you write “ask @X to do Y”, emit `tellask` or `tellaskSessionless` in the same response.',
             `- When you define a “reply/delivery format” inside tellask body, you must explicitly include: \`Dominds auto-injects reply markers; do not hand-write markers\`; do not require the responder to hand-write \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR markers (\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`).`,
             '- When you are in a teammate-triggered sideline and need clarification, you MUST issue `tellaskBack` to ask back upstream; `tellaskBack` must not carry `sessionSlug`.',
@@ -187,12 +194,12 @@ function buildTellaskCollaborationProtocol(language, dialogScope) {
         ...pickLocalized(language, {
             zh: [
                 '- Tellask 统一走函数工具通道：`tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman` / `freshBootsReasoning`。',
-                '- 对队友诉请默认使用 `tellask` 并复用 `sessionSlug`；仅在确认一次性诉请足够时才使用 `tellaskSessionless`，且需说明理由。',
+                '- 对队友诉请默认使用 `tellask` 并复用 `sessionSlug`；仅在确认一次性诉请足够、且后续不需要更新任务安排/提前收口时才使用 `tellaskSessionless`，并需说明理由。',
                 '- 例外优先级（强制）：`tellaskBack` 仅用于回问上游诉请者，不适用队友长线默认规则，也不携带 `sessionSlug`。',
             ],
             en: [
                 '- Tellask must use the function-tool channel: `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman` / `freshBootsReasoning`.',
-                '- For teammate tellasks, default to `tellask` and continue with the same `sessionSlug`; use `tellaskSessionless` only for justified one-shot calls.',
+                '- For teammate tellasks, default to `tellask` and continue with the same `sessionSlug`; use `tellaskSessionless` only when a one-shot is truly sufficient and later assignment updates / early wrap-up are not needed.',
                 '- Mandatory exception precedence: `tellaskBack` is ask-back-only and outside the teammate-session default; it does not carry `sessionSlug`.',
             ],
         }),
@@ -257,14 +264,14 @@ function buildTellaskInteractionRules(language) {
         zh: [
             '- `tellaskBack`：仅用于支线回问上游诉请者。',
             '- `tellask`：用于可恢复的长线诉请（必须提供 `targetAgentId` / `sessionSlug` / `tellaskContent`）。',
-            '- `tellaskSessionless`：用于一次性诉请（必须提供 `targetAgentId` / `tellaskContent`）。',
+            '- `tellaskSessionless`：用于一次性诉请（必须提供 `targetAgentId` / `tellaskContent`）；它不会建立可更新的任务安排通道，后续再次调用只会新开支线，不会影响旧支线继续执行。',
             '- `askHuman`：用于 Q4H（向人类请求必要澄清/决策/授权/缺失输入）。',
             '- `freshBootsReasoning`：用于发起扪心自问（FBR）支线（`tellaskContent` 必填，`effort` 可选）。',
         ],
         en: [
             '- `tellaskBack`: ask back upstream from a sideline dialog only.',
             '- `tellask`: resumable tellask (requires `targetAgentId` / `sessionSlug` / `tellaskContent`).',
-            '- `tellaskSessionless`: one-shot tellask (requires `targetAgentId` / `tellaskContent`).',
+            '- `tellaskSessionless`: one-shot tellask (requires `targetAgentId` / `tellaskContent`); it does not create an assignment-update channel, and later calls create new sidelines instead of affecting the earlier one.',
             '- `askHuman`: Q4H for necessary clarification/decision/authorization/missing input.',
             '- `freshBootsReasoning`: starts an FBR sideline dialog (requires `tellaskContent`, optional `effort`).',
         ],

package/dist/problems.js

@@ -138,6 +138,8 @@ function problemPayloadEqual(a, b) {
         a.severity === b.severity &&
         a.source === b.source &&
         a.message === b.message &&
+        JSON.stringify(a.messageI18n) === JSON.stringify(b.messageI18n) &&
+        JSON.stringify(a.detailTextI18n) === JSON.stringify(b.detailTextI18n) &&
         JSON.stringify(a.detail) === JSON.stringify(b.detail));
 }
 function problemRecordsEqual(a, b) {

package/dist/runtime/driver-messages.js

@@ -157,6 +157,10 @@ function formatReminderItemGuide(language, index, content, options) {
     // to keep reminder ownership/management loosely coupled and extensible.
     const metaValue = options && 'meta' in options ? options.meta : undefined;
     const isContinuationPackageReminder = isRecord(metaValue) && metaValue['kind'] === 'continuation_package';
+    const isPendingTellaskReminder = isRecord(metaValue) && metaValue['kind'] === 'pending_tellask';
+    const pendingTellaskCount = isPendingTellaskReminder && typeof metaValue['pendingCount'] === 'number'
+        ? metaValue['pendingCount']
+        : undefined;
     const managerValue = isRecord(metaValue) ? metaValue['manager'] : undefined;
     const managementTool = isRecord(managerValue) && typeof managerValue['tool'] === 'string'
         ? managerValue['tool'].trim()
@@ -177,10 +181,14 @@ function formatReminderItemGuide(language, index, content, options) {
     const deleteInstruction = language === 'zh'
         ? deleteAltInstruction
             ? `如果我要删除这条提醒项，不能用 delete_reminder；请执行：${deleteAltInstruction}`
-            : `如果我要删除这条提醒项，可执行：delete_reminder({ "reminder_no": ${index} })`
+            : isPendingTellaskReminder && pendingTellaskCount === 0
+                ? `如果我已确认这里只是清理噪音、并非要推进动作，可执行：delete_reminder({ "reminder_no": ${index} })`
+                : `如果我要删除这条提醒项，可执行：delete_reminder({ "reminder_no": ${index} })`
         : deleteAltInstruction
             ? `If I need to delete this reminder, I must not use delete_reminder; run: ${deleteAltInstruction}`
-            : `If I need to delete this reminder, run: delete_reminder({ "reminder_no": ${index} })`;
+            : isPendingTellaskReminder && pendingTellaskCount === 0
+                ? `If I have confirmed this is only noise cleanup and not an action step, I may run: delete_reminder({ "reminder_no": ${index} })`
+                : `If I need to delete this reminder, run: delete_reminder({ "reminder_no": ${index} })`;
     if (language === 'zh') {
         if (managementTool) {
             const updateInstructionSafe = updateInstruction ?? `${managementTool}({ ... })`;

package/dist/server/api-routes.js

@@ -125,6 +125,10 @@ function parseDialogStatusKind(raw) {
     }
     return null;
 }
+async function detectWaitingForFreshBootsReasoning(dialogId, status) {
+    const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, status);
+    return pending.some((entry) => entry.callName === 'freshBootsReasoning');
+}
 function buildPrimingWarningSummary(warnings) {
     if (warnings.length === 0)
         return undefined;
@@ -1958,6 +1962,7 @@ async function handleGetTeamConfig(res) {
             provider: m.provider,
             model: m.model,
             gofor: m.gofor,
+            nogo: m.nogo,
             toolsets: m.toolsets,
             tools: m.tools,
             icon: m.icon,
@@ -1998,6 +2003,7 @@ async function handleGetDialogs(res, status) {
                 continue;
             // Load latest.yaml for currentCourse and lastModified timestamp
             const latest = await persistence_1.DialogPersistence.loadDialogLatest(new dialog_1.DialogID(id), status);
+            const waitingForFreshBootsReasoning = await detectWaitingForFreshBootsReasoning(new dialog_1.DialogID(id), status);
             // Count subdialogs for this root dialog
             const rootPath = persistence_1.DialogPersistence.getRootDialogPath(new dialog_1.DialogID(id), status);
             const subPath = path.join(rootPath, 'subdialogs');
@@ -2011,6 +2017,7 @@ async function handleGetDialogs(res, status) {
                 createdAt: meta.createdAt,
                 lastModified: latest?.lastModified || meta.createdAt,
                 displayState: latest?.displayState,
+                waitingForFreshBootsReasoning,
                 subdialogCount,
             });
         }
@@ -2099,6 +2106,7 @@ async function handleGetDialogHierarchy(res, rootId, status) {
             createdAt: rootMeta.createdAt,
             lastModified: rootLatest?.lastModified || rootMeta.createdAt,
             displayState: rootLatest?.displayState,
+            waitingForFreshBootsReasoning: await detectWaitingForFreshBootsReasoning(new dialog_1.DialogID(rootId), status),
         };
         let subdialogs = [];
         const dialogIds = await persistence_1.DialogPersistence.listAllDialogIds(status);
@@ -2111,6 +2119,7 @@ async function handleGetDialogHierarchy(res, rootId, status) {
                 continue;
             }
             const subLatest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, status);
+            const waitingForFreshBootsReasoning = await detectWaitingForFreshBootsReasoning(dialogId, status);
             const derivedSupdialogId = meta.assignmentFromSup?.callerDialogId &&
                 meta.assignmentFromSup.callerDialogId.trim() !== ''
                 ? meta.assignmentFromSup.callerDialogId
@@ -2130,6 +2139,7 @@ async function handleGetDialogHierarchy(res, rootId, status) {
                 displayState: subLatest?.displayState,
                 sessionSlug: meta.sessionSlug,
                 assignmentFromSup: meta.assignmentFromSup,
+                waitingForFreshBootsReasoning,
             });
         }
         respondJson(res, 200, {

package/dist/team.d.ts

@@ -60,7 +60,8 @@ export declare namespace Team {
         name: string;
         provider?: string;
         model?: string;
-        gofor?: string[] | Record<string, string>;
+        gofor?: string | string[] | Record<string, string>;
+        nogo?: string | string[] | Record<string, string>;
         toolsets?: string[];
         tools?: string[];
         model_params?: ModelParams;
@@ -84,7 +85,8 @@ export declare namespace Team {
             name: string;
             provider?: string;
             model?: string;
-            gofor?: string[] | Record<string, string>;
+            gofor?: string | string[] | Record<string, string>;
+            nogo?: string | string[] | Record<string, string>;
             toolsets?: string[];
             tools?: string[];
             model_params?: ModelParams;
@@ -107,7 +109,8 @@ export declare namespace Team {
         setName(name: string): void;
         setProvider(provider: string | undefined): void;
         setModel(model: string | undefined): void;
-        setGofor(gofor: string[] | Record<string, string> | undefined): void;
+        setGofor(gofor: string | string[] | Record<string, string> | undefined): void;
+        setNogo(nogo: string | string[] | Record<string, string> | undefined): void;
         setToolsets(toolsets: string[] | undefined): void;
         setTools(tools: string[] | undefined): void;
         setModelParams(modelParams: ModelParams | undefined): void;
@@ -147,7 +150,7 @@ export declare namespace Team {
     }): Promise<readonly string[]>;
     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", "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_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 ["max_tokens", "json_response", "general", "codex", "openai", "anthropic"];
     export const TEAM_YAML_MODEL_PARAMS_GENERAL_KEYS: readonly ["max_tokens"];
     export const TEAM_YAML_MODEL_PARAMS_OPENAI_KEYS: readonly ["temperature", "max_tokens", "service_tier", "top_p", "frequency_penalty", "presence_penalty", "seed", "logprobs", "top_logprobs", "stop", "logit_bias", "user", "reasoning_effort", "reasoning_summary", "verbosity", "parallel_tool_calls", "web_search", "json_response"];