dominds 1.16.7 → 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/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/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

@@ -155,6 +155,55 @@ 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.
+
+**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 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".
+- 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**:
+
+- 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:
+
+- 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,55 @@
 
 这确保了崩溃恢复，并使后端能够从任何持久化状态恢复，而不依赖于前端状态。
 
+### 用户插话暂停与 Continue 语义
+
+当某个对话仍带有跨对话回复义务，但用户临时插话要求它先处理本地问题时，系统必须区分**UI 投影**与**真实驱动源状态**。
+
+**规范语义**：
+
+1. 每条用户插话消息都按正常驱动轮完整执行。
+2. 若该轮需要工具，则必须先完整跑完该工具轮及其 post-tool follow-up。
+3. 只有当这条插话确实打断了一个仍待恢复的“原任务”时，系统才把该原任务投影为可 `Continue` 的 `stopped`，让用户先看到最后一条回复。
+4. 若当前并不存在待恢复的原任务（例如没有待重申的跨对话回复义务），则插话轮结束后应直接回到真实 underlying state，而不显示这个特殊 `stopped` 面板。
+5. 只要用户继续发送新消息，就继续作为插话临时对话处理；这个 paused projection 仅在它已被建立时持续保持。
+6. 只有用户显式点击 UI `Continue`，系统才尝试恢复原任务。
+
+**严格边界**：`askHuman` 的正式回答不属于这里的“用户插话”。只要一条 prompt 带着真实的 `q4hAnswerCallId`，它就属于 askHuman 回复通道，语义上是在继续已 materialize 的提问/应答链路，绝不能被压入“本地临时插话聊天”。
+
+**关键点**：这里的 `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”。
+- 若 `Continue` 后真源仍是 `blocked`，回复责任重申文案应当立即作为 runtime guide 同时进入 `dlg.msgs` 与持久化课程历史，并同步发前端气泡；这样后面真正恢复 drive 时只需正常读取上下文，不应再额外补发一条重复的 runtime prompt。
+- run-control 工具栏中的 `resumable` 计数，应与“是否允许手动 Continue 尝试”保持一致。因此，处于 interjection-paused `stopped` 的对话即便底层仍有 blocker，也应计入 `resumable`；因为 `Continue` 的业务语义正是“退出这层临时 paused projection，并从真源重判下一步”。
+
+**心智模型提醒**：
+
+- 不能只看 `displayState.kind === 'stopped'` 就理解这条链路。
+- 不能只看 blocker facts 就理解为什么 UI 仍显示 `stopped`。
+- 也不能只看 `resume_dialog` eligibility 就推断恢复后一定马上运行。
+- 更不能把所有 `origin === 'user'` 的输入都笼统视作“用户插话”；`q4hAnswerCallId` 非空的 prompt 是 askHuman answer continuation，必须按另一条语义链处理。
+
+必须把以下几块一起看，才能形成完整且精确的理解：
+
+- reply-guidance 中对插话轮的回复义务 suppression / deferred reassertion
+- flow 中“插话回复后停车”与“Continue 后 fresh fact 二次判定”
+- dialog-display-state 中 paused projection 的保留策略
+- websocket resume 入口对“可尝试 Continue”与“实际已恢复 drive”的区分
+
+这是一条跨模块协同语义，不允许在单点上做“表面看起来更简单”的局部简化。
+
 ---
 
 ## 三类队友诉请分类

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