dominds 1.26.2 → 1.26.4

package/README.md

@@ -257,6 +257,8 @@ Platform note:
 
 Dominds always keeps an HTTP listener. When a valid certificate matching the current `--host` exists under `~/.dominds/certs/`, Dominds also starts HTTPS. Certificates match DNS/IP hostnames, not ports, so one certificate covers all Dominds WebUI ports on that host.
 
+Dominds generates certificates through npm dependencies, so no separate `openssl` command is required.
+
 ```bash
 # Create a 10-year self-signed certificate for detected non-loopback LAN hosts
 dominds cert create

package/README.zh.md

@@ -196,6 +196,8 @@ dominds
 
 Dominds 默认始终提供 HTTP 监听；当 `~/.dominds/certs/` 下存在匹配当前 `--host` 的有效证书时，会额外启用 HTTPS。证书按 DNS/IP 主机名匹配，不绑定端口，因此同一张证书可覆盖该主机上的所有 Dominds WebUI 端口。
 
+证书由 Dominds 通过 npm 依赖生成，无需额外安装 `openssl` 等系统命令。
+
 ```bash
 # 自动为检测到的一个或多个非 loopback LAN 主机创建 10 年有效的自签名证书
 dominds cert create

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/docs/cli-usage.md

@@ -153,7 +153,7 @@ dominds cert create [--host <host>] [--days <days>] [--force]
 dominds cert status [--host <host>] [--port <port>] [--origin]
 ```
 
-Create or inspect local HTTPS certificates for the Dominds WebUI. Certificates live in `~/.dominds/certs/` and match DNS/IP hostnames, not ports; one certificate covers every WebUI port on that host.
+Create or inspect local HTTPS certificates for the Dominds WebUI. Dominds generates certificates through npm dependencies, so no separate `openssl` command is required. Certificates live in `~/.dominds/certs/` and match DNS/IP hostnames, not ports; one certificate covers every WebUI port on that host.
 
 **Options:**
 

package/dist/docs/cli-usage.zh.md

@@ -160,7 +160,7 @@ dominds cert create [--host <host>] [--days <days>] [--force]
 dominds cert status [--host <host>] [--port <port>] [--origin]
 ```
 
-创建或检查 Dominds WebUI 的本机 HTTPS 证书。证书保存在 `~/.dominds/certs/`，按 DNS/IP 主机名匹配，不绑定端口；同一张证书可覆盖该主机上的所有 WebUI 端口。
+创建或检查 Dominds WebUI 的本机 HTTPS 证书。证书由 Dominds 通过 npm 依赖生成，无需额外安装 `openssl` 等系统命令。证书保存在 `~/.dominds/certs/`，按 DNS/IP 主机名匹配，不绑定端口；同一张证书可覆盖该主机上的所有 WebUI 端口。
 
 **选项：**
 

package/dist/llm/gen/mock.js

