dominds 1.27.2 → 1.27.3

package/dist/apps/runtime.js

@@ -123,7 +123,9 @@ async function resolveTargetDialog(sourceDlg, target) {
         }
         return sideDialog;
     }
-    const matches = targetRoot.getAllDialogs().filter((dialog) => dialog.agentId === target.agentId);
+    const matches = targetRoot
+        .getLoadedDialogTreeSnapshot()
+        .filter((dialog) => dialog.agentId === target.agentId);
     if (matches.length === 1) {
         return matches[0];
     }

package/dist/dialog-global-registry.d.ts

@@ -1,4 +1,4 @@
-import { type MainDialog } from './dialog';
+import { type Dialog, type MainDialog } from './dialog';
 export type DriveTriggerEvent = Readonly<{
     type: 'drive_trigger_evt';
     action: 'queue_root_drive' | 'clear_root_drive_queue' | 'active_run_cleared';
@@ -47,6 +47,16 @@ declare class GlobalDialogRegistry {
     noteActiveRunBlockedQueuedDrive(rootId: string): void;
     hasPendingActiveRunClearedDrive(rootId: string): boolean;
     isRootDriveQueued(rootId: string): boolean;
+    /**
+     * One-shot runtime snapshot for shared-reminder impact routing.
+     *
+     * This intentionally does not enumerate persisted "all running dialogs". It walks only the roots
+     * this runtime has already registered, and includes only dialogs with direct in-memory evidence
+     * of current work: locked running main dialogs and the loaded active-callee frontier under each
+     * root. Dialogs that merely remain in memory/history but have no current-work signal are not
+     * considered parallel work.
+     */
+    getLoadedInFlightDialogsForSharedReminderImpact(): Dialog[];
     getLastDriveTrigger(rootId: string): DriveTriggerEvent | undefined;
     consumeQueuedMainDialogs(): MainDialog[];
     get size(): number;

package/dist/dialog-global-registry.js

@@ -218,6 +218,51 @@ class GlobalDialogRegistry {
     isRootDriveQueued(rootId) {
         return this.entries.get(rootId)?.driveQueued === true;
     }
+    /**
+     * One-shot runtime snapshot for shared-reminder impact routing.
+     *
+     * This intentionally does not enumerate persisted "all running dialogs". It walks only the roots
+     * this runtime has already registered, and includes only dialogs with direct in-memory evidence
+     * of current work: locked running main dialogs and the loaded active-callee frontier under each
+     * root. Dialogs that merely remain in memory/history but have no current-work signal are not
+     * considered parallel work.
+     */
+    getLoadedInFlightDialogsForSharedReminderImpact() {
+        const dialogs = [];
+        for (const entry of this.entries.values()) {
+            const rootDialog = entry.mainDialog;
+            const visitedDialogIds = new Set();
+            const stack = [];
+            if (rootDialog.status === 'running' && rootDialog.isLocked()) {
+                dialogs.push(rootDialog);
+                visitedDialogIds.add(rootDialog.id.valueOf());
+            }
+            for (const calleeId of rootDialog.activeCalleeDialogIds) {
+                const loadedCallee = rootDialog.lookupDialog(calleeId.selfId);
+                if (loadedCallee && loadedCallee.status === 'running') {
+                    stack.push(loadedCallee);
+                }
+            }
+            while (stack.length > 0) {
+                const current = stack.pop();
+                if (!current || visitedDialogIds.has(current.id.valueOf())) {
+                    continue;
+                }
+                visitedDialogIds.add(current.id.valueOf());
+                if (current.status !== 'running') {
+                    continue;
+                }
+                dialogs.push(current);
+                for (const calleeId of current.activeCalleeDialogIds) {
+                    const loadedCallee = rootDialog.lookupDialog(calleeId.selfId);
+                    if (loadedCallee && loadedCallee.status === 'running') {
+                        stack.push(loadedCallee);
+                    }
+                }
+            }
+        }
+        return dialogs;
+    }
     getLastDriveTrigger(rootId) {
         return this.lastDriveTriggerByRootId.get(rootId);
     }

package/dist/dialog.d.ts

@@ -275,6 +275,8 @@ export declare abstract class Dialog {
     private processReminderCollection;
     private buildVisibleReminderContents;
     private emitFullRemindersUpdate;
+    private reportReminderRuntimeFailure;
+    private dispatchSharedReminderOwnerUpdateImpacts;
     /**
      * Emits current visible reminders without reconciling tool-owned state or writing persistence.
      * This is for read-only dialog display, especially completed/archived dialogs opened from old tabs.
@@ -371,6 +373,13 @@ export declare abstract class Dialog {
         tellaskReplyDirective: TellaskReplyDirective;
         skipTaskdoc?: boolean;
     }): Promise<DialogQueuedPromptState>;
+    queueRuntimeGuidePrompt(options: {
+        prompt: string;
+        msgId: string;
+        grammar: 'markdown';
+        userLanguageCode?: LanguageCode;
+        skipTaskdoc?: boolean;
+    }): Promise<DialogQueuedPromptState>;
     queueRuntimeSideDialogPrompt(options: {
         prompt: string;
         msgId: string;
@@ -529,9 +538,9 @@ export declare class MainDialog extends Dialog {
      */
     lookupDialog(selfId: string): Dialog | undefined;
     /**
-     * Get all registered dialogs in this dialog tree.
+     * Snapshot of dialogs loaded in this root's in-memory dialog tree.
      */
-    getAllDialogs(): Dialog[];
+    getLoadedDialogTreeSnapshot(): Dialog[];
     /**
      * Remove a dialog from the local registry.
      */

package/dist/dialog.js

@@ -572,6 +572,7 @@ class Dialog {
     }
     async processReminderCollection(reminders) {
         let changed = false;
+        const updatedReminderIds = [];
         const indicesToRemove = [];
         for (let i = 0; i < reminders.length; i++) {
             const reminder = reminders[i];
@@ -599,26 +600,42 @@ class Dialog {
                             priority: reminder.priority,
                             renderMode: reminder.renderMode,
                         });
-                        const contentChanged = updatedReminder.content !== reminder.content;
-                        const metaChanged = updatedReminder.meta !== reminder.meta;
-                        if (contentChanged || metaChanged) {
+                        const reminderChanged = (0, tool_1.computeReminderRenderRevision)(updatedReminder) !==
+                            (0, tool_1.computeReminderRenderRevision)(reminder);
+                        if (reminderChanged) {
                             reminders[i] = updatedReminder;
                             changed = true;
+                            updatedReminderIds.push(updatedReminder.id);
                         }
                         break;
                     }
                     case 'keep':
                         break;
+                    default: {
+                        const _exhaustive = result.treatment;
+                        return _exhaustive;
+                    }
                 }
             }
             catch (error) {
-                log_1.log.error(`Error updating reminder from tool ${reminder.owner}:`, error);
+                const detail = `Reminder owner update failed ` +
+                    `(rootId=${this.id.rootId}, selfId=${this.id.selfId}, course=${this.currentCourse}, ` +
+                    `reminderId=${reminder.id}, owner=${reminder.owner.name}, taskDocPath=${this.taskDocPath})`;
+                await this.reportReminderRuntimeFailure(detail, error, {
+                    rootId: this.id.rootId,
+                    selfId: this.id.selfId,
+                    course: this.currentCourse,
+                    reminderId: reminder.id,
+                    ownerName: reminder.owner.name,
+                    taskDocPath: this.taskDocPath,
+                });
+                throw error;
             }
         }
         for (let i = indicesToRemove.length - 1; i >= 0; i--) {
             reminders.splice(indicesToRemove[i], 1);
         }
-        return changed;
+        return { changed, updatedReminderIds };
     }
     buildVisibleReminderContents(taskSharedReminders, runtimeReminders) {
         const visibleReminders = [
@@ -644,6 +661,32 @@ class Dialog {
         };
         (0, evt_registry_1.postDialogEvent)(this, fullRemindersEvt);
     }
+    async reportReminderRuntimeFailure(detail, error, context) {
+        try {
+            await this.streamError(detail);
+        }
+        catch (streamError) {
+            log_1.log.warn('Failed to emit stream_error_evt for reminder runtime failure', streamError, {
+                ...context,
+                streamErrorMessage: streamError instanceof Error ? streamError.message : String(streamError),
+            });
+        }
+        log_1.log.error(detail, error, {
+            ...context,
+            errorMessage: error instanceof Error ? error.message : String(error),
+        });
+    }
+    async dispatchSharedReminderOwnerUpdateImpacts(reminderIds, scope) {
+        const { dispatchSharedReminderUpdateImpact } = await import('./runtime/shared-reminder-update-impact.js');
+        for (const reminderId of reminderIds) {
+            await dispatchSharedReminderUpdateImpact({
+                updater: this,
+                reminderId,
+                scope,
+                language: (0, work_language_1.getWorkLanguage)(),
+            });
+        }
+    }
     /**
      * Emits current visible reminders without reconciling tool-owned state or writing persistence.
      * This is for read-only dialog display, especially completed/archived dialogs opened from old tabs.
@@ -675,10 +718,10 @@ class Dialog {
         const runtimeTarget = { kind: 'agent', agentId: this.agentId };
         const taskSharedReminders = await (0, shared_reminders_1.loadSharedReminders)(taskSharedTarget);
         const runtimeReminders = await (0, shared_reminders_1.loadSharedReminders)(runtimeTarget);
-        const localChanged = await this.processReminderCollection(this.reminders);
-        const taskSharedChanged = await this.processReminderCollection(taskSharedReminders);
-        const runtimeChanged = await this.processReminderCollection(runtimeReminders);
-        if (localChanged || taskSharedChanged || runtimeChanged) {
+        const localResult = await this.processReminderCollection(this.reminders);
+        const taskSharedResult = await this.processReminderCollection(taskSharedReminders);
+        const runtimeResult = await this.processReminderCollection(runtimeReminders);
+        if (localResult.changed || taskSharedResult.changed || runtimeResult.changed) {
             this.touchReminders();
         }
         // Centralized persistence - called when emitting event.
@@ -687,26 +730,55 @@ class Dialog {
             await this.dlgStore.persistReminders(this, this.reminders);
         }
         catch (err) {
-            log_1.log.warn('Failed to persist reminders', err, { dialogId: this.id.valueOf() });
+            const detail = `Failed to persist dialog-local reminders ` +
+                `(rootId=${this.id.rootId}, selfId=${this.id.selfId}, course=${this.currentCourse})`;
+            await this.reportReminderRuntimeFailure(detail, err, {
+                rootId: this.id.rootId,
+                selfId: this.id.selfId,
+                course: this.currentCourse,
+                taskDocPath: this.taskDocPath,
+            });
+            throw err;
         }
         try {
             await (0, shared_reminders_1.replaceSharedReminders)(taskSharedTarget, taskSharedReminders);
         }
         catch (err) {
-            log_1.log.warn('Failed to persist task-scoped reminders', err, {
-                dialogId: this.id.valueOf(),
+            const detail = `Failed to persist task-scoped reminders ` +
+                `(rootId=${this.id.rootId}, selfId=${this.id.selfId}, course=${this.currentCourse}, ` +
+                `agentId=${this.agentId}, taskDocPath=${this.taskDocPath})`;
+            await this.reportReminderRuntimeFailure(detail, err, {
+                rootId: this.id.rootId,
+                selfId: this.id.selfId,
+                course: this.currentCourse,
                 agentId: this.agentId,
                 taskDocPath: this.taskDocPath,
             });
+            throw err;
         }
+        await this.dispatchSharedReminderOwnerUpdateImpacts(taskSharedResult.updatedReminderIds, 'task');
         try {
             await (0, shared_reminders_1.replaceSharedReminders)(runtimeTarget, runtimeReminders);
         }
         catch (err) {
-            log_1.log.warn('Failed to persist agent-scoped reminders', err, {
-                dialogId: this.id.valueOf(),
+            const detail = `Failed to persist agent-scoped reminders ` +
+                `(rootId=${this.id.rootId}, selfId=${this.id.selfId}, course=${this.currentCourse}, ` +
+                `agentId=${this.agentId})`;
+            await this.reportReminderRuntimeFailure(detail, err, {
+                rootId: this.id.rootId,
+                selfId: this.id.selfId,
+                course: this.currentCourse,
                 agentId: this.agentId,
+                taskDocPath: this.taskDocPath,
             });
+            throw err;
+        }
+        for (const reminderId of runtimeResult.updatedReminderIds) {
+            const reminder = runtimeReminders.find((candidate) => candidate.id === reminderId);
+            if (!reminder) {
+                throw new Error(`Updated shared reminder ${reminderId} disappeared before update impact dispatch`);
+            }
+            await this.dispatchSharedReminderOwnerUpdateImpacts([reminderId], reminder.scope === 'runtime' ? 'runtime' : 'agent');
         }
         const reminders = this.buildVisibleReminderContents(taskSharedReminders, runtimeReminders);
         this.emitFullRemindersUpdate(reminders);
@@ -1168,6 +1240,24 @@ class Dialog {
         });
         return created;
     }
+    async queueRuntimeGuidePrompt(options) {
+        const common = this.runtimePromptCommon(options);
+        const created = {
+            ...common,
+            kind: 'new_course_runtime_guide',
+            skipTaskdoc: options.skipTaskdoc,
+        };
+        this.enqueueQueuedPromptState(created);
+        await this.persistPendingRuntimePrompt({
+            content: created.prompt,
+            msgId: created.msgId,
+            grammar: created.grammar ?? 'markdown',
+            userLanguageCode: created.userLanguageCode,
+            origin: 'runtime',
+            skipTaskdoc: created.skipTaskdoc,
+        });
+        return created;
+    }
     async queueRuntimeSideDialogPrompt(options) {
         const common = this.runtimePromptCommon(options);
         const created = {
@@ -1860,7 +1950,7 @@ exports.SideDialog = SideDialog;
  */
 class MainDialog extends Dialog {
     _status = 'running';
-    // Tracks all dialogs in this dialog tree for O(1) lookup
+    // Tracks dialogs loaded into this root's in-memory dialog tree for O(1) lookup
     _localRegistry = new Map();
     // Tracks Type-B registered sideDialogs by agentId!sessionSlug
     _sideDialogRegistry = new Map();
@@ -1887,9 +1977,9 @@ class MainDialog extends Dialog {
         return this._localRegistry.get(selfId);
     }
     /**
-     * Get all registered dialogs in this dialog tree.
+     * Snapshot of dialogs loaded in this root's in-memory dialog tree.
      */
-    getAllDialogs() {
+    getLoadedDialogTreeSnapshot() {
         return Array.from(this._localRegistry.values());
     }
     /**

package/dist/docs/daemon-cmd-runner.md

@@ -115,6 +115,8 @@ Ownership boundaries are simple:
 - `pid: number`
 - `stdout?: boolean`
 - `stderr?: boolean`
+- `wait_for_new_output?: boolean`
+- `timeout_ms?: number`
 
 ### Semantics
 
@@ -123,6 +125,9 @@ Ownership boundaries are simple:
 - output order is always `stdout` first, then `stderr`
 - each stream gets its own heading, content block, and scroll notice
 - unrequested streams are omitted entirely
+- when `wait_for_new_output=true`, the runner waits until at least one requested stream receives output after the request is accepted
+- if `timeout_ms` is provided, the wait is bounded by that many milliseconds, capped at `86400000` (24h), and returns the current snapshot with an explicit timeout notice
+- `timeout_ms` cannot be combined with `wait_for_new_output=false`; that contradictory argument set returns an error
 
 ### Why this is better
 

package/dist/docs/daemon-cmd-runner.zh.md

@@ -114,6 +114,8 @@ runner 自己作为进程组 leader，daemon 默认继承该 pgid。这样 `stop
   - `pid: number`
   - `stdout?: boolean`
   - `stderr?: boolean`
+  - `wait_for_new_output?: boolean`
+  - `timeout_ms?: number`
 
 ### 语义
 
@@ -122,6 +124,9 @@ runner 自己作为进程组 leader，daemon 默认继承该 pgid。这样 `stop
 - 返回顺序固定为 `stdout` 在前、`stderr` 在后
 - 每个流各自带自己的标题、内容、scroll notice
 - 未请求的流不展示
+- `wait_for_new_output=true` 时，runner 会等到请求的流中至少一个在请求被接受后出现新输出再返回
+- 提供 `timeout_ms` 时，等待最多持续指定毫秒数，上限为 `86400000`（24 小时）；超时后返回当前快照，并显式提示等待超时
+- `timeout_ms` 不可与 `wait_for_new_output=false` 同时使用；这种矛盾参数会直接报错
 
 ### 取舍理由
 

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

@@ -46,6 +46,7 @@ const KERNEL_DRIVER_DEFAULT_RETRY_POLICY = {
     backoffMultiplier: 1.5,
     maxDelayMs: 30 * 60 * 1000, // 30 minutes
 };
+const CLEAR_MIND_TOOL_NAME = 'clear_mind';
 const KERNEL_DRIVER_EMPTY_LLM_RESPONSE_ERROR_CODE = 'DOMINDS_LLM_EMPTY_RESPONSE';
 // Wrapper isolation boundary:
 // - Wrappers emit provider-native web-search events.
@@ -246,6 +247,35 @@ function buildKernelDriverFbrPrompt(dlg, state) {
         origin: 'runtime',
     };
 }
+function resolveLatestModelOutputGenseq(dlg) {
+    for (let index = dlg.msgs.length - 1; index >= 0; index -= 1) {
+        const msg = dlg.msgs[index];
+        if (msg === undefined) {
+            continue;
+        }
+        switch (msg.type) {
+            case 'saying_msg':
+            case 'thinking_msg':
+            case 'func_call_msg': {
+                const genseq = Math.floor(msg.genseq);
+                if (Number.isFinite(genseq) && genseq > 0) {
+                    return genseq;
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return undefined;
+}
+function resolveProgrammaticFbrConclusionGenseq(args) {
+    return (args.lastAssistantSayingGenseq ??
+        args.lastFunctionCallGenseq ??
+        resolveLatestModelOutputGenseq(args.dlg) ??
+        args.dlg.activeGenSeqOrUndefined ??
+        1);
+}
 function normalizeQ4HAnswerCallId(raw) {
     if (typeof raw !== 'string')
         return undefined;
@@ -750,7 +780,7 @@ function formatContextHealthLargeToolReturnUnavailable(args) {
                 '1. 把需要回传给主线对话的结论、证据定位和风险整理清楚。',
                 '2. 对于下一程恢复工作需要的信息，写入提醒项。',
                 '',
-                '然后尽快完成当前支线回复；如果你有 clear_mind({})，再调用它开启新一程。',
+                '然后调用 clear_mind({}) 开启新一程，并尽快完成当前支线回复。',
                 '',
                 `详情：本次返回约 ${approxBytes} 字节。`,
             ].join('\n');
@@ -775,7 +805,7 @@ function formatContextHealthLargeToolReturnUnavailable(args) {
             '1. Organize the conclusions, evidence pointers, and risks that need to go back to the Mainline dialog.',
             '2. Write any details needed to resume the next course into reminders.',
             '',
-            'Then finish the current Sideline dialog reply as soon as possible; if you have clear_mind({}), call it to start a new course.',
+            'Then call clear_mind({}) to start a new course, and finish the current Sideline dialog reply as soon as possible.',
             '',
             `Detail: this return was about ${approxBytes} bytes.`,
         ].join('\n');
@@ -814,6 +844,9 @@ function countToolResultVisibleBytes(output) {
     return bytes;
 }
 function applyContextHealthToolResultVisibilityLimit(args) {
+    if (isFbrSideDialog(args.dlg)) {
+        return { output: args.output, largeReturnUnavailable: false };
+    }
     if ((0, context_health_1.getContextHealthRemediationLevel)(args.contextHealth) === undefined) {
         return { output: args.output, largeReturnUnavailable: false };
     }
@@ -1961,6 +1994,30 @@ function shouldImmediatelyFollowUpToolOutcome(tool, outcome) {
     }
     return shouldImmediatelyFollowUpSuccessfulToolResult(tool);
 }
+function isFailedToolOutcome(outcome) {
+    return outcome === 'failure' || outcome === 'partial_failure';
+}
+function formatClearMindBlockedByFailedSiblingTools(failedTools) {
+    const language = (0, work_language_1.getWorkLanguage)();
+    const details = failedTools
+        .map((tool) => `- ${tool.toolName} (callId=${tool.callId}, outcome=${String(tool.outcome)})`)
+        .join('\n');
+    return language === 'zh'
+        ? [
+            '错误：本轮 clear_mind 与其它工具一起调用，但其它工具返回了失败结果。',
+            '',
+            details,
+            '',
+            'clear_mind 已拒绝开启新一程。请先确保其它工具调用正常完成（必要时修正参数、重试或处理失败），然后再次调用 clear_mind。',
+        ].join('\n')
+        : [
+            'Error: clear_mind was called in the same round as other tools, and at least one other tool returned a failure result.',
+            '',
+            details,
+            '',
+            'clear_mind refused to start a new course. Ensure the other tool calls complete normally first (fix arguments, retry, or handle the failure), then call clear_mind again.',
+        ].join('\n');
+}
 function trimOptionalCallId(value) {
     if (typeof value !== 'string')
         return undefined;
@@ -2133,7 +2190,7 @@ async function executeFunctionCalls(args) {
         throwIfAborted(args.abortSignal, args.dlg);
         await args.dlg.persistFunctionCall(prepared.func.id, prepared.func.name, prepared.argsStr, prepared.callGenseq, prepared.func.rawId);
     }
-    const functionPromises = preparedCalls.map(async ({ func, originalFunc, callGenseq, argsStr, tool, preparedInvocationArgs, }) => {
+    const executePreparedCall = async ({ func, originalFunc, callGenseq, argsStr, tool, preparedInvocationArgs, }) => {
         let result;
         let outcome = 'success';
         let forceImmediateFollowup = false;
@@ -2226,8 +2283,54 @@ async function executeFunctionCalls(args) {
             throw rethrowError;
         }
         return { func, originalFunc, outcome, forceImmediateFollowup, result };
-    });
-    return await Promise.all(functionPromises);
+    };
+    const blockClearMindCall = async (prepared, failedTools) => {
+        const output = (0, tool_1.toolFailure)(formatClearMindBlockedByFailedSiblingTools(failedTools));
+        const result = {
+            type: 'func_result_msg',
+            id: prepared.func.id,
+            rawId: prepared.func.rawId,
+            effectiveId: prepared.func.effectiveId,
+            name: prepared.func.name,
+            content: output.content,
+            role: 'tool',
+            genseq: prepared.callGenseq,
+        };
+        await args.dlg.receiveFuncResult(result);
+        return {
+            func: prepared.func,
+            originalFunc: prepared.originalFunc,
+            outcome: output.outcome,
+            forceImmediateFollowup: false,
+            result,
+        };
+    };
+    const clearMindCalls = preparedCalls.filter((call) => call.func.name === CLEAR_MIND_TOOL_NAME);
+    const siblingCalls = preparedCalls.filter((call) => call.func.name !== CLEAR_MIND_TOOL_NAME);
+    const failedPriorToolResults = args.failedPriorToolResults ?? [];
+    if (clearMindCalls.length === 0 || siblingCalls.length === 0) {
+        if (clearMindCalls.length > 0 && failedPriorToolResults.length > 0) {
+            return await Promise.all(clearMindCalls.map((call) => blockClearMindCall(call, failedPriorToolResults)));
+        }
+        return await Promise.all(preparedCalls.map((call) => executePreparedCall(call)));
+    }
+    const siblingExecutions = await Promise.all(siblingCalls.map((call) => executePreparedCall(call)));
+    const failedSiblingToolResults = [
+        ...failedPriorToolResults,
+        ...siblingExecutions
+            .filter((execution) => isFailedToolOutcome(execution.outcome))
+            .map((execution) => ({
+            callId: execution.result.id,
+            toolName: execution.result.name,
+            outcome: execution.outcome,
+        })),
+    ];
+    if (failedSiblingToolResults.length > 0) {
+        const clearMindExecutions = await Promise.all(clearMindCalls.map((call) => blockClearMindCall(call, failedSiblingToolResults)));
+        return [...siblingExecutions, ...clearMindExecutions];
+    }
+    const clearMindExecutions = await Promise.all(clearMindCalls.map((call) => executePreparedCall(call)));
+    return [...siblingExecutions, ...clearMindExecutions];
 }
 async function executeFunctionRound(args) {
     if (args.funcCalls.length === 0) {
@@ -2270,6 +2373,17 @@ async function executeFunctionRound(args) {
         activePromptReplyDirective: args.activePromptReplyDirective,
     });
     throwIfAborted(args.abortSignal, args.dlg);
+    const failedTellaskToolResults = tellaskRound.invalidTellaskCallIds.map((callId) => {
+        const call = args.funcCalls.find((candidate) => candidate.id === callId);
+        if (call === undefined) {
+            throw new Error(`kernel-driver tellask result invariant violation: missing invalid tellask call '${callId}'`);
+        }
+        return {
+            callId,
+            toolName: call.name,
+            outcome: 'failure',
+        };
+    });
     const genericExecutions = await executeFunctionCalls({
         dlg: args.dlg,
         agent: args.agent,
@@ -2277,6 +2391,7 @@ async function executeFunctionRound(args) {
         funcCalls: tellaskRound.normalCalls,
         abortSignal: args.abortSignal,
         contextHealthForToolResultVisibility: args.contextHealthForToolResultVisibility,
+        failedPriorToolResults: failedTellaskToolResults,
     });
     const genericExecutionByOriginalCall = new Map(genericExecutions.map((execution) => [execution.originalFunc, execution]));
     const funcToolByName = new Map(args.agentTools
@@ -2602,8 +2717,41 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
             for (;;) {
                 genIterNo += 1;
                 throwIfAborted(abortSignal, dlg);
-                const activeFbrState = await loadDialogFbrState(dlg);
+                let activeFbrState = await loadDialogFbrState(dlg);
                 if (isFbrSideDialog(dlg)) {
+                    const fbrContextHealthLevel = (0, context_health_1.getContextHealthRemediationLevel)(dlg.getLastContextHealth());
+                    if (activeFbrState !== undefined && fbrContextHealthLevel === 'critical') {
+                        log_1.log.warn('kernel-driver ending FBR with critical context fixed conclusion', undefined, {
+                            rootId: dlg.id.rootId,
+                            selfId: dlg.id.selfId,
+                            course: dlg.currentCourse,
+                            phase: activeFbrState.phase,
+                            iteration: activeFbrState.iteration,
+                        });
+                        fbrConclusion = {
+                            responseText: (0, fbr_1.buildProgrammaticFbrContextCriticalContent)({
+                                language: (0, work_language_1.getWorkLanguage)(),
+                            }),
+                            responseGenseq: resolveProgrammaticFbrConclusionGenseq({
+                                dlg,
+                                lastAssistantSayingGenseq,
+                                lastFunctionCallGenseq,
+                            }),
+                            replyResolutionCallId: `fbr-context-critical-${(0, id_1.generateShortId)()}`,
+                        };
+                        await persistDialogFbrState(dlg, undefined);
+                        dlg.setFbrConclusionToolsEnabled(false);
+                        finalDisplayState = await (0, dialog_display_state_1.computeIdleDisplayState)(dlg);
+                        break driveCoreLoop;
+                    }
+                    if (activeFbrState !== undefined &&
+                        fbrContextHealthLevel === 'caution' &&
+                        !(0, fbr_1.isFbrContextCautionFinalizationState)(activeFbrState) &&
+                        (pendingPrompt === undefined || pendingPrompt.origin === 'runtime')) {
+                        activeFbrState = (0, fbr_1.forceFbrContextCautionFinalizationState)(activeFbrState);
+                        await persistDialogFbrState(dlg, activeFbrState);
+                        pendingPrompt = buildKernelDriverFbrPrompt(dlg, activeFbrState);
+                    }
                     dlg.setFbrConclusionToolsEnabled(activeFbrState !== undefined && (0, fbr_1.isFbrFinalizationState)(activeFbrState));
                     if (pendingPrompt === undefined &&
                         activeFbrState &&
@@ -2786,7 +2934,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                 let currentRuntimeGuideMsg;
                 const currentPromptFromFbrState = currentPrompt !== undefined &&
                     currentFbrState !== undefined &&
-                    currentFbrState.promptDelivered !== true;
+                    currentFbrState.promptDelivered !== true &&
+                    isFbrSideDialog(dlg) &&
+                    currentPrompt.origin === 'runtime' &&
+                    currentPrompt.content === buildKernelDriverFbrPrompt(dlg, currentFbrState).content;
                 pendingPrompt = undefined;
                 if (currentPrompt) {
                     const diligenceSkipReason = await shouldSkipDiligencePromptBeforeGeneration({
@@ -3780,10 +3931,11 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 language: (0, work_language_1.getWorkLanguage)(),
                                 finalizationAttempts: persistedFbrState.effort,
                             }),
-                            responseGenseq: lastAssistantSayingGenseq ??
-                                lastFunctionCallGenseq ??
-                                dlg.activeGenSeqOrUndefined ??
-                                1,
+                            responseGenseq: resolveProgrammaticFbrConclusionGenseq({
+                                dlg,
+                                lastAssistantSayingGenseq,
+                                lastFunctionCallGenseq,
+                            }),
                             replyResolutionCallId: `fbr-conclusion-${(0, id_1.generateShortId)()}`,
                         };
                         if (!isFbrSideDialog(dlg)) {

package/dist/llm/kernel-driver/fbr.d.ts

@@ -32,6 +32,13 @@ export declare function buildFbrFinalizationPrompt(args: {
     total: number;
     language: LanguageCode;
 }): string;
+export declare function buildFbrContextCautionFinalizationPrompt(args: {
+    attempt: number;
+    language: LanguageCode;
+}): string;
+export declare function buildProgrammaticFbrContextCriticalContent(args: {
+    language: LanguageCode;
+}): string;
 export declare function buildProgrammaticFbrUnreasonableSituationContent(args: {
     language: LanguageCode;
     finalizationAttempts: number;
@@ -40,6 +47,8 @@ export declare function inspectFbrConclusionAttempt(messages: readonly ChatMessa
 export declare function createInitialFbrState(effort: number): DialogFbrState;
 export declare function markFbrPromptDelivered(state: DialogFbrState): DialogFbrState;
 export declare function isFbrFinalizationState(state: DialogFbrState): boolean;
+export declare function isFbrContextCautionFinalizationState(state: DialogFbrState): boolean;
+export declare function forceFbrContextCautionFinalizationState(state: DialogFbrState): DialogFbrState;
 export declare function advanceFbrState(state: DialogFbrState): DialogFbrState | undefined;
 export declare function buildFbrPromptForState(args: {
     state: DialogFbrState;