dominds 1.23.8 → 1.23.10

package/dist/docs/dialog-system.md

@@ -396,8 +396,8 @@ Result (second call):
 
 - **No registry lookup** - always creates a new sideDialog
 - **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 sideDialog**; it does not update, stop, or tell the earlier Type C Side Dialog to stop
+- Cannot continue or change the earlier task like Type B can
+- Another `tellaskSessionless` is another independent task; it does not update or stop the earlier Type C task
 - If later correction, scope change, or earlier wrap-up may be needed, choose Type B `tellask` with `sessionSlug` from the start
 - The sideDialog 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

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

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

package/dist/docs/dominds-terminology.md

@@ -212,8 +212,8 @@ 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 Side Dialog; it does not update or tell the earlier one to stop.
-- ZH（操作后果）: 一次性诉请**没有任务安排更新通道**。再次发起 `tellaskSessionless` 只会新建另一条瞬态支线，不会更新、更不会要求先前那条支线停止。
+- EN (operational consequence): A Fresh Tellask cannot continue or change the earlier task. Another `tellaskSessionless` is another independent task; it does not update or stop the earlier one.
+- 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

@@ -35,9 +35,10 @@ These points reflect current behavior in `dialog-system.md`, `fbr.md`, and `dili
 
 Important addition:
 
-- Only `Tellask Session` has an assignment-update channel.
-- `Fresh Tellask` has no such channel; another `tellaskSessionless` only creates another transient Side Dialog and does not affect or tell the earlier owner to stop.
+- Only `Tellask Session` can continue the same task and update that task.
+- `Fresh Tellask` cannot continue or change an earlier task; another `tellaskSessionless` is another independent task and does not affect or stop the earlier task.
 - If later correction, earlier wrap-up, or scope change may be needed, do not choose `Fresh Tellask`; use `tellask` with `sessionSlug` from the start.
+- Do not treat an agent teammate like a human coworker who can only handle one conversation at a time. Same teammate + same `sessionSlug` = continue the same task and update that task; `tellaskSessionless` or a different `sessionSlug` = another independent task.
 
 ### 2.2 What `Tellask Session` really means
 
@@ -139,6 +140,7 @@ For teammate Tellasks (non-`freshBootsReasoning({ tellaskContent: "..." })`), al
 Hard rule:
 
 - You can only claim “waiting for result” if there is an explicit pending Tellask and known acceptance evidence.
+- If several independent tasks should go to the same teammate, do not queue them: send separate `tellaskSessionless` calls, or use different `sessionSlug` values with `tellask`.
 
 ### 4.2 Always continue via explicit re-Tellask
 

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

@@ -35,9 +35,10 @@
 
 关键补充：
 
-- 只有长线诉请有“更新任务安排”的通道。
-- 一次性诉请没有这个通道；后续再开一个 `tellaskSessionless` 只会创建新的瞬态支线，不会影响旧支线继续执行，更不能要求旧主理人停止。
+- 只有长线诉请能接着同一件事说、更新那件正在做的事。
+- 一次性诉请不能接着旧任务改要求；后续再开一个 `tellaskSessionless` 只是另一件独立任务，不会影响旧任务继续执行，更不能要求旧主理人停止。
 - 如果你后来可能需要改要求、提前收口或纠偏，就不该使用一次性诉请，而应从一开始就用带 `sessionSlug` 的长线诉请。
+- 不要把智能体队友当成真人同事：祂不会因为你又发一条诉请而被打扰。同一个队友 + 同一个 `sessionSlug` = 接着同一件事说，并更新那件正在做的事；`tellaskSessionless` 或不同 `sessionSlug` = 另一件独立任务。
 
 ### 2.2 长线诉请的真实语义
 
@@ -136,6 +137,7 @@
 
 - 任何“等待结果/等待回贴”表述，必须能指向**刚刚已发出的具体诉请**与**等待的验收证据**。
 - 若没有已发出的待回贴诉请，就不能写“等待”；应立刻发诉请或改为本地执行。
+- 若有多件独立工作要交给同一队友，不需要排队、不需要担心打扰：分别发起 `tellaskSessionless`，或用不同 `sessionSlug` 发起 `tellask`。
 
 ### 4.2 续推时必须显式“再诉请”
 

package/dist/llm/defaults.yaml

@@ -484,6 +484,9 @@ providers:
           min: 0
           max: 1
           description: Nucleus sampling parameter.
+        parallel_tool_calls:
+          type: boolean
+          description: Allow the model to emit parallel tool calls.
     models:
       kimi-for-coding:
         name: Kimi For Coding

package/dist/llm/gen/codex.js

@@ -263,8 +263,23 @@ function extractReasoningPayload(item) {
         reasoning.content = content;
     if (encrypted)
         reasoning.encrypted_content = encrypted;
+    const hasReasoningData = summary.length > 0 || (content?.length ?? 0) > 0 || encrypted !== undefined;
+    if (hasReasoningData) {
+        reasoning.metadata = {
+            itemType: item.type,
+        };
+        if (typeof item.id === 'string' && item.id.length > 0) {
+            reasoning.metadata.itemId = item.id;
+        }
+    }
     return reasoning;
 }
+function hasReasoningPayloadSignals(payload) {
+    return (payload.summary.length > 0 ||
+        (payload.content?.length ?? 0) > 0 ||
+        (payload.encrypted_content?.length ?? 0) > 0 ||
+        payload.metadata !== undefined);
+}
 function buildReasoningPayloadFromText(text) {
     if (text.trim().length === 0)
         return undefined;
@@ -932,7 +947,7 @@ class CodexGen {
                                     : sawReasoningDeltaWithoutItemId;
                                 if (!sawReasoningDelta) {
                                     const text = extractReasoningText(event.item);
-                                    if (text.length > 0) {
+                                    if (text.length > 0 || hasReasoningPayloadSignals(payloadFromItem)) {
                                         if (activeStream === 'saying') {
                                             const detail = 'CODEX stream overlap violation: received reasoning while saying stream still active';
                                             log.error(detail, new Error('codex_stream_overlap_violation'));
@@ -951,9 +966,11 @@ class CodexGen {
                                             await receiver.thinkingStart();
                                             activeStream = 'thinking';
                                         }
-                                        currentThinkingContent += text;
-                                        await receiver.thinkingChunk(text);
-                                        await receiver.thinkingFinish(payloadFromItem ?? buildReasoningPayloadFromText(currentThinkingContent));
+                                        if (text.length > 0) {
+                                            currentThinkingContent += text;
+                                            await receiver.thinkingChunk(text);
+                                        }
+                                        await receiver.thinkingFinish(payloadFromItem);
                                         thinkingStarted = false;
                                         currentThinkingContent = '';
                                         if (activeStream === 'thinking')
@@ -961,12 +978,16 @@ class CodexGen {
                                     }
                                 }
                                 else if (thinkingStarted) {
-                                    await receiver.thinkingFinish(payloadFromItem ?? buildReasoningPayloadFromText(currentThinkingContent));
+                                    await receiver.thinkingFinish(payloadFromItem);
                                     thinkingStarted = false;
                                     currentThinkingContent = '';
                                     if (activeStream === 'thinking')
                                         activeStream = 'idle';
                                 }
+                                else if (hasReasoningPayloadSignals(payloadFromItem)) {
+                                    await receiver.thinkingStart();
+                                    await receiver.thinkingFinish(payloadFromItem);
+                                }
                                 return;
                             }
                             case 'local_shell_call':

package/dist/llm/gen/openai-compatible.js

@@ -117,8 +117,6 @@ function resolveOpenAiCompatibleParallelToolCalls(args) {
     if (args.openAiParams.parallel_tool_calls !== undefined) {
         return args.openAiParams.parallel_tool_calls;
     }
-    if (isKimiCodeProvider(args.providerConfig))
-        return undefined;
     return true;
 }
 function isOpenAiCompatibleSseCaptureEnabled() {

package/dist/llm/gen/openai.js

@@ -1135,8 +1135,28 @@ function extractReasoningPayload(item) {
         out.content = content;
     if (encrypted)
         out.encrypted_content = encrypted;
+    const hasReasoningData = summary.length > 0 || content.length > 0 || encrypted !== undefined;
+    if (hasReasoningData) {
+        const metadata = { itemType: item.type };
+        if (typeof item.id === 'string' && item.id.length > 0) {
+            metadata.itemId = item.id;
+        }
+        if (item.status === 'in_progress' ||
+            item.status === 'completed' ||
+            item.status === 'incomplete') {
+            metadata.status = item.status;
+        }
+        out.metadata = metadata;
+    }
     return out;
 }
+function hasReasoningPayloadSignals(payload) {
+    return (payload !== null &&
+        (payload.summary.length > 0 ||
+            (payload.content?.length ?? 0) > 0 ||
+            (payload.encrypted_content?.length ?? 0) > 0 ||
+            payload.metadata !== undefined));
+}
 function openAiResponseToBatchOutputs(response, genseq) {
     const outputs = [];
     const output = response.output;
@@ -1149,7 +1169,7 @@ function openAiResponseToBatchOutputs(response, genseq) {
         if (item.type === 'reasoning') {
             const reasoning = extractReasoningPayload(item);
             const content = extractReasoningText(item);
-            if (content.length > 0 || reasoning !== null) {
+            if (content.length > 0 || hasReasoningPayloadSignals(reasoning)) {
                 outputs.push({
                     kind: 'message',
                     message: {
@@ -1157,7 +1177,7 @@ function openAiResponseToBatchOutputs(response, genseq) {
                         role: 'assistant',
                         genseq,
                         content,
-                        reasoning: reasoning ?? undefined,
+                        ...(reasoning !== null ? { reasoning } : {}),
                     },
                 });
             }
@@ -1655,6 +1675,7 @@ class OpenAiGen {
                             const sawReasoningDelta = itemId !== null
                                 ? streamedReasoningItemIds.has(itemId)
                                 : sawReasoningDeltaWithoutItemId;
+                            const payload = extractReasoningPayload(item);
                             if (sawReasoningDelta) {
                                 if (itemId !== null) {
                                     streamedReasoningItemIds.delete(itemId);
@@ -1662,9 +1683,20 @@ class OpenAiGen {
                                 else {
                                     sawReasoningDeltaWithoutItemId = false;
                                 }
+                                if (thinkingStarted) {
+                                    await receiver.thinkingFinish(payload ?? buildReasoningPayloadFromText(currentThinkingContent));
+                                    thinkingStarted = false;
+                                    currentThinkingContent = '';
+                                    if (activeStream === 'thinking')
+                                        activeStream = 'idle';
+                                    break;
+                                }
+                                if (hasReasoningPayloadSignals(payload)) {
+                                    await receiver.thinkingStart();
+                                    await receiver.thinkingFinish(payload);
+                                }
                                 break;
                             }
-                            const payload = extractReasoningPayload(item);
                             const text = extractReasoningText(item);
                             if (thinkingStarted) {
                                 if (currentThinkingContent.length === 0 && text.length > 0) {
@@ -1678,7 +1710,7 @@ class OpenAiGen {
                                     activeStream = 'idle';
                                 break;
                             }
-                            if (text.length > 0 || payload !== null) {
+                            if (text.length > 0 || hasReasoningPayloadSignals(payload)) {
                                 if (activeStream === 'saying') {
                                     if (sayingStarted) {
                                         await receiver.sayingFinish();

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

@@ -431,7 +431,7 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
     {
         type: 'func',
         name: 'tellask',
-        description: 'Create or resume a teammate Side Dialog with sessionSlug.',
+        description: 'Ask a teammate to work on a task. Same targetAgentId + same sessionSlug continues the same task and updates it; a different sessionSlug is another independent task and will not affect other work for that teammate.',
         parameters: {
             type: 'object',
             properties: {
@@ -449,7 +449,7 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
     {
         type: 'func',
         name: 'tellaskSessionless',
-        description: 'Create a one-shot teammate Side Dialog with no assignment-update channel; later tellaskSessionless calls create new dialogs rather than updating or stopping this one.',
+        description: 'Ask a teammate to do a one-shot independent task. It does not update, affect, or stop earlier tasks.',
         parameters: {
             type: 'object',
             properties: {

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

@@ -3,10 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.emitThinkingEvents = emitThinkingEvents;
 exports.emitSayingEvents = emitSayingEvents;
 async function emitThinkingEvents(dlg, content, reasoning) {
-    if (!content.trim())
-        return undefined;
+    const hasContent = content.trim().length > 0;
+    if (!hasContent && reasoning === undefined)
+        return;
     await dlg.thinkingStart();
-    await dlg.thinkingChunk(content);
+    if (hasContent) {
+        await dlg.thinkingChunk(content);
+    }
     await dlg.thinkingFinish(reasoning);
 }
 async function emitSayingEvents(dlg, content) {

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

@@ -196,7 +196,7 @@ function getMemoryPromptCopy(ctx) {
                 ? `你当前处于支线对话：此处不允许 \`do_mind\` / \`mind_more\` / \`change_mind\` / \`never_mind\`。当你判断需要更新差遣牒（尤其是 progress 公告牌）时，请在合适时机直接诉请差遣牒维护人 \`@${ctx.taskdocMaintainerId}\` 执行更新，并给出要新增的章节、要追加的条目、已合并好的“新全文/替换稿”，或要删除的章节。不要声称已更新，除非看到回执。`
                 : '你当前处于支线对话，且上下文已进入吃紧/告急处置态：本程不要维护差遣牒，也不要整理差遣牒更新提案。请把下一程需要恢复的讨论细节、定位、验证方式和临时信息写入足够详尽的接续包提醒项。',
             mainDialogDutyLine: '你当前处于主线对话：你负责综合维护全队共享差遣牒（尤其是 progress 公告牌）。当队友/支线对话提出更新建议时，及时合并、压缩并保持清晰。',