@@ -326,9 +326,17 @@ class MockGen {
             if (trimmed !== '') {
                 variants.add(trimmed.toLowerCase());
             }
-            const tellaskStatusIndexZh = trimmed.lastIndexOf('\n[Dominds 诉请状态]\n');
-            const tellaskStatusIndexEn = trimmed.lastIndexOf('\n[Dominds tellask status]\n');
-            const tellaskStatusIndex = Math.max(tellaskStatusIndexZh, tellaskStatusIndexEn);
+            const tellaskStatusPrefixes = [
+                '\n[Dominds 诉请状态]\n',
+                '\n[Dominds tellask status]\n',
+                '\n[Dominds 等待人类回复]\n',
+                '\n[Dominds waiting for human answer]\n',
+                '\n[Dominds 等待队友回贴]\n',
+                '\n[Dominds waiting for teammate reply]\n',
+                '\n[Dominds 队友回贴状态]\n',
+                '\n[Dominds teammate reply status]\n',
+            ];
+            const tellaskStatusIndex = Math.max(...tellaskStatusPrefixes.map((prefix) => trimmed.lastIndexOf(prefix)));
             if (tellaskStatusIndex >= 0) {
                 const strippedTellaskStatus = trimmed.slice(0, tellaskStatusIndex).trim();
                 if (strippedTellaskStatus !== '') {

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

@@ -7,6 +7,7 @@ export type KernelDriverContextHealthDecision = Readonly<{
 }>;
 export declare const KERNEL_DRIVER_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS = 5;
 export declare const KERNEL_DRIVER_DEFAULT_CAUTION_REMEDIATION_CADENCE_GENERATIONS = 10;
+export declare function getContextHealthRemediationLevel(snapshot: ContextHealthSnapshot | undefined): 'caution' | 'critical' | undefined;
 export declare function resetContextHealthRoundState(dialogKey: string): void;
 export declare function resolveCriticalCountdownRemaining(dialogKey: string, snapshot: ContextHealthSnapshot | undefined): number;
 export declare function consumeCriticalCountdown(dialogKey: string): number;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KERNEL_DRIVER_DEFAULT_CAUTION_REMEDIATION_CADENCE_GENERATIONS = exports.KERNEL_DRIVER_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS = void 0;
+exports.getContextHealthRemediationLevel = getContextHealthRemediationLevel;
 exports.resetContextHealthRoundState = resetContextHealthRoundState;
 exports.resolveCriticalCountdownRemaining = resolveCriticalCountdownRemaining;
 exports.consumeCriticalCountdown = consumeCriticalCountdown;
@@ -9,6 +10,12 @@ exports.decideKernelDriverContextHealth = decideKernelDriverContextHealth;
 exports.KERNEL_DRIVER_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS = 5;
 exports.KERNEL_DRIVER_DEFAULT_CAUTION_REMEDIATION_CADENCE_GENERATIONS = 10;
 const stateByDialogKey = new Map();
+function getContextHealthRemediationLevel(snapshot) {
+    if (snapshot?.kind !== 'available') {
+        return undefined;
+    }
+    return snapshot.level === 'caution' || snapshot.level === 'critical' ? snapshot.level : undefined;
+}
 function getOrCreateState(dialogKey) {
     const existing = stateByDialogKey.get(dialogKey);
     if (existing)

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

@@ -34,6 +34,7 @@ const context_health_1 = require("./context-health");
 const events_1 = require("./events");
 const fbr_1 = require("./fbr");
 const guardrails_1 = require("./guardrails");
+const reminder_context_1 = require("./reminder-context");
 const reply_guidance_1 = require("./reply-guidance");
 const runtime_1 = require("./runtime");
 const tellask_special_1 = require("./tellask-special");
@@ -254,31 +255,31 @@ function isUserOriginPrompt(prompt) {
         return false;
     return prompt.origin === 'user' && normalizeQ4HAnswerCallId(prompt.q4hAnswerCallId) === undefined;
 }
-function resolveReminderContextFollowingDialogState(prompt, currentTurnDialogMsgsForContext) {
-    if (prompt === undefined || currentTurnDialogMsgsForContext.length === 0)
-        return 'none';
-    return prompt.origin === 'user' ? 'user_message' : 'runtime_notice';
-}
-function resolveReminderContextHealthState(snapshot) {
-    const remediationLevel = getContextHealthRemediationLevel(snapshot);
-    return remediationLevel === undefined ? 'normal' : remediationLevel;
-}
 async function resolveReminderContextFooterState(args) {
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
     const deferredReplyReassertion = latest?.deferredReplyReassertion;
     const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(args.dlg.id, args.dlg.status);
     const pendingUserInterjectionReply = latest?.pendingUserInterjectionReply !== undefined;
-    const interDialogReplyObligation = deferredReplyReassertion?.reason === 'user_interjection_with_parked_original_task'
-        ? 'parked_by_user_interjection'
-        : activeReplyObligation !== undefined
-            ? 'active'
-            : 'none';
-    return {
-        followingDialogState: resolveReminderContextFollowingDialogState(args.prompt, args.currentTurnDialogMsgsForContext),
+    const hasDeferredReplyReassertion = deferredReplyReassertion?.reason === 'user_interjection_with_parked_original_task';
+    const hasActiveReplyObligation = activeReplyObligation !== undefined;
+    // Business scenario: a user can reopen a completed Side Dialog to ask a follow-up. A recorded
+    // final response with no active/parked reply task means the old handoff has already been
+    // reported back; if a real user message is now present, the footer should say "talk with the
+    // user now" instead of making the model infer that from old transcript/reminder context.
+    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(),
         pendingUserInterjectionReply,
-        interDialogReplyObligation,
-        contextHealthState: resolveReminderContextHealthState(args.dlg.getLastContextHealth()),
-    };
+        hasCompletedHandoffWithoutPendingReply,
+        hasDeferredReplyReassertion,
+        hasActiveReplyObligation,
+    });
 }
 function splitDialogMsgsForReminderInsertion(args) {
     const msgId = args.currentPrompt?.msgId;
@@ -722,12 +723,6 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
 const CONTEXT_HEALTH_TOOL_RESULT_VISIBLE_BYTE_LIMIT = 2000;
 const CONTEXT_HEALTH_LARGE_TOOL_RETURN_UNAVAILABLE_ZH = '这次函数返回内容太大，清理头脑之前不会显示给你。';
 const CONTEXT_HEALTH_LARGE_TOOL_RETURN_UNAVAILABLE_EN = 'This function returned too much content. It will not be shown to you before you clear your mind.';
-function getContextHealthRemediationLevel(snapshot) {
-    if (snapshot?.kind !== 'available') {
-        return undefined;
-    }
-    return snapshot.level === 'caution' || snapshot.level === 'critical' ? snapshot.level : undefined;
-}
 function pickContextHealthForLargeToolResultVisibility(args) {
     if (args.current?.kind === 'available') {
         return args.current;
@@ -809,7 +804,7 @@ function countToolResultVisibleBytes(output) {
     return bytes;
 }
 function applyContextHealthToolResultVisibilityLimit(args) {
-    if (getContextHealthRemediationLevel(args.contextHealth) === undefined) {
+    if ((0, context_health_1.getContextHealthRemediationLevel)(args.contextHealth) === undefined) {
         return { output: args.output, largeReturnUnavailable: false };
     }
     const visibleBytes = countToolResultVisibleBytes(args.output);
@@ -1336,7 +1331,7 @@ function formatInvalidFuncCallRuntimeGuide(language, call) {
     const indexLine = call.toolCallIndex === undefined ? undefined : `- toolCallIndex: ${String(call.toolCallIndex)}`;
     if (language === 'en') {
         return [
-            '[Runtime notice] The previous model output contained an invalid tool-call payload that could not be represented as a normal provider tool call in the next generation context.',
+            '[Runtime notice] Your previous response tried to call a tool, but the tool call was malformed and could not be run.',
             '',
             `- provider: ${call.provider}`,
             `- callId: ${call.callId}`,
@@ -1348,13 +1343,13 @@ function formatInvalidFuncCallRuntimeGuide(language, call) {
             '```',
             ...(indexLine === undefined ? [] : [indexLine]),
             '',
-            'Treat that payload as failed. Do not assume the tool ran. Continue from the current task, and if a tool call is still needed, emit a new valid tool call with a non-empty function name and valid arguments.',
+            'Treat that tool call as failed. Do not assume the tool ran. Continue the current task; if you still need a tool, call it again with a real tool name and valid arguments.',
         ]
             .filter((line) => line.length > 0)
             .join('\n');
     }
     return [
-        '[运行时提示] 上一轮模型输出包含一个无效工具调用载荷，无法按正常 provider tool call 形态进入下一轮生成上下文。',
+        '[Dominds 提示] 你上一轮尝试调用工具，但工具调用格式无效，Dominds 没有执行它。',
         '',
         `- provider: ${call.provider}`,
         `- callId: ${call.callId}`,
@@ -1366,7 +1361,7 @@ function formatInvalidFuncCallRuntimeGuide(language, call) {
         '```',
         ...(indexLine === undefined ? [] : [indexLine]),
         '',
-        '请把该载荷视为调用失败，不要假设工具已经执行。继续当前任务；如果仍需要调用工具，请重新发起一个函数名非空、参数有效的新工具调用。',
+        '请把这次工具调用视为失败，不要假设工具已经执行。继续当前任务；如果仍需要工具，请重新发起一次工具名明确、参数有效的调用。',
     ]
         .filter((line) => line.length > 0)
         .join('\n');

package/dist/llm/kernel-driver/idle-reminder-wake.js

@@ -89,15 +89,19 @@ function buildAggregatedWakePromptContent(events) {
         return `${String(index + 1)}. ${eventText}`;
     })
         .join('\n\n');
+    // Business scenario: several reminder/environment wakes arrived while the dialog was idle.
+    // The model needs the events as state updates, but they are not a new human request and should
+    // not trigger a standalone acknowledgement. Say the product meaning plainly instead of exposing
+    // internal "runtime event" wording.
     return language === 'zh'
         ? `${prefix}
-以下是对话空闲期间发生的 runtime 环境事件。这些事件不是新的用户指令。
+以下是对话空闲期间 Dominds 收到的环境事件。这些事件不是新的用户指令。
 
 ${body}
 
 请结合当前任务上下文继续推进；若这些事件不影响当前工作，不要发送占位式确认。`
         : `${prefix}
-The following runtime environment events happened while the dialog was idle. These events are not new user instructions.
+The following environment events reached Dominds while the dialog was idle. These events are not new user instructions.
 
 ${body}
 

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

@@ -0,0 +1,26 @@
+import type { ContextHealthSnapshot } from '@longrun-ai/kernel/types/context-health';
+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: {
+    prompt: KernelDriverPrompt | undefined;
+    currentTurnDialogMsgsForContext: readonly ChatMessage[];
+}): ReminderContextFollowingMessage;
+export declare function resolveReminderContextHealth(snapshot: ContextHealthSnapshot | undefined): ReminderContextHealth;
+export declare function resolveReminderContextBusinessState(args: {
+    followingMessage: ReminderContextFollowingMessage;
+    pendingUserInterjectionReply: boolean;
+    hasCompletedHandoffWithoutPendingReply: boolean;
+    hasDeferredReplyReassertion: boolean;
+    hasActiveReplyObligation: boolean;
+}): ReminderContextBusiness;
+export declare function resolveReminderContextFooterStateFromSignals(args: {
+    dialogScope: ReminderContextDialogScope;
+    prompt: KernelDriverPrompt | undefined;
+    currentTurnDialogMsgsForContext: readonly ChatMessage[];
+    contextHealth: ContextHealthSnapshot | undefined;
+    pendingUserInterjectionReply: boolean;
+    hasCompletedHandoffWithoutPendingReply: boolean;
+    hasDeferredReplyReassertion: boolean;
+    hasActiveReplyObligation: boolean;
+}): ReminderContextFooterState;

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveReminderContextFollowingMessage = resolveReminderContextFollowingMessage;
+exports.resolveReminderContextHealth = resolveReminderContextHealth;
+exports.resolveReminderContextBusinessState = resolveReminderContextBusinessState;
+exports.resolveReminderContextFooterStateFromSignals = resolveReminderContextFooterStateFromSignals;
+const context_health_1 = require("./context-health");
+function resolveReminderContextFollowingMessage(args) {
+    if (args.prompt === undefined || args.currentTurnDialogMsgsForContext.length === 0) {
+        return { kind: 'none' };
+    }
+    if (args.prompt.origin !== 'user') {
+        return { kind: 'runtime_notice' };
+    }
+    return typeof args.prompt.q4hAnswerCallId === 'string' &&
+        args.prompt.q4hAnswerCallId.trim() !== ''
+        ? { kind: 'human_answer' }
+        : { kind: 'user_message' };
+}
+function resolveReminderContextHealth(snapshot) {
+    const remediationLevel = (0, context_health_1.getContextHealthRemediationLevel)(snapshot);
+    return remediationLevel === undefined ? { kind: 'normal' } : { kind: remediationLevel };
+}
+function resolveReminderContextBusinessState(args) {
+    if (args.followingMessage.kind === 'human_answer') {
+        // askHuman answers resume a waiting task. They are not fresh user follow-ups and should not
+        // inherit interjection or completed-handoff wording from adjacent durable state.
+        return { kind: 'none' };
+    }
+    if (args.followingMessage.kind === 'user_message' &&
+        args.hasCompletedHandoffWithoutPendingReply) {
+        // Business scenario: the requester-side work has already received its final report, and now a
+        // user is speaking again inside that completed Side Dialog. Dominds can know this from durable
+        // handoff state; the model should hear the simple product meaning directly instead of guessing
+        // from older task context or reminder-maintenance references.
+        return { kind: 'user_followup_after_completed_handoff' };
+    }
+    if (args.pendingUserInterjectionReply) {
+        // User-visible reply gaps take priority over handoff continuation state. The completed
+        // handoff case is most specific: Dominds already knows the old delegated task is done. The
+        // footer should say there is no old handoff to advance and the model should handle the current
+        // user message normally. Do not narrow this to "only answer" or "do not organize reminders":
+        // a user may explicitly ask for reminder cleanup/correction as the current conversation topic.
+        //
+        // This branch may run on a later tool-followup turn where no user message immediately
+        // follows the reminder block anymore. That is still the same pending user follow-up; do not
+        // demote it to generic auto-continuation wording just because the prompt itself is absent
+        // on this retry/continuation round.
+        if (args.hasCompletedHandoffWithoutPendingReply) {
+            return { kind: 'user_followup_after_completed_handoff' };
+        }
+        if (args.hasDeferredReplyReassertion) {
+            return { kind: 'pending_user_interjection_with_parked_reply' };
+        }
+        if (args.hasActiveReplyObligation) {
+            return { kind: 'pending_user_interjection_with_active_reply' };
+        }
+        return { kind: 'pending_user_interjection' };
+    }
+    if (args.hasActiveReplyObligation) {
+        return { kind: 'active_reply_obligation' };
+    }
+    return { kind: 'none' };
+}
+function resolveReminderContextFooterStateFromSignals(args) {
+    const followingMessage = resolveReminderContextFollowingMessage({
+        prompt: args.prompt,
+        currentTurnDialogMsgsForContext: args.currentTurnDialogMsgsForContext,
+    });
+    return {
+        followingMessage,
+        contextHealth: resolveReminderContextHealth(args.contextHealth),
+        dialogScope: args.dialogScope,
+        business: resolveReminderContextBusinessState({
+            followingMessage,
+            pendingUserInterjectionReply: args.pendingUserInterjectionReply,
+            hasCompletedHandoffWithoutPendingReply: args.hasCompletedHandoffWithoutPendingReply,
+            hasDeferredReplyReassertion: args.hasDeferredReplyReassertion,
+            hasActiveReplyObligation: args.hasActiveReplyObligation,
+        }),
+    };
+}

package/dist/llm/kernel-driver/reply-guidance.js

@@ -38,6 +38,12 @@ function buildPromptContentWithExactReplyToolName(args) {
     ];
     const directive = args.activeReplyDirective;
     if (!directive) {
+        // Business scenario: a user can come back to a Side Dialog after its final reply has already
+        // been delivered to the requester. At that point the business obligation is complete and the
+        // visible user is simply asking a follow-up in this dialog. Old assignment text and reply tool
+        // names remain in transcript history, so the model may otherwise "finish" the old request
+        // again. Dominds has already checked durable reply state here; the prompt says the current
+        // business expectation directly: answer/continue this conversation normally.
         if (isFbrSideDialog) {
             return args.prompt.content;
         }
@@ -50,13 +56,13 @@ function buildPromptContentWithExactReplyToolName(args) {
         const note = args.language === 'zh'
             ? [
                 noActivePrefix,
-                '当前没有待完成的跨对话回复义务。',
-                '这轮不要调用任何 `reply*`；直接按当前本地对话继续即可。',
+                'Dominds 已经判断好：当前没有别的对话在等你发送最终回贴。',
+                '本轮按当前对话正常交流即可；如果用户提出了问题，就直接回答这个问题。',
             ].join('\n')
             : [
                 noActivePrefix,
-                'There is no active inter-dialog reply obligation right now.',
-                'Do not call any `reply*` tool in this turn; just continue the current local conversation.',
+                'Dominds has already decided that no other dialog is waiting for your final reply right now.',
+                'Handle this as a normal turn in the current conversation; if the user asked a question, answer that question directly.',
             ].join('\n');
         return `${note}\n\n${args.prompt.content}`;
     }