dominds 1.25.9 → 1.25.10

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

@@ -1347,6 +1347,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 +1440,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({
@@ -1418,11 +1466,11 @@ async function upsertImmediateFollowupTrigger(args) {
         });
     }
     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 +1479,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';
@@ -2269,6 +2384,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 +3255,38 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         });
                         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) {
+                        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 +3307,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 +3317,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 +3373,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 +3393,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/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,7 @@ 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 COMMAND_OUTPUT_LOG_LIMIT = 2000;
 const PROXY_URL_ENV_KEYS = new Set([
     'HTTP_PROXY',
@@ -97,6 +98,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 +624,7 @@ function configureDomindsSelfUpdate(params) {
         host: params.host,
         port: params.port,
         mode: params.mode,
+        closeWebSocketClients: params.closeWebSocketClients,
         stopServer: params.stopServer,
     };
     latestObservation = { kind: 'unknown' };
@@ -922,7 +927,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.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.25.9",
+  "version": "1.25.10",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {