dominds 1.16.2 → 1.16.4

package/dist/llm/gen.d.ts

@@ -1,6 +1,6 @@
 import type { LlmUsageStats } from '@longrun-ai/kernel/types/context-health';
 import type { DialogDisplayTextI18n } from '@longrun-ai/kernel/types/display-state';
-import type { ReasoningPayload } from '@longrun-ai/kernel/types/storage';
+import type { ReasoningPayload, ToolResultImageArtifact, ToolResultImageDisposition } from '@longrun-ai/kernel/types/storage';
 import { Team } from '../team';
 import { FuncTool } from '../tool';
 import { ChatMessage, ProviderConfig } from './client';
@@ -26,6 +26,9 @@ export type LlmBatchOutput = {
 } | {
     kind: 'native_tool_call';
     call: OpenAiResponsesNativeToolCall;
+} | {
+    kind: 'tool_result_image_ingest';
+    ingest: ToolResultImageIngest;
 };
 export interface LlmBatchResult {
     messages: ChatMessage[];
@@ -46,8 +49,20 @@ export type LlmFailureClassifier = (error: unknown) => LlmFailureDisposition | u
 export interface LlmRequestContext {
     dialogSelfId: string;
     dialogRootId: string;
+    providerKey?: string;
+    modelKey?: string;
     promptCacheKey?: string;
 }
+export type ToolResultImageIngest = {
+    toolCallId: string;
+    toolName: string;
+    artifact: ToolResultImageArtifact;
+    provider: string;
+    model: string;
+    disposition: ToolResultImageDisposition;
+    message: string;
+    detail?: string;
+};
 export type CodexLlmWebSearchAction = {
     type: 'search';
     query?: string;
@@ -120,6 +135,7 @@ export interface LlmStreamReceiver {
     funcCall: (callId: string, name: string, args: string) => Promise<void>;
     webSearchCall?: (call: LlmWebSearchCall) => Promise<void>;
     nativeToolCall?: (call: OpenAiResponsesNativeToolCall) => Promise<void>;
+    toolResultImageIngest?: (ingest: ToolResultImageIngest) => Promise<void>;
     streamError?: (detail: string) => Promise<void>;
 }
 export interface LlmGenerator {

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

@@ -235,6 +235,9 @@ function resolveKernelDriverRetryPolicy(providerCfg) {
 function hasMeaningfulBatchOutput(batch) {
     if (Array.isArray(batch.outputs) && batch.outputs.length > 0) {
         for (const output of batch.outputs) {
+            if (output.kind === 'tool_result_image_ingest') {
+                continue;
+            }
             if (output.kind !== 'message') {
                 return true;
             }
@@ -1602,6 +1605,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                     const batchResult = await llmGen.genMoreMessages(providerCfg, agent, systemPrompt, funcTools, {
                                         dialogSelfId: dlg.id.selfId,
                                         dialogRootId: dlg.id.rootId,
+                                        providerKey: provider,
+                                        modelKey: model,
                                         promptCacheKey: `${dlg.id.selfId}:c${String(dlg.currentCourse)}`,
                                     }, ctxMsgs, dlg.activeGenSeq, abortSignal);
                                     if (!hasMeaningfulBatchOutput(batchResult)) {
@@ -1776,6 +1781,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 sawNativeToolSideChannelOutput = true;
                                 await dlg.nativeToolCall(call);
                             },
+                            toolResultImageIngest: async (ingest) => {
+                                throwIfAborted(abortSignal, dlg);
+                                await dlg.toolResultImageIngest(ingest);
+                            },
                         };
                         const res = await (0, runtime_1.runLlmRequestWithRetry)({
                             dlg,
@@ -1810,6 +1819,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 const streamResult = await llmGen.genToReceiver(providerCfg, agent, systemPrompt, funcTools, {
                                     dialogSelfId: dlg.id.selfId,
                                     dialogRootId: dlg.id.rootId,
+                                    providerKey: provider,
+                                    modelKey: model,
                                     promptCacheKey: `${dlg.id.selfId}:c${String(dlg.currentCourse)}`,
                                 }, ctxMsgs, receiver, dlg.activeGenSeq, abortSignal);
                                 const hasThinkingContent = currentThinkingContent.trim() !== '';
@@ -1884,6 +1895,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 await dlg.nativeToolCall(output.call);
                                 break;
                             }
+                            case 'tool_result_image_ingest': {
+                                await dlg.toolResultImageIngest(output.ingest);
+                                break;
+                            }
                             default: {
                                 const _exhaustive = output;
                                 throw new Error(`Unhandled batch output kind: ${String(_exhaustive)}`);

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

@@ -74,6 +74,38 @@ async function loadPendingDiagnosticsSnapshot(args) {
         };
     }
 }
+async function clearConsumedDeferredRootQueueIfIdle(dialog) {
+    if (dialog.id.selfId !== dialog.id.rootId) {
+        return;
+    }
+    if (!dialog_global_registry_1.globalDialogRegistry.get(dialog.id.rootId)) {
+        return;
+    }
+    const suspension = await dialog.getSuspensionStatus();
+    if (dialog.hasUpNext() || !suspension.canDrive) {
+        return;
+    }
+    const persistedNeedsDrive = await persistence_1.DialogPersistence.getNeedsDrive(dialog.id);
+    const registryNeedsDrive = dialog_global_registry_1.globalDialogRegistry.isMarkedNeedingDrive(dialog.id.rootId);
+    if (!registryNeedsDrive && !persistedNeedsDrive) {
+        return;
+    }
+    try {
+        await persistence_1.DialogPersistence.setNeedsDrive(dialog.id, false, dialog.status);
+    }
+    catch (error) {
+        log_1.log.error('kernel-driver failed to persist consumed deferred root queue cleanup', error, {
+            dialogId: dialog.id.valueOf(),
+            rootId: dialog.id.rootId,
+            selfId: dialog.id.selfId,
+        });
+        return;
+    }
+    dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(dialog.id.rootId, {
+        source: 'kernel_driver_flow_tail',
+        reason: 'root_idle_after_consuming_deferred_queue',
+    });
+}
 function hasNoPromptSubdialogResumeEntitlement(dialog, driveOptions) {
     const entitlement = driveOptions?.noPromptSubdialogResumeEntitlement;
     if (!entitlement) {
@@ -490,203 +522,224 @@ async function executeDriveRound(args) {
         if (!interruptedBySignal) {
             followUp = dialog.takeUpNext();
         }
-    }
-    finally {
-        if (activeRunPrimed && ownsActiveRun) {
-            (0, dialog_display_state_1.clearActiveRun)(dialog.id);
-        }
-        release();
-    }
-    if (dialog instanceof dialog_1.SubDialog &&
-        driveResult &&
-        !interruptedBySignal &&
-        (driveResult.fbrConclusion !== undefined || driveResult.lastAssistantSayingContent !== null)) {
-        if (driveResult.fbrConclusion) {
-            await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
-                subdialog: dialog,
-                responseText: driveResult.fbrConclusion.responseText,
-                responseGenseq: driveResult.fbrConclusion.responseGenseq,
-                scheduleDrive: args.scheduleDrive,
-            });
-        }
-        else if (driveResult.lastAssistantSayingContent !== null) {
-            const hasInProgressFunctionCall = typeof driveResult.lastFunctionCallGenseq === 'number' &&
-                Number.isFinite(driveResult.lastFunctionCallGenseq) &&
-                driveResult.lastFunctionCallGenseq > 0 &&
-                (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
-                    !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
-                    driveResult.lastAssistantSayingGenseq <= driveResult.lastFunctionCallGenseq);
-            if (hasInProgressFunctionCall) {
-                // Any function call means execution is still in-progress. Only supply when the callee
-                // has produced a newer assistant saying after the latest function call.
-                log_1.log.debug('kernel-driver skip subdialog response supply because latest saying is not after function calls', undefined, {
-                    rootId: dialog.id.rootId,
-                    selfId: dialog.id.selfId,
-                    lastAssistantSayingGenseq: driveResult.lastAssistantSayingGenseq,
-                    lastFunctionCallGenseq: driveResult.lastFunctionCallGenseq,
-                });
-            }
-            else {
-                const hasFollowUp = followUp !== undefined;
-                const suspension = await dialog.getSuspensionStatus();
-                if (!suspension.canDrive || hasFollowUp) {
-                    log_1.log.debug('kernel-driver skip subdialog response supply while callee is not finalized', undefined, {
-                        rootId: dialog.id.rootId,
-                        selfId: dialog.id.selfId,
-                        waitingQ4H: suspension.q4h,
-                        waitingSubdialogs: suspension.subdialogs,
-                        hasFollowUp,
+        let tailError;
+        try {
+            if (dialog instanceof dialog_1.SubDialog &&
+                driveResult &&
+                !interruptedBySignal &&
+                (driveResult.fbrConclusion !== undefined || driveResult.lastAssistantSayingContent !== null)) {
+                if (driveResult.fbrConclusion) {
+                    await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
+                        subdialog: dialog,
+                        responseText: driveResult.fbrConclusion.responseText,
+                        responseGenseq: driveResult.fbrConclusion.responseGenseq,
+                        scheduleDrive: args.scheduleDrive,
                     });
                 }
-                if (suspension.canDrive && !hasFollowUp) {
-                    if (!activeTellaskReplyDirective) {
-                        log_1.log.debug('kernel-driver skip implicit subdialog reply because no active tellask reply directive is bound to this drive', undefined, {
+                else if (driveResult.lastAssistantSayingContent !== null) {
+                    const hasInProgressFunctionCall = typeof driveResult.lastFunctionCallGenseq === 'number' &&
+                        Number.isFinite(driveResult.lastFunctionCallGenseq) &&
+                        driveResult.lastFunctionCallGenseq > 0 &&
+                        (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
+                            !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
+                            driveResult.lastAssistantSayingGenseq <= driveResult.lastFunctionCallGenseq);
+                    if (hasInProgressFunctionCall) {
+                        // Any function call means execution is still in-progress. Only supply when the callee
+                        // has produced a newer assistant saying after the latest function call.
+                        log_1.log.debug('kernel-driver skip subdialog response supply because latest saying is not after function calls', undefined, {
                             rootId: dialog.id.rootId,
                             selfId: dialog.id.selfId,
+                            lastAssistantSayingGenseq: driveResult.lastAssistantSayingGenseq,
+                            lastFunctionCallGenseq: driveResult.lastFunctionCallGenseq,
                         });
                     }
                     else {
-                        if (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
-                            !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
-                            driveResult.lastAssistantSayingGenseq <= 0) {
-                            throw new Error(`Subdialog response supply invariant violation: missing lastAssistantSayingGenseq for dialog=${dialog.id.valueOf()}`);
-                        }
-                        const responseGenseq = Math.floor(driveResult.lastAssistantSayingGenseq);
-                        const directFallbackCallId = `direct-fallback-${(0, id_1.generateShortId)()}`;
-                        let supplied = false;
-                        if (subdialogReplyTarget) {
-                            supplied = await (0, subdialog_1.supplySubdialogResponseToSpecificCallerIfPendingV2)({
-                                subdialog: dialog,
-                                responseText: driveResult.lastAssistantSayingContent,
-                                responseGenseq,
-                                target: subdialogReplyTarget,
-                                deliveryMode: 'direct_fallback',
-                                replyResolution: {
-                                    callId: directFallbackCallId,
-                                    replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
-                                },
-                                scheduleDrive: args.scheduleDrive,
+                        const hasFollowUp = followUp !== undefined;
+                        const suspension = await dialog.getSuspensionStatus();
+                        if (!suspension.canDrive || hasFollowUp) {
+                            log_1.log.debug('kernel-driver skip subdialog response supply while callee is not finalized', undefined, {
+                                rootId: dialog.id.rootId,
+                                selfId: dialog.id.selfId,
+                                waitingQ4H: suspension.q4h,
+                                waitingSubdialogs: suspension.subdialogs,
+                                hasFollowUp,
                             });
-                            if (!supplied) {
-                                supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
-                                    subdialog: dialog,
-                                    responseText: driveResult.lastAssistantSayingContent,
-                                    responseGenseq,
-                                    deliveryMode: 'direct_fallback',
-                                    replyResolution: {
-                                        callId: directFallbackCallId,
-                                        replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
-                                    },
-                                    scheduleDrive: args.scheduleDrive,
+                        }
+                        if (suspension.canDrive && !hasFollowUp) {
+                            if (!activeTellaskReplyDirective) {
+                                log_1.log.debug('kernel-driver skip implicit subdialog reply because no active tellask reply directive is bound to this drive', undefined, {
+                                    rootId: dialog.id.rootId,
+                                    selfId: dialog.id.selfId,
                                 });
                             }
-                        }
-                        else {
-                            supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
-                                subdialog: dialog,
-                                responseText: driveResult.lastAssistantSayingContent,
-                                responseGenseq,
-                                deliveryMode: 'direct_fallback',
-                                replyResolution: {
-                                    callId: directFallbackCallId,
-                                    replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
-                                },
-                                scheduleDrive: args.scheduleDrive,
-                            });
-                        }
-                        if (!supplied && subdialogReplyTarget) {
-                            const diagnostics = await loadPendingDiagnosticsSnapshot({
-                                rootId: dialog.id.rootId,
-                                ownerDialogId: subdialogReplyTarget.ownerDialogId,
-                                expectedSubdialogId: dialog.id.selfId,
-                                status: dialog.status,
-                            });
-                            log_1.log.debug('kernel-driver failed to supply subdialog response to specific caller', undefined, {
-                                calleeId: dialog.id.valueOf(),
-                                targetOwner: subdialogReplyTarget.ownerDialogId,
-                                targetOwnerDialogId: subdialogReplyTarget.ownerDialogId,
-                                targetCallType: subdialogReplyTarget.callType,
-                                targetCallId: subdialogReplyTarget.callId,
-                                diagnostics,
-                            });
+                            else {
+                                if (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
+                                    !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
+                                    driveResult.lastAssistantSayingGenseq <= 0) {
+                                    throw new Error(`Subdialog response supply invariant violation: missing lastAssistantSayingGenseq for dialog=${dialog.id.valueOf()}`);
+                                }
+                                const responseGenseq = Math.floor(driveResult.lastAssistantSayingGenseq);
+                                const directFallbackCallId = `direct-fallback-${(0, id_1.generateShortId)()}`;
+                                let supplied = false;
+                                if (subdialogReplyTarget) {
+                                    supplied = await (0, subdialog_1.supplySubdialogResponseToSpecificCallerIfPendingV2)({
+                                        subdialog: dialog,
+                                        responseText: driveResult.lastAssistantSayingContent,
+                                        responseGenseq,
+                                        target: subdialogReplyTarget,
+                                        deliveryMode: 'direct_fallback',
+                                        replyResolution: {
+                                            callId: directFallbackCallId,
+                                            replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
+                                        },
+                                        scheduleDrive: args.scheduleDrive,
+                                    });
+                                    if (!supplied) {
+                                        supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
+                                            subdialog: dialog,
+                                            responseText: driveResult.lastAssistantSayingContent,
+                                            responseGenseq,
+                                            deliveryMode: 'direct_fallback',
+                                            replyResolution: {
+                                                callId: directFallbackCallId,
+                                                replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
+                                            },
+                                            scheduleDrive: args.scheduleDrive,
+                                        });
+                                    }
+                                }
+                                else {
+                                    supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
+                                        subdialog: dialog,
+                                        responseText: driveResult.lastAssistantSayingContent,
+                                        responseGenseq,
+                                        deliveryMode: 'direct_fallback',
+                                        replyResolution: {
+                                            callId: directFallbackCallId,
+                                            replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
+                                        },
+                                        scheduleDrive: args.scheduleDrive,
+                                    });
+                                }
+                                if (!supplied && subdialogReplyTarget) {
+                                    const diagnostics = await loadPendingDiagnosticsSnapshot({
+                                        rootId: dialog.id.rootId,
+                                        ownerDialogId: subdialogReplyTarget.ownerDialogId,
+                                        expectedSubdialogId: dialog.id.selfId,
+                                        status: dialog.status,
+                                    });
+                                    log_1.log.debug('kernel-driver failed to supply subdialog response to specific caller', undefined, {
+                                        calleeId: dialog.id.valueOf(),
+                                        targetOwner: subdialogReplyTarget.ownerDialogId,
+                                        targetOwnerDialogId: subdialogReplyTarget.ownerDialogId,
+                                        targetCallType: subdialogReplyTarget.callType,
+                                        targetCallId: subdialogReplyTarget.callId,
+                                        diagnostics,
+                                    });
+                                }
+                            }
                         }
                     }
                 }
             }
-        }
-    }
-    if (!(dialog instanceof dialog_1.SubDialog) &&
-        driveResult &&
-        !interruptedBySignal &&
-        driveResult.lastAssistantSayingContent !== null &&
-        activeTellaskReplyDirective?.expectedReplyCallName === 'replyTellaskBack' &&
-        followUp === undefined) {
-        const hasInProgressFunctionCall = typeof driveResult.lastFunctionCallGenseq === 'number' &&
-            Number.isFinite(driveResult.lastFunctionCallGenseq) &&
-            driveResult.lastFunctionCallGenseq > 0 &&
-            (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
-                !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
-                driveResult.lastAssistantSayingGenseq <= driveResult.lastFunctionCallGenseq);
-        if (!hasInProgressFunctionCall) {
-            if (!activePromptWasReplyToolReminder) {
-                const language = (0, work_language_1.getWorkLanguage)();
-                followUp = {
-                    prompt: await buildReplyToolReminderPrompt({
-                        dlg: dialog,
-                        directive: activeTellaskReplyDirective,
-                        language,
-                    }),
-                    msgId: (0, id_1.generateShortId)(),
-                    grammar: 'markdown',
-                    origin: 'runtime',
-                    userLanguageCode: language,
-                    tellaskReplyDirective: activeTellaskReplyDirective,
-                };
-                log_1.log.debug('kernel-driver queued replyTellaskBack reminder prompt after plain reply', undefined, {
-                    dialogId: dialog.id.valueOf(),
-                    targetCallId: activeTellaskReplyDirective.targetCallId,
-                });
+            if (!(dialog instanceof dialog_1.SubDialog) &&
+                driveResult &&
+                !interruptedBySignal &&
+                driveResult.lastAssistantSayingContent !== null &&
+                activeTellaskReplyDirective?.expectedReplyCallName === 'replyTellaskBack' &&
+                followUp === undefined) {
+                const hasInProgressFunctionCall = typeof driveResult.lastFunctionCallGenseq === 'number' &&
+                    Number.isFinite(driveResult.lastFunctionCallGenseq) &&
+                    driveResult.lastFunctionCallGenseq > 0 &&
+                    (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
+                        !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
+                        driveResult.lastAssistantSayingGenseq <= driveResult.lastFunctionCallGenseq);
+                if (!hasInProgressFunctionCall) {
+                    if (!activePromptWasReplyToolReminder) {
+                        const language = (0, work_language_1.getWorkLanguage)();
+                        followUp = {
+                            prompt: await buildReplyToolReminderPrompt({
+                                dlg: dialog,
+                                directive: activeTellaskReplyDirective,
+                                language,
+                            }),
+                            msgId: (0, id_1.generateShortId)(),
+                            grammar: 'markdown',
+                            origin: 'runtime',
+                            userLanguageCode: language,
+                            tellaskReplyDirective: activeTellaskReplyDirective,
+                        };
+                        log_1.log.debug('kernel-driver queued replyTellaskBack reminder prompt after plain reply', undefined, {
+                            dialogId: dialog.id.valueOf(),
+                            targetCallId: activeTellaskReplyDirective.targetCallId,
+                        });
+                    }
+                    else {
+                        await (0, tellask_special_1.deliverTellaskBackReplyFromDirective)({
+                            dlg: dialog,
+                            directive: activeTellaskReplyDirective,
+                            replyContent: driveResult.lastAssistantSayingContent,
+                            callbacks: {
+                                scheduleDrive: args.scheduleDrive,
+                                driveDialog: args.driveDialog,
+                            },
+                            deliveryMode: 'direct_fallback',
+                        });
+                        await dialog.appendTellaskReplyResolution({
+                            callId: `direct-fallback-${(0, id_1.generateShortId)()}`,
+                            replyCallName: 'replyTellaskBack',
+                            targetCallId: activeTellaskReplyDirective.targetCallId,
+                        });
+                    }
+                }
             }
-            else {
-                await (0, tellask_special_1.deliverTellaskBackReplyFromDirective)({
-                    dlg: dialog,
-                    directive: activeTellaskReplyDirective,
-                    replyContent: driveResult.lastAssistantSayingContent,
-                    callbacks: {
-                        scheduleDrive: args.scheduleDrive,
-                        driveDialog: args.driveDialog,
+            if (followUp) {
+                args.scheduleDrive(dialog, {
+                    waitInQue: true,
+                    driveOptions: {
+                        source: 'kernel_driver_follow_up',
+                        reason: 'follow_up_prompt',
+                    },
+                    humanPrompt: {
+                        content: followUp.prompt,
+                        msgId: followUp.msgId,
+                        grammar: followUp.grammar ?? 'markdown',
+                        origin: followUp.origin,
+                        userLanguageCode: followUp.userLanguageCode === 'zh' || followUp.userLanguageCode === 'en'
+                            ? followUp.userLanguageCode
+                            : undefined,
+                        q4hAnswerCallId: followUp.q4hAnswerCallId,
+                        tellaskReplyDirective: followUp.tellaskReplyDirective,
+                        skipTaskdoc: followUp.skipTaskdoc,
+                        subdialogReplyTarget: followUp.subdialogReplyTarget,
+                        runControl: followUp.runControl,
                     },
-                    deliveryMode: 'direct_fallback',
                 });
-                await dialog.appendTellaskReplyResolution({
-                    callId: `direct-fallback-${(0, id_1.generateShortId)()}`,
-                    replyCallName: 'replyTellaskBack',
-                    targetCallId: activeTellaskReplyDirective.targetCallId,
+            }
+        }
+        catch (error) {
+            tailError = error;
+        }
+        if (tailError === undefined) {
+            try {
+                await clearConsumedDeferredRootQueueIfIdle(dialog);
+            }
+            catch (error) {
+                log_1.log.error('kernel-driver failed to reconcile consumed deferred root queue after tail', error, {
+                    dialogId: dialog.id.valueOf(),
+                    rootId: dialog.id.rootId,
+                    selfId: dialog.id.selfId,
                 });
             }
         }
+        if (tailError !== undefined) {
+            throw tailError;
+        }
     }
-    if (followUp) {
-        args.scheduleDrive(dialog, {
-            waitInQue: true,
-            driveOptions: {
-                source: 'kernel_driver_follow_up',
-                reason: 'follow_up_prompt',
-            },
-            humanPrompt: {
-                content: followUp.prompt,
-                msgId: followUp.msgId,
-                grammar: followUp.grammar ?? 'markdown',
-                origin: followUp.origin,
-                userLanguageCode: followUp.userLanguageCode === 'zh' || followUp.userLanguageCode === 'en'
-                    ? followUp.userLanguageCode
-                    : undefined,
-                q4hAnswerCallId: followUp.q4hAnswerCallId,
-                tellaskReplyDirective: followUp.tellaskReplyDirective,
-                skipTaskdoc: followUp.skipTaskdoc,
-                subdialogReplyTarget: followUp.subdialogReplyTarget,
-                runControl: followUp.runControl,
-            },
-        });
+    finally {
+        if (activeRunPrimed && ownsActiveRun) {
+            (0, dialog_display_state_1.clearActiveRun)(dialog.id);
+        }
+        release();
     }
 }

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

@@ -36,6 +36,11 @@ async function driveQueuedDialogsOnce() {
                 continue;
             }
             if ((0, dialog_display_state_1.hasActiveRun)(rootDialog.id)) {
+                log_1.log.debug('Backend driver deferred queued root drive because dialog already has an active run', undefined, {
+                    dialogId: rootDialog.id.valueOf(),
+                    rootId: rootDialog.id.rootId,
+                });
+                dialog_global_registry_1.globalDialogRegistry.noteActiveRunBlockedQueuedDrive(rootDialog.id.rootId);
                 continue;
             }
             if (!(await rootDialog.canDrive())) {

package/dist/persistence.d.ts

@@ -13,6 +13,7 @@ import { WebSocket } from 'ws';
 import type { PendingSubdialog } from './dialog';
 import { Dialog, DialogID, DialogStore, RootDialog, SubDialog } from './dialog';
 import { ChatMessage, FuncResultMsg, TellaskCarryoverMsg, TellaskResultMsg } from './llm/client';
+import type { ToolResultImageIngest } from './llm/gen';
 import { Reminder } from './tool';
 export declare function setDialogsQuarantinedBroadcaster(fn: ((msg: DialogsQuarantinedMessage) => void) | null): void;
 export declare function setPrepareDialogQuarantineHook(fn: ((args: {
@@ -114,6 +115,7 @@ export declare class DiskFileDialogStore extends DialogStore {
         action?: WebSearchCallAction;
     }): Promise<void>;
     nativeToolCall(dialog: Dialog, payload: NativeToolCallPayload): Promise<void>;
+    toolResultImageIngest(dialog: Dialog, payload: ToolResultImageIngest): Promise<void>;
     /**
      * Emit stream error for current generation lifecycle (uses active genseq when present)
      */