dominds 1.23.10 → 1.24.1

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,3 @@
+import type { DialogLatestFile } from '@longrun-ai/kernel/types/storage';
+export type DialogLatestSnapshot = DialogLatestFile | null;
+export declare function hasDurableDriveWork(latest: DialogLatestSnapshot): boolean;

package/dist/dialog-drive-work.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 hasDurableDriveWork(latest) {
+    if (!latest) {
+        return false;
+    }
+    const replyDelivery = latest.replyDelivery;
+    if (replyDelivery &&
+        (replyDelivery.status === 'pending' || replyDelivery.toolResultStatus === 'pending')) {
+        return true;
+    }
+    if (latest.sideDialogFinalResponse !== undefined) {
+        return hasResultArrivalTrigger(latest);
+    }
+    return (latest.nextStep.triggers.length > 0 || (0, dialog_generation_run_1.getRecoverableGenerationRunState)(latest) !== undefined);
+}

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';
 }>;

package/dist/dialog-fork.js

@@ -9,6 +9,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const storage_1 = require("@longrun-ai/kernel/types/storage");
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const dialog_1 = require("./dialog");
+const dialog_latest_state_1 = require("./dialog-latest-state");
 const persistence_1 = require("./persistence");
 const tool_1 = require("./tool");
 const id_1 = require("./utils/id");
@@ -49,8 +50,8 @@ function cloneQuestions(questions) {
         callSiteRef: { ...question.callSiteRef },
     }));
 }
