dominds 1.26.3 → 1.26.5

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/dialog.d.ts

@@ -272,6 +272,13 @@ export declare abstract class Dialog {
     listVisibleReminders(): Promise<Reminder[]>;
     resolveReminderTargetById(reminderId: string): Promise<VisibleReminderTarget | null>;
     private processReminderCollection;
+    private buildVisibleReminderContents;
+    private emitFullRemindersUpdate;
+    /**
+     * Emits current visible reminders without reconciling tool-owned state or writing persistence.
+     * This is for read-only dialog display, especially completed/archived dialogs opened from old tabs.
+     */
+    emitReminderSnapshot(): Promise<ReminderContent[]>;
     /**
      * Process reminder updates before LLM generation.
      * Calls updateReminder on each tool that owns reminders to allow them to update/drop/keep their reminders.

package/dist/dialog.js

@@ -629,6 +629,47 @@ class Dialog {
         }
         return changed;
     }
+    buildVisibleReminderContents(taskSharedReminders, runtimeReminders) {
+        const visibleReminders = [
+            ...this.reminders.map((reminder) => (0, tool_1.cloneReminder)(reminder)),
+            ...taskSharedReminders.map((reminder) => (0, tool_1.cloneReminder)(reminder)),
+            ...runtimeReminders.map((reminder) => (0, tool_1.cloneReminder)(reminder)),
+        ];
+        visibleReminders.sort(tool_1.compareReminderDisplayOrder);
+        return visibleReminders.map((r) => ({
+            content: r.content,
+            meta: r.meta,
+            reminder_id: r.id,
+            renderRevision: (0, tool_1.computeReminderRenderRevision)(r),
+            echoback: (0, tool_1.reminderEchoBackEnabled)(r),
+            scope: r.scope,
+            renderMode: r.renderMode ?? 'markdown',
+        }));
+    }
+    emitFullRemindersUpdate(reminders) {
+        const fullRemindersEvt = {
+            type: 'full_reminders_update',
+            reminders,
+        };
+        (0, evt_registry_1.postDialogEvent)(this, fullRemindersEvt);
+    }
+    /**
+     * Emits current visible reminders without reconciling tool-owned state or writing persistence.
+     * This is for read-only dialog display, especially completed/archived dialogs opened from old tabs.
+     */
+    async emitReminderSnapshot() {
+        const taskSharedTarget = {
+            kind: 'task',
+            agentId: this.agentId,
+            taskDocPath: this.taskDocPath,
+        };
+        const runtimeTarget = { kind: 'agent', agentId: this.agentId };
+        const taskSharedReminders = await (0, shared_reminders_1.loadSharedReminders)(taskSharedTarget);
+        const runtimeReminders = await (0, shared_reminders_1.loadSharedReminders)(runtimeTarget);
+        const reminders = this.buildVisibleReminderContents(taskSharedReminders, runtimeReminders);
+        this.emitFullRemindersUpdate(reminders);
+        return reminders;
+    }
     /**
      * Process reminder updates before LLM generation.
      * Calls updateReminder on each tool that owns reminders to allow them to update/drop/keep their reminders.
@@ -676,27 +717,8 @@ class Dialog {
                 agentId: this.agentId,
             });
         }
-        const visibleReminders = [
-            ...this.reminders.map((reminder) => (0, tool_1.cloneReminder)(reminder)),
-            ...taskSharedReminders,
-            ...runtimeReminders,
-        ];
-        visibleReminders.sort(tool_1.compareReminderDisplayOrder);
-        const reminders = visibleReminders.map((r) => ({
-            content: r.content,
-            meta: r.meta,
-            reminder_id: r.id,
-            renderRevision: (0, tool_1.computeReminderRenderRevision)(r),
-            echoback: (0, tool_1.reminderEchoBackEnabled)(r),
-            scope: r.scope,
-            renderMode: r.renderMode ?? 'markdown',
-        }));
-        // Emit full_reminders_update event with complete reminder list including metadata
-        const fullRemindersEvt = {
-            type: 'full_reminders_update',
-            reminders,
-        };
-        (0, evt_registry_1.postDialogEvent)(this, fullRemindersEvt);
+        const reminders = this.buildVisibleReminderContents(taskSharedReminders, runtimeReminders);
+        this.emitFullRemindersUpdate(reminders);
         return reminders;
     }
     setCoursePrefixMsgs(msgs) {

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/persistence.js

@@ -3590,7 +3590,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      * Note: Event emission is handled by processReminderUpdates() in Dialog
      */
     async persistReminders(dialog, reminders) {
-        await DialogPersistence._saveReminderState(this.dialogId, reminders);
+        await DialogPersistence._saveReminderState(this.dialogId, reminders, dialog.status);
         await DialogPersistence.appendRemindersReconciledRecord(this.dialogId, reminders, resolveReconciledRecordWriteTarget(dialog), dialog.status);
     }
     /**

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

@@ -179,6 +179,7 @@ function formatReminderContextGuide(language) {
     if (language === 'zh') {
         return [
             `${formatSystemNoticePrefix(language)} 提醒项上下文块开始`,
+            'Dominds 是你当前所在的自主运行环境；它会把运行中需要你看到的提醒、提示和状态放进上下文。',
             '以下是 Dominds 为你放到当前上下文里的可见提醒项。它们不是用户的新诉求/指令，也不是聊天正文。',
             '在 WebUI 中，用户通过独立的 Reminder 小组件/面板项看到这些提醒，并能把它们和聊天正文区分开。',
             '请把提醒项作为手头工作/状态参考；只有实际改变你的判断、计划或风险的信息，才需要提炼进后续有实质内容的对外回复。不要为了提醒项单独回复“收到/已了解/静默吸收”。',
@@ -186,6 +187,7 @@ function formatReminderContextGuide(language) {
     }
     return [
         `${formatSystemNoticePrefix(language)} Reminder context block begins`,
+        'Dominds is the autonomous runtime environment you are currently working in; it places needed reminders, notices, and state into your context.',
         'The following visible reminders were added to the current context by Dominds. They are not new user requests/instructions, and not chat transcript text.',
         'In the WebUI, the user sees these reminders through a separate Reminder widget/panel item and can distinguish them from the chat transcript.',
         'Use reminders as current-work/state references; only carry information into a later substantive outward reply when it materially changes your current judgment, plan, or risk. Do not send a standalone "acknowledged/noted/silently absorbed" reply for reminder items.',
@@ -328,6 +330,54 @@ 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. Business
+            // scenario: this is a tool-followup turn with no new user/runtime message, and stale
+            // reminders can distort the model's next-step choice. Tell the model to first reconcile
+            // reminders that affect the current judgment, then proceed from the corrected task state.
+            // This is deliberately positive wording: users may ask the agent to fix reminders, and a
+            // stale reminder should be corrected instead of preserved by a blanket "do not maintain
+            // reminders" warning.
+            return '当前是主线对话。先校对会影响当前判断的提醒项：如果某条提醒项已经过时、失真、互相冲突或会误导当前行动，就先修正或删除；其余提醒项只作为背景参考。然后按校正后的真实任务状态行动：已有明确、相关且有价值的任务动作就继续执行；确实缺少人类本人澄清、裁决、验收口径、授权或输入时，用 `askHuman({ tellaskContent })` 提出一个最小且可回答的问题；如果既不缺这些信息、也没有真实任务动作，就交给 Dominds 按主线安排处理，鞭策开启时会继续续推，鞭策关闭且没有真实动作时可以自然收住。';
+        case 'side_dialog':
+            // Side Dialogs are answering a requester. Business scenario: in a reminder-only
+            // tool-followup turn, runtime already knows this is a Sideline Dialog, so the model should
+            // not infer whether askHuman or tellaskBack is appropriate. First reconcile reminders that
+            // could mislead the current answer; then ask the requester before the human whenever the
+            // requester can supply the missing requirement/decision/criteria/input.
+            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. Business
+            // scenario: this is a tool-followup turn with no new user/runtime message, and stale
+            // reminders can distort the model's next-step choice. Tell the model to first reconcile
+            // reminders that affect the current judgment, then proceed from the corrected task state.
+            // This is deliberately positive wording: users may ask the agent to fix reminders, and a
+            // stale reminder should be corrected instead of preserved by a blanket "do not maintain
+            // reminders" warning.
+            return 'This is a Main Dialog. First check reminders that affect your current judgment: if a reminder is stale, distorted, conflicting, or would mislead the current action, correct or delete it; use the other reminders only as background reference. Then act from the corrected real task state: continue any clear, relevant, valuable task action; use `askHuman({ tellaskContent })` only when you truly need clarification, a decision, acceptance criteria, authorization, or input from the human, and ask one minimal, answerable question; if none of that is needed and there is no real task action, hand control back to Dominds mainline behavior, where 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. Business scenario: in a reminder-only
+            // tool-followup turn, runtime already knows this is a Sideline Dialog, so the model should
+            // not infer whether askHuman or tellaskBack is appropriate. First reconcile reminders that
+            // could mislead the current answer; then ask the requester before the human whenever the
+            // requester can supply the missing requirement/decision/criteria/input.
+            return 'This is a Side Dialog. First check reminders that affect your current judgment: if a reminder is stale, distorted, conflicting, or would mislead the current action, correct or delete it; use the other reminders only as background reference. Then act from the corrected real task state: continue any clear, relevant, valuable task action. 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 none of that is needed and there is no real task action, hand control back to Dominds sideline behavior: 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') {
@@ -357,14 +407,15 @@ function formatReminderContextFooter(language, state) {
                     // When context is tight/critical, the context-preservation notice owns the turn. Do not add
                     // ordinary continuation wording that could encourage more work from old reminders.
                     return (`${base}本轮没有新的用户消息或 Dominds 提示；这是工具调用后的自动续推。` +
-                        `不要把“没有新消息”理解为空系统提示。${statusTail}`);
+                        `这里的“没有新消息”只说明本轮没有额外用户消息或 Dominds 提示。${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 提示；这是工具调用后的自动续推。` +
-                    '请基于提醒项之外的已有任务状态判断下一步：若已有明确、相关且有价值的任务动作，就继续执行；若唯一看似可做的动作只是新增、更新、删除、压缩或整理提醒项，则不要单独为提醒项维护继续调用工具。若当前确实只能等待外部结果或用户输入，不要为了避免“等待”而寻找无关小事。' +
-                    `不要把“没有新消息”理解为空系统提示。${businessTail}`);
+                    scopeTail +
+                    `这里的“没有新消息”只说明本轮没有额外用户消息或 Dominds 提示。${businessTail}`);
             default: {
                 const _exhaustive = state.followingMessage;
                 throw new Error(`Unhandled zh reminder following-message state: ${String(_exhaustive)}`);
@@ -399,14 +450,15 @@ function formatReminderContextFooter(language, state) {
                 // When context is tight/critical, the context-preservation notice owns the turn. Do not add
                 // ordinary continuation wording that could encourage more work from old reminders.
                 return (`${base}There is no new user message or Dominds notice in this round; this is an automatic continuation after a tool call. ` +
-                    `Do not interpret the absence of a new message as an empty system notice. ${statusTail}`);
+                    `Here, "no new message" only means this round has no extra user message or Dominds 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". ' +
-                `Do not interpret the absence of a new message as an empty system notice. ${businessTail}`);
+                `${scopeTail} ` +
+                `Here, "no new message" only means this round has no extra user message or Dominds notice. ${businessTail}`);
         default: {
             const _exhaustive = state.followingMessage;
             throw new Error(`Unhandled en reminder following-message state: ${String(_exhaustive)}`);
@@ -501,15 +553,19 @@ function formatReminderMaintenanceReference(language, reminders) {
     }
     if (lines.length === 0)
         return undefined;
+    // Business scenario: this block exposes exact reminder_id maintenance channels. The footer
+    // decides what the model should do next; this note only tells the model how to repair a concrete
+    // reminder when the current user message, Dominds notice, or task state makes that repair useful.
+    // Keep it positive: stale reminders should be fixed, while accurate reminders remain references.
     if (language === 'zh') {
         return [
-            `${formatSystemNoticePrefix(language)} 我把下面的提醒项维护通道仅作为操作参考；如果我在处理真实用户消息、Dominds 提示或当前任务动作时确实需要维护某条 reminder，我会按对应 reminder_id 选择工具。我不会把这些参考当成当前轮必须立即执行的动作；没有新的用户消息、Dominds 提示或提醒项之外的任务动作时，我不会只为了清理/整理提醒项而继续调用提醒项工具，也不会因此延迟回应后续真实用户消息。`,
+            `${formatSystemNoticePrefix(language)} 下面列出这些提醒项可用的修正、更新或删除方式，按 reminder_id 对照使用。处理真实用户消息、Dominds 提示或当前任务时，如果某条提醒项已经过时、失真、重复或会误导当前判断，就用对应方式维护；如果它仍然准确，就把它当作参考继续处理当前场景。`,
             '',
             ...lines,
         ].join('\n');
     }
     return [
-        `${formatSystemNoticePrefix(language)} I treat the following reminder-maintenance channels as an operational reference only. If I truly need to maintain a reminder while handling a real user message, Dominds notice, or current task action, I match the corresponding reminder_id and choose the tool from there. I do not treat these references as actions I must perform immediately in this turn; when there is no new user message, no Dominds notice, and no task action outside reminders, I do not keep calling reminder tools solely to clean up or organize reminders, and I do not let them delay my response to any following real user message.`,
+        `${formatSystemNoticePrefix(language)} The following are the available ways to correct, update, or delete these reminders; use the matching reminder_id. While handling a real user message, Dominds notice, or current task, if a reminder is stale, distorted, duplicate, or would mislead your current judgment, maintain it through the matching path; if it is still accurate, use it as a reference and continue with the current situation.`,
         '',
         ...lines,
     ].join('\n');

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 {};