dominds 1.23.5 → 1.23.6

package/dist/dialog-display-state.js

@@ -96,6 +96,25 @@ function isSideDialogResponseAnchor(record) {
 function isNonIdleDisplayProjection(state) {
     return state !== undefined && state.kind !== 'idle_waiting_user';
 }
+function pendingReplyObligationDisplayState() {
+    return {
+        kind: 'stopped',
+        reason: { kind: 'pending_reply_obligation' },
+        continueEnabled: true,
+    };
+}
+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 hasSideDialogFinalResponseAnchor(dialogId, latest) {
     if (dialogId.selfId === dialogId.rootId) {
         return false;
@@ -111,6 +130,35 @@ async function hasSideDialogFinalResponseAnchor(dialogId, latest) {
     }
     return false;
 }
+async function hasActiveSideDialogReplyObligation(dialogId) {
+    if (dialogId.selfId === dialogId.rootId) {
+        return false;
+    }
+    const activeObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dialogId, 'running');
+    return activeObligation !== undefined;
+}
+async function coerceIdleDisplayStateForActiveSideDialogReplyObligation(dialogId, displayState) {
+    if (displayState.kind !== 'idle_waiting_user') {
+        return displayState;
+    }
+    if (!(await hasActiveSideDialogReplyObligation(dialogId))) {
+        return displayState;
+    }
+    const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
+    const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
+    const blocked = blockerDisplayState({
+        hasQ4H: q4h.length > 0,
+        hasSideDialogs: pendingSideDialogs.length > 0,
+    });
+    const healedDisplayState = blocked ?? pendingReplyObligationDisplayState();
+    log.warn('Prevented sideDialog with active reply obligation from entering idle display state', new Error('sideDialog idle display-state invariant violation'), {
+        dialogId: dialogId.valueOf(),
+        rootId: dialogId.rootId,
+        selfId: dialogId.selfId,
+        healedDisplayState,
+    });
+    return healedDisplayState;
+}
 function classifyRunControlBucket(state) {
     if (!state)
         return 'none';
@@ -345,6 +393,7 @@ async function clearDialogInterruptedExecutionMarker(dialogId) {
     await setDialogExecutionMarker(dialogId, undefined);
 }
 async function setDialogDisplayState(dialogId, displayState) {
+    displayState = await coerceIdleDisplayStateForActiveSideDialogReplyObligation(dialogId, displayState);
     if (displayState.kind === 'dead' && dialogId.selfId === dialogId.rootId) {
         log.warn('Rejecting dead displayState for main dialog (main dialogs must not be dead)', undefined, {
             dialogId: dialogId.valueOf(),
@@ -441,7 +490,8 @@ async function computeIdleDisplayState(dlg) {
         latest.executionMarker.kind === 'dead') {
         return { kind: 'dead', reason: latest.executionMarker.reason };
     }
-    if (latest?.executionMarker?.kind === 'interrupted') {
+    if (latest?.executionMarker?.kind === 'interrupted' &&
+        latest.executionMarker.reason.kind !== 'pending_reply_obligation') {
         return {
             kind: 'stopped',
             reason: latest.executionMarker.reason,
@@ -457,14 +507,12 @@ async function computeIdleDisplayState(dlg) {
     }
     const hasQ4H = await dlg.hasPendingQ4H();
     const hasSideDialogs = await dlg.hasPendingSideDialogs();
-    if (hasQ4H && hasSideDialogs) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
+    const blocked = blockerDisplayState({ hasQ4H, hasSideDialogs });
+    if (blocked) {
+        return blocked;
     }
-    if (hasQ4H) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
-    }
-    if (hasSideDialogs) {
-        return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
+    if (await hasActiveSideDialogReplyObligation(dlg.id)) {
+        return pendingReplyObligationDisplayState();
     }
     return { kind: 'idle_waiting_user' };
 }
@@ -480,7 +528,8 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
         latest.executionMarker.kind === 'dead') {
         return { kind: 'dead', reason: latest.executionMarker.reason };
     }
-    if (latest?.executionMarker?.kind === 'interrupted') {
+    if (latest?.executionMarker?.kind === 'interrupted' &&
+        latest.executionMarker.reason.kind !== 'pending_reply_obligation') {
         return {
             kind: 'stopped',
             reason: latest.executionMarker.reason,
@@ -494,21 +543,19 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
             continueEnabled: true,
         };
     }
-    if (latest && (await hasSideDialogFinalResponseAnchor(dialogId, latest))) {
-        return { kind: 'idle_waiting_user' };
-    }
     const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
     const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
     const hasQ4H = q4h.length > 0;
     const hasSideDialogs = pendingSideDialogs.length > 0;
-    if (hasQ4H && hasSideDialogs) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
+    const blocked = blockerDisplayState({ hasQ4H, hasSideDialogs });
+    if (blocked) {
+        return blocked;
     }
-    if (hasQ4H) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
+    if (await hasActiveSideDialogReplyObligation(dialogId)) {
+        return pendingReplyObligationDisplayState();
     }
-    if (hasSideDialogs) {
-        return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
+    if (latest && (await hasSideDialogFinalResponseAnchor(dialogId, latest))) {
+        return { kind: 'idle_waiting_user' };
     }
     return { kind: 'idle_waiting_user' };
 }
@@ -602,23 +649,22 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
                 continueEnabled: true,
             };
         }
-        if (await hasSideDialogFinalResponseAnchor(dialogId, latest)) {
-            return { kind: 'idle_waiting_user' };
-        }
         const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
         const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
         const hasQ4H = q4h.length > 0;
         const hasSideDialogs = pendingSideDialogs.length > 0;
-        if (hasQ4H && hasSideDialogs) {
-            return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
+        const blocked = blockerDisplayState({ hasQ4H, hasSideDialogs });
+        if (blocked) {
+            return blocked;
         }
-        if (hasQ4H) {
-            return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
+        if (await hasActiveSideDialogReplyObligation(dialogId)) {
+            return pendingReplyObligationDisplayState();
         }
-        if (hasSideDialogs) {
-            return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
+        if (await hasSideDialogFinalResponseAnchor(dialogId, latest)) {
+            return { kind: 'idle_waiting_user' };
         }
-        if (latest.executionMarker?.kind === 'interrupted') {
+        if (latest.executionMarker?.kind === 'interrupted' &&
+            latest.executionMarker.reason.kind !== 'pending_reply_obligation') {
             return {
                 kind: 'stopped',
                 reason: latest.executionMarker.reason,
@@ -673,7 +719,9 @@ function isRecoverableGeneratingLatest(latest) {
     if (marker.kind === 'dead') {
         return false;
     }
-    return marker.kind !== 'interrupted' || marker.reason.kind === 'pending_course_start';
+    return (marker.kind !== 'interrupted' ||
+        marker.reason.kind === 'pending_course_start' ||
+        marker.reason.kind === 'pending_reply_obligation');
 }
 async function reconcileDisplayStatesAfterRestart() {
     const dialogIds = await persistence_1.DialogPersistence.listAllDialogIds('running');
@@ -743,7 +791,8 @@ async function reconcileDisplayStatesAfterRestart() {
                         needsDrive: true,
                         displayState: { kind: 'proceeding' },
                         executionMarker: existingMarker?.kind === 'interrupted' &&
-                            existingMarker.reason.kind === 'pending_course_start'
+                            (existingMarker.reason.kind === 'pending_course_start' ||
+                                existingMarker.reason.kind === 'pending_reply_obligation')
                             ? undefined
                             : existingMarker,
                     },

package/dist/dialog-interruption.js

@@ -24,6 +24,7 @@ function isInterruptionReasonManualResumeEligible(reason) {
         case 'emergency_stop':
         case 'server_restart':
         case 'pending_course_start':
+        case 'pending_reply_obligation':
         case 'fork_continue_ready':
         case 'system_stop':
         case 'llm_retry_stopped':
@@ -37,6 +38,7 @@ function isInterruptionReasonManualResumeEligible(reason) {
 function doesInterruptionReasonRequireExplicitResume(reason) {
     switch (reason.kind) {
         case 'pending_course_start':
+        case 'pending_reply_obligation':
             return false;
         case 'user_stop':
         case 'emergency_stop':

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,
@@ -640,6 +740,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 });
@@ -916,8 +1039,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 +1073,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 +1170,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)();

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';
@@ -475,6 +536,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 +572,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 +1886,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 +1897,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 +1935,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 +6547,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 +6586,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) {