dominds 1.26.3 → 1.26.4

package/dist/cli.js

@@ -93,8 +93,8 @@ function parseSupervisorArgs(argv) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function isRestartRunKind(value) {
-    return value === 'global' || value === 'npx';
+function isRestartStrategy(value) {
+    return value === 'current_entrypoint' || value === 'npx_latest';
 }
 function parseRunnerMessage(message) {
     if (!isRecord(message))
@@ -108,7 +108,7 @@ function parseRunnerMessage(message) {
     const debugDir = message['debugDir'];
     const currentVersion = message['currentVersion'];
     const targetVersion = message['targetVersion'];
-    const runKind = message['runKind'];
+    const restartStrategy = message['restartStrategy'];
     const invalid = (reason) => ({
         kind: 'invalid',
         reason,
@@ -131,8 +131,9 @@ function parseRunnerMessage(message) {
     if (targetVersion !== null && typeof targetVersion !== 'string') {
         return invalid('targetVersion must be a string or null');
     }
-    if (!isRestartRunKind(runKind))
-        return invalid('runKind must be global or npx');
+    if (!isRestartStrategy(restartStrategy)) {
+        return invalid('restartStrategy must be current_entrypoint or npx_latest');
+    }
     return {
         kind: 'restart',
         message: {
@@ -144,7 +145,7 @@ function parseRunnerMessage(message) {
             debugDir,
             currentVersion,
             targetVersion,
-            runKind,
+            restartStrategy,
         },
     };
 }
@@ -186,7 +187,7 @@ function appendInvalidSupervisorTraceSoon(parsed, event = 'supervisor.invalid_re
         debugDir: parsed.debugDir,
         currentVersion: 'unknown',
         targetVersion: null,
-        runKind: 'global',
+        restartStrategy: 'current_entrypoint',
     };
     appendSupervisorTraceSoon(message, event, {
         ...details,
@@ -490,6 +491,7 @@ async function runSupervised(params) {
                     cwd: message.cwd,
                     host: message.host,
                     port: message.port,
+                    restartStrategy: message.restartStrategy,
                 });
                 scheduleRestartExitEnforcement(child, message);
             });
@@ -540,7 +542,7 @@ async function runSupervised(params) {
                     return 0;
                 backoffMs = Math.min(backoffMs * 2, MAX_RESTART_BACKOFF_MS);
             }
-            if (restart.runKind === 'npx') {
+            if (restart.restartStrategy === 'npx_latest') {
                 while (true) {
                     try {
                         const runnerEntrypoint = await resolveNpxLatestRunnerEntrypoint();

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

@@ -269,7 +269,9 @@ async function resolveReminderContextFooterState(args) {
     const hasCompletedHandoffWithoutPendingReply = latest?.sideDialogFinalResponse !== undefined &&
         !hasDeferredReplyReassertion &&
         !hasActiveReplyObligation;
+    const dialogScope = args.dlg instanceof dialog_1.SideDialog ? { kind: 'side_dialog' } : { kind: 'main_dialog' };
     return (0, reminder_context_1.resolveReminderContextFooterStateFromSignals)({
+        dialogScope,
         prompt: args.prompt,
         currentTurnDialogMsgsForContext: args.currentTurnDialogMsgsForContext,
         contextHealth: args.dlg.getLastContextHealth(),

package/dist/llm/kernel-driver/reminder-context.d.ts

@@ -1,5 +1,5 @@
 import type { ContextHealthSnapshot } from '@longrun-ai/kernel/types/context-health';
-import type { ReminderContextBusiness, ReminderContextFollowingMessage, ReminderContextFooterState, ReminderContextHealth } from '../../runtime/driver-messages';
+import type { ReminderContextBusiness, ReminderContextDialogScope, ReminderContextFollowingMessage, ReminderContextFooterState, ReminderContextHealth } from '../../runtime/driver-messages';
 import type { ChatMessage } from '../client';
 import type { KernelDriverPrompt } from './types';
 export declare function resolveReminderContextFollowingMessage(args: {
@@ -15,6 +15,7 @@ export declare function resolveReminderContextBusinessState(args: {
     hasActiveReplyObligation: boolean;
 }): ReminderContextBusiness;
 export declare function resolveReminderContextFooterStateFromSignals(args: {
+    dialogScope: ReminderContextDialogScope;
     prompt: KernelDriverPrompt | undefined;
     currentTurnDialogMsgsForContext: readonly ChatMessage[];
     contextHealth: ContextHealthSnapshot | undefined;

package/dist/llm/kernel-driver/reminder-context.js

@@ -70,6 +70,7 @@ function resolveReminderContextFooterStateFromSignals(args) {
     return {
         followingMessage,
         contextHealth: resolveReminderContextHealth(args.contextHealth),
+        dialogScope: args.dialogScope,
         business: resolveReminderContextBusinessState({
             followingMessage,
             pendingUserInterjectionReply: args.pendingUserInterjectionReply,

package/dist/minds/system-prompt.js

@@ -367,6 +367,12 @@ function buildSystemPrompt(input) {
     const fbrGuidelines = buildFbrGuidelines(input.language, input.dialogScope, input.contextHealthPromptMode);
     const tellaskInteractionRules = buildTellaskInteractionRules(input.language);
     const functionToolRules = buildFunctionToolRules(input.language, input.funcToolRulesText);
+    // Business scenario: many runtime notices say "Dominds has reminded / decided / injected ..."
+    // because Dominds, not the human user, maintains dialog state, reminder projection, course
+    // transitions, and inter-dialog routing. Without a plain glossary definition, models may treat
+    // "Dominds" as a user request source, a third-party product name, or an abstract platform.
+    // Define it once near the top of the system prompt so later Dominds notices read as state and
+    // guidance from the current autonomous runtime.
     if (input.language === 'zh') {
         return `
 # Agent 系统提示
@@ -390,6 +396,7 @@ function buildSystemPrompt(input) {
 
 ## 术语表
 
+- Dominds：你当前所在的智能体自主运行环境；它负责维护对话、提醒项、换程、队友诉请和系统提示。看到“Dominds 提示”时，把它当作当前运行环境给你的状态说明或行动引导，不是用户的新诉求。
 - 诉请：对智能体的结构化请求。
 - 诉请内容（tellaskContent）：tellask 系列函数的正文参数，用于承载上下文/约束/验收。
 - 提及列表（mentionList）：仅用于 \`tellask\` / \`tellaskSessionless\` 的队友目标列表（\`@<agentId>\`）。
@@ -488,6 +495,7 @@ System notices convey important state changes (e.g., context caution/critical, D
 
 ## Glossary
 
+- Dominds: your current autonomous agent runtime. It maintains dialogs, reminders, course transitions, teammate tellasks, and system notices. When you see a "Dominds notice", treat it as state or action guidance from the current runtime, not as a new user request.
 - Tellask: a structured request addressed to an agent.
 - Mention list (\`mentionList\`): teammate targets for \`tellask\` / \`tellaskSessionless\` only (\`@<agentId>\`).
 - Tellask content (\`tellaskContent\`): main call payload carrying context/constraints/acceptance.

package/dist/runtime/driver-messages.d.ts

@@ -28,6 +28,11 @@ export type ReminderContextHealth = Readonly<{
 }> | Readonly<{
     kind: 'critical';
 }>;
+export type ReminderContextDialogScope = Readonly<{
+    kind: 'main_dialog';
+}> | Readonly<{
+    kind: 'side_dialog';
+}>;
 export type ReminderContextBusiness = Readonly<{
     kind: 'none';
 }> | Readonly<{
@@ -44,6 +49,7 @@ export type ReminderContextBusiness = Readonly<{
 export type ReminderContextFooterState = Readonly<{
     followingMessage: ReminderContextFollowingMessage;
     contextHealth: ReminderContextHealth;
+    dialogScope: ReminderContextDialogScope;
     business: ReminderContextBusiness;
 }>;
 export declare function formatReminderContextFooter(language: LanguageCode, state: ReminderContextFooterState): string;

package/dist/runtime/driver-messages.js

@@ -328,6 +328,44 @@ function joinReminderFooterTails(language, tails) {
         return '';
     return language === 'zh' ? nonEmptyTails.join('') : nonEmptyTails.join(' ');
 }
+function formatZhNormalAutoContinueByDialogScope(scope) {
+    switch (scope.kind) {
+        case 'main_dialog':
+            // Main Dialogs own the broad task and do not have a requester to tellaskBack. When the only
+            // apparent action is reminder maintenance, ask the human only for genuinely missing human
+            // input/authorization; otherwise hand control back to the Main Dialog keep-alive setting
+            // instead of making up work.
+            return '当前是主线对话。请基于提醒项之外的已有任务状态判断下一步：若已有明确、相关且有价值的任务动作，就继续执行；若唯一看似可做的只是新增、更新、删除、压缩或整理提醒项，不要把提醒项维护当成续推动作。若确实缺少人类本人澄清、裁决、验收口径、授权或输入，才用 `askHuman({ tellaskContent })` 提出一个最小且可回答的问题。若不缺这些信息、也没有真实任务动作，不要为了避免停顿而寻找无关小事；让主线按 Dominds 的主线机制处理，鞭策开启时会继续续推，鞭策关闭且没有真实动作时可以自然收住。';
+        case 'side_dialog':
+            // Side Dialogs are answering a requester. If blocked on requirement clarification, a business
+            // decision, acceptance criteria, or requester-held input, tellaskBack is the local loop and
+            // askHuman is only for information that truly must come from the human.
+            return '当前是支线对话。请基于提醒项之外的已有任务状态判断下一步：若已有明确、相关且有价值的任务动作，就继续执行；若唯一看似可做的只是新增、更新、删除、压缩或整理提醒项，不要把提醒项维护当成续推动作。若缺少需求澄清、业务裁决、验收口径、授权或输入，先判断缺的东西该由谁补：如果诉请者能补需求澄清/业务裁决/验收口径/缺失输入，先按当前工具规则考虑 `tellaskBack({ tellaskContent })` 回问诉请者；只有确实需要人类本人澄清、决策、授权或输入时，才用 `askHuman({ tellaskContent })` 提出一个最小且可回答的问题。若不缺这些信息、也没有真实任务动作，不要为了避免停顿而寻找无关小事；让支线按 Dominds 的支线机制处理：需要回贴时会收到回贴提醒，已完成且无新诉求时可以自然收住。';
+        default: {
+            const _exhaustive = scope;
+            throw new Error(`Unhandled zh reminder dialog scope: ${String(_exhaustive)}`);
+        }
+    }
+}
+function formatEnNormalAutoContinueByDialogScope(scope) {
+    switch (scope.kind) {
+        case 'main_dialog':
+            // Main Dialogs own the broad task and do not have a requester to tellaskBack. When the only
+            // apparent action is reminder maintenance, ask the human only for genuinely missing human
+            // input/authorization; otherwise hand control back to the Main Dialog keep-alive setting
+            // instead of making up work.
+            return "This is a Main Dialog. Judge the next step from existing task state outside the reminder items: if there is a clear, relevant, valuable actual task action, continue with it; if the only apparent action is to add, update, delete, compress, or organize reminders, do not treat reminder maintenance as task progress. Use `askHuman({ tellaskContent })` only when you truly need clarification, a decision, acceptance criteria, authorization, or input from the human; ask one minimal, answerable question. If you do not need any of that and there is no real task action, do not invent unrelated work just to avoid a pause; let the Main Dialog follow Dominds' mainline mechanism: diligence can continue it when enabled, and when diligence is disabled with no real action, it may naturally settle.";
+        case 'side_dialog':
+            // Side Dialogs are answering a requester. If blocked on requirement clarification, a business
+            // decision, acceptance criteria, or requester-held input, tellaskBack is the local loop and
+            // askHuman is only for information that truly must come from the human.
+            return "This is a Side Dialog. Judge the next step from existing task state outside the reminder items: if there is a clear, relevant, valuable actual task action, continue with it; if the only apparent action is to add, update, delete, compress, or organize reminders, do not treat reminder maintenance as task progress. If you are missing clarification, a business decision, acceptance criteria, authorization, or input, first identify who should provide it: when the requester can provide the missing requirement clarification, business decision, acceptance criteria, or missing input, follow the current tool rules and consider `tellaskBack({ tellaskContent })` first; use `askHuman({ tellaskContent })` only when the needed clarification, decision, authorization, or input truly must come from the human. If you do not need any of that and there is no real task action, do not invent unrelated work just to avoid a pause; let the Side Dialog follow Dominds' sideline mechanism: it can receive reply reminders when a reply is needed, and when it is complete with no new request, it may naturally settle.";
+        default: {
+            const _exhaustive = scope;
+            throw new Error(`Unhandled en reminder dialog scope: ${String(_exhaustive)}`);
+        }
+    }
+}
 function formatReminderContextFooter(language, state) {
     const contextHealthIsNormal = state.contextHealth.kind === 'normal';
     if (language === 'zh') {
@@ -360,10 +398,11 @@ function formatReminderContextFooter(language, state) {
                         `不要把“没有新消息”理解为空系统提示。${statusTail}`);
                 }
                 // Normal tool-followup rounds may continue real business work, but reminder maintenance
-                // paths are merely references. This is the guard against loops that only add/delete/merge
-                // reminders after a task is otherwise done.
+                // paths are merely references. Runtime already knows whether this is a Main Dialog or Side
+                // Dialog, so do not ask the model to self-classify before choosing askHuman vs tellaskBack.
+                const scopeTail = formatZhNormalAutoContinueByDialogScope(state.dialogScope);
                 return (`${base}本轮没有新的用户消息或 Dominds 提示；这是工具调用后的自动续推。` +
-                    '请基于提醒项之外的已有任务状态判断下一步：若已有明确、相关且有价值的任务动作，就继续执行；若唯一看似可做的动作只是新增、更新、删除、压缩或整理提醒项，则不要单独为提醒项维护继续调用工具。若当前确实只能等待外部结果或用户输入，不要为了避免“等待”而寻找无关小事。' +
+                    scopeTail +
                     `不要把“没有新消息”理解为空系统提示。${businessTail}`);
             default: {
                 const _exhaustive = state.followingMessage;
@@ -402,10 +441,11 @@ function formatReminderContextFooter(language, state) {
                     `Do not interpret the absence of a new message as an empty system notice. ${statusTail}`);
             }
             // Normal tool-followup rounds may continue real business work, but reminder maintenance
-            // paths are merely references. This is the guard against loops that only add/delete/merge
-            // reminders after a task is otherwise done.
+            // paths are merely references. Runtime already knows whether this is a Main Dialog or Side
+            // Dialog, so do not ask the model to self-classify before choosing askHuman vs tellaskBack.
+            const scopeTail = formatEnNormalAutoContinueByDialogScope(state.dialogScope);
             return (`${base}There is no new user message or Dominds notice in this round; this is an automatic continuation after a tool call. ` +
-                'Judge the next step from existing task state outside the reminder items: if there is a clear, relevant, valuable actual task action, continue with it; if the only apparent action is to add, update, delete, compress, or organize reminders, do not keep calling tools solely for reminder maintenance. If the work genuinely can only wait for an external result or user input, do not invent unrelated work just to avoid "waiting". ' +
+                `${scopeTail} ` +
                 `Do not interpret the absence of a new message as an empty system notice. ${businessTail}`);
         default: {
             const _exhaustive = state.followingMessage;

package/dist/server/api-routes.js

@@ -414,7 +414,7 @@ function parseDomindsSelfUpdateAction(body) {
     if (!isRecord(body))
         return null;
     const action = body['action'];
-    if (action === 'install' || action === 'restart')
+    if (action === 'install' || action === 'restart' || action === 'force_restart')
         return action;
     return null;
 }
@@ -1084,7 +1084,7 @@ async function handleApiRoute(req, res, pathname, context) {
             if (action === null) {
                 respondJson(res, 400, {
                     success: false,
-                    error: "Invalid action. Expected 'install' or 'restart'",
+                    error: "Invalid action. Expected 'install', 'restart', or 'force_restart'",
                 });
                 return true;
             }
@@ -1094,6 +1094,11 @@ async function handleApiRoute(req, res, pathname, context) {
                     respondJson(res, 200, { success: true, update: status });
                     return true;
                 }
+                if (action === 'force_restart') {
+                    const status = await (0, dominds_self_update_1.forceRestartDominds)();
+                    respondJson(res, 202, { success: true, update: status });
+                    return true;
+                }
                 const status = await (0, dominds_self_update_1.restartDomindsIntoLatest)();
                 respondJson(res, 202, { success: true, update: status });
                 return true;

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

@@ -12,4 +12,5 @@ export declare function setDomindsSelfUpdateBroadcaster(next: ((status: DomindsS
 export declare function getDomindsSelfUpdateStatus(): Promise<DomindsSelfUpdateStatus>;
 export declare function installLatestDominds(): Promise<DomindsSelfUpdateStatus>;
 export declare function restartDomindsIntoLatest(): Promise<DomindsSelfUpdateStatus>;
+export declare function forceRestartDominds(): Promise<DomindsSelfUpdateStatus>;
 export {};

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

@@ -9,6 +9,7 @@ exports.setDomindsSelfUpdateBroadcaster = setDomindsSelfUpdateBroadcaster;
 exports.getDomindsSelfUpdateStatus = getDomindsSelfUpdateStatus;
 exports.installLatestDominds = installLatestDominds;
 exports.restartDomindsIntoLatest = restartDomindsIntoLatest;
+exports.forceRestartDominds = forceRestartDominds;
 const child_process_1 = require("child_process");
 const crypto_1 = require("crypto");
 const promises_1 = __importDefault(require("fs/promises"));
@@ -1099,10 +1100,11 @@ async function getDomindsSelfUpdateStatus() {
         });
     }
     if (restartPromise !== null) {
+        const targetVersion = latestObservation.kind === 'ok' ? latestObservation.latestVersion : null;
         return buildStatus({
             currentVersion: runningVersion,
-            installedVersion: runningVersion,
-            latestVersion: latestObservation.kind === 'ok' ? latestObservation.latestVersion : null,
+            installedVersion: targetVersion ?? runningVersion,
+            latestVersion: targetVersion,
             checkedAt: latestObservation.kind === 'unknown' ? null : latestObservation.checkedAt,
             mode: cfg.mode,
             runKind,
@@ -1110,7 +1112,7 @@ async function getDomindsSelfUpdateStatus() {
             busy: 'restarting',
             reason: 'restart_required',
             message: 'Dominds restart is in progress',
-            targetVersion: latestObservation.kind === 'ok' ? latestObservation.latestVersion : null,
+            targetVersion,
         });
     }
     if (latestObservation.kind === 'unknown') {
@@ -1353,7 +1355,7 @@ async function requestSupervisorRestart(params) {
         debugDir: params.trace.debugDir,
         currentVersion: params.currentVersion,
         targetVersion: params.targetVersion,
-        runKind: params.runKind,
+        restartStrategy: params.restartStrategy,
     };
     await new Promise((resolve, reject) => {
         process.send?.(message, (error) => {
@@ -1422,6 +1424,69 @@ async function stopAndExitForRestart() {
     }
     process.exit(0);
 }
+async function requestDomindsRestart(params) {
+    const cfg = assertRuntimeConfig();
+    const runKind = detectRunKind(cfg.mode);
+    if (runKind === 'disabled') {
+        throw new Error('Dominds restart requires a production run kind');
+    }
+    restartState = { kind: 'restarting', targetVersion: params.targetVersion };
+    publishStatusUpdateSoon();
+    const restartCwd = process.cwd();
+    const trace = buildRestartTraceContext();
+    activeRestartTraceFile = trace.traceFile;
+    try {
+        await appendRestartTraceBestEffort(trace, params.traceEvent, {
+            runKind,
+            restartStrategy: params.restartStrategy,
+            currentVersion: params.currentVersion,
+            targetVersion: params.targetVersion,
+            restartCwd,
+            host: cfg.host,
+            port: cfg.port,
+            traceFile: trace.traceFile,
+        });
+        await requestSupervisorRestart({
+            trace,
+            restartStrategy: params.restartStrategy,
+            currentVersion: params.currentVersion,
+            targetVersion: params.targetVersion,
+        });
+        await appendRestartTraceBestEffort(trace, 'parent.supervisor_restart_requested', {
+            retiringPid: process.pid,
+            host: cfg.host,
+            port: cfg.port,
+        });
+        log.info('Dominds supervisor restart requested', undefined, {
+            traceFile: trace.traceFile,
+            forced: params.traceEvent === 'parent.force_restart_requested',
+            restartStrategy: params.restartStrategy,
+        });
+        setImmediate(() => {
+            void stopAndExitForRestart().catch((error) => {
+                void appendRestartTraceBestEffort(trace, 'parent.stop_and_exit.error', {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? (error.stack ?? null) : null,
+                });
+                log.error('Failed to stop Dominds server during restart', error);
+                restartState = params.rollbackState;
+                activeRestartTraceFile = null;
+                publishStatusUpdateSoon();
+            });
+        });
+    }
+    catch (error) {
+        await appendRestartTraceBestEffort(trace, 'parent.restart_error', {
+            message: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? (error.stack ?? null) : null,
+        });
+        restartState = params.rollbackState;
+        activeRestartTraceFile = null;
+        publishStatusUpdateSoon();
+        throw error;
+    }
+    return await getDomindsSelfUpdateStatus();
+}
 async function restartDomindsIntoLatest() {
     const cfg = assertRuntimeConfig();
     if (cfg.mode !== 'production') {
@@ -1452,63 +1517,55 @@ async function restartDomindsIntoLatest() {
         else if (previousRestartRequiredState === null) {
             throw new Error('Dominds restart requires a completed install or a restartable session');
         }
-        restartState = { kind: 'restarting', targetVersion: status.targetVersion };
+        return await requestDomindsRestart({
+            traceEvent: 'parent.restart_requested',
+            restartStrategy: runKind === 'npx' ? 'npx_latest' : 'current_entrypoint',
+            currentVersion: status.currentVersion,
+            targetVersion: status.targetVersion,
+            rollbackState: previousRestartRequiredState ?? IDLE_RESTART_STATE,
+        });
+    })()
+        .catch((error) => {
+        const statusSnapshot = restartState.kind === 'restarting' ? restartState : null;
+        log.error('Dominds version restart failed', error, {
+            runKind: detectRunKind(cfg.mode),
+            restartState: statusSnapshot,
+        });
+        throw error;
+    })
+        .finally(() => {
+        restartPromise = null;
         publishStatusUpdateSoon();
-        const restartCwd = process.cwd();
-        const trace = buildRestartTraceContext();
-        activeRestartTraceFile = trace.traceFile;
-        try {
-            await appendRestartTraceBestEffort(trace, 'parent.restart_requested', {
-                runKind,
-                currentVersion: status.currentVersion,
-                targetVersion: status.targetVersion,
-                restartCwd,
-                host: cfg.host,
-                port: cfg.port,
-                traceFile: trace.traceFile,
-            });
-            await requestSupervisorRestart({
-                trace,
-                runKind,
-                currentVersion: status.currentVersion,
-                targetVersion: status.targetVersion,
-            });
-            await appendRestartTraceBestEffort(trace, 'parent.supervisor_restart_requested', {
-                retiringPid: process.pid,
-                host: cfg.host,
-                port: cfg.port,
-            });
-            log.info('Dominds supervisor restart requested', undefined, {
-                traceFile: trace.traceFile,
-            });
-            setImmediate(() => {
-                void stopAndExitForRestart().catch((error) => {
-                    void appendRestartTraceBestEffort(trace, 'parent.stop_and_exit.error', {
-                        message: error instanceof Error ? error.message : String(error),
-                        stack: error instanceof Error ? (error.stack ?? null) : null,
-                    });
-                    log.error('Failed to stop Dominds server during restart', error);
-                    restartState = previousRestartRequiredState ?? IDLE_RESTART_STATE;
-                    activeRestartTraceFile = null;
-                    publishStatusUpdateSoon();
-                });
-            });
-        }
-        catch (error) {
-            await appendRestartTraceBestEffort(trace, 'parent.restart_error', {
-                message: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? (error.stack ?? null) : null,
-            });
-            restartState = previousRestartRequiredState ?? IDLE_RESTART_STATE;
-            activeRestartTraceFile = null;
-            publishStatusUpdateSoon();
-            throw error;
-        }
+    });
+    return await restartPromise;
+}
+async function forceRestartDominds() {
+    const cfg = assertRuntimeConfig();
+    if (cfg.mode !== 'production') {
+        throw new Error('Dominds force restart is disabled in development mode');
+    }
+    if (installPromise !== null) {
+        throw new Error('Dominds force restart is blocked while installation is in progress');
+    }
+    if (restartPromise !== null) {
         return await getDomindsSelfUpdateStatus();
+    }
+    if (restartState.kind === 'restarting') {
+        return await getDomindsSelfUpdateStatus();
+    }
+    restartPromise = (async () => {
+        const runningVersion = getRunningVersion();
+        return await requestDomindsRestart({
+            traceEvent: 'parent.force_restart_requested',
+            restartStrategy: 'current_entrypoint',
+            currentVersion: runningVersion,
+            targetVersion: runningVersion,
+            rollbackState: IDLE_RESTART_STATE,
+        });
     })()
         .catch((error) => {
         const statusSnapshot = restartState.kind === 'restarting' ? restartState : null;
-        log.error('Dominds version restart failed', error, {
+        log.error('Dominds force restart failed', error, {
             runKind: detectRunKind(cfg.mode),
             restartState: statusSnapshot,
         });

package/dist/supervisor-protocol.d.ts

@@ -1,6 +1,5 @@
-import type { DomindsSelfUpdateRunKind } from '@longrun-ai/kernel/types';
 export declare const DOMINDS_SUPERVISOR_RESTART_WEBUI = "dominds.supervisor.restart_webui.v1";
-export type DomindsSupervisorRestartRunKind = Extract<DomindsSelfUpdateRunKind, 'global' | 'npx'>;
+export type DomindsSupervisorRestartStrategy = 'current_entrypoint' | 'npx_latest';
 export type DomindsSupervisorRestartWebuiMessage = Readonly<{
     type: typeof DOMINDS_SUPERVISOR_RESTART_WEBUI;
     cwd: string;
@@ -10,6 +9,6 @@ export type DomindsSupervisorRestartWebuiMessage = Readonly<{
     debugDir: string;
     currentVersion: string;
     targetVersion: string | null;
-    runKind: DomindsSupervisorRestartRunKind;
+    restartStrategy: DomindsSupervisorRestartStrategy;
 }>;
 export type DomindsRunnerToSupervisorMessage = DomindsSupervisorRestartWebuiMessage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.26.3",
+  "version": "1.26.4",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {
@@ -55,8 +55,8 @@
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
     "@longrun-ai/codex-auth": "0.13.0",
-    "@longrun-ai/kernel": "1.16.0",
-    "@longrun-ai/shell": "1.16.0"
+    "@longrun-ai/shell": "1.16.0",
+    "@longrun-ai/kernel": "1.16.0"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",

package/webapp/dist/assets/{_basePickBy-DTJFxmut.js → _basePickBy-mFK6EVZU.js}

@@ -1,5 +1,5 @@
-import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-CVu4lo4P.js";
-import { aU as isObject, aC as baseRest, aV as isIterateeCall, aW as keysIn, aX as eq, aY as isArrayLike, aZ as isArray, a_ as identity, a$ as isIndex, b0 as assignValue } from "./index-DYO4ZL8y.js";
+import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-C8zyOqn7.js";
+import { aU as isObject, aC as baseRest, aV as isIterateeCall, aW as keysIn, aX as eq, aY as isArrayLike, aZ as isArray, a_ as identity, a$ as isIndex, b0 as assignValue } from "./index-C_PzQ5W5.js";
 var reWhitespace = /\s/;
 function trimmedEndIndex(string) {
   var index = string.length;
@@ -193,4 +193,4 @@ export {
   map as m,
   toFinite as t
 };
-//# sourceMappingURL=_basePickBy-DTJFxmut.js.map
+//# sourceMappingURL=_basePickBy-mFK6EVZU.js.map