dominds 1.23.5 → 1.23.7

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

@@ -23,6 +23,26 @@ const idle_reminder_wake_1 = require("./idle-reminder-wake");
 const reply_guidance_1 = require("./reply-guidance");
 const sideDialog_1 = require("./sideDialog");
 const tellask_special_1 = require("./tellask-special");
+function buildRuntimeReplyReminderFollowUp(args) {
+    const common = {
+        prompt: args.prompt,
+        msgId: (0, id_1.generateShortId)(),
+        grammar: 'markdown',
+        origin: 'runtime',
+        userLanguageCode: args.language,
+        tellaskReplyDirective: args.directive,
+    };
+    return args.sideDialogReplyTarget === undefined
+        ? {
+            kind: 'runtime_reply_reminder',
+            ...common,
+        }
+        : {
+            kind: 'runtime_sideDialog_reply_reminder',
+            ...common,
+            sideDialogReplyTarget: args.sideDialogReplyTarget,
+        };
+}
 async function queueReplyReminderFollowUp(args) {
     if (args.followUp.kind === 'runtime_sideDialog_reply_reminder') {
         await args.dialog.queueRuntimeSideDialogPrompt({
@@ -74,6 +94,10 @@ function resolveDirectFallbackResponse(args) {
             source: 'saying',
         };
     }
+    // Thinking-only output is intentionally a fallback candidate: some providers/models can finish a
+    // Side Dialog with useful content in thinking and no public saying. This helper only extracts the
+    // candidate; callers below must still reject it when a same-round function/tellask call needs
+    // auto-continuation, when the dialog is suspended, or when another follow-up prompt is queued.
     if (args.driveResult.lastAssistantThinkingContent !== null &&
         args.driveResult.lastAssistantThinkingContent.trim() !== '') {
         if (typeof args.driveResult.lastAssistantThinkingGenseq !== 'number' ||
@@ -185,6 +209,79 @@ async function loadPendingDiagnosticsSnapshot(args) {
         };
     }
 }
+async function hasAssistantOutputAfterAssignmentAnchor(args) {
+    const events = await persistence_1.DialogPersistence.loadCourseEvents(args.dialog.id, args.dialog.currentCourse, args.dialog.status);
+    let assignmentGenseq;
+    for (const event of events) {
+        if (event.type === 'tellask_anchor_record' &&
+            event.anchorRole === 'assignment' &&
+            event.callId === args.callId) {
+            assignmentGenseq = event.genseq;
+            continue;
+        }
+        if (assignmentGenseq !== undefined &&
+            (event.type === 'agent_thought_record' || event.type === 'agent_words_record') &&
+            event.genseq >= assignmentGenseq &&
+            event.content.trim() !== '') {
+            return true;
+        }
+    }
+    return false;
+}
+async function resolveStrandedSideDialogReplyReminderFollowUp(args) {
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dialog.id, args.dialog.status);
+    const displayState = latest?.displayState;
+    const isRecoverableProjection = displayState?.kind === 'idle_waiting_user' ||
+        (displayState?.kind === 'stopped' && displayState.reason.kind === 'pending_reply_obligation');
+    if (!latest ||
+        !isRecoverableProjection ||
+        latest.pendingCourseStartPrompt !== undefined ||
+        latest.executionMarker?.kind === 'dead') {
+        return undefined;
+    }
+    const directive = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(args.dialog);
+    if (!directive) {
+        return undefined;
+    }
+    const ownerDialogId = directive.targetDialogId.trim();
+    if (ownerDialogId === '') {
+        throw new Error(`stranded sideDialog reply recovery invariant violation: empty targetDialogId ` +
+            `(dialogId=${args.dialog.id.valueOf()}, targetCallId=${directive.targetCallId})`);
+    }
+    const pending = await persistence_1.DialogPersistence.loadPendingSideDialogs(new dialog_1.DialogID(ownerDialogId, args.dialog.id.rootId), args.dialog.status);
+    const pendingRecord = pending.find((record) => record.sideDialogId === args.dialog.id.selfId && record.callId === directive.targetCallId);
+    if (!pendingRecord) {
+        return undefined;
+    }
+    if (!(await hasAssistantOutputAfterAssignmentAnchor({
+        dialog: args.dialog,
+        callId: pendingRecord.callId,
+    }))) {
+        return undefined;
+    }
+    const language = (0, work_language_1.getWorkLanguage)();
+    const sideDialogReplyTarget = {
+        ownerDialogId,
+        callType: pendingRecord.callType,
+        callId: pendingRecord.callId,
+        callSiteCourse: pendingRecord.callSiteCourse,
+        callSiteGenseq: pendingRecord.callSiteGenseq,
+    };
+    return {
+        kind: 'runtime_sideDialog_reply_reminder',
+        prompt: await buildReplyToolReminderPrompt({
+            dlg: args.dialog,
+            directive,
+            language,
+        }),
+        msgId: (0, id_1.generateShortId)(),
+        grammar: 'markdown',
+        origin: 'runtime',
+        userLanguageCode: language,
+        tellaskReplyDirective: directive,
+        sideDialogReplyTarget,
+    };
+}
 async function clearConsumedDeferredRootQueueIfIdle(dialog) {
     if (dialog.id.selfId !== dialog.id.rootId) {
         return;
@@ -366,6 +463,8 @@ async function inspectNoPromptSideDialogDrive(args) {
     const inProgressGenerationResumeAllowed = args.driveOptions?.resumeInProgressGeneration === true;
     const supplyResponseParentReviveAllowed = source === 'kernel_driver_supply_response_parent_revive' &&
         hasNoPromptSideDialogResumeEntitlement(args.dialog, args.driveOptions);
+    const pendingReplyObligationResumeAllowed = latest?.executionMarker?.kind === 'interrupted' &&
+        latest.executionMarker.reason.kind === 'pending_reply_obligation';
     if (lastEvent?.type === 'tellask_anchor_record' && lastEvent.anchorRole === 'response') {
         return {
             shouldReject: true,
@@ -378,7 +477,8 @@ async function inspectNoPromptSideDialogDrive(args) {
     }
     if (!explicitInterruptedResumeAllowed &&
         !inProgressGenerationResumeAllowed &&
-        !supplyResponseParentReviveAllowed) {
+        !supplyResponseParentReviveAllowed &&
+        !pendingReplyObligationResumeAllowed) {
         return {
             shouldReject: true,
             source,
@@ -558,6 +658,7 @@ async function executeDriveRound(args) {
     let activeRunPrimed = false;
     let ownsActiveRun = false;
     let interruptedBySignal = false;
+    let shouldRefreshDisplayStateAfterActiveRunCleared = false;
     let followUp;
     let driveResult;
     let sideDialogReplyTarget;
@@ -640,6 +741,29 @@ async function executeDriveRound(args) {
         // suspended by pending Q4H or sideDialogs. This prevents duplicate generations when
         // multiple wake-ups race around the same sideDialog completion boundary.
         if (!humanPrompt) {
+            if (dialog instanceof dialog_1.SideDialog && !dialog.hasUpNext()) {
+                const strandedReplyReminder = await resolveStrandedSideDialogReplyReminderFollowUp({
+                    dialog,
+                });
+                if (strandedReplyReminder !== undefined) {
+                    await queueReplyReminderFollowUp({ dialog, followUp: strandedReplyReminder });
+                    args.scheduleDrive(dialog, {
+                        waitInQue: true,
+                        driveOptions: {
+                            source: 'kernel_driver_follow_up',
+                            reason: 'follow_up_prompt',
+                        },
+                    });
+                    log_1.log.warn('kernel-driver recovered stranded sideDialog reply obligation by queueing reply reminder', undefined, {
+                        dialogId: dialog.id.valueOf(),
+                        rootId: dialog.id.rootId,
+                        selfId: dialog.id.selfId,
+                        targetCallId: strandedReplyReminder.tellaskReplyDirective.targetCallId,
+                        targetOwnerDialogId: strandedReplyReminder.sideDialogReplyTarget.ownerDialogId,
+                    });
+                    return;
+                }
+            }
             if (dialog instanceof dialog_1.SideDialog && !dialog.hasUpNext()) {
                 try {
                     const inspection = await inspectNoPromptSideDialogDrive({ dialog, driveOptions });
@@ -899,12 +1023,20 @@ async function executeDriveRound(args) {
                 (driveResult.fbrConclusion !== undefined ||
                     resolveDirectFallbackResponse({ driveResult, dialog }) !== undefined)) {
                 if (driveResult.fbrConclusion) {
-                    await (0, sideDialog_1.supplySideDialogResponseToAssignedAskerIfPendingV2)({
+                    const suppliedFbrConclusion = await (0, sideDialog_1.supplySideDialogResponseToAssignedAskerIfPendingV2)({
                         sideDialog: dialog,
                         responseText: driveResult.fbrConclusion.responseText,
                         responseGenseq: driveResult.fbrConclusion.responseGenseq,
+                        replyResolution: {
+                            callId: driveResult.fbrConclusion.replyResolutionCallId,
+                            replyCallName: 'replyTellaskSessionless',
+                        },
                         scheduleDrive: args.scheduleDrive,
                     });
+                    if (!suppliedFbrConclusion) {
+                        throw new Error(`FBR conclusion delivery invariant violation: no pending asker target for dialog=${dialog.id.valueOf()}`);
+                    }
+                    shouldRefreshDisplayStateAfterActiveRunCleared = true;
                 }
                 else {
                     const directFallbackResponse = resolveDirectFallbackResponse({ driveResult, dialog });
@@ -916,8 +1048,10 @@ async function executeDriveRound(args) {
                         driveResult.lastFunctionCallGenseq > 0 &&
                         directFallbackResponse.responseGenseq <= driveResult.lastFunctionCallGenseq;
                     if (hasInProgressFunctionCall) {
-                        // Any function call means execution is still in-progress. Only supply when the tellaskee
-                        // has produced a newer assistant saying after the latest function call.
+                        // A candidate direct fallback, including thinking-only output, must be newer than the
+                        // latest same-round function/tellask call. Otherwise the call is still the active move
+                        // and may auto-continue; the candidate is merely pre-tool reasoning/progress, not final
+                        // tellasker delivery.
                         log_1.log.debug('kernel-driver skip sideDialog response supply because latest assistant output is not after function calls', undefined, {
                             rootId: dialog.id.rootId,
                             selfId: dialog.id.selfId,
@@ -948,35 +1082,16 @@ async function executeDriveRound(args) {
                             else {
                                 if (!activePromptWasReplyToolReminder) {
                                     const language = (0, work_language_1.getWorkLanguage)();
-                                    followUp =
-                                        sideDialogReplyTarget === undefined
-                                            ? {
-                                                kind: 'runtime_reply_reminder',
-                                                prompt: await buildReplyToolReminderPrompt({
-                                                    dlg: dialog,
-                                                    directive: activeTellaskReplyDirective,
-                                                    language,
-                                                }),
-                                                msgId: (0, id_1.generateShortId)(),
-                                                grammar: 'markdown',
-                                                origin: 'runtime',
-                                                userLanguageCode: language,
-                                                tellaskReplyDirective: activeTellaskReplyDirective,
-                                            }
-                                            : {
-                                                kind: 'runtime_sideDialog_reply_reminder',
-                                                prompt: await buildReplyToolReminderPrompt({
-                                                    dlg: dialog,
-                                                    directive: activeTellaskReplyDirective,
-                                                    language,
-                                                }),
-                                                msgId: (0, id_1.generateShortId)(),
-                                                grammar: 'markdown',
-                                                origin: 'runtime',
-                                                userLanguageCode: language,
-                                                tellaskReplyDirective: activeTellaskReplyDirective,
-                                                sideDialogReplyTarget,
-                                            };
+                                    followUp = buildRuntimeReplyReminderFollowUp({
+                                        directive: activeTellaskReplyDirective,
+                                        prompt: await buildReplyToolReminderPrompt({
+                                            dlg: dialog,
+                                            directive: activeTellaskReplyDirective,
+                                            language,
+                                        }),
+                                        language,
+                                        sideDialogReplyTarget,
+                                    });
                                     log_1.log.debug('kernel-driver queued sideDialog replyTellask reminder after plain reply', undefined, {
                                         dialogId: dialog.id.valueOf(),
                                         targetCallId: activeTellaskReplyDirective.targetCallId,
@@ -1064,6 +1179,8 @@ async function executeDriveRound(args) {
                     Number.isFinite(driveResult.lastFunctionCallGenseq) &&
                     driveResult.lastFunctionCallGenseq > 0 &&
                     directFallbackResponse.responseGenseq <= driveResult.lastFunctionCallGenseq;
+                // Same rule as Side Dialog final delivery: direct fallback is allowed only after the
+                // candidate content is known to be post-tool and no same-round call is waiting to continue.
                 if (!hasInProgressFunctionCall) {
                     if (!activePromptWasReplyToolReminder) {
                         const language = (0, work_language_1.getWorkLanguage)();
@@ -1226,6 +1343,18 @@ async function executeDriveRound(args) {
         if (activeRunPrimed && ownsActiveRun) {
             (0, dialog_display_state_1.clearActiveRun)(dialog.id);
         }
+        if (shouldRefreshDisplayStateAfterActiveRunCleared && !(0, dialog_display_state_1.hasActiveRun)(dialog.id)) {
+            try {
+                await (0, dialog_display_state_1.setDialogDisplayState)(dialog.id, await (0, dialog_display_state_1.computeIdleDisplayState)(dialog));
+            }
+            catch (error) {
+                log_1.log.warn('kernel-driver failed to refresh display state after FBR auto-delivery', error, {
+                    dialogId: dialog.id.valueOf(),
+                    rootId: dialog.id.rootId,
+                    selfId: dialog.id.selfId,
+                });
+            }
+        }
         release();
         (0, idle_reminder_wake_1.maybeStartIdleReminderWake)(dialog, {
             scheduleDrive: args.scheduleDrive,

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

@@ -867,6 +867,8 @@ async function runLlmRequestWithRetry(params) {
                         errorText: detail,
                     },
                 });
+            }
+            if (failure.kind === 'rejected' && handledFailure.handling.kind !== 'give_up') {
                 let streamErrorEmitted = false;
                 try {
                     await params.dlg.streamError(detail);
@@ -941,7 +943,7 @@ async function runLlmRequestWithRetry(params) {
                             reason: interruptionReason,
                         });
                     }
-                    log_1.log.warn('LLM retriable failure stopped retry flow', undefined, {
+                    log_1.log.warn('LLM failure stopped retry flow', undefined, {
                         provider: params.provider,
                         dialogId: params.dlg.id.valueOf(),
                         rootId: params.dlg.id.rootId,

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

@@ -114,6 +114,7 @@ export type KernelDriverCoreResult = {
     fbrConclusion?: {
         responseText: string;
         responseGenseq: number;
+        replyResolutionCallId: string;
     };
 };
 export declare function createKernelDriverRuntimeState(): KernelDriverRuntimeState;

package/dist/minds/system-prompt.js

@@ -130,7 +130,7 @@ function buildSideDialogTellaskerReplyMarkerRules(language) {
             '- 当前支线未完成时，不要默认直接 `tellaskBack`。先判断当前团队规程/SOP/职责卡能否明确负责人：若能明确且属于执行性处理，直接 `tellask` / `tellaskSessionless` 对应负责人；只有当必须向诉请者补充需求、做业务裁决、澄清验收口径、提供缺失输入，或现有规程无法明确判责时，才发起 `tellaskBack({ tellaskContent: "..." })`，并在 `tellaskContent` 中给出具体问题。',
             '- 是否存在“待你收口的跨对话回复义务”、以及精确该调用哪个 reply 函数，均由运行时程序化判断；运行时会在 assignment 或最新 runtime/user 提示里直接点名。',
             '- 若运行时点名了精确 reply 函数名，你只需调用那个被点名的函数；不要自己判断 `reply*` 变体。禁止调用 `tellaskBack` 发送最终结果，也禁止用 `tellask` 向诉请者发送最终结果。',
-            `- 只有在运行时当前明确点名了某个精确 reply 函数，且你通过那个函数回复时，运行时才会把该回复作为完成结果投递给诉请者，并在传递正文中添加 ${runtimeMarkers.finalCompleted}。`,
+            `- 正式完成路径：只有在运行时当前明确点名了某个精确 reply 函数，且你通过那个函数回复时，运行时才会把该回复作为完成结果投递给诉请者，并在传递正文中添加 ${runtimeMarkers.finalCompleted}。不要依赖 direct-reply fallback；它只是运行时临时过渡兜底，不是正式回复机制。`,
             '- 若运行时当前明确提示“没有待完成的跨对话回复义务”，就直接继续当前本地对话；不要凭记忆再次调用 `reply*`。',
             '- "不得发普通文本中间汇报"只针对未完成态；若你已经完成任务并能给出最终交付，就应使用运行时当前点名的精确 reply 函数，不要使用 `tellaskBack` 或 `tellask`。',
             '- 例外：FBR 支线为工具禁用模式（不得调用 `tellaskBack`）；其回贴标记（`' +
@@ -145,7 +145,7 @@ function buildSideDialogTellaskerReplyMarkerRules(language) {
             '- 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 to the tellasker as completion results and marked with ${runtimeMarkers.finalCompleted}.`,
+            `- Formal completion path: 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}. Do not rely on direct-reply fallback; it is only a temporary runtime transition safeguard, not the formal reply mechanism.`,
             '- 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 Side Dialog is tool-less (no \`tellaskBack\`); its reply markers (`' +
@@ -169,7 +169,7 @@ function buildTellaskReplyMarkerScopePolicy(language, dialogScope) {
                     '- `tellaskBack` 只允许用于回问诉请者；仅当必须向诉请者补需求/澄清/裁决/缺失输入，或现有团队规程无法明确判责时才使用。禁止用 `tellaskBack` 发送最终结果。',
                     '- 当前支线未完成时，不得把“阻塞/不确定”机械等同于 `tellaskBack`；若团队规程/SOP/职责卡已明确负责人，应直接 `tellask` / `tellaskSessionless` 对应负责人，不得发普通文本中间汇报。',
                     `- ${(0, reply_prompt_copy_1.buildSideDialogCompletionRule)('zh')}`,
-                    `- 仅当运行时当前明确点名了某个精确 reply 函数，且你通过那个函数回复时，运行时才会把该回复投递给诉请者并标注 ${runtimeMarkers.finalCompleted}。`,
+                    `- 正式完成路径中，仅当运行时当前明确点名了某个精确 reply 函数，且你通过那个函数回复时，运行时才会把该回复投递给诉请者并标注 ${runtimeMarkers.finalCompleted}；不要依赖 direct-reply fallback，它只是运行时临时过渡兜底，不是正式回复机制。`,
                     '- 若运行时当前明确提示“没有待完成的跨对话回复义务”，说明这轮不是待你收口的跨对话回复义务；不要重复调用 `reply*`。',
                 ],
                 en: [
@@ -178,7 +178,7 @@ function buildTellaskReplyMarkerScopePolicy(language, dialogScope) {
                     '- `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.`,
+                    `- In the formal completion path, 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; do not rely on direct-reply fallback, which is only a temporary runtime transition safeguard, not the formal reply mechanism.`,
                     '- 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.',
                 ],
             }),

package/dist/persistence.js

@@ -220,6 +220,67 @@ function normalizeGeneratingDisplayStateMismatch(dialogId, status, previous, lat
         executionMarker: hasInterruptedExecutionMarker ? undefined : latest.executionMarker,
     };
 }
+function hasActiveReplyObligationInAskerStackState(state) {
+    const top = state?.askerStack[state.askerStack.length - 1];
+    return top?.tellaskReplyObligation !== undefined;
+}
+function blockerDisplayState(args) {
+    if (args.hasQ4H && args.hasSideDialogs) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
+    }
+    if (args.hasQ4H) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
+    }
+    if (args.hasSideDialogs) {
+        return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
+    }
+    return undefined;
+}
+async function normalizeSideDialogIdleWhileReplyObligationPending(dialogId, status, previous, latest, askerStackState, context) {
+    if (status !== 'running' || dialogId.selfId === dialogId.rootId) {
+        return latest;
+    }
+    if (latest.displayState?.kind !== 'idle_waiting_user') {
+        return latest;
+    }
+    if (!hasActiveReplyObligationInAskerStackState(askerStackState)) {
+        return latest;
+    }
+    const blockerState = blockerDisplayState({
+        hasQ4H: (await DialogPersistence.loadQuestions4HumanState(dialogId, status)).length > 0,
+        hasSideDialogs: (await DialogPersistence.loadPendingSideDialogs(dialogId, status)).length > 0,
+    });
+    const top = askerStackState?.askerStack[askerStackState.askerStack.length - 1];
+    const healedDisplayState = blockerState ?? pendingReplyObligationDisplayState();
+    const healedExecutionMarker = healedDisplayState.kind === 'stopped' ? pendingReplyObligationExecutionMarker() : undefined;
+    emitInvariantWarning('Dialog latest projection invariant warning: sideDialog with active reply obligation attempted to enter idle displayState; healing from persistence facts', {
+        trigger: context.trigger,
+        mutationKind: context.mutationKind,
+        latestSource: context.latestSource,
+        latestWriteBackKey: context.latestWriteBackKey,
+        patchSummary: context.patchSummary,
+        dialogId: dialogId.valueOf(),
+        rootId: dialogId.rootId,
+        selfId: dialogId.selfId,
+        status,
+        targetCallId: top?.tellaskReplyObligation?.targetCallId ?? null,
+        blockedByQ4H: blockerState?.kind === 'blocked' && blockerState.reason.kind !== 'waiting_for_sideDialogs',
+        blockedBySideDialogs: blockerState?.kind === 'blocked' && blockerState.reason.kind !== 'needs_human_input',
+        before: summarizeLatestProjectionState(previous),
+        afterBeforeHealing: summarizeLatestProjectionState(latest),
+        healedTo: {
+            displayState: healedDisplayState,
+            executionMarker: healedExecutionMarker,
+        },
+        callStack: captureInvariantWarningStack(),
+    });
+    return {
+        ...latest,
+        lastModified: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        displayState: healedDisplayState,
+        executionMarker: healedDisplayState.kind === 'stopped' ? healedExecutionMarker : undefined,
+    };
+}
 const quarantiningMainDialogs = new Set();
 const PERSISTABLE_DIALOG_STATUSES = ['running', 'completed', 'archived'];
 const RUN_STATUS_DIR = 'run';
@@ -459,6 +520,12 @@ function parseDialogLlmRetryRecoveryAction(value) {
             return { kind: 'none' };
         case 'diligence_push_once':
             return { kind: 'diligence_push_once' };
+        case 'runtime_prompt_once': {
+            const content = value.content;
+            if (typeof content !== 'string' || content.trim() === '')
+                return null;
+            return { kind: 'runtime_prompt_once', content };
+        }
         default:
             return null;
     }
@@ -475,6 +542,8 @@ function parseDialogInterruptionReason(value) {
             return { kind: 'server_restart' };
         case 'pending_course_start':
             return { kind: 'pending_course_start' };
+        case 'pending_reply_obligation':
+            return { kind: 'pending_reply_obligation' };
         case 'fork_continue_ready':
             return { kind: 'fork_continue_ready' };
         case 'system_stop': {
@@ -509,6 +578,19 @@ function parseDialogInterruptionReason(value) {
             return null;
     }
 }
+function pendingReplyObligationDisplayState() {
+    return {
+        kind: 'stopped',
+        reason: { kind: 'pending_reply_obligation' },
+        continueEnabled: true,
+    };
+}
+function pendingReplyObligationExecutionMarker() {
+    return {
+        kind: 'interrupted',
+        reason: { kind: 'pending_reply_obligation' },
+    };
+}
 function resolveStoppedContinueEnabled(reason) {
     return (0, dialog_interruption_1.isInterruptionReasonManualResumeEligible)(reason);
 }
@@ -1810,6 +1892,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             },
         };
         await this.appendEvent(askerDialog, parentCourse, sideDialogCreatedRecord);
+        const initialSideDialogDisplayState = pendingReplyObligationDisplayState();
         // Initialize latest.yaml via the mutation API (write-back will flush).
         await DialogPersistence.mutateDialogLatest(sideDialogId, () => ({
             kind: 'replace',
@@ -1820,7 +1903,8 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 messageCount: 0,
                 functionCallCount: 0,
                 sideDialogCount: 0,
-                displayState: { kind: 'idle_waiting_user' },
+                displayState: initialSideDialogDisplayState,
+                executionMarker: pendingReplyObligationExecutionMarker(),
                 disableDiligencePush: false,
             },
         }));
@@ -1857,7 +1941,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 currentCourse: 1,
                 createdAt: nowTs,
                 lastModified: nowTs,
-                displayState: { kind: 'idle_waiting_user' },
+                displayState: initialSideDialogDisplayState,
                 sessionSlug: options.sessionSlug,
                 assignmentFromAsker: {
                     callName: options.callName,
@@ -6469,10 +6553,27 @@ class DialogPersistence {
                 lastModified: (0, time_1.formatUnifiedTimestamp)(new Date()),
                 status: 'active',
             };
+            const askerStackState = status === 'running' && dialogId.selfId !== dialogId.rootId
+                ? await this.loadSideDialogAskerStackState(dialogId, status)
+                : null;
             const mutation = mutator(existing);
+            const mutationContext = {
+                trigger: 'mutateDialogLatest',
+                mutationKind: mutation.kind,
+                patchSummary: mutation.kind === 'patch'
+                    ? summarizeLatestMutationPatch(mutation.patch)
+                    : mutation.kind === 'replace'
+                        ? summarizeLatestProjectionState(mutation.next)
+                        : null,
+                latestSource: staged ? 'staged' : latestFromDisk ? 'disk' : 'default_bootstrap',
+                latestWriteBackKey: key,
+            };
             let updated;
             if (mutation.kind === 'noop') {
-                return existing;
+                updated = await normalizeSideDialogIdleWhileReplyObligationPending(dialogId, status, existing, existing, askerStackState, mutationContext);
+                if (updated === existing) {
+                    return existing;
+                }
             }
             else if (mutation.kind === 'replace') {
                 updated = {
@@ -6491,17 +6592,8 @@ class DialogPersistence {
                 const _exhaustive = mutation;
                 throw new Error(`Unhandled dialog latest mutation: ${String(_exhaustive)}`);
             }
-            updated = normalizeGeneratingDisplayStateMismatch(dialogId, status, existing, updated, {
-                trigger: 'mutateDialogLatest',
-                mutationKind: mutation.kind,
-                patchSummary: mutation.kind === 'patch'
-                    ? summarizeLatestMutationPatch(mutation.patch)
-                    : mutation.kind === 'replace'
-                        ? summarizeLatestProjectionState(mutation.next)
-                        : null,
-                latestSource: staged ? 'staged' : latestFromDisk ? 'disk' : 'default_bootstrap',
-                latestWriteBackKey: key,
-            });
+            updated = normalizeGeneratingDisplayStateMismatch(dialogId, status, existing, updated, mutationContext);
+            updated = await normalizeSideDialogIdleWhileReplyObligationPending(dialogId, status, existing, updated, askerStackState, mutationContext);
             this.assertMainDialogWriteBackNotCanceled(effectiveCancellationToken, 'mutateDialogLatest:before-stage');
             const pending = this.latestWriteBack.get(key);
             if (!pending) {

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

@@ -263,11 +263,11 @@ function formatTellaskResponseContent(input) {
     const deliveryNotice = input.deliveryMode === 'direct_fallback'
         ? 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'
+                ? '> 系统提示：本次回贴未调用 replyTellask* 工具，且模型仅产出 thinking；在确认本轮没有待续推工具调用后，Dominds 已通过 direct-reply fallback 临时过渡兜底投递该 thinking 内容。此路径不是正式回复机制，保留本标记仅用于追踪。\n\n'
+                : '> System note: this reply did not use a replyTellask* tool, and the model only produced thinking. After confirming that no tool call in this round was waiting for auto-continuation, Dominds delivered that thinking content through direct-reply fallback as a temporary transition safeguard. This path is not the formal reply mechanism; this marker is kept only 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'
+                ? '> 系统提示：本次回贴未调用 replyTellask* 工具；在确认本轮没有待续推工具调用后，Dominds 已通过 direct-reply fallback 临时过渡兜底投递。此路径不是正式回复机制，保留本标记仅用于追踪。\n\n'
+                : '> System note: this reply did not use a replyTellask* tool. After confirming that no tool call in this round was waiting for auto-continuation, Dominds delivered it through direct-reply fallback as a temporary transition safeguard. This path is not the formal reply mechanism; this marker is kept only for traceability.\n\n'
         : '';
     if (isFbr) {
         const title = language === 'zh' ? '【扪心自问（FBR）支线对话回贴】' : '[FBR Side Dialog response]';

package/dist/runtime/reply-prompt-copy.js

@@ -149,18 +149,18 @@ function buildReplyToolReminderText(args) {
         ? [
             prefix,
             '',
-            `你刚才已经写了正文，但还没调用 \`${args.directive.expectedReplyCallName}\`。`,
+            `你刚才已经产出了可作为回贴的内容，但还没调用 \`${args.directive.expectedReplyCallName}\`。`,
             '',
             buildReplyToolReminderLine(args),
-            '如果你再次直接输出最终消息而仍不调用该工具，运行时会按 direct-reply fallback 投递，并在 UI/传递正文中明确标注。',
+            '不要依赖 direct-reply fallback；它只是运行时临时过渡兜底，不是正式回复机制。请现在调用正确的 reply 工具完成回复。',
         ].join('\n')
         : [
             prefix,
             '',
-            `You already wrote the reply body, but you still have not called \`${args.directive.expectedReplyCallName}\`.`,
+            `You already produced content that can be delivered as the reply, but you still have not called \`${args.directive.expectedReplyCallName}\`.`,
             '',
             buildReplyToolReminderLine(args),
-            'If you still emit a plain final message without the tool, runtime will deliver it via direct-reply fallback and label that path explicitly in UI and transfer text.',
+            'Do not rely on direct-reply fallback; it is only a temporary runtime transition safeguard, not the formal reply mechanism. Call the correct reply tool now.',
         ].join('\n');
 }
 function isReplyToolReminderPromptContent(content) {

package/dist/tools/prompts/control/en/principles.md

@@ -103,7 +103,7 @@ Taskdoc is a **task contract** and the task's **team-shared source of current tr
 - If the current Side Dialog is complete and the assignment header says `replyTellask`: call `replyTellask({ replyContent })`
 - If the current Side Dialog is complete and the assignment header says `replyTellaskSessionless`: call `replyTellaskSessionless({ replyContent })`
 - If you are answering a tellasker `tellaskBack` follow-up and runtime exposes `replyTellaskBack`: call `replyTellaskBack({ replyContent })`
-- Plain text is not the normal completion channel for inter-dialog delivery; if you emit plain text instead of the reply tool, runtime may temporarily inject a `role=user` reminder telling you to use the correct reply function
+- Plain text is not the completion channel for inter-dialog delivery; if you produce final deliverable content instead of the reply tool, runtime may temporarily inject a `role=user` reminder telling you to use the correct reply function. Do not rely on direct-reply fallback; it is only a temporary runtime transition safeguard, not the formal reply mechanism
 
 ### Low-Burden Rule
 

package/dist/tools/prompts/control/en/scenarios.md

@@ -68,7 +68,7 @@ replyTellask({
 
 ### Key Points
 
-- Do not replace this with a plain final message
+- Do not replace this with a plain final message; direct-reply fallback is only a temporary runtime transition safeguard, not a valid planned completion method
 - Put the final deliverable body directly in `replyContent`
 - If the header says `replyTellaskSessionless`, use the same shape with that exact function name
 

package/dist/tools/prompts/control/en/tools.md

@@ -36,7 +36,7 @@ The **tool descriptions themselves** for these functions intentionally stay mini
 - Call whichever `reply*` runtime currently exposes; do not switch to another reply variant by yourself
 - If the assignment header explicitly names a reply function, follow that exact name
 - Put only the final deliverable body in `replyContent`; do not wrap it in meta-explanations like "I am now calling replyTellask"
-- If you emit plain text instead of the reply tool, runtime may inject a temporary `role=user` reminder telling you to use the correct reply function
+- If you produce final deliverable content instead of the reply tool, runtime may inject a temporary `role=user` reminder telling you to use the correct reply function; do not rely on direct-reply fallback, which is only a temporary runtime transition safeguard, not the formal reply mechanism
 
 ### 1. add_reminder
 

package/dist/tools/prompts/control/zh/principles.md

@@ -103,7 +103,7 @@
 - 当前支线已经完成，且当前 assignment 明确要求 `replyTellask`：调用 `replyTellask({ replyContent })`
 - 当前支线已经完成，且当前 assignment 明确要求 `replyTellaskSessionless`：调用 `replyTellaskSessionless({ replyContent })`
 - 当前是在回复一条诉请者发来的 `tellaskBack` 续诉请，且 runtime 暴露了 `replyTellaskBack`：调用 `replyTellaskBack({ replyContent })`
-- 普通文本不是跨对话完成交付通道；如果你直接输出正文而没调 reply 工具，runtime 可能临时插入一条 `role=user` 的提醒要求你改用正确的 reply 函数
+- 普通文本不是跨对话完成交付通道；如果你直接产出可作为最终回贴的内容而没调 reply 工具，runtime 可能临时插入一条 `role=user` 的提醒要求你改用正确的 reply 函数。不要依赖 direct-reply fallback；它只是运行时临时过渡兜底，不是正式回复机制
 
 ### 心智负担最小化规则
 

package/dist/tools/prompts/control/zh/scenarios.md

@@ -67,7 +67,7 @@ replyTellask({
 
 ### 关键点
 
-- 不要再发一条普通最终消息代替
+- 不要再发一条普通最终消息代替；direct-reply fallback 只是运行时临时过渡兜底，不是可规划使用的收口方式
 - `replyContent` 直接放最终交付正文
 - 若 assignment 头部写的是 `replyTellaskSessionless`，则同结构替换函数名
 

package/dist/tools/prompts/control/zh/tools.md

@@ -36,7 +36,7 @@
 - 看见哪一个 `reply*` 被 runtime 暴露，就调用哪一个；不要自行改选别的 reply 变体
 - assignment 头部若已点名 reply 函数名，以那个名字为准
 - `replyContent` 只放最终交付正文，不要再包一层“我现在调用了 replyXXX”
-- 如果你直接输出普通文本而没调 reply 工具，runtime 可能插入一条 `role=user` 的 runtime reminder 纠正你
+- 如果你直接产出最终回贴内容而没调 reply 工具，runtime 可能插入一条 `role=user` 的 runtime reminder 纠正你；不要依赖 direct-reply fallback，它只是运行时临时过渡兜底，不是正式回复机制
 
 ### 1. add_reminder