-            teammateTellaskRoundDoneLine: `队友诉请重要语义：当你在诉请者上下文中收到带${runtimeMarkers.finalCompleted}标记的回贴，表示该轮诉请已经结束；对方不会继续执行同一轮诉请。此时如果目标未达成，“等待”是错误的：必须显式发起新一轮 tellask 才能继续推进。`,
+            teammateTellaskRoundDoneLine: `队友诉请重要语义：当你在诉请者上下文中收到带${runtimeMarkers.finalCompleted}标记的回贴，表示该轮诉请已经结束；对方不会继续执行同一轮诉请。此时如果目标未达成，“等待”是错误的：必须显式发起新一轮 tellask 才能继续推进。并行语义：不要把智能体队友当成真人同事；祂不会因为你又发一条诉请而被打扰。同一个队友 + 同一个 sessionSlug = 接着同一件事说，并更新那件正在做的事；tellaskSessionless 或不同 sessionSlug = 另一件独立任务。`,
             teamMemoryHintLine: '提示：你具备团队记忆工具（`add_team_memory` / `replace_team_memory` / `drop_team_memory` / `clear_team_memory`），可在必要时维护团队记忆（谨慎、少量、只写稳定约定）。',
             personalMemoryHintLine: `提示：你具备个人记忆工具（\`add_personal_memory\` / \`replace_personal_memory\` / \`drop_personal_memory\` / \`clear_personal_memory\`）。个人记忆仅对当前智能体可见，且系统会自动按成员隔离到 \`.minds/memory/individual/<member-id>/...\`；因此 \`path\` 不应包含你的成员 id（不要写 \`${ctx.agentId}/...\`）。首次创建时直接用 \`add_personal_memory\` 即可，目录会由系统自动创建。记忆会在每次生成时自动注入上下文：保持少量、保持准确、按“未来会一起更新的内容”合并；写稳定事实（关键路径 + 最小必要约定），不要写任务进度/当天状态；一旦你修改了相关文件或发现记忆过期/冲突，立刻用 \`replace_personal_memory\` 更新。`,
             sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'
