dominds 1.16.8 → 1.16.10

package/README.md

@@ -203,7 +203,7 @@ Then:
 
 Platform note:
 
-- On Windows, the runtime does not register the `codex_style_tools` toolset. Do not grant `codex_style_tools` in `.minds/team.yaml` for Windows hosts.
+- On Windows, the runtime does not register the `codex_inspect_and_patch_tools` toolset. Do not grant `codex_inspect_and_patch_tools` in `.minds/team.yaml` for Windows hosts.
 
 ## Start from scratch
 

package/README.zh.md

@@ -142,7 +142,7 @@ dominds
 
 平台说明：
 
-- Windows 运行时不会注册 `codex_style_tools` 工具集。在 Windows 主机上的 `.minds/team.yaml` 中不要授予 `codex_style_tools`。
+- Windows 运行时不会注册 `codex_inspect_and_patch_tools` 工具集。在 Windows 主机上的 `.minds/team.yaml` 中不要授予 `codex_inspect_and_patch_tools`。
 
 ## 从零开始（空文件夹启动）
 

package/dist/docs/app-constitution.md

@@ -444,7 +444,7 @@ Suggested team shape:
   - non-goal: does not directly edit product code or take over build/process management.
 - `web_developer`
   - primary responsibility: implement UI/interaction fixes, consume `web_tester` findings, and close the loop;
-  - default toolsets: code-edit/search tools such as `codex_style_tools` (or equivalent) plus optional access to read tester evidence;
+  - default toolsets: code-edit/search tools such as `codex_inspect_and_patch_tools` (or equivalent) plus optional access to read tester evidence;
   - non-goal: should not blur browser acceptance into an implicit “I also tested it” posture; when acceptance is needed, it should explicitly tell/ask `web_tester`.
 
 Suggested `team.yaml` fragment:
@@ -463,7 +463,7 @@ members:
     icon: '🛠️'
     toolsets:
       - ws_read
-      - codex_style_tools
+      - codex_inspect_and_patch_tools
 ```
 
 Requirements for the `playwright_interactive` toolset design:

package/dist/docs/app-constitution.zh.md

@@ -443,7 +443,7 @@ Web Dev App 需要明确区分三套命名，避免再次漂移：
   - 非目标：不直接修改业务代码；不接管构建/进程管理。
 - `web_developer`
   - 主要职责：实现页面/UI/交互修复，消费 `web_tester` 的缺陷报告并完成闭环。
-  - 默认工具集：代码修改/检索工具（如 `codex_style_tools` 或等价工具）+ 可选读取 `web_tester` 产出的证据。
+  - 默认工具集：代码修改/检索工具（如 `codex_inspect_and_patch_tools` 或等价工具）+ 可选读取 `web_tester` 产出的证据。
   - 非目标：不把浏览器验收职责模糊地“顺手做掉”；需要时应显式 tellask `web_tester` 做验收。
 
 建议的 `team.yaml` 片段：
@@ -462,7 +462,7 @@ members:
     icon: '🛠️'
     toolsets:
       - ws_read
-      - codex_style_tools
+      - codex_inspect_and_patch_tools
 ```
 
 关于 `playwright_interactive` 工具集的设计要求：

package/dist/docs/dialog-system.md

@@ -168,6 +168,8 @@ When a dialog still carries an inter-dialog reply obligation, but the user tempo
 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.
 
+**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`:
@@ -183,6 +185,7 @@ After the user clicks `Continue`, the backend MUST re-evaluate fresh persistence
 
 - `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 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**:
@@ -190,6 +193,7 @@ After the user clicks `Continue`, the backend MUST re-evaluate fresh persistence
 - 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.
+- Do not flatten every `origin === 'user'` prompt into "interjection"; a non-empty `q4hAnswerCallId` means askHuman answer continuation and follows a different semantic path.
 
 You need all of the following together to understand the behavior correctly:
 

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

@@ -167,6 +167,8 @@
 5. 只要用户继续发送新消息，就继续作为插话临时对话处理；这个 paused projection 仅在它已被建立时持续保持。
 6. 只有用户显式点击 UI `Continue`，系统才尝试恢复原任务。
 
