dominds 1.16.7 → 1.16.8

package/dist/dialog-display-state.js

@@ -51,6 +51,7 @@ const evt_registry_1 = require("./evt-registry");
 const log_1 = require("./log");
 const persistence_1 = require("./persistence");
 const persistence_errors_1 = require("./persistence-errors");
+const interjection_pause_stop_1 = require("./runtime/interjection-pause-stop");
 const log = (0, log_1.createLogger)('dialog-display-state');
 let broadcastToClients;
 const activeRunsByDialogKey = new Map();
@@ -128,11 +129,21 @@ async function getRunControlCountsSnapshot() {
             }
             else if (latest?.executionMarker?.kind === 'interrupted' &&
                 isStoppedReasonResumable(latest.executionMarker.reason)) {
-                const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
-                const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
-                if (q4h.length === 0 && pendingSubdialogs.length === 0) {
+                // Keep run-control counts aligned with actual Continue affordance:
+                // - ordinary interrupted dialogs count as resumable only when no blocker remains
+                // - interjection-paused dialogs still count as resumable even if blocker facts remain,
+                //   because the intended UX is that Continue exits the temporary paused projection
+                //   and re-evaluates the original task from fresh facts
+                if ((0, interjection_pause_stop_1.isUserInterjectionPauseStopReason)(latest.executionMarker.reason)) {
                     resumable++;
                 }
+                else {
+                    const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
+                    const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
+                    if (q4h.length === 0 && pendingSubdialogs.length === 0) {
+                        resumable++;
+                    }
+                }
             }
         }
         catch (error) {
@@ -470,6 +481,27 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
             latest.executionMarker.kind === 'dead') {
             return { kind: 'dead', reason: latest.executionMarker.reason };
         }
+        if (latest.executionMarker?.kind === 'interrupted' &&
+            (0, interjection_pause_stop_1.isUserInterjectionPauseStopReason)(latest.executionMarker.reason)) {
+            // WARNING:
+            // This is the one place where the projection intentionally preserves the paused-interjection
+            // stopped state ahead of the current blocker facts. That is not a bug: after a user
+            // interjection we want the UI to keep showing "original task paused; click Continue" even if
+            // the underlying dialog is still waiting on Q4H/subdialogs.
+            //
+            // The true source-of-truth decision about what Continue should do next lives in
+            // `flow.ts`'s resume path, which performs a fresh fact scan at resume time and then either:
+            // - restores `blocked`, or
+            // - keeps driving immediately.
+            //
+            // Do not "heal" this branch away by prioritizing blocker facts here; that would collapse the
+            // temporary interjection UX and make repeated interjection turns revert too early.
+            return {
+                kind: 'stopped',
+                reason: latest.executionMarker.reason,
+                continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
+            };
+        }
         const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
         const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
         const hasQ4H = q4h.length > 0;

package/dist/docs/dialog-system.md

@@ -155,6 +155,51 @@ Dialog state is persisted to storage at key points:
 
 This ensures crash recovery and enables the backend to resume from any persisted state without depending on frontend state.
 
+### User Interjection Pause And Continue Semantics
+
+When a dialog still carries an inter-dialog reply obligation, but the user temporarily interjects and asks it to handle a local question first, the system must distinguish between the **UI projection** and the **true driving source state**.
+
+**Normative semantics**:
+
+1. Every user interjection message is driven as a complete normal round.
+2. If that round needs tools, the system MUST finish the full tool round and any post-tool follow-up before pausing.
+3. The system only projects the original task as resumable `stopped` when this interjection has actually parked an original task that still needs explicit restoration.
+4. If there is no parked original task to resume afterwards (for example, no inter-dialog reply obligation needs reassertion), the interjection round should simply finish and return to the true underlying state without showing this special `stopped` panel.
+5. As long as the user keeps sending new messages, the dialog stays in temporary interjection-chat handling, and that paused projection remains in place only if it was established in the first place.
+6. Only an explicit UI `Continue` attempts to restore the original task.
+
+**Key point**: this `stopped` state is only a temporary run-control / UI projection. It is not the same as an ordinary system-stop failure, and it is not the final business source of truth. It also does not apply to every interjection; it exists only when there really is a parked original task to resume.
+
+After the user clicks `Continue`, the backend MUST re-evaluate fresh persistence facts and decide which true-source case now applies. It must not infer the result purely from the visible `displayState`:
+
+- **Case 1: the dialog no longer has a reply obligation**
+  If there is also no blocker, the dialog should simply continue driving. If it has already become ordinary idle-waiting-user, then `resume_dialog` is no longer actually resumable.
+- **Case 2: the dialog still has a reply obligation and is still suspended**
+  Typical examples are pending Q4H or pending subdialogs. In this case, `Continue` should exit the interjection-paused projection and restore the true `blocked` state.
+- **Case 3: the dialog still has a reply obligation but is no longer suspended and is eligible to proceed**
+  For example, the blocker has disappeared, or a queued prompt provides a valid continuation path. In this case, `Continue` must not first fall back to an intermediate placeholder `blocked/idle` state; it should keep driving immediately.
+
+**This leads to two implementation constraints**:
+
+- `refreshRunControlProjectionFromPersistenceFacts()` MUST preserve the special "interjection handled; original task paused" `stopped` projection until the user explicitly clicks `Continue`; otherwise the UI collapses back to ordinary `blocked` too early and breaks multi-turn interjection UX. Conversely, when there is no parked original task, this paused projection should not be created at all.
+- The actual outcome of `Continue` MUST be decided in the resume drive path by re-reading fresh persistence facts. "Continue is clickable" does not mean "the dialog will definitely enter proceeding immediately".
+- The run-control toolbar's `resumable` count should align with "manual Continue attempt is meaningful". Therefore an interjection-paused `stopped` dialog still counts as resumable even when underlying blocker facts remain, because the business meaning of `Continue` there is "exit the temporary paused projection and re-evaluate from source-of-truth facts".
+
+**Mental-model warning**:
+
+- Do not reason about this flow from `displayState.kind === 'stopped'` alone.
+- Do not reason about it from blocker facts alone and then wonder why the UI still shows `stopped`.
+- Do not reason about it from `resume_dialog` eligibility alone and assume resumption always means immediate running.
+
+You need all of the following together to understand the behavior correctly:
+
+- reply-guidance suppression / deferred reassertion for interjection turns
+- flow logic for "pause after local interjection reply" plus "fresh-fact second decision after Continue"
+- dialog-display-state projection preservation
+- websocket resume entry semantics distinguishing "allowed to attempt Continue" from "actually re-entered driving"
+
+This is an intentionally cross-module semantic contract. Do not locally "simplify" one piece based only on its surface meaning.
+
 ---
 
 ## 3-Type Teammate Tellask Taxonomy

package/dist/docs/dialog-system.zh.md

@@ -154,6 +154,51 @@
 
 这确保了崩溃恢复，并使后端能够从任何持久化状态恢复，而不依赖于前端状态。
 
+### 用户插话暂停与 Continue 语义
+
+当某个对话仍带有跨对话回复义务，但用户临时插话要求它先处理本地问题时，系统必须区分**UI 投影**与**真实驱动源状态**。
+
+**规范语义**：
+
+1. 每条用户插话消息都按正常驱动轮完整执行。
+2. 若该轮需要工具，则必须先完整跑完该工具轮及其 post-tool follow-up。
+3. 只有当这条插话确实打断了一个仍待恢复的“原任务”时，系统才把该原任务投影为可 `Continue` 的 `stopped`，让用户先看到最后一条回复。
+4. 若当前并不存在待恢复的原任务（例如没有待重申的跨对话回复义务），则插话轮结束后应直接回到真实 underlying state，而不显示这个特殊 `stopped` 面板。
+5. 只要用户继续发送新消息，就继续作为插话临时对话处理；这个 paused projection 仅在它已被建立时持续保持。
+6. 只有用户显式点击 UI `Continue`，系统才尝试恢复原任务。
+
+**关键点**：这里的 `stopped` 只是一个临时 run-control / UI 投影，不等于普通 system-stop 失败，也不是最终的业务真源；并且它不是所有插话都会出现，只在“确有一个待恢复的原任务被临时停靠”时出现。
+
+点击 `Continue` 后，后端必须重新从 persistence 真源判定当前对话属于哪一种情况，而不能只根据表面的 `displayState` 做静态推断：
+
+- **情况 1：当前对话没有回复义务**
+  这时若也没有其他 blocker，就应直接继续 drive；若已回到普通待用户输入态，则 `resume_dialog` 不应再被视为可继续。
+- **情况 2：当前对话仍有回复义务，但处于 suspend 状态**
+  常见于仍在等待 Q4H / pending subdialogs。此时 `Continue` 应退出插话 paused projection，并恢复成真实的 `blocked`。
+- **情况 3：当前对话仍有回复义务，但已不再 suspend，具备继续推进条件**
+  例如 blocker 已消失，或存在允许继续的 queued prompt。此时 `Continue` 不应先落一个中间 `blocked/idle` 占位态，而应直接继续 drive。
+
+**因此有两个实现约束**：
+
+- `refreshRunControlProjectionFromPersistenceFacts()` 在用户尚未点击 `Continue` 前，必须保留这层“插话已处理；原任务已暂停”的 `stopped` 投影；否则 UI 会过早塌回普通 `blocked`，破坏多轮插话体验。反过来，如果当前其实没有待恢复原任务，则根本不应建立这层 paused projection。
+- 真正决定 `Continue` 结果的逻辑，必须在恢复驱动路径中重新读取 fresh persistence facts；不能把“可点 Continue”误解为“必然立即 proceeding”。
+- run-control 工具栏中的 `resumable` 计数，应与“是否允许手动 Continue 尝试”保持一致。因此，处于 interjection-paused `stopped` 的对话即便底层仍有 blocker，也应计入 `resumable`；因为 `Continue` 的业务语义正是“退出这层临时 paused projection，并从真源重判下一步”。
+
+**心智模型提醒**：
+
+- 不能只看 `displayState.kind === 'stopped'` 就理解这条链路。
+- 不能只看 blocker facts 就理解为什么 UI 仍显示 `stopped`。
+- 也不能只看 `resume_dialog` eligibility 就推断恢复后一定马上运行。
+
+必须把以下几块一起看，才能形成完整且精确的理解：
+
+- reply-guidance 中对插话轮的回复义务 suppression / deferred reassertion
+- flow 中“插话回复后停车”与“Continue 后 fresh fact 二次判定”
+- dialog-display-state 中 paused projection 的保留策略
+- websocket resume 入口对“可尝试 Continue”与“实际已恢复 drive”的区分
+
+这是一条跨模块协同语义，不允许在单点上做“表面看起来更简单”的局部简化。
+
 ---
 
 ## 三类队友诉请分类

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

@@ -10,6 +10,7 @@ const log_1 = require("../../log");
 const load_1 = require("../../minds/load");
 const persistence_1 = require("../../persistence");
 const driver_messages_1 = require("../../runtime/driver-messages");
+const interjection_pause_stop_1 = require("../../runtime/interjection-pause-stop");
 const reply_prompt_copy_1 = require("../../runtime/reply-prompt-copy");
 const work_language_1 = require("../../runtime/work-language");
 const client_1 = require("../client");
@@ -40,6 +41,30 @@ async function buildReplyToolReminderPrompt(args) {
         }),
     });
 }
+async function loadFreshSuspensionStatusFromPersistence(dialog) {
+    const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialog.id, dialog.status);
+    const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialog.id, dialog.status);
+    const hasQ4H = q4h.length > 0;
+    const hasSubdialogs = pendingSubdialogs.length > 0;
+    return {
+        q4h: hasQ4H,
+        subdialogs: hasSubdialogs,
+        blockingSubdialogs: hasSubdialogs,
+        canDrive: !hasQ4H && !hasSubdialogs,
+    };
+}
+function buildDisplayStateFromSuspensionStatus(args) {
+    if (args.q4h && args.subdialogs) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+    }
+    if (args.q4h) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
+    }
+    if (args.subdialogs) {
+        return { kind: 'blocked', reason: { kind: 'waiting_for_subdialogs' } };
+    }
+    return { kind: 'idle_waiting_user' };
+}
 async function loadPendingDiagnosticsSnapshot(args) {
     const ownerDialogIdObj = new dialog_1.DialogID(args.ownerDialogId, args.rootId);
     try {
@@ -304,6 +329,8 @@ async function executeDriveRound(args) {
     let subdialogReplyTarget;
     let activeTellaskReplyDirective;
     let activePromptWasReplyToolReminder = false;
+    let shouldPauseAfterLocalUserInterjection = false;
+    let resumeFromInterjectionPause = false;
     const allowResumeFromInterrupted = driveOptions?.allowResumeFromInterrupted === true || humanPrompt?.origin === 'user';
     const driveSource = resolveDriveRequestSource(humanPrompt, driveOptions);
     try {
@@ -340,6 +367,11 @@ async function executeDriveRound(args) {
                 });
                 return;
             }
+            resumeFromInterjectionPause =
+                humanPrompt === undefined &&
+                    allowResumeFromInterrupted &&
+                    latest?.executionMarker?.kind === 'interrupted' &&
+                    (0, interjection_pause_stop_1.isUserInterjectionPauseStopReason)(latest.executionMarker.reason);
         }
         catch (err) {
             log_1.log.warn('kernel-driver failed to check execution facts before drive; proceeding best-effort', err, {
@@ -382,10 +414,39 @@ async function executeDriveRound(args) {
                     return;
                 }
             }
-            const suspension = await dialog.getSuspensionStatus();
+            // WARNING:
+            // `allowResumeFromInterrupted` covers multiple stop reasons, but the interjection-pause case
+            // is semantically special. Clicking Continue here does NOT mean "blindly clear stopped and
+            // drive". We must re-read the fresh persistence facts first because there are three distinct
+            // true-source cases behind the same visible stopped panel:
+            // - no active reply obligation / not suspended anymore -> continue real driving now
+            // - active reply obligation + suspended -> restore true blocked state
+            // - active reply obligation + still proceeding entitlement (for example queued upNext) ->
+            //   continue real driving now
+            //
+            // Do not refactor this branch using only `displayState` or only the previous interrupted
+            // marker. The correct behavior emerges from combining fresh blocker facts, queued prompt
+            // state, and the deferred reply reassertion logic elsewhere.
+            const suspension = resumeFromInterjectionPause
+                ? await loadFreshSuspensionStatusFromPersistence(dialog)
+                : await dialog.getSuspensionStatus();
             const queuedPrompt = dialog.peekUpNext();
             const queuedSubdialogPromptCanResume = dialog instanceof dialog_1.SubDialog && queuedPrompt !== undefined;
             if (!suspension.canDrive && !queuedSubdialogPromptCanResume) {
+                if (resumeFromInterjectionPause) {
+                    const restoredState = buildDisplayStateFromSuspensionStatus({
+                        q4h: suspension.q4h,
+                        subdialogs: suspension.subdialogs,
+                    });
+                    await (0, dialog_display_state_1.setDialogDisplayState)(dialog.id, restoredState);
+                    log_1.log.debug('kernel-driver continue after interjection pause restored true suspended state from fresh persistence facts', undefined, {
+                        dialogId: dialog.id.valueOf(),
+                        restoredState,
+                        waitingQ4H: suspension.q4h,
+                        waitingSubdialogs: suspension.subdialogs,
+                    });
+                    return;
+                }
                 const lastTrigger = dialog_global_registry_1.globalDialogRegistry.getLastDriveTrigger(dialog.id.rootId);
                 const lastTriggerAgeMs = lastTrigger !== undefined ? Math.max(0, Date.now() - lastTrigger.emittedAtMs) : undefined;
                 log_1.log.debug('kernel-driver skip queued auto-drive while dialog is suspended', undefined, {
@@ -413,6 +474,15 @@ async function executeDriveRound(args) {
                 });
                 return;
             }
+            if (resumeFromInterjectionPause) {
+                log_1.log.debug('kernel-driver continue after interjection pause passed fresh fact scan and will keep driving', undefined, {
+                    dialogId: dialog.id.valueOf(),
+                    waitingQ4H: suspension.q4h,
+                    waitingSubdialogs: suspension.subdialogs,
+                    hasQueuedUpNext: dialog.hasUpNext(),
+                    queuedSubdialogPromptCanResume,
+                });
+            }
         }
         const minds = await (0, load_1.loadAgentMinds)(dialog.agentId, dialog);
         const policy = (0, guardrails_1.buildKernelDriverPolicy)({
@@ -508,6 +578,14 @@ async function executeDriveRound(args) {
             dlg: dialog,
             prompt: effectivePrompt,
         });
+        // Only park into the special interjection stopped-panel state when this user turn has
+        // suppressed a still-pending inter-dialog reply obligation that must be reasserted later.
+        // User interjections without a parked original task should simply finish and fall back to the
+        // dialog's true underlying state, without showing the special stopped panel.
+        shouldPauseAfterLocalUserInterjection =
+            effectivePrompt?.origin === 'user' &&
+                replyGuidance.suppressInterDialogReplyGuidance &&
+                replyGuidance.deferredReplyReassertionDirective !== undefined;
         activeTellaskReplyDirective = replyGuidance.activeReplyDirective;
         activePromptWasReplyToolReminder = isReplyToolReminderPrompt(effectivePrompt);
         if (effectivePrompt && effectivePrompt.userLanguageCode) {
@@ -573,28 +651,64 @@ async function executeDriveRound(args) {
                                 });
                             }
                             else {
-                                if (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
-                                    !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
-                                    driveResult.lastAssistantSayingGenseq <= 0) {
-                                    throw new Error(`Subdialog response supply invariant violation: missing lastAssistantSayingGenseq for dialog=${dialog.id.valueOf()}`);
-                                }
-                                const responseGenseq = Math.floor(driveResult.lastAssistantSayingGenseq);
-                                const directFallbackCallId = `direct-fallback-${(0, id_1.generateShortId)()}`;
-                                let supplied = false;
-                                if (subdialogReplyTarget) {
-                                    supplied = await (0, subdialog_1.supplySubdialogResponseToSpecificCallerIfPendingV2)({
-                                        subdialog: dialog,
-                                        responseText: driveResult.lastAssistantSayingContent,
-                                        responseGenseq,
-                                        target: subdialogReplyTarget,
-                                        deliveryMode: 'direct_fallback',
-                                        replyResolution: {
-                                            callId: directFallbackCallId,
-                                            replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
-                                        },
-                                        scheduleDrive: args.scheduleDrive,
+                                if (!activePromptWasReplyToolReminder) {
+                                    const language = (0, work_language_1.getWorkLanguage)();
+                                    followUp = {
+                                        prompt: await buildReplyToolReminderPrompt({
+                                            dlg: dialog,
+                                            directive: activeTellaskReplyDirective,
+                                            language,
+                                        }),
+                                        msgId: (0, id_1.generateShortId)(),
+                                        grammar: 'markdown',
+                                        origin: 'runtime',
+                                        userLanguageCode: language,
+                                        tellaskReplyDirective: activeTellaskReplyDirective,
+                                        subdialogReplyTarget,
+                                    };
+                                    log_1.log.debug('kernel-driver queued subdialog replyTellask reminder after plain reply', undefined, {
+                                        dialogId: dialog.id.valueOf(),
+                                        targetCallId: activeTellaskReplyDirective.targetCallId,
+                                        targetOwnerDialogId: subdialogReplyTarget?.ownerDialogId,
                                     });
-                                    if (!supplied) {
+                                }
+                                else {
+                                    if (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
+                                        !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
+                                        driveResult.lastAssistantSayingGenseq <= 0) {
+                                        throw new Error(`Subdialog response supply invariant violation: missing lastAssistantSayingGenseq for dialog=${dialog.id.valueOf()}`);
+                                    }
+                                    const responseGenseq = Math.floor(driveResult.lastAssistantSayingGenseq);
+                                    const directFallbackCallId = `direct-fallback-${(0, id_1.generateShortId)()}`;
+                                    let supplied = false;
+                                    if (subdialogReplyTarget) {
+                                        supplied = await (0, subdialog_1.supplySubdialogResponseToSpecificCallerIfPendingV2)({
+                                            subdialog: dialog,
+                                            responseText: driveResult.lastAssistantSayingContent,
+                                            responseGenseq,
+                                            target: subdialogReplyTarget,
+                                            deliveryMode: 'direct_fallback',
+                                            replyResolution: {
+                                                callId: directFallbackCallId,
+                                                replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
+                                            },
+                                            scheduleDrive: args.scheduleDrive,
+                                        });
+                                        if (!supplied) {
+                                            supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
+                                                subdialog: dialog,
+                                                responseText: driveResult.lastAssistantSayingContent,
+                                                responseGenseq,
+                                                deliveryMode: 'direct_fallback',
+                                                replyResolution: {
+                                                    callId: directFallbackCallId,
+                                                    replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
+                                                },
+                                                scheduleDrive: args.scheduleDrive,
+                                            });
+                                        }
+                                    }
+                                    else {
                                         supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
                                             subdialog: dialog,
                                             responseText: driveResult.lastAssistantSayingContent,
@@ -607,35 +721,21 @@ async function executeDriveRound(args) {
                                             scheduleDrive: args.scheduleDrive,
                                         });
                                     }
-                                }
-                                else {
-                                    supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
-                                        subdialog: dialog,
-                                        responseText: driveResult.lastAssistantSayingContent,
-                                        responseGenseq,
-                                        deliveryMode: 'direct_fallback',
-                                        replyResolution: {
-                                            callId: directFallbackCallId,
-                                            replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
-                                        },
-                                        scheduleDrive: args.scheduleDrive,
-                                    });
-                                }
-                                if (!supplied && subdialogReplyTarget) {
-                                    const diagnostics = await loadPendingDiagnosticsSnapshot({
-                                        rootId: dialog.id.rootId,
-                                        ownerDialogId: subdialogReplyTarget.ownerDialogId,
-                                        expectedSubdialogId: dialog.id.selfId,
-                                        status: dialog.status,
-                                    });
-                                    log_1.log.debug('kernel-driver failed to supply subdialog response to specific caller', undefined, {
-                                        calleeId: dialog.id.valueOf(),
-                                        targetOwner: subdialogReplyTarget.ownerDialogId,
-                                        targetOwnerDialogId: subdialogReplyTarget.ownerDialogId,
-                                        targetCallType: subdialogReplyTarget.callType,
-                                        targetCallId: subdialogReplyTarget.callId,
-                                        diagnostics,
-                                    });
+                                    if (!supplied && subdialogReplyTarget) {
+                                        const diagnostics = await loadPendingDiagnosticsSnapshot({
+                                            rootId: dialog.id.rootId,
+                                            ownerDialogId: subdialogReplyTarget.ownerDialogId,
+                                            expectedSubdialogId: dialog.id.selfId,
+                                            status: dialog.status,
+                                        });
+                                        log_1.log.debug('kernel-driver failed to supply subdialog response to specific caller', undefined, {
+                                            calleeId: dialog.id.valueOf(),
+                                            targetOwnerDialogId: subdialogReplyTarget.ownerDialogId,
+                                            targetCallType: subdialogReplyTarget.callType,
+                                            targetCallId: subdialogReplyTarget.callId,
+                                            diagnostics,
+                                        });
+                                    }
                                 }
                             }
                         }
@@ -716,6 +816,26 @@ async function executeDriveRound(args) {
                     },
                 });
             }
+            if (shouldPauseAfterLocalUserInterjection &&
+                !interruptedBySignal &&
+                followUp === undefined &&
+                driveResult?.lastAssistantSayingContent !== null) {
+                const pauseReason = (0, interjection_pause_stop_1.buildUserInterjectionPauseStopReason)();
+                await (0, dialog_display_state_1.setDialogDisplayState)(dialog.id, {
+                    kind: 'stopped',
+                    reason: pauseReason,
+                    continueEnabled: true,
+                });
+                (0, dialog_display_state_1.broadcastDisplayStateMarker)(dialog.id, {
+                    kind: 'interrupted',
+                    reason: pauseReason,
+                });
+                log_1.log.debug('kernel-driver paused original task after local user interjection reply', undefined, {
+                    dialogId: dialog.id.valueOf(),
+                    rootId: dialog.id.rootId,
+                    selfId: dialog.id.selfId,
+                });
+            }
         }
         catch (error) {
             tailError = error;

package/dist/llm/kernel-driver/reply-guidance.js

@@ -6,6 +6,8 @@ exports.buildReplyObligationSuppressionGuide = buildReplyObligationSuppressionGu
 exports.buildReplyObligationReassertionPrompt = buildReplyObligationReassertionPrompt;
 const dialog_1 = require("../../dialog");
 const dialog_instance_registry_1 = require("../../dialog-instance-registry");
+const persistence_1 = require("../../persistence");
+const interjection_pause_stop_1 = require("../../runtime/interjection-pause-stop");
 const reply_prompt_copy_1 = require("../../runtime/reply-prompt-copy");
 const work_language_1 = require("../../runtime/work-language");
 const tellask_special_1 = require("./tellask-special");
@@ -81,6 +83,17 @@ function buildPromptContentWithExactReplyToolName(args) {
     return `${note}\n\n${args.prompt.content}`;
 }
 async function shouldSuppressInterDialogReplyGuidanceForUserInterjection(args) {
+    // WARNING:
+    // This suppression decision is not a cosmetic prompt tweak. It is one leg of the full
+    // interjection-pause state machine:
+    // 1. user interjection suppresses the live reply obligation here;
+    // 2. `flow.ts` answers locally and parks the original task in a resumable stopped state;
+    // 3. manual Continue later decides from fresh persistence facts whether the dialog should stay
+    //    blocked or resume real driving.
+    //
+    // Do not "simplify" this into a pure display-state check or a pure pending-subdialog check.
+    // The business anchor is the deferred reply reassertion, while the paused execution marker keeps
+    // repeated interjection turns behaving as local side conversation until explicit Continue.
     const prompt = args.prompt;
     if (!prompt) {
         return false;
@@ -91,7 +104,18 @@ async function shouldSuppressInterDialogReplyGuidanceForUserInterjection(args) {
     if (prompt.tellaskReplyDirective !== undefined) {
         return false;
     }
-    return await args.dlg.hasPendingSubdialogs();
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
+    if (latest?.deferredReplyReassertion?.reason === 'user_interjection_while_pending_subdialog') {
+        return true;
+    }
+    if (latest?.executionMarker?.kind === 'interrupted' &&
+        (0, interjection_pause_stop_1.isUserInterjectionPauseStopReason)(latest.executionMarker.reason)) {
+        return true;
+    }
+    // Use strict persistence reads here. This branch changes business behavior, so a read failure
+    // must loud-fail the round instead of being silently treated as "pending subdialogs exist".
+    const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(args.dlg.id, args.dlg.status);
+    return pendingSubdialogs.length > 0;
 }
 async function resolvePromptReplyGuidance(args) {
     const prompt = args.prompt;

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

@@ -140,8 +140,8 @@ async function deliverTellaskBackReplyFromDirective(args) {
     // the dialog running `replyTellaskBack` is the ask-back responder, while
     // directive.targetDialogId points to the ask-back requester that must receive the canonical
     // tellaskBack result. Keep those roles explicit, otherwise it is very easy to accidentally
-    // write the same business result once from the reply-tool path and then again from a fallback
-    // path that treats the responder's plain assistant words as if they were the canonical reply.
+    // write the same business result twice by confusing the responder's local plaintext with the
+    // canonical upstream delivery that must come only from an explicit reply tool call.
     const rootDialog = args.replyingDialog instanceof dialog_1.RootDialog
         ? args.replyingDialog
         : args.replyingDialog instanceof dialog_1.SubDialog
@@ -910,9 +910,6 @@ function findDeliveredTellaskBackReplyOnAskBackRequester(args) {
     return undefined;
 }
 async function extractAskBackResponderPlaintextFallback(args) {
-    // This fallback is intentionally second-class: it exists only for legacy/plain-reply flows
-    // where no explicit `replyTellaskBack` canonical result has been delivered. It must never
-    // compete with or overwrite an already delivered canonical tellaskBack result.
     try {
         return extractLastAssistantResponse(args.responderDialog.msgs, 'Supdialog completed without producing output.');
     }
@@ -1253,6 +1250,7 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                         tellaskContent: body,
                         responseBody: responseText,
                         status: 'completed',
+                        deliveryMode: 'direct_fallback',
                         language: (0, work_language_1.getWorkLanguage)(),
                     });
                     askBackRequesterDialog.setSuspensionState('resumed');

package/dist/persistence.js

@@ -1553,7 +1553,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         // Duplicate final results are not harmless transcript noise. They mean two different program
         // paths both believed they owned the same business-level completion fact for one callId.
         // In ask-back flows this usually points to identity confusion between requester/responder or
-        // canonical reply-tool delivery versus fallback plaintext synthesis. We fail fast here so the
+        // canonical reply-tool delivery versus another mistaken write path. We fail fast here so the
         // second writer keeps its own stack trace instead of silently corrupting the dialog transcript.
         const err = new Error(`${args.kind} duplicate callId invariant violation: rootId=${args.dialog.id.rootId} selfId=${args.dialog.id.selfId} ` +
             `callId=${args.callId} callName=${args.callName} existingCourse=${args.existingCourse} ` +

package/dist/runtime/interjection-pause-stop.d.ts

@@ -0,0 +1,5 @@
+import type { DialogInterruptionReason } from '@longrun-ai/kernel/types/display-state';
+export declare function buildUserInterjectionPauseStopReason(): Extract<DialogInterruptionReason, {
+    kind: 'system_stop';
+}>;
+export declare function isUserInterjectionPauseStopReason(reason: DialogInterruptionReason | undefined): boolean;

package/dist/runtime/interjection-pause-stop.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUserInterjectionPauseStopReason = buildUserInterjectionPauseStopReason;
+exports.isUserInterjectionPauseStopReason = isUserInterjectionPauseStopReason;
+const USER_INTERJECTION_PAUSE_STOP_DETAIL = 'user_interjection_pause_resume_original_task';
+// WARNING:
+// This special stop reason is only a UI/run-control projection for "user interjected, and there
+// is still an original task parked for explicit Continue". It is intentionally encoded as
+// `system_stop`, but it does NOT mean the same thing as ordinary system-stop failure semantics.
+//
+// Not every user interjection should use this reason. If there is no parked original task to
+// resume afterwards, the interjection should simply complete and the dialog should fall back to
+// its true underlying state without showing this stopped panel.
+//
+// Do not change this file in isolation. The complete behavior depends on coordinated logic across:
+// - `reply-guidance.ts`          suppressing upstream reply obligation during interjection chat
+// - `flow.ts`                   parking after the local reply, then re-running fresh-fact resume
+// - `dialog-display-state.ts`   preserving this paused projection until explicit Continue
+// - `websocket-handler.ts`      treating Continue as "resume attempt" rather than immediate success
+//
+// Reading only this stop reason or only `displayState.kind === 'stopped'` gives an incomplete and
+// often wrong mental model.
+function buildUserInterjectionPauseStopReason() {
+    return {
+        kind: 'system_stop',
+        detail: USER_INTERJECTION_PAUSE_STOP_DETAIL,
+        i18nStopReason: {
+            zh: '插话已处理；原任务已暂停。点击“继续”恢复原任务，继续发送新消息则继续这段临时对话。',
+            en: 'Interjection handled; the original task is paused. Click Continue to resume it, or send another message to keep this temporary side conversation going.',
+        },
+    };
+}
+function isUserInterjectionPauseStopReason(reason) {
+    return reason?.kind === 'system_stop' && reason.detail === USER_INTERJECTION_PAUSE_STOP_DETAIL;
+}

package/dist/server/websocket-handler.js

@@ -102,6 +102,15 @@ function emitRunControlRefresh(reason) {
     });
 }
 function buildResumeIneligibleMessage(latest) {
+    // WARNING:
+    // `resume_dialog` eligibility is intentionally based on the freshly healed projection, not on a
+    // naive local check of raw blocker facts. In particular, the paused-interjection stopped state
+    // must remain resumable here so the user can explicitly press Continue even while the underlying
+    // dialog may still be blocked.
+    //
+    // The actual outcome of that Continue attempt is decided later in `flow.ts` from fresh facts:
+    // it may restore `blocked`, or it may immediately continue driving. Do not reinterpret a
+    // resumable stopped state here as "guaranteed to run now".
     const state = latest?.displayState;
     if (!state) {
         return {
@@ -1288,6 +1297,11 @@ async function handleResumeDialog(ws, packet) {
     }
     const dialogIdObj = new dialog_1.DialogID(dialog.selfId, dialog.rootId);
     const latest = await (0, dialog_display_state_1.refreshRunControlProjectionFromPersistenceFacts)(dialogIdObj, 'resume_dialog');
+    // WARNING:
+    // Passing this gate only means "a manual Continue attempt is allowed". It does not mean the
+    // dialog is guaranteed to re-enter proceeding immediately. For the paused-interjection flow, the
+    // resumed drive itself performs a second fresh-fact decision and may land in true `blocked`
+    // instead of proceeding.
     if (!(0, dialog_display_state_1.isDialogLatestResumable)(latest)) {
         const ineligible = buildResumeIneligibleMessage(latest);
         log.warn('resume_dialog rejected after fresh fact scan', undefined, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.16.7",
+  "version": "1.16.8",
   "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/shell": "1.8.13",
     "@longrun-ai/kernel": "1.8.13",
+    "@longrun-ai/shell": "1.8.13",
     "@longrun-ai/codex-auth": "0.12.0"
   },
   "devDependencies": {