@@ -230,7 +230,7 @@ function getMemoryPromptCopy(ctx) {
             ? `You are currently in a Side Dialog: \`do_mind\` / \`mind_more\` / \`change_mind\` / \`never_mind\` are not allowed here. When Taskdoc should be updated (especially the shared progress bulletin board), tellask the Taskdoc maintainer \`@${ctx.taskdocMaintainerId}\` with the new section to create, entries to append, a fully merged replacement draft, or the section to delete. Do not claim it is updated until you see a receipt.`
             : 'You are currently in a Side Dialog under caution/critical context-health remediation: do not maintain Taskdoc and do not draft Taskdoc update proposals in this course. Put discussion details, pointers, verification method, and volatile resume information into sufficiently detailed continuation-package reminders.',
         mainDialogDutyLine: 'You are currently in the Main Dialog: you are responsible for keeping the team-shared Taskdoc coherent and up to date (especially the progress bulletin board). Merge proposals from teammates/Side Dialogs promptly and keep it concise.',
-        teammateTellaskRoundDoneLine: `Teammate Tellask semantics: when you receive a tellasker reply with the ${runtimeMarkers.finalCompleted} marker, that Tellask round is finished; the tellaskee will not keep executing the same call in the background. If the objective is not met, “waiting” is wrong: you must explicitly start a new Tellask round to continue.`,
+        teammateTellaskRoundDoneLine: `Teammate Tellask semantics: when you receive a tellasker reply with the ${runtimeMarkers.finalCompleted} marker, that Tellask round is finished; the tellaskee will not keep executing the same call in the background. If the objective is not met, “waiting” is wrong: you must explicitly start a new Tellask round to continue. Parallel semantics: do not treat an agent teammate like a human coworker who can only handle one conversation at a time. Same teammate + same sessionSlug = continue the same task and update that task; tellaskSessionless or a different sessionSlug = another independent task.`,
         teamMemoryHintLine: 'Hint: you have team-memory tools (`add_team_memory` / `replace_team_memory` / `drop_team_memory` / `clear_team_memory`) and may maintain team memory when it is truly stable and worth sharing.',
         personalMemoryHintLine: `Hint: you have personal-memory tools (\`add_personal_memory\` / \`replace_personal_memory\` / \`drop_personal_memory\` / \`clear_personal_memory\`). Personal memory is private to the current agent and is automatically isolated under \`.minds/memory/individual/<member-id>/...\`; therefore \`path\` MUST NOT include your member id (do not write \`${ctx.agentId}/...\`). For first-time setup, just call \`add_personal_memory\`—the directory will be created automatically. Memory is automatically injected into context on each generation: keep it small, keep it accurate, and group facts that are updated together. Store stable facts (exact key paths + minimal contracts), not daily state/progress. If you changed those files or detect staleness/conflicts, immediately \`replace_personal_memory\` to keep it accurate.`,
         sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'

package/dist/minds/system-prompt.js

@@ -101,7 +101,8 @@ function buildTeammateTellaskPhaseContract(language) {
             '- 若被诉请者在回贴送达前因 `clear_mind` 开启新一程，同一进行中诉请默认继续有效；新一程会自然承接，直到产生回贴或明确失败。不要仅因对方换程就把该轮诉请当作失效重发。',
             '- 只有在存在明确进行中诉请时，才可声明“等待回贴/等待结果”（通常应可在“⏳ 进行中诉请（共 N 路，自动维护；仅 0 路时可手动删除）”这类提醒项中观测到）；若该提醒项不存在，或提醒项已明确“当前没有执行中的诉请”，则“等待”是错误动作，必须执行下一动作（直接诉请或本地执行）。',
             '- “⏳ 进行中诉请”提醒项只是系统状态窗，不是控制面：内容不可手改；当存在非 0 路进行中诉请时，不可删除，误删会被拒绝并返回引导文案。若某一路诉请需要改要求、提前收口或纠偏，只能更新那一路诉请的“任务安排”（对长线诉请通常复用同一 `sessionSlug` 再发 `tellask`），让对应主理人按最新安排自行最终回复并自然结束。',
-            '- 只有长线诉请（`tellask` + `sessionSlug`）才有“更新任务安排”的通道；一次性诉请（`tellaskSessionless`）没有这个通道。再次发起 `tellaskSessionless` 只会创建新的瞬态支线，不会更新、更不会要求旧支线主理人停止；若你后来发现可能需要改要求/提前收口，一开始就不该选择 `tellaskSessionless`。',
+            '- 只有长线诉请（`tellask` + `sessionSlug`）能接着同一件事说、更新同一件正在做的事；一次性诉请（`tellaskSessionless`）做不到。再次发起 `tellaskSessionless` 只是另一件独立任务，不会更新、更不会要求旧任务停止；若你后来发现可能需要改要求/提前收口，一开始就不该选择 `tellaskSessionless`。',
+            '- 不要把智能体队友当成真人同事：祂不会因为你又发一条诉请而被打扰。同一个队友可以同时做多件独立任务，系统会分开处理。记住这个简单规则：同一个队友 + 同一个 `sessionSlug` = 接着同一件事说，并更新那件正在做的事；`tellaskSessionless` 或不同 `sessionSlug` = 另一件独立任务。只要任务独立、目标清楚，就直接并行诉请。',
             '- 能由队友诉请完成的执行性工作，禁止转交 `askHuman` 做“转发员”；当你写“让 @X 执行 Y”时，必须在同一回复内直接发出 `tellask` 或 `tellaskSessionless`。',
             `- 当你在诉请正文里定义“回贴格式/交付格式”时，只写业务交付结构即可；不要要求被诉请者手写 \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR 标记（\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`），这些标记由 Dominds 运行时自动注入。`,
             '- 当你处于队友诉请触发的支线时，不要把“阻塞/不确定”默认等同于 `tellaskBack`：若按当前团队规程/SOP/职责卡已能明确判定执行负责人，直接用 `tellask` / `tellaskSessionless` 诉请对应负责人；只有确实需要诉请者补充需求、做裁决、澄清验收口径、提供缺失输入，或现有规程无法明确判责时，才使用 `tellaskBack`。`tellaskBack` 不携带 `sessionSlug`。',
@@ -113,7 +114,8 @@ function buildTeammateTellaskPhaseContract(language) {
             '- If the tellaskee 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 tellaskee 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-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 tellaskee 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 Side Dialog 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.',
+            '- Only a sessioned Tellask (`tellask` + `sessionSlug`) can continue the same task and update that task. A one-shot Tellask (`tellaskSessionless`) cannot: another `tellaskSessionless` is a separate task and does not update, stop, or instruct the earlier task to stop. If you may need later correction or earlier wrap-up, do not choose `tellaskSessionless` in the first place.',
+            '- Do not treat an agent teammate like a human coworker who can only handle one conversation at a time. The same teammate can work on several independent tasks at once, and the system keeps them separate. Simple rule: same teammate + same `sessionSlug` = continue the same task and update that task; `tellaskSessionless` or a different `sessionSlug` = another independent task. When tasks are independent and clear, tellask in parallel.',
             '- 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, keep it to the business delivery structure; do not require the tellaskee to hand-write \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR markers (\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`), because Dominds runtime injects those markers automatically.`,
             '- In a teammate-triggered Side Dialog, do not treat “blocked / uncertain” as an automatic `tellaskBack`: if current team SOP / role ownership already identifies the responsible executor, directly use `tellask` / `tellaskSessionless` for that owner; use `tellaskBack` only when you truly need the tellasker to clarify, decide, confirm acceptance criteria, provide missing input, or when existing SOP cannot determine ownership. `tellaskBack` must not carry `sessionSlug`.',
@@ -197,11 +199,13 @@ function buildTellaskCollaborationProtocol(language, dialogScope) {
             zh: [
                 '- Tellask 统一走函数工具通道：`tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman` / `freshBootsReasoning`。',
                 '- 对队友诉请默认使用 `tellask` 并复用 `sessionSlug`；仅在确认一次性诉请足够、且后续不需要更新任务安排/提前收口时才使用 `tellaskSessionless`，并需说明理由。',
+                '- 并行协调默认允许：不要把智能体队友当成真人同事；祂不会因为你又发一条诉请而被打扰。同一个队友 + 同一个 `sessionSlug` = 接着同一件事说；`tellaskSessionless` 或不同 `sessionSlug` = 另一件独立任务。',
                 '- 例外优先级（强制）：`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 when a one-shot is truly sufficient and later assignment updates / early wrap-up are not needed.',
+                '- Parallel coordination is allowed by default: do not treat an agent teammate like a human coworker who can only handle one conversation at a time. Same teammate + same `sessionSlug` = continue the same task; `tellaskSessionless` or a different `sessionSlug` = another independent task.',
                 '- Mandatory exception precedence: `tellaskBack` is ask-back-only and outside the teammate-session default; it does not carry `sessionSlug`.',
             ],
         }),