-function clonePendingSideDialogs(pendingSideDialogs) {
-    return pendingSideDialogs.map((entry) => ({
+function cloneActiveCalleeDispatches(activeCalleeDispatches) {
+    return activeCalleeDispatches.map((entry) => ({
         ...entry,
         mentionList: entry.mentionList ? [...entry.mentionList] : undefined,
     }));
@@ -111,7 +112,7 @@ function isForkStateRecord(record) {
         case 'sideDialog_created_record':
         case 'reminders_reconciled_record':
         case 'questions4human_reconciled_record':
-        case 'pending_sideDialogs_reconciled_record':
+        case 'active_callees_reconciled_record':
         case 'sideDialog_registry_reconciled_record':
         case 'sideDialog_responses_reconciled_record':
             return record;
@@ -147,7 +148,7 @@ function isPersistedMessageRecord(record) {
         case 'sideDialog_created_record':
         case 'reminders_reconciled_record':
         case 'questions4human_reconciled_record':
-        case 'pending_sideDialogs_reconciled_record':
+        case 'active_callees_reconciled_record':
         case 'sideDialog_registry_reconciled_record':
         case 'sideDialog_responses_reconciled_record':
             return false;
@@ -242,7 +243,7 @@ function rewriteRecordForFork(record, newRootId) {
         case 'sideDialog_created_record':
         case 'reminders_reconciled_record':
         case 'questions4human_reconciled_record':
-        case 'pending_sideDialogs_reconciled_record':
+        case 'active_callees_reconciled_record':
         case 'sideDialog_registry_reconciled_record':
         case 'sideDialog_responses_reconciled_record':
             throw new Error(`Fork transcript copy must not include state record ${record.type}`);
@@ -275,16 +276,9 @@ function computeRootForkDisplayState(args) {
         return { kind: 'idle_waiting_user' };
     }
     const hasQ4H = args.questions.length > 0;
-    const hasSideDialogs = args.pendingSideDialogs.length > 0;
-    if (hasQ4H && hasSideDialogs) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
-    }
     if (hasQ4H) {
         return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
     }
-    if (hasSideDialogs) {
-        return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
-    }
     return { kind: 'stopped', reason: { kind: 'fork_continue_ready' }, continueEnabled: true };
 }
 async function copyArtifactsIfPresent(sourceId, targetId, sourceStatus) {
@@ -329,7 +323,7 @@ async function collectForkSnapshot(dialogId, status, cutoffAnchor) {
     const courseNumbers = await listDialogCourseNumbers(dialogId, status);
     let latestReminders = null;
     let latestQuestions = null;
-    let latestPending = null;
+    let latestActiveCalleeDispatches = null;
     let latestRegistry = null;
     let latestResponses = null;
     for (const course of courseNumbers) {
@@ -347,8 +341,8 @@ async function collectForkSnapshot(dialogId, status, cutoffAnchor) {
                 case 'questions4human_reconciled_record':
                     latestQuestions = cloneQuestions(stateRecord.questions);
                     break;
-                case 'pending_sideDialogs_reconciled_record':
-                    latestPending = clonePendingSideDialogs(stateRecord.pendingSideDialogs);
+                case 'active_callees_reconciled_record':
+                    latestActiveCalleeDispatches = cloneActiveCalleeDispatches(stateRecord.activeCalleeDispatches);
                     break;
                 case 'sideDialog_registry_reconciled_record':
                     latestRegistry = cloneRegistryEntries(stateRecord.entries);
@@ -368,7 +362,7 @@ async function collectForkSnapshot(dialogId, status, cutoffAnchor) {
     return {
         reminders: latestReminders !== null ? latestReminders.map((item) => cloneReminderSnapshot(item)) : [],
         questions: latestQuestions ?? [],
-        pendingSideDialogs: latestPending ?? [],
+        activeCalleeDispatches: latestActiveCalleeDispatches ?? [],
         registryEntries: latestRegistry ?? [],
         sideDialogResponses: latestResponses ?? [],
     };
@@ -378,15 +372,15 @@ async function collectIncludedSideDialogs(args) {
     const scannedDialogSelfIds = new Set();
     const included = new Map();
     while (queue.length > 0) {
-        const ownerDialogId = queue.shift();
-        if (!ownerDialogId)
+        const sourceDialogId = queue.shift();
+        if (!sourceDialogId)
             break;
-        if (scannedDialogSelfIds.has(ownerDialogId.selfId))
+        if (scannedDialogSelfIds.has(sourceDialogId.selfId))
             continue;
-        scannedDialogSelfIds.add(ownerDialogId.selfId);
-        const courseNumbers = await listDialogCourseNumbers(ownerDialogId, args.sourceStatus);
+        scannedDialogSelfIds.add(sourceDialogId.selfId);
+        const courseNumbers = await listDialogCourseNumbers(sourceDialogId, args.sourceStatus);
         for (const course of courseNumbers) {
-            const events = await persistence_1.DialogPersistence.readCourseEvents(ownerDialogId, course, args.sourceStatus);
+            const events = await persistence_1.DialogPersistence.readCourseEvents(sourceDialogId, course, args.sourceStatus);
             for (const event of events) {
                 if (event.type !== 'sideDialog_created_record')
                     continue;
@@ -457,7 +451,7 @@ async function buildDialogForkPlan(args) {
         currentCourse: retainedCurrentCourse,
         reminders: snapshot.reminders,
         questions: snapshot.questions,
-        pendingSideDialogs: snapshot.pendingSideDialogs,
+        activeCalleeDispatches: snapshot.activeCalleeDispatches,
         registryEntries: snapshot.registryEntries,
         sideDialogResponses: snapshot.sideDialogResponses,
         childCount: args.childCount,
@@ -489,11 +483,11 @@ async function appendForkBaselineState(plan, baselineSideDialogCreatedRecords) {
         ...FORK_BASELINE_ANCHOR,
         questions: cloneQuestions(plan.questions),
     };
-    const pendingRecord = {
+    const activeCalleesRecord = {
         ts: baselineTs,
-        type: 'pending_sideDialogs_reconciled_record',
+        type: 'active_callees_reconciled_record',
         ...FORK_BASELINE_ANCHOR,
-        pendingSideDialogs: clonePendingSideDialogs(plan.pendingSideDialogs),
+        activeCalleeDispatches: cloneActiveCalleeDispatches(plan.activeCalleeDispatches),
     };
     const registryRecord = {
         ts: baselineTs,
@@ -509,7 +503,7 @@ async function appendForkBaselineState(plan, baselineSideDialogCreatedRecords) {
     };
     await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, remindersRecord, 'running');
     await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, q4hRecord, 'running');
-    await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, pendingRecord, 'running');
+    await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, activeCalleesRecord, 'running');
     await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, registryRecord, 'running');
     await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, responsesRecord, 'running');
 }
@@ -549,7 +543,9 @@ async function persistForkPlan(args) {
     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');
-    await persistence_1.DialogPersistence.savePendingSideDialogs(plan.targetId, [...plan.pendingSideDialogs], undefined, '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),
@@ -563,7 +559,6 @@ async function persistForkPlan(args) {
         ? computeRootForkDisplayState({
             action: args.action,
             questions: plan.questions,
-            pendingSideDialogs: plan.pendingSideDialogs,
         })
         : { kind: 'idle_waiting_user' };
     await persistence_1.DialogPersistence.mutateDialogLatest(plan.targetId, () => ({
@@ -576,7 +571,9 @@ async function persistForkPlan(args) {
             functionCallCount: countFunctionCalls(currentCourseEvents),
             sideDialogCount: plan.childCount,
             generating: false,
-            needsDrive: false,
+            nextStep: (0, dialog_latest_state_1.createEmptyDialogNextStepState)(),
+            tellaskCalls: (0, dialog_latest_state_1.createEmptyDialogTellaskCallState)(),
+            tellaskResults: (0, dialog_latest_state_1.createEmptyDialogTellaskResultState)(),
             displayState,
             disableDiligencePush: plan.targetId.selfId === plan.targetId.rootId ? args.latestDisableDiligencePush : false,
             diligencePushRemainingBudget: plan.targetId.selfId === plan.targetId.rootId
@@ -642,11 +639,10 @@ async function forkMainDialogTreeAtGeneration(args) {
     });
     const action = draftUserText !== null
         ? { kind: 'draft_user_text', userText: draftUserText }
-        : rootPlan.questions.length > 0 || rootPlan.pendingSideDialogs.length > 0
+        : rootPlan.questions.length > 0
             ? {
                 kind: 'restore_pending',
                 pendingQ4H: rootPlan.questions.length > 0,
-                pendingSideDialogs: rootPlan.pendingSideDialogs.length > 0,
             }
             : { kind: 'auto_continue' };
     const sideDialogPlans = [];

package/dist/dialog-generation-run.d.ts

@@ -0,0 +1,4 @@
+import type { DialogGenerationRunState, DialogLatestFile } from '@longrun-ai/kernel/types/storage';
+export declare function getRecoverableGenerationRunState(latest: DialogLatestFile | null | undefined): Extract<DialogGenerationRunState, {
+    kind: 'open';
+}> | undefined;