dominds 1.23.10 → 1.24.2

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;

package/dist/dialog-generation-run.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRecoverableGenerationRunState = getRecoverableGenerationRunState;
+function getRecoverableGenerationRunState(latest) {
+    if (!latest) {
+        return undefined;
+    }
+    if (latest.generationRunState?.kind !== 'open') {
+        return undefined;
+    }
+    const marker = latest.executionMarker;
+    if (!marker) {
+        return latest.generationRunState;
+    }
+    if (marker.kind === 'dead') {
+        return undefined;
+    }
+    if (marker.kind !== 'interrupted' ||
+        marker.reason.kind === 'pending_runtime_prompt' ||
+        marker.reason.kind === 'pending_reply_obligation') {
+        return latest.generationRunState;
+    }
+    return undefined;
+}

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

@@ -1,11 +1,11 @@
-import type { MainDialog } from './dialog';
+import { type MainDialog } from './dialog';
 export type DriveTriggerEvent = Readonly<{
     type: 'drive_trigger_evt';
-    action: 'mark_needs_drive' | 'mark_not_needing_drive' | 'active_run_cleared';
+    action: 'wake_drive' | 'clear_drive_wake' | 'active_run_cleared';
     rootId: string;
     entryFound: boolean;
-    previousNeedsDrive: boolean | null;
-    nextNeedsDrive: boolean;
+    previousWakeQueued: boolean | null;
+    nextWakeQueued: boolean;
     source: string;
     reason: string;
     emittedAtMs: number;
@@ -26,13 +26,12 @@ declare class GlobalDialogRegistry {
     unregister(rootId: string): void;
     private publishDriveTrigger;
     waitForDriveTrigger(): Promise<DriveTriggerEvent>;
-    markNeedsDrive(rootId: string, meta?: DriveTriggerMeta): void;
-    markNotNeedingDrive(rootId: string, meta?: DriveTriggerMeta): void;
+    wakeDrive(rootId: string, meta?: DriveTriggerMeta): void;
+    clearDriveWake(rootId: string, meta?: DriveTriggerMeta): void;
     notifyActiveRunCleared(rootId: string, meta?: DriveTriggerMeta): void;
     noteActiveRunBlockedQueuedDrive(rootId: string): void;
     hasPendingActiveRunClearedWake(rootId: string): boolean;
-    isMarkedNeedingDrive(rootId: string): boolean;
-    getDialogsNeedingDrive(): MainDialog[];
+    isDriveWakeQueued(rootId: string): boolean;
     getLastDriveTrigger(rootId: string): DriveTriggerEvent | undefined;
     getAll(): MainDialog[];
     get size(): number;

package/dist/dialog-global-registry.js

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.globalDialogRegistry = void 0;
 const evt_1 = require("@longrun-ai/kernel/evt");
+const dialog_1 = require("./dialog");
+const log_1 = require("./log");
 const persistence_1 = require("./persistence");
+const log = (0, log_1.createLogger)('dialog-global-registry');
 class GlobalDialogRegistry {
     constructor() {
         this.entries = new Map();
@@ -31,26 +34,34 @@ class GlobalDialogRegistry {
         }
         this.entries.set(mainDialog.id.rootId, {
             mainDialog,
-            needsDrive: false,
+            wakeQueued: false,
             activeRunClearedWakePending: false,
         });
         void (async () => {
             try {
-                const needsDrive = await persistence_1.DialogPersistence.getNeedsDrive(mainDialog.id);
-                if (needsDrive) {
-                    this.markNeedsDrive(mainDialog.id.rootId, {
+                const hasPendingNextStepTriggers = await persistence_1.DialogPersistence.hasPendingNextStepTriggers(mainDialog.id);
+                const watchedDialogIds = await persistence_1.DialogPersistence.loadDriveWatchedDialogIds(mainDialog.id);
+                if (hasPendingNextStepTriggers || watchedDialogIds.length > 0) {
+                    this.wakeDrive(mainDialog.id.rootId, {
                         source: 'dialog_registry_hydration',
-                        reason: 'persisted_needs_drive_true',
+                        reason: hasPendingNextStepTriggers
+                            ? 'persisted_next_step_triggers'
+                            : 'persisted_drive_watch',
                     });
                 }
             }
-            catch {
-                // Best-effort hydration; backend driver will still function for runtime-triggered drives.
+            catch (error) {
+                log.warn('Failed to hydrate persisted drive wake for registered main dialog', error, {
+                    rootId: mainDialog.id.rootId,
+                    selfId: mainDialog.id.selfId,
+                });
             }
         })();
     }
     unregister(rootId) {
         this.entries.delete(rootId);
+        this.lastDriveTriggerByRootId.delete(rootId);
+        (0, dialog_1.scheduleGlobalDialogMutexCleanupForRoot)(rootId);
     }
     publishDriveTrigger(args) {
         const trigger = {
@@ -58,8 +69,8 @@ class GlobalDialogRegistry {
             action: args.action,
             rootId: args.rootId,
             entryFound: args.entryFound,
-            previousNeedsDrive: args.previousNeedsDrive,
-            nextNeedsDrive: args.nextNeedsDrive,
+            previousWakeQueued: args.previousWakeQueued,
+            nextWakeQueued: args.nextWakeQueued,
             source: args.meta.source,
             reason: args.meta.reason,
             emittedAtMs: Date.now(),
@@ -77,44 +88,44 @@ class GlobalDialogRegistry {
             this.driveTriggerSubChan = (0, evt_1.createSubChan)(this.driveTriggerPubChan);
         }
     }
-    markNeedsDrive(rootId, meta) {
+    wakeDrive(rootId, meta) {
         const triggerMeta = meta ?? {
             source: 'unknown',
             reason: 'unspecified',
         };
         const entry = this.entries.get(rootId);
-        const previousNeedsDrive = entry ? entry.needsDrive : null;
+        const previousWakeQueued = entry ? entry.wakeQueued : null;
         if (entry) {
-            entry.needsDrive = true;
+            entry.wakeQueued = true;
             // A fresh queueing trigger supersedes any earlier "wake me once active run clears" debt.
             entry.activeRunClearedWakePending = false;
         }
         this.publishDriveTrigger({
-            action: 'mark_needs_drive',
+            action: 'wake_drive',
             rootId,
             entryFound: entry !== undefined,
-            previousNeedsDrive,
-            nextNeedsDrive: true,
+            previousWakeQueued,
+            nextWakeQueued: true,
             meta: triggerMeta,
         });
     }
-    markNotNeedingDrive(rootId, meta) {
+    clearDriveWake(rootId, meta) {
         const triggerMeta = meta ?? {
             source: 'unknown',
             reason: 'unspecified',
         };
         const entry = this.entries.get(rootId);
-        const previousNeedsDrive = entry ? entry.needsDrive : null;
+        const previousWakeQueued = entry ? entry.wakeQueued : null;
         if (entry) {
-            entry.needsDrive = false;
+            entry.wakeQueued = false;
             entry.activeRunClearedWakePending = false;
         }
         this.publishDriveTrigger({
-            action: 'mark_not_needing_drive',
+            action: 'clear_drive_wake',
             rootId,
             entryFound: entry !== undefined,
-            previousNeedsDrive,
-            nextNeedsDrive: false,
+            previousWakeQueued,
+            nextWakeQueued: false,
             meta: triggerMeta,
         });
     }
@@ -127,24 +138,24 @@ class GlobalDialogRegistry {
         if (!entry) {
             return;
         }
-        if (!entry.activeRunClearedWakePending || !entry.needsDrive) {
+        if (!entry.activeRunClearedWakePending || !entry.wakeQueued) {
             entry.activeRunClearedWakePending = false;
             return;
         }
-        const currentNeedsDrive = entry ? entry.needsDrive : null;
+        const currentWakeQueued = entry ? entry.wakeQueued : null;
         entry.activeRunClearedWakePending = false;
         this.publishDriveTrigger({
             action: 'active_run_cleared',
             rootId,
             entryFound: true,
-            previousNeedsDrive: currentNeedsDrive,
-            nextNeedsDrive: entry.needsDrive,
+            previousWakeQueued: currentWakeQueued,
+            nextWakeQueued: entry.wakeQueued,
             meta: triggerMeta,
         });
     }
     noteActiveRunBlockedQueuedDrive(rootId) {
         const entry = this.entries.get(rootId);
-        if (!entry || !entry.needsDrive) {
+        if (!entry || !entry.wakeQueued) {
             return;
         }
         entry.activeRunClearedWakePending = true;
@@ -152,13 +163,8 @@ class GlobalDialogRegistry {
     hasPendingActiveRunClearedWake(rootId) {
         return this.entries.get(rootId)?.activeRunClearedWakePending === true;
     }
-    isMarkedNeedingDrive(rootId) {
-        return this.entries.get(rootId)?.needsDrive === true;
-    }
-    getDialogsNeedingDrive() {
-        return Array.from(this.entries.values())
-            .filter((entry) => entry.needsDrive)
-            .map((entry) => entry.mainDialog);
+    isDriveWakeQueued(rootId) {
+        return this.entries.get(rootId)?.wakeQueued === true;
     }
     getLastDriveTrigger(rootId) {
         return this.lastDriveTriggerByRootId.get(rootId);

package/dist/dialog-instance-registry.js

@@ -24,28 +24,28 @@ function clampNonNegativeFiniteInt(value, fallback) {
         return fallback;
     return Math.max(0, Math.floor(value));
 }
-async function resolvePendingCourseStartPromptForRestore(args) {
-    const pending = args.latest?.pendingCourseStartPrompt;
+async function resolvePendingRuntimePromptForRestore(args) {
+    const pending = args.latest?.pendingRuntimePrompt;
     if (!pending) {
-        return { pendingCourseStartPrompt: undefined };
+        return { pendingRuntimePrompt: undefined };
     }
     const alreadyPersisted = args.messages.some((message) => {
         return message.type === 'prompting_msg' && message.msgId === pending.msgId;
     });
     if (alreadyPersisted) {
         if (args.status === 'running') {
-            await persistence_1.DialogPersistence.clearPendingCourseStartPrompt(args.dialogId, pending.msgId, args.status);
+            await persistence_1.DialogPersistence.clearPendingRuntimePrompt(args.dialogId, pending.msgId, args.status);
         }
-        return { pendingCourseStartPrompt: undefined };
+        return { pendingRuntimePrompt: undefined };
     }
-    return { pendingCourseStartPrompt: pending };
+    return { pendingRuntimePrompt: pending };
 }
 async function getOrRestoreMainDialog(rootId, status) {
     const existing = dialog_global_registry_1.globalDialogRegistry.get(rootId);
     if (existing) {
         existing.setPersistenceStatus(status);
         await existing.loadSideDialogRegistry();
-        await existing.loadPendingSideDialogsFromPersistence();
+        await existing.loadActiveCalleeDispatchesFromPersistence();
         return existing;
     }
     const mainDialogId = new dialog_1.DialogID(rootId);
@@ -54,7 +54,7 @@ async function getOrRestoreMainDialog(rootId, status) {
         return undefined;
     const rootMetadata = rootState.metadata;
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(mainDialogId, status);
-    const { pendingCourseStartPrompt } = await resolvePendingCourseStartPromptForRestore({
+    const { pendingRuntimePrompt } = await resolvePendingRuntimePromptForRestore({
         dialogId: mainDialogId,
         status,
         messages: rootState.messages,
@@ -75,7 +75,7 @@ async function getOrRestoreMainDialog(rootId, status) {
         reminders: rootState.reminders,
         currentCourse: rootState.currentCourse,
         contextHealth: rootState.contextHealth,
-        pendingCourseStartPrompt,
+        pendingRuntimePrompt,
     });
     const persistedDisableDiligencePush = latest && typeof latest.disableDiligencePush === 'boolean'
         ? latest.disableDiligencePush
@@ -93,7 +93,7 @@ async function getOrRestoreMainDialog(rootId, status) {
     // Keep the in-memory main dialog fully hydrated regardless of persistence status
     // (running/completed/archived) so sideDialog lookup is stable across UI navigation.
     await mainDialog.loadSideDialogRegistry();
-    await mainDialog.loadPendingSideDialogsFromPersistence();
+    await mainDialog.loadActiveCalleeDispatchesFromPersistence();
     return mainDialog;
 }
 async function ensureDialogLoaded(mainDialog, targetId, status, visitedSelfIds = new Set()) {
@@ -124,7 +124,7 @@ async function ensureDialogLoaded(mainDialog, targetId, status, visitedSelfIds =
     if (!state)
         return undefined;
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(targetId, status);
-    const { pendingCourseStartPrompt } = await resolvePendingCourseStartPromptForRestore({
+    const { pendingRuntimePrompt } = await resolvePendingRuntimePromptForRestore({
         dialogId: targetId,
         status,
         messages: state.messages,
@@ -151,7 +151,7 @@ async function ensureDialogLoaded(mainDialog, targetId, status, visitedSelfIds =
         reminders: state.reminders,
         currentCourse: state.currentCourse,
         contextHealth: state.contextHealth,
-        pendingCourseStartPrompt,
+        pendingRuntimePrompt,
     });
     sideDialog.disableDiligencePush =
         latest && typeof latest.disableDiligencePush === 'boolean'

package/dist/dialog-interruption.js

@@ -23,7 +23,7 @@ function isInterruptionReasonManualResumeEligible(reason) {
         case 'user_stop':
         case 'emergency_stop':
         case 'server_restart':
-        case 'pending_course_start':
+        case 'pending_runtime_prompt':
         case 'pending_reply_obligation':
         case 'fork_continue_ready':
         case 'system_stop':
@@ -37,7 +37,7 @@ function isInterruptionReasonManualResumeEligible(reason) {
 }
 function doesInterruptionReasonRequireExplicitResume(reason) {
     switch (reason.kind) {
-        case 'pending_course_start':
+        case 'pending_runtime_prompt':
         case 'pending_reply_obligation':
             return false;
         case 'user_stop':

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

@@ -0,0 +1,4 @@
+import type { DialogNextStepTriggerState, DialogTellaskCallState, DialogTellaskResultState } from '@longrun-ai/kernel/types/storage';
+export declare function createEmptyDialogNextStepState(): DialogNextStepTriggerState;
+export declare function createEmptyDialogTellaskCallState(): DialogTellaskCallState;
+export declare function createEmptyDialogTellaskResultState(): DialogTellaskResultState;

package/dist/dialog-latest-state.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmptyDialogNextStepState = createEmptyDialogNextStepState;
+exports.createEmptyDialogTellaskCallState = createEmptyDialogTellaskCallState;
+exports.createEmptyDialogTellaskResultState = createEmptyDialogTellaskResultState;
+function createEmptyDialogNextStepState() {
+    return { nextSeq: 1, triggers: [] };
+}
+function createEmptyDialogTellaskCallState() {
+    return { calls: [] };
+}
+function createEmptyDialogTellaskResultState() {
+    return { results: [] };
+}