@@ -266,14 +270,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 to tellasker from a Side Dialog only.',
             '- `tellask`: resumable tellask (requires `targetAgentId` / `sessionSlug` / `tellaskContent`).',
-            '- `tellaskSessionless`: one-shot tellask (requires `targetAgentId` / `tellaskContent`); it does not create an assignment-update channel, and later calls create new Side Dialogs instead of affecting the earlier one.',
+            '- `tellaskSessionless`: one-shot tellask (requires `targetAgentId` / `tellaskContent`); it cannot continue an earlier task or change its requirements. Later calls are separate tasks and do not affect earlier work for the same teammate. Do not treat agent teammates like human coworkers who need you to wait in line to talk.',
             '- `askHuman`: Q4H for necessary clarification/decision/authorization/missing input.',
             '- `freshBootsReasoning`: starts an FBR Side Dialog (requires `tellaskContent`, optional `effort`).',
         ],

package/dist/persistence.d.ts

@@ -97,6 +97,7 @@ export declare class DiskFileDialogStore extends DialogStore {
     private sayingContent;
     private thinkingContent;
     private thinkingReasoning;
+    private thinkingStarted;
     sayingStart(dialog: Dialog): Promise<void>;
     sayingChunk(dialog: Dialog, chunk: string): Promise<void>;
     sayingFinish(dialog: Dialog): Promise<void>;

package/dist/persistence.js

@@ -1816,6 +1816,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         this.sayingContent = '';
         this.thinkingContent = '';
         this.thinkingReasoning = undefined;
+        this.thinkingStarted = false;
         this.dialogId = dialogId;
     }
     // === DialogStore interface methods ===
