dominds 1.23.2 → 1.23.4

package/dist/llm/kernel-driver/tellask-special.js

@@ -151,6 +151,7 @@ async function deliverTellaskBackReplyFromDirective(args) {
         responseBody: args.replyContent,
         status: 'completed',
         deliveryMode: args.deliveryMode,
+        directFallbackSource: args.directFallbackSource,
         language: (0, work_language_1.getWorkLanguage)(),
     });
     const targetCallSiteCourse = (0, storage_1.toCallSiteCourseNo)(askBackAskerDialog.currentCourse);
@@ -997,23 +998,6 @@ async function reviveDialogIfUnblocked(dialog, callbacks, reason) {
         },
     });
 }
-function extractLastAssistantResponse(messages, defaultMessage) {
-    let responseText = '';
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        if (msg.type === 'saying_msg' && typeof msg.content === 'string') {
-            responseText = msg.content;
-            break;
-        }
-        if (msg.type === 'thinking_msg' && typeof msg.content === 'string') {
-            responseText = msg.content;
-        }
-    }
-    if (!responseText) {
-        responseText = defaultMessage;
-    }
-    return responseText;
-}
 function findDeliveredTellaskBackReplyOnAskBackAsker(args) {
     // `replyTellaskBack` persists the canonical tellaskBack business result onto the ask-back
     // asker immediately. Type-A orchestration must check that canonical delivery first
@@ -1031,15 +1015,6 @@ function findDeliveredTellaskBackReplyOnAskBackAsker(args) {
     }
     return undefined;
 }
-async function extractAskBackTellaskeePlaintextFallback(args) {
-    try {
-        return extractLastAssistantResponse(args.tellaskeeDialog.msgs, 'AskerDialog completed without producing output.');
-    }
-    catch (err) {
-        log_1.log.warn('Failed to extract askerDialog response for Type A', err);
-        return 'AskerDialog completed with errors.';
-    }
-}
 async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, options) {
     const toolOutputs = [];
     const callName = options.callName;
@@ -1387,7 +1362,7 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                         origin: 'runtime',
                         tellaskReplyDirective: tellaskBackReplyDirective,
                     };
