dominds 1.25.6 → 1.25.8

package/dist/dialog-display-state.js

@@ -97,12 +97,29 @@ function isNonIdleDisplayProjection(state) {
 function hasPendingNextStepTriggers(latest) {
     return (latest?.nextStep.triggers.length ?? 0) > 0;
 }
-function q4hSuspensionDisplayState(hasQ4H) {
+function waitingHumanInputDisplayState(hasQ4H) {
     if (hasQ4H) {
         return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
     }
     return undefined;
 }
+async function waitingSideDialogDisplayState(dialogId, status, activeReplyObligation) {
+    if (status !== 'running' || activeReplyObligation === undefined) {
+        return undefined;
+    }
+    const activeCallees = await persistence_1.DialogPersistence.loadActiveCallees(dialogId, status);
+    const hasPendingSideDialog = activeCallees.batches.some((batch) => batch.callees.some((callee) => callee.status === 'pending'));
+    if (!hasPendingSideDialog) {
+        return undefined;
+    }
+    return { kind: 'waiting_side_dialog' };
+}
+function pendingReplyObligationDisplayState(activeReplyObligation) {
+    if (activeReplyObligation === undefined) {
+        return undefined;
+    }
+    return { kind: 'proceeding' };
+}
 async function resolveSideDialogFinalResponseClosure(args) {
     if (!args.latest) {
         return { kind: 'no_final_response' };
@@ -111,26 +128,50 @@ async function resolveSideDialogFinalResponseClosure(args) {
     if (!finalResponseAnchor) {
         return { kind: 'no_final_response' };
     }
+    const finalResponseCallId = finalResponseAnchor.callId.trim();
     const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(args.dialogId, 'running');
     if (activeReplyObligation === undefined) {
         return {
             kind: 'closed_without_active_reply_obligation',
-            callId: finalResponseAnchor.callId,
+            callId: finalResponseCallId,
         };
     }
-    if (activeReplyObligation.targetCallId === finalResponseAnchor.callId) {
+    if (activeReplyObligation.targetCallId.trim() === finalResponseCallId) {
         return {
             kind: 'closed_with_matching_reply_obligation',
-            callId: finalResponseAnchor.callId,
+            callId: finalResponseCallId,
             activeReplyObligation,
         };
     }
     return {
         kind: 'blocked_by_different_reply_obligation',
-        callId: finalResponseAnchor.callId,
+        callId: finalResponseCallId,
         activeReplyObligation,
     };
 }
+async function clearMatchingFinalResponseReplyObligation(dialogId, closure) {
+    if (closure.kind !== 'closed_with_matching_reply_obligation') {
+        return false;
+    }
+    await persistence_1.DialogPersistence.setActiveTellaskReplyObligation(dialogId, undefined, 'running');
+    return true;
+}
+async function settleFinalResponseClosureForIdleProjection(dialogId, closure) {
+    switch (closure.kind) {
+        case 'no_final_response':
+        case 'blocked_by_different_reply_obligation':
+            return false;
+        case 'closed_without_active_reply_obligation':
+            return true;
+        case 'closed_with_matching_reply_obligation':
+            await clearMatchingFinalResponseReplyObligation(dialogId, closure);
+            return true;
+        default: {
+            const _exhaustive = closure;
+            throw new Error(`Unhandled final response closure kind: ${String(_exhaustive)}`);
+        }
+    }
+}
 function classifyRunControlBucket(state) {
     if (!state)
         return 'none';
@@ -181,7 +222,7 @@ async function getRunControlCountsSnapshot() {
             else if (latest?.executionMarker?.kind === 'interrupted' &&
                 isStoppedReasonResumable(latest.executionMarker.reason)) {
                 // Keep run-control counts aligned with actual Continue affordance:
-                // - ordinary interrupted dialogs count as resumable only when no Q4H suspension remains
+                // - ordinary interrupted dialogs count as resumable only when no Q4H human-input wait remains
                 // - legacy interjection-paused dialogs still count as resumable even if Q4H remains,
                 //   because Continue only re-evaluates the original task from fresh facts
                 if ((0, interjection_pause_stop_1.isUserInterjectionPauseStopReason)(latest.executionMarker.reason)) {
@@ -372,6 +413,7 @@ async function setDialogDisplayState(dialogId, displayState, status = 'running')
         });
         return;
     }
+    let nextDisplayState = displayState;
     let previousDisplayState;
     let previousExecutionMarker;
     // "dead" is irreversible. Once a dialog is marked dead, do not allow overwriting it with
@@ -397,24 +439,82 @@ async function setDialogDisplayState(dialogId, displayState, status = 'running')
             }
             return;
         }
+        if (status === 'running' && displayState.kind === 'idle_waiting_user') {
+            const waitingHumanInput = waitingHumanInputDisplayState(latest?.userWait?.kind === 'awaiting_user_answer');
+            if (waitingHumanInput) {
+                nextDisplayState = waitingHumanInput;
+                log.warn('Redirecting idle displayState to waiting-human-input state', undefined, {
+                    dialogId: dialogId.valueOf(),
+                    rootId: dialogId.rootId,
+                    selfId: dialogId.selfId,
+                    status,
+                    nextDisplayState,
+                    previousDisplayState: latest?.displayState ?? null,
+                    previousExecutionMarker: latest?.executionMarker ?? null,
+                });
+            }
+            else if (!(await settleFinalResponseClosureForIdleProjection(dialogId, await resolveSideDialogFinalResponseClosure({
+                dialogId,
+                latest,
+            })))) {
+                const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dialogId, status);
+                const waitingSideDialog = await waitingSideDialogDisplayState(dialogId, status, activeReplyObligation);
+                if (waitingSideDialog) {
+                    nextDisplayState = waitingSideDialog;
+                    log.warn('Redirecting idle displayState to waiting-side-dialog state', undefined, {
+                        dialogId: dialogId.valueOf(),
+                        rootId: dialogId.rootId,
+                        selfId: dialogId.selfId,
+                        status,
+                        nextDisplayState,
+                        targetCallId: activeReplyObligation?.targetCallId ?? null,
+                        targetDialogId: activeReplyObligation?.targetDialogId.valueOf() ?? null,
+                        previousDisplayState: latest?.displayState ?? null,
+                        previousExecutionMarker: latest?.executionMarker ?? null,
+                    });
+                }
+                else {
+                    const pendingReplyObligation = pendingReplyObligationDisplayState(activeReplyObligation);
+                    if (pendingReplyObligation) {
+                        nextDisplayState = pendingReplyObligation;
+                        log.warn('Redirecting idle displayState to active reply obligation state', undefined, {
+                            dialogId: dialogId.valueOf(),
+                            rootId: dialogId.rootId,
+                            selfId: dialogId.selfId,
+                            status,
+                            nextDisplayState,
+                            targetCallId: activeReplyObligation?.targetCallId ?? null,
+                            targetDialogId: activeReplyObligation?.targetDialogId.valueOf() ?? null,
+                            previousDisplayState: latest?.displayState ?? null,
+                            previousExecutionMarker: latest?.executionMarker ?? null,
+                            sideDialogFinalResponseCallId: latest?.sideDialogFinalResponse?.callId ?? null,
+                        });
+                    }
+                }
+            }
+        }
     }
     catch (err) {
         log.warn('Failed to check existing displayState before setDialogDisplayState', err, {
             dialogId: dialogId.valueOf(),
             status,
+            intendedDisplayState: displayState,
         });
+        if (status === 'running' && displayState.kind === 'idle_waiting_user') {
+            return;
+        }
     }
-    const nextExecutionMarker = displayState.kind === 'stopped'
-        ? { kind: 'interrupted', reason: displayState.reason }
-        : displayState.kind === 'dead'
-            ? { kind: 'dead', reason: displayState.reason }
+    const nextExecutionMarker = nextDisplayState.kind === 'stopped'
+        ? { kind: 'interrupted', reason: nextDisplayState.reason }
+        : nextDisplayState.kind === 'dead'
+            ? { kind: 'dead', reason: nextDisplayState.reason }
             : previousExecutionMarker?.kind === 'interrupted'
                 ? undefined
                 : previousExecutionMarker;
     try {
         await persistence_1.DialogPersistence.mutateDialogLatest(dialogId, () => ({
             kind: 'patch',
-            patch: { displayState, executionMarker: nextExecutionMarker },
+            patch: { displayState: nextDisplayState, executionMarker: nextExecutionMarker },
         }), status);
     }
     catch (err) {
@@ -424,16 +524,17 @@ async function setDialogDisplayState(dialogId, displayState, status = 'running')
             selfId: dialogId.selfId,
             status,
             intendedDisplayState: displayState,
+            persistedDisplayState: nextDisplayState,
         });
     }
     const typed = evt_registry_1.dialogEventRegistry.createTypedEvent(dialogId, {
         type: 'dlg_display_state_evt',
-        displayState,
+        displayState: nextDisplayState,
     });
     if (broadcastToClients) {
         broadcastToClients(typed);
     }