@@ -2261,6 +2262,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         // Reset thinking content tracker
         this.thinkingContent = '';
         this.thinkingReasoning = undefined;
+        this.thinkingStarted = true;
         const thinkingStartEvt = {
             type: 'thinking_start_evt',
             course,
@@ -2286,13 +2288,13 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         if (reasoning)
             this.thinkingReasoning = reasoning;
         const thinkingContent = this.thinkingContent;
-        if (thinkingContent || this.thinkingReasoning) {
+        if (this.thinkingStarted || thinkingContent || this.thinkingReasoning) {
             const thinkingMessageEvent = {
                 ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
                 type: 'agent_thought_record',
                 genseq: dialog.activeGenSeq,
                 content: thinkingContent,
-                reasoning: this.thinkingReasoning,
+                ...(this.thinkingReasoning !== undefined ? { reasoning: this.thinkingReasoning } : {}),
             };
             await this.appendEvent(dialog, course, thinkingMessageEvent);
         }
@@ -2300,8 +2302,10 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             type: 'thinking_finish_evt',
             course,
             genseq: dialog.activeGenSeq,
+            ...(this.thinkingReasoning !== undefined ? { reasoning: this.thinkingReasoning } : {}),
         };
         (0, evt_registry_1.postDialogEvent)(dialog, thinkingFinishEvt);
+        this.thinkingStarted = false;
     }
     async markdownStart(dialog) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
