dominds 1.23.6 → 1.23.8

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

@@ -81,6 +81,7 @@ function isNonIdleDisplayProjection(state) {
     return state !== undefined && state.kind !== 'idle_waiting_user';
 }
 function resolveDirectFallbackResponse(args) {
+    let saying;
     if (args.driveResult.lastAssistantSayingContent !== null &&
         args.driveResult.lastAssistantSayingContent.trim() !== '') {
         if (typeof args.driveResult.lastAssistantSayingGenseq !== 'number' ||
@@ -88,16 +89,22 @@ function resolveDirectFallbackResponse(args) {
             args.driveResult.lastAssistantSayingGenseq <= 0) {
             throw new Error(`Direct reply fallback invariant violation: missing lastAssistantSayingGenseq for dialog=${args.dialog.id.valueOf()}`);
         }
-        return {
+        saying = {
             responseText: args.driveResult.lastAssistantSayingContent,
             responseGenseq: Math.floor(args.driveResult.lastAssistantSayingGenseq),
             source: 'saying',
         };
     }
-    // Thinking-only output is intentionally a fallback candidate: some providers/models can finish a
-    // Side Dialog with useful content in thinking and no public saying. This helper only extracts the
-    // candidate; callers below must still reject it when a same-round function/tellask call needs
-    // auto-continuation, when the dialog is suspended, or when another follow-up prompt is queued.
+    // Thinking output is intentionally a fallback candidate: some providers/models can finish a
+    // Side Dialog with useful content in thinking and no public saying. Pick the newest non-empty
+    // assistant generation candidate across the whole drive, preferring public saying over thinking
+    // on the same generation. A post-tool thinking segment must not be shadowed by an older pre-tool
+    // saying segment from an earlier generation iteration.
+    //
+    // This helper only extracts the candidate; callers below must still reject it when a same-round
+    // function/tellask call needs auto-continuation, when the dialog is suspended, or when another
+    // follow-up prompt is queued.
+    let thinking;
     if (args.driveResult.lastAssistantThinkingContent !== null &&
         args.driveResult.lastAssistantThinkingContent.trim() !== '') {
         if (typeof args.driveResult.lastAssistantThinkingGenseq !== 'number' ||
@@ -105,13 +112,16 @@ function resolveDirectFallbackResponse(args) {
             args.driveResult.lastAssistantThinkingGenseq <= 0) {
             throw new Error(`Direct reply fallback invariant violation: missing lastAssistantThinkingGenseq for dialog=${args.dialog.id.valueOf()}`);
         }
-        return {
+        thinking = {
             responseText: args.driveResult.lastAssistantThinkingContent,
             responseGenseq: Math.floor(args.driveResult.lastAssistantThinkingGenseq),
             source: 'thinking_only',
         };
     }
-    return undefined;
+    if (saying !== undefined && thinking !== undefined) {
+        return saying.responseGenseq >= thinking.responseGenseq ? saying : thinking;
+    }
+    return saying ?? thinking;
 }
 async function buildReplyToolReminderPrompt(args) {
     return (0, reply_prompt_copy_1.buildReplyToolReminderText)({
@@ -209,79 +219,6 @@ async function loadPendingDiagnosticsSnapshot(args) {
         };
     }
 }
-async function hasAssistantOutputAfterAssignmentAnchor(args) {
-    const events = await persistence_1.DialogPersistence.loadCourseEvents(args.dialog.id, args.dialog.currentCourse, args.dialog.status);
-    let assignmentGenseq;
-    for (const event of events) {
-        if (event.type === 'tellask_anchor_record' &&
-            event.anchorRole === 'assignment' &&
-            event.callId === args.callId) {
-            assignmentGenseq = event.genseq;
-            continue;
-        }
-        if (assignmentGenseq !== undefined &&
-            (event.type === 'agent_thought_record' || event.type === 'agent_words_record') &&
-            event.genseq >= assignmentGenseq &&
-            event.content.trim() !== '') {
-            return true;
-        }
-    }
-    return false;
-}
-async function resolveStrandedSideDialogReplyReminderFollowUp(args) {
-    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dialog.id, args.dialog.status);
-    const displayState = latest?.displayState;
-    const isRecoverableProjection = displayState?.kind === 'idle_waiting_user' ||
-        (displayState?.kind === 'stopped' && displayState.reason.kind === 'pending_reply_obligation');
-    if (!latest ||
-        !isRecoverableProjection ||
-        latest.pendingCourseStartPrompt !== undefined ||
-        latest.executionMarker?.kind === 'dead') {
-        return undefined;
-    }
-    const directive = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(args.dialog);
-    if (!directive) {
-        return undefined;
-    }
-    const ownerDialogId = directive.targetDialogId.trim();
-    if (ownerDialogId === '') {
-        throw new Error(`stranded sideDialog reply recovery invariant violation: empty targetDialogId ` +
-            `(dialogId=${args.dialog.id.valueOf()}, targetCallId=${directive.targetCallId})`);
-    }
-    const pending = await persistence_1.DialogPersistence.loadPendingSideDialogs(new dialog_1.DialogID(ownerDialogId, args.dialog.id.rootId), args.dialog.status);
-    const pendingRecord = pending.find((record) => record.sideDialogId === args.dialog.id.selfId && record.callId === directive.targetCallId);
-    if (!pendingRecord) {
-        return undefined;
-    }
-    if (!(await hasAssistantOutputAfterAssignmentAnchor({
-        dialog: args.dialog,
-        callId: pendingRecord.callId,
-    }))) {
-        return undefined;
-    }
-    const language = (0, work_language_1.getWorkLanguage)();
-    const sideDialogReplyTarget = {
-        ownerDialogId,
-        callType: pendingRecord.callType,
-        callId: pendingRecord.callId,
-        callSiteCourse: pendingRecord.callSiteCourse,
-        callSiteGenseq: pendingRecord.callSiteGenseq,
-    };
-    return {
-        kind: 'runtime_sideDialog_reply_reminder',
-        prompt: await buildReplyToolReminderPrompt({
-            dlg: args.dialog,
-            directive,
-            language,
-        }),
-        msgId: (0, id_1.generateShortId)(),
-        grammar: 'markdown',
-        origin: 'runtime',
-        userLanguageCode: language,
-        tellaskReplyDirective: directive,
-        sideDialogReplyTarget,
-    };
-}
 async function clearConsumedDeferredRootQueueIfIdle(dialog) {
     if (dialog.id.selfId !== dialog.id.rootId) {
         return;
@@ -658,6 +595,7 @@ async function executeDriveRound(args) {
     let activeRunPrimed = false;
     let ownsActiveRun = false;
     let interruptedBySignal = false;
+    let shouldRefreshDisplayStateAfterActiveRunCleared = false;
     let followUp;
     let driveResult;
     let sideDialogReplyTarget;
@@ -740,29 +678,6 @@ async function executeDriveRound(args) {
         // suspended by pending Q4H or sideDialogs. This prevents duplicate generations when
         // multiple wake-ups race around the same sideDialog completion boundary.
         if (!humanPrompt) {
-            if (dialog instanceof dialog_1.SideDialog && !dialog.hasUpNext()) {
-                const strandedReplyReminder = await resolveStrandedSideDialogReplyReminderFollowUp({
-                    dialog,
-                });
-                if (strandedReplyReminder !== undefined) {
-                    await queueReplyReminderFollowUp({ dialog, followUp: strandedReplyReminder });
-                    args.scheduleDrive(dialog, {
-                        waitInQue: true,
-                        driveOptions: {
-                            source: 'kernel_driver_follow_up',
-                            reason: 'follow_up_prompt',
-                        },
-                    });
-                    log_1.log.warn('kernel-driver recovered stranded sideDialog reply obligation by queueing reply reminder', undefined, {
-                        dialogId: dialog.id.valueOf(),
-                        rootId: dialog.id.rootId,
-                        selfId: dialog.id.selfId,
-                        targetCallId: strandedReplyReminder.tellaskReplyDirective.targetCallId,
-                        targetOwnerDialogId: strandedReplyReminder.sideDialogReplyTarget.ownerDialogId,
-                    });
-                    return;
-                }
-            }
             if (dialog instanceof dialog_1.SideDialog && !dialog.hasUpNext()) {
                 try {
                     const inspection = await inspectNoPromptSideDialogDrive({ dialog, driveOptions });
@@ -1022,12 +937,20 @@ async function executeDriveRound(args) {
                 (driveResult.fbrConclusion !== undefined ||
                     resolveDirectFallbackResponse({ driveResult, dialog }) !== undefined)) {
                 if (driveResult.fbrConclusion) {
-                    await (0, sideDialog_1.supplySideDialogResponseToAssignedAskerIfPendingV2)({
+                    const suppliedFbrConclusion = await (0, sideDialog_1.supplySideDialogResponseToAssignedAskerIfPendingV2)({
                         sideDialog: dialog,
                         responseText: driveResult.fbrConclusion.responseText,
                         responseGenseq: driveResult.fbrConclusion.responseGenseq,
+                        replyResolution: {
+                            callId: driveResult.fbrConclusion.replyResolutionCallId,
+                            replyCallName: 'replyTellaskSessionless',
+                        },
                         scheduleDrive: args.scheduleDrive,
                     });
+                    if (!suppliedFbrConclusion) {
+                        throw new Error(`FBR conclusion delivery invariant violation: no pending asker target for dialog=${dialog.id.valueOf()}`);
+                    }
+                    shouldRefreshDisplayStateAfterActiveRunCleared = true;
                 }
                 else {
                     const directFallbackResponse = resolveDirectFallbackResponse({ driveResult, dialog });
@@ -1334,6 +1257,18 @@ async function executeDriveRound(args) {
         if (activeRunPrimed && ownsActiveRun) {
             (0, dialog_display_state_1.clearActiveRun)(dialog.id);
         }
+        if (shouldRefreshDisplayStateAfterActiveRunCleared && !(0, dialog_display_state_1.hasActiveRun)(dialog.id)) {
+            try {
+                await (0, dialog_display_state_1.setDialogDisplayState)(dialog.id, await (0, dialog_display_state_1.computeIdleDisplayState)(dialog));
+            }
+            catch (error) {
+                log_1.log.warn('kernel-driver failed to refresh display state after FBR auto-delivery', error, {
+                    dialogId: dialog.id.valueOf(),
+                    rootId: dialog.id.rootId,
+                    selfId: dialog.id.selfId,
+                });
+            }
+        }
         release();
         (0, idle_reminder_wake_1.maybeStartIdleReminderWake)(dialog, {
             scheduleDrive: args.scheduleDrive,

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

@@ -867,6 +867,8 @@ async function runLlmRequestWithRetry(params) {
                         errorText: detail,
                     },
                 });
+            }
+            if (failure.kind === 'rejected' && handledFailure.handling.kind !== 'give_up') {
                 let streamErrorEmitted = false;
                 try {
                     await params.dlg.streamError(detail);
@@ -941,7 +943,7 @@ async function runLlmRequestWithRetry(params) {
                             reason: interruptionReason,
                         });
                     }
-                    log_1.log.warn('LLM retriable failure stopped retry flow', undefined, {
+                    log_1.log.warn('LLM failure stopped retry flow', undefined, {
                         provider: params.provider,
                         dialogId: params.dlg.id.valueOf(),
                         rootId: params.dlg.id.rootId,

package/dist/llm/kernel-driver/types.d.ts

@@ -114,6 +114,7 @@ export type KernelDriverCoreResult = {
     fbrConclusion?: {
         responseText: string;
         responseGenseq: number;
+        replyResolutionCallId: string;
     };
 };
 export declare function createKernelDriverRuntimeState(): KernelDriverRuntimeState;

package/dist/persistence.js

@@ -520,6 +520,12 @@ function parseDialogLlmRetryRecoveryAction(value) {
             return { kind: 'none' };
         case 'diligence_push_once':
             return { kind: 'diligence_push_once' };
+        case 'runtime_prompt_once': {
+            const content = value.content;
+            if (typeof content !== 'string' || content.trim() === '')
+                return null;
+            return { kind: 'runtime_prompt_once', content };
+        }
         default:
             return null;
     }

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

@@ -1,5 +1,6 @@
 import { type LanguageCode } from '@longrun-ai/kernel/types/language';
 export declare function formatSystemNoticePrefix(language: LanguageCode): string;
+export declare function formatAutoMaintainedReminderManualMirrorBan(language: LanguageCode): string;
 export declare function formatCurrentUserLanguagePreference(workingLanguage: LanguageCode, uiLanguage: LanguageCode): string;
 export declare function formatUserLanguagePreferenceChangedNotice(workingLanguage: LanguageCode, previousUiLanguage: LanguageCode, nextUiLanguage: LanguageCode): string;
 export declare function formatRegisteredTellaskTellaskerUpdateNotice(language: LanguageCode): string;

package/dist/runtime/driver-messages.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatSystemNoticePrefix = formatSystemNoticePrefix;
+exports.formatAutoMaintainedReminderManualMirrorBan = formatAutoMaintainedReminderManualMirrorBan;
 exports.formatCurrentUserLanguagePreference = formatCurrentUserLanguagePreference;
 exports.formatUserLanguagePreferenceChangedNotice = formatUserLanguagePreferenceChangedNotice;
 exports.formatRegisteredTellaskTellaskerUpdateNotice = formatRegisteredTellaskTellaskerUpdateNotice;
@@ -23,6 +24,11 @@ const language_1 = require("@longrun-ai/kernel/types/language");
 function formatSystemNoticePrefix(language) {
     return language === 'zh' ? '【系统提示】' : '[System notice]';
 }
+function formatAutoMaintainedReminderManualMirrorBan(language) {
+    return language === 'zh'
+        ? '这条状态由系统维护；禁止把它抄进、改写进、或同步维护到你手工创建的提醒项里。'
+        : 'This state is system-maintained; do not copy, rewrite, or separately maintain it in manual reminders.';
+}
 function formatCurrentUserLanguagePreference(workingLanguage, uiLanguage) {
     const uiName = (0, language_1.formatLanguageName)(uiLanguage, workingLanguage);
     const workingName = (0, language_1.formatLanguageName)(workingLanguage, workingLanguage);
@@ -290,15 +296,15 @@ function formatReminderItemGuide(language, reminderId, content, options) {
         : undefined;
     const deleteInstruction = language === 'zh'
         ? deleteAltInstruction
-            ? `如果你要删除这条提醒项，不能用 delete_reminder；请执行：${deleteAltInstruction}`
+            ? `删除通道：不要用 delete_reminder；请执行：${deleteAltInstruction}`
             : isPendingTellaskReminder && pendingTellaskCount === 0
-                ? `如果你已确认这里只是清理噪音、并非要推进动作，可执行：delete_reminder({ "reminder_id": "${reminderId}" })`
-                : `如果你要删除这条提醒项，可执行：delete_reminder({ "reminder_id": "${reminderId}" })`
+                ? `清理噪音时可删除：delete_reminder({ "reminder_id": "${reminderId}" })`
+                : `删除通道：delete_reminder({ "reminder_id": "${reminderId}" })`
         : deleteAltInstruction
-            ? `If you need to delete this reminder, do not use delete_reminder; run: ${deleteAltInstruction}`
+            ? `Delete path: do not use delete_reminder; run: ${deleteAltInstruction}`
             : isPendingTellaskReminder && pendingTellaskCount === 0
-                ? `If you have confirmed this is only noise cleanup and not an action step, you may run: delete_reminder({ "reminder_id": "${reminderId}" })`
-                : `If you need to delete this reminder, run: delete_reminder({ "reminder_id": "${reminderId}" })`;
+                ? `Noise cleanup delete path: delete_reminder({ "reminder_id": "${reminderId}" })`
+                : `Delete path: delete_reminder({ "reminder_id": "${reminderId}" })`;
     const projectionNote = formatReminderItemProjectionNote(language);
     const enProjectionPrefix = `${projectionNote} `;
     const systemPrefix = formatSystemNoticePrefix(language);
@@ -309,12 +315,13 @@ function formatReminderItemGuide(language, reminderId, content, options) {
                 `${systemPrefix} 提醒项 [${reminderId}]（工具状态）`,
                 '',
                 `${projectionNote}当前运行环境中有一条由工具 ${managementTool} 管理的状态提醒项。请把它当作环境/工具状态参考，不要当作你自己写的工作便签。`,
+                formatAutoMaintainedReminderManualMirrorBan(language),
                 '',
                 '默认不要在对外回复里专门确认、复述或总结它；只有它实际改变你的判断、计划或风险时，才提炼真正相关的部分。',
                 '',
-                `这条提醒项由工具 ${managementTool} 管理；如果你要调整它，就用 ${managementTool}（不要用 update_reminder）。`,
+                `调整通道：使用 ${managementTool}；不要用 update_reminder。`,
                 '',
-                `如果你要更新这条提醒项，可执行：${updateInstructionSafe}`,
+                `更新通道：${updateInstructionSafe}`,
                 deleteInstruction,
                 '',
                 '---',
@@ -326,8 +333,9 @@ function formatReminderItemGuide(language, reminderId, content, options) {
                 `${systemPrefix} 提醒项 [${reminderId}]`,
                 '',
                 `${projectionNote}当前运行环境中有一条带有 meta 控制更新规则的提醒项。请把它当作状态参考，不要用 update_reminder 直接改写内容。`,
+                formatAutoMaintainedReminderManualMirrorBan(language),
                 '',
-                `如果你要更新这条提醒项，不能用 update_reminder；请按此处理：${updateInstruction}`,
+                `更新通道：不要用 update_reminder；请按此处理：${updateInstruction}`,
                 deleteInstruction,
                 '',
                 '---',
@@ -373,11 +381,13 @@ function formatReminderItemGuide(language, reminderId, content, options) {
 
 ${enProjectionPrefix}The current runtime environment has a tool-managed state reminder from ${managementTool}. Treat it as environment/tool state, not as your self-authored work note.
 
+${formatAutoMaintainedReminderManualMirrorBan(language)}
+
 By default, do not explicitly acknowledge, restate, or summarize it in your outward reply; only extract the parts that materially change your current judgment, plan, or risk.
 
-This reminder is managed by tool ${managementTool}; if you need to change it, use ${managementTool} instead of update_reminder.
+Change path: use ${managementTool}; do not use update_reminder.
 
-If you need to update this reminder, run: ${updateInstructionSafe}
+Update path: ${updateInstructionSafe}
 ${deleteInstruction}
 ---
 ${content}`;
@@ -387,7 +397,9 @@ ${content}`;
 
 ${enProjectionPrefix}The current runtime environment has a reminder with a meta-controlled update path. Treat it as state/reference, and do not rewrite it directly with update_reminder.
 
-If you need to update this reminder, do not use update_reminder; follow instead: ${updateInstruction}
+${formatAutoMaintainedReminderManualMirrorBan(language)}
+
+Update path: do not use update_reminder; follow instead: ${updateInstruction}
 ${deleteInstruction}
 ---
 ${content}`;
@@ -399,7 +411,7 @@ ${enProjectionPrefix}You set a continuation reminder so the runtime system can r
 
 Keep the next step, key pointers, run/verify info, and easy-to-lose volatile details here. Do not duplicate Taskdoc content. In the new course, your first step is to review and rewrite this with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress it into a high-quality reminder. If this is only a rough bridge note, reconcile it early in the new course.
 
-If you need to update this package, run: update_reminder({ "reminder_id": "${reminderId}", "content": "..." })
+Update path: update_reminder({ "reminder_id": "${reminderId}", "content": "..." })
 ${deleteInstruction}
 ---
 ${content}`;
@@ -414,7 +426,7 @@ ${scope === 'personal'
         ? 'Keep it concise, refresh it when needed, and delete it when obsolete. If it is only useful for the current dialog, rewrite it into dialog scope instead of letting personal scope accumulate noise.'
         : 'Keep it concise, refresh it when needed, and delete it when obsolete. If you are preparing a new course, you can also rewrite it into a continuation package.'}
 
-If you need to update this reminder, run: update_reminder({ "reminder_id": "${reminderId}", "content": "..." })
+Update path: update_reminder({ "reminder_id": "${reminderId}", "content": "..." })
 ${deleteInstruction}
 ---
 ${content}`;

package/dist/server/websocket-handler.js

@@ -597,8 +597,8 @@ async function handleDeclareSideDialogDead(ws, packet) {
     const responseTextWithNote = note === ''
         ? responseText
         : (0, work_language_1.getWorkLanguage)() === 'zh'
-            ? `${responseText}\n\n使用者补充（来自输入框）：\n${note}`
-            : `${responseText}\n\nUser note (from the input box):\n${note}`;
+            ? `${responseText}\n\n人类用户补充：\n${note}`
+            : `${responseText}\n\nHuman user note:\n${note}`;
     await (0, kernel_driver_1.supplyResponseToAskerDialog)(parentDialog, dialogIdObj, responseTextWithNote, pendingRecord.callType, assignmentFromAsker.callId, 'failed');
 }
 async function handleSetDiligencePush(ws, packet) {

package/dist/tools/app-reminders.js

@@ -168,6 +168,18 @@ function fallbackRenderedReminder(reminder) {
         }),
     };
 }
+function formatAppReminderWrapperPrelude(language) {
+    return language === 'zh'
+        ? `这是 app 自动维护的状态提醒，不是你自己写的工作便签。${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}`
+        : `This is app-maintained state, not a work note you wrote. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}`;
+}
+function wrapAppRenderedReminder(message, language) {
+    return {
+        type: 'environment_msg',
+        role: 'user',
+        content: `${formatAppReminderWrapperPrelude(language)}\n\n${message.content}`,
+    };
+}
 async function persistAndPublishReminders(dlg) {
     await dlg.dlgStore.persistReminders(dlg, dlg.reminders);
     const sharedReminders = await (0, shared_reminders_1.loadAgentSharedReminders)(dlg.agentId);
@@ -229,12 +241,14 @@ function createAppReminderOwner(params) {
             }
             try {
                 const client = await resolveHostClient();
-                return await client.renderReminder(descriptor.appId, descriptor.ownerRef, {
+                const language = (0, work_language_1.getWorkLanguage)();
+                const rendered = await client.renderReminder(descriptor.appId, descriptor.ownerRef, {
                     dialogId: dlg.id.selfId,
                     reminder: toReminderState(reminder),
                     reminderId: reminder.id,
-                    workLanguage: (0, work_language_1.getWorkLanguage)(),
+                    workLanguage: language,
                 });
+                return wrapAppRenderedReminder(rendered, language);
             }
             catch (error) {
                 log_1.log.warn('App reminder render failed; using generic reminder rendering', error, {

package/dist/tools/mcp.js

@@ -198,8 +198,8 @@ exports.mcpLeaseReminderOwner = {
                 type: 'environment_msg',
                 role: 'user',
                 content: workLanguage === 'zh'
-                    ? `${prefix} MCP 工具集租约提醒 [${reminder.id}]\n你正在查看系统维护的 MCP 租约状态，不要把它当成你自己写的工作便签。\n\n${reminder.content}`
-                    : `${prefix} MCP toolset lease reminder [${reminder.id}]\nYou are looking at system-maintained MCP lease state. Do not treat it as a self-authored work note.\n\n${reminder.content}`,
+                    ? `${prefix} MCP 工具集租约提醒 [${reminder.id}]\n这是系统自动维护的 MCP 租约状态，不是你自己写的工作便签。${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(workLanguage)}\n\n${reminder.content}`
+                    : `${prefix} MCP toolset lease reminder [${reminder.id}]\nThis is system-maintained MCP lease state, not a work note you wrote. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(workLanguage)}\n\n${reminder.content}`,
             };
         }
         const serverId = reminder.meta.serverId;
@@ -211,6 +211,7 @@ exports.mcpLeaseReminderOwner = {
                     `${prefix} MCP 工具集租约 [${reminder.id}]: \`${serverId}\``,
                     '',
                     `你当前看到的是系统维护的 MCP 租约状态。该 MCP server 被视为非“真正无状态”；当前对话持有一个 MCP 运行时实例（HTTP 连接或 stdio 进程）。`,
+                    (0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(workLanguage),
                     '',
                     `当你确认近期不再需要这个运行时实例时，请释放它，以停止/回收底层 MCP 进程或连接：`,
                     `- \`mcp_release({\"serverId\":\"${serverId}\"})\``,
@@ -221,6 +222,7 @@ exports.mcpLeaseReminderOwner = {
                     `${prefix} MCP toolset lease [${reminder.id}]: \`${serverId}\``,
                     '',
                     `You are looking at system-maintained MCP lease state. This MCP server is treated as non-stateless, and the current dialog holds one MCP runtime instance for it (an HTTP connection or stdio process).`,
+                    (0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(workLanguage),
                     '',
                     `When you are confident you will not need this runtime instance soon, release it to stop the underlying MCP process/connection:`,
                     `- \`mcp_release({\"serverId\":\"${serverId}\"})\``,

package/dist/tools/os.js

@@ -547,7 +547,7 @@ async function waitForShellCmdReminderWakeEvent(reminder, signal) {
 function getOsToolMessages(language) {
     if (language === 'zh') {
         return {
-            daemonStarted: (pid, timeoutSeconds, command) => `🟢 ${command} 已转入后台持续运行（PID: ${pid}）\n该进程在 ${timeoutSeconds} 秒内未完成，现已作为守护进程继续执行。你将看到同一条生命周期提醒持续刷新：系统维护 / 实时真源 / 不可删除。\n\n需要时可使用 stop_daemon({"pid": ${pid}}) 终止该进程。`,
+            daemonStarted: (pid, timeoutSeconds, command) => `🟢 ${command} 已转入后台持续运行（PID: ${pid}）\n该进程在 ${timeoutSeconds} 秒内未完成，现已作为守护进程继续执行。你将看到同一条生命周期提醒持续刷新：系统维护 / 实时真源 / 不可删除。${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}\n\n需要时可使用 stop_daemon({"pid": ${pid}}) 终止该进程。`,
             commandCompleted: (exitCode, scrollNotice) => `✅ 命令已完成（退出码：${exitCode ?? 'unknown'}）${scrollNotice}\n\n`,
             scrolledLinesNotice: (lines) => `\n⚠️  执行期间有 ${lines} 行已滚出可视范围`,
             stdoutLabel: '📤 stdout：',
@@ -562,7 +562,7 @@ function getOsToolMessages(language) {
         };
     }
     return {
-        daemonStarted: (pid, timeoutSeconds, command) => `🟢 ${command} is now running in the background (PID: ${pid})\nThe process did not finish within ${timeoutSeconds} seconds and has transitioned into a daemon. You will see the same lifecycle reminder keep updating: system-maintained / live source of truth / not deletable.\n\nUse stop_daemon({"pid": ${pid}}) to terminate it when needed.`,
+        daemonStarted: (pid, timeoutSeconds, command) => `🟢 ${command} is now running in the background (PID: ${pid})\nThe process did not finish within ${timeoutSeconds} seconds and has transitioned into a daemon. You will see the same lifecycle reminder keep updating: system-maintained / live source of truth / not deletable. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}\n\nUse stop_daemon({"pid": ${pid}}) to terminate it when needed.`,
         commandCompleted: (exitCode, scrollNotice) => `✅ Command completed (exit code: ${exitCode ?? 'unknown'})${scrollNotice}\n\n`,
         scrolledLinesNotice: (lines) => `\n⚠️  ${lines} lines scrolled out of view during execution`,
         stdoutLabel: '📤 stdout:',
@@ -1091,8 +1091,8 @@ ${formatRunnerBackedDaemonStatusDetails(daemon, language)}`;
 }
 function formatRunnerRecoveryError(pid, errorText, language) {
     return language === 'zh'
-        ? `⚠️ 守护进程 ${pid} 的 runner 恢复失败：${errorText}`
-        : `⚠️ Failed to recover runner for daemon ${pid}: ${errorText}`;
+        ? `⚠️ 守护进程 ${pid} 的 runner 恢复失败：${errorText}\n这是系统维护的后台进程状态。${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}`
+        : `⚠️ Failed to recover runner for daemon ${pid}: ${errorText}\nThis is system-maintained background-process state. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}`;
 }
 // JSON Schema for shell_cmd parameters
 const shellCmdSchema = {
@@ -1369,11 +1369,13 @@ exports.shellCmdReminderOwner = {
                 role: 'user',
                 content: language === 'zh'
                     ? `${prefix} 后台进程生命周期提醒 [${reminder.id}]
-当前运行环境中有一条系统维护的后台进程状态提醒。请把它当成环境信号，不要当成你自己写的工作便签。若它没有实质改变你的判断/计划/风险，则禁止做任何用户可见回应（禁止写“静默吸收”“已收到”等占位语句）；只有它实际影响后续动作时，才在下一条有实质内容的回复中体现相关事实。该提醒在进程运行期间会自动更新；进程结束后会保留终态，等待你确认后手动删除。
+当前运行环境中有一条系统维护的后台进程状态提醒。请把它当成环境信号，不要当成你自己写的工作便签。
+${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}
+若它没有实质改变你的判断/计划/风险，则禁止做任何用户可见回应（禁止写“静默吸收”“已收到”等占位语句）；只有它实际影响后续动作时，才在下一条有实质内容的回复中体现相关事实。该提醒在进程运行期间会自动更新；进程结束后会保留终态，等待你确认后手动删除。
 ---
 ${reminder.content}`
                     : `${prefix} Background process lifecycle reminder [${reminder.id}]
-The current runtime environment has a system-maintained background-process state reminder. Treat it as an environment signal, not as your self-authored work note. If it does not materially change your judgment/plan/risk, make no user-visible reply at all (do not send filler like "silently noted" or "received"); only reflect it inside the next substantive reply when it actually affects the next action. This reminder auto-updates while the process is running; after exit it keeps the terminal state until you delete it manually.
+The current runtime environment has a system-maintained background-process state reminder. Treat it as an environment signal, not as your self-authored work note. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)} If it does not materially change your judgment/plan/risk, make no user-visible reply at all (do not send filler like "silently noted" or "received"); only reflect it inside the next substantive reply when it actually affects the next action. This reminder auto-updates while the process is running; after exit it keeps the terminal state until you delete it manually.
 ---
 ${reminder.content}`,
             };
@@ -1391,11 +1393,13 @@ ${reminder.content}`,
                     role: 'user',
                     content: language === 'zh'
                         ? `${prefix} 守护进程生命周期提醒 [${reminder.id}] - ${exitedSummary}｜PID ${pid}
-当前运行环境中 daemon 已退出。若需要再核对最后 stdout/stderr，可先按需调用 get_daemon_output({ "pid": ${pid} })；若该调用已不可用，则以下是最后一次已知快照。确认已知悉后，请手动删除这条提醒。
+当前运行环境中 daemon 已退出。
+${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}
+若需要再核对最后 stdout/stderr，可先按需调用 get_daemon_output({ "pid": ${pid} })；若该调用已不可用，则以下是最后一次已知快照。确认已知悉后，请手动删除这条提醒。
 ---
 ${reminder.content}`
                         : `${prefix} Daemon lifecycle reminder [${reminder.id}] - ${exitedSummary} | PID ${pid}
-The current runtime environment shows that this daemon has exited. If you still need to inspect the final stdout/stderr, first call get_daemon_output({ "pid": ${pid} }) if it is still available; otherwise use the last known snapshot below. After you have acknowledged the exit, delete this reminder manually.
+The current runtime environment shows that this daemon has exited. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)} If you still need to inspect the final stdout/stderr, first call get_daemon_output({ "pid": ${pid} }) if it is still available; otherwise use the last known snapshot below. After you have acknowledged the exit, delete this reminder manually.
 ---
 ${reminder.content}`,
                 };
@@ -1405,9 +1409,9 @@ ${reminder.content}`,
                 role: 'user',
                 content: language === 'zh'
                     ? `${prefix} 进程生命周期提醒 [${reminder.id}] - 后台进程已结束（PID ${pid}）
-当前运行环境中该后台进程的生命周期已经结束，当前不再运行。`
+当前运行环境中该后台进程的生命周期已经结束，当前不再运行。${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}`
                     : `${prefix} Process lifecycle reminder [${reminder.id}] - daemon terminated (PID ${pid})
-The current runtime environment shows that this daemon process has finished its lifecycle and is no longer running.`,
+The current runtime environment shows that this daemon process has finished its lifecycle and is no longer running. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}`,
             };
         }
         if (resolved.kind === 'error') {
@@ -1431,12 +1435,14 @@ The current runtime environment shows that this daemon process has finished its
             role: 'user',
             content: language === 'zh'
                 ? `🔄 ${prefix} 守护进程生命周期提醒 [${reminder.id}] - ${runningSummary}｜PID ${pid}，已运行 ${uptimeStr}
-当前运行环境中 daemon 仍在运行。这是系统维护的状态提醒，不是默认需要单独汇报的事项。若下面的信息没有实质改变你的判断、计划、风险，且不需要调用守护进程相关工具，则禁止做任何用户可见回应；若它有实质影响，只在下一条有实质内容的回复中体现，禁止单独发送“静默吸收”“已收到”等占位语句。
+当前运行环境中 daemon 仍在运行。这是系统维护的状态提醒，不是默认需要单独汇报的事项。
+${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}
+若下面的信息没有实质改变你的判断、计划、风险，且不需要调用守护进程相关工具，则禁止做任何用户可见回应；若它有实质影响，只在下一条有实质内容的回复中体现，禁止单独发送“静默吸收”“已收到”等占位语句。
 
 **状态快照：**
 ${statusInfo}`
                 : `🔄 ${prefix} Daemon lifecycle reminder [${reminder.id}] - ${runningSummary} | PID ${pid}, uptime: ${uptimeStr}
-The current runtime environment shows that this daemon is still running. This is a system-maintained state reminder and not something that normally deserves a standalone mention. If the information below does not materially change your judgment, plan, risk, or require a daemon-management action, make no user-visible reply at all; if it does matter, reflect it only inside the next substantive reply instead of sending filler like "silently noted" or "received".
+The current runtime environment shows that this daemon is still running. This is a system-maintained state reminder and not something that normally deserves a standalone mention. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)} If the information below does not materially change your judgment, plan, risk, or require a daemon-management action, make no user-visible reply at all; if it does matter, reflect it only inside the next substantive reply instead of sending filler like "silently noted" or "received".
 
 **State snapshot:**
 ${statusInfo}`,

package/dist/tools/pending-tellask-reminder.js

@@ -36,13 +36,13 @@ function isPendingTellaskReminderMeta(value) {
 }
 function getPendingTellaskUpdateAltInstruction(language) {
     return language === 'zh'
-        ? '不要手改这条系统提醒。若要改变某一路诉请，只有长线诉请（`tellask` + `sessionSlug`）才能更新那一路诉请的“任务安排”：复用同一 `sessionSlug` 再发 `tellask`，让对应主理人按最新安排自行最终回复并自然结束。一次性诉请（`tellaskSessionless`）没有这个通道；新开一个 `tellaskSessionless` 只会再创建新的瞬态支线，不能要求旧主理人停止。其余情况等待系统按真实诉请状态自动刷新。'
-        : 'Do not hand-edit this system reminder. If you need to change one tellask, only a sessioned tellask (`tellask` + `sessionSlug`) can be updated in place: send another `tellask` with the same `sessionSlug` so the tellaskee can finish naturally under the latest assignment. A one-shot tellask (`tellaskSessionless`) has no such channel; another `tellaskSessionless` only creates a new transient Side Dialog and cannot tell the earlier owner to stop. Otherwise wait for system refresh from real tellask state.';
+        ? '不要手改这条系统提醒。诉请更改通道：只有长线诉请（`tellask` + `sessionSlug`）才能更新那一路诉请的“任务安排”：复用同一 `sessionSlug` 再发 `tellask`，让对应主理人按最新安排自行最终回复并自然结束。一次性诉请（`tellaskSessionless`）没有这个通道；新开一个 `tellaskSessionless` 只会再创建新的瞬态支线，不能要求旧主理人停止。其余情况等待系统按真实诉请状态自动刷新。'
+        : 'Do not hand-edit this system reminder. Tellask change path: only a sessioned tellask (`tellask` + `sessionSlug`) can be updated in place: send another `tellask` with the same `sessionSlug` so the tellaskee can finish naturally under the latest assignment. A one-shot tellask (`tellaskSessionless`) has no such channel; another `tellaskSessionless` only creates a new transient Side Dialog and cannot tell the earlier owner to stop. Otherwise wait for system refresh from real tellask state.';
 }
 function getPendingTellaskDeleteAltInstruction(language) {
     return language === 'zh'
-        ? '这条系统提醒不可删除。若要改变某一路诉请，只有长线诉请（`tellask` + `sessionSlug`）才能更新那一路诉请的“任务安排”：复用同一 `sessionSlug` 再发 `tellask`，让对应主理人按最新安排自行最终回复并自然结束。一次性诉请（`tellaskSessionless`）没有这个通道；新开一个 `tellaskSessionless` 只会再创建新的瞬态支线，不能要求旧主理人停止。其余情况等待系统按真实诉请状态自动刷新。'
-        : 'This system reminder is not deletable. If you need to change one tellask, only a sessioned tellask (`tellask` + `sessionSlug`) can be updated in place: send another `tellask` with the same `sessionSlug` so the tellaskee can finish naturally under the latest assignment. A one-shot tellask (`tellaskSessionless`) has no such channel; another `tellaskSessionless` only creates a new transient Side Dialog and cannot tell the earlier owner to stop. Otherwise wait for system refresh from real tellask state.';
+        ? '这条系统提醒不可删除。诉请更改通道：只有长线诉请（`tellask` + `sessionSlug`）才能更新那一路诉请的“任务安排”：复用同一 `sessionSlug` 再发 `tellask`，让对应主理人按最新安排自行最终回复并自然结束。一次性诉请（`tellaskSessionless`）没有这个通道；新开一个 `tellaskSessionless` 只会再创建新的瞬态支线，不能要求旧主理人停止。其余情况等待系统按真实诉请状态自动刷新。'
+        : 'This system reminder is not deletable. Tellask change path: only a sessioned tellask (`tellask` + `sessionSlug`) can be updated in place: send another `tellask` with the same `sessionSlug` so the tellaskee can finish naturally under the latest assignment. A one-shot tellask (`tellaskSessionless`) has no such channel; another `tellaskSessionless` only creates a new transient Side Dialog and cannot tell the earlier owner to stop. Otherwise wait for system refresh from real tellask state.';
 }
 function callKindLabel(language, view) {
     if (view.callType === 'A') {
@@ -234,21 +234,12 @@ exports.pendingTellaskReminderOwner = {
     async renderReminder(_dlg, reminder) {
         const language = (0, work_language_1.getWorkLanguage)();
         const prefix = (0, driver_messages_1.formatSystemNoticePrefix)(language);
-        if (reminder.owner !== exports.pendingTellaskReminderOwner) {
-            return {
-                type: 'environment_msg',
-                role: 'user',
-                content: language === 'zh'
-                    ? `${prefix} 自动维护诉请状态提醒 [${reminder.id}]\n你正在查看系统自动维护的诉请状态，不要把它当成你自己写的工作便签。\n\n${reminder.content}`
-                    : `${prefix} Auto-maintained tellask status reminder [${reminder.id}]\nYou are looking at system-maintained tellask state. Do not treat it as a self-authored work note.\n\n${reminder.content}`,
-            };
-        }
         return {
             type: 'environment_msg',
             role: 'user',
             content: language === 'zh'
-                ? `${prefix} 自动维护诉请状态提醒 [${reminder.id}]\n你正在查看系统自动维护的诉请状态，不要把它当成你自己写的工作便签。\n\n${reminder.content}`
-                : `${prefix} Auto-maintained tellask status reminder [${reminder.id}]\nYou are looking at system-maintained tellask state. Do not treat it as a self-authored work note.\n\n${reminder.content}`,
+                ? `${prefix} 自动维护诉请状态提醒 [${reminder.id}]\n这是系统自动维护的诉请状态，不是你自己写的工作便签。${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}\n\n${reminder.content}`
+                : `${prefix} Auto-maintained tellask status reminder [${reminder.id}]\nThis is system-maintained tellask state, not a work note you wrote. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}\n\n${reminder.content}`,
         };
     },
 };

package/package.json

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

package/webapp/dist/assets/{_basePickBy-528dB5Tu.js → _basePickBy-BKcCOLIM.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-DkdKmFUs.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-DvqI98wY.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-7-u-sxFw.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--IEBo-K3.js";
 var reWhitespace = /\s/;
 function trimmedEndIndex(string) {
   var index = string.length;
@@ -193,4 +193,4 @@ export {
   map as m,
   toFinite as t
 };
-//# sourceMappingURL=_basePickBy-528dB5Tu.js.map
+//# sourceMappingURL=_basePickBy-BKcCOLIM.js.map