dominds 0.7.6 → 0.8.2

package/dist/server/api-routes.js

@@ -779,7 +779,7 @@ async function handleGetDialogHierarchy(res, rootId) {
                 createdAt: meta.createdAt,
                 lastModified: subLatest?.lastModified || meta.createdAt,
                 runState: subLatest?.runState,
-                tellaskSession: meta.tellaskSession,
+                sessionSlug: meta.sessionSlug,
                 assignmentFromSup: meta.assignmentFromSup,
             });
         }

package/dist/server/websocket-handler.js

@@ -258,14 +258,12 @@ async function handleDeclareSubdialogDead(ws, packet) {
     }
     if (!metadata)
         return;
-    if ('tellaskSession' in metadata &&
-        typeof metadata.tellaskSession === 'string' &&
-        metadata.tellaskSession.trim() !== '') {
+    if (typeof metadata.sessionSlug === 'string' && metadata.sessionSlug.trim() !== '') {
         const rootRestored = await restoreDialogForDrive(new dialog_1.DialogID(dialogIdObj.rootId), 'running');
         if (!(rootRestored instanceof dialog_1.RootDialog)) {
             throw new Error(`Expected root dialog instance for ${dialogIdObj.rootId}`);
         }
-        const removed = rootRestored.unregisterSubdialog(metadata.agentId, metadata.tellaskSession);
+        const removed = rootRestored.unregisterSubdialog(metadata.agentId, metadata.sessionSlug);
         if (removed) {
             await rootRestored.saveSubdialogRegistry();
         }
@@ -390,12 +388,6 @@ async function maybeTriggerImmediateDiligencePrompt(rootDialog) {
         if (!suspension.canDrive) {
             return;
         }
-        if ((0, driver_entry_1.getActiveDriverEngine)() === 'v1') {
-            const queuedResponses = await persistence_1.DialogPersistence.loadSubdialogResponsesQueue(rootDialog.id);
-            if (queuedResponses.length > 0) {
-                return;
-            }
-        }
         const team = await team_1.Team.load();
         const prepared = await (0, runtime_utils_1.maybePrepareDiligenceAutoContinuePrompt)({
             dlg: rootDialog,
@@ -732,7 +724,7 @@ async function handleDisplayDialog(ws, packet) {
             agentId: metadata.agentId,
             taskDocPath: metadata.taskDocPath,
             supdialogId: derivedSupdialogId,
-            tellaskSession: metadata.tellaskSession,
+            sessionSlug: metadata.sessionSlug,
             assignmentFromSup: metadata.assignmentFromSup,
             disableDiligencePush: effectiveDisableDiligencePush,
             diligencePushMax,
@@ -771,8 +763,7 @@ async function handleDisplayDialog(ws, packet) {
                     rootId: q.rootId,
                     agentId: q.agentId,
                     taskDocPath: q.taskDocPath,
-                    tellaskHead: q.tellaskHead,
-                    bodyContent: q.bodyContent,
+                    tellaskContent: q.tellaskContent,
                     askedAt: q.askedAt,
                     callId: q.callId,
                     remainingCallIds: q.remainingCallIds,
@@ -814,8 +805,7 @@ async function handleGetQ4HState(ws, _packet) {
             rootId: q.rootId,
             agentId: q.agentId,
             taskDocPath: q.taskDocPath,
-            tellaskHead: q.tellaskHead,
-            bodyContent: q.bodyContent,
+            tellaskContent: q.tellaskContent,
             askedAt: q.askedAt,
             callId: q.callId,
             remainingCallIds: q.remainingCallIds,
@@ -969,7 +959,7 @@ async function handleUserMsg2Dlg(ws, packet) {
             existingDialog.status === 'running' &&
             existingSub &&
             existingSub.dialogKey === existingDialog.id.valueOf()) {
-            await (0, driver_entry_1.driveDialogStream)(existingDialog, { content, msgId, grammar: 'tellask', userLanguageCode, origin: 'user' }, true);
+            await (0, driver_entry_1.driveDialogStream)(existingDialog, { content, msgId, grammar: 'markdown', userLanguageCode, origin: 'user' }, true);
             return;
         }
         // Dialog not found in wsLiveDlg - drive using the canonical root/subdialog instances.
@@ -989,7 +979,7 @@ async function handleUserMsg2Dlg(ws, packet) {
                 return;
             }
             await setupWebSocketSubscription(ws, dialog);
-            await (0, driver_entry_1.driveDialogStream)(dialog, { content, msgId, grammar: 'tellask', userLanguageCode, origin: 'user' }, true);
+            await (0, driver_entry_1.driveDialogStream)(dialog, { content, msgId, grammar: 'markdown', userLanguageCode, origin: 'user' }, true);
             return;
         }
         catch (restoreError) {
@@ -1163,10 +1153,10 @@ async function handleUserAnswer2Q4H(ws, packet) {
             dialog.queueUpNextPrompt({
                 prompt: content,
                 msgId,
-                grammar: 'tellask',
+                grammar: 'markdown',
                 userLanguageCode,
             });
-            log.info('Deferred Q4H answer until pending subdialogs resolve', {
+            log.debug('Deferred Q4H answer until pending subdialogs resolve', undefined, {
                 rootId: dialog.id.rootId,
                 selfId: dialog.id.selfId,
                 questionId,
@@ -1175,7 +1165,7 @@ async function handleUserAnswer2Q4H(ws, packet) {
             return;
         }
         // Resume the dialog with the user's answer.
-        await (0, driver_entry_1.driveDialogStream)(dialog, { content, msgId, grammar: 'tellask', userLanguageCode, origin: 'user' }, true);
+        await (0, driver_entry_1.driveDialogStream)(dialog, { content, msgId, grammar: 'markdown', userLanguageCode, origin: 'user' }, true);
     }
     catch (error) {
         log.error('Error processing Q4H user answer:', error);

package/dist/server.js

@@ -57,16 +57,16 @@ require("./tools/builtins");
 const log = (0, log_1.createLogger)('server');
 // Setup unhandled rejection handler to capture crashes
 process.on('unhandledRejection', (reason, promise) => {
-    log.error('Unhandled Rejection at:', promise);
+    log.error('Unhandled Rejection at:', undefined, { promise });
     log.error('Reason:', reason instanceof Error ? reason : new Error(String(reason)));
-    log.error('Stack trace:', (reason instanceof Error && reason.stack) || 'No stack trace available');
+    log.error('Stack trace:', undefined, (reason instanceof Error && reason.stack) || 'No stack trace available');
     // Optionally, we could exit the process here with code 1
     // But in development, we might want to keep running
 });
 // Setup uncaught exception handler
 process.on('uncaughtException', (error) => {
     log.error('Uncaught Exception:', error);
-    log.error('Stack trace:', error.stack);
+    log.error('Stack trace:', undefined, error.stack);
     // Optionally, exit with code 1
     // process.exit(1);
 });

package/dist/shared/diligence.js

@@ -6,21 +6,21 @@ exports.DILIGENCE_FALLBACK_TEXT = {
     zh: [
         '你扪心自问（做一次 FBR），差遣牒已经包含足够明确的目标定义了吗？',
         '',
-        '如果没有，`!?@human` 诉请人类给出足够清晰的目标。',
+        '如果没有，使用 `askHuman` 请求人类给出足够清晰的目标。',
         '',
         '如果目标已经清晰定义，那么你已经完成了所有目标吗？',
         '',
-        '如果已经完成，`!?@human` 诉请人类验收。',
+        '如果已经完成，使用 `askHuman` 请求人类验收。',
         '',
-        '如果尚未完成，优先直接确定并执行下一步最优行动项（调用工具或诉请队友）。仅当“下一步不清晰/难以决策”时，才发起一次 `!?@self` 扪心自问（FBR）；收齐该次回贴后，立即把结论落地为可执行动作并开始执行，不要只汇报决定。',
+        '如果尚未完成，优先直接确定并执行下一步最优行动项（调用工具或诉请队友）。仅当“下一步不清晰/难以决策”时，才发起一次 freshBootsReasoning 扪心自问（FBR）；收齐该次回贴后，立即把结论落地为可执行动作并开始执行，不要只汇报决定。',
         '',
-        '当你确信自己不该或者不能自主继续工作时，立即 `!?@human` 诉请人类确认相关问题或者指出工作方向。',
+        '当你确信自己不该或者不能自主继续工作时，立即使用 `askHuman` 请求人类确认相关问题或者指出工作方向。',
         '',
         '---',
         '',
         '**注意**：',
         '',
-        '扪心自问时，自诉请正文需要包含对当前状况的完整事实性总结（但不要包含差遣牒已有内容）；`!?@self` 发起后不要立即下最终行动决策，先等回贴再综合。综合完成后必须立刻执行已确定行动（工具调用/诉请队友），避免停留在“仅汇报决定”的状态。',
+        '扪心自问时，自诉请正文需要包含对当前状况的完整事实性总结（但不要包含差遣牒已有内容）；发起 freshBootsReasoning 后不要立即下最终行动决策，先等回贴再综合。综合完成后必须立刻执行已确定行动（工具调用/诉请队友），避免停留在“仅汇报决定”的状态。',
         '',
         '队友如果回复 “将要/可以” 做 XXX 的，你要审视祂所说是否符合整体/分项任务目标，是否值得继续：',
         '- 如果祂建议的事情可做可不做，那么就可以忽略，不以琐碎小事安排工作。',
@@ -28,26 +28,26 @@ exports.DILIGENCE_FALLBACK_TEXT = {
         '',
         '系统会把“尚未收到反馈、仍在执行中的诉请”自动展示为提醒项；请以提醒项作为是否仍在执行中的唯一判断依据。',
         '',
-        '凡是不在提醒项里的历史诉请，都不要继续等待（通常代表已回贴或已结束当前轮次）。若该工作线仍需推进，必须立即使用同一个 `!tellaskSession <slug>` 再次诉请对应队友，明确要求继续执行下一步。',
+        '凡是不在提醒项里的历史诉请，都不要继续等待（通常代表已回贴或已结束当前轮次）。若该工作线仍需推进，必须立即使用同一个 `sessionSlug` 再次调用 `tellask` 诉请对应队友，明确要求继续执行下一步。',
     ].join('\n'),
     en: [
         'Do a self-check (run one FBR): does the Taskdoc already contain a sufficiently clear goal definition?',
         '',
-        'If not, use `!?@human` to ask for a sufficiently clear goal.',
+        'If not, use `askHuman` to request a sufficiently clear goal.',
         '',
         'If the goal is already clearly defined, ask: have you completed all goals?',
         '',
-        'If yes, use `!?@human` to request acceptance.',
+        'If yes, use `askHuman` to request acceptance.',
         '',
-        'If not complete, first determine and execute the best next action (tool call or teammate tellask). Use `!?@self` FBR only when the next move is unclear or hard to decide; after feedback from that FBR run is collected, immediately turn the conclusion into executable action and start execution. Do not stop at reporting a decision.',
+        'If not complete, first determine and execute the best next action (tool call or teammate tellask). Use freshBootsReasoning for FBR only when the next move is unclear or hard to decide; after feedback from that FBR run is collected, immediately turn the conclusion into executable action and start execution. Do not stop at reporting a decision.',
         '',
-        'When you are convinced you should not or cannot continue autonomously, immediately use `!?@human` to confirm the relevant issue or provide direction.',
+        'When you are convinced you should not or cannot continue autonomously, immediately use `askHuman` to confirm the relevant issue or provide direction.',
         '',
         '---',
         '',
         '**Notes**:',
         '',
-        'When running FBR, the self-tellask body must include a complete factual summary of the current situation (but do not repeat information already present in the Taskdoc). After `!?@self`, do not finalize the next action immediately; wait for feedback first, then synthesize. Once synthesized, immediately execute the chosen action (tool call / teammate tellask), and avoid staying in a “decision report only” state.',
+        'When running FBR, the FBR body must include a complete factual summary of the current situation (but do not repeat information already present in the Taskdoc). After initiating a freshBootsReasoning, do not finalize the next action immediately; wait for feedback first, then synthesize. Once synthesized, immediately execute the chosen action (tool call / teammate tellask), and avoid staying in a “decision report only” state.',
         '',
         'If a teammate replies that they “will/can do X”, examine whether it aligns with the overall/sub-task goals and is worth continuing:',
         '- If it is optional and low impact, ignore it instead of assigning trivial work.',
@@ -55,6 +55,6 @@ exports.DILIGENCE_FALLBACK_TEXT = {
         '',
         'The system automatically surfaces still-running tellasks (those without feedback yet) as reminder items; treat reminders as the single source of truth for whether a tellask is still in progress.',
         '',
-        'For any historical tellask not listed in reminders, do not keep waiting (it usually means the previous round already replied or ended). If that workstream should continue, immediately re-tellask the same teammate with the same `!tellaskSession <slug>` and explicitly ask for the next step.',
+        'For any historical tellask not listed in reminders, do not keep waiting (it usually means the previous round already replied or ended). If that workstream should continue, immediately call `tellask` for the same teammate with the same `sessionSlug` and explicitly ask for the next step.',
     ].join('\n'),
 };

package/dist/shared/i18n/driver-messages.js

@@ -7,14 +7,9 @@ exports.formatDomindsNoteTellaskForTeammatesOnly = formatDomindsNoteTellaskForTe
 exports.formatDomindsNoteQ4HRegisterFailed = formatDomindsNoteQ4HRegisterFailed;
 exports.formatAgentFacingContextHealthV3RemediationGuide = formatAgentFacingContextHealthV3RemediationGuide;
 exports.formatDomindsNoteTellaskerOnlyInSidelineDialog = formatDomindsNoteTellaskerOnlyInSidelineDialog;
-exports.formatDomindsNoteTellaskerNoTellaskSession = formatDomindsNoteTellaskerNoTellaskSession;
 exports.formatDomindsNoteDirectSelfCall = formatDomindsNoteDirectSelfCall;
 exports.formatDomindsNoteFbrDisabled = formatDomindsNoteFbrDisabled;
 exports.formatDomindsNoteFbrToollessViolation = formatDomindsNoteFbrToollessViolation;
-exports.formatDomindsNoteMalformedTellaskCall = formatDomindsNoteMalformedTellaskCall;
-exports.formatDomindsNoteInvalidMultiTeammateTargets = formatDomindsNoteInvalidMultiTeammateTargets;
-exports.formatDomindsNoteInvalidTellaskSessionDirective = formatDomindsNoteInvalidTellaskSessionDirective;
-exports.formatDomindsNoteMultipleTellaskSessionDirectives = formatDomindsNoteMultipleTellaskSessionDirectives;
 const language_1 = require("../types/language");
 function formatCurrentUserLanguagePreference(workingLanguage, uiLanguage) {
     const uiName = (0, language_1.formatLanguageName)(uiLanguage, workingLanguage);
@@ -131,24 +126,24 @@ function formatQ4HDiligencePushBudgetExhausted(language, args) {
 function formatDomindsNoteTellaskForTeammatesOnly(language, args) {
     const firstMention = args.firstMention;
     if (language === 'zh') {
-        return (`错误：诉请（tellask）仅用于队友诉请（\`!?@<teammate>\`）。\n` +
+        return (`错误：诉请（tellask）仅用于队友诉请（tellask-special 函数）。\n` +
             `- 当前目标：\`@${firstMention}\` 不是已知队友呼号。\n` +
-            `- 若你要调用工具：请使用原生 function-calling（函数工具），不要在文本中输出 \`!?@tool\`。\n` +
-            `- 若你要找队友：请确认呼号（如 \`!?@pangu\` / \`!?@tellasker\` / \`!?@self\`）。`);
+            `- 若你要调用工具：请使用原生 function-calling（函数工具）。\n` +
+            `- 若你要找队友：请使用 tellask-special 函数并确认 targetAgentId（如 \`pangu\`），支线回问请用 \`tellaskBack\`。`);
     }
-    return (`Error: tellask is reserved for teammate tellasks (\`!?@<teammate>\`).\n` +
+    return (`Error: tellask is reserved for teammate tellasks (tellask-special functions).\n` +
         `- Current target: \`@${firstMention}\` is not a known teammate call sign.\n` +
-        `- If you intended to call a tool: use native function-calling; do not emit \`!?@tool\` in text.\n` +
-        `- If you intended to call a teammate: double-check the call sign (e.g. \`!?@pangu\` / \`!?@tellasker\` / \`!?@self\`).`);
+        `- If you intended to call a tool: use native function-calling.\n` +
+        `- If you intended to call a teammate: use tellask-special functions and verify targetAgentId (e.g. \`pangu\`); use \`tellaskBack\` for ask-back.`);
 }
 function formatDomindsNoteQ4HRegisterFailed(language, args) {
     const error = args.error;
     if (language === 'zh') {
-        return (`错误：Q4H（\`@human\`）登记失败。\n` +
+        return (`错误：Q4H（\`askHuman\`）登记失败。\n` +
             `- 原因：${error}\n` +
             `- 建议：请重试；若持续失败，可删除该对话的 \`q4h.yaml\`（会丢失该对话的待答问题），或查看服务端日志。`);
     }
-    return (`Error: failed to register Q4H (\`@human\`).\n` +
+    return (`Error: failed to register Q4H (\`askHuman\`).\n` +
         `- Reason: ${error}\n` +
         `- Next: retry; if this keeps failing, delete the dialog's \`q4h.yaml\` (will drop pending questions) or check server logs.`);
 }
@@ -216,150 +211,65 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
 }
 function formatDomindsNoteTellaskerOnlyInSidelineDialog(language) {
     if (language === 'zh') {
-        return ('Dominds 提示：`!?@tellasker` 只在支线对话中有效，用于向“诉请者”（发起本次诉请的对话）回问澄清。\n' +
+        return ('Dominds 提示：`tellaskBack` 只在支线对话中有效，用于向“诉请者”（发起本次诉请的对话）回问澄清。\n' +
             '你当前不在支线对话中，因此没有“诉请者”可回问。\n' +
             '（注：诉请者不一定是主线对话；差遣牒 `*.tsk/` 通常由主线对话维护人统一更新。）');
     }
-    return ('Dominds note: `!?@tellasker` is only valid inside a sideline dialog and tellasks back to the tellasker (the dialog that issued the current Tellask) for clarification. ' +
+    return ('Dominds note: `tellaskBack` is only valid inside a sideline dialog and asks back to the tellasker (the dialog that issued the current Tellask) for clarification. ' +
         'You are currently not in a sideline dialog, so there is no tellasker to call.');
 }
-function formatDomindsNoteTellaskerNoTellaskSession(language) {
-    if (language === 'zh') {
-        return ('Dominds 提示：`!?@tellasker` 是回问诉请（TellaskBack），不接受 `!tellaskSession`。' +
-            '请使用不带 `!tellaskSession` 的 `!?@tellasker`；若你需要可恢复的多轮协作，请使用长线诉请：`!?@self !tellaskSession <tellaskSession>` / `!?@<agentId> !tellaskSession <tellaskSession>`。');
-    }
-    return ('Dominds note: `!?@tellasker` is a TellaskBack and does not accept `!tellaskSession`. ' +
-        'Use `!?@tellasker` with NO `!tellaskSession`, or use `!?@self !tellaskSession <tellaskSession>` / `!?@<agentId> !tellaskSession <tellaskSession>` for a resumable Tellask Session.');
-}
 function formatDomindsNoteDirectSelfCall(language) {
     if (language === 'zh') {
-        return ('Dominds 提示：该诉请目标是当前 agent（自诉请/self-tellask）。' +
-            '扪心自问 通常应使用 `!?@self`（不带 `!tellaskSession`）来创建一次性的初心会话；' +
-            '仅在你明确需要可恢复的长期支线对话时才使用 `!?@self !tellaskSession <tellaskSession>`。该诉请将继续执行。');
+        return ('错误：不允许通过 `tellask` / `tellaskSessionless` 对当前 agent 发起自诉请。\n' +
+            '- 若你要发起扪心自问（FBR），请使用 `freshBootsReasoning({ tellaskContent })`。\n' +
+            '- `tellask` / `tellaskSessionless` 仅用于队友诉请（targetAgentId 必须是队友 id）。');
     }
-    return ('Dominds note: This call targets the current agent (self-tellask). ' +
-        'Fresh Boots Reasoning should usually use `!?@self` (no `!tellaskSession`) for an ephemeral fresh boots session; use ' +
-        '`!?@self !tellaskSession <tellaskSession>` only when you explicitly want a resumable long-lived sideline dialog. This call will proceed.');
+    return ('Error: self-targeted calls via `tellask` / `tellaskSessionless` are not allowed.\n' +
+        '- For FBR, use `freshBootsReasoning({ tellaskContent })`.\n' +
+        '- `tellask` / `tellaskSessionless` are teammate-only (targetAgentId must be a teammate id).');
 }
 function formatDomindsNoteFbrDisabled(language) {
     if (language === 'zh') {
-        return ('错误：当前团队配置不允许你使用 `!?@self` 扪心自问（FBR）自诉请。\n' +
+        return ('错误：当前团队配置不允许你使用 `freshBootsReasoning` 发起扪心自问（FBR）。\n' +
             '- 请联系团队管理者调整配置后再试。\n' +
-            '- 你仍可使用其它队友诉请（`!?@<teammate>`）或在当前对话中直接分析并给出结论。');
+            '- 你仍可使用其它队友诉请函数（tellask/tellaskSessionless）或在当前对话中直接分析并给出结论。');
     }
-    return ('Error: `!?@self` Fresh Boots Reasoning (FBR) is disabled by your team configuration.\n' +
-        '- Ask your team manager to adjust the team config, then retry `!?@self`.\n' +
-        '- You can still tellask other teammates (`!?@<teammate>`) or provide analysis directly in the current dialog.');
+    return ('Error: `freshBootsReasoning` (FBR) is disabled by your team configuration.\n' +
+        '- Ask your team manager to adjust the team config, then retry `freshBootsReasoning`.\n' +
+        '- You can still tellask other teammates via tellask functions (`tellask` / `tellaskSessionless`) or provide analysis directly in the current dialog.');
 }
 function formatDomindsNoteFbrToollessViolation(language, args) {
     const kind = args.kind;
     if (language === 'zh') {
         const detail = kind === 'tellask'
-            ? '检测到你在 FBR 支线对话里发起了队友诉请（`!?@...`）。'
+            ? '检测到你在 FBR 支线对话里尝试发起诉请（tellask 系列）。'
             : kind === 'tool'
                 ? '检测到你在 FBR 支线对话里尝试调用函数工具。'
                 : kind === 'tellask_and_tool'
-                    ? '检测到你在 FBR 支线对话里同时尝试发起队友诉请与函数工具调用。'
+                    ? '检测到你在 FBR 支线对话里同时尝试发起诉请与函数工具调用。'
                     : '内部错误：无法安全驱动 FBR 支线对话。';
         return [
             'ERR_FBR_TOOLLESS_VIOLATION',
             `Dominds 提示：当前是扪心自问（FBR）支线对话（无工具模式）。${detail}`,
             '',
             '- 本对话无任何工具：禁止函数工具调用。',
-            '- 本对话禁止任何队友诉请（包括 `!?@human` / `!?@tellasker` / `!?@self`）。',
+            '- 本对话禁止任何 tellask-special 函数（包括 `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`）。',
             '- 请只基于诉请正文（以及本支线对话自身的会话历史，如有）进行推理与总结。',
         ].join('\n');
     }
     const detail = kind === 'tellask'
-        ? 'Detected a teammate tellask (`!?@...`) emitted inside an FBR sideline dialog.'
+        ? 'Detected a tellask-special invocation attempt inside an FBR sideline dialog.'
         : kind === 'tool'
             ? 'Detected a function tool call attempt inside an FBR sideline dialog.'
             : kind === 'tellask_and_tool'
-                ? 'Detected both tellask and tool-call attempts inside an FBR sideline dialog.'
+                ? 'Detected both tellask-special and tool-call attempts inside an FBR sideline dialog.'
                 : 'Internal error: cannot safely drive the FBR sideline dialog.';
     return [
         'ERR_FBR_TOOLLESS_VIOLATION',
-        `Dominds note: this is a tool-less @self FBR sideline dialog. ${detail}`,
+        `Dominds note: this is a tool-less FBR sideline dialog (triggered by \`freshBootsReasoning\`). ${detail}`,
         '',
         '- No tools are available: do not emit function tool calls.',
-        '- No tellasks are allowed (including `!?@human` / `!?@tellasker` / `!?@self`).',
+        '- No tellask-special functions are allowed (`tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`).',
         '- Provide pure reasoning and a summary grounded in the tellask body (and this sideline dialog’s own tellaskSession history, if any).',
     ].join('\n');
 }
-function formatDomindsNoteMalformedTellaskCall(language, reason, options) {
-    const firstLine = options?.firstLineAfterPrefix?.trim() ?? '';
-    const got = firstLine !== '' ? `\n\nGot: \`!?${firstLine}\`` : '';
-    if (language === 'zh') {
-        switch (reason) {
-            case 'missing_mention_prefix': {
-                return ('ERR_MALFORMED_TELLASK\n' +
-                    'Dominds 提示：这段内容被解析为“诉请块”，但第一行不是有效的诉请头。\n\n' +
-                    '规则：诉请块第一行必须以 `!?@<mention-id>` 开头，例如：`!?@pangu`。\n' +
-                    '如果你只是想写普通 markdown，请不要在行首使用 `!?`。' +
-                    got);
-            }
-            case 'invalid_mention_id': {
-                return ('ERR_MALFORMED_TELLASK\n' +
-                    'Dominds 提示：这段内容被解析为“诉请块”，但 `!?@` 后的 mention-id 为空或无效。\n\n' +
-                    '规则：第一行必须是 `!?@<mention-id>`（mention-id 不能为空），例如：`!?@pangu`。' +
-                    got);
-            }
-            default: {
-                const _exhaustive = reason;
-                return _exhaustive;
-            }
-        }
-    }
-    switch (reason) {
-        case 'missing_mention_prefix': {
-            return ('ERR_MALFORMED_TELLASK\n' +
-                'Dominds note: This content was parsed as a tellask block, but the first line is not a valid tellask headline.\n\n' +
-                'Rule: the first line must start with `!?@<mention-id>`, e.g. `!?@pangu`.\n' +
-                'If you want normal markdown, do not start the line with `!?`.' +
-                got);
-        }
-        case 'invalid_mention_id': {
-            return ('ERR_MALFORMED_TELLASK\n' +
-                'Dominds note: This content was parsed as a tellask block, but the mention-id after `!?@` is empty or invalid.\n\n' +
-                'Rule: the first line must be `!?@<mention-id>` (mention-id cannot be empty), e.g. `!?@pangu`.' +
-                got);
-        }
-        default: {
-            const _exhaustive = reason;
-            return _exhaustive;
-        }
-    }
-}
-function formatDomindsNoteInvalidMultiTeammateTargets(language, options) {
-    const unknown = options.unknown.map((id) => `@${id}`).join(', ');
-    if (language === 'zh') {
-        return ('ERR_INVALID_MULTI_TEAMMATE_TARGETS\n' +
-            `Dominds 提示：这条队友诉请包含未知队友呼号：${unknown}\n\n` +
-            '在队友诉请中，headline 里出现的队友呼号会被视为 collective targets 并被分发（所有目标共享同一 tellaskHead+tellaskBody）。\n' +
-            '请确认这些呼号是否存在于团队目录中；若你只是想写字面上的 @something，请用反引号包裹（例如 `@something`）。');
-    }
-    return ('ERR_INVALID_MULTI_TEAMMATE_TARGETS\n' +
-        `Dominds note: This teammate tellask includes unknown teammate id(s): ${unknown}\n\n` +
-        'In teammate tellasks, teammate mentions inside the headline are treated as collective targets and fanned out (shared tellaskHead+tellaskBody).\n' +
-        'Confirm those ids exist in the team roster; if you meant a literal `@something`, wrap it in backticks (e.g., `@something`).');
-}
-function formatDomindsNoteInvalidTellaskSessionDirective(language) {
-    if (language === 'zh') {
-        return ('ERR_INVALID_TELLASK_SESSION_DIRECTIVE\n' +
-            'Dominds 提示：检测到 `!tellaskSession` 指令，但 tellaskSession 无效。\n\n' +
-            '规则：`!tellaskSession <tellaskSession>` 的 tellaskSession 必须满足 `^[a-zA-Z][a-zA-Z0-9_-]*(\\.[a-zA-Z0-9_-]+)*$`。');
-    }
-    return ('ERR_INVALID_TELLASK_SESSION_DIRECTIVE\n' +
-        'Dominds note: Detected a `!tellaskSession` directive, but the tellaskSession is invalid.\n\n' +
-        'Rule: `!tellaskSession <tellaskSession>` must match `^[a-zA-Z][a-zA-Z0-9_-]*(\\.[a-zA-Z0-9_-]+)*$`.');
-}
-function formatDomindsNoteMultipleTellaskSessionDirectives(language) {
-    if (language === 'zh') {
-        return ('ERR_MULTIPLE_TELLASK_SESSION_DIRECTIVES\n' +
-            'Dominds 提示：同一条诉请的 headline 中出现了多个 `!tellaskSession` 指令。\n\n' +
-            '规则：每条诉请最多只能包含一个 `!tellaskSession <tellaskSession>`（对 collective teammate tellask，该 tellaskSession 会对所有目标队友生效）。');
-    }
-    return ('ERR_MULTIPLE_TELLASK_SESSION_DIRECTIVES\n' +
-        'Dominds note: Multiple `!tellaskSession` directives were found in the headline.\n\n' +
-        'Rule: a tellask may include at most one `!tellaskSession <tellaskSession>` (for collective teammate tellasks, the same tellaskSession applies to all targets).');
-}

package/dist/shared/utils/inter-dialog-format.js

@@ -8,17 +8,10 @@
  * - Do not store formatted text inside persisted records; keep raw fields only.
  *
  * UI display contract:
- * - Display the record data only (headline + body).
- * - Call display (request/assignment): render headline, then body (no quote/divider).
- * - Response display: render the original tellask headline as a blockquote,
- *   then a horizontal divider (`---`), then the response body.
+ * - Display the record data only (mention list + tellask content).
+ * - Call display (request/assignment): render mention list, then tellask content.
+ * - Response display: render response body first, then original call site summary.
  * - Participant identity (from/to/responder) should live in bubble chrome, not inside content.
- *
- * LLM context contract:
- * - Use the same markdown record layout as the UI for the record data.
- * - Prepend a short natural-language narrative line that states:
- *   who is in what role (requester/responder/assignee) and what action occurred.
- * - Include the original tellask headline in the narrative for clarity.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatAssignmentFromSupdialog = formatAssignmentFromSupdialog;
@@ -31,37 +24,48 @@ function requireNonEmpty(value, fieldLabel) {
     }
     return value;
 }
+function trimTrailingDots(value) {
+    let out = value;
+    while (out.endsWith('.'))
+        out = out.slice(0, -1);
+    return out;
+}
+function requireMentionLine(mentionList) {
+    const mentionLine = mentionList.join(' ').trim();
+    return requireNonEmpty(mentionLine, 'mentionList');
+}
 function formatAssignmentFromSupdialog(input) {
     const language = input.language ?? 'en';
     const to = requireNonEmpty(input.toAgentId, 'toAgentId');
     const from = requireNonEmpty(input.fromAgentId, 'fromAgentId');
-    const tellaskHead = requireNonEmpty(input.tellaskHead, 'tellaskHead');
-    const isFbrSelfTellask = /^\s*@self\b/.test(tellaskHead);
-    if (isFbrSelfTellask) {
+    const tellaskContent = requireNonEmpty(input.tellaskContent, 'tellaskContent');
+    const isFbr = input.callName === 'freshBootsReasoning';
+    if (isFbr) {
         const intro = language === 'zh'
             ? [
                 '# 扪心自问（FBR）自诉请',
                 '',
-                `- 诉请：\`${tellaskHead}\``,
                 '- 约束：这是一个 FBR 支线对话；请以“初心视角”独立推理与总结。',
-                '- 回问：仅当你需要澄清关键上下文时，允许 `!?@tellasker` 回问诉请者；除此之外不要发起任何队友诉请。',
+                '- 回问：若当前回合函数工具可用，且你需要澄清关键上下文，可使用 `tellaskBack` 回问上游；否则不要发起任何诉请。',
                 '- 重要：不要依赖诉请者对话历史；仅基于诉请正文（以及本支线对话自身的会话历史，如有）。',
                 '',
                 '---',
             ].join('\n')
             : [
-                '# @self Fresh Boots Reasoning (FBR) request',
+                '# Fresh Boots Reasoning (FBR) request',
                 '',
-                `- Tellask: \`${tellaskHead}\``,
                 '- Constraint: this is an FBR sideline dialog; reason independently from a “fresh boots” perspective.',
-                '- TellaskBack: `!?@tellasker` is allowed only when you must clarify critical missing context; otherwise do not emit any tellasks.',
+                '- TellaskBack: if function tools are enabled for this turn and you must clarify critical missing context, use `tellaskBack`; otherwise do not emit tellasks.',
                 '- Important: do not rely on the tellasker dialog history; use only the tellask body (and this sideline dialog’s own history, if any).',
                 '',
                 '---',
             ].join('\n');
-        const body = input.tellaskBody ?? '';
-        return `${intro}\n\n${body}\n`;
+        return `${intro}\n\n${tellaskContent}\n`;
     }
+    if (input.callName !== 'tellask' && input.callName !== 'tellaskSessionless') {
+        throw new Error(`Unsupported callName for assignment formatting: ${input.callName}`);
+    }
+    const mentionLine = requireMentionLine(input.mentionList ?? []);
     const rawTargets = input.collectiveTargets && input.collectiveTargets.length > 0 ? input.collectiveTargets : [to];
     const cleanedTargets = rawTargets.map(trimTrailingDots).filter((t) => t.trim() !== '');
     const uniqueTargets = Array.from(new Set(cleanedTargets));
@@ -80,17 +84,7 @@ function formatAssignmentFromSupdialog(input) {
             ? `你好 @${to}，我是 @${from}。这是一项集体诉请（collective assignment），同时发给：${targetsText}。请作为其中一员并行推进，必要时与其他队友对齐：`
             : `Hi @${to}, this is @${from}. This is a collective assignment sent to: ${targetsText}. Please proceed in parallel as one of the assignees and coordinate with other teammates when needed:`;
     })();
-    return `${greeting}
-
-${(0, fmt_1.markdownQuote)(tellaskHead)}
-${(0, fmt_1.markdownQuote)(input.tellaskBody)}
-`;
-}
-function trimTrailingDots(value) {
-    let out = value;
-    while (out.endsWith('.'))
-        out = out.slice(0, -1);
-    return out;
+    return `${greeting}\n\n${(0, fmt_1.markdownQuote)(mentionLine)}\n${(0, fmt_1.markdownQuote)(tellaskContent)}\n`;
 }
 function formatSupdialogCallPrompt(input) {
     const language = input.language ?? 'en';
@@ -100,35 +94,41 @@ function formatSupdialogCallPrompt(input) {
     const asking = language === 'zh'
         ? `\`@${requireNonEmpty(input.fromAgentId, 'fromAgentId')}\` 回问：`
         : `\`@${requireNonEmpty(input.fromAgentId, 'fromAgentId')}\` TellaskBack:`;
-    return `${hello}
-
-${(0, fmt_1.markdownQuote)(requireNonEmpty(input.supdialogAssignment.tellaskHead, 'assignmentHeadLine'))}
-
-${asking}
-
-${(0, fmt_1.markdownQuote)(requireNonEmpty(input.subdialogRequest.tellaskHead, 'requestHeadLine'))}
-${(0, fmt_1.markdownQuote)(input.subdialogRequest.tellaskBody)}
-`;
+    const supMention = (() => {
+        if (input.supdialogAssignment.callName === 'tellask' ||
+            input.supdialogAssignment.callName === 'tellaskSessionless') {
+            return (0, fmt_1.markdownQuote)(requireMentionLine(input.supdialogAssignment.mentionList ?? []));
+        }
+        return '';
+    })();
+    const subMention = (() => {
+        if (input.subdialogRequest.callName === 'tellask' ||
+            input.subdialogRequest.callName === 'tellaskSessionless') {
+            return (0, fmt_1.markdownQuote)(requireMentionLine(input.subdialogRequest.mentionList ?? []));
+        }
+        return '';
+    })();
+    return `${hello}\n\n${supMention ? `${supMention}\n` : ''}${(0, fmt_1.markdownQuote)(requireNonEmpty(input.supdialogAssignment.tellaskContent, 'assignmentTellaskContent'))}\n\n${asking}\n\n${subMention ? `${subMention}\n` : ''}${(0, fmt_1.markdownQuote)(requireNonEmpty(input.subdialogRequest.tellaskContent, 'requestTellaskContent'))}\n`;
 }
 function formatTeammateResponseContent(input) {
     const language = input.language ?? 'en';
-    const originalCallHeadLine = requireNonEmpty(input.originalCallHeadLine, 'originalCallHeadLine');
-    const isFbrSelfTellask = /^\s*@self\b/.test(originalCallHeadLine);
-    if (isFbrSelfTellask) {
-        const title = language === 'zh' ? '【扪心自问（FBR）支线对话回贴】' : '[FBR @self sideline response]';
-        // Keep response body as plain markdown (no quote) to make it easy to read and integrate.
+    const tellaskContent = requireNonEmpty(input.tellaskContent, 'tellaskContent');
+    const isFbr = input.callName === 'freshBootsReasoning';
+    if (isFbr) {
+        const title = language === 'zh' ? '【扪心自问（FBR）支线对话回贴】' : '[FBR sideline response]';
         return `${title}\n\n${input.responseBody}\n`;
     }
+    if (input.callName !== 'tellask' &&
+        input.callName !== 'tellaskSessionless' &&
+        input.callName !== 'tellaskBack') {
+        throw new Error(`Unsupported callName for teammate response formatting: ${input.callName}`);
+    }
+    const mentionLine = input.callName === 'tellask' || input.callName === 'tellaskSessionless'
+        ? requireMentionLine(input.mentionList ?? [])
+        : '';
     const hello = language === 'zh'
         ? `你好 @${requireNonEmpty(input.requesterId, 'toAgentId')}，@${requireNonEmpty(input.responderId, 'fromAgentId')} 已回复：`
         : `Hi @${requireNonEmpty(input.requesterId, 'toAgentId')}, @${requireNonEmpty(input.responderId, 'fromAgentId')} provided response:`;
     const tail = language === 'zh' ? '针对原始诉请：' : 'regarding the original tellask:';
-    return `${hello}
-
-${(0, fmt_1.markdownQuote)(input.responseBody)}
-
-${tail}
-
-${(0, fmt_1.markdownQuote)(originalCallHeadLine)}
-`;
+    return `${hello}\n\n${(0, fmt_1.markdownQuote)(input.responseBody)}\n\n${tail}\n\n${mentionLine ? `${(0, fmt_1.markdownQuote)(mentionLine)}\n` : ''}${(0, fmt_1.markdownQuote)(tellaskContent)}\n`;
 }

package/dist/snippets/starting.en.md

@@ -19,7 +19,7 @@ description: Start from a blank taskdoc, initialize and launch a new task
 
 ## Constraints:
 
-- Except for taskdoc sections (`change_mind(selector, category)`), do not create new documents unless explicitly requested by the human user; if truly required for the task, tellask @human for permission
+- Except for taskdoc sections (`change_mind(selector, category)`), do not create new documents unless explicitly requested by the human user; if truly required for the task, call `askHuman` for permission
 
 ## Grants:
 

package/dist/snippets/starting.zh.md

@@ -19,7 +19,7 @@ description: 从空白差遣牒开始，初始化并启动新任务
 
 ## 约束：
 
-- 差遣牒章节（change_mind(selector, category)）以外，不得创建新文档，除非人类用户明确要求；若确为任务所需，诉请 @human 获取许可
+- 差遣牒章节（change_mind(selector, category)）以外，不得创建新文档，除非人类用户明确要求；若确为任务所需，使用 `askHuman` 获取许可
 
 ## 授权：
 
@@ -28,4 +28,3 @@ description: 从空白差遣牒开始，初始化并启动新任务
 ## 下一步：
 
 先更新差遣牒，然后开始行动！
-

package/dist/static/assets/{_baseUniq-2IQvcpiv.js → _baseUniq-D4N_zVXV.js}

@@ -1,4 +1,4 @@
-import { aV as isObjectLike, br as baseGetTag, aE as isArray, aT as Symbol$1, bs as arrayLikeKeys, bt as baseKeys, aD as isArrayLike, bu as memoize, bv as isArguments, bw as MapCache, bm as eq, bx as Uint8Array, aW as getTag, a$ as isBuffer, b2 as Stack, by as isTypedArray, aZ as isObject, bz as isLength, bp as isIndex, aF as identity, bn as baseFor, bA as Set } from "./index-CUZD-Ua6.js";
+import { aV as isObjectLike, br as baseGetTag, aE as isArray, aT as Symbol$1, bs as arrayLikeKeys, bt as baseKeys, aD as isArrayLike, bu as memoize, bv as isArguments, bw as MapCache, bm as eq, bx as Uint8Array, aW as getTag, a$ as isBuffer, b2 as Stack, by as isTypedArray, aZ as isObject, bz as isLength, bp as isIndex, aF as identity, bn as baseFor, bA as Set } from "./index-Vrp1PT3b.js";
 var symbolTag$1 = "[object Symbol]";
 function isSymbol(value) {
   return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$1;
@@ -658,4 +658,4 @@ export {
   hasIn as x,
   toString as y
 };
-//# sourceMappingURL=_baseUniq-2IQvcpiv.js.map
+//# sourceMappingURL=_baseUniq-D4N_zVXV.js.map