-                    await callbacks.driveDialog(askBackTellaskeeDialog, {
+                    const askBackTellaskeeDriveResult = await callbacks.driveDialog(askBackTellaskeeDialog, {
                         humanPrompt: askerPrompt,
                         waitInQue: true,
                         driveOptions: {
@@ -1407,9 +1382,22 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                         toolOutputs.push(explicitReplyDelivery);
                         return toolOutputs;
                     }
-                    const responseText = await extractAskBackTellaskeePlaintextFallback({
-                        tellaskeeDialog: askBackTellaskeeDialog,
-                    });
+                    const fallbackResponse = askBackTellaskeeDriveResult?.lastAssistantSayingContent !== null &&
+                        askBackTellaskeeDriveResult?.lastAssistantSayingContent !== undefined &&
+                        askBackTellaskeeDriveResult.lastAssistantSayingContent.trim() !== ''
+                        ? {
+                            text: askBackTellaskeeDriveResult.lastAssistantSayingContent,
+                            source: 'saying',
+                        }
+                        : askBackTellaskeeDriveResult?.lastAssistantThinkingContent !== null &&
+                            askBackTellaskeeDriveResult?.lastAssistantThinkingContent !== undefined &&
+                            askBackTellaskeeDriveResult.lastAssistantThinkingContent.trim() !== ''
+                            ? {
+                                text: askBackTellaskeeDriveResult.lastAssistantThinkingContent,
+                                source: 'thinking_only',
+                            }
+                            : undefined;
+                    const responseText = fallbackResponse?.text ?? 'AskerDialog completed without producing output.';
                     const responseContent = (0, inter_dialog_format_1.formatTellaskResponseContent)({
                         callName,
                         callId,
@@ -1420,6 +1408,7 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                         responseBody: responseText,
                         status: 'completed',
                         deliveryMode: 'direct_fallback',
+                        directFallbackSource: fallbackResponse?.source,
                         language: (0, work_language_1.getWorkLanguage)(),
                     });
                     askBackAskerDialog.setSuspensionState('resumed');
@@ -1693,6 +1682,13 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                 }
                 if (result.kind === 'existing' && result.replacedPending !== undefined) {
                     const previousPendingOwner = await resolveDialogWithinRoot(mainDialog, result.previousPendingOwnerId);
+                    // Design boundary:
+                    // A registered-assignment update is accepted once pending state + asker stack are updated,
+                    // but the tellaskee has not necessarily consumed the runtime update prompt yet. Do not
+                    // phrase this replacement notice as "delivered to / being handled by the Side Dialog"
+                    // unless an assignment anchor for the new call is known; phrase it as superseded +
+                    // registered instead. The up-next prompt remains runtime scheduling state, not a durable
+                    // redo log.
                     await finishRegisteredTellaskReplacement({
                         ownerDialog: previousPendingOwner,
                         sideDialog: result.sideDialog,
@@ -1736,6 +1732,10 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     let queuedIntoActiveLoop = false;
                     let queuedRuntimePrompt = false;
                     try {
+                        // Keep registered assignment updates as in-memory up-next scheduling. This deliberately
+                        // avoids turning the queue into a persistence/redo-log protocol: backend restart
+                        // recovery should expose loud facts for the LLM to reason from, not pretend this
+                        // runtime prompt was durably delivered to the tellaskee before it is consumed.
                         result.sideDialog.queueRegisteredAssignmentUpdatePrompt({
                             prompt: resumePrompt.content,
                             msgId: resumePrompt.msgId,

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

@@ -8,6 +8,7 @@ export type KernelDriverDriveOptions = Readonly<{
     suppressDiligencePush?: boolean;
     allowResumeFromInterrupted?: boolean;
     resumeInProgressGeneration?: boolean;
+    criticalUserInterjectionRuntimeGuide?: string;
     noPromptSideDialogResumeEntitlement?: Readonly<{
         ownerDialogId: string;
         reason: 'reply_tellask_back_delivered';
@@ -62,7 +63,7 @@ export type KernelDriverDriveCallOptions = Readonly<{
     driveOptions: KernelDriverDriveOptions;
 }>;
 export type KernelDriverDriveScheduler = (dialog: Dialog, options: KernelDriverDriveCallOptions) => void;
-export type KernelDriverDriveInvoker = (dialog: Dialog, options: KernelDriverDriveCallOptions) => Promise<void>;
+export type KernelDriverDriveInvoker = (dialog: Dialog, options: KernelDriverDriveCallOptions) => Promise<KernelDriverCoreResult | void>;
 export type KernelDriverDriveCallbacks = Readonly<{
     scheduleDrive: KernelDriverDriveScheduler;
     driveDialog: KernelDriverDriveInvoker;
@@ -78,7 +79,7 @@ export type KernelDriverDriveArgs = readonly [
     waitInQue: boolean,
     driveOptions: KernelDriverDriveOptions
 ];
-export type KernelDriverDriveResult = Promise<void>;
+export type KernelDriverDriveResult = Promise<KernelDriverCoreResult | void>;
 export type KernelDriverEmitSayingArgs = [dlg: Dialog, content: string];
 export type KernelDriverEmitSayingResult = Promise<void>;
 export type KernelDriverSupplyResponseArgs = [
@@ -91,7 +92,8 @@ export type KernelDriverSupplyResponseArgs = [
     calleeResponseRef?: {
         course: number;
         genseq: number;
-    }
+    },
+    directFallbackSource?: 'saying' | 'thinking_only'
 ];
 export type KernelDriverSupplyResponseResult = Promise<void>;
 export type KernelDriverRunBackendResult = Promise<void>;
@@ -105,6 +107,8 @@ export type KernelDriverRuntimeState = {
 export type KernelDriverCoreResult = {
     lastAssistantSayingContent: string | null;
     lastAssistantSayingGenseq: number | null;
+    lastAssistantThinkingContent: string | null;
+    lastAssistantThinkingGenseq: number | null;
     lastFunctionCallGenseq: number | null;
     lastAssistantReplyTarget?: KernelDriverSideDialogReplyTarget;
     fbrConclusion?: {

package/dist/log.js

@@ -78,6 +78,39 @@ const DETAIL_INSPECT_PROFILES = [
         maxStringLength: 192,
     },
 ];
+const LOG_KEY_PRIORITY = new Map([
+    'rootId',
+    'selfId',
+    'dialogId',
+    'course',
+    'genseq',
+    'callId',
+    'questionId',
+    'agentId',
+    'toolName',
+    'provider',
+    'model',
+    'dialogClass',
+    'status',
+    'error',
+    'detail',
+    'message',
+    'code',
+    'name',
+    'type',
+].map((key, index) => [key, index]));
+function compareLogObjectKeys(left, right) {
+    const leftPriority = LOG_KEY_PRIORITY.get(left);
+    const rightPriority = LOG_KEY_PRIORITY.get(right);
+    if (leftPriority !== undefined || rightPriority !== undefined) {
+        return (leftPriority ?? Number.MAX_SAFE_INTEGER) - (rightPriority ?? Number.MAX_SAFE_INTEGER);
+    }
+    const leftInternal = left.startsWith('_') || left.startsWith('__');
+    const rightInternal = right.startsWith('_') || right.startsWith('__');
+    if (leftInternal !== rightInternal)
+        return leftInternal ? 1 : -1;
+    return left.localeCompare(right);
+}
 function truncateText(value, maxChars, suffix) {
     if (maxChars <= 0) {
         return { text: '', truncated: value.length > 0 };
@@ -248,7 +281,7 @@ function pruneForLog(value, profile, depth, seen) {
             return { value: `[${ctorName} byteLength=${byteLen}]`, pruned: true };
         }
         const source = value;
-        const allKeys = Object.keys(source).sort();
+        const allKeys = Object.keys(source).sort(compareLogObjectKeys);
         const visibleKeys = allKeys.slice(0, profile.maxObjectKeys);
         const ctorName = getConstructorName(value);
         const reduced = {};
@@ -286,7 +319,7 @@ function inspectAdaptive(value, maxChars) {
             depth: null,
             breakLength: 120,
             compact: false,
-            sorted: true,
+            sorted: false,
             maxArrayLength: profile.maxArrayItems,
             maxStringLength: profile.maxStringLength,
         });

package/dist/persistence.js

@@ -2573,9 +2573,20 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      * Emit stream error for current generation lifecycle (uses active genseq when present)
      */
     async streamError(dialog, error) {
-        log_1.log.error(`Dialog stream error '${error}'`, new Error(), { dialog });
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
         const genseq = dialog.activeGenSeqOrUndefined;
+        log_1.log.error(`Dialog stream error '${error}'`, new Error(), {
+            dialogId: dialog.id.valueOf(),
+            rootId: dialog.id.rootId,
+            selfId: dialog.id.selfId,
+            course,
+            genseq,
+            agentId: dialog.agentId,
+            dialogClass: dialog.constructor.name,
+            status: dialog.status,
+            activeGeneration: dialog.hasActiveGeneration,
+            dialogSnapshot: dialog,
+        });
         // Enhanced stream error event with better error classification
         const streamErrorEvent = {
             type: 'stream_error_evt',

package/dist/recovery/reply-special.js

@@ -32,7 +32,7 @@ async function recoverPendingReplyTellaskCallsForDialog(dialog) {
                 void dispatchDrive(scheduledDialog, options);
             },
             driveDialog: async (scheduledDialog, options) => {
-                await dispatchDrive(scheduledDialog, options);
+                return await dispatchDrive(scheduledDialog, options);
             },
         },
     });

package/dist/runtime/driver-messages.d.ts

@@ -9,8 +9,16 @@ export declare function formatNewCourseStartPrompt(language: LanguageCode, args:
     source: 'clear_mind' | 'critical_auto_clear';
 }): string;
 export declare function formatDiligenceAutoContinuePrompt(language: LanguageCode, diligenceText: string): string;
+type SideDialogDiligenceVariant = 0 | 1 | 2;
+export declare function formatSideDialogDiligenceAutoContinuePrompt(language: LanguageCode, args: {
+    now: Date;
+    tellaskContent: string;
+    replyToolName: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack';
+    variant: SideDialogDiligenceVariant;
+}): string;
 export declare function formatReminderContextGuide(language: LanguageCode): string;
-export declare function formatReminderContextFooter(language: LanguageCode): string;
+export type ReminderContextFollowingDialogState = 'user_message' | 'runtime_notice' | 'none';
+export declare function formatReminderContextFooter(language: LanguageCode, followingState: ReminderContextFollowingDialogState): string;
 export declare function formatReminderItemGuide(language: LanguageCode, reminderId: string, content: string, options?: {
     meta?: unknown;
     scope?: 'dialog' | 'personal' | 'agent_shared';
@@ -37,9 +45,14 @@ export type ContextHealthV3RemediationGuideArgs = {
     promptsTotal: number;
 };
 export declare function formatAgentFacingContextHealthV3RemediationGuide(language: LanguageCode, args: ContextHealthV3RemediationGuideArgs): string;
+export declare function formatAgentFacingCriticalUserInterjectionRemediationGuide(language: LanguageCode, args: {
+    dialogScope: ContextHealthV3RemediationDialogScope;
+    promptsRemainingAfterThis: number;
+}): string;
 export declare function formatDomindsNoteDirectSelfCall(language: LanguageCode): string;
 export declare function formatDomindsNoteFbrDisabled(language: LanguageCode): string;
 export type FbrToollessViolationKind = 'tellask' | 'tool' | 'tellask_and_tool' | 'internal_error';
 export declare function formatDomindsNoteFbrToollessViolation(language: LanguageCode, args: {
     kind: FbrToollessViolationKind;
 }): string;
+export {};

package/dist/runtime/driver-messages.js

@@ -7,6 +7,7 @@ exports.formatRegisteredTellaskTellaskerUpdateNotice = formatRegisteredTellaskTe
 exports.formatRegisteredTellaskTellaskeeUpdateNotice = formatRegisteredTellaskTellaskeeUpdateNotice;
 exports.formatNewCourseStartPrompt = formatNewCourseStartPrompt;
 exports.formatDiligenceAutoContinuePrompt = formatDiligenceAutoContinuePrompt;
+exports.formatSideDialogDiligenceAutoContinuePrompt = formatSideDialogDiligenceAutoContinuePrompt;
 exports.formatReminderContextGuide = formatReminderContextGuide;
 exports.formatReminderContextFooter = formatReminderContextFooter;
 exports.formatReminderItemGuide = formatReminderItemGuide;
@@ -14,6 +15,7 @@ exports.formatQ4HDiligencePushBudgetExhausted = formatQ4HDiligencePushBudgetExha
 exports.formatDomindsNoteTellaskForTeammatesOnly = formatDomindsNoteTellaskForTeammatesOnly;
 exports.formatDomindsNoteQ4HRegisterFailed = formatDomindsNoteQ4HRegisterFailed;
 exports.formatAgentFacingContextHealthV3RemediationGuide = formatAgentFacingContextHealthV3RemediationGuide;
+exports.formatAgentFacingCriticalUserInterjectionRemediationGuide = formatAgentFacingCriticalUserInterjectionRemediationGuide;
 exports.formatDomindsNoteDirectSelfCall = formatDomindsNoteDirectSelfCall;
 exports.formatDomindsNoteFbrDisabled = formatDomindsNoteFbrDisabled;
 exports.formatDomindsNoteFbrToollessViolation = formatDomindsNoteFbrToollessViolation;
@@ -80,12 +82,14 @@ function formatRegisteredTellaskTellaskerUpdateNotice(language) {
     if (language === 'zh') {
         return [
             prefix,
-            '刚才那轮诉请不用再等了；对方接下来会按你刚更新的要求继续处理，后续请以最新要求为准。',
+            '刚才那轮诉请已被你后续发出的新要求取代；运行时已登记这次更新。',
+            '如果目标支线正忙，更新会在下一次安全推进边界进入目标支线；请把目标支线里的更新气泡作为可见确认点。',
         ].join('\n');
     }
     return [
         prefix,
-        'You no longer need to wait on that earlier request. The teammate will continue under your updated request, so treat the latest request as the one now in effect.',
+        'That earlier request has been superseded by your later updated request; runtime has registered the update.',
+        'If the target Side Dialog is busy, the update will enter it at the next safe drive boundary. Use the target Side Dialog update bubble as the visible confirmation point.',
     ].join('\n');
 }
 function formatRegisteredTellaskTellaskeeUpdateNotice(language) {
@@ -151,6 +155,64 @@ function formatDiligenceAutoContinuePrompt(language, diligenceText) {
         trimmed,
     ].join('\n');
 }
+function truncateSideDialogGoal(goal) {
+    const normalized = goal.trim().replace(/\s+/g, ' ');
+    if (normalized.length <= 900)
+        return normalized;
+    return `${normalized.slice(0, 900).trimEnd()}...`;
+}
+function pad2(value) {
+    return String(value).padStart(2, '0');
+}
+function formatSideDialogDiligenceTimestamp(language, date) {
+    const year = date.getFullYear();
+    const month = pad2(date.getMonth() + 1);
+    const day = pad2(date.getDate());
+    const hour = pad2(date.getHours());
+    const minute = pad2(date.getMinutes());
+    const second = pad2(date.getSeconds());
+    return language === 'zh'
+        ? `${year} 年 ${month} 月 ${day} 日 ${hour} 时 ${minute} 分 ${second} 秒`
+        : `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+}
+function formatSideDialogDiligenceAutoContinuePrompt(language, args) {
+    const noticePrefix = formatSystemNoticePrefix(language);
+    const goal = truncateSideDialogGoal(args.tellaskContent);
+    const timestamp = formatSideDialogDiligenceTimestamp(language, args.now);
+    const replyCall = `${args.replyToolName}({ replyContent })`;
+    if (language === 'zh') {
+        const lines = args.variant === 0
+            ? [
+                `${noticePrefix} 现在是 ${timestamp}，这是一条支线对话运行时续推指令，不是新的用户诉求。`,
+                `请继续完成当前诉请任务；若已经形成可交付结果，必须调用 \`${replyCall}\` 回复诉请者。`,
+            ]
+            : args.variant === 1
+                ? [
+                    `${noticePrefix} 现在是 ${timestamp}。当前支线还不能停在空回复或仅确认状态。`,
+                    `围绕下面的诉请目标继续推进；准备好最终交付后，精确调用 \`${replyCall}\` 回复。`,
+                ]
+                : [
+                    `${noticePrefix} 当前时间：${timestamp}。系统检测到这条支线需要继续推进。`,
+                    `请直接执行下一步有效动作，或在结果已完整时调用 \`${replyCall}\` 完成回贴。`,
+                ];
+        return [...lines, '', '当前诉请目标：', goal].join('\n');
+    }
+    const lines = args.variant === 0
+        ? [
+            `${noticePrefix} It is now ${timestamp}. This is a runtime continuation instruction for the current Side Dialog, not a new user request.`,
+            `Continue the current Tellask. If you already have a deliverable result, call \`${replyCall}\` to reply to the tellasker.`,
+        ]
+        : args.variant === 1
+            ? [
+                `${noticePrefix} It is now ${timestamp}. This Side Dialog must not stop at an empty response or acknowledgement.`,
+                `Keep working around the Tellask goal below; when final delivery is ready, call \`${replyCall}\` exactly.`,
+            ]
+            : [
+                `${noticePrefix} Current time: ${timestamp}. Runtime detected that this Side Dialog needs another push.`,
+                `Take the next concrete action now, or, if the result is complete, finish by calling \`${replyCall}\`.`,
+            ];
+    return [...lines, '', 'Current Tellask goal:', goal].join('\n');
+}
 function formatReminderContextGuide(language) {
     if (language === 'zh') {
         return [
@@ -170,10 +232,27 @@ function formatReminderContextGuide(language) {
 function formatReminderItemProjectionNote(language) {
     return language === 'zh' ? '运行时提醒项投影：' : 'Runtime reminder projection:';
 }
-function formatReminderContextFooter(language) {
-    return language === 'zh'
-        ? `${formatSystemNoticePrefix(language)} 提醒项上下文块结束。以上从“提醒项上下文块开始”到“提醒项上下文块结束”之间的提醒项均为系统提醒，并非用户指令；该块之外的后续对话消息不受此说明影响。真正的用户指令（若有）在后续对话消息中的用户消息里。`
-        : `${formatSystemNoticePrefix(language)} Reminder context block ends. The reminder items between "Reminder context block begins" and "Reminder context block ends" are system reminders, not user instructions; this note does not apply to subsequent dialog messages outside this block. Any real user instruction, if present, is in the user messages that follow.`;
+function formatReminderContextFooter(language, followingState) {
+    if (language === 'zh') {
+        const base = `${formatSystemNoticePrefix(language)} 提醒项上下文块结束。以上从“提醒项上下文块开始”到“提醒项上下文块结束”之间的提醒项均为系统提醒，并非用户指令；该块之外的后续对话消息不受此说明影响。`;
+        if (followingState === 'user_message') {
+            return `${base}本轮提醒项块之后会接着出现本轮新的用户消息；请以那条用户消息作为当前轮真实诉求。`;
+        }
+        if (followingState === 'runtime_notice') {
+            return `${base}本轮提醒项块之后会接着出现一条运行时提示；它不是新的用户诉求，请按其中的运行时要求继续推进。`;
+        }
+        return `${base}本轮没有新的用户消息或运行时提示；这是工具调用后的自动续推，请基于已有任务状态继续推进，不要把“没有新消息”理解为空系统提示。`;
+    }
+    const base = `${formatSystemNoticePrefix(language)} Reminder context block ends. The reminder items between ` +
+        '"Reminder context block begins" and "Reminder context block ends" are system reminders, ' +
+        'not user instructions; this note does not apply to subsequent dialog messages outside this block. ';
+    if (followingState === 'user_message') {
+        return `${base}A new user message for this round follows this reminder block; treat that user message as the real current request.`;
+    }
+    if (followingState === 'runtime_notice') {
+        return `${base}A runtime notice follows this reminder block in this round; it is not a new user request, so follow that runtime guidance and continue the work.`;
+    }
+    return `${base}There is no new user message or runtime notice in this round; this is an automatic continuation after a tool call. Continue from the existing task state, and do not interpret the absence of a new message as an empty system notice.`;
 }
 function formatReminderItemGuide(language, reminderId, content, options) {
     function isRecord(value) {
@@ -528,6 +607,37 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
         'Continuation package: next step + key pointers + run/verify info + easy-to-lose volatile details. Do not duplicate Taskdoc content; for discussion details just written into Taskdoc in this course, only remind the next course to review Taskdoc first. During critical remediation in the current course, do not start the new-course cleanup early; once the system actually starts the new course, the first step is to reconcile rough bridge reminders by removing redundancy, correcting biased or distorted bridge notes, and merging/compressing them into high-quality reminders.',
     ].join('\n');
 }
+function formatAgentFacingCriticalUserInterjectionRemediationGuide(language, args) {
+    const isSideDialog = args.dialogScope === 'sideDialog';
+    if (language === 'zh') {
+        return [
+            `${formatSystemNoticePrefix(language)} 上下文状态：🔴 告急；收到用户插话`,
+            '',
+            '下面紧跟的是一条真实用户消息，不是普通运行时处置提示；必须把它当作有效用户轮次处理，让用户看到你已经接住了这次插话。',
+            '',
+            `这次用户轮次已计入告急处置倒计数。系统最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
+            '',
+            isSideDialog
+                ? '行动：先直接回应用户这条插话；不要继续扩张上下文，不要维护差遣牒，也不要整理差遣牒更新提案。若还需要保留接续信息，只维护足够详尽的接续包提醒项，然后尽快 clear_mind。'
+                : '行动：先直接回应用户这条插话；不要继续扩张上下文。若仍有当前对话中尚未落实到文档、且下一程需要知会的讨论细节，先落到差遣牒合适章节；再把差遣牒仍未覆盖、但恢复工作会丢的信息新增提醒项带过桥，然后尽快 clear_mind。',
+            '',
+            '要求：不要因为 critical 状态沉默、挂起或只回复“收到/好的”。若必须调用工具才能回答用户，工具结果回来后继续给出用户可见回复；保持回答聚焦，并把清理/换程作为紧随其后的处置动作。',
+        ].join('\n');
+    }
+    return [
+        `${formatSystemNoticePrefix(language)} Context state: 🔴 critical; user interjection received`,
+        '',
+        'The next message is a real user message, not an ordinary runtime remediation notice. Treat it as an effective user turn and make the system reaction visible to the user.',
+        '',
+        `This user turn has been counted toward critical remediation. System will remind you ${args.promptsRemainingAfterThis} more time(s), then automatically clear mind.`,
+        '',
+        isSideDialog
+            ? 'Action: answer this user interjection directly first. Do not expand context, do not maintain Taskdoc, and do not draft Taskdoc update proposals. If continuation info still needs preserving, maintain sufficiently detailed continuation-package reminders only, then clear_mind as soon as possible.'
+            : 'Action: answer this user interjection directly first. Do not expand context. If current-dialog discussion details are still undocumented but the next course needs to know them, record them into the appropriate Taskdoc sections first; then add bridge reminders for information still not covered by Taskdoc but easy to lose, and clear_mind as soon as possible.',
+        '',
+        'Requirement: do not go silent, suspend, or reply only with "acknowledged/ok" because context is critical. If a tool call is necessary to answer the user, continue with a user-visible reply after the tool result returns; keep the answer focused, and perform cleanup/course transition immediately after that.',
+    ].join('\n');
+}
 function formatDomindsNoteDirectSelfCall(language) {
     if (language === 'zh') {
         return ('错误：不允许通过 `tellask` / `tellaskSessionless` 对当前 agent 发起自诉请。\n' +

package/dist/runtime/inter-dialog-format.d.ts

@@ -48,6 +48,7 @@ export type TellaskResponseFormatInput = {
     responseBody: string;
     status?: 'completed' | 'failed';
     deliveryMode?: 'reply_tool' | 'direct_fallback';
+    directFallbackSource?: 'saying' | 'thinking_only';
     language?: LanguageCode;
 };
 export type TellaskReplacementNoticeFormatInput = {

package/dist/runtime/inter-dialog-format.js

@@ -261,9 +261,13 @@ function formatTellaskResponseContent(input) {
     const marker = getRuntimeTransferMarker(input);
     const markerPrefix = marker ? `${marker}\n\n` : '';
     const deliveryNotice = input.deliveryMode === 'direct_fallback'
-        ? language === 'zh'
-            ? '> 系统提示：本次回贴未调用 replyTellask* 工具，Dominds 已按 direct-reply fallback 投递，并保留此标记便于追踪。\n\n'
-            : '> System note: this reply did not use a replyTellask* tool. Dominds delivered it via direct-reply fallback and kept this marker for traceability.\n\n'
+        ? input.directFallbackSource === 'thinking_only'
+            ? language === 'zh'
+                ? '> 系统提示：本次回贴未调用 replyTellask* 工具，且模型仅产出 thinking；Dominds 已将该 thinking 内容按 direct-reply fallback 投递，并保留此标记便于追踪。\n\n'
+                : '> System note: this reply did not use a replyTellask* tool, and the model only produced thinking. Dominds delivered that thinking content via direct-reply fallback and kept this marker for traceability.\n\n'
+            : language === 'zh'
+                ? '> 系统提示：本次回贴未调用 replyTellask* 工具，Dominds 已按 direct-reply fallback 投递，并保留此标记便于追踪。\n\n'
+                : '> System note: this reply did not use a replyTellask* tool. Dominds delivered it via direct-reply fallback and kept this marker for traceability.\n\n'
         : '';
     if (isFbr) {
         const title = language === 'zh' ? '【扪心自问（FBR）支线对话回贴】' : '[FBR Side Dialog response]';

package/dist/server/websocket-handler.js

@@ -707,7 +707,6 @@ async function maybeTriggerImmediateDiligencePrompt(mainDialog) {
         const team = await team_1.Team.load();
         const prepared = await (0, runtime_2.maybePrepareDiligenceAutoContinuePrompt)({
             dlg: mainDialog,
-            isMainDialog: true,
             remainingBudget: mainDialog.diligencePushRemainingBudget,
             diligencePushMax: resolveMemberDiligencePushMax(team, mainDialog.agentId),
         });

package/dist/tools/team_mgmt-manual.js

@@ -114,7 +114,7 @@ async function renderTeamMgmtGuideContent(language, topicsRaw = []) {
                     '`model_param_options` 可选：用于记录该 provider 支持的 `.minds/team.yaml model_params` 选项（文档用途）。',
                     '`apiQuirks` 可选：写在 `providers.<providerKey>.apiQuirks`，类型是 `string|string[]`；需要多个 quirk 时用数组，例如 `apiQuirks: [same-context-empty-response]`。它是 provider 级 transport / 网关兼容开关，用来描述“这个供应商/网关的 API 有非标准行为”，不是 `.minds/team.yaml` 的成员参数，也不是 `model_params`。',
                     '使用原则：只有在你确认某个上游网关确实偏离了标准协议，而且 Dominds 已为这个偏差实现了命名 quirk 时才配置；不要把它当作随意调参入口。当前实现里，未知 quirk 值通常不会报错，但也不会带来任何效果。',
-                    '当前已知示例：OpenAI Responses 包装层支持 `apiQuirks: xcode.best`（或数组里包含它），用于识别 vendor keepalive、处理 xcode.best 特有的失败模式，以及把网关返回的 HTML 版 502 Bad Gateway 错误页和 `500 auth_unavailable: no auth available` 这类基础设施失败归类为 conservative 策略重试。OpenAI-compatible Chat Completions 包装层支持 `apiQuirks: same-context-empty-response`，用于“同一对话 generation 上下文连续返回 empty response”时先做少量临时重试；也支持内置 `kimi-code` provider 使用的 `apiQuirks: kimi-code`，用于 Kimi Code 专用 User-Agent、`prompt_cache_key` 和 `thinking`/`reasoning_effort` 请求整形。最小示例：\n```yaml\nproviders:\n  my_gateway:\n    apiType: openai-compatible\n    baseUrl: https://example.invalid/v1\n    apiKeyEnvVar: MY_GATEWAY_API_KEY\n    apiQuirks: same-context-empty-response\n    models:\n      my_model: { name: "upstream-model-id" }\n```',
+                    '当前已知示例：OpenAI Responses 包装层支持 `apiQuirks: xcode.best`（或数组里包含它），用于识别 vendor keepalive、处理 xcode.best 特有的失败模式，以及把网关返回的 HTML 版 502 Bad Gateway 错误页和 `500 auth_unavailable: no auth available` 这类基础设施失败归类为 conservative 策略重试。OpenAI-compatible Chat Completions 包装层支持 `apiQuirks: same-context-empty-response`，用于“同一对话 generation 上下文连续返回 empty response”时先做少量临时重试；支持 `apiQuirks: volcengine-invalid-parameter-aggressive-retry`，用于火山方舟 Coding Plan 偶发 `400 InvalidParameter` 但同 payload 可重放成功的场景，将其归类为 aggressive 策略重试；也支持内置 `kimi-code` provider 使用的 `apiQuirks: kimi-code`，用于 Kimi Code 专用 User-Agent（`KimiCLI/Dominds/<version>`）、`prompt_cache_key` 和 `thinking`/`reasoning_effort` 请求整形。最小示例：\n```yaml\nproviders:\n  my_gateway:\n    apiType: openai-compatible\n    baseUrl: https://example.invalid/v1\n    apiKeyEnvVar: MY_GATEWAY_API_KEY\n    apiQuirks: same-context-empty-response\n    models:\n      my_model: { name: "upstream-model-id" }\n```',
                     '边界提醒：`apiQuirks` 只影响实现里显式消费它的 provider/generator。就当前实现看，OpenAI Responses 与 OpenAI-compatible 路径会读取它；不要假设所有 `apiType` 都支持或需要它。若配置后行为仍异常，应继续检查上游网关文档、抓流事件类型，并结合 `team_mgmt_check_provider(...)` / 运行日志排查。',
                 ])
             : fmtHeader('.minds/llm.yaml') +
@@ -128,7 +128,7 @@ async function renderTeamMgmtGuideContent(language, topicsRaw = []) {
                     'Optional: `model_param_options` documents `.minds/team.yaml model_params` knobs (documentation only).',
                     '`apiQuirks` is optional under `providers.<providerKey>.apiQuirks`, with type `string|string[]`; use an array for multiple quirks, for example `apiQuirks: [same-context-empty-response]`. It is a provider-level transport / gateway compatibility switch for non-standard upstream API behavior. It is not a `.minds/team.yaml` member field and not part of `model_params`.',
                     'Use it only when you have confirmed that an upstream gateway deviates from the expected protocol and Dominds has an explicitly named quirk for that deviation. Do not treat it as a generic tuning field. In the current implementation, unknown quirk values are usually ignored rather than rejected, so a typo may silently do nothing.',
-                    'Known current example: the OpenAI Responses wrapper supports `apiQuirks: xcode.best` (or an array containing it) for vendor keepalive recognition, xcode.best-specific failures, and gateway-returned HTML 502 Bad Gateway plus `500 auth_unavailable: no auth available` infrastructure failures. The OpenAI-compatible Chat Completions wrapper supports `apiQuirks: same-context-empty-response` for repeated empty responses in the same dialog generation context, and `apiQuirks: kimi-code` for the built-in Kimi Code provider request shaping: Dominds User-Agent, `prompt_cache_key`, and `thinking`/`reasoning_effort`. Minimal example:\n```yaml\nproviders:\n  my_gateway:\n    apiType: openai-compatible\n    baseUrl: https://example.invalid/v1\n    apiKeyEnvVar: MY_GATEWAY_API_KEY\n    apiQuirks: same-context-empty-response\n    models:\n      my_model: { name: "upstream-model-id" }\n```',
+                    'Known current example: the OpenAI Responses wrapper supports `apiQuirks: xcode.best` (or an array containing it) for vendor keepalive recognition, xcode.best-specific failures, and gateway-returned HTML 502 Bad Gateway plus `500 auth_unavailable: no auth available` infrastructure failures. The OpenAI-compatible Chat Completions wrapper supports `apiQuirks: same-context-empty-response` for repeated empty responses in the same dialog generation context; `apiQuirks: volcengine-invalid-parameter-aggressive-retry` for Volcano Ark Coding Plan transient `400 InvalidParameter` failures where the same payload can succeed on replay, classified as aggressive retry; and `apiQuirks: kimi-code` for the built-in Kimi Code provider request shaping: `KimiCLI/Dominds/<version>` User-Agent, `prompt_cache_key`, and `thinking`/`reasoning_effort`. Minimal example:\n```yaml\nproviders:\n  my_gateway:\n    apiType: openai-compatible\n    baseUrl: https://example.invalid/v1\n    apiKeyEnvVar: MY_GATEWAY_API_KEY\n    apiQuirks: same-context-empty-response\n    models:\n      my_model: { name: "upstream-model-id" }\n```',
                     'Boundary reminder: `apiQuirks` only affects providers/generators that explicitly read it in code. In the current implementation, the OpenAI Responses and OpenAI-compatible paths consume it; do not assume every `apiType` supports or needs it. If behavior is still wrong after setting it, continue with upstream gateway docs, raw stream event inspection, and `team_mgmt_check_provider(...)` / runtime logs.',
                 ]);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.23.2",
+  "version": "1.23.4",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {
@@ -52,8 +52,8 @@
     "ws": "^8.19.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
-    "@longrun-ai/kernel": "1.13.1",
     "@longrun-ai/codex-auth": "0.13.0",
+    "@longrun-ai/kernel": "1.13.1",
     "@longrun-ai/shell": "1.13.1"
   },
   "devDependencies": {

package/webapp/dist/assets/{_basePickBy-C3SVVywm.js → _basePickBy-DMD1UhXs.js}

@@ -1,5 +1,5 @@
-import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-egNq6cCa.js";
-import { aU as isObject, aC as baseRest, aV as isIterateeCall, aW as keysIn, aX as eq, aY as isArrayLike, aZ as isArray, a_ as identity, a$ as isIndex, b0 as assignValue } from "./index-CGbZlct2.js";
+import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-CsE8Qvwt.js";
+import { aU as isObject, aC as baseRest, aV as isIterateeCall, aW as keysIn, aX as eq, aY as isArrayLike, aZ as isArray, a_ as identity, a$ as isIndex, b0 as assignValue } from "./index-DgfF56L4.js";
 var reWhitespace = /\s/;
 function trimmedEndIndex(string) {
   var index = string.length;
@@ -193,4 +193,4 @@ export {
   map as m,
   toFinite as t
 };
-//# sourceMappingURL=_basePickBy-C3SVVywm.js.map
+//# sourceMappingURL=_basePickBy-DMD1UhXs.js.map