dominds 1.25.9 → 1.25.11

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

@@ -645,6 +645,7 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
     {
         type: 'func',
         name: 'replyTellask',
+        followupMode: 'deferred',
         description: 'Deliver final reply for the current tellask session.',
         parameters: {
             type: 'object',
@@ -661,6 +662,7 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
     {
         type: 'func',
         name: 'replyTellaskSessionless',
+        followupMode: 'deferred',
         description: 'Deliver final reply for the current one-shot tellask.',
         parameters: {
             type: 'object',
@@ -677,6 +679,7 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
     {
         type: 'func',
         name: 'replyTellaskBack',
+        followupMode: 'deferred',
         description: 'Deliver final reply for the current tellaskBack request.',
         parameters: {
             type: 'object',
@@ -1228,6 +1231,49 @@ async function persistInvalidFuncCallRuntimeGuide(args) {
     });
     await persistAndPostRuntimeGuide(dlg, content);
 }
+function isQueuedNewCourseRuntimePrompt(prompt) {
+    return (prompt?.kind === 'new_course_runtime_guide' ||
+        prompt?.kind === 'new_course_runtime_reply' ||
+        prompt?.kind === 'new_course_runtime_sideDialog');
+}
+function queuedNewCourseRuntimePromptToKernelPrompt(prompt) {
+    const common = {
+        content: prompt.prompt,
+        msgId: prompt.msgId,
+        grammar: prompt.grammar ?? 'markdown',
+        userLanguageCode: prompt.userLanguageCode,
+        runControl: prompt.runControl,
+        origin: 'runtime',
+        ...(prompt.skipTaskdoc === undefined ? {} : { skipTaskdoc: prompt.skipTaskdoc }),
+    };
+    switch (prompt.kind) {
+        case 'new_course_runtime_guide':
+            return common;
+        case 'new_course_runtime_reply':
+            return {
+                ...common,
+                tellaskReplyDirective: prompt.tellaskReplyDirective,
+            };
+        case 'new_course_runtime_sideDialog':
+            return {
+                ...common,
+                tellaskReplyDirective: prompt.tellaskReplyDirective,
+                calleeDialogReplyTarget: prompt.calleeDialogReplyTarget,
+            };
+    }
+}
+async function consumeQueuedNewCourseRuntimePromptForSameDrive(dlg) {
+    const queuedPrompt = dlg.peekQueuedPrompt();
+    if (!isQueuedNewCourseRuntimePrompt(queuedPrompt)) {
+        return undefined;
+    }
+    const consumedPrompt = dlg.takeQueuedPrompt();
+    if (!consumedPrompt || consumedPrompt.msgId !== queuedPrompt.msgId) {
+        throw new Error(`queued new-course prompt invariant violation: expected queued prompt ${queuedPrompt.msgId} before same-drive continuation`);
+    }
+    await persistence_1.DialogPersistence.clearPendingRuntimePrompt(dlg.id, queuedPrompt.msgId, dlg.status);
+    return queuedNewCourseRuntimePromptToKernelPrompt(queuedPrompt);
+}
 function resolveFuncToolFollowupMode(tool) {
     return tool?.followupMode ?? 'immediate';
 }
@@ -1237,6 +1283,7 @@ function summarizeRoutedFunctionResult(routed) {
         hasImmediateTellaskOutputs: routed.hasImmediateTellaskOutputs,
         immediateFollowupCallIds: routed.immediateFollowupCallIds,
         immediateTellaskOutputCallIds: routed.immediateTellaskOutputCallIds,
+        invalidTellaskCallIds: routed.invalidTellaskCallIds,
         shouldStopAfterReplyTool: routed.shouldStopAfterReplyTool,
         shouldStopAfterPendingTellaskWait: routed.shouldStopAfterPendingTellaskWait,
         pairedMessageTypes: routed.pairedMessages.map((msg) => msg.type),
@@ -1347,6 +1394,54 @@ async function maybeWriteUnexpectedIdleAfterToolRoundDebugDump(args) {
     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 writeMissingImmediateFollowupTriggerDebugDump(args) {
+    const capturedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+    const debugDir = node_path_1.default.resolve(process.cwd(), '.dialogs', 'debug');
+    const trigger = args.expectation.trigger;
+    const fileName = [
+        'kernel-driver-missing-immediate-followup-trigger',
+        sanitizeDebugFileSegment(capturedAt),
+        sanitizeDebugFileSegment(args.dlg.id.rootId),
+        sanitizeDebugFileSegment(args.dlg.id.selfId),
+        sanitizeDebugFileSegment(trigger.triggerId),
+        `${(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: args.repairOutcome === 'repaired'
+            ? 'kernel_driver_missing_immediate_followup_trigger_repaired'
+            : 'kernel_driver_missing_immediate_followup_trigger_repair_failed',
+        capturedAt,
+        rtwsRootAbs: process.cwd(),
+        repairOutcome: args.repairOutcome,
+        checkPoint: args.checkPoint,
+        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,
+        },
+        expectation: args.expectation,
+        latestBeforeRepair: args.latestBeforeRepair,
+        latestAfterRepair: args.latestAfterRepair,
+        activeCallees,
+        suspension,
+        callstack: new Error(args.repairOutcome === 'repaired'
+            ? 'kernel-driver missing immediate followup trigger repaired'
+            : 'kernel-driver missing immediate followup trigger repair failed').stack ?? null,
+    };
+    await promises_1.default.mkdir(debugDir, { recursive: true });
+    const debugPath = node_path_1.default.join(debugDir, fileName);
+    await promises_1.default.writeFile(debugPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+    return debugPath;
+}
 async function maybeWriteIdleWithActiveReplyObligationDebugDump(args) {
     if (args.finalDisplayState.kind !== 'idle_waiting_user') {
         return;
@@ -1392,7 +1487,7 @@ async function maybeWriteIdleWithActiveReplyObligationDebugDump(args) {
     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) {
+function buildImmediateFollowupTriggerExpectation(args) {
     const reasons = [];
     if (args.routed.immediateFollowupCallIds.length > 0) {
         reasons.push({
@@ -1407,22 +1502,30 @@ async function upsertImmediateFollowupTrigger(args) {
             replyCallId: args.routed.immediateTellaskOutputCallIds[0],
         });
     }
+    const invalidRecoveryCallIds = new Set(args.routed.invalidTellaskCallIds);
     if (args.invalidFuncCallCount > 0) {
-        const callIds = args.streamedFuncCalls.map((call) => call.id);
-        // Invalid provider tool payloads are a same-turn recovery fact, not a generic retry hint.
-        // Keep them inside the follow-up trigger so the next generation can repair the current turn
-        // immediately, while the invalid payload itself stays loud in runtime guides and logs.
+        for (const call of args.streamedFuncCalls) {
+            invalidRecoveryCallIds.add(call.id);
+        }
+        if (args.streamedFuncCalls.length === 0) {
+            invalidRecoveryCallIds.add(`invalid-tool:${args.invalidFuncCallCount}`);
+        }
+    }
+    if (invalidRecoveryCallIds.size > 0) {
+        // Invalid provider tool payloads and invalid tellask specials are same-turn recovery facts,
+        // not generic retry hints. Keep them inside the follow-up trigger so the next generation can
+        // repair the current turn immediately, while the invalid payload itself stays loud.
         reasons.push({
             kind: 'invalid_tool_recovery',
-            callIds: callIds.length > 0 ? callIds : [`invalid-tool:${args.invalidFuncCallCount}`],
+            callIds: [...invalidRecoveryCallIds],
         });
     }
     if (reasons.length === 0) {
-        return;
+        return undefined;
     }
     const course = args.dlg.activeGenCourseOrUndefined ?? args.dlg.currentCourse;
     const genseq = args.dlg.activeGenSeq;
-    await persistence_1.DialogPersistence.upsertNextStepTrigger(args.dlg.id, {
+    const trigger = {
         triggerId: `followup:c${String(course)}:g${String(genseq)}`,
         kind: 'followup',
         sourceGeneration: {
@@ -1431,7 +1534,74 @@ async function upsertImmediateFollowupTrigger(args) {
         },
         reasons,
         continuation: args.continuation,
+    };
+    return {
+        trigger,
+        callIds: args.streamedFuncCalls.map((call) => call.id),
+        callNames: args.streamedFuncCalls.map((call) => call.name),
+        routed: summarizeRoutedFunctionResult(args.routed),
+        continuation: args.continuation,
+        invalidFuncCallCount: args.invalidFuncCallCount,
+    };
+}
+async function upsertImmediateFollowupTrigger(dlg, expectation) {
+    await persistence_1.DialogPersistence.upsertNextStepTrigger(dlg.id, expectation.trigger, dlg.status);
+}
+function hasExpectedImmediateFollowupTrigger(latest, expectation) {
+    return (latest?.nextStep.triggers.some((trigger) => trigger.kind === 'followup' && trigger.triggerId === expectation.trigger.triggerId) === true);
+}
+async function repairMissingImmediateFollowupTrigger(args) {
+    const expectation = args.expectation;
+    if (expectation === undefined) {
+        return;
+    }
+    const latestBeforeRepair = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
+    if (hasExpectedImmediateFollowupTrigger(latestBeforeRepair, expectation)) {
+        return;
+    }
+    await persistence_1.DialogPersistence.upsertNextStepTrigger(args.dlg.id, expectation.trigger, args.dlg.status);
+    const latestAfterRepair = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
+    const repairSucceeded = hasExpectedImmediateFollowupTrigger(latestAfterRepair, expectation);
+    const repairOutcome = repairSucceeded
+        ? 'repaired'
+        : 'repair_failed';
+    const debugPath = await writeMissingImmediateFollowupTriggerDebugDump({
+        dlg: args.dlg,
+        expectation,
+        latestBeforeRepair,
+        latestAfterRepair,
+        checkPoint: args.checkPoint,
+        repairOutcome,
+    });
+    const message = `${repairSucceeded ? 'Repaired' : 'Failed to repair'} missing immediate follow-up trigger after function results ` +
+        `(triggerId=${expectation.trigger.triggerId}, checkPoint=${args.checkPoint})`;
+    log_1.log.error(message, new Error(`kernel_driver_missing_immediate_followup_trigger_${repairOutcome}`), {
+        rootId: args.dlg.id.rootId,
+        selfId: args.dlg.id.selfId,
+        dialogId: args.dlg.id.valueOf(),
+        status: args.dlg.status,
+        triggerId: expectation.trigger.triggerId,
+        checkPoint: args.checkPoint,
+        repairSucceeded,
+        sourceGeneration: expectation.trigger.sourceGeneration,
+        reasonKinds: expectation.trigger.reasons.map((reason) => reason.kind),
+        callIds: expectation.callIds,
+        callNames: expectation.callNames,
+        invalidFuncCallCount: expectation.invalidFuncCallCount,
+        continuation: expectation.continuation,
+        routed: expectation.routed,
+        latestBeforeRepairNextStep: latestBeforeRepair?.nextStep ?? null,
+        latestBeforeRepairGenerationRunState: latestBeforeRepair?.generationRunState ?? null,
+        latestBeforeRepairDisplayState: latestBeforeRepair?.displayState ?? null,
+        latestAfterRepairNextStep: latestAfterRepair?.nextStep ?? null,
+        latestAfterRepairGenerationRunState: latestAfterRepair?.generationRunState ?? null,
+        latestAfterRepairDisplayState: latestAfterRepair?.displayState ?? null,
+        debugPath,
     });
+    await args.dlg.streamError(`${message}; debug=${debugPath}`);
+    if (!repairSucceeded) {
+        throw new Error(`${message}; debug=${debugPath}`);
+    }
 }
 function shouldImmediatelyFollowUpSuccessfulToolResult(tool) {
     return resolveFuncToolFollowupMode(tool) === 'immediate';
@@ -1708,6 +1878,7 @@ async function executeFunctionRound(args) {
             hasImmediateTellaskOutputs: false,
             immediateFollowupCallIds: [],
             immediateTellaskOutputCallIds: [],
+            invalidTellaskCallIds: [],
             shouldStopAfterReplyTool: false,
             shouldStopAfterPendingTellaskWait: false,
             pairedMessages: [],
@@ -1818,6 +1989,7 @@ async function executeFunctionRound(args) {
         hasImmediateTellaskOutputs: tellaskRound.hasImmediateTellaskOutputs,
         immediateFollowupCallIds,
         immediateTellaskOutputCallIds: tellaskRound.immediateTellaskOutputCallIds,
+        invalidTellaskCallIds: tellaskRound.invalidTellaskCallIds,
         shouldStopAfterReplyTool: tellaskRound.shouldStopAfterReplyTool,
         shouldStopAfterPendingTellaskWait: tellaskRound.shouldStopAfterPendingTellaskWait,
         pairedMessages,
@@ -2269,6 +2441,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                 }
                 lastBusinessContinuation = currentBusinessContinuation;
                 let generationBodyError;
+                let immediateFollowupTriggerExpectation;
                 const q4hAnswerCallId = normalizeQ4HAnswerCallId(currentPrompt?.q4hAnswerCallId);
                 const isQ4HAnswerPrompt = q4hAnswerCallId !== undefined;
                 try {
@@ -3139,13 +3312,44 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         });
                         break;
                     }
+                    const queuedNewCoursePrompt = await consumeQueuedNewCourseRuntimePromptForSameDrive(dlg);
+                    if (queuedNewCoursePrompt !== undefined) {
+                        pendingPrompt = queuedNewCoursePrompt;
+                        skipTaskdocForThisDrive = false;
+                        continue;
+                    }
+                    // Start an immediate post-tool generation only when this round produced tool outputs that
+                    // warrant same-drive LLM reaction right away. Provider-native side-channel UI events are
+                    // meaningful output, but they are not transcript/context inputs and therefore must not
+                    // trigger another immediate generation round by themselves.
+                    const shouldStartImmediatePostToolGeneration = routed.hasImmediateFollowupToolCalls ||
+                        routed.hasImmediateTellaskOutputs ||
+                        invalidFuncCallCount > 0;
+                    if (shouldStartImmediatePostToolGeneration) {
+                        const expectation = buildImmediateFollowupTriggerExpectation({
+                            dlg,
+                            routed,
+                            invalidFuncCallCount,
+                            streamedFuncCalls,
+                            continuation: currentBusinessContinuation,
+                        });
+                        if (expectation === undefined) {
+                            throw new Error(`Immediate follow-up trigger invariant violation: expected trigger reasons missing ` +
+                                `(dialog=${dlg.id.valueOf()}, course=${String(dlg.activeGenCourseOrUndefined ?? dlg.currentCourse)}, ` +
+                                `genseq=${String(dlg.activeGenSeq)}, immediateToolCalls=${String(routed.hasImmediateFollowupToolCalls)}, ` +
+                                `immediateTellaskOutputs=${String(routed.hasImmediateTellaskOutputs)}, ` +
+                                `invalidFuncCallCount=${String(invalidFuncCallCount)})`);
+                        }
+                        immediateFollowupTriggerExpectation = expectation;
+                        await upsertImmediateFollowupTrigger(dlg, immediateFollowupTriggerExpectation);
+                    }
                     if (dlg.hasQueuedPrompt()) {
                         lastToolRoundStopDiagnostics = buildToolRoundStopDiagnostics({
                             dlg,
                             streamedFuncCalls,
                             routed,
                             lastBusinessContinuation,
-                            shouldStartImmediatePostToolGeneration: false,
+                            shouldStartImmediatePostToolGeneration,
                             stopReason: 'queued_prompt_after_tool_round',
                             queuedPromptAfterToolRound: true,
                             remindersVer: dlg.remindersVer,
@@ -3166,7 +3370,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             streamedFuncCalls,
                             routed,
                             lastBusinessContinuation,
-                            shouldStartImmediatePostToolGeneration: false,
+                            shouldStartImmediatePostToolGeneration,
                             stopReason: 'suspended_after_tool_round',
                             suspensionAfterToolRound,
                             queuedPromptAfterToolRound: dlg.hasQueuedPrompt(),
@@ -3176,13 +3380,6 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         await preserveDiligenceBudgetAcrossQ4H(dlg);
                         break;
                     }
-                    // Start an immediate post-tool generation only when this round produced tool outputs that
-                    // warrant same-drive LLM reaction right away. Provider-native side-channel UI events are
-                    // meaningful output, but they are not transcript/context inputs and therefore must not
-                    // trigger another immediate generation round by themselves.
-                    const shouldStartImmediatePostToolGeneration = routed.hasImmediateFollowupToolCalls ||
-                        routed.hasImmediateTellaskOutputs ||
-                        invalidFuncCallCount > 0;
                     if (!shouldStartImmediatePostToolGeneration) {
                         if (routed.shouldStopAfterPendingTellaskWait) {
                             lastToolRoundStopDiagnostics = buildToolRoundStopDiagnostics({
@@ -3239,23 +3436,19 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         });
                         break;
                     }
-                    if (shouldStartImmediatePostToolGeneration) {
-                        await upsertImmediateFollowupTrigger({
-                            dlg,
-                            routed,
-                            invalidFuncCallCount,
-                            streamedFuncCalls,
-                            continuation: currentBusinessContinuation,
-                        });
-                        resolvingImmediateToolResultForUserPrompt =
-                            currentGenerationBelongsToUserPrompt ||
-                                currentGenerationBelongsToUserToolChain ||
-                                isUserOriginPrompt(currentPrompt);
-                        resolvingImmediateToolResultUserPromptMsgId = resolvingImmediateToolResultForUserPrompt
-                            ? currentUserPromptMsgId
-                            : undefined;
-                        continue;
-                    }
+                    await repairMissingImmediateFollowupTrigger({
+                        dlg,
+                        expectation: immediateFollowupTriggerExpectation,
+                        checkPoint: 'before_immediate_post_tool_generation_continue',
+                    });
+                    resolvingImmediateToolResultForUserPrompt =
+                        currentGenerationBelongsToUserPrompt ||
+                            currentGenerationBelongsToUserToolChain ||
+                            isUserOriginPrompt(currentPrompt);
+                    resolvingImmediateToolResultUserPromptMsgId = resolvingImmediateToolResultForUserPrompt
+                        ? currentUserPromptMsgId
+                        : undefined;
+                    continue;
                 }
                 catch (err) {
                     generationBodyError = err;
@@ -3263,6 +3456,13 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                 }
                 finally {
                     try {
+                        if (generationBodyError === undefined) {
+                            await repairMissingImmediateFollowupTrigger({
+                                dlg,
+                                expectation: immediateFollowupTriggerExpectation,
+                                checkPoint: 'before_notify_generating_finish',
+                            });
+                        }
                         await dlg.notifyGeneratingFinish(contextHealthForGen, llmGenModelForGen);
                     }
                     catch (finishErr) {

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

@@ -48,6 +48,7 @@ function buildFbrConclusionTools(language) {
         {
             type: 'func',
             name: exports.FBR_LOW_NOISE_CONCLUSION_TOOL_NAME,
+            followupMode: 'deferred',
             description: buildFbrConclusionToolDescription({ language, kind: 'low_noise' }),
             parameters: {
                 type: 'object',
@@ -67,6 +68,7 @@ function buildFbrConclusionTools(language) {
         {
             type: 'func',
             name: exports.FBR_UNREASONABLE_SITUATION_TOOL_NAME,
+            followupMode: 'deferred',
             description: buildFbrConclusionToolDescription({ language, kind: 'unreasonable' }),
             parameters: {
                 type: 'object',

package/dist/llm/kernel-driver/tellask-special.d.ts

@@ -121,6 +121,7 @@ export type TellaskFunctionRoundResult = Readonly<{
     hasInvalidTellaskCalls: boolean;
     hasImmediateTellaskOutputs: boolean;
     immediateTellaskOutputCallIds: readonly string[];
+    invalidTellaskCallIds: readonly string[];
     shouldStopAfterReplyTool: boolean;
     shouldStopAfterPendingTellaskWait: boolean;
 }>;

package/dist/llm/kernel-driver/tellask-special.js

@@ -2396,6 +2396,10 @@ async function processTellaskFunctionRound(args) {
             const result = output;
             tellaskFuncResultByCallId.set(result.id, result);
             tellaskFuncResults.push(result);
+            const originatingCall = specialCallById.get(result.id);
+            if (originatingCall !== undefined && isReplyTellaskCallName(originatingCall.callName)) {
+                continue;
+            }
             hasImmediateTellaskOutputs = true;
             immediateTellaskOutputCallIds.push(result.id);
             continue;
@@ -2460,7 +2464,8 @@ async function processTellaskFunctionRound(args) {
         hasInvalidTellaskCalls: orderedInvalidCalls.length > 0,
         hasImmediateTellaskOutputs,
         immediateTellaskOutputCallIds,
-        shouldStopAfterReplyTool: orderedInvalidCalls.length === 0 && tellaskExecution.successfulReplyCallIds.length > 0,
+        invalidTellaskCallIds: orderedInvalidCalls.map((issue) => issue.originalCall.id),
+        shouldStopAfterReplyTool: tellaskExecution.successfulReplyCallIds.length > 0,
         shouldStopAfterPendingTellaskWait,
     };
 }

package/dist/server/dominds-self-update.d.ts

@@ -5,6 +5,7 @@ export declare function configureDomindsSelfUpdate(params: {
     host: string;
     port: number;
     mode: ServerMode;
+    closeWebSocketClients: () => void;
     stopServer: () => Promise<void>;
 }): void;
 export declare function setDomindsSelfUpdateBroadcaster(next: ((status: DomindsSelfUpdateStatus) => void) | null): void;

package/dist/server/dominds-self-update.js

@@ -20,6 +20,8 @@ const BACKGROUND_CHECK_INTERVAL_MS = 30 * 60 * 1000;
 const LATEST_VERSION_CHECK_TIMEOUT_MS = 60000;
 const RESTART_PORT_RELEASE_TIMEOUT_MS = 15000;
 const RESTART_PORT_PROBE_INTERVAL_MS = 150;
+const RESTART_EXIT_GRACE_MS = 1000;
+const RESTART_FORCE_KILL_AFTER_MS = 3000;
 const COMMAND_OUTPUT_LOG_LIMIT = 2000;
 const PROXY_URL_ENV_KEYS = new Set([
     'HTTP_PROXY',
@@ -97,6 +99,9 @@ function truncateCommandOutput(value) {
         return raw;
     return `${raw.slice(0, COMMAND_OUTPUT_LOG_LIMIT)}...[truncated ${raw.length - COMMAND_OUTPUT_LOG_LIMIT} chars]`;
 }
+function delayMs(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function formatPathEnvExcerpt(pathEnv) {
     if (pathEnv === null || pathEnv.trim() === '')
         return null;
@@ -620,6 +625,7 @@ function configureDomindsSelfUpdate(params) {
         host: params.host,
         port: params.port,
         mode: params.mode,
+        closeWebSocketClients: params.closeWebSocketClients,
         stopServer: params.stopServer,
     };
     latestObservation = { kind: 'unknown' };
@@ -860,6 +866,8 @@ function spawnDetachedRestartHelper(params) {
         cwd: params.cwd,
         host: getRestartPortProbeHost(params.host),
         port: params.port,
+        retiringPid: process.pid,
+        forceKillAfterMs: RESTART_FORCE_KILL_AFTER_MS,
         probeIntervalMs: RESTART_PORT_PROBE_INTERVAL_MS,
         portReleaseTimeoutMs: RESTART_PORT_RELEASE_TIMEOUT_MS,
         stdioMode,
@@ -884,8 +892,8 @@ function spawnDetachedRestartHelper(params) {
         '    socket.setTimeout(1000, () => finish(true));',
         '  });',
         '}',
-        'async function waitForPortRelease() {',
-        '  const deadline = Date.now() + payload.portReleaseTimeoutMs;',
+        'async function waitForPortRelease(timeoutMs) {',
+        '  const deadline = Date.now() + timeoutMs;',
         '  let consecutiveIdle = 0;',
         '  while (Date.now() < deadline) {',
         '    if (await isPortBusy()) {',
@@ -894,13 +902,42 @@ function spawnDetachedRestartHelper(params) {
         '      continue;',
         '    }',
         '    consecutiveIdle += 1;',
-        '    if (consecutiveIdle >= 2) return;',
+        '    if (consecutiveIdle >= 2) return true;',
         '    await new Promise((resolve) => setTimeout(resolve, payload.probeIntervalMs));',
         '  }',
+        '  return false;',
+        '}',
+        'function forceKillRetiringProcess() {',
+        '  if (!Number.isInteger(payload.retiringPid) || payload.retiringPid <= 0) {',
+        '    throw new Error(`Invalid retiring Dominds pid for restart: ${String(payload.retiringPid)}`);',
+        '  }',
+        '  if (payload.retiringPid === process.pid) {',
+        '    throw new Error(`Refusing to kill restart helper pid ${String(process.pid)}`);',
+        '  }',
+        "  const killer = process.platform === 'win32'",
+        "    ? spawn('taskkill.exe', ['/PID', String(payload.retiringPid), '/F'], { stdio: payload.stdioMode })",
+        "    : spawn('kill', ['-KILL', String(payload.retiringPid)], { stdio: payload.stdioMode });",
+        '  return new Promise((resolve, reject) => {',
+        "    killer.once('error', reject);",
+        "    killer.once('exit', (code) => {",
+        '      if (code === 0) {',
+        '        resolve();',
+        '        return;',
+        '      }',
+        '      resolve();',
+        '    });',
+        '  });',
         '}',
         '(async () => {',
         '  try {',
-        '    await waitForPortRelease();',
+        '    const releasedGracefully = await waitForPortRelease(payload.forceKillAfterMs);',
+        '    if (!releasedGracefully) {',
+        '      await forceKillRetiringProcess();',
+        '      const releasedAfterKill = await waitForPortRelease(payload.portReleaseTimeoutMs);',
+        '      if (!releasedAfterKill) {',
+        '        throw new Error(`Dominds restart port ${String(payload.host)}:${String(payload.port)} is still busy after force-killing pid ${String(payload.retiringPid)}`);',
+        '      }',
+        '    }',
         "    const child = spawn(payload.command, payload.args, { cwd: payload.cwd, env: process.env, detached, stdio: payload.stdioMode, shell: process.platform === 'win32' });",
         '    if (detached) child.unref();',
         '    process.exit(0);',
@@ -922,7 +959,28 @@ function spawnDetachedRestartHelper(params) {
 }
 async function stopAndExitForRestart() {
     const cfg = assertRuntimeConfig();
-    await cfg.stopServer();
+    let stopSettled = false;
+    void cfg
+        .stopServer()
+        .then(() => {
+        stopSettled = true;
+    })
+        .catch((error) => {
+        stopSettled = true;
+        log.error('Failed to stop Dominds HTTP server during restart grace window', error, {
+            host: cfg.host,
+            port: cfg.port,
+        });
+    });
+    cfg.closeWebSocketClients();
+    await delayMs(RESTART_EXIT_GRACE_MS);
+    if (!stopSettled) {
+        log.warn('Exiting Dominds process before graceful HTTP server stop completed during restart', undefined, {
+            host: cfg.host,
+            port: cfg.port,
+            graceMs: RESTART_EXIT_GRACE_MS,
+        });
+    }
     process.exit(0);
 }
 async function restartDomindsIntoLatest() {

package/dist/server/websocket-handler.js

@@ -1035,8 +1035,23 @@ async function handleDisplayDialog(ws, packet) {
         }
         const rootPrimingConfig = dialogIdObj.selfId === dialogIdObj.rootId ? (0, priming_1.getMainDialogPrimingConfig)(metadata) : undefined;
         const showPrimingEventsInUi = rootPrimingConfig?.showInUi !== false;
-        const decidedCourse = (await persistence_1.DialogPersistence.getCurrentCourseNumber(dialogIdObj, requestedStatus)) ||
+        if (packet.course !== undefined && (!Number.isInteger(packet.course) || packet.course <= 0)) {
+            ws.send(JSON.stringify({
+                type: 'error',
+                message: 'display_dialog course must be a positive integer when provided',
+            }));
+            return;
+        }
+        const latestCourse = (await persistence_1.DialogPersistence.getCurrentCourseNumber(dialogIdObj, requestedStatus)) ||
             (dialogState.currentCourse ?? 1);
+        const decidedCourse = packet.course ?? latestCourse;
+        if (decidedCourse > latestCourse) {
+            ws.send(JSON.stringify({
+                type: 'error',
+                message: `display_dialog course ${String(decidedCourse)} exceeds latest course ${String(latestCourse)}`,
+            }));
+            return;
+        }
         const enableLive = requestedStatus === 'running';
         const mainDialog = await (0, dialog_instance_registry_1.getOrRestoreMainDialog)(dialogIdObj.rootId, requestedStatus);
         if (!mainDialog) {
@@ -1068,7 +1083,7 @@ async function handleDisplayDialog(ws, packet) {
         try {
             const dialogStore = dialog.dlgStore;
             if (dialogStore instanceof persistence_1.DiskFileDialogStore) {
-                await dialogStore.sendDialogEventsDirectly(ws, dialog, decidedCourse, decidedCourse, requestedStatus, { showPrimingEventsInUi });
+                await dialogStore.sendDialogEventsDirectly(ws, dialog, decidedCourse, latestCourse, requestedStatus, { showPrimingEventsInUi });
             }
             else {
                 throw new Error('Unexpected dialog store type for sendDialogEventsDirectly');
@@ -1340,6 +1355,13 @@ async function handleDisplayCourse(ws, packet) {
         if (!dialog || typeof course !== 'number') {
             throw new Error('dialog and course are required');
         }
+        if (!Number.isInteger(course) || course <= 0) {
+            ws.send(JSON.stringify({
+                type: 'error',
+                message: 'display_course course must be a positive integer',
+            }));
+            return;
+        }
         // Extract dialog ID from DialogIdent
         let dialogIdStr = dialog.selfId;
         let mainDialogIdStr = dialog.rootId;
@@ -1371,6 +1393,13 @@ async function handleDisplayCourse(ws, packet) {
                 return;
             }
             const totalCourses = (await persistence_1.DialogPersistence.getCurrentCourseNumber(dialogId, requestedStatus)) || course;
+            if (course > totalCourses) {
+                ws.send(JSON.stringify({
+                    type: 'error',
+                    message: `display_course course ${String(course)} exceeds latest course ${String(totalCourses)}`,
+                }));
+                return;
+            }
             const mainDialog = await (0, dialog_instance_registry_1.getOrRestoreMainDialog)(dialogId.rootId, requestedStatus);
             if (!mainDialog)
                 return;

package/dist/server.js

@@ -233,6 +233,19 @@ async function startServer(opts = {}) {
             host,
             port: boundPort,
             mode: serverMode,
+            closeWebSocketClients: () => {
+                if (clients.size === 0)
+                    return;
+                log.info(`Closing ${clients.size} WebSocket client(s) for Dominds restart`);
+                for (const ws of clients) {
+                    try {
+                        ws.close(1012, 'server_restart');
+                    }
+                    catch (error) {
+                        log.warn('Failed to close WebSocket client for Dominds restart', error);
+                    }
+                }
+            },
             stopServer: async () => {
                 await httpServer.stop();
             },

package/dist/tools/ctrl.js

@@ -612,6 +612,7 @@ exports.updateReminderTool = {
 exports.clearMindTool = {
     type: 'func',
     name: 'clear_mind',
+    followupMode: 'deferred',
     description: 'Start a new dialog course, optionally carrying one extra continuation reminder.',
     descriptionI18n: {
         en: 'Start a new dialog course, optionally carrying one extra continuation reminder.',