dominds 1.16.10 → 1.17.0

package/dist/dialog-display-state.js

@@ -417,6 +417,13 @@ async function computeIdleDisplayState(dlg) {
             continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
         };
     }
+    if (latest?.pendingCourseStartPrompt) {
+        return {
+            kind: 'stopped',
+            reason: { kind: 'pending_course_start' },
+            continueEnabled: true,
+        };
+    }
     const hasQ4H = await dlg.hasPendingQ4H();
     const hasSubdialogs = await dlg.hasPendingSubdialogs();
     if (hasQ4H && hasSubdialogs) {
@@ -449,6 +456,13 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
             continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
         };
     }
+    if (latest?.pendingCourseStartPrompt) {
+        return {
+            kind: 'stopped',
+            reason: { kind: 'pending_course_start' },
+            continueEnabled: true,
+        };
+    }
     const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
     const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
     const hasQ4H = q4h.length > 0;
@@ -502,6 +516,13 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
                 continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
             };
         }
+        if (latest.pendingCourseStartPrompt) {
+            return {
+                kind: 'stopped',
+                reason: { kind: 'pending_course_start' },
+                continueEnabled: true,
+            };
+        }
         const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
         const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
         const hasQ4H = q4h.length > 0;
@@ -605,7 +626,7 @@ async function reconcileDisplayStatesAfterRestart() {
             if (!nextIdle) {
                 continue;
             }
-            const next = nextIdle.kind === 'blocked'
+            const next = nextIdle.kind === 'blocked' || nextIdle.kind === 'stopped' || nextIdle.kind === 'dead'
                 ? nextIdle
                 : {
                     kind: 'stopped',

package/dist/dialog-instance-registry.js

@@ -24,6 +24,39 @@ function clampNonNegativeFiniteInt(value, fallback) {
         return fallback;
     return Math.max(0, Math.floor(value));
 }
+async function resolvePendingCourseStartPromptForRestore(args) {
+    const pending = args.latest?.pendingCourseStartPrompt;
+    if (!pending) {
+        return { pendingCourseStartPrompt: 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);
+        }
+        return { pendingCourseStartPrompt: undefined };
+    }
+    return {
+        pendingCourseStartPrompt: {
+            content: pending.content,
+            msgId: pending.msgId,
+            grammar: 'markdown',
+            origin: 'runtime',
+            ...(pending.userLanguageCode === undefined
+                ? {}
+                : { userLanguageCode: pending.userLanguageCode }),
+            ...(pending.tellaskReplyDirective === undefined
+                ? {}
+                : { tellaskReplyDirective: pending.tellaskReplyDirective }),
+            ...(pending.skipTaskdoc === undefined ? {} : { skipTaskdoc: pending.skipTaskdoc }),
+            ...(pending.subdialogReplyTarget === undefined
+                ? {}
+                : { subdialogReplyTarget: pending.subdialogReplyTarget }),
+        },
+    };
+}
 async function getOrRestoreRootDialog(rootId, status) {
     const existing = dialog_global_registry_1.globalDialogRegistry.get(rootId);
     if (existing) {
@@ -41,6 +74,12 @@ async function getOrRestoreRootDialog(rootId, status) {
         return undefined;
     }
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(rootDialogId, status);
+    const { pendingCourseStartPrompt } = await resolvePendingCourseStartPromptForRestore({
+        dialogId: rootDialogId,
+        status,
+        messages: rootState.messages,
+        latest,
+    });
     let diligencePushMax = diligence_1.DEFAULT_DILIGENCE_PUSH_MAX;
     try {
         const team = await team_1.Team.load();
@@ -56,6 +95,7 @@ async function getOrRestoreRootDialog(rootId, status) {
         reminders: rootState.reminders,
         currentCourse: rootState.currentCourse,
         contextHealth: rootState.contextHealth,
+        pendingCourseStartPrompt,
     });
     const persistedDisableDiligencePush = latest && typeof latest.disableDiligencePush === 'boolean'
         ? latest.disableDiligencePush
@@ -97,6 +137,12 @@ async function ensureDialogLoaded(rootDialog, targetId, status, visitedSelfIds =
     if (!state)
         return undefined;
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(targetId, status);
+    const { pendingCourseStartPrompt } = await resolvePendingCourseStartPromptForRestore({
+        dialogId: targetId,
+        status,
+        messages: state.messages,
+        latest,
+    });
     const assignmentFromSup = state.metadata.assignmentFromSup;
     if (!assignmentFromSup)
         return undefined;
@@ -112,6 +158,7 @@ async function ensureDialogLoaded(rootDialog, targetId, status, visitedSelfIds =
         reminders: state.reminders,
         currentCourse: state.currentCourse,
         contextHealth: state.contextHealth,
+        pendingCourseStartPrompt,
     });
     subdialog.disableDiligencePush = latest?.disableDiligencePush ?? false;
     if (subdialog.sessionSlug) {

package/dist/dialog-interruption.d.ts

@@ -16,3 +16,4 @@ import type { DialogInterruptionReason } from '@longrun-ai/kernel/types/display-
  *   provider/model and should keep protecting the system.
  */
 export declare function isInterruptionReasonManualResumeEligible(reason: DialogInterruptionReason): boolean;
+export declare function doesInterruptionReasonRequireExplicitResume(reason: DialogInterruptionReason): boolean;

package/dist/dialog-interruption.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isInterruptionReasonManualResumeEligible = isInterruptionReasonManualResumeEligible;
+exports.doesInterruptionReasonRequireExplicitResume = doesInterruptionReasonRequireExplicitResume;
 /**
  * Decides whether a finalized stopped dialog should expose manual Continue.
  *
@@ -22,6 +23,24 @@ function isInterruptionReasonManualResumeEligible(reason) {
         case 'user_stop':
         case 'emergency_stop':
         case 'server_restart':
+        case 'pending_course_start':
+        case 'fork_continue_ready':
+        case 'system_stop':
+        case 'llm_retry_stopped':
+            return true;
+        default: {
+            const _exhaustive = reason;
+            return _exhaustive;
+        }
+    }
+}
+function doesInterruptionReasonRequireExplicitResume(reason) {
+    switch (reason.kind) {
+        case 'pending_course_start':
+            return false;
+        case 'user_stop':
+        case 'emergency_stop':
+        case 'server_restart':
         case 'fork_continue_ready':
         case 'system_stop':
         case 'llm_retry_stopped':

package/dist/dialog.d.ts

@@ -106,6 +106,7 @@ export interface DialogInitParams {
         createdAt?: string;
         updatedAt?: string;
         contextHealth?: ContextHealthSnapshot;
+        pendingCourseStartPrompt?: DialogPrompt;
     };
 }
 export type VisibleReminderTarget = Readonly<{
@@ -678,7 +679,7 @@ export declare abstract class DialogStore {
     /**
      * Start a new course in storage
      */
-    startNewCourse(_dialog: Dialog, _newCoursePrompt: string): Promise<void>;
+    startNewCourse(_dialog: Dialog, _newCoursePrompt: DialogPrompt): Promise<void>;
     /**
      * Handle stream error
      */

package/dist/dialog.js

@@ -67,6 +67,38 @@ function getGlobalDialogMutex(dialogId) {
 function compareVisibleReminderTargetOrder(a, b) {
     return (0, tool_1.compareReminderDisplayOrder)(a.reminder, b.reminder);
 }
+function buildSubdialogAssignmentPromptMeta(subdialog) {
+    const assignment = subdialog.assignmentFromSup;
+    switch (assignment.callName) {
+        case 'tellask':
+            return {
+                tellaskReplyDirective: {
+                    expectedReplyCallName: 'replyTellask',
+                    targetCallId: assignment.callId,
+                    tellaskContent: assignment.tellaskContent,
+                },
+                subdialogReplyTarget: {
+                    ownerDialogId: assignment.callerDialogId,
+                    callType: 'B',
+                    callId: assignment.callId,
+                },
+            };
+        case 'tellaskSessionless':
+        case 'freshBootsReasoning':
+            return {
+                tellaskReplyDirective: {
+                    expectedReplyCallName: 'replyTellaskSessionless',
+                    targetCallId: assignment.callId,
+                    tellaskContent: assignment.tellaskContent,
+                },
+                subdialogReplyTarget: {
+                    ownerDialogId: assignment.callerDialogId,
+                    callType: 'C',
+                    callId: assignment.callId,
+                },
+            };
+    }
+}
 /**
  * Abstract base class for all dialog types.
  * Contains common properties and methods shared between RootDialog and SubDialog.
@@ -132,6 +164,9 @@ class Dialog {
         this._lastUserLanguageCode = (0, work_language_1.getWorkLanguage)();
         this._lastContextHealth = initialState?.contextHealth;
         this._lastContextHealthGenseq = undefined;
+        if (initialState?.pendingCourseStartPrompt) {
+            this.setNewCourseStartPrompt(initialState.pendingCourseStartPrompt);
+        }
         this.resetCourseLanguageNotice();
     }
     setLastContextHealth(snapshot) {
@@ -844,6 +879,7 @@ class Dialog {
             grammar: 'markdown',
             userLanguageCode: this._lastUserLanguageCode,
             origin: 'runtime',
+            ...(this instanceof SubDialog ? buildSubdialogAssignmentPromptMeta(this) : {}),
         };
         const runControlSpec = options?.runControl ?? this._activeRunControlSpec;
         let nextPrompt = basePrompt;
@@ -863,7 +899,7 @@ class Dialog {
         await this.dlgStore.clearQuestions4Human(this);
         // Delegate to DialogStore for course start persistence
         if (this.dlgStore) {
-            await this.dlgStore.startNewCourse(this, nextPrompt.content);
+            await this.dlgStore.startNewCourse(this, nextPrompt);
         }
         const storeCourse = this.dlgStore
             ? await this.dlgStore.loadCurrentCourse(this.id)

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

@@ -1465,6 +1465,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 content: replyGuidance.promptContent,
                             });
                             await dlg.persistUserMessage(replyGuidance.promptContent, currentPrompt.msgId, 'markdown', origin, persistedUserLanguageCode, q4hAnswerCallId, replyGuidance.persistedTellaskReplyDirective);
+                            await persistence_1.DialogPersistence.clearPendingCourseStartPrompt(dlg.id, currentPrompt.msgId, dlg.status);
                         }
                         if (renderPromptAsRuntimeGuideBubble) {
                             (0, evt_registry_1.postDialogEvent)(dlg, {

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

@@ -6,6 +6,7 @@ const run_control_1 = require("../../apps/run-control");
 const dialog_1 = require("../../dialog");
 const dialog_display_state_1 = require("../../dialog-display-state");
 const dialog_global_registry_1 = require("../../dialog-global-registry");
+const dialog_interruption_1 = require("../../dialog-interruption");
 const evt_registry_1 = require("../../evt-registry");
 const log_1 = require("../../log");
 const load_1 = require("../../minds/load");
@@ -415,6 +416,7 @@ async function executeDriveRound(args) {
             if (latest &&
                 latest.executionMarker &&
                 latest.executionMarker.kind === 'interrupted' &&
+                (0, dialog_interruption_1.doesInterruptionReasonRequireExplicitResume)(latest.executionMarker.reason) &&
                 !allowResumeFromInterrupted) {
                 log_1.log.debug('kernel-driver skip drive for interrupted dialog without explicit resume/user prompt', undefined, {
                     dialogId: dialog.id.valueOf(),
@@ -473,7 +475,7 @@ async function executeDriveRound(args) {
             // `allowResumeFromInterrupted` covers multiple stop reasons, but the interjection-pause case
             // is semantically special. Clicking Continue here does NOT mean "blindly clear stopped and
             // drive". We must re-read the fresh persistence facts first because there are three distinct
-            // true-source cases behind the same visible stopped panel:
+            // true-source cases behind the same visible resumption panel:
             // - no active reply obligation / not suspended anymore -> continue real driving now
             // - active reply obligation + suspended -> restore true blocked state
             // - active reply obligation + still proceeding entitlement (for example queued upNext) ->
@@ -634,10 +636,10 @@ async function executeDriveRound(args) {
             dlg: dialog,
             prompt: effectivePrompt,
         });
-        // Only park into the special interjection stopped-panel state when this user turn has
+        // Only park into the special interjection resumption-panel state when this user turn has
         // suppressed a still-pending inter-dialog reply obligation that must be reasserted later.
         // User interjections without a parked original task should simply finish and fall back to the
-        // dialog's true underlying state, without showing the special stopped panel.
+        // dialog's true underlying state, without showing the special resumption panel.
         //
         // Q4H answers are explicitly outside this branch even though they also come from the human.
         // They belong to the askHuman reply channel and must continue the suspended askHuman round,

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runBackendDriver = runBackendDriver;
 const dialog_display_state_1 = require("../../dialog-display-state");
 const dialog_global_registry_1 = require("../../dialog-global-registry");
+const dialog_interruption_1 = require("../../dialog-interruption");
 const log_1 = require("../../log");
 const persistence_1 = require("../../persistence");
 const engine_1 = require("./engine");
@@ -25,10 +26,12 @@ async function driveQueuedDialogsOnce() {
             const latest = await persistence_1.DialogPersistence.loadDialogLatest(rootDialog.id, 'running');
             const executionMarker = latest?.executionMarker;
             const stopRequested = (0, dialog_display_state_1.getStopRequestedReason)(rootDialog.id);
-            if (executionMarker?.kind === 'interrupted' || stopRequested !== undefined) {
+            const interruptedRequiresExplicitResume = executionMarker?.kind === 'interrupted' &&
+                (0, dialog_interruption_1.doesInterruptionReasonRequireExplicitResume)(executionMarker.reason);
+            if (interruptedRequiresExplicitResume || stopRequested !== undefined) {
                 dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(rootDialog.id.rootId, {
                     source: 'kernel_driver_backend_loop',
-                    reason: executionMarker?.kind === 'interrupted'
+                    reason: interruptedRequiresExplicitResume
                         ? 'execution_marker_blocked:interrupted'
                         : `stop_requested:${stopRequested}`,
                 });

package/dist/persistence.d.ts

@@ -6,6 +6,7 @@
  */
 import type { ContextHealthSnapshot } from '@longrun-ai/kernel/types/context-health';
 import type { NativeToolCallPayload, WebSearchCallAction, WebSearchCallSource } from '@longrun-ai/kernel/types/dialog';
+import type { DialogPrompt } from '@longrun-ai/kernel/types/drive-intent';
 import type { LanguageCode } from '@longrun-ai/kernel/types/language';
 import type { DialogLatestFile, DialogMetadataFile, HumanQuestion, PendingSubdialogStateRecord, PersistedDialogRecord, ProviderData, ReasoningPayload, ReconciledRecordWriteTarget, RootDialogMetadataFile, RootGenerationAnchor, SubdialogMetadataFile, SubdialogRegistryStateRecord, SubdialogResponseStateRecord, TellaskCallRecordName, TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import type { DialogsQuarantinedMessage, DialogStatusKind } from '@longrun-ai/kernel/types/wire';
@@ -126,7 +127,7 @@ export declare class DiskFileDialogStore extends DialogStore {
     /**
      * Start new course (append-only JSONL + exceptional reminder persistence)
      */
-    startNewCourse(dialog: Dialog, _newCoursePrompt: string): Promise<void>;
+    startNewCourse(dialog: Dialog, newCoursePrompt: DialogPrompt): Promise<void>;
     /**
      * Persist reminder state (exceptional overwrite pattern)
      * Note: Event emission is handled by processReminderUpdates() in Dialog
@@ -561,6 +562,7 @@ export declare class DialogPersistence {
     private static flushLatestWriteBack;
     static setNeedsDrive(dialogId: DialogID, needsDrive: boolean, status?: DialogStatusKind): Promise<void>;
     static getNeedsDrive(dialogId: DialogID, status?: DialogStatusKind): Promise<boolean>;
+    static clearPendingCourseStartPrompt(dialogId: DialogID, msgId: string, status?: DialogStatusKind): Promise<void>;
     static setDeferredReplyReassertion(dialogId: DialogID, deferredReplyReassertion: DialogLatestFile['deferredReplyReassertion'], status?: DialogStatusKind): Promise<void>;
     static getDeferredReplyReassertion(dialogId: DialogID, status?: DialogStatusKind): Promise<DialogLatestFile['deferredReplyReassertion']>;
     /**

package/dist/persistence.js

@@ -311,6 +311,8 @@ function parseDialogInterruptionReason(value) {
             return { kind: 'emergency_stop' };
         case 'server_restart':
             return { kind: 'server_restart' };
+        case 'pending_course_start':
+            return { kind: 'pending_course_start' };
         case 'fork_continue_ready':
             return { kind: 'fork_continue_ready' };
         case 'system_stop': {
@@ -837,6 +839,104 @@ function isSubdialogMetadataFile(value) {
 function isDialogMetadataFile(value) {
     return isRootDialogMetadataFile(value) || isSubdialogMetadataFile(value);
 }
+function parseTellaskReplyDirective(value) {
+    if (!isRecord(value))
+        return null;
+    const expectedReplyCallName = value.expectedReplyCallName;
+    const targetCallId = value.targetCallId;
+    const tellaskContent = value.tellaskContent;
+    if (expectedReplyCallName !== 'replyTellask' &&
+        expectedReplyCallName !== 'replyTellaskSessionless' &&
+        expectedReplyCallName !== 'replyTellaskBack') {
+        return null;
+    }
+    if (typeof targetCallId !== 'string' || typeof tellaskContent !== 'string') {
+        return null;
+    }
+    if (expectedReplyCallName === 'replyTellaskBack') {
+        const targetDialogId = value.targetDialogId;
+        if (typeof targetDialogId !== 'string')
+            return null;
+        return {
+            expectedReplyCallName,
+            targetCallId,
+            targetDialogId,
+            tellaskContent,
+        };
+    }
+    return {
+        expectedReplyCallName,
+        targetCallId,
+        tellaskContent,
+    };
+}
+function parseDialogSubdialogReplyTarget(value) {
+    if (!isRecord(value))
+        return null;
+    const ownerDialogId = value.ownerDialogId;
+    const callType = value.callType;
+    const callId = value.callId;
+    if (typeof ownerDialogId !== 'string' || typeof callId !== 'string') {
+        return null;
+    }
+    if (callType !== 'A' && callType !== 'B' && callType !== 'C') {
+        return null;
+    }
+    return {
+        ownerDialogId,
+        callType,
+        callId,
+    };
+}
+function parseDialogPendingCourseStartPrompt(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value.content !== 'string' || typeof value.msgId !== 'string') {
+        return null;
+    }
+    if (value.grammar !== 'markdown' || value.origin !== 'runtime') {
+        return null;
+    }
+    const userLanguageCodeRaw = value.userLanguageCode;
+    if (userLanguageCodeRaw !== undefined &&
+        (typeof userLanguageCodeRaw !== 'string' || !(0, language_1.isLanguageCode)(userLanguageCodeRaw))) {
+        return null;
+    }
+    const skipTaskdocRaw = value.skipTaskdoc;
+    if (skipTaskdocRaw !== undefined && typeof skipTaskdocRaw !== 'boolean') {
+        return null;
+    }
+    const tellaskReplyDirective = value.tellaskReplyDirective === undefined
+        ? undefined
+        : parseTellaskReplyDirective(value.tellaskReplyDirective);
+    if (value.tellaskReplyDirective !== undefined && tellaskReplyDirective === null) {
+        return null;
+    }
+    const subdialogReplyTarget = value.subdialogReplyTarget === undefined
+        ? undefined
+        : parseDialogSubdialogReplyTarget(value.subdialogReplyTarget);
+    if (value.subdialogReplyTarget !== undefined && subdialogReplyTarget === null) {
+        return null;
+    }
+    const userLanguageCode = userLanguageCodeRaw;
+    const skipTaskdoc = skipTaskdocRaw;
+    const normalizedTellaskReplyDirective = tellaskReplyDirective === null ? undefined : tellaskReplyDirective;
+    const normalizedSubdialogReplyTarget = subdialogReplyTarget === null ? undefined : subdialogReplyTarget;
+    return {
+        content: value.content,
+        msgId: value.msgId,
+        grammar: 'markdown',
+        origin: 'runtime',
+        ...(userLanguageCode === undefined ? {} : { userLanguageCode }),
+        ...(normalizedTellaskReplyDirective === undefined
+            ? {}
+            : { tellaskReplyDirective: normalizedTellaskReplyDirective }),
+        ...(skipTaskdoc === undefined ? {} : { skipTaskdoc }),
+        ...(normalizedSubdialogReplyTarget === undefined
+            ? {}
+            : { subdialogReplyTarget: normalizedSubdialogReplyTarget }),
+    };
+}
 function parseDialogLatestFile(value) {
     if (!isRecord(value))
         return null;
@@ -1006,48 +1106,16 @@ function parseDialogLatestFile(value) {
         if (deferredReplyReassertionRaw.reason !== 'user_interjection_with_parked_original_task') {
             return null;
         }
-        const directiveRaw = deferredReplyReassertionRaw.directive;
-        if (!isRecord(directiveRaw))
+        const directive = parseTellaskReplyDirective(deferredReplyReassertionRaw.directive);
+        if (directive === null)
             return null;
         const resumeGuideSurfacedRaw = deferredReplyReassertionRaw.resumeGuideSurfaced;
         if (resumeGuideSurfacedRaw !== undefined && typeof resumeGuideSurfacedRaw !== 'boolean') {
             return null;
         }
-        const expectedReplyCallName = directiveRaw.expectedReplyCallName;
-        const targetCallId = directiveRaw.targetCallId;
-        const tellaskContent = directiveRaw.tellaskContent;
-        if (expectedReplyCallName !== 'replyTellask' &&
-            expectedReplyCallName !== 'replyTellaskSessionless' &&
-            expectedReplyCallName !== 'replyTellaskBack') {
-            return null;
-        }
-        if (typeof targetCallId !== 'string' || typeof tellaskContent !== 'string') {
-            return null;
-        }
-        if (expectedReplyCallName === 'replyTellaskBack') {
-            const targetDialogId = directiveRaw.targetDialogId;
-            if (typeof targetDialogId !== 'string')
-                return null;
-            return {
-                reason: 'user_interjection_with_parked_original_task',
-                directive: {
-                    expectedReplyCallName,
-                    targetCallId,
-                    targetDialogId,
-                    tellaskContent,
-                },
-                ...(resumeGuideSurfacedRaw === undefined
-                    ? {}
-                    : { resumeGuideSurfaced: resumeGuideSurfacedRaw }),
-            };
-        }
         return {
             reason: 'user_interjection_with_parked_original_task',
-            directive: {
-                expectedReplyCallName,
-                targetCallId,
-                tellaskContent,
-            },
+            directive,
             ...(resumeGuideSurfacedRaw === undefined
                 ? {}
                 : { resumeGuideSurfaced: resumeGuideSurfacedRaw }),
@@ -1055,6 +1123,14 @@ function parseDialogLatestFile(value) {
     })();
     if (deferredReplyReassertion === null)
         return null;
+    const pendingCourseStartPromptRaw = value.pendingCourseStartPrompt;
+    const pendingCourseStartPrompt = (() => {
+        if (pendingCourseStartPromptRaw === undefined)
+            return undefined;
+        return parseDialogPendingCourseStartPrompt(pendingCourseStartPromptRaw);
+    })();
+    if (pendingCourseStartPrompt === null)
+        return null;
     return {
         currentCourse,
         lastModified: value.lastModified,
@@ -1068,6 +1144,7 @@ function parseDialogLatestFile(value) {
         executionMarker,
         fbrState,
         deferredReplyReassertion,
+        pendingCourseStartPrompt,
         disableDiligencePush: value.disableDiligencePush,
         diligencePushRemainingBudget: value.diligencePushRemainingBudget,
     };
@@ -2070,16 +2147,49 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
     /**
      * Start new course (append-only JSONL + exceptional reminder persistence)
      */
-    async startNewCourse(dialog, _newCoursePrompt) {
+    async startNewCourse(dialog, newCoursePrompt) {
         const previousCourse = dialog.currentCourse;
         const newCourse = previousCourse + 1;
+        if (newCoursePrompt.origin !== 'runtime') {
+            throw new Error(`startNewCourse invariant violation: pending new-course prompt must have runtime origin for dialog=${dialog.id.valueOf()}`);
+        }
         // Persist reminders state for new course (exceptional overwrite)
         // Use the currently attached dialog's reminders to avoid stale state
         await this.persistReminders(dialog, dialog.reminders || []);
         // Update latest.yaml with new course (lastModified is set by persistence layer)
         await DialogPersistence.mutateDialogLatest(this.dialogId, () => ({
             kind: 'patch',
-            patch: { currentCourse: newCourse },
+            patch: {
+                currentCourse: newCourse,
+                needsDrive: true,
+                displayState: {
+                    kind: 'stopped',
+                    reason: { kind: 'pending_course_start' },
+                    continueEnabled: true,
+                },
+                executionMarker: {
+                    kind: 'interrupted',
+                    reason: { kind: 'pending_course_start' },
+                },
+                pendingCourseStartPrompt: {
+                    content: newCoursePrompt.content,
+                    msgId: newCoursePrompt.msgId,
+                    grammar: 'markdown',
+                    origin: 'runtime',
+                    ...(newCoursePrompt.userLanguageCode === undefined
+                        ? {}
+                        : { userLanguageCode: newCoursePrompt.userLanguageCode }),
+                    ...(newCoursePrompt.tellaskReplyDirective === undefined
+                        ? {}
+                        : { tellaskReplyDirective: newCoursePrompt.tellaskReplyDirective }),
+                    ...(newCoursePrompt.skipTaskdoc === undefined
+                        ? {}
+                        : { skipTaskdoc: newCoursePrompt.skipTaskdoc }),
+                    ...(newCoursePrompt.subdialogReplyTarget === undefined
+                        ? {}
+                        : { subdialogReplyTarget: newCoursePrompt.subdialogReplyTarget }),
+                },
+            },
         }));
         // Post course update event
         const courseUpdateEvt = {
@@ -5778,6 +5888,33 @@ class DialogPersistence {
         const latest = await this.loadDialogLatest(dialogId, status);
         return latest?.needsDrive === true;
     }
+    static async clearPendingCourseStartPrompt(dialogId, msgId, status = 'running') {
+        const normalizedMsgId = msgId.trim();
+        if (normalizedMsgId === '') {
+            throw new Error(`clearPendingCourseStartPrompt invariant violation: empty msgId for dialog=${dialogId.valueOf()}`);
+        }
+        await this.mutateDialogLatest(dialogId, (previous) => {
+            const pending = previous.pendingCourseStartPrompt;
+            if (!pending || pending.msgId !== normalizedMsgId) {
+                return { kind: 'noop' };
+            }
+            return {
+                kind: 'patch',
+                patch: {
+                    pendingCourseStartPrompt: undefined,
+                    needsDrive: false,
+                    displayState: previous.displayState?.kind === 'stopped' &&
+                        previous.displayState.reason.kind === 'pending_course_start'
+                        ? { kind: 'idle_waiting_user' }
+                        : previous.displayState,
+                    executionMarker: previous.executionMarker?.kind === 'interrupted' &&
+                        previous.executionMarker.reason.kind === 'pending_course_start'
+                        ? undefined
+                        : previous.executionMarker,
+                },
+            };
+        }, status);
+    }
     static async setDeferredReplyReassertion(dialogId, deferredReplyReassertion, status = 'running') {
         await this.mutateDialogLatest(dialogId, () => ({ kind: 'patch', patch: { deferredReplyReassertion } }), status);
     }

package/dist/runtime/interjection-pause-stop.js

@@ -10,7 +10,7 @@ const USER_INTERJECTION_PAUSE_STOP_DETAIL = 'user_interjection_pause_resume_orig
 //
 // Not every user interjection should use this reason. If there is no parked original task to
 // resume afterwards, the interjection should simply complete and the dialog should fall back to
-// its true underlying state without showing this stopped panel.
+// its true underlying state without showing this resumption panel.
 //
 // In particular, askHuman answers are NOT "user interjections" for this purpose. A prompt carrying
 // a real `q4hAnswerCallId` belongs to the askHuman reply channel and must never be routed through

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.16.10",
+  "version": "1.17.0",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {
@@ -52,9 +52,9 @@
     "ws": "^8.19.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
-    "@longrun-ai/shell": "1.8.14",
-    "@longrun-ai/kernel": "1.8.14",
-    "@longrun-ai/codex-auth": "0.12.1"
+    "@longrun-ai/shell": "1.8.15",
+    "@longrun-ai/codex-auth": "0.12.1",
+    "@longrun-ai/kernel": "1.8.15"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",