dominds 1.25.3 → 1.25.5

package/dist/dialog-display-state.js

@@ -182,9 +182,8 @@ async function getRunControlCountsSnapshot() {
                 isStoppedReasonResumable(latest.executionMarker.reason)) {
                 // Keep run-control counts aligned with actual Continue affordance:
                 // - ordinary interrupted dialogs count as resumable only when no Q4H suspension remains
-                // - interjection-paused dialogs still count as resumable even if Q4H remains,
-                //   because the intended UX is that Continue exits the temporary paused projection
-                //   and re-evaluates the original task from fresh facts
+                // - legacy interjection-paused dialogs still count as resumable even if Q4H remains,
+                //   because Continue only re-evaluates the original task from fresh facts
                 if ((0, interjection_pause_stop_1.isUserInterjectionPauseStopReason)(latest.executionMarker.reason)) {
                     resumable++;
                 }
@@ -615,10 +614,10 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
         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 suspension 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.
+            // This is the one place where the projection intentionally preserves legacy
+            // paused-interjection stopped state ahead of the current suspension facts. That is not a bug:
+            // the UI may still need to show that the original task was paused even if the underlying
+            // dialog is now waiting on Q4H.
             //
             // 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 the

package/dist/docs/dialog-system.md

@@ -155,52 +155,38 @@ 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
+### User Interjection And A2H 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**.
 
+Plainly: the system should answer the user's interjection first. Once the user receives a visible answer, the backend records that answer as A2H (Answer to Human) in Human Attention so the user can find and acknowledge it even if the dialog immediately continues automatically.
+
 **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.
+2. If that round needs tools, the system MUST finish the full tool round and any post-tool follow-up before treating the interjection as answered.
+3. A visible assistant `saying` settles the pending user-interjection reply only when no same-round function/tellask call remains after that `saying`.
+4. Settling the interjection appends an A2H item to the dialog's `a2h.yaml`. A2H is an acknowledgement queue, not a problem report and not durable drive work.
+5. If an inter-dialog reply obligation still exists after the interjection is answered, the backend automatically reasserts that obligation and continues. The user should not need to click `Continue` merely because the interjection answer completed.
+6. A2H disappears when the user acknowledges it. This is intentionally "read then burn"; the canonical answer remains in the dialog transcript at `answerRef`.
+7. The Human Attention panel shows Q4H and A2H together. Q4H waits for a human answer; A2H waits only for human acknowledgement.
 
 **Strict boundary**: a formal `askHuman` answer is not part of this "user interjection" category. As soon as a prompt carries a real `q4hAnswerCallId`, it belongs to the askHuman reply channel and semantically continues an already-materialized question/answer chain; it must never be downgraded into temporary local side-chat.
 
-**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 user-wait fact such as Q4H, 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 waiting for user input**
-  The canonical example is pending Q4H. 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 Q4H/user-wait fact 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".
-- If `Continue` reveals that the true state is still `blocked`, the reply-obligation reassertion copy should be materialized immediately as a runtime guide in both `dlg.msgs` and persisted course history, while also surfacing as a frontend bubble. That lets the later real resume path rely on ordinary context replay instead of synthesizing a second duplicate runtime prompt.
-- 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 user-wait facts remain, because the business meaning of `Continue` there is "exit the temporary paused projection and re-evaluate from source-of-truth facts".
+**Key point**: pending user-interjection reply and inter-dialog reply obligation are independent business facts. Reminder/footer copy can use those two facts directly: if the interjection is still pending, prioritize answering the user; if it is settled and the reply obligation remains active, continue toward the required inter-dialog closure.
 
 **Mental-model warning**:
 
-- Do not reason about this flow from `displayState.kind === 'stopped'` alone.
-- Do not reason about it from user-wait 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.
 - Do not flatten every `origin === 'user'` prompt into "interjection"; a non-empty `q4hAnswerCallId` means askHuman answer continuation and follows a different semantic path.
+- Do not treat A2H as Q4H. A2H does not block drive and does not route input to an agent.
+- Do not store A2H in the Problems panel. It belongs to Human Attention and is removed by Ack.
 
 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"
+- pending user-interjection reply settlement after visible final `saying`
+- A2H persistence and Ack flow
+- automatic reply-obligation reassertion after the user-visible answer
 
 This is an intentionally cross-module semantic contract. Do not locally "simplify" one piece based only on its surface meaning.
 

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

@@ -154,52 +154,38 @@ askerDialog 可以在执行期间接收来自当前需向它回复的支线对
 
 这确保了崩溃恢复，并使后端能够从任何持久化状态恢复，而不依赖于前端状态。
 
-### 用户插话暂停与 Continue 语义
+### 用户插话与 A2H 语义
 
 当某个对话仍带有跨对话回复义务，但用户临时插话要求它先处理本地问题时，系统必须区分**UI 投影**与**真实驱动源状态**。
 
+直白地说：先把用户这次插话接住并答完。用户看到可见答复后，后端把这条答复记录成 A2H（Answer to Human）放进“待人处理”，这样即使对话马上自动续推，用户也能找到并确认已阅。
+
 **规范语义**：
 
 1. 每条用户插话消息都按正常驱动轮完整执行。
-2. 若该轮需要工具，则必须先完整跑完该工具轮及其 post-tool follow-up。
-3. 只有当这条插话确实打断了一个仍待恢复的“原任务”时，系统才把该原任务投影为可 `Continue` 的 `stopped`，让用户先看到最后一条回复。
-4. 若当前并不存在待恢复的原任务（例如没有待重申的跨对话回复义务），则插话轮结束后应直接回到真实 underlying state，而不显示这个特殊 `stopped` 面板。
-5. 只要用户继续发送新消息，就继续作为插话临时对话处理；这个 paused projection 仅在它已被建立时持续保持。
-6. 只有用户显式点击 UI `Continue`，系统才尝试恢复原任务。
+2. 若该轮需要工具，则必须先完整跑完该工具轮及其 post-tool follow-up，之后才可认为插话已答完。
+3. 只有当模型产生可见 `saying`，且该 `saying` 后同轮没有普通 function/tellask call 继续挂起时，才清除“待回复用户插话”。
+4. 清除该状态时，把答复追加到该对话的 `a2h.yaml`。A2H 是待人确认队列，不是 Problems，也不是持久驱动工作。
+5. 如果插话答完后仍有跨对话回复义务，后端自动重申并继续推进；用户不应仅因为插话答完而需要手工点 `Continue`。
+6. 用户 Ack 以后 A2H 立即消失，语义是“阅后即焚”；答复正文的真源仍在对话 transcript 中，由 `answerRef` 回链定位。
+7. “待人处理”面板同时显示 Q4H 与 A2H：Q4H 等人回答，A2H 只等人确认已阅。
 
 **严格边界**：`askHuman` 的正式回答不属于这里的“用户插话”。只要一条 prompt 带着真实的 `q4hAnswerCallId`，它就属于 askHuman 回复通道，语义上是在继续已 materialize 的提问/应答链路，绝不能被压入“本地临时插话聊天”。
 
-**关键点**：这里的 `stopped` 只是一个临时 run-control / UI 投影，不等于普通 system-stop 失败，也不是最终的业务真源；并且它不是所有插话都会出现，只在“确有一个待恢复的原任务被临时停靠”时出现。
-
-点击 `Continue` 后，后端必须重新从 persistence 真源判定当前对话属于哪一种情况，而不能只根据表面的 `displayState` 做静态推断：
-
-- **情况 1：当前对话没有回复义务**
-  这时若也没有 Q4H 等用户等待事实，就应直接继续 drive；若已回到普通待用户输入态，则 `resume_dialog` 不应再被视为可继续。
-- **情况 2：当前对话仍有回复义务，但正在等待用户输入**
-  典型例子是 pending Q4H。此时 `Continue` 应退出插话 paused projection，并恢复成真实的 `blocked`。
-- **情况 3：当前对话仍有回复义务，但已不再 suspend，具备继续推进条件**
-  例如 Q4H/用户等待事实已消失，或存在允许继续的 queued prompt。此时 `Continue` 不应先落一个中间 `blocked/idle` 占位态，而应直接继续 drive。
-
-**因此有两个实现约束**：
-
-- `refreshRunControlProjectionFromPersistenceFacts()` 在用户尚未点击 `Continue` 前，必须保留这层“插话已处理；原任务已暂停”的 `stopped` 投影；否则 UI 会过早塌回普通 `blocked`，破坏多轮插话体验。反过来，如果当前其实没有待恢复原任务，则根本不应建立这层 paused projection。
-- 真正决定 `Continue` 结果的逻辑，必须在恢复驱动路径中重新读取 fresh persistence facts；不能把“可点 Continue”误解为“必然立即 proceeding”。
-- 若 `Continue` 后真源仍是 `blocked`，回复责任重申文案应当立即作为 runtime guide 同时进入 `dlg.msgs` 与持久化课程历史，并同步发前端气泡；这样后面真正恢复 drive 时只需正常读取上下文，不应再额外补发一条重复的 runtime prompt。
-- run-control 工具栏中的 `resumable` 计数，应与“是否允许手动 Continue 尝试”保持一致。因此，处于 interjection-paused `stopped` 的对话即便底层仍有用户等待事实，也应计入 `resumable`；因为 `Continue` 的业务语义正是“退出这层临时 paused projection，并从真源重判下一步”。
+**关键点**：“是否还有用户插话待可见回复”和“是否还有跨对话回复义务”是两个独立业务事实。提醒项 footer 可以直接用这两个事实定制：插话尚未答复时优先答人；插话已答复且回复义务仍 active 时，继续按跨对话回贴要求收口。
 
 **心智模型提醒**：
 
-- 不能只看 `displayState.kind === 'stopped'` 就理解这条链路。
-- 不能只看用户等待事实就理解为什么 UI 仍显示 `stopped`。
-- 也不能只看 `resume_dialog` eligibility 就推断恢复后一定马上运行。
 - 更不能把所有 `origin === 'user'` 的输入都笼统视作“用户插话”；`q4hAnswerCallId` 非空的 prompt 是 askHuman answer continuation，必须按另一条语义链处理。
+- 不能把 A2H 当成 Q4H；A2H 不阻塞 drive，也不把输入路由给智能体。
+- 不能把 A2H 放进 Problems 面板；它属于“待人处理”，由 Ack 删除。
 
 必须把以下几块一起看，才能形成完整且精确的理解：
 
 - reply-guidance 中对插话轮的回复义务 suppression / deferred reassertion
-- flow 中“插话回复后停车”与“Continue 后 fresh fact 二次判定”
-- dialog-display-state 中 paused projection 的保留策略
-- websocket resume 入口对“可尝试 Continue”与“实际已恢复 drive”的区分
+- 可见最终 `saying` 后对 pending user-interjection reply 的结算
+- A2H 持久化与 Ack 流程
+- 用户可见答复后的跨对话回复义务自动重申
 
 这是一条跨模块协同语义，不允许在单点上做“表面看起来更简单”的局部简化。
 

package/dist/evt-registry.js

@@ -50,6 +50,8 @@ class DialogEventRegistryImpl {
         switch (evt.type) {
             case 'new_q4h_asked':
             case 'q4h_answered':
+            case 'new_a2h_answered':
+            case 'a2h_acknowledged':
             case 'sideDialog_created_evt':
             case 'dlg_background_callee_summary_evt':
             case 'dlg_touched_evt':

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

@@ -254,6 +254,22 @@ function resolveReminderContextFollowingDialogState(prompt, currentTurnDialogMsg
         return 'none';
     return prompt.origin === 'user' ? 'user_message' : 'runtime_notice';
 }
+async function resolveReminderContextFooterState(args) {
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
+    const deferredReplyReassertion = latest?.deferredReplyReassertion;
+    const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(args.dlg.id, args.dlg.status);
+    const pendingUserInterjectionReply = latest?.pendingUserInterjectionReply !== undefined;
+    const interDialogReplyObligation = deferredReplyReassertion?.reason === 'user_interjection_with_parked_original_task'
+        ? 'parked_by_user_interjection'
+        : activeReplyObligation !== undefined
+            ? 'active'
+            : 'none';
+    return {
+        followingDialogState: resolveReminderContextFollowingDialogState(args.prompt, args.currentTurnDialogMsgsForContext),
+        pendingUserInterjectionReply,
+        interDialogReplyObligation,
+    };
+}
 function splitDialogMsgsForReminderInsertion(args) {
     const msgId = args.currentPrompt?.msgId;
     if (typeof msgId !== 'string' || msgId.trim() === '') {
@@ -281,6 +297,82 @@ function getUserOriginPromptMsgId(prompt) {
         ? prompt.msgId
         : undefined;
 }
+function samePendingUserInterjectionMsg(pending, msgId) {
+    return pending.msgId === msgId;
+}
+async function maybeResolveAnsweredUserInterjection(args) {
+    if (args.userPromptMsgId === undefined ||
+        args.assistantSayingContent === null ||
+        args.assistantSayingContent.trim() === '' ||
+        args.assistantSayingGenseq === null) {
+        return;
+    }
+    for (const rawGenseq of args.functionCallGenseqs) {
+        if (!Number.isFinite(rawGenseq) || rawGenseq <= 0) {
+            continue;
+        }
+        if (args.assistantSayingGenseq <= Math.floor(rawGenseq)) {
+            return;
+        }
+    }
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
+    const pending = latest?.pendingUserInterjectionReply;
+    if (pending === undefined || !samePendingUserInterjectionMsg(pending, args.userPromptMsgId)) {
+        return;
+    }
+    const course = args.dlg.activeGenCourseOrUndefined ?? args.dlg.currentCourse;
+    const answerIdSource = [
+        args.dlg.id.rootId,
+        args.dlg.id.selfId,
+        `c${String(course)}`,
+        `g${String(args.assistantSayingGenseq)}`,
+        pending.msgId,
+    ].join('|');
+    const answer = {
+        id: `a2h-${Buffer.from(answerIdSource).toString('base64url')}`,
+        content: args.assistantSayingContent,
+        answeredAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        userInterjection: {
+            msgId: pending.msgId,
+            course: pending.course,
+            genseq: pending.genseq,
+        },
+        answerRef: {
+            course,
+            genseq: args.assistantSayingGenseq,
+        },
+    };
+    const existingAnswers = await persistence_1.DialogPersistence.loadAnswersToHumanState(args.dlg.id, args.dlg.status);
+    if (!existingAnswers.some((item) => item.id === answer.id)) {
+        await persistence_1.DialogPersistence.appendAnswerToHumanState(args.dlg.id, answer, args.dlg.status);
+        const metadata = await persistence_1.DialogPersistence.loadDialogMetadata(args.dlg.id, args.dlg.status);
+        const taskDocPath = metadata?.taskDocPath ?? args.dlg.taskDocPath ?? '';
+        const event = {
+            type: 'new_a2h_answered',
+            answer: {
+                ...answer,
+                selfId: args.dlg.id.selfId,
+                rootId: args.dlg.id.rootId,
+                agentId: metadata?.agentId ?? args.dlg.agentId,
+                taskDocPath,
+            },
+        };
+        (0, evt_registry_1.postDialogEvent)(args.dlg, event);
+    }
+    await persistence_1.DialogPersistence.mutateDialogLatest(args.dlg.id, (previous) => {
+        const previousPending = previous.pendingUserInterjectionReply;
+        const userPromptMsgId = args.userPromptMsgId;
+        if (previousPending === undefined ||
+            userPromptMsgId === undefined ||
+            !samePendingUserInterjectionMsg(previousPending, userPromptMsgId)) {
+            return { kind: 'noop' };
+        }
+        return {
+            kind: 'patch',
+            patch: { pendingUserInterjectionReply: undefined },
+        };
+    }, args.dlg.status);
+}
 async function persistAndEmitRuntimeGuide(dlg, content) {
     await dlg.addChatMessages({
         type: 'transient_guide_msg',
@@ -2009,16 +2101,16 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                 }
                 lastBusinessContinuation = currentBusinessContinuation;
                 let generationBodyError;
+                const q4hAnswerCallId = normalizeQ4HAnswerCallId(currentPrompt?.q4hAnswerCallId);
+                const isQ4HAnswerPrompt = q4hAnswerCallId !== undefined;
                 try {
                     if (currentPrompt) {
                         if (currentPrompt.skipTaskdoc === true) {
                             skipTaskdocForThisDrive = true;
                         }
                         const persistedUserLanguageCode = currentPrompt.userLanguageCode ?? dlg.getLastUserLanguageCode();
-                        const q4hAnswerCallId = normalizeQ4HAnswerCallId(currentPrompt.q4hAnswerCallId);
                         // `q4hAnswerCallId` marks a continuation input for an already-materialized askHuman
                         // answer. It is not a second business-level user prompt that should re-enter transcript.
-                        const isQ4HAnswerPrompt = q4hAnswerCallId !== undefined;
                         const promptLanguage = persistedUserLanguageCode === 'zh' || persistedUserLanguageCode === 'en'
                             ? persistedUserLanguageCode
                             : (0, work_language_1.getWorkLanguage)();
@@ -2034,12 +2126,12 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             // User interjection suppression is a reversible state transition, not a one-shot
                             // latch. The normal cycle is:
                             // - user interjects -> suppress reply obligation
-                            // - operator clicks Continue -> restore reply obligation
+                            // - the visible local answer auto-reasserts the reply obligation
                             // - user interjects again -> suppress it again
                             //
-                            // Therefore a repeated interjection after a blocked Continue MUST re-arm the deferred
-                            // state and re-materialize the suppression guide, even when the underlying reply
-                            // directive itself did not change.
+                            // Legacy blocked-Continue paths may also re-enter here. A repeated interjection MUST
+                            // re-arm the deferred state and re-materialize the suppression guide, even when the
+                            // underlying reply directive itself did not change.
                             const existingDeferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(dlg.id, dlg.status);
                             const nextDeferredReplyReassertion = {
                                 reason: 'user_interjection_with_parked_original_task',
@@ -2077,6 +2169,18 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         if (replyGuidance.promptContent === undefined) {
                             throw new Error(`kernel-driver reply guidance invariant violation: missing prompt content for dialog=${dlg.id.valueOf()} msgId=${currentPrompt.msgId}`);
                         }
+                        if (currentPrompt.origin === 'user' && !replyGuidance.isQ4HAnswerPrompt) {
+                            await persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
+                                kind: 'patch',
+                                patch: {
+                                    pendingUserInterjectionReply: {
+                                        msgId: currentPrompt.msgId,
+                                        course: (0, storage_1.toDialogCourseNumber)(dlg.activeGenCourseOrUndefined ?? dlg.currentCourse),
+                                        genseq: (0, storage_1.toCallSiteGenseqNo)(dlg.activeGenSeq),
+                                    },
+                                },
+                            }), dlg.status);
+                        }
                         const renderPromptAsRuntimeGuideBubble = currentPrompt.origin === 'runtime' &&
                             (0, reply_prompt_copy_1.isStandaloneRuntimeGuidePromptContent)(replyGuidance.promptContent);
                         if (currentRuntimeGuideMsg) {
@@ -2225,7 +2329,11 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             {
                                 type: 'environment_msg',
                                 role: 'user',
-                                content: (0, driver_messages_1.formatReminderContextFooter)((0, work_language_1.getWorkLanguage)(), resolveReminderContextFollowingDialogState(currentPrompt, splitDialogMsgs.currentTurnDialogMsgsForContext)),
+                                content: (0, driver_messages_1.formatReminderContextFooter)((0, work_language_1.getWorkLanguage)(), await resolveReminderContextFooterState({
+                                    dlg,
+                                    prompt: currentPrompt,
+                                    currentTurnDialogMsgsForContext: splitDialogMsgs.currentTurnDialogMsgsForContext,
+                                })),
                             },
                         ]
                         : renderedReminders;
@@ -2588,10 +2696,13 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         }
                         return { usage: res.usage, llmGenModel: res.llmGenModel };
                     };
+                    const previousAssistantSayingGenseq = lastAssistantSayingGenseq;
                     const llmOutput = await streamOrBatch();
                     if (typeof llmOutput.llmGenModel === 'string' && llmOutput.llmGenModel.trim() !== '') {
                         llmGenModelForGen = llmOutput.llmGenModel.trim();
                     }
+                    let currentRoundAssistantSayingContent = null;
+                    let currentRoundAssistantSayingGenseq = null;
                     contextHealthForGen = computeContextHealthSnapshot({
                         providerCfg,
                         model,
@@ -2618,6 +2729,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                     else {
                                         lastAssistantSayingContent = msg.content;
                                         lastAssistantSayingGenseq = msg.genseq;
+                                        currentRoundAssistantSayingContent = msg.content;
+                                        currentRoundAssistantSayingGenseq = msg.genseq;
                                         lastAssistantReplyTarget = currentReplyTarget;
                                         await emitAssistantSaying(dlg, msg.content);
                                     }
@@ -2735,11 +2848,13 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     });
                     streamedFuncCalls.length = 0;
                     streamedFuncCalls.push(...normalizedStreamedFuncCalls);
+                    const currentRoundFunctionCallGenseqs = [];
                     for (const call of streamedFuncCalls) {
                         const rawCallGenseq = call.genseq;
                         if (!Number.isFinite(rawCallGenseq) || rawCallGenseq <= 0)
                             continue;
                         const callGenseq = Math.floor(rawCallGenseq);
+                        currentRoundFunctionCallGenseqs.push(callGenseq);
                         if (lastFunctionCallGenseq === null || callGenseq > lastFunctionCallGenseq) {
                             lastFunctionCallGenseq = callGenseq;
                         }
@@ -2761,6 +2876,21 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         newMsgs.push(...routed.pairedMessages);
                     }
                     await dlg.addChatMessages(...newMsgs);
+                    const streamedCurrentRoundSayingContent = batchOutputs.length === 0 && lastAssistantSayingGenseq !== previousAssistantSayingGenseq
+                        ? lastAssistantSayingContent
+                        : null;
+                    const streamedCurrentRoundSayingGenseq = batchOutputs.length === 0 && lastAssistantSayingGenseq !== previousAssistantSayingGenseq
+                        ? lastAssistantSayingGenseq
+                        : null;
+                    if (currentPrompt?.origin === 'user' && !isQ4HAnswerPrompt) {
+                        await maybeResolveAnsweredUserInterjection({
+                            dlg,
+                            userPromptMsgId: currentPrompt.msgId,
+                            assistantSayingContent: currentRoundAssistantSayingContent ?? streamedCurrentRoundSayingContent,
+                            assistantSayingGenseq: currentRoundAssistantSayingGenseq ?? streamedCurrentRoundSayingGenseq,
+                            functionCallGenseqs: currentRoundFunctionCallGenseqs,
+                        });
+                    }
                     const persistedFbrState = await loadDialogFbrState(dlg);
                     if (persistedFbrState) {
                         if (persistedFbrState.phase === 'finalization') {

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

@@ -1002,8 +1002,8 @@ async function maybeSurfaceDeferredReplyReassertionGuideForBlockedContinue(dialo
     // 3. emit runtime_guide_evt so the user immediately sees the reassertion bubble after Continue.
     //
     // Do not "optimize" this into only an event or only a deferred prompt. The whole point is that
-    // once blocked Continue is clicked, the guide becomes a first-class historical context fact and
-    // later real driving should need no special duplicate reassertion path.
+    // once a legacy blocked Continue path surfaces the guide, it becomes a first-class historical
+    // context fact and later real driving should need no special duplicate reassertion path.
     await surfaceRuntimeGuide(dialog, content);
     await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, {
         reason: 'user_interjection_with_parked_original_task',
@@ -1399,9 +1399,9 @@ async function executeDriveRound(args) {
         if (!humanPrompt) {
             // 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 resumption panel:
+            // is semantically special. 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 resumption panel:
             // - no active reply obligation / not suspended anymore -> continue real driving now
             // - active reply obligation + suspended -> restore the true suspension state
             // - active reply obligation + still proceeding continuation (for example queued prompt) ->
@@ -1623,6 +1623,15 @@ async function executeDriveRound(args) {
                 !replyGuidance.isQ4HAnswerPrompt &&
                 replyGuidance.suppressInterDialogReplyGuidance &&
                 replyGuidance.deferredReplyReassertionDirective !== undefined;
+        if (effectivePrompt?.origin === 'user' &&
+            !replyGuidance.isQ4HAnswerPrompt &&
+            !replyGuidance.suppressInterDialogReplyGuidance &&
+            replyGuidance.deferredReplyReassertionDirective !== undefined) {
+            await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, {
+                reason: 'user_interjection_with_parked_original_task',
+                directive: replyGuidance.deferredReplyReassertionDirective,
+            }, dialog.status);
+        }
         activeTellaskReplyDirective =
             replyGuidance.activeReplyDirective ?? replyContinuationScope.directive();
         activePromptWasReplyToolReminder = isReplyToolReminderPrompt(effectivePrompt);
@@ -1927,6 +1936,36 @@ async function executeDriveRound(args) {
                     }
                 }
             }
+            if (shouldPauseAfterLocalUserInterjection &&
+                !interruptedBySignal &&
+                followUp === undefined &&
+                driveResult?.lastAssistantSayingContent !== null) {
+                const deferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(dialog.id, dialog.status);
+                if (deferredReplyReassertion?.reason === 'user_interjection_with_parked_original_task') {
+                    const language = (0, work_language_1.getWorkLanguage)();
+                    const prompt = await (0, reply_guidance_1.buildReplyObligationReassertionPrompt)({
+                        dlg: dialog,
+                        directive: deferredReplyReassertion.directive,
+                        language,
+                    });
+                    followUp = {
+                        kind: 'runtime_reply_reminder',
+                        prompt,
+                        msgId: (0, id_1.generateShortId)(),
+                        grammar: 'markdown',
+                        origin: 'runtime',
+                        userLanguageCode: language,
+                        tellaskReplyDirective: deferredReplyReassertion.directive,
+                    };
+                    await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
+                    log_1.log.debug('kernel-driver queued automatic reply-obligation reassertion after user interjection answer', undefined, {
+                        dialogId: dialog.id.valueOf(),
+                        rootId: dialog.id.rootId,
+                        selfId: dialog.id.selfId,
+                        targetCallId: deferredReplyReassertion.directive.targetCallId,
+                    });
+                }
+            }
             if (followUp) {
                 if (followUp.kind === 'runtime_reply_reminder' ||
                     followUp.kind === 'runtime_sideDialog_reply_reminder') {
@@ -2016,21 +2055,8 @@ async function executeDriveRound(args) {
                 shouldDriveQueuedPromptAfterCore = true;
                 return driveResult;
             }
-            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, {
+            if (shouldPauseAfterLocalUserInterjection && !interruptedBySignal && followUp === undefined) {
+                log_1.log.debug('kernel-driver observed local user interjection pause condition, but continuation is now fully automatic', undefined, {
                     dialogId: dialog.id.valueOf(),
                     rootId: dialog.id.rootId,
                     selfId: dialog.id.selfId,

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

@@ -196,15 +196,15 @@ async function shouldSuppressInterDialogReplyGuidanceForUserInterjection(args) {
     // 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.
+    // 2. `flow.ts` answers locally and stores a deferred reply reassertion;
+    // 3. after a visible local answer, the driver reasserts the reply obligation automatically.
     //
     // Do not "simplify" this into a pure display-state check or a pure active-callee check.
     // Proceeding dialogs with a still-active reply obligation are part of the same rule: a fresh
     // user interjection should still suppress the live reply obligation and answer locally first.
-    // 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.
+    // The business anchor is the deferred reply reassertion. A stale paused execution marker still
+    // means a repeated interjection should behave as local side conversation, but it is not durable
+    // drive work and must not force a manual Continue after the answer is visible.
     const prompt = args.prompt;
     if (!prompt) {
         return false;

package/dist/minds/system-prompt-parts.js

@@ -204,6 +204,11 @@ function getMemoryPromptCopy(ctx) {
                 ? `工作流：先做事 → 再提炼（\`update_reminder\`；必要时整理差遣牒追加条目/更新提案并诉请 \`@${ctx.taskdocMaintainerId}\` 合并写入）→ 然后 \`clear_mind\` 清空噪音。`
                 : '工作流：停止扩张上下文 → 维护足够详尽的接续包提醒项（`add_reminder` 或 `update_reminder`，长度没有技术限制）→ 然后 `clear_mind` 开启新一程。',
             mainDialogWorkflowLine: '工作流：先做事 -> 再提炼（`update_reminder` + `mind_more(progress)`；需要压缩/删旧时先 `recall_taskdoc` 取得 `content_hash`，再用带 `previous_content_hash` 的 `change_mind`；要删除整章文件时用 `never_mind`）-> 然后 `clear_mind` 清空噪音。',
+            ...(ctx.isSideDialog
+                ? {}
+                : {
+                    progressVcsOrderLine: '硬性顺序：先补 `progress`，再动 git。只要这次代码/文档改动准备进 git（add / commit / push），先确认 `progress` 已经写清当前状态、决策、阻塞和下一步；如果还没写清，就先补写。简单判断：改动会进仓库 + `progress` 还没跟上 = 先别动 git。`git status` 只用来确认，不是提交动作。不要把“提交了某个 commit”“push 了”写进 `progress`。',
+                }),
             contextHealthLine: contextHealthLineZh,
             taskdocLogLine: taskdocLogLineZh,
         };
@@ -239,6 +244,11 @@ function getMemoryPromptCopy(ctx) {
             ? `Workflow: do work → distill (\`update_reminder\`; when Taskdoc needs updates, draft append entries, a merged replacement, or a section deletion and ask \`@${ctx.taskdocMaintainerId}\`) → then \`clear_mind\` to drop noise.`
             : 'Workflow: stop expanding context → maintain sufficiently detailed continuation-package reminders (`add_reminder` or `update_reminder`, with no technical length limit) → then `clear_mind` to start a new course.',
         mainDialogWorkflowLine: 'Workflow: do work -> distill (`update_reminder` + `mind_more(progress)`; when compression/deletion is needed, first use `recall_taskdoc` to get `content_hash`, then use `change_mind` with `previous_content_hash`; use `never_mind` when removing a whole section file) -> then `clear_mind` to drop noise.',
+        ...(ctx.isSideDialog
+            ? {}
+            : {
+                progressVcsOrderLine: 'Hard order: update `progress` first, then use git. If this code/docs change is going into git (add / commit / push), make sure `progress` already says the current state, decisions, blockers, and next step; if not, write it first. Simple check: change will enter the repo + `progress` is behind = stop and update `progress` first. `git status` is only for checking, not a commit step. Do not write git events like “committed X” or “ran git push” into progress.',
+            }),
         contextHealthLine: contextHealthLineEn,
         taskdocLogLine: taskdocLogLineEn,
     };
@@ -264,6 +274,7 @@ function buildMemorySystemPrompt(ctx) {
         ...(ctx.agentHasTeamMemoryTools ? [copy.teamMemoryHintLine] : []),
         ...(ctx.agentHasPersonalMemoryTools ? [copy.personalMemoryHintLine] : []),
         ctx.isSideDialog ? copy.sideDialogWorkflowLine : copy.mainDialogWorkflowLine,
+        ...(copy.progressVcsOrderLine === undefined ? [] : [copy.progressVcsOrderLine]),
         copy.contextHealthLine,
         copy.taskdocLogLine,
     ].join('\n');

package/dist/persistence-errors.d.ts

@@ -1,4 +1,4 @@
-export type DomindsPersistenceFileSource = 'dialog_state' | 'dialog_latest' | 'dialog_metadata' | 'dialog_asker_stack' | 'dialog_course_events' | 'reminder_state' | 'questions4human_state' | 'active_callees' | 'wake_queue' | 'sideDialog_responses' | 'sideDialog_registry';
+export type DomindsPersistenceFileSource = 'dialog_state' | 'dialog_latest' | 'dialog_metadata' | 'dialog_asker_stack' | 'dialog_course_events' | 'reminder_state' | 'questions4human_state' | 'answers2human_state' | 'active_callees' | 'wake_queue' | 'sideDialog_responses' | 'sideDialog_registry';
 export type DomindsPersistenceFileOperation = 'read' | 'parse';
 export type DomindsPersistenceFileFormat = 'yaml' | 'json' | 'jsonl';
 type DomindsPersistenceFileErrorArgs = {