dominds 1.25.6 → 1.25.7

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

@@ -1,10 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.driveDialogStreamCore = driveDialogStreamCore;
 const diligence_1 = require("@longrun-ai/kernel/diligence");
 const storage_1 = require("@longrun-ai/kernel/types/storage");
 const id_1 = require("@longrun-ai/kernel/utils/id");
 const time_1 = require("@longrun-ai/kernel/utils/time");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
 const dialog_1 = require("../../dialog");
 const dialog_display_state_1 = require("../../dialog-display-state");
 const dialog_interruption_1 = require("../../dialog-interruption");
@@ -1226,6 +1231,167 @@ async function persistInvalidFuncCallRuntimeGuide(args) {
 function resolveFuncToolFollowupMode(tool) {
     return tool?.followupMode ?? 'immediate';
 }
+function summarizeRoutedFunctionResult(routed) {
+    return {
+        hasImmediateFollowupToolCalls: routed.hasImmediateFollowupToolCalls,
+        hasImmediateTellaskOutputs: routed.hasImmediateTellaskOutputs,
+        immediateFollowupCallIds: routed.immediateFollowupCallIds,
+        immediateTellaskOutputCallIds: routed.immediateTellaskOutputCallIds,
+        shouldStopAfterReplyTool: routed.shouldStopAfterReplyTool,
+        shouldStopAfterPendingTellaskWait: routed.shouldStopAfterPendingTellaskWait,
+        pairedMessageTypes: routed.pairedMessages.map((msg) => msg.type),
+        tellaskToolOutputTypes: routed.tellaskToolOutputs.map((msg) => msg.type),
+    };
+}
+function buildToolRoundStopDiagnostics(args) {
+    return {
+        course: args.dlg.activeGenCourseOrUndefined ?? args.dlg.currentCourse,
+        genseq: args.dlg.activeGenSeq,
+        callIds: args.streamedFuncCalls.map((call) => call.id),
+        callNames: args.streamedFuncCalls.map((call) => call.name),
+        lastBusinessContinuation: args.lastBusinessContinuation,
+        routed: summarizeRoutedFunctionResult(args.routed),
+        decision: {
+            shouldStartImmediatePostToolGeneration: args.shouldStartImmediatePostToolGeneration,
+            stopReason: args.stopReason,
+            ...(args.suspensionAfterToolRound === undefined
+                ? {}
+                : { suspensionAfterToolRound: args.suspensionAfterToolRound }),
+            ...(args.queuedPromptAfterToolRound === undefined
+                ? {}
+                : { queuedPromptAfterToolRound: args.queuedPromptAfterToolRound }),
+            ...(args.remindersVer === undefined ? {} : { remindersVer: args.remindersVer }),
+            ...(args.pubRemindersVer === undefined ? {} : { pubRemindersVer: args.pubRemindersVer }),
+        },
+    };
+}
+function shouldCaptureUnexpectedIdleAfterToolRound(args) {
+    if (args.finalDisplayState.kind !== 'idle_waiting_user')
+        return false;
+    const diagnostics = args.diagnostics;
+    if (diagnostics === undefined)
+        return false;
+    if (diagnostics.callIds.length === 0)
+        return false;
+    if ((args.latest?.nextStep.triggers.length ?? 0) > 0)
+        return false;
+    if (diagnostics.decision.stopReason === 'reply_tool' ||
+        diagnostics.decision.stopReason === 'pending_tellask_wait') {
+        return false;
+    }
+    const continuation = diagnostics.lastBusinessContinuation;
+    if (continuation.kind !== 'none')
+        return true;
+    if (diagnostics.routed.hasImmediateFollowupToolCalls)
+        return true;
+    if (diagnostics.routed.hasImmediateTellaskOutputs)
+        return true;
+    if (diagnostics.routed.immediateFollowupCallIds.length > 0)
+        return true;
+    if (diagnostics.routed.immediateTellaskOutputCallIds.length > 0)
+        return true;
+    return false;
+}
+function sanitizeDebugFileSegment(value) {
+    const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, '_').replace(/^_+|_+$/g, '');
+    return sanitized.length > 0 ? sanitized.slice(0, 80) : 'unknown';
+}
+async function maybeWriteUnexpectedIdleAfterToolRoundDebugDump(args) {
+    if (!shouldCaptureUnexpectedIdleAfterToolRound({
+        finalDisplayState: args.finalDisplayState,
+        latest: args.latest,
+        diagnostics: args.diagnostics,
+    })) {
+        return;
+    }
+    const diagnostics = args.diagnostics;
+    if (diagnostics === undefined) {
+        throw new Error('unexpected idle debug invariant violation: diagnostics disappeared');
+    }
+    const capturedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+    const debugDir = node_path_1.default.resolve(process.cwd(), '.dislogs', 'debug');
+    const fileName = [
+        'kernel-driver-unexpected-idle-after-tool-round',
+        sanitizeDebugFileSegment(capturedAt),
+        sanitizeDebugFileSegment(args.dlg.id.rootId),
+        sanitizeDebugFileSegment(args.dlg.id.selfId),
+        `c${String(diagnostics.course)}`,
+        `g${String(diagnostics.genseq)}`,
+        `${(0, id_1.generateShortId)()}.json`,
+    ].join('-');
+    const activeCallees = await persistence_1.DialogPersistence.loadActiveCallees(args.dlg.id, args.dlg.status);
+    const suspension = await args.dlg.getSuspensionStatus();
+    const payload = {
+        kind: 'kernel_driver_unexpected_idle_after_tool_round',
+        capturedAt,
+        rtwsRootAbs: process.cwd(),
+        dialog: {
+            rootId: args.dlg.id.rootId,
+            selfId: args.dlg.id.selfId,
+            value: args.dlg.id.valueOf(),
+            agentId: args.dlg.agentId,
+            status: args.dlg.status,
+            currentCourse: args.dlg.currentCourse,
+            activeGenCourse: args.dlg.activeGenCourseOrUndefined ?? null,
+            activeGenSeq: args.dlg.activeGenSeqOrUndefined ?? null,
+            hasQueuedPrompt: args.dlg.hasQueuedPrompt(),
+            queuedPrompt: args.dlg.peekQueuedPrompt() ?? null,
+        },
+        finalDisplayState: args.finalDisplayState,
+        latest: args.latest,
+        activeCallees,
+        suspension,
+        diagnostics,
+        callstack: new Error('kernel-driver unexpected idle after tool round').stack ?? null,
+    };
+    await promises_1.default.mkdir(debugDir, { recursive: true });
+    await promises_1.default.writeFile(node_path_1.default.join(debugDir, fileName), `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+}
+async function maybeWriteIdleWithActiveReplyObligationDebugDump(args) {
+    if (args.finalDisplayState.kind !== 'idle_waiting_user') {
+        return;
+    }
+    if (args.activeReplyObligation === undefined) {
+        return;
+    }
+    const capturedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+    const debugDir = node_path_1.default.resolve(process.cwd(), '.dislogs', 'debug');
+    const fileName = [
+        'kernel-driver-idle-with-active-reply-obligation',
+        sanitizeDebugFileSegment(capturedAt),
+        sanitizeDebugFileSegment(args.dlg.id.rootId),
+        sanitizeDebugFileSegment(args.dlg.id.selfId),
+        sanitizeDebugFileSegment(args.activeReplyObligation.targetCallId),
+        `${(0, id_1.generateShortId)()}.json`,
+    ].join('-');
+    const activeCallees = await persistence_1.DialogPersistence.loadActiveCallees(args.dlg.id, args.dlg.status);
+    const suspension = await args.dlg.getSuspensionStatus();
+    const payload = {
+        kind: 'kernel_driver_idle_with_active_reply_obligation',
+        capturedAt,
+        rtwsRootAbs: process.cwd(),
+        dialog: {
+            rootId: args.dlg.id.rootId,
+            selfId: args.dlg.id.selfId,
+            value: args.dlg.id.valueOf(),
+            agentId: args.dlg.agentId,
+            status: args.dlg.status,
+            currentCourse: args.dlg.currentCourse,
+            activeGenCourse: args.dlg.activeGenCourseOrUndefined ?? null,
+            activeGenSeq: args.dlg.activeGenSeqOrUndefined ?? null,
+            hasQueuedPrompt: args.dlg.hasQueuedPrompt(),
+            queuedPrompt: args.dlg.peekQueuedPrompt() ?? null,
+        },
+        finalDisplayState: args.finalDisplayState,
+        latest: args.latest,
+        activeCallees,
+        suspension,
+        activeReplyObligation: args.activeReplyObligation,
+        callstack: new Error('kernel-driver idle with active reply obligation').stack ?? null,
+    };
+    await promises_1.default.mkdir(debugDir, { recursive: true });
+    await promises_1.default.writeFile(node_path_1.default.join(debugDir, fileName), `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+}
 async function upsertImmediateFollowupTrigger(args) {
     const reasons = [];
     if (args.routed.immediateFollowupCallIds.length > 0) {
@@ -1856,6 +2022,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
     let lastBusinessContinuation = { kind: 'none' };
     let fbrConclusion;
     let pubRemindersVer = dlg.remindersVer;
+    let lastToolRoundStopDiagnostics;
     let pendingPrompt = humanPrompt;
     let resolvingImmediateToolResultForUserPrompt = false;
     let resolvingImmediateToolResultUserPromptMsgId;
@@ -2088,6 +2255,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     }
                 }
                 const acceptedTriggers = await dlg.notifyGeneratingStart(currentPrompt?.msgId);
+                lastToolRoundStopDiagnostics = undefined;
                 for (const trigger of acceptedTriggers) {
                     if (trigger.kind === 'followup' && trigger.continuation !== undefined) {
                         if (currentBusinessContinuation.kind !== 'none' &&
@@ -2119,9 +2287,11 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             prompt: currentPrompt,
                             language: promptLanguage,
                         });
-                        if (currentPrompt.origin === 'user' &&
+                        const deferredReplyReassertionDirective = replyGuidance.deferredReplyReassertionDirective;
+                        const currentPromptIsUserInterjection = currentPrompt.origin === 'user' &&
                             replyGuidance.suppressInterDialogReplyGuidance &&
-                            replyGuidance.deferredReplyReassertionDirective !== undefined) {
+                            deferredReplyReassertionDirective !== undefined;
+                        if (currentPromptIsUserInterjection) {
                             // WARNING:
                             // User interjection suppression is a reversible state transition, not a one-shot
                             // latch. The normal cycle is:
@@ -2135,7 +2305,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             const existingDeferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(dlg.id, dlg.status);
                             const nextDeferredReplyReassertion = {
                                 reason: 'user_interjection_with_parked_original_task',
-                                directive: replyGuidance.deferredReplyReassertionDirective,
+                                directive: deferredReplyReassertionDirective,
                             };
                             const mustRearmDeferredReplyReassertion = existingDeferredReplyReassertion === undefined ||
                                 existingDeferredReplyReassertion.resumeGuideSurfaced === true ||
@@ -2169,7 +2339,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         if (replyGuidance.promptContent === undefined) {
                             throw new Error(`kernel-driver reply guidance invariant violation: missing prompt content for dialog=${dlg.id.valueOf()} msgId=${currentPrompt.msgId}`);
                         }
-                        if (currentPrompt.origin === 'user' && !replyGuidance.isQ4HAnswerPrompt) {
+                        if (currentPromptIsUserInterjection) {
                             await persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
                                 kind: 'patch',
                                 patch: {
@@ -2951,6 +3121,14 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         break;
                     }
                     if (routed.shouldStopAfterReplyTool) {
+                        lastToolRoundStopDiagnostics = buildToolRoundStopDiagnostics({
+                            dlg,
+                            streamedFuncCalls,
+                            routed,
+                            lastBusinessContinuation,
+                            shouldStartImmediatePostToolGeneration: false,
+                            stopReason: 'reply_tool',
+                        });
                         log_1.log.debug('kernel-driver stop round after explicit replyTellask* tool', undefined, {
                             dialogId: dlg.id.valueOf(),
                             toolNames: streamedFuncCalls
@@ -2962,6 +3140,17 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         break;
                     }
                     if (dlg.hasQueuedPrompt()) {
+                        lastToolRoundStopDiagnostics = buildToolRoundStopDiagnostics({
+                            dlg,
+                            streamedFuncCalls,
+                            routed,
+                            lastBusinessContinuation,
+                            shouldStartImmediatePostToolGeneration: false,
+                            stopReason: 'queued_prompt_after_tool_round',
+                            queuedPromptAfterToolRound: true,
+                            remindersVer: dlg.remindersVer,
+                            pubRemindersVer,
+                        });
                         break;
                     }
                     if (dlg.remindersVer > pubRemindersVer) {
@@ -2972,6 +3161,18 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     // background work, so only Q4H can suspend this same-drive continuation point.
                     const suspensionAfterToolRound = await dlg.getSuspensionStatus();
                     if (!suspensionAfterToolRound.canDrive) {
+                        lastToolRoundStopDiagnostics = buildToolRoundStopDiagnostics({
+                            dlg,
+                            streamedFuncCalls,
+                            routed,
+                            lastBusinessContinuation,
+                            shouldStartImmediatePostToolGeneration: false,
+                            stopReason: 'suspended_after_tool_round',
+                            suspensionAfterToolRound,
+                            queuedPromptAfterToolRound: dlg.hasQueuedPrompt(),
+                            remindersVer: dlg.remindersVer,
+                            pubRemindersVer,
+                        });
                         await preserveDiligenceBudgetAcrossQ4H(dlg);
                         break;
                     }
@@ -2984,6 +3185,18 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         invalidFuncCallCount > 0;
                     if (!shouldStartImmediatePostToolGeneration) {
                         if (routed.shouldStopAfterPendingTellaskWait) {
+                            lastToolRoundStopDiagnostics = buildToolRoundStopDiagnostics({
+                                dlg,
+                                streamedFuncCalls,
+                                routed,
+                                lastBusinessContinuation,
+                                shouldStartImmediatePostToolGeneration,
+                                stopReason: 'pending_tellask_wait',
+                                suspensionAfterToolRound,
+                                queuedPromptAfterToolRound: dlg.hasQueuedPrompt(),
+                                remindersVer: dlg.remindersVer,
+                                pubRemindersVer,
+                            });
                             log_1.log.debug('kernel-driver stop round after pending tellask wait boundary', undefined, {
                                 dialogId: dlg.id.valueOf(),
                                 rootId: dlg.id.rootId,
@@ -3012,6 +3225,18 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             pendingPrompt = next.prompt;
                             continue;
                         }
+                        lastToolRoundStopDiagnostics = buildToolRoundStopDiagnostics({
+                            dlg,
+                            streamedFuncCalls,
+                            routed,
+                            lastBusinessContinuation,
+                            shouldStartImmediatePostToolGeneration,
+                            stopReason: 'no_post_tool_continuation',
+                            suspensionAfterToolRound,
+                            queuedPromptAfterToolRound: dlg.hasQueuedPrompt(),
+                            remindersVer: dlg.remindersVer,
+                            pubRemindersVer,
+                        });
                         break;
                     }
                     if (shouldStartImmediatePostToolGeneration) {
@@ -3180,6 +3405,30 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                 reason: 'newer_generation_active',
             });
         }
+        const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dlg.id, dlg.status);
+        try {
+            await maybeWriteUnexpectedIdleAfterToolRoundDebugDump({
+                dlg,
+                finalDisplayState,
+                latest,
+                diagnostics: lastToolRoundStopDiagnostics,
+            });
+            await maybeWriteIdleWithActiveReplyObligationDebugDump({
+                dlg,
+                finalDisplayState,
+                latest,
+                activeReplyObligation,
+            });
+        }
+        catch (debugErr) {
+            log_1.log.warn('kernel-driver failed to write idle debug dump', debugErr, {
+                dialogId: dlg.id.valueOf(),
+                rootId: dlg.id.rootId,
+                selfId: dlg.id.selfId,
+                course: lastToolRoundStopDiagnostics?.course ?? null,
+                genseq: lastToolRoundStopDiagnostics?.genseq ?? null,
+            });
+        }
     }
     catch (err) {
         log_1.log.warn('kernel-driver failed to re-check displayState before finalizing', err, {

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

@@ -294,15 +294,6 @@ async function loadFreshSuspensionStatusFromPersistence(dialog) {
         canDrive: !hasQ4H,
     };
 }
-function buildDisplayStateFromSuspensionStatus(args) {
-    if (args.q4h && args.backgroundCalleeDialogs) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
-    }
-    if (args.q4h) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
-    }
-    return { kind: 'idle_waiting_user' };
-}
 async function loadPendingDiagnosticsSnapshot(args) {
     const callerDialogIdObj = new dialog_1.DialogID(args.callerDialogId, args.rootId);
     try {
@@ -413,13 +404,23 @@ async function clearStaleSideDialogRunControlForFinalResponse(args) {
             previousNextStepTriggerCount: latest?.nextStep.triggers.length ?? null,
         };
     }
+    const finalResponseCallId = latest.sideDialogFinalResponse?.callId.trim();
+    if (finalResponseCallId !== undefined && finalResponseCallId !== '') {
+        const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(args.dialog.id, args.dialog.status);
+        if (activeReplyObligation?.targetCallId.trim() === finalResponseCallId) {
+            await persistence_1.DialogPersistence.setActiveTellaskReplyObligation(args.dialog.id, undefined, args.dialog.status);
+        }
+    }
+    const displayState = await (0, dialog_display_state_1.computeIdleDisplayState)(args.dialog);
     await persistence_1.DialogPersistence.mutateDialogLatest(args.dialog.id, () => ({
         kind: 'patch',
         patch: {
             generating: false,
             nextStep: (0, dialog_latest_state_1.createEmptyDialogNextStepState)(),
-            displayState: { kind: 'idle_waiting_user' },
-            executionMarker: undefined,
+            displayState,
+            executionMarker: displayState.kind === 'stopped'
+                ? { kind: 'interrupted', reason: displayState.reason }
+                : undefined,
         },
     }), args.dialog.status);
     await persistence_1.DialogPersistence.removeWakeQueueEntriesForDialog(args.dialog.id, args.dialog.status);
@@ -1420,10 +1421,7 @@ async function executeDriveRound(args) {
             const queuedSideDialogPromptCanResume = dialog instanceof dialog_1.SideDialog && queuedPrompt !== undefined;
             if (!suspension.canDrive && !queuedSideDialogPromptCanResume) {
                 if (resumeFromInterjectionPause) {
-                    const restoredState = buildDisplayStateFromSuspensionStatus({
-                        q4h: suspension.q4h,
-                        backgroundCalleeDialogs: suspension.backgroundCalleeDialogs,
-                    });
+                    const restoredState = await (0, dialog_display_state_1.computeIdleDisplayState)(dialog);
                     await (0, dialog_display_state_1.setDialogDisplayState)(dialog.id, restoredState);
                     await maybeSurfaceDeferredReplyReassertionGuideForBlockedContinue(dialog);
                     log_1.log.debug('kernel-driver continue after interjection pause restored true suspended state from fresh persistence facts', undefined, {

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

@@ -6,6 +6,7 @@ exports.supplySideDialogResponseToAssignedAskerIfPendingV2 = supplySideDialogRes
 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_display_state_1 = require("../../dialog-display-state");
 const dialog_global_registry_1 = require("../../dialog-global-registry");
 const dialog_instance_registry_1 = require("../../dialog-instance-registry");
 const log_1 = require("../../log");
@@ -378,6 +379,18 @@ async function supplyResponseToAskerDialog(args) {
                     },
                 },
             }), callerDialog.status);
+            if (maybeSideDialog) {
+                const displayState = await (0, dialog_display_state_1.computeIdleDisplayState)(maybeSideDialog);
+                await persistence_1.DialogPersistence.mutateDialogLatest(sideDialogId, () => ({
+                    kind: 'patch',
+                    patch: {
+                        displayState,
+                        executionMarker: displayState.kind === 'stopped'
+                            ? { kind: 'interrupted', reason: displayState.reason }
+                            : undefined,
+                    },
+                }), callerDialog.status);
+            }
         }
         await syncPendingTellaskReminderBestEffort(callerDialog, 'kernel-driver:supplyResponseToAskerDialog');
         const responseRouteRef = calleeResponseRef;

package/dist/persistence.js

@@ -252,12 +252,6 @@ function hasActiveReplyObligationInAskerStackState(state) {
     const top = state?.askerStack[state.askerStack.length - 1];
     return top?.tellaskReplyObligation !== undefined;
 }
-function q4hSuspensionDisplayState(hasQ4H) {
-    if (hasQ4H) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
-    }
-    return undefined;
-}
 async function normalizeSideDialogIdleWhileReplyObligationPending(dialogId, status, previous, latest, askerStackState, context) {
     if (status !== 'running' || dialogId.selfId === dialogId.rootId) {
         return latest;
@@ -268,12 +262,13 @@ async function normalizeSideDialogIdleWhileReplyObligationPending(dialogId, stat
     if (!hasActiveReplyObligationInAskerStackState(askerStackState)) {
         return latest;
     }
-    const q4hSuspensionState = q4hSuspensionDisplayState((await DialogPersistence.loadQuestions4HumanState(dialogId, status)).length > 0);
-    if (!q4hSuspensionState) {
-        return latest;
-    }
     const top = askerStackState?.askerStack[askerStackState.askerStack.length - 1];
-    log_1.log.debug('Dialog latest projection invariant warning: sideDialog awaiting Q4H attempted to enter idle displayState; healing from persistence facts', undefined, {
+    const healedDisplayState = {
+        kind: 'stopped',
+        reason: { kind: 'pending_reply_obligation' },
+        continueEnabled: true,
+    };
+    log_1.log.debug('Dialog latest projection invariant warning: sideDialog with active reply obligation attempted to enter idle displayState; healing from persistence facts', undefined, {
         trigger: context.trigger,
         mutationKind: context.mutationKind,
         latestSource: context.latestSource,
@@ -284,20 +279,20 @@ async function normalizeSideDialogIdleWhileReplyObligationPending(dialogId, stat
         selfId: dialogId.selfId,
         status,
         targetCallId: top?.tellaskReplyObligation?.targetCallId ?? null,
-        suspendedByQ4H: q4hSuspensionState?.kind === 'blocked',
+        targetDialogId: top?.tellaskReplyObligation?.targetDialogId ?? null,
         before: summarizeLatestProjectionState(previous),
         afterBeforeHealing: summarizeLatestProjectionState(latest),
         healedTo: {
-            displayState: q4hSuspensionState,
-            executionMarker: undefined,
+            displayState: healedDisplayState,
+            executionMarker: { kind: 'interrupted', reason: healedDisplayState.reason },
         },
         callStack: captureInvariantWarningStack(),
     });
     return {
         ...latest,
         lastModified: (0, time_1.formatUnifiedTimestamp)(new Date()),
-        displayState: q4hSuspensionState,
-        executionMarker: undefined,
+        displayState: healedDisplayState,
+        executionMarker: { kind: 'interrupted', reason: healedDisplayState.reason },
     };
 }
 const quarantiningMainDialogs = new Set();
@@ -2615,7 +2610,9 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         };
         await this.appendEvent(askerDialog, callerCourse, sideDialogCreatedRecord);
         const initialSideDialogDisplayState = {
-            kind: 'idle_waiting_user',
+            kind: 'stopped',
+            reason: { kind: 'pending_reply_obligation' },
+            continueEnabled: true,
         };
         // Initialize latest.yaml via the mutation API (write-back will flush).
         await DialogPersistence.mutateDialogLatest(sideDialogId, () => ({
@@ -2631,6 +2628,10 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 tellaskCalls: (0, dialog_latest_state_1.createEmptyDialogTellaskCallState)(),
                 tellaskResults: (0, dialog_latest_state_1.createEmptyDialogTellaskResultState)(),
                 displayState: initialSideDialogDisplayState,
+                executionMarker: {
+                    kind: 'interrupted',
+                    reason: initialSideDialogDisplayState.reason,
+                },
                 disableDiligencePush: false,
             },
         }));