@@ -2805,8 +2809,8 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 type: 'agent_thought_record',
                 genseq,
                 content: content || '',
-                reasoning,
-                provider_data,
+                ...(reasoning !== undefined ? { reasoning } : {}),
+                ...(provider_data !== undefined ? { provider_data } : {}),
             }
             : {
                 ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
@@ -3319,43 +3323,26 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 break;
             }
             case 'agent_thought_record': {
-                // Replay thinking content as thinking events
+                // Replay persisted thinking records as substream boundaries, with chunks when content exists.
                 const content = event.content || '';
-                if (content) {
-                    // Start thinking phase
-                    const thinkingStartEvent = {
-                        type: 'thinking_start_evt',
-                        course,
-                        genseq: event.genseq,
-                        dialog: {
-                            selfId: dialog.id.selfId,
-                            rootId: dialog.id.rootId,
-                        },
-                        timestamp: event.ts,
-                    };
-                    if (ws.readyState === 1) {
-                        ws.send(JSON.stringify(thinkingStartEvent));
-                    }
-                    const thinkingChunks = this.createOptimalChunks(content);
-                    for (const chunk of thinkingChunks) {
-                        const thinkingChunkEvent = {
-                            type: 'thinking_chunk_evt',
-                            chunk,
-                            course,
-                            genseq: event.genseq,
-                            dialog: {
-                                selfId: dialog.id.selfId,
-                                rootId: dialog.id.rootId,
-                            },
-                            timestamp: event.ts,
-                        };
-                        if (ws.readyState === 1) {
-                            ws.send(JSON.stringify(thinkingChunkEvent));
-                        }
-                    }
-                    // Finish thinking phase
-                    const thinkingFinishEvent = {
-                        type: 'thinking_finish_evt',
+                const thinkingStartEvent = {
+                    type: 'thinking_start_evt',
+                    course,
+                    genseq: event.genseq,
+                    dialog: {
+                        selfId: dialog.id.selfId,
+                        rootId: dialog.id.rootId,
+                    },
+                    timestamp: event.ts,
+                };
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify(thinkingStartEvent));
+                }
+                const thinkingChunks = this.createOptimalChunks(content);
+                for (const chunk of thinkingChunks) {
+                    const thinkingChunkEvent = {
+                        type: 'thinking_chunk_evt',
+                        chunk,
                         course,
                         genseq: event.genseq,
                         dialog: {
@@ -3365,9 +3352,23 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                         timestamp: event.ts,
                     };
                     if (ws.readyState === 1) {
-                        ws.send(JSON.stringify(thinkingFinishEvent));
+                        ws.send(JSON.stringify(thinkingChunkEvent));
                     }
                 }
+                const thinkingFinishEvent = {
+                    type: 'thinking_finish_evt',
+                    course,
+                    genseq: event.genseq,
+                    ...(event.reasoning !== undefined ? { reasoning: event.reasoning } : {}),
+                    dialog: {
+                        selfId: dialog.id.selfId,
+                        rootId: dialog.id.rootId,
+                    },
+                    timestamp: event.ts,
+                };
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify(thinkingFinishEvent));
+                }
                 break;
             }
             case 'agent_words_record': {
@@ -6933,8 +6934,8 @@ class DialogPersistence {
                         role: 'assistant',
                         genseq: event.genseq,
                         content: event.content,
-                        reasoning: event.reasoning,
-                        provider_data: event.provider_data,
+                        ...(event.reasoning !== undefined ? { reasoning: event.reasoning } : {}),
+                        ...(event.provider_data !== undefined ? { provider_data: event.provider_data } : {}),
                     });
                     break;
                 }

package/dist/priming.js

@@ -440,11 +440,48 @@ function parseOptionalReasoningPayload(value, context) {
     if (encryptedContentRaw !== undefined && typeof encryptedContentRaw !== 'string') {
         throw new Error(`${context}.reasoning.encrypted_content must be a string when provided`);
     }
+    const metadataRaw = value['metadata'];
+    let metadata;
+    if (metadataRaw !== undefined) {
+        if (!isRecord(metadataRaw)) {
+            throw new Error(`${context}.reasoning.metadata must be an object when provided`);
+        }
+        const itemIdRaw = metadataRaw['itemId'];
+        if (itemIdRaw !== undefined && typeof itemIdRaw !== 'string') {
+            throw new Error(`${context}.reasoning.metadata.itemId must be a string when provided`);
+        }
+        const itemTypeRaw = metadataRaw['itemType'];
+        if (itemTypeRaw !== undefined && itemTypeRaw !== 'reasoning') {
+            throw new Error(`${context}.reasoning.metadata.itemType must be 'reasoning' when provided`);
+        }
+        const statusRaw = metadataRaw['status'];
+        if (statusRaw !== undefined &&
+            statusRaw !== 'in_progress' &&
+            statusRaw !== 'completed' &&
+            statusRaw !== 'incomplete') {
+            throw new Error(`${context}.reasoning.metadata.status must be in_progress|completed|incomplete when provided`);
+        }
+        metadata = {};
+        if (typeof itemIdRaw === 'string')
+            metadata.itemId = itemIdRaw;
+        if (itemTypeRaw === 'reasoning')
+            metadata.itemType = itemTypeRaw;
+        if (statusRaw === 'in_progress' || statusRaw === 'completed' || statusRaw === 'incomplete') {
+            metadata.status = statusRaw;
+        }
+        if (metadata.itemId === undefined &&
+            metadata.itemType === undefined &&
+            metadata.status === undefined) {
+            metadata = undefined;
+        }
+    }
     const reasoning = { summary };
     if (content !== undefined)
         reasoning.content = content;
     if (typeof encryptedContentRaw === 'string')
         reasoning.encrypted_content = encryptedContentRaw;
+    if (metadata !== undefined)
+        reasoning.metadata = metadata;
     return reasoning;
 }
 function parseOptionalStringArray(record, key, context) {
@@ -1979,8 +2016,8 @@ function primingRecordToChatMessage(record) {
                 role: 'assistant',
                 genseq: record.genseq,
                 content: record.content,
-                reasoning: record.reasoning,
-                provider_data: record.provider_data,
+                ...(record.reasoning !== undefined ? { reasoning: record.reasoning } : {}),
+                ...(record.provider_data !== undefined ? { provider_data: record.provider_data } : {}),
             };
         case 'agent_words_record':
             return {