dominds 1.23.10 → 1.24.2

package/dist/apps/runtime.js

@@ -55,7 +55,7 @@ async function ensureMainDialogLoaded(rootId) {
     const existing = dialog_global_registry_1.globalDialogRegistry.get(rootId);
     if (existing) {
         await existing.loadSideDialogRegistry();
-        await existing.loadPendingSideDialogsFromPersistence();
+        await existing.loadActiveCalleeDispatchesFromPersistence();
         return existing;
     }
     return await (0, dialog_instance_registry_1.getOrRestoreMainDialog)(rootId, 'running');
@@ -118,7 +118,7 @@ async function resolveTargetDialog(sourceDlg, target) {
         throw new Error(`dialog reminder target root not found (${describeTarget(target)})`);
     }
     await targetRoot.loadSideDialogRegistry();
-    await targetRoot.loadPendingSideDialogsFromPersistence();
+    await targetRoot.loadActiveCalleeDispatchesFromPersistence();
     if (target.sessionSlug) {
         const sideDialog = targetRoot.lookupSideDialog(target.agentId, target.sessionSlug);
         if (!sideDialog) {

package/dist/dialog-display-state.d.ts

@@ -7,7 +7,7 @@
  * Design constraints:
  * - `displayState` is a UI/diagnostic projection, not a business source of truth.
  * - Primary control flow must rely on underlying facts (active runs, stop requests,
- *   pending Q4H, pending sideDialogs, queued prompts, persisted status, explicit
+ *   pending Q4H, active callee dispatches, queued prompts, persisted status, explicit
  *   interruption/death markers).
  * - The projection is persisted to latest.yaml (`DialogLatestFile.displayState`) so it survives
  *   restarts and multi-tab views can converge quickly.
@@ -51,8 +51,7 @@ export declare function broadcastDisplayStateMarker(dialogId: DialogID, marker:
     reason?: DialogInterruptionReason;
 }): void;
 export declare function computeIdleDisplayState(dlg: Dialog): Promise<DialogDisplayState>;
-export declare function refreshRunControlProjectionFromPersistenceFacts(dialogId: DialogID, trigger: 'resume_dialog' | 'resume_all' | 'run_control_snapshot' | 'pending_sideDialogs_changed' | 'q4h_changed'): Promise<DialogLatestFile | null>;
-export declare function isRecoverableGeneratingLatest(latest: DialogLatestFile | null): boolean;
+export declare function refreshRunControlProjectionFromPersistenceFacts(dialogId: DialogID, trigger: 'resume_dialog' | 'resume_all' | 'run_control_snapshot' | 'active_callee_dispatches_changed' | 'q4h_changed'): Promise<DialogLatestFile | null>;
 export declare function reconcileDisplayStatesAfterRestart(): Promise<void>;
 export declare function requestInterruptDialog(dialogId: DialogID, reason: StopRequestedReason): Promise<{
     applied: boolean;

package/dist/dialog-display-state.js

@@ -8,7 +8,7 @@
  * Design constraints:
  * - `displayState` is a UI/diagnostic projection, not a business source of truth.
  * - Primary control flow must rely on underlying facts (active runs, stop requests,
- *   pending Q4H, pending sideDialogs, queued prompts, persisted status, explicit
+ *   pending Q4H, active callee dispatches, queued prompts, persisted status, explicit
  *   interruption/death markers).
  * - The projection is persisted to latest.yaml (`DialogLatestFile.displayState`) so it survives
  *   restarts and multi-tab views can converge quickly.
@@ -40,14 +40,15 @@ exports.setDialogDisplayState = setDialogDisplayState;
 exports.broadcastDisplayStateMarker = broadcastDisplayStateMarker;
 exports.computeIdleDisplayState = computeIdleDisplayState;
 exports.refreshRunControlProjectionFromPersistenceFacts = refreshRunControlProjectionFromPersistenceFacts;
-exports.isRecoverableGeneratingLatest = isRecoverableGeneratingLatest;
 exports.reconcileDisplayStatesAfterRestart = reconcileDisplayStatesAfterRestart;
 exports.requestInterruptDialog = requestInterruptDialog;
 exports.requestEmergencyStopAll = requestEmergencyStopAll;
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const dialog_1 = require("./dialog");
+const dialog_generation_run_1 = require("./dialog-generation-run");
 const dialog_global_registry_1 = require("./dialog-global-registry");
 const dialog_interruption_1 = require("./dialog-interruption");
+const dialog_latest_state_1 = require("./dialog-latest-state");
 const evt_registry_1 = require("./evt-registry");
 const log_1 = require("./log");
 const persistence_1 = require("./persistence");
@@ -90,58 +91,23 @@ function isDialogLatestResumable(latest) {
 function isSameDisplayState(left, right) {
     return JSON.stringify(left) === JSON.stringify(right);
 }
-function isSideDialogResponseAnchor(record) {
-    return record?.type === 'tellask_anchor_record' && record.anchorRole === 'response';
-}
 function isNonIdleDisplayProjection(state) {
     return state !== undefined && state.kind !== 'idle_waiting_user';
 }
-function pendingReplyObligationDisplayState() {
-    return {
-        kind: 'stopped',
-        reason: { kind: 'pending_reply_obligation' },
-        continueEnabled: true,
-    };
+function hasPendingNextStepTriggers(latest) {
+    return (latest?.nextStep.triggers.length ?? 0) > 0;
 }
-function blockerDisplayState(args) {
-    if (args.hasQ4H && args.hasSideDialogs) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
-    }
-    if (args.hasQ4H) {
+function q4hSuspensionDisplayState(hasQ4H) {
+    if (hasQ4H) {
         return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
     }
-    if (args.hasSideDialogs) {
-        return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
-    }
     return undefined;
 }
-async function hasSideDialogFinalResponseAnchor(dialogId, latest) {
-    if (dialogId.selfId === dialogId.rootId) {
-        return undefined;
-    }
-    const rawCourse = latest.currentCourse;
-    const currentCourse = Number.isFinite(rawCourse) && rawCourse > 0 ? Math.floor(rawCourse) : 1;
-    const courseEvents = await persistence_1.DialogPersistence.loadCourseEvents(dialogId, currentCourse, 'running');
-    for (let index = courseEvents.length - 1; index >= 0; index -= 1) {
-        const event = courseEvents[index];
-        if (event.type === 'tellask_anchor_record') {
-            return isSideDialogResponseAnchor(event) ? { callId: event.callId } : undefined;
-        }
-    }
-    return undefined;
-}
-async function hasActiveSideDialogReplyObligation(dialogId) {
-    if (dialogId.selfId === dialogId.rootId) {
-        return false;
-    }
-    const activeObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dialogId, 'running');
-    return activeObligation !== undefined;
-}
 async function resolveSideDialogFinalResponseClosure(args) {
     if (!args.latest) {
         return { kind: 'no_final_response' };
     }
-    const finalResponseAnchor = await hasSideDialogFinalResponseAnchor(args.dialogId, args.latest);
+    const finalResponseAnchor = args.latest.sideDialogFinalResponse;
     if (!finalResponseAnchor) {
         return { kind: 'no_final_response' };
     }
@@ -165,37 +131,6 @@ async function resolveSideDialogFinalResponseClosure(args) {
         activeReplyObligation,
     };
 }
-async function coerceIdleDisplayStateForActiveSideDialogReplyObligation(dialogId, displayState) {
-    if (displayState.kind !== 'idle_waiting_user') {
-        return displayState;
-    }
-    if (!(await hasActiveSideDialogReplyObligation(dialogId))) {
-        return displayState;
-    }
-    const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
-    const finalResponseClosure = await resolveSideDialogFinalResponseClosure({ dialogId, latest });
-    if (finalResponseClosure.kind === 'closed_with_matching_reply_obligation') {
-        await persistence_1.DialogPersistence.setActiveTellaskReplyObligation(dialogId, undefined, 'running');
-        return displayState;
-    }
-    if (finalResponseClosure.kind === 'closed_without_active_reply_obligation') {
-        return displayState;
-    }
-    const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
-    const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
-    const blocked = blockerDisplayState({
-        hasQ4H: q4h.length > 0,
-        hasSideDialogs: pendingSideDialogs.length > 0,
-    });
-    const healedDisplayState = blocked ?? pendingReplyObligationDisplayState();
-    log.warn('Prevented sideDialog with active reply obligation from entering idle display state', new Error('sideDialog idle display-state invariant violation'), {
-        dialogId: dialogId.valueOf(),
-        rootId: dialogId.rootId,
-        selfId: dialogId.selfId,
-        healedDisplayState,
-    });
-    return healedDisplayState;
-}
 function classifyRunControlBucket(state) {
     if (!state)
         return 'none';
@@ -246,17 +181,15 @@ 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 blocker remains
-                // - interjection-paused dialogs still count as resumable even if blocker facts remain,
+                // - ordinary interrupted dialogs count as resumable only when no Q4H suspension remains
+                // - interjection-paused dialogs still count as resumable even if Q4H remains,
                 //   because the intended UX is that Continue exits the temporary paused projection
                 //   and re-evaluates the original task from fresh facts
                 if ((0, interjection_pause_stop_1.isUserInterjectionPauseStopReason)(latest.executionMarker.reason)) {
                     resumable++;
                 }
                 else {
-                    const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
-                    const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
-                    if (q4h.length === 0 && pendingSideDialogs.length === 0) {
+                    if (latest.userWait?.kind !== 'awaiting_user_answer') {
                         resumable++;
                     }
                 }
@@ -430,7 +363,6 @@ async function clearDialogInterruptedExecutionMarker(dialogId) {
     await setDialogExecutionMarker(dialogId, undefined);
 }
 async function setDialogDisplayState(dialogId, displayState) {
-    displayState = await coerceIdleDisplayStateForActiveSideDialogReplyObligation(dialogId, displayState);
     if (displayState.kind === 'dead' && dialogId.selfId === dialogId.rootId) {
         log.warn('Rejecting dead displayState for main dialog (main dialogs must not be dead)', undefined, {
             dialogId: dialogId.valueOf(),
@@ -535,18 +467,16 @@ async function computeIdleDisplayState(dlg) {
             continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
         };
     }
-    if (latest?.pendingCourseStartPrompt) {
+    if (latest?.pendingRuntimePrompt) {
         return {
             kind: 'stopped',
-            reason: { kind: 'pending_course_start' },
+            reason: { kind: 'pending_runtime_prompt' },
             continueEnabled: true,
         };
     }
-    const hasQ4H = await dlg.hasPendingQ4H();
-    const hasSideDialogs = await dlg.hasPendingSideDialogs();
-    const blocked = blockerDisplayState({ hasQ4H, hasSideDialogs });
-    if (blocked) {
-        return blocked;
+    const q4hSuspension = q4hSuspensionDisplayState(latest?.userWait?.kind === 'awaiting_user_answer');
+    if (q4hSuspension) {
+        return q4hSuspension;
     }
     const finalResponseClosure = await resolveSideDialogFinalResponseClosure({
         dialogId: dlg.id,
@@ -556,9 +486,6 @@ async function computeIdleDisplayState(dlg) {
         finalResponseClosure.kind === 'closed_with_matching_reply_obligation') {
         return { kind: 'idle_waiting_user' };
     }
-    if (await hasActiveSideDialogReplyObligation(dlg.id)) {
-        return pendingReplyObligationDisplayState();
-    }
     return { kind: 'idle_waiting_user' };
 }
 async function computeIdleDisplayStateFromPersistence(dialogId) {
@@ -581,34 +508,27 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
             continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
         };
     }
-    if (latest?.pendingCourseStartPrompt) {
+    if (latest?.pendingRuntimePrompt) {
         return {
             kind: 'stopped',
-            reason: { kind: 'pending_course_start' },
+            reason: { kind: 'pending_runtime_prompt' },
             continueEnabled: true,
         };
     }
-    const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
-    const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
-    const hasQ4H = q4h.length > 0;
-    const hasSideDialogs = pendingSideDialogs.length > 0;
-    const blocked = blockerDisplayState({ hasQ4H, hasSideDialogs });
-    if (blocked) {
-        return blocked;
+    const q4hSuspension = q4hSuspensionDisplayState(latest?.userWait?.kind === 'awaiting_user_answer');
+    if (q4hSuspension) {
+        return q4hSuspension;
     }
     const finalResponseClosure = await resolveSideDialogFinalResponseClosure({ dialogId, latest });
     if (finalResponseClosure.kind === 'closed_without_active_reply_obligation' ||
         finalResponseClosure.kind === 'closed_with_matching_reply_obligation') {
         return { kind: 'idle_waiting_user' };
     }
-    if (await hasActiveSideDialogReplyObligation(dialogId)) {
-        return pendingReplyObligationDisplayState();
-    }
     return { kind: 'idle_waiting_user' };
 }
 async function healStaleSideDialogRunControlAfterFinalResponse(args) {
     if (args.dialogId.selfId === args.dialogId.rootId ||
-        (args.latest.needsDrive !== true &&
+        (!hasPendingNextStepTriggers(args.latest) &&
             args.latest.generating !== true &&
             args.latest.executionMarker?.kind !== 'interrupted' &&
             !isNonIdleDisplayProjection(args.latest.displayState))) {
@@ -617,7 +537,7 @@ async function healStaleSideDialogRunControlAfterFinalResponse(args) {
     if (args.latest.executionMarker?.kind === 'dead') {
         return args.latest;
     }
-    if (args.latest.pendingCourseStartPrompt) {
+    if (args.latest.pendingRuntimePrompt) {
         return args.latest;
     }
     const finalResponseClosure = await resolveSideDialogFinalResponseClosure({
@@ -645,7 +565,7 @@ async function healStaleSideDialogRunControlAfterFinalResponse(args) {
         responseCallId: finalResponseClosure.callId,
         clearedReplyObligation,
         previousGenerating: args.latest.generating ?? null,
-        previousNeedsDrive: args.latest.needsDrive ?? null,
+        previousNextStepTriggerCount: args.latest.nextStep.triggers.length,
         previousDisplayState: args.latest.displayState ?? null,
         previousExecutionMarker: args.latest.executionMarker ?? null,
     });
@@ -653,7 +573,7 @@ async function healStaleSideDialogRunControlAfterFinalResponse(args) {
         kind: 'patch',
         patch: {
             generating: false,
-            needsDrive: false,
+            nextStep: (0, dialog_latest_state_1.createEmptyDialogNextStepState)(),
             displayState: { kind: 'idle_waiting_user' },
             executionMarker: undefined,
         },
@@ -690,16 +610,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 the paused-interjection
-            // stopped state ahead of the current blocker facts. That is not a bug: after a user
+            // stopped state ahead of the current suspension facts. That is not a bug: after a user
             // interjection we want the UI to keep showing "original task paused; click Continue" even if
-            // the underlying dialog is still waiting on Q4H/sideDialogs.
+            // the underlying dialog is still 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 `blocked`, or
-            // - keeps driving immediately.
+            // 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.
             //
-            // Do not "heal" this branch away by prioritizing blocker facts here; that would collapse the
+            // Do not "heal" this branch away by prioritizing suspension facts here; that would collapse the
             // temporary interjection UX and make repeated interjection turns revert too early.
             return {
                 kind: 'stopped',
@@ -707,29 +626,22 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
                 continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
             };
         }
-        if (latest.pendingCourseStartPrompt) {
+        if (latest.pendingRuntimePrompt) {
             return {
                 kind: 'stopped',
-                reason: { kind: 'pending_course_start' },
+                reason: { kind: 'pending_runtime_prompt' },
                 continueEnabled: true,
             };
         }
-        const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
-        const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
-        const hasQ4H = q4h.length > 0;
-        const hasSideDialogs = pendingSideDialogs.length > 0;
-        const blocked = blockerDisplayState({ hasQ4H, hasSideDialogs });
-        if (blocked) {
-            return blocked;
+        const q4hSuspension = q4hSuspensionDisplayState(latest.userWait?.kind === 'awaiting_user_answer');
+        if (q4hSuspension) {
+            return q4hSuspension;
         }
         const finalResponseClosure = await resolveSideDialogFinalResponseClosure({ dialogId, latest });
         if (finalResponseClosure.kind === 'closed_without_active_reply_obligation' ||
             finalResponseClosure.kind === 'closed_with_matching_reply_obligation') {
             return { kind: 'idle_waiting_user' };
         }
-        if (await hasActiveSideDialogReplyObligation(dialogId)) {
-            return pendingReplyObligationDisplayState();
-        }
         if (latest.executionMarker?.kind === 'interrupted' &&
             latest.executionMarker.reason.kind !== 'pending_reply_obligation') {
             return {
@@ -775,21 +687,6 @@ async function computeIdleDisplayStateForReconciliation(dialogId) {
         return null;
     }
 }
-function isRecoverableGeneratingLatest(latest) {
-    if (latest?.generating !== true) {
-        return false;
-    }
-    const marker = latest.executionMarker;
-    if (!marker) {
-        return true;
-    }
-    if (marker.kind === 'dead') {
-        return false;
-    }
-    return (marker.kind !== 'interrupted' ||
-        marker.reason.kind === 'pending_course_start' ||
-        marker.reason.kind === 'pending_reply_obligation');
-}
 async function reconcileDisplayStatesAfterRestart() {
     const dialogIds = await persistence_1.DialogPersistence.listAllDialogIds('running');
     for (const dialogId of dialogIds) {
@@ -832,9 +729,13 @@ async function reconcileDisplayStatesAfterRestart() {
             }
             continue;
         }
+        if (latest.generating === true && latest.generationRunState === undefined) {
+            await persistence_1.DialogPersistence.quarantineMalformedRuntimeState(dialogId, 'running', 'restart_reconciliation_missing_generation_run_state', `Restart reconciliation refused to recover generating dialog without generationRunState (rootId=${dialogId.rootId}, selfId=${dialogId.selfId})`);
+            continue;
+        }
         if (dialogId.selfId !== dialogId.rootId &&
             (latest.generating === true ||
-                latest.needsDrive === true ||
+                hasPendingNextStepTriggers(latest) ||
                 latest.executionMarker?.kind === 'interrupted' ||
                 isNonIdleDisplayProjection(latest.displayState))) {
             const healedStaleSideDialogRunControl = await healStaleSideDialogRunControlAfterFinalResponse({
@@ -846,19 +747,26 @@ async function reconcileDisplayStatesAfterRestart() {
                 continue;
             }
             latest = healedStaleSideDialogRunControl;
-            if (latest.generating !== true && latest.needsDrive !== true) {
+            if (latest.generating !== true && !hasPendingNextStepTriggers(latest)) {
                 continue;
             }
         }
-        if (isRecoverableGeneratingLatest(latest)) {
+        const recoverableGenerationRunState = (0, dialog_generation_run_1.getRecoverableGenerationRunState)(latest);
+        if (recoverableGenerationRunState !== undefined) {
             try {
+                await persistence_1.DialogPersistence.upsertNextStepTrigger(dialogId, {
+                    triggerId: `open-generation-recovery:${dialogId.selfId}:${recoverableGenerationRunState.course}:${recoverableGenerationRunState.genseq}`,
+                    kind: 'open_generation_recovery',
+                    course: recoverableGenerationRunState.course,
+                    genseq: recoverableGenerationRunState.genseq,
+                    createdAt: recoverableGenerationRunState.openedAt,
+                }, 'running');
                 await persistence_1.DialogPersistence.mutateDialogLatest(dialogId, () => ({
                     kind: 'patch',
                     patch: {
-                        needsDrive: true,
                         displayState: { kind: 'proceeding' },
                         executionMarker: existingMarker?.kind === 'interrupted' &&
-                            (existingMarker.reason.kind === 'pending_course_start' ||
+                            (existingMarker.reason.kind === 'pending_runtime_prompt' ||
                                 existingMarker.reason.kind === 'pending_reply_obligation')
                             ? undefined
                             : existingMarker,
@@ -872,7 +780,7 @@ async function reconcileDisplayStatesAfterRestart() {
             }
             continue;
         }
-        if (latest.generating === true || latest.needsDrive === true) {
+        if (latest.generating === true || hasPendingNextStepTriggers(latest)) {
             const nextIdle = await computeIdleDisplayStateForReconciliation(dialogId);
             if (!nextIdle) {
                 continue;

package/dist/dialog-drive-work.d.ts

@@ -0,0 +1,4 @@
+import type { DialogLatestFile } from '@longrun-ai/kernel/types/storage';
+export type DialogLatestSnapshot = DialogLatestFile | null;
+export declare function hasRecoverableGenerationBeyondFinalResponse(latest: DialogLatestFile): boolean;
+export declare function hasDurableDriveWork(latest: DialogLatestSnapshot): boolean;

package/dist/dialog-drive-work.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasRecoverableGenerationBeyondFinalResponse = hasRecoverableGenerationBeyondFinalResponse;
+exports.hasDurableDriveWork = hasDurableDriveWork;
+const dialog_generation_run_1 = require("./dialog-generation-run");
+function hasResultArrivalTrigger(latest) {
+    return latest.nextStep.triggers.some((trigger) => trigger.kind === 'result_arrival');
+}
+function hasRecoverableGenerationBeyondFinalResponse(latest) {
+    if ((0, dialog_generation_run_1.getRecoverableGenerationRunState)(latest) === undefined) {
+        return false;
+    }
+    const finalResponse = latest.sideDialogFinalResponse;
+    if (finalResponse === undefined) {
+        return true;
+    }
+    return (latest.pendingRuntimePrompt !== undefined ||
+        (latest.latestAssignmentAnchor !== undefined &&
+            latest.latestAssignmentAnchor.callId !== finalResponse.callId));
+}
+function hasDurableDriveWork(latest) {
+    if (!latest) {
+        return false;
+    }
+    const replyDelivery = latest.replyDelivery;
+    if (replyDelivery &&
+        (replyDelivery.status === 'pending' || replyDelivery.toolResultStatus === 'pending')) {
+        return true;
+    }
+    if (latest.pendingRuntimePrompt !== undefined) {
+        return true;
+    }
+    if (hasRecoverableGenerationBeyondFinalResponse(latest)) {
+        return true;
+    }
+    if (latest.sideDialogFinalResponse !== undefined) {
+        return hasResultArrivalTrigger(latest);
+    }
+    return latest.nextStep.triggers.length > 0;
+}

package/dist/dialog-fork.d.ts

@@ -5,7 +5,6 @@ type ForkDialogAction = Readonly<{
 }> | Readonly<{
     kind: 'restore_pending';
     pendingQ4H: boolean;
-    pendingSideDialogs: boolean;
 }> | Readonly<{
     kind: 'auto_continue';
 }>;