+**严格边界**：`askHuman` 的正式回答不属于这里的“用户插话”。只要一条 prompt 带着真实的 `q4hAnswerCallId`，它就属于 askHuman 回复通道，语义上是在继续已 materialize 的提问/应答链路，绝不能被压入“本地临时插话聊天”。
+
 **关键点**：这里的 `stopped` 只是一个临时 run-control / UI 投影，不等于普通 system-stop 失败，也不是最终的业务真源；并且它不是所有插话都会出现，只在“确有一个待恢复的原任务被临时停靠”时出现。
 
 点击 `Continue` 后，后端必须重新从 persistence 真源判定当前对话属于哪一种情况，而不能只根据表面的 `displayState` 做静态推断：
@@ -182,6 +184,7 @@
 
 - `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` 的对话即便底层仍有 blocker，也应计入 `resumable`；因为 `Continue` 的业务语义正是“退出这层临时 paused projection，并从真源重判下一步”。
 
 **心智模型提醒**：
@@ -189,6 +192,7 @@
 - 不能只看 `displayState.kind === 'stopped'` 就理解这条链路。
 - 不能只看 blocker facts 就理解为什么 UI 仍显示 `stopped`。
 - 也不能只看 `resume_dialog` eligibility 就推断恢复后一定马上运行。
+- 更不能把所有 `origin === 'user'` 的输入都笼统视作“用户插话”；`q4hAnswerCallId` 非空的 prompt 是 askHuman answer continuation，必须按另一条语义链处理。
 
 必须把以下几块一起看，才能形成完整且精确的理解：
 

package/dist/docs/team_mgmt-toolset.md

@@ -533,7 +533,7 @@ Best practices:
 
 - Make `member_defaults` conservative. Grant additional tools/dirs on a per-member basis.
 - Prefer toolsets over individually enumerating tools unless you need a one-off tool.
-- Platform note: Windows runtime intentionally does not register `codex_style_tools`; do not grant that toolset in `.minds/team.yaml` on Windows hosts.
+- Platform note: Windows runtime intentionally does not register `codex_inspect_and_patch_tools`; do not grant that toolset in `.minds/team.yaml` on Windows hosts.
 - Keep `.minds/team.yaml` ownership tight; only the team manager should be able to edit it.
 - Avoid repeating built-in constraints in `team.yaml`:
   - `*.tsk/**` (encapsulated Taskdocs) are hard-denied for all general file tools.

package/dist/docs/team_mgmt-toolset.zh.md

@@ -452,7 +452,7 @@ members:
 
 - 使 `member_defaults` 保守。按成员授予额外的工具/目录
 - 优先使用工具集而不是单独枚举工具，除非你需要一次性工具
-- 平台说明：Windows 运行时不会注册 `codex_style_tools`；在 Windows 主机上的 `.minds/team.yaml` 中不要授予该工具集
+- 平台说明：Windows 运行时不会注册 `codex_inspect_and_patch_tools`；在 Windows 主机上的 `.minds/team.yaml` 中不要授予该工具集
 - 保持 `.minds/team.yaml` 的所有权严格；只有团队管理者应该能够编辑它
 - 避免在 `team.yaml` 中重复内置约束：
   - `*.tsk/**`（封装的差遣牒任务包）对所有通用文件工具被硬性拒绝

package/dist/llm/gen/codex.d.ts

@@ -11,15 +11,7 @@ import type { FuncTool } from '../../tool';
 import type { ChatMessage, ProviderConfig } from '../client';
 import type { LlmBatchResult, LlmFailureDisposition, LlmGenerator, LlmRequestContext, LlmStreamReceiver, LlmStreamResult } from '../gen';
 export declare function resolveCodexServiceTier(serviceTier: ChatGptResponsesRequest['service_tier'] | undefined): Exclude<NonNullable<ChatGptResponsesRequest['service_tier']>, 'default'> | undefined;
-export declare function spliceCodexBuiltinPrompt(params: {
-    template: string;
-    defaultModel: string;
-    loadPrompt: (model: string) => string | null;
-}): string;
-export declare function resolveCodexInstructions(systemPrompt: string, options?: {
-    defaultModel?: string;
-    loadPrompt?: (model: string) => string | null;
-}): string;
+export declare function resolveCodexInstructions(systemPrompt: string): string;
 export declare class CodexGen implements LlmGenerator {
     get apiType(): string;
     classifyFailure(error: unknown): LlmFailureDisposition | undefined;

package/dist/llm/gen/codex.js

@@ -35,7 +35,6 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodexGen = void 0;
 exports.resolveCodexServiceTier = resolveCodexServiceTier;
-exports.spliceCodexBuiltinPrompt = spliceCodexBuiltinPrompt;
 exports.resolveCodexInstructions = resolveCodexInstructions;
 const log_1 = require("../../log");
 const i18n_text_1 = require("../../runtime/i18n-text");
@@ -47,7 +46,6 @@ const tool_output_limit_1 = require("./tool-output-limit");
 const tool_result_image_ingest_1 = require("./tool-result-image-ingest");
 const log = (0, log_1.createLogger)('llm/codex');
 const codexFallbackInstructions = 'You are Codex CLI.';
-const CODEX_SYSTEM_PROMPT_DIRECTIVE_PATTERN = /^([ \t]*)@codex-system-prompt(?::([A-Za-z0-9._-]+))?([ \t]*)$/gm;
 function resolveCodexServiceTier(serviceTier) {
     // The ChatGPT codex backend rejects the literal `default` tier even though some SDK typings
     // still list it. Omitting the field preserves the standard tier semantics without a 400.
@@ -116,29 +114,8 @@ function tryExtractApiReturnedModel(value) {
     const trimmed = model.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
-function spliceCodexBuiltinPrompt(params) {
-    let replaced = false;
-    const resolved = params.template.replace(CODEX_SYSTEM_PROMPT_DIRECTIVE_PATTERN, (_match, leading, overrideModel, trailing) => {
-        const selectedModel = overrideModel ?? params.defaultModel;
-        const prompt = params.loadPrompt(selectedModel);
-        if (prompt === null) {
-            throw new Error(`Bundled Codex prompt template not found for model: ${selectedModel}`);
-        }
-        replaced = true;
-        return `${leading}${prompt}${trailing}`;
-    });
-    return replaced ? resolved : params.template;
-}
-function resolveCodexInstructions(systemPrompt, options) {
-    const baseInstructions = systemPrompt.trim().length > 0 ? systemPrompt : codexFallbackInstructions;
-    if (options?.defaultModel === undefined || options.loadPrompt === undefined) {
-        return baseInstructions;
-    }
-    return spliceCodexBuiltinPrompt({
-        template: baseInstructions,
-        defaultModel: options.defaultModel,
-        loadPrompt: options.loadPrompt,
-    });
+function resolveCodexInstructions(systemPrompt) {
+    return systemPrompt.trim().length > 0 ? systemPrompt : codexFallbackInstructions;
 }
 function funcToolToCodex(funcTool) {
     // MCP schemas are passed through to providers. Codex tool schema types are narrower; runtime
@@ -534,10 +511,7 @@ class CodexGen {
         if (!agent.model) {
             throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
         }
-        const instructions = resolveCodexInstructions(systemPrompt, {
-            defaultModel: agent.model,
-            loadPrompt: codexAuth.loadCodexPromptSync,
-        });
+        const instructions = resolveCodexInstructions(systemPrompt);
         const payload = await buildCodexRequest(providerConfig, agent, instructions, funcTools, requestContext, context, receiver.toolResultImageIngest);
         let sayingStarted = false;
         let thinkingStarted = false;

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

@@ -807,7 +807,6 @@ async function emitAssistantSaying(dlg, content) {
     await dlg.sayingChunk(content);
     await dlg.sayingFinish();
 }
-const KERNEL_DRIVER_IDENTICAL_UPDATE_PLAN_ONLY_STOP_THRESHOLD = 3;
 function resolveFuncToolFollowupMode(tool) {
     return tool?.followupMode ?? 'immediate';
 }
@@ -820,20 +819,6 @@ function shouldImmediatelyFollowUpToolOutcome(tool, outcome) {
     }
     return shouldImmediatelyFollowUpSuccessfulToolResult(tool);
 }
-function formatIdenticalUpdatePlanLoopStopDetail(language) {
-    return language === 'zh'
-        ? `检测到连续 ${String(KERNEL_DRIVER_IDENTICAL_UPDATE_PLAN_ONLY_STOP_THRESHOLD)} 次完全相同的 update_plan 自动续跑，已停止本次自动执行以避免自激发循环。你可以点击“继续”人工观察，或先修改计划内容再继续。`
-        : `Detected ${String(KERNEL_DRIVER_IDENTICAL_UPDATE_PLAN_ONLY_STOP_THRESHOLD)} consecutive identical update_plan auto-follow-up rounds. Stopped this automatic run to avoid a self-trigger loop. You can click Continue to inspect manually, or change the plan content before resuming.`;
-}
-function extractAssistantSayingRoundSignature(newMsgs) {
-    const contents = newMsgs
-        .filter((msg) => msg.type === 'saying_msg' && msg.role === 'assistant')
-        .map((msg) => msg.content);
-    if (contents.length === 0) {
-        return undefined;
-    }
-    return JSON.stringify(contents);
-}
 async function executeFunctionCalls(args) {
     const functionPromises = args.funcCalls.map(async (func) => {
         throwIfAborted(args.abortSignal, args.dlg);
@@ -933,7 +918,6 @@ async function executeFunctionRound(args) {
             shouldStopAfterReplyTool: false,
             pairedMessages: [],
             tellaskToolOutputs: [],
-            updatePlanOnlyRound: false,
         };
     }
     throwIfAborted(args.abortSignal, args.dlg);
@@ -977,24 +961,6 @@ async function executeFunctionRound(args) {
         }
         return shouldImmediatelyFollowUpToolOutcome(tool, outcome);
     });
-    const updatePlanOnlyRound = (() => {
-        if (tellaskRound.normalCalls.length === 0) {
-            return false;
-        }
-        if (tellaskRound.handledCallIds.length > 0 || tellaskRound.toolOutputs.length > 0) {
-            return false;
-        }
-        for (const call of tellaskRound.normalCalls) {
-            if (call.name !== 'update_plan') {
-                return false;
-            }
-            const outcome = genericOutcomeByCallId.get(call.id);
-            if (outcome !== 'success') {
-                return false;
-            }
-        }
-        return true;
-    })();
     const resultByCallId = new Map();
     const register = (result) => {
         const existing = resultByCallId.get(result.id);
@@ -1043,7 +1009,6 @@ async function executeFunctionRound(args) {
         shouldStopAfterReplyTool: tellaskRound.shouldStopAfterReplyTool,
         pairedMessages,
         tellaskToolOutputs: [...tellaskRound.toolOutputs],
-        updatePlanOnlyRound,
     };
 }
 async function resetDiligenceBudgetAfterQ4H(dlg, team) {
@@ -1202,8 +1167,6 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
     let retryStoppedRecoveryPrompt;
     let skipTaskdocForThisDrive = humanPrompt?.skipTaskdoc === true;
     let genIterNo = 0;
-    let consecutiveIdenticalUpdatePlanOnlyRounds = 0;
-    let lastIdenticalUpdatePlanRoundSignature;
     // Quirk retry state intentionally spans multiple request invocations in the same driver run,
     // including course changes. Provider/API retry heuristics are tracked independently from
     // user-facing course boundaries.
@@ -1417,16 +1380,28 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         if (currentPrompt.origin === 'user' &&
                             replyGuidance.suppressInterDialogReplyGuidance &&
                             replyGuidance.deferredReplyReassertionDirective !== undefined) {
+                            // WARNING:
+                            // 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
+                            // - 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.
                             const existingDeferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(dlg.id, dlg.status);
                             const nextDeferredReplyReassertion = {
-                                reason: 'user_interjection_while_pending_subdialog',
+                                reason: 'user_interjection_with_parked_original_task',
                                 directive: replyGuidance.deferredReplyReassertionDirective,
                             };
-                            if (existingDeferredReplyReassertion === undefined ||
-                                !hasSameReplyDirective(existingDeferredReplyReassertion.directive, nextDeferredReplyReassertion.directive)) {
+                            const mustRearmDeferredReplyReassertion = existingDeferredReplyReassertion === undefined ||
+                                existingDeferredReplyReassertion.resumeGuideSurfaced === true ||
+                                !hasSameReplyDirective(existingDeferredReplyReassertion.directive, nextDeferredReplyReassertion.directive);
+                            if (mustRearmDeferredReplyReassertion) {
                                 await persistence_1.DialogPersistence.setDeferredReplyReassertion(dlg.id, nextDeferredReplyReassertion, dlg.status);
                             }
-                            if (existingDeferredReplyReassertion === undefined) {
+                            if (mustRearmDeferredReplyReassertion) {
                                 currentRuntimeGuideMsg = replyGuidance.transientGuideContent
                                     ? {
                                         type: 'transient_guide_msg',
@@ -1466,6 +1441,9 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             currentRuntimeGuideMsg = undefined;
                         }
                         if (isQ4HAnswerPrompt) {
+                            if (!replyGuidance.isQ4HAnswerPrompt) {
+                                throw new Error(`kernel-driver q4h answer classification invariant violation: msgId=${currentPrompt.msgId} was parsed as q4h answer before reply-guidance but not after`);
+                            }
                             // Record only the answered call correlation / user language for the resumed round.
                             // The actual human answer fact was already persisted via askHuman tellask result flow.
                             await dlg.receiveHumanReply({
@@ -1474,6 +1452,9 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 q4hAnswerCallId,
                             });
                         }
+                        else if (replyGuidance.isQ4HAnswerPrompt) {
+                            throw new Error(`kernel-driver q4h answer classification invariant violation: msgId=${currentPrompt.msgId} was classified as q4h answer by reply-guidance without a normalized q4hAnswerCallId`);
+                        }
                         else {
                             await dlg.addChatMessages({
                                 type: 'prompting_msg',
@@ -1992,25 +1973,6 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         newMsgs.push(...routed.pairedMessages);
                     }
                     await dlg.addChatMessages(...newMsgs);
-                    const assistantSayingRoundSignature = extractAssistantSayingRoundSignature(newMsgs);
-                    const identicalUpdatePlanRoundSignature = routed.updatePlanOnlyRound
-                        ? JSON.stringify({
-                            assistantSayingRoundSignature: assistantSayingRoundSignature ?? '',
-                        })
-                        : undefined;
-                    if (identicalUpdatePlanRoundSignature !== undefined) {
-                        if (identicalUpdatePlanRoundSignature === lastIdenticalUpdatePlanRoundSignature) {
-                            consecutiveIdenticalUpdatePlanOnlyRounds += 1;
-                        }
-                        else {
-                            consecutiveIdenticalUpdatePlanOnlyRounds = 1;
-                            lastIdenticalUpdatePlanRoundSignature = identicalUpdatePlanRoundSignature;
-                        }
-                    }
-                    else {
-                        consecutiveIdenticalUpdatePlanOnlyRounds = 0;
-                        lastIdenticalUpdatePlanRoundSignature = undefined;
-                    }
                     const persistedFbrState = await loadDialogFbrState(dlg);
                     if (persistedFbrState) {
                         if (persistedFbrState.phase === 'finalization') {
@@ -2096,27 +2058,6 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         await resetDiligenceBudgetAfterQ4H(dlg, team);
                         break;
                     }
-                    if (consecutiveIdenticalUpdatePlanOnlyRounds >=
-                        KERNEL_DRIVER_IDENTICAL_UPDATE_PLAN_ONLY_STOP_THRESHOLD) {
-                        const detail = formatIdenticalUpdatePlanLoopStopDetail((0, work_language_1.getWorkLanguage)());
-                        log_1.log.error(detail, new Error('kernel_driver_identical_update_plan_loop_stopped'), {
-                            dialogId: dlg.id.valueOf(),
-                            rootId: dlg.id.rootId,
-                            selfId: dlg.id.selfId,
-                            course: dlg.currentCourse,
-                            genseq: dlg.activeGenSeqOrUndefined ?? null,
-                            consecutiveIdenticalUpdatePlanOnlyRounds,
-                            identicalUpdatePlanRoundSignature,
-                        });
-                        throw new KernelDriverInterruptedError({
-                            kind: 'system_stop',
-                            detail,
-                            i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({
-                                detail,
-                                kind: 'identical_update_plan_loop',
-                            }),
-                        });
-                    }
                     // Start an immediate post-tool generation only when this round produced tool outputs that
                     // warrant same-drive LLM reaction right away. Provider-native side-channel UI events are
                     // meaningful output, but they are not transcript/context inputs and therefore must not

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

@@ -6,6 +6,7 @@ const run_control_1 = require("../../apps/run-control");
 const dialog_1 = require("../../dialog");
 const dialog_display_state_1 = require("../../dialog-display-state");
 const dialog_global_registry_1 = require("../../dialog-global-registry");
+const evt_registry_1 = require("../../evt-registry");
 const log_1 = require("../../log");
 const load_1 = require("../../minds/load");
 const persistence_1 = require("../../persistence");
@@ -271,6 +272,15 @@ async function maybeResolveDeferredReplyReassertionPrompt(dialog) {
         await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
         return undefined;
     }
+    // WARNING:
+    // `resumeGuideSurfaced` means the reply-obligation reassertion has already been materialized as a
+    // runtime guide and injected into both dialog.msgs and persisted course history at blocked
+    // Continue time. Once that has happened, later real resume must not emit a second visible prompt:
+    // normal context replay is now the source of truth for the model-facing reminder.
+    if (deferredReplyReassertion.resumeGuideSurfaced === true) {
+        await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
+        return undefined;
+    }
     await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
     const language = (0, work_language_1.getWorkLanguage)();
     return {
@@ -286,6 +296,51 @@ async function maybeResolveDeferredReplyReassertionPrompt(dialog) {
         tellaskReplyDirective: deferredReplyReassertion.directive,
     };
 }
+async function maybeSurfaceDeferredReplyReassertionGuideForBlockedContinue(dialog) {
+    const deferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(dialog.id, dialog.status);
+    if (!deferredReplyReassertion || deferredReplyReassertion.resumeGuideSurfaced === true) {
+        return;
+    }
+    const activeDirective = await (0, tellask_special_1.loadLatestActiveTellaskReplyDirective)(dialog);
+    if (!activeDirective ||
+        activeDirective.targetCallId !== deferredReplyReassertion.directive.targetCallId) {
+        await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
+        return;
+    }
+    const language = (0, work_language_1.getWorkLanguage)();
+    const content = await (0, reply_guidance_1.buildReplyObligationReassertionPrompt)({
+        dlg: dialog,
+        directive: deferredReplyReassertion.directive,
+        language,
+    });
+    const genseq = dialog.activeGenSeqOrUndefined ?? 1;
+    // WARNING:
+    // This helper intentionally does three things at once:
+    // 1. append the guide into dialog.msgs so an in-memory later resume sees it naturally;
+    // 2. persist a runtime_guide_record so reload/replay reconstructs the same context;
+    // 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.
+    await dialog.addChatMessages({
+        type: 'transient_guide_msg',
+        role: 'assistant',
+        content,
+    });
+    await persistence_1.DialogPersistence.persistRuntimeGuide(dialog, content, genseq);
+    (0, evt_registry_1.postDialogEvent)(dialog, {
+        type: 'runtime_guide_evt',
+        course: dialog.currentCourse,
+        genseq,
+        content,
+    });
+    await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, {
+        reason: 'user_interjection_with_parked_original_task',
+        directive: deferredReplyReassertion.directive,
+        resumeGuideSurfaced: true,
+    }, dialog.status);
+}
 async function resolveEffectivePrompt(dialog, humanPrompt) {
     if (humanPrompt) {
         return { prompt: humanPrompt, fromUpNext: false };
@@ -439,6 +494,7 @@ async function executeDriveRound(args) {
                         subdialogs: suspension.subdialogs,
                     });
                     await (0, dialog_display_state_1.setDialogDisplayState)(dialog.id, restoredState);
+                    await maybeSurfaceDeferredReplyReassertionGuideForBlockedContinue(dialog);
                     log_1.log.debug('kernel-driver continue after interjection pause restored true suspended state from fresh persistence facts', undefined, {
                         dialogId: dialog.id.valueOf(),
                         restoredState,
@@ -582,8 +638,13 @@ async function executeDriveRound(args) {
         // 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.
+        //
+        // Q4H answers are explicitly outside this branch even though they also come from the human.
+        // They belong to the askHuman reply channel and must continue the suspended askHuman round,
+        // never be mistaken for ad hoc interjection chat.
         shouldPauseAfterLocalUserInterjection =
             effectivePrompt?.origin === 'user' &&
+                !replyGuidance.isQ4HAnswerPrompt &&
                 replyGuidance.suppressInterDialogReplyGuidance &&
                 replyGuidance.deferredReplyReassertionDirective !== undefined;
         activeTellaskReplyDirective = replyGuidance.activeReplyDirective;

package/dist/llm/kernel-driver/reply-guidance.d.ts

@@ -12,6 +12,7 @@ export declare function resolvePromptReplyGuidance(args: {
 }): Promise<{
     activeReplyDirective: KernelDriverHumanPrompt['tellaskReplyDirective'];
     deferredReplyReassertionDirective: KernelDriverHumanPrompt['tellaskReplyDirective'];
+    isQ4HAnswerPrompt: boolean;
     promptContent: string | undefined;
     persistedTellaskReplyDirective: KernelDriverHumanPrompt['tellaskReplyDirective'];
     suppressInterDialogReplyGuidance: boolean;

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

@@ -92,6 +92,8 @@ async function shouldSuppressInterDialogReplyGuidanceForUserInterjection(args) {
     //    blocked or resume real driving.
     //
     // Do not "simplify" this into a pure display-state check or a pure pending-subdialog 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.
     const prompt = args.prompt;
@@ -105,13 +107,17 @@ async function shouldSuppressInterDialogReplyGuidanceForUserInterjection(args) {
         return false;
     }
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
-    if (latest?.deferredReplyReassertion?.reason === 'user_interjection_while_pending_subdialog') {
+    if (latest?.deferredReplyReassertion?.reason === 'user_interjection_with_parked_original_task') {
         return true;
     }
     if (latest?.executionMarker?.kind === 'interrupted' &&
         (0, interjection_pause_stop_1.isUserInterjectionPauseStopReason)(latest.executionMarker.reason)) {
         return true;
     }
+    const activeReplyDirective = await (0, tellask_special_1.loadLatestActiveTellaskReplyDirective)(args.dlg);
+    if (activeReplyDirective) {
+        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);
@@ -119,10 +125,13 @@ async function shouldSuppressInterDialogReplyGuidanceForUserInterjection(args) {
 }
 async function resolvePromptReplyGuidance(args) {
     const prompt = args.prompt;
-    const suppressInterDialogReplyGuidance = await shouldSuppressInterDialogReplyGuidanceForUserInterjection({
-        dlg: args.dlg,
-        prompt,
-    });
+    const isQ4HAnswerPrompt = typeof prompt?.q4hAnswerCallId === 'string' && prompt.q4hAnswerCallId.trim() !== '';
+    const suppressInterDialogReplyGuidance = isQ4HAnswerPrompt
+        ? false
+        : await shouldSuppressInterDialogReplyGuidanceForUserInterjection({
+            dlg: args.dlg,
+            prompt,
+        });
     const availableReplyDirective = prompt?.tellaskReplyDirective ?? (await (0, tellask_special_1.loadLatestActiveTellaskReplyDirective)(args.dlg));
     const activeReplyDirective = suppressInterDialogReplyGuidance
         ? undefined
@@ -142,6 +151,7 @@ async function resolvePromptReplyGuidance(args) {
         deferredReplyReassertionDirective: suppressInterDialogReplyGuidance
             ? availableReplyDirective
             : undefined,
+        isQ4HAnswerPrompt,
         promptContent,
         persistedTellaskReplyDirective: prompt?.tellaskReplyDirective ?? activeReplyDirective,
         suppressInterDialogReplyGuidance,

package/dist/llm/stop-reason-i18n.d.ts

@@ -1,5 +1,5 @@
 import type { DialogDisplayTextI18n } from '@longrun-ai/kernel/types/display-state';
-type HumanStopReasonKind = 'aborted' | 'transport_interrupted' | 'malformed_stream' | 'conflicting_stream' | 'invalid_tool_call' | 'incomplete_tool_call_stream' | 'invalid_tool_context' | 'provider_rejected' | 'request_failed' | 'identical_update_plan_loop' | 'generic';
+type HumanStopReasonKind = 'aborted' | 'transport_interrupted' | 'malformed_stream' | 'conflicting_stream' | 'invalid_tool_call' | 'incomplete_tool_call_stream' | 'invalid_tool_context' | 'provider_rejected' | 'request_failed' | 'generic';
 export declare function buildHumanSystemStopReasonTextI18n(args: {
     detail: string;
     providerName?: string;

package/dist/llm/stop-reason-i18n.js

@@ -82,10 +82,6 @@ function renderHumanStopReason(args) {
             return args.language === 'zh'
                 ? `本次生成因上游报错而停止。${formatUpstreamRawMessage(args.detail, 'zh')}`
                 : `This generation was stopped because the upstream service returned an error. ${formatUpstreamRawMessage(args.detail, 'en')}`;
-        case 'identical_update_plan_loop':
-            return args.language === 'zh'
-                ? '模型连续重复相同的 update_plan 结果，本次生成已停止。'
-                : 'The model repeated the same update_plan result multiple times. This generation was stopped.';
         case 'generic':
             return args.language === 'zh'
                 ? `本次生成已因系统错误停止。${formatUpstreamRawMessage(args.detail, 'zh')}`

package/dist/persistence.js

@@ -1003,12 +1003,16 @@ function parseDialogLatestFile(value) {
             return undefined;
         if (!isRecord(deferredReplyReassertionRaw))
             return null;
-        if (deferredReplyReassertionRaw.reason !== 'user_interjection_while_pending_subdialog') {
+        if (deferredReplyReassertionRaw.reason !== 'user_interjection_with_parked_original_task') {
             return null;
         }
         const directiveRaw = deferredReplyReassertionRaw.directive;
         if (!isRecord(directiveRaw))
             return null;
+        const resumeGuideSurfacedRaw = deferredReplyReassertionRaw.resumeGuideSurfaced;
+        if (resumeGuideSurfacedRaw !== undefined && typeof resumeGuideSurfacedRaw !== 'boolean') {
+            return null;
+        }
         const expectedReplyCallName = directiveRaw.expectedReplyCallName;
         const targetCallId = directiveRaw.targetCallId;
         const tellaskContent = directiveRaw.tellaskContent;
@@ -1025,22 +1029,28 @@ function parseDialogLatestFile(value) {
             if (typeof targetDialogId !== 'string')
                 return null;
             return {
-                reason: 'user_interjection_while_pending_subdialog',
+                reason: 'user_interjection_with_parked_original_task',
                 directive: {
                     expectedReplyCallName,
                     targetCallId,
                     targetDialogId,
                     tellaskContent,
                 },
+                ...(resumeGuideSurfacedRaw === undefined
+                    ? {}
+                    : { resumeGuideSurfaced: resumeGuideSurfacedRaw }),
             };
         }
         return {
-            reason: 'user_interjection_while_pending_subdialog',
+            reason: 'user_interjection_with_parked_original_task',
             directive: {
                 expectedReplyCallName,
                 targetCallId,
                 tellaskContent,
             },
+            ...(resumeGuideSurfacedRaw === undefined
+                ? {}
+                : { resumeGuideSurfaced: resumeGuideSurfacedRaw }),
         };
     })();
     if (deferredReplyReassertion === null)

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

@@ -12,6 +12,10 @@ const USER_INTERJECTION_PAUSE_STOP_DETAIL = 'user_interjection_pause_resume_orig
 // resume afterwards, the interjection should simply complete and the dialog should fall back to
 // its true underlying state without showing this stopped panel.
 //
+// In particular, askHuman answers are NOT "user interjections" for this purpose. A prompt carrying
+// a real `q4hAnswerCallId` belongs to the askHuman reply channel and must never be routed through
+// this paused-original-task stop semantics.
+//
 // 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