-    if (shouldBroadcastRunControlCounts(previousDisplayState, displayState)) {
+    if (shouldBroadcastRunControlCounts(previousDisplayState, nextDisplayState)) {
         try {
             await broadcastRunControlCountsSnapshot();
         }
@@ -479,18 +580,26 @@ async function computeIdleDisplayState(dlg) {
             continueEnabled: true,
         };
     }
-    const q4hSuspension = q4hSuspensionDisplayState(latest?.userWait?.kind === 'awaiting_user_answer');
-    if (q4hSuspension) {
-        return q4hSuspension;
+    const waitingHumanInput = waitingHumanInputDisplayState(latest?.userWait?.kind === 'awaiting_user_answer');
+    if (waitingHumanInput) {
+        return waitingHumanInput;
     }
     const finalResponseClosure = await resolveSideDialogFinalResponseClosure({
         dialogId: dlg.id,
         latest,
     });
-    if (finalResponseClosure.kind === 'closed_without_active_reply_obligation' ||
-        finalResponseClosure.kind === 'closed_with_matching_reply_obligation') {
+    if (await settleFinalResponseClosureForIdleProjection(dlg.id, finalResponseClosure)) {
         return { kind: 'idle_waiting_user' };
     }
+    const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dlg.id, dlg.status);
+    const waitingSideDialog = await waitingSideDialogDisplayState(dlg.id, dlg.status, activeReplyObligation);
+    if (waitingSideDialog) {
+        return waitingSideDialog;
+    }
+    const pendingReplyObligation = pendingReplyObligationDisplayState(activeReplyObligation);
+    if (pendingReplyObligation) {
+        return pendingReplyObligation;
+    }
     return { kind: 'idle_waiting_user' };
 }
 async function computeIdleDisplayStateFromPersistence(dialogId) {
@@ -520,15 +629,23 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
             continueEnabled: true,
         };
     }
-    const q4hSuspension = q4hSuspensionDisplayState(latest?.userWait?.kind === 'awaiting_user_answer');
-    if (q4hSuspension) {
-        return q4hSuspension;
+    const waitingHumanInput = waitingHumanInputDisplayState(latest?.userWait?.kind === 'awaiting_user_answer');
+    if (waitingHumanInput) {
+        return waitingHumanInput;
     }
     const finalResponseClosure = await resolveSideDialogFinalResponseClosure({ dialogId, latest });
-    if (finalResponseClosure.kind === 'closed_without_active_reply_obligation' ||
-        finalResponseClosure.kind === 'closed_with_matching_reply_obligation') {
+    if (await settleFinalResponseClosureForIdleProjection(dialogId, finalResponseClosure)) {
         return { kind: 'idle_waiting_user' };
     }
+    const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dialogId, 'running');
+    const waitingSideDialog = await waitingSideDialogDisplayState(dialogId, 'running', activeReplyObligation);
+    if (waitingSideDialog) {
+        return waitingSideDialog;
+    }
+    const pendingReplyObligation = pendingReplyObligationDisplayState(activeReplyObligation);
+    if (pendingReplyObligation) {
+        return pendingReplyObligation;
+    }
     return { kind: 'idle_waiting_user' };
 }
 async function healStaleSideDialogRunControlAfterFinalResponse(args) {
@@ -549,19 +666,12 @@ async function healStaleSideDialogRunControlAfterFinalResponse(args) {
         dialogId: args.dialogId,
         latest: args.latest,
     });
-    switch (finalResponseClosure.kind) {
-        case 'no_final_response':
-        case 'blocked_by_different_reply_obligation':
-            return args.latest;
-        case 'closed_without_active_reply_obligation':
-            break;
-        case 'closed_with_matching_reply_obligation':
-            await persistence_1.DialogPersistence.setActiveTellaskReplyObligation(args.dialogId, undefined, 'running');
-            break;
-        default: {
-            const _exhaustive = finalResponseClosure;
-            throw new Error(`Unhandled final response closure kind: ${String(_exhaustive)}`);
-        }
+    if (finalResponseClosure.kind !== 'closed_without_active_reply_obligation' &&
+        finalResponseClosure.kind !== 'closed_with_matching_reply_obligation') {
+        return args.latest;
+    }
+    if (!(await settleFinalResponseClosureForIdleProjection(args.dialogId, finalResponseClosure))) {
+        return args.latest;
     }
     const clearedReplyObligation = finalResponseClosure.kind === 'closed_with_matching_reply_obligation';
     log.warn('Healing stale sideDialog run-control flags after final response anchor', undefined, {
@@ -615,15 +725,15 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
             (0, interjection_pause_stop_1.isUserInterjectionPauseStopReason)(latest.executionMarker.reason)) {
             // WARNING:
             // This is the one place where the projection intentionally preserves legacy
-            // paused-interjection stopped state ahead of the current suspension facts. That is not a bug:
+            // paused-interjection stopped state ahead of the current wait facts. That is not a bug:
             // the UI may still need to show that the original task was paused even if the underlying
             // dialog is now waiting on Q4H.
             //
             // The true source-of-truth decision about what Continue should do next lives in `flow.ts`'s
             // resume path, which performs a fresh fact scan at resume time and then either restores the
-            // Q4H suspension projection or keeps driving immediately.
+            // Q4H waiting-human-input state or keeps driving immediately.
             //
-            // Do not "heal" this branch away by prioritizing suspension facts here; that would collapse the
+            // Do not "heal" this branch away by prioritizing wait facts here; that would collapse the
             // temporary interjection UX and make repeated interjection turns revert too early.
             return {
                 kind: 'stopped',
@@ -638,15 +748,23 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
                 continueEnabled: true,
             };
         }
-        const q4hSuspension = q4hSuspensionDisplayState(latest.userWait?.kind === 'awaiting_user_answer');
-        if (q4hSuspension) {
-            return q4hSuspension;
+        const waitingHumanInput = waitingHumanInputDisplayState(latest.userWait?.kind === 'awaiting_user_answer');
+        if (waitingHumanInput) {
+            return waitingHumanInput;
         }
         const finalResponseClosure = await resolveSideDialogFinalResponseClosure({ dialogId, latest });
-        if (finalResponseClosure.kind === 'closed_without_active_reply_obligation' ||
-            finalResponseClosure.kind === 'closed_with_matching_reply_obligation') {
+        if (await settleFinalResponseClosureForIdleProjection(dialogId, finalResponseClosure)) {
             return { kind: 'idle_waiting_user' };
         }
+        const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dialogId, 'running');
+        const waitingSideDialog = await waitingSideDialogDisplayState(dialogId, 'running', activeReplyObligation);
+        if (waitingSideDialog) {
+            return waitingSideDialog;
+        }
+        const pendingReplyObligation = pendingReplyObligationDisplayState(activeReplyObligation);
+        if (pendingReplyObligation) {
+            return pendingReplyObligation;
+        }
         if (latest.executionMarker?.kind === 'interrupted' &&
             latest.executionMarker.reason.kind !== 'pending_reply_obligation') {
             return {
@@ -790,7 +908,10 @@ async function reconcileDisplayStatesAfterRestart() {
             if (!nextIdle) {
                 continue;
             }
-            const next = nextIdle.kind === 'blocked' || nextIdle.kind === 'stopped' || nextIdle.kind === 'dead'
+            const next = nextIdle.kind === 'blocked' ||
+                nextIdle.kind === 'waiting_side_dialog' ||
+                nextIdle.kind === 'stopped' ||
+                nextIdle.kind === 'dead'
                 ? nextIdle
                 : {
                     kind: 'stopped',

package/dist/dialog-fork.js

@@ -272,6 +272,10 @@ function countFunctionCalls(events) {
     return count;
 }
 function computeRootForkDisplayState(args) {
+    const topFrame = args.askerStack?.askerStack[args.askerStack.askerStack.length - 1];
+    if (topFrame?.tellaskReplyObligation !== undefined) {
+        return { kind: 'proceeding' };
+    }
     if (args.action.kind === 'draft_user_text') {
         return { kind: 'idle_waiting_user' };
     }
@@ -281,6 +285,13 @@ function computeRootForkDisplayState(args) {
     }
     return { kind: 'stopped', reason: { kind: 'fork_continue_ready' }, continueEnabled: true };
 }
+function computeSideDialogForkDisplayState(askerStack) {
+    const topFrame = askerStack?.askerStack[askerStack.askerStack.length - 1];
+    if (topFrame?.tellaskReplyObligation !== undefined) {
+        return { kind: 'proceeding' };
+    }
+    return { kind: 'idle_waiting_user' };
+}
 async function copyArtifactsIfPresent(sourceId, targetId, sourceStatus) {
     const sourceDir = node_path_1.default.join(persistence_1.DialogPersistence.getDialogEventsPath(sourceId, sourceStatus), 'artifacts');
     const targetDir = node_path_1.default.join(persistence_1.DialogPersistence.getDialogEventsPath(targetId, 'running'), 'artifacts');
@@ -535,32 +546,14 @@ async function persistForkPlan(args) {
     if (sourceAskerStack.askerStack.length > 0) {
         await persistence_1.DialogPersistence.saveDialogAskerStack(plan.targetId, rewriteSideDialogAskerStackStateForFork(sourceAskerStack, plan.sourceId.rootId, plan.targetId.rootId), 'running');
     }
-    for (const course of plan.retainedCourses) {
-        for (const event of course.events) {
-            await persistence_1.DialogPersistence.appendEvent(plan.targetId, course.course, rewriteRecordForFork(event, plan.targetId.rootId), 'running');
-        }
-    }
-    await appendForkBaselineState(plan, args.baselineRecordsByParentSelfId.get(plan.targetId.selfId) ?? []);
-    await persistence_1.DialogPersistence._saveReminderState(plan.targetId, [...plan.reminders], 'running');
-    await persistence_1.DialogPersistence._saveQuestions4HumanState(plan.targetId, [...plan.questions], 'running');
-    for (const record of plan.activeCalleeDispatches) {
-        await persistence_1.DialogPersistence.appendActiveCalleeDispatch(plan.targetId, record, undefined, 'running');
-    }
-    await persistence_1.DialogPersistence.saveSideDialogRegistry(plan.targetId, plan.registryEntries.map((entry) => ({
-        key: entry.key,
-        sideDialogId: new dialog_1.DialogID(entry.sideDialogId, plan.targetId.rootId),
-        agentId: entry.agentId,
-        sessionSlug: entry.sessionSlug,
-    })), 'running');
-    await persistence_1.DialogPersistence.saveSideDialogResponses(plan.targetId, [...plan.sideDialogResponses], undefined, 'running');
-    await copyArtifactsIfPresent(plan.sourceId, plan.targetId, args.sourceStatus);
     const currentCourseEvents = plan.retainedCourses.find((item) => item.course === plan.currentCourse)?.events ?? [];
     const displayState = plan.targetId.selfId === plan.targetId.rootId
         ? computeRootForkDisplayState({
             action: args.action,
             questions: plan.questions,
+            askerStack: sourceAskerStack,
         })
-        : { kind: 'idle_waiting_user' };
+        : computeSideDialogForkDisplayState(sourceAskerStack);
     await persistence_1.DialogPersistence.mutateDialogLatest(plan.targetId, () => ({
         kind: 'replace',
         next: {
@@ -581,6 +574,38 @@ async function persistForkPlan(args) {
                 : undefined,
         },
     }));
+    for (const course of plan.retainedCourses) {
+        for (const event of course.events) {
+            await persistence_1.DialogPersistence.appendEvent(plan.targetId, course.course, rewriteRecordForFork(event, plan.targetId.rootId), 'running');
+        }
+    }
+    await appendForkBaselineState(plan, args.baselineRecordsByParentSelfId.get(plan.targetId.selfId) ?? []);
+    await persistence_1.DialogPersistence._saveReminderState(plan.targetId, [...plan.reminders], 'running');
+    await persistence_1.DialogPersistence._saveQuestions4HumanState(plan.targetId, [...plan.questions], 'running');
+    for (const record of plan.activeCalleeDispatches) {
+        await persistence_1.DialogPersistence.appendActiveCalleeDispatch(plan.targetId, record, undefined, 'running');
+    }
+    await persistence_1.DialogPersistence.saveSideDialogRegistry(plan.targetId, plan.registryEntries.map((entry) => ({
+        key: entry.key,
+        sideDialogId: new dialog_1.DialogID(entry.sideDialogId, plan.targetId.rootId),
+        agentId: entry.agentId,
+        sessionSlug: entry.sessionSlug,
+    })), 'running');
+    await persistence_1.DialogPersistence.saveSideDialogResponses(plan.targetId, [...plan.sideDialogResponses], undefined, 'running');
+    await copyArtifactsIfPresent(plan.sourceId, plan.targetId, args.sourceStatus);
+    await persistence_1.DialogPersistence.mutateDialogLatest(plan.targetId, (previous) => ({
+        kind: 'patch',
+        patch: {
+            currentCourse: plan.currentCourse,
+            messageCount: countMessages(currentCourseEvents),
+            functionCallCount: countFunctionCalls(currentCourseEvents),
+            sideDialogCount: plan.childCount,
+            displayState,
+            executionMarker: displayState.kind === 'stopped'
+                ? { kind: 'interrupted', reason: displayState.reason }
+                : previous.executionMarker,
+        },
+    }));
 }
 async function forkMainDialogTreeAtGeneration(args) {
     const sourceRootId = args.sourceRootId.trim();

package/dist/dialog-interruption.js

@@ -25,11 +25,12 @@ function isInterruptionReasonManualResumeEligible(reason) {
         case 'emergency_stop':
         case 'server_restart':
         case 'pending_runtime_prompt':
-        case 'pending_reply_obligation':
         case 'fork_continue_ready':
         case 'system_stop':
         case 'llm_retry_stopped':
             return true;
+        case 'pending_reply_obligation':
+            return false;
         default: {
             const _exhaustive = reason;
             return _exhaustive;

package/dist/dialog.d.ts

@@ -375,6 +375,8 @@ export declare abstract class Dialog {
     hasQueuedPrompt(): boolean;
     peekQueuedPrompt(): DialogQueuedPromptState | undefined;
     takeQueuedPrompt(): DialogQueuedPromptState | undefined;
+    removeQueuedPromptByMsgId(msgId: string): boolean;
+    removeQueuedPromptsMatching(predicate: (prompt: DialogQueuedPromptState) => boolean): number;
     setActiveRunControlSpec(spec?: DialogRunControlSpec): void;
     getActiveRunControlSpec(): DialogRunControlSpec | undefined;
     setNewCourseHook(hook?: NewCourseHook): void;
@@ -459,6 +461,7 @@ export declare abstract class Dialog {
     persistFunctionCall(id: string, name: string, rawArgumentsText: string, genseq: number, rawId?: string): Promise<void>;
     persistTellaskCall(id: string, name: TellaskCallRecordName, rawArgumentsText: string, genseq: number, options?: {
         deliveryMode?: 'tellask_call_start' | 'func_call_requested';
+        replyDirective?: TellaskReplyDirective;
     }): Promise<void>;
     /**
      * Post sideDialog completion response to this dialog.
@@ -693,6 +696,7 @@ export declare abstract class DialogStore {
     persistFunctionCall(_dialog: Dialog, _id: string, _name: string, _rawArgumentsText: string, _genseq: number, _rawId?: string): Promise<void>;
     persistTellaskCall(_dialog: Dialog, _id: string, _name: TellaskCallRecordName, _rawArgumentsText: string, _genseq: number, _options?: {
         deliveryMode?: 'tellask_call_start' | 'func_call_requested';
+        replyDirective?: TellaskReplyDirective;
     }): Promise<void>;
     /**
      * Start a new course in storage

package/dist/dialog.js

@@ -1186,6 +1186,20 @@ class Dialog {
     takeQueuedPrompt() {
         return this._queuedPrompts.shift();
     }
+    removeQueuedPromptByMsgId(msgId) {
+        const normalized = msgId.trim();
+        if (normalized === '') {
+            return false;
+        }
+        const before = this._queuedPrompts.length;
+        this._queuedPrompts = this._queuedPrompts.filter((prompt) => prompt.msgId !== normalized);
+        return this._queuedPrompts.length !== before;
+    }
+    removeQueuedPromptsMatching(predicate) {
+        const before = this._queuedPrompts.length;
+        this._queuedPrompts = this._queuedPrompts.filter((prompt) => !predicate(prompt));
+        return before - this._queuedPrompts.length;
+    }
     setActiveRunControlSpec(spec) {
         this._activeRunControlSpec = spec;
     }

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

@@ -65,6 +65,7 @@ export declare class MockGen implements LlmGenerator {
     private responseMatchesContext;
     private normalizeFuncCallArgs;
     private extractLastAssistantSaying;
+    private extractCurrentPromptMsgId;
     private buildReplyToolReminderAutoResponse;
     /**
      * Find matching response using EXACT last message only.

package/dist/llm/gen/mock.js

@@ -276,6 +276,16 @@ class MockGen {
         }
         return null;
     }
+    extractCurrentPromptMsgId(context) {
+        for (let index = context.length - 1; index >= 0; index -= 1) {
+            const msg = context[index];
+            if (msg?.type === 'prompting_msg') {
+                const trimmed = msg.msgId.trim();
+                return trimmed === '' ? undefined : trimmed;
+            }
+        }
+        return undefined;
+    }
     buildReplyToolReminderAutoResponse(input, role, context) {
         if (role !== 'user' || !(0, reply_prompt_copy_1.isReplyToolReminderPromptContent)(input)) {
             return null;
@@ -288,12 +298,14 @@ class MockGen {
         if (!replyContent) {
             return null;
         }
+        const promptMsgId = this.extractCurrentPromptMsgId(context);
         return {
             message: input,
             role,
             response: '',
             funcCalls: [
                 {
+                    id: promptMsgId ? `mock_reply_${promptMsgId}` : undefined,
                     name: toolMatch[1],
                     arguments: { replyContent },
                 },