dominds 1.18.2 → 1.19.2

package/dist/llm/kernel-driver/types.d.ts

@@ -1,23 +1,39 @@
 import type { DialogDisplayState, DialogInterruptionReason } from '@longrun-ai/kernel/types/display-state';
-import type { DialogDiligencePrompt, DialogPrompt, DialogRunControlSpec, DialogRuntimeGuidePrompt, DialogRuntimePrompt, DialogRuntimeReplyPrompt, DialogRuntimeSubdialogPrompt, DialogUserPrompt } from '@longrun-ai/kernel/types/drive-intent';
+import type { DialogDiligencePrompt, DialogPrompt, DialogRunControlSpec, DialogRuntimeGuidePrompt, DialogRuntimePrompt, DialogRuntimeReplyPrompt, DialogRuntimeSideDialogPrompt, DialogUserPrompt } from '@longrun-ai/kernel/types/drive-intent';
 import type { Dialog, DialogID } from '../../dialog';
 export type KernelDriverRunControl = DialogRunControlSpec;
-export type KernelDriverDriveSource = 'unspecified' | 'ws_user_message' | 'ws_user_answer' | 'ws_diligence_push' | 'ws_resume_dialog' | 'ws_resume_all' | 'kernel_driver_backend_loop' | 'kernel_driver_follow_up' | 'kernel_driver_subdialog_init' | 'kernel_driver_subdialog_resume' | 'kernel_driver_fbr_subdialog_round' | 'kernel_driver_type_a_supdialog_call' | 'kernel_driver_supply_response_parent_revive';
+export type KernelDriverDriveSource = 'unspecified' | 'ws_user_message' | 'ws_user_answer' | 'ws_diligence_push' | 'ws_resume_dialog' | 'ws_resume_all' | 'kernel_driver_backend_loop' | 'kernel_driver_follow_up' | 'kernel_driver_sideDialog_init' | 'kernel_driver_sideDialog_resume' | 'kernel_driver_fbr_sideDialog_round' | 'kernel_driver_type_a_askerDialog_call' | 'kernel_driver_supply_response_parent_revive';
 export type KernelDriverDriveOptions = Readonly<{
     suppressDiligencePush?: boolean;
     allowResumeFromInterrupted?: boolean;
-    noPromptSubdialogResumeEntitlement?: Readonly<{
+    noPromptSideDialogResumeEntitlement?: Readonly<{
         ownerDialogId: string;
-        reason: 'resolved_pending_subdialog_reply' | 'reply_tellask_back_delivered';
-        subdialogId?: string;
+        reason: 'reply_tellask_back_delivered';
+        sideDialogId?: string;
         callType?: 'A' | 'B' | 'C';
         callId?: string;
+    }> | Readonly<{
+        ownerDialogId: string;
+        reason: 'replaced_pending_sideDialog_reply';
+        sideDialogId?: string;
+        callType?: 'A' | 'B' | 'C';
+        callId?: string;
+    }> | Readonly<{
+        ownerDialogId: string;
+        reason: 'resolved_pending_sideDialog_reply';
+        sideDialogId?: string;
+        callType?: 'A' | 'B' | 'C';
+        callId?: string;
+        callSiteCourse: number;
+        callSiteGenseq: number;
+        resolvedCallIds?: readonly string[];
+        triggerCallId?: string;
     }>;
     runControl?: KernelDriverRunControl;
     source: KernelDriverDriveSource;
     reason: string;
 }>;
-export type KernelDriverSubdialogReplyTarget = {
+export type KernelDriverSideDialogReplyTarget = {
     ownerDialogId: string;
     callType: 'A' | 'B' | 'C';
     callId: string;
@@ -29,7 +45,7 @@ export type KernelDriverUserPrompt = KernelDriverPromptWithRunControl<DialogUser
 export type KernelDriverDiligencePrompt = KernelDriverPromptWithRunControl<DialogDiligencePrompt>;
 export type KernelDriverRuntimeGuidePrompt = KernelDriverPromptWithRunControl<DialogRuntimeGuidePrompt>;
 export type KernelDriverRuntimeReplyPrompt = KernelDriverPromptWithRunControl<DialogRuntimeReplyPrompt>;
-export type KernelDriverRuntimeSubdialogPrompt = KernelDriverPromptWithRunControl<DialogRuntimeSubdialogPrompt>;
+export type KernelDriverRuntimeSideDialogPrompt = KernelDriverPromptWithRunControl<DialogRuntimeSideDialogPrompt>;
 export type KernelDriverRuntimePrompt = KernelDriverPromptWithRunControl<DialogRuntimePrompt>;
 export type KernelDriverPrompt = KernelDriverPromptWithRunControl<DialogPrompt>;
 export type KernelDriverDriveCallOptions = Readonly<{
@@ -63,7 +79,7 @@ export type KernelDriverEmitSayingArgs = [dlg: Dialog, content: string];
 export type KernelDriverEmitSayingResult = Promise<void>;
 export type KernelDriverSupplyResponseArgs = [
     parentDialog: Dialog,
-    subdialogId: DialogID,
+    sideDialogId: DialogID,
     responseText: string,
     callType: 'A' | 'B' | 'C',
     callId?: string,
@@ -86,7 +102,7 @@ export type KernelDriverCoreResult = {
     lastAssistantSayingContent: string | null;
     lastAssistantSayingGenseq: number | null;
     lastFunctionCallGenseq: number | null;
-    lastAssistantReplyTarget?: KernelDriverSubdialogReplyTarget;
+    lastAssistantReplyTarget?: KernelDriverSideDialogReplyTarget;
     fbrConclusion?: {
         responseText: string;
         responseGenseq: number;

package/dist/mcp/config.d.ts

@@ -12,6 +12,7 @@ export type McpHeaderValue = {
 } | {
     kind: 'from_env';
     env: string;
+    prefix: string;
 };
 export type McpTransport = 'stdio' | 'streamable_http';
 type McpServerConfigBase = {

package/dist/mcp/config.js

@@ -168,9 +168,14 @@ function parseServerConfig(serverId, value) {
         const mapped = asRecord(v, `servers.${serverId}.headers.${k}`);
         const fromEnv = mapped.env;
         if (typeof fromEnv !== 'string' || !fromEnv.trim()) {
-            throw new Error(`Invalid mcp.yaml: servers.${serverId}.headers.${k} must be a string or { env: 'NAME' }`);
+            throw new Error(`Invalid mcp.yaml: servers.${serverId}.headers.${k} must be a string, { env: 'NAME' }, or { prefix: 'Bearer ', env: 'NAME' }`);
         }
-        headers[k] = { kind: 'from_env', env: fromEnv };
+        const prefixVal = mapped.prefix;
+        if (prefixVal !== undefined && typeof prefixVal !== 'string') {
+            throw new Error(`Invalid mcp.yaml: servers.${serverId}.headers.${k}.prefix must be a string`);
+        }
+        const prefix = prefixVal ?? '';
+        headers[k] = { kind: 'from_env', env: fromEnv, prefix };
     }
     const sessionIdVal = obj.sessionId;
     const sessionId = sessionIdVal === undefined

package/dist/mcp/supervisor.d.ts

@@ -1,3 +1,4 @@
+import type { McpStreamableHttpServerConfig } from './config';
 export type McpDeclaredServerRuntimeStatus = Readonly<{
     serverId: string;
     transport: 'stdio' | 'streamable_http' | 'invalid' | 'unknown';
@@ -31,3 +32,4 @@ export declare function requestMcpConfigReload(reason?: string): Promise<{
     ok: false;
     errorText: string;
 }>;
+export declare function buildHttpHeaders(cfg: McpStreamableHttpServerConfig, serverId: string): Record<string, string>;

package/dist/mcp/supervisor.js

@@ -41,6 +41,7 @@ exports.startMcpSupervisor = startMcpSupervisor;
 exports.stopMcpSupervisor = stopMcpSupervisor;
 exports.requestMcpServerRestart = requestMcpServerRestart;
 exports.requestMcpConfigReload = requestMcpConfigReload;
+exports.buildHttpHeaders = buildHttpHeaders;
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const fs = __importStar(require("fs"));
 const node_crypto_1 = require("node:crypto");
@@ -1417,7 +1418,7 @@ function buildHttpHeaders(cfg, serverId) {
                 if (val === undefined) {
                     throw new Error(`MCP server '${serverId}' missing required host env var '${v.env}' (for headers.${k})`);
                 }
-                headers[k] = val;
+                headers[k] = `${v.prefix}${val}`;
                 break;
             }
             default: {

package/dist/minds/builtin/pangu/persona.en.md

@@ -18,7 +18,7 @@ Build and maintain the rtws scaffolding and operational health:
 - Execute all legitimate rtws-operation requests from @fuxi.
 - Execute other teammates’ requests **only** after explicit per-item authorization from @fuxi.
 - Provide a stable, executable substrate for the visible DevOps team that @fuxi builds.
-- Only intervene proactively for **foundational scaffolding** or **cleaning up severe breakage**; otherwise stay in responder mode.
+- Only intervene proactively for **foundational scaffolding** or **cleaning up severe breakage**; otherwise stay in Dialog Responder mode.
 - Never perform team governance; defer all team-related decisions to @fuxi.
 
 ## Core Permissions (Explicit boundary; mutually known with @fuxi)
@@ -31,7 +31,7 @@ Build and maintain the rtws scaffolding and operational health:
 ## Core Principles
 
 1. **Mutual trust, division of labor**: strictly follow “@pangu manages the rtws; @fuxi manages the team”. Do not do team-management work.
-2. **Minimal intervention**: usually act as a precise executor/responder. Only go “hands-on” for foundational scaffolding or severe cleanup.
+2. **Minimal intervention**: usually act as a precise executor / Dialog Responder. Only go “hands-on” for foundational scaffolding or severe cleanup.
 3. **Authorization before execution**: treat @fuxi authorization as the only execution basis. For non-@fuxi requests, confirm authorization first; without it, do nothing (no probing, no pre-work).
 4. **Foundation aligned to team**: before foundational work, sync direction with @fuxi so rtws structure matches the team plan and collaboration patterns.
 5. **Encourage exploration**: explore rtws setup and operational workflows when aligned with product needs and team execution.
@@ -42,7 +42,7 @@ Build and maintain the rtws scaffolding and operational health:
 ### 1) Request execution (daily default)
 
 1. **Directly respond to @fuxi**: execute rtws operations requested by @fuxi (directory structure, file edits outside `.minds/`, repo setup, command execution, etc.) and report results back to `tellask(targetAgentId: "fuxi", ...)`.
-2. **Respond to other teammates only with authorization**: when any other teammate requests something, immediately ask `tellask(targetAgentId: "fuxi", ...)` for explicit authorization, including caller + request details; execute only after authorization, and then report back to both `tellask(targetAgentId: "fuxi", ...)` and the requester.
+2. **Respond to other teammates only with authorization**: when any other teammate requests something, immediately ask `tellask(targetAgentId: "fuxi", ...)` for explicit authorization, including tellasker + request details; execute only after authorization, and then report back to both `tellask(targetAgentId: "fuxi", ...)` and the tellasker.
 
 ### 2) Foundational work (the only proactive mode; discuss first)
 
@@ -67,7 +67,7 @@ Only intervene when the rtws is fundamentally broken and @fuxi asks for help. Co
 1. **With @fuxi**: every execution/progress/direction/authorization exchange starts with **tellask(targetAgentId: "fuxi", ...)**. Be concise and direct.
 2. **With the user**: only in foundational work or severe cleanup. Start with **askHuman()** and ask minimal, high-leverage questions.
 3. **With other visible teammates**: without @fuxi authorization, provide no operational commitments. With authorization, execute precisely and report results.
-4. **Cadence**: communicate proactively. If blocked, immediately alert both the requester and `tellask(targetAgentId: "fuxi", ...)`.
+4. **Cadence**: communicate proactively. If blocked, immediately alert both the tellasker and `tellask(targetAgentId: "fuxi", ...)`.
 
 ## Operating Rules
 

package/dist/minds/load.js

@@ -213,8 +213,8 @@ async function loadAgentMinds(agentId, dialog, options) {
         ctrl_1.clearMindTool,
         ctrl_1.recallTaskdocTool,
     ];
-    // change_mind is only available in main dialogs (not subdialogs).
-    if (dialog === undefined || dialog.supdialog === undefined) {
+    // change_mind is only available in main dialogs (not sideDialogs).
+    if (dialog === undefined || dialog.askerDialog === undefined) {
         intrinsicFuncTools.push(ctrl_1.changeMindTool);
     }
     const agentTools = (() => {
@@ -271,8 +271,8 @@ async function loadAgentMinds(agentId, dialog, options) {
     }
     const agentHasTeamMemoryTools = funcTools.some((t) => isTeamMemoryToolName(t.name));
     const agentHasPersonalMemoryTools = funcTools.some((t) => isPersonalMemoryToolName(t.name));
-    const isSubdialog = dialog !== undefined && dialog.supdialog !== undefined;
-    const taskdocMaintainerId = dialog && dialog instanceof dialog_1.SubDialog ? dialog.rootDialog.agentId : agent.id;
+    const isSideDialog = dialog !== undefined && dialog.askerDialog !== undefined;
+    const taskdocMaintainerId = dialog && dialog instanceof dialog_1.SideDialog ? dialog.mainDialog.agentId : agent.id;
     const contextHealthSnapshot = dialog?.getLastContextHealth();
     const contextHealthPromptMode = contextHealthSnapshot &&
         contextHealthSnapshot.kind === 'available' &&
@@ -286,7 +286,7 @@ async function loadAgentMinds(agentId, dialog, options) {
     const promptdocContext = {
         language: workingLanguage,
         agentId: agent.id,
-        isSubdialog,
+        isSideDialog,
         taskdocMaintainerId,
         agentHasTeamMemoryTools,
         agentHasPersonalMemoryTools,
@@ -312,7 +312,7 @@ async function loadAgentMinds(agentId, dialog, options) {
     const funcToolRulesText = funcTools.length > 0 ? (0, minds_i18n_1.funcToolRulesText)(workingLanguage) : '';
     const systemPrompt = (0, system_prompt_1.buildSystemPrompt)({
         language: workingLanguage,
-        dialogScope: isSubdialog ? 'sideline' : 'mainline',
+        dialogScope: isSideDialog ? 'sideDialog' : 'mainDialog',
         contextHealthPromptMode,
         agent,
         persona,

package/dist/minds/system-prompt-parts.d.ts

@@ -4,7 +4,7 @@ export type ContextHealthPromptMode = 'normal' | 'caution' | 'critical';
 export type PromptdocContext = {
     language: LanguageCode;
     agentId: string;
-    isSubdialog: boolean;
+    isSideDialog: boolean;
     taskdocMaintainerId: string;
     agentHasTeamMemoryTools: boolean;
     agentHasPersonalMemoryTools: boolean;

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

@@ -170,13 +170,13 @@ function getMemoryPromptCopy(ctx) {
             remindersLine: '- 提醒项（以 `reminder_id` 标识，工作集）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。准备 `clear_mind` 开启新一程对话时，默认整理成“结构化接续包提醒项”；其中只保留差遣牒未覆盖、但恢复工作容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。若系统已把当前程切到吃紧/告急处置态，则允许先保留多条粗略提醒项把信息带过桥；当前程只做保信息 + clear_mind；只有系统实际开启新一程后，第一步才是以清醒头脑复核并整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。',
             teamMemoryLine: '- 团队记忆：稳定的团队约定/工程规约（跨任务共享）。',
             personalMemoryLine: '- 个人记忆：稳定的个人习惯/偏好与职责域知识；记忆会在每次生成时自动注入上下文，应保持少量且准确（关键文档/代码的精确路径 + 最小必要事实）。不要记录具体任务状态。',
-            subdialogDutyLine: `你当前处于支线对话：此处不允许 \`change_mind\`。当你判断需要更新差遣牒（尤其是 progress 公告牌）时，请在合适时机直接诉请差遣牒维护人 \`@${ctx.taskdocMaintainerId}\` 执行更新，并给出你已合并好的“新全文/替换稿”（用于替换对应章节全文）。不要声称已更新，除非看到回执。`,
-            mainlineDutyLine: '你当前处于主线对话：你负责综合维护全队共享差遣牒（尤其是 progress 公告牌）。当队友/支线对话提出更新建议时，及时合并、压缩并保持清晰。',
-            teammateTellaskRoundDoneLine: `队友诉请重要语义：当你在上游上下文中收到带${runtimeMarkers.finalCompleted}标记的回贴，表示该轮诉请已经结束；对方不会继续执行同一轮诉请。此时如果目标未达成，“等待”是错误的：必须显式发起新一轮 tellask 才能继续推进。`,
+            sideDialogDutyLine: `你当前处于支线对话：此处不允许 \`change_mind\`。当你判断需要更新差遣牒（尤其是 progress 公告牌）时，请在合适时机直接诉请差遣牒维护人 \`@${ctx.taskdocMaintainerId}\` 执行更新，并给出你已合并好的“新全文/替换稿”（用于替换对应章节全文）。不要声称已更新，除非看到回执。`,
+            mainDialogDutyLine: '你当前处于主线对话：你负责综合维护全队共享差遣牒（尤其是 progress 公告牌）。当队友/支线对话提出更新建议时，及时合并、压缩并保持清晰。',
+            teammateTellaskRoundDoneLine: `队友诉请重要语义：当你在诉请者上下文中收到带${runtimeMarkers.finalCompleted}标记的回贴，表示该轮诉请已经结束；对方不会继续执行同一轮诉请。此时如果目标未达成，“等待”是错误的：必须显式发起新一轮 tellask 才能继续推进。`,
             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\` 更新。`,
-            subdialogWorkflowLine: `工作流：先做事 → 再提炼（\`update_reminder\`；必要时整理差遣牒更新提案并诉请 \`@${ctx.taskdocMaintainerId}\` 合并写入）→ 然后 \`clear_mind\` 清空噪音。`,
-            mainlineWorkflowLine: '工作流：先做事 → 再提炼（`update_reminder` + `change_mind(progress)`）→ 然后 `clear_mind` 清空噪音。',
+            sideDialogWorkflowLine: `工作流：先做事 → 再提炼（\`update_reminder\`；必要时整理差遣牒更新提案并诉请 \`@${ctx.taskdocMaintainerId}\` 合并写入）→ 然后 \`clear_mind\` 清空噪音。`,
+            mainDialogWorkflowLine: '工作流：先做事 → 再提炼（`update_reminder` + `change_mind(progress)`）→ 然后 `clear_mind` 清空噪音。',
             contextHealthLine: contextHealthLineZh,
             taskdocLogLine: taskdocLogLineZh,
         };
@@ -194,13 +194,13 @@ function getMemoryPromptCopy(ctx) {
         remindersLine: '- Reminders (addressed by `reminder_id`, working set): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. When preparing `clear_mind` to start a new course, default to a structured continuation-package reminder that keeps only details not already covered by Taskdoc but easy to lose during resume (first step, key pointers, run/verify info, volatile ids/paths). If the system has already put the current course into caution/critical remediation, rough multi-reminder bridge notes are acceptable; in the current course, only preserve volatile information and clear_mind. Only after the system actually starts the new course does the mandatory first step become reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.',
         teamMemoryLine: '- Team memory: stable shared conventions (cross-task).',
         personalMemoryLine: '- Personal memory: stable personal habits/preferences and responsibility-scope knowledge. Memory is automatically injected into context on each generation: keep it small and accurate (exact key doc/code paths + minimal key facts); do not store per-task state.',
-        subdialogDutyLine: `You are currently in a subdialog: \`change_mind\` is not allowed here. When Taskdoc should be updated (especially the shared progress bulletin board), tellask the Taskdoc maintainer \`@${ctx.taskdocMaintainerId}\` with a fully merged replacement draft (full-section replacement). Do not claim it is updated until you see a receipt.`,
-        mainlineDutyLine: '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/subdialogs promptly and keep it concise.',
-        teammateTellaskRoundDoneLine: `Teammate Tellask semantics: when you receive an upstream reply with the ${runtimeMarkers.finalCompleted} marker, that Tellask round is finished; the responder 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.`,
+        sideDialogDutyLine: `You are currently in a Side Dialog: \`change_mind\` is not allowed here. When Taskdoc should be updated (especially the shared progress bulletin board), tellask the Taskdoc maintainer \`@${ctx.taskdocMaintainerId}\` with a fully merged replacement draft (full-section replacement). Do not claim it is updated until you see a receipt.`,
+        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.`,
         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.`,
-        subdialogWorkflowLine: `Workflow: do work → distill (\`update_reminder\`; when Taskdoc needs updates, draft a merged replacement and ask \`@${ctx.taskdocMaintainerId}\`) → then \`clear_mind\` to drop noise.`,
-        mainlineWorkflowLine: 'Workflow: do work → distill (`update_reminder` + `change_mind(progress)`) → then `clear_mind` to drop noise.',
+        sideDialogWorkflowLine: `Workflow: do work → distill (\`update_reminder\`; when Taskdoc needs updates, draft a merged replacement and ask \`@${ctx.taskdocMaintainerId}\`) → then \`clear_mind\` to drop noise.`,
+        mainDialogWorkflowLine: 'Workflow: do work → distill (`update_reminder` + `change_mind(progress)`) → then `clear_mind` to drop noise.',
         contextHealthLine: contextHealthLineEn,
         taskdocLogLine: taskdocLogLineEn,
     };
@@ -220,11 +220,11 @@ function buildMemorySystemPrompt(ctx) {
         copy.teamMemoryLine,
         copy.personalMemoryLine,
         '',
-        ctx.isSubdialog ? copy.subdialogDutyLine : copy.mainlineDutyLine,
+        ctx.isSideDialog ? copy.sideDialogDutyLine : copy.mainDialogDutyLine,
         copy.teammateTellaskRoundDoneLine,
         ...(ctx.agentHasTeamMemoryTools ? [copy.teamMemoryHintLine] : []),
         ...(ctx.agentHasPersonalMemoryTools ? [copy.personalMemoryHintLine] : []),
-        ctx.isSubdialog ? copy.subdialogWorkflowLine : copy.mainlineWorkflowLine,
+        ctx.isSideDialog ? copy.sideDialogWorkflowLine : copy.mainDialogWorkflowLine,
         copy.contextHealthLine,
         copy.taskdocLogLine,
     ].join('\n');

package/dist/minds/system-prompt.d.ts

@@ -4,7 +4,7 @@ import type { ContextHealthPromptMode } from './system-prompt-parts';
 export declare function formatTeamIntro(team: Team, selfAgentId: string, language: LanguageCode): string;
 export type BuildSystemPromptInput = {
     language: LanguageCode;
-    dialogScope: 'mainline' | 'sideline';
+    dialogScope: 'mainDialog' | 'sideDialog';
     contextHealthPromptMode: ContextHealthPromptMode;
     agent: Team.Member;
     persona: string;

package/dist/minds/system-prompt.js

@@ -46,25 +46,25 @@ function pickLocalized(language, localized) {
 function buildFbrContextHealthScopeRule(scope, language, contextHealthPromptMode) {
     if (contextHealthPromptMode === 'critical') {
         return pickLocalized(language, {
-            zh: scope === 'mainline'
+            zh: scope === 'mainDialog'
                 ? '- 当前上下文处于系统告急处置态：本程禁止发起 FBR。先按处置要求保信息、维护提醒项，并立即 `clear_mind`；系统真正开启新一程并完成接续包复核后，再恢复 FBR 与差遣牒更新。'
                 : '- 当前上下文处于系统告急处置态：本程禁止发起 FBR。先按处置要求保信息、维护提醒项，并立即 `clear_mind`；系统真正开启新一程并完成接续包复核后，再恢复 FBR。',
-            en: scope === 'mainline'
+            en: scope === 'mainDialog'
                 ? '- Current context is under system critical remediation: do not start FBR in this course. Preserve volatile information, maintain reminders, and clear immediately; resume FBR and Taskdoc updates only after the system starts the new course and the continuation package has been reviewed.'
                 : '- Current context is under system critical remediation: do not start FBR in this course. Preserve volatile information, maintain reminders, and clear immediately; resume FBR only after the system starts the new course and the continuation package has been reviewed.',
         });
     }
     if (contextHealthPromptMode === 'caution') {
         return pickLocalized(language, {
-            zh: scope === 'mainline'
+            zh: scope === 'mainDialog'
                 ? '- 当前上下文处于系统吃紧处置态：本程不要发起 FBR。先按处置要求提炼提醒项并尽快 `clear_mind`；系统真正开启新一程并完成接续包复核后，再恢复 FBR 与差遣牒更新。'
                 : '- 当前上下文处于系统吃紧处置态：本程不要发起 FBR。先按处置要求提炼提醒项并尽快 `clear_mind`；系统真正开启新一程并完成接续包复核后，再恢复 FBR。',
-            en: scope === 'mainline'
+            en: scope === 'mainDialog'
                 ? '- Current context is under system caution remediation: do not start FBR in this course. Distill reminders and clear soon; resume FBR and Taskdoc updates only after the system starts the new course and the continuation package has been reviewed.'
                 : '- Current context is under system caution remediation: do not start FBR in this course. Distill reminders and clear soon; resume FBR only after the system starts the new course and the continuation package has been reviewed.',
         });
     }
-    if (scope === 'mainline') {
+    if (scope === 'mainDialog') {
         return pickLocalized(language, {
             zh: '- 当前没有生效中的上下文健康处置指令，可以按正常流程进行 FBR。完成 FBR 后，基于当前可观测事实调用 `change_mind` 更新差遣牒，体现任务最新进展情况。FBR 自诉请正文不要冗余包含差遣牒已有信息。',
             en: '- There is no active context-health remediation instruction in effect, so FBR may proceed normally. After FBR, call `change_mind` based on currently observable facts to update the Taskdoc with the latest progress; do not redundantly include information already present in the Taskdoc in the FBR body.',
@@ -78,16 +78,16 @@ function buildFbrContextHealthScopeRule(scope, language, contextHealthPromptMode
 function buildFbrPhaseContract(language) {
     const lines = pickLocalized(language, {
         zh: [
-            '- FBR 必须按“发起 → 逐轮推理 → 上游回帖”三段执行：发起 `freshBootsReasoning` 只代表发起，不代表你已完成推理。',
-            '- 发出 `freshBootsReasoning` 后，必须在该 FBR 子对话内按序走完整个 N 轮流程；只有最后一轮才会回帖给上游。',
-            '- 若 `fbr-effort = N`（力度 N，内部映射为 N 次串行推理），等待该 FBR 子对话一次性完整回帖；收到全量回帖后完成提炼并据此做下游决策；不得基于未完成中间轮次提前定稿。',
-            '- 每一轮都应给出与此前不同的增量观点；每轮均不得复述前文结论。程序会把该 FBR 全量支线正文在最后一轮合并后回贴到上游。',
+            '- FBR 必须按“发起 → 逐轮推理 → 诉请者回帖”三段执行：发起 `freshBootsReasoning` 只代表发起，不代表你已完成推理。',
+            '- 发出 `freshBootsReasoning` 后，必须在该 FBR 支线对话内按序走完整个 N 轮流程；只有最后一轮才会回帖给诉请者。',
+            '- 若 `fbr-effort = N`（力度 N，内部映射为 N 次串行推理），等待该 FBR 支线对话一次性完整回帖；收到全量回帖后完成提炼并据此做下游决策；不得基于未完成中间轮次提前定稿。',
+            '- 每一轮都应给出与此前不同的增量观点；每轮均不得复述前文结论。程序会把该 FBR 全量支线正文在最后一轮合并后回贴给诉请者。',
         ],
         en: [
-            '- FBR MUST follow three phases: “initiate -> serial reasoning rounds -> upstream update”. Calling `freshBootsReasoning` means initiation only, not completed reasoning.',
-            '- After calling `freshBootsReasoning`, run all required rounds in that single FBR sideline window; only the final round may post upstream.',
-            '- If `fbr-effort = N` (intensity N, internally mapped to N serial passes), wait for the complete sideline response from the final pass; after receiving the full reply, distill it before downstream action. Do not finalize based on partial passes.',
-            '- Every round must add a distinct incremental view. Every round, including the final one, must not repeat conclusions from earlier rounds. Runtime will relay the full accumulated FBR sideline output upstream in a single upstream-visible message.',
+            '- FBR MUST follow three phases: “initiate -> serial reasoning rounds -> tellasker update”. Calling `freshBootsReasoning` means initiation only, not completed reasoning.',
+            '- After calling `freshBootsReasoning`, run all required rounds in that single FBR Side Dialog window; only the final round may post to tellasker.',
+            '- If `fbr-effort = N` (intensity N, internally mapped to N serial passes), wait for the complete Side Dialog response from the final pass; after receiving the full reply, distill it before downstream action. Do not finalize based on partial passes.',
+            '- Every round must add a distinct incremental view. Every round, including the final one, must not repeat conclusions from earlier rounds. Runtime will relay the full accumulated FBR Side Dialog output to tellasker in a single tellasker-visible message.',
         ],
     });
     return lines.join('\n');
@@ -104,33 +104,33 @@ function buildTeammateTellaskPhaseContract(language) {
             '- 只有长线诉请（`tellask` + `sessionSlug`）才有“更新任务安排”的通道；一次性诉请（`tellaskSessionless`）没有这个通道。再次发起 `tellaskSessionless` 只会创建新的瞬态支线，不会更新、更不会要求旧支线主理人停止；若你后来发现可能需要改要求/提前收口，一开始就不该选择 `tellaskSessionless`。',
             '- 能由队友诉请完成的执行性工作，禁止转交 `askHuman` 做“转发员”；当你写“让 @X 执行 Y”时，必须在同一回复内直接发出 `tellask` 或 `tellaskSessionless`。',
             `- 当你在诉请正文里定义“回贴格式/交付格式”时，只写业务交付结构即可；不要要求被诉请者手写 \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR 标记（\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`），这些标记由 Dominds 运行时自动注入。`,
-            '- 当你处于队友诉请触发的支线时，不要把“阻塞/不确定”默认等同于 `tellaskBack`：若按当前团队规程/SOP/职责卡已能明确判定执行负责人，直接用 `tellask` / `tellaskSessionless` 诉请对应负责人；只有确实需要上游诉请者补充需求、做裁决、澄清验收口径、提供缺失输入，或现有规程无法明确判责时，才使用 `tellaskBack`。`tellaskBack` 不携带 `sessionSlug`。',
+            '- 当你处于队友诉请触发的支线时，不要把“阻塞/不确定”默认等同于 `tellaskBack`：若按当前团队规程/SOP/职责卡已能明确判定执行负责人，直接用 `tellask` / `tellaskSessionless` 诉请对应负责人；只有确实需要诉请者补充需求、做裁决、澄清验收口径、提供缺失输入，或现有规程无法明确判责时，才使用 `tellaskBack`。`tellaskBack` 不携带 `sessionSlug`。',
             `- 回贴文本标记由运行时在跨对话传递正文中按语义自动添加（例如 \`${runtimeMarkers.tellaskBack}\` / \`${runtimeMarkers.finalCompleted}\` / FBR 标记 \`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`）；该传递正文会进入目标智能体上下文，且 UI 与其一致。你不应手写这些标记。`,
         ],
         en: [
             '- 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.',
+            '- 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 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.',
+            '- 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.',
             '- 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 responder to hand-write \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR markers (\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`), because Dominds runtime injects those markers automatically.`,
-            '- In a teammate-triggered sideline, 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 upstream requester to clarify, decide, confirm acceptance criteria, provide missing input, or when existing SOP cannot determine ownership. `tellaskBack` must not carry `sessionSlug`.',
+            `- 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`.',
             `- Reply markers are auto-added by runtime in the inter-dialog transfer payload (for example \`${runtimeMarkers.tellaskBack}\` / \`${runtimeMarkers.finalCompleted}\` / FBR markers \`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`); that same transfer payload is what the target agent receives in context and what UI shows. Do not hand-write markers.`,
         ],
     });
     return lines.join('\n');
 }
-function buildSidelineUpstreamReplyMarkerRules(language) {
+function buildSideDialogTellaskerReplyMarkerRules(language) {
     const runtimeMarkers = (0, inter_dialog_format_1.getRuntimeTransferMarkers)(language);
     const lines = pickLocalized(language, {
         zh: [
-            '- 本规则仅用于当前支线向上游回复；`tellask` 用于**发起新的下游诉请对话**（委托队友做事），不用于向上游汇报。',
-            '- 当前支线未完成时，不要默认直接 `tellaskBack`。先判断当前团队规程/SOP/职责卡能否明确负责人：若能明确且属于执行性处理，直接 `tellask` / `tellaskSessionless` 对应负责人；只有当必须向上游诉请者补充需求、做业务裁决、澄清验收口径、提供缺失输入，或现有规程无法明确判责时，才发起 `tellaskBack({ tellaskContent: "..." })`，并在 `tellaskContent` 中给出具体问题。',
+            '- 本规则仅用于当前支线向诉请者回复；`tellask` 用于**发起新的下游诉请对话**（委托队友做事），不用于向诉请者汇报。',
+            '- 当前支线未完成时，不要默认直接 `tellaskBack`。先判断当前团队规程/SOP/职责卡能否明确负责人：若能明确且属于执行性处理，直接 `tellask` / `tellaskSessionless` 对应负责人；只有当必须向诉请者补充需求、做业务裁决、澄清验收口径、提供缺失输入，或现有规程无法明确判责时，才发起 `tellaskBack({ tellaskContent: "..." })`，并在 `tellaskContent` 中给出具体问题。',
             '- 是否存在“待你收口的跨对话回复义务”、以及精确该调用哪个 reply 函数，均由运行时程序化判断；运行时会在 assignment 或最新 runtime/user 提示里直接点名。',
             '- 若运行时点名了精确 reply 函数名，你只需调用那个被点名的函数；不要自己判断 `reply*` 变体。禁止调用 `tellaskBack` 发送最终结果，也禁止用 `tellask` 向诉请者发送最终结果。',
-            `- 只有在运行时当前明确点名了某个精确 reply 函数，且你通过那个函数回复时，运行时才会把该回复作为完成结果投递给上游，并在传递正文中添加 ${runtimeMarkers.finalCompleted}。`,
+            `- 只有在运行时当前明确点名了某个精确 reply 函数，且你通过那个函数回复时，运行时才会把该回复作为完成结果投递给诉请者，并在传递正文中添加 ${runtimeMarkers.finalCompleted}。`,
             '- 若运行时当前明确提示“没有待完成的跨对话回复义务”，就直接继续当前本地对话；不要凭记忆再次调用 `reply*`。',
             '- "不得发普通文本中间汇报"只针对未完成态；若你已经完成任务并能给出最终交付，就应使用运行时当前点名的精确 reply 函数，不要使用 `tellaskBack` 或 `tellask`。',
             '- 例外：FBR 支线为工具禁用模式（不得调用 `tellaskBack`）；其回贴标记（`' +
@@ -138,47 +138,47 @@ function buildSidelineUpstreamReplyMarkerRules(language) {
                 '` / `' +
                 runtimeMarkers.fbrReasoningOnly +
                 '`)也由运行时在传递正文中注入。',
-            '- 若人类用户在支线对话中插入消息或补问：直接正常回复即可，不需要向诉请者汇报（支线不需要主动汇报上游，默认行为就是直接回复）。',
+            '- 若人类用户在支线对话中插入消息或补问：直接正常回复即可，不需要向诉请者汇报（支线不需要主动汇报诉请者，默认行为就是直接回复）。',
         ],
         en: [
-            '- This rule applies only when replying upstream from the current sideline; tellask is for initiating a new downstream tellask dialog (delegating work to a teammate), not for reporting back to the requester.',
-            '- If the current sideline is unfinished, do not default to `tellaskBack`. First judge whether current team SOP / role ownership already identifies the responsible executor: if yes and the issue is execution work, directly use `tellask` / `tellaskSessionless` for that owner; use `tellaskBack({ tellaskContent: "..." })` only when the upstream requester must provide clarification, business decision, acceptance-criteria confirmation, missing input, or when existing SOP cannot determine ownership. Put concrete questions in `tellaskContent`.',
+            '- This rule applies only when replying to the tellasker from the current Side Dialog; tellask is for initiating a new downstream tellask dialog (delegating work to a teammate), not for reporting back to the tellasker.',
+            '- If the current Side Dialog is unfinished, do not default to `tellaskBack`. First judge whether current team SOP / role ownership already identifies the responsible executor: if yes and the issue is execution work, directly use `tellask` / `tellaskSessionless` for that owner; use `tellaskBack({ tellaskContent: "..." })` only when the tellasker must provide clarification, business decision, acceptance-criteria confirmation, missing input, or when existing SOP cannot determine ownership. Put concrete questions in `tellaskContent`.',
             '- Runtime programmatically decides whether there is an active inter-dialog reply obligation for you, and which exact reply function name applies; runtime will state that directly in the assignment or the latest runtime/user prompt.',
             '- If runtime names an exact reply function, call that named function and do not choose a `reply*` variant by yourself. Do not use `tellaskBack` or `tellask` to send final delivery.',
-            `- Only replies sent through the exact reply function currently named by runtime are delivered upstream as completion results and marked with ${runtimeMarkers.finalCompleted}.`,
+            `- Only replies sent through the exact reply function currently named by runtime are delivered to the tellasker as completion results and marked with ${runtimeMarkers.finalCompleted}.`,
             '- If runtime explicitly tells you there is no active inter-dialog reply obligation right now, just continue the current local conversation; do not call `reply*` again from memory.',
             '- "Do not post a plain-text progress update" only applies to unfinished states; if the task is done and you can deliver the final result, use the exact reply function currently named by runtime instead of `tellaskBack` or `tellask`.',
-            '- Exception: FBR sideline is tool-less (no \`tellaskBack\`); its reply markers (`' +
+            '- Exception: FBR Side Dialog is tool-less (no \`tellaskBack\`); its reply markers (`' +
                 runtimeMarkers.fbrDirectReply +
                 '` / `' +
                 runtimeMarkers.fbrReasoningOnly +
                 '`) are also injected by runtime into the transfer payload.',
-            '- If a human user inserts a message or asks a follow-up in the sideline: just reply normally; no need to report back to the upstream requester (sideline has no standing obligation to report upstream).',
+            '- If a human user inserts a message or asks a follow-up in the Side Dialog: just reply normally; no need to report back to the tellasker (Side Dialog has no standing obligation to report to the tellasker).',
         ],
     });
     return lines.join('\n');
 }
 function buildTellaskReplyMarkerScopePolicy(language, dialogScope) {
     const runtimeMarkers = (0, inter_dialog_format_1.getRuntimeTransferMarkers)(language);
-    if (dialogScope === 'sideline') {
+    if (dialogScope === 'sideDialog') {
         return [
             ...pickLocalized(language, {
                 zh: [
-                    `- 回贴文本标记由运行时在跨对话传递正文中自动添加（常规完成=${runtimeMarkers.finalCompleted}；FBR=${runtimeMarkers.fbrDirectReply} 或 ${runtimeMarkers.fbrReasoningOnly}）；该正文直接进入上游上下文，且 UI 展示与其一致。你无需、也不应手写标记。`,
+                    `- 回贴文本标记由运行时在跨对话传递正文中自动添加（常规完成=${runtimeMarkers.finalCompleted}；FBR=${runtimeMarkers.fbrDirectReply} 或 ${runtimeMarkers.fbrReasoningOnly}）；该正文直接进入诉请者上下文，且 UI 展示与其一致。你无需、也不应手写标记。`,
                     '- 若你在正文中给下游写“回贴格式”，只写业务交付结构；不得要求下游手写任何标记，运行时会自动注入。',
-                    '- `tellaskBack` 只允许用于回问上游诉请者；仅当必须向上游补需求/澄清/裁决/缺失输入，或现有团队规程无法明确判责时才使用。禁止用 `tellaskBack` 发送最终结果。',
+                    '- `tellaskBack` 只允许用于回问诉请者；仅当必须向诉请者补需求/澄清/裁决/缺失输入，或现有团队规程无法明确判责时才使用。禁止用 `tellaskBack` 发送最终结果。',
                     '- 当前支线未完成时，不得把“阻塞/不确定”机械等同于 `tellaskBack`；若团队规程/SOP/职责卡已明确负责人，应直接 `tellask` / `tellaskSessionless` 对应负责人，不得发普通文本中间汇报。',
-                    `- ${(0, reply_prompt_copy_1.buildSidelineCompletionRule)('zh')}`,
-                    `- 仅当运行时当前明确点名了某个精确 reply 函数，且你通过那个函数回复时，运行时才会把该回复投递给上游并标注 ${runtimeMarkers.finalCompleted}。`,
+                    `- ${(0, reply_prompt_copy_1.buildSideDialogCompletionRule)('zh')}`,
+                    `- 仅当运行时当前明确点名了某个精确 reply 函数，且你通过那个函数回复时，运行时才会把该回复投递给诉请者并标注 ${runtimeMarkers.finalCompleted}。`,
                     '- 若运行时当前明确提示“没有待完成的跨对话回复义务”，说明这轮不是待你收口的跨对话回复义务；不要重复调用 `reply*`。',
                 ],
                 en: [
-                    `- Reply markers are runtime-added in the inter-dialog transfer payload (regular completed reply = ${runtimeMarkers.finalCompleted}; FBR = ${runtimeMarkers.fbrDirectReply} or ${runtimeMarkers.fbrReasoningOnly}); this payload is delivered to upstream context and shown identically in UI. Do not hand-write markers.`,
+                    `- Reply markers are runtime-added in the inter-dialog transfer payload (regular completed reply = ${runtimeMarkers.finalCompleted}; FBR = ${runtimeMarkers.fbrDirectReply} or ${runtimeMarkers.fbrReasoningOnly}); this payload is delivered to tellasker context and shown identically in UI. Do not hand-write markers.`,
                     '- If you define a reply format for downstream, keep it to the business delivery structure; do not require downstream to hand-write any marker, because runtime injects markers automatically.',
-                    '- `tellaskBack` is only for asking the upstream requester back; use it only when upstream clarification / decision / missing input is required, or current team SOP cannot determine ownership. Do not use `tellaskBack` to send final results.',
-                    '- If the current sideline is unfinished, do not mechanically map “blocked / uncertain” to `tellaskBack`; when team SOP / role ownership already identifies the responsible owner, directly use `tellask` / `tellaskSessionless` for that owner instead of posting a plain-text progress update.',
-                    `- ${(0, reply_prompt_copy_1.buildSidelineCompletionRule)('en')}`,
-                    `- Runtime marks ${runtimeMarkers.finalCompleted} and delivers upstream only when runtime currently names an exact reply function and you reply through that named function.`,
+                    '- `tellaskBack` is only for asking the tellasker back; use it only when tellasker clarification / decision / missing input is required, or current team SOP cannot determine ownership. Do not use `tellaskBack` to send final results.',
+                    '- If the current Side Dialog is unfinished, do not mechanically map “blocked / uncertain” to `tellaskBack`; when team SOP / role ownership already identifies the responsible owner, directly use `tellask` / `tellaskSessionless` for that owner instead of posting a plain-text progress update.',
+                    `- ${(0, reply_prompt_copy_1.buildSideDialogCompletionRule)('en')}`,
+                    `- Runtime marks ${runtimeMarkers.finalCompleted} and delivers to the tellasker only when runtime currently names an exact reply function and you reply through that named function.`,
                     '- If runtime currently tells you there is no active inter-dialog reply obligation, then this turn is not awaiting another inter-dialog closure from you; do not call `reply*` again.',
                 ],
             }),
@@ -197,7 +197,7 @@ function buildTellaskCollaborationProtocol(language, dialogScope) {
             zh: [
                 '- Tellask 统一走函数工具通道：`tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman` / `freshBootsReasoning`。',
                 '- 对队友诉请默认使用 `tellask` 并复用 `sessionSlug`；仅在确认一次性诉请足够、且后续不需要更新任务安排/提前收口时才使用 `tellaskSessionless`，并需说明理由。',
-                '- 例外优先级（强制）：`tellaskBack` 仅用于回问上游诉请者，不适用队友长线默认规则，也不携带 `sessionSlug`。',
+                '- 例外优先级（强制）：`tellaskBack` 仅用于回问诉请者，不适用队友长线默认规则，也不携带 `sessionSlug`。',
             ],
             en: [
                 '- Tellask must use the function-tool channel: `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman` / `freshBootsReasoning`.',
@@ -212,11 +212,11 @@ function buildTellaskCollaborationProtocol(language, dialogScope) {
         }),
         buildTeammateTellaskPhaseContract(language),
     ];
-    if (dialogScope === 'sideline') {
+    if (dialogScope === 'sideDialog') {
         lines.push(pickLocalized(language, {
             zh: '- 支线对话交付规则（强制）：',
-            en: '- Sideline completion rule (mandatory):',
-        }), buildSidelineUpstreamReplyMarkerRules(language));
+            en: '- Side Dialog completion rule (mandatory):',
+        }), buildSideDialogTellaskerReplyMarkerRules(language));
     }
     return lines.join('\n');
 }
@@ -249,9 +249,9 @@ function buildFbrGuidelines(language, dialogScope, contextHealthPromptMode) {
             fbrContextHealthRule,
             '- The standard FBR entry is `freshBootsReasoning({ tellaskContent, effort? })`; do not emulate FBR via self-targeted `tellask` / `tellaskSessionless`.',
             '- When the user explicitly says “FBR x3” / “3x FBR”, pass `effort: 3` directly; here `x3` is the absolute effort value, not “3 × current fbr_effort”. Use the current member default only when the user did not specify an effort.',
-            '- When initiating FBR, keep `tellaskContent` to goals, facts, constraints, and evidence only; do not predefine analysis directions (for example fixed question checklists or prescribed frameworks). Reasoning directions must be expanded autonomously by the FBR sideline.',
+            '- When initiating FBR, keep `tellaskContent` to goals, facts, constraints, and evidence only; do not predefine analysis directions (for example fixed question checklists or prescribed frameworks). Reasoning directions must be expanded autonomously by the FBR Side Dialog.',
             '- Pre-call self-check (mandatory): if the body contains scaffolded directives such as “from the following dimensions/aspects” or stepwise templates (“analyze in steps 1..N”), rewrite first, then call `freshBootsReasoning`; otherwise the call is a protocol violation.',
-            '- Recommended body template (semantic MUST): `Goal` / `Facts` / `Constraints` / `Evidence` (optional `Unknowns`). The body should present neutral facts, not command the FBR sideline to analyze by fixed dimensions or steps.',
+            '- Recommended body template (semantic MUST): `Goal` / `Facts` / `Constraints` / `Evidence` (optional `Unknowns`). The body should present neutral facts, not command the FBR Side Dialog to analyze by fixed dimensions or steps.',
             '- Forbidden patterns: “from the following dimensions”, “analyze in steps 1..N”, “at least N rounds per dimension”. Rewrite these into neutral factual context before calling FBR.',
             '- Even without an explicit request, before resorting to `askHuman` (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):',
@@ -264,18 +264,18 @@ function buildFbrGuidelines(language, dialogScope, contextHealthPromptMode) {
 function buildTellaskInteractionRules(language) {
     const lines = pickLocalized(language, {
         zh: [
-            '- `tellaskBack`：仅用于支线回问上游诉请者。',
+            '- `tellaskBack`：仅用于支线回问诉请者。',
             '- `tellask`：用于可恢复的长线诉请（必须提供 `targetAgentId` / `sessionSlug` / `tellaskContent`）。',
             '- `tellaskSessionless`：用于一次性诉请（必须提供 `targetAgentId` / `tellaskContent`）；它不会建立可更新的任务安排通道，后续再次调用只会新开支线，不会影响旧支线继续执行。',
             '- `askHuman`：用于 Q4H（向人类请求必要澄清/决策/授权/缺失输入）。',
             '- `freshBootsReasoning`：用于发起扪心自问（FBR）支线（`tellaskContent` 必填，`effort` 可选）。',
         ],
         en: [
-            '- `tellaskBack`: ask back upstream from a sideline dialog only.',
+            '- `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 sidelines instead of affecting the earlier one.',
+            '- `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.',
             '- `askHuman`: Q4H for necessary clarification/decision/authorization/missing input.',
-            '- `freshBootsReasoning`: starts an FBR sideline dialog (requires `tellaskContent`, optional `effort`).',
+            '- `freshBootsReasoning`: starts an FBR Side Dialog (requires `tellaskContent`, optional `effort`).',
         ],
     });
     return lines.join('\n');
@@ -447,7 +447,7 @@ ${functionToolRules}
 - Full Name: ${input.agent.name}
 
 ## Language Model
-- Your internal working language is English (system prompt, tool rules, teammate/sideline-dialog narrative formatting).
+- Your internal working language is English (system prompt, tool rules, teammate/Side 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.
 
 ## Message Types
@@ -465,15 +465,15 @@ System notices convey important state changes (e.g., context caution/critical, D
 - Mention list (\`mentionList\`): teammate targets for \`tellask\` / \`tellaskSessionless\` only (\`@<agentId>\`).
 - Tellask content (\`tellaskContent\`): main call payload 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 \`tellaskBack\` to ask the tellasker for clarification.
-- Fresh Boots Reasoning (FBR): a tool-less sideline reasoning mechanism triggered by \`freshBootsReasoning\`.
+- tellasker: the dialog / Dialog Responder that issued the Tellask.
+- tellaskee: the dialog / Dialog Responder that receives the Tellask.
+- TellaskBack: a Side Dialog uses \`tellaskBack\` to ask the tellasker for clarification.
+- Fresh Boots Reasoning (FBR): a tool-less Side Dialog reasoning mechanism triggered by \`freshBootsReasoning\`.
 - Q4H (Question for Human): use \`askHuman\` to request necessary clarification/decision/authorization/missing input from a human.
 - Tellask Session: resumable multi-turn work using \`tellask\` with \`sessionSlug\`.
 - 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.
+- Main Dialog: the dialog that owns the shared Taskdoc and overall progress.
+- Side Dialog: a temporary dialog for a subtask.
 - Taskdoc: the shared task contract with required goals/constraints/progress sections plus optional extra sections.
 
 ## Persona

package/dist/persistence-errors.d.ts

@@ -1,4 +1,4 @@
-export type DomindsPersistenceFileSource = 'dialog_state' | 'dialog_latest' | 'dialog_metadata' | 'dialog_course_events' | 'reminder_state' | 'questions4human_state' | 'pending_subdialogs' | 'subdialog_responses' | 'subdialog_registry';
+export type DomindsPersistenceFileSource = 'dialog_state' | 'dialog_latest' | 'dialog_metadata' | 'dialog_asker_stack' | 'dialog_course_events' | 'reminder_state' | 'questions4human_state' | 'pending_sideDialogs' | 'sideDialog_responses' | 'sideDialog_registry';
 export type DomindsPersistenceFileOperation = 'read' | 'parse';
 export type DomindsPersistenceFileFormat = 'yaml' | 'json' | 'jsonl';
 type DomindsPersistenceFileErrorArgs = {