dominds 1.25.13 → 1.25.15

package/dist/dialog-display-state.d.ts

@@ -17,19 +17,21 @@
  */
 import type { DialogDisplayState, DialogInterruptionReason } from '@longrun-ai/kernel/types/display-state';
 import type { DialogExecutionMarker, DialogLatestFile } from '@longrun-ai/kernel/types/storage';
-import type { WebSocketMessage } from '@longrun-ai/kernel/types/wire';
+import type { RunControlCountsMessage, WebSocketMessage } from '@longrun-ai/kernel/types/wire';
 import { DialogID, type Dialog } from './dialog';
 type StopRequestedReason = 'user_stop' | 'emergency_stop';
 export type RunControlCountsSnapshot = {
     proceeding: number;
     resumable: number;
 };
-export declare function setDisplayStateBroadcaster(fn: (msg: WebSocketMessage) => void): void;
+export declare function getRunControlCountsSnapshotEpoch(): string;
+export declare function setDisplayStateBroadcaster(fn: ((msg: WebSocketMessage) => void) | null): void;
 export declare function isStoppedReasonResumable(reason: DialogInterruptionReason): boolean;
 export declare function isDisplayStateResumable(state: DialogDisplayState | undefined): boolean;
 export declare function isExecutionMarkerResumable(executionMarker: DialogExecutionMarker | undefined): boolean;
 export declare function isDialogLatestResumable(latest: DialogLatestFile | null | undefined): boolean;
 export declare function getRunControlCountsSnapshot(): Promise<RunControlCountsSnapshot>;
+export declare function createRunControlCountsMessage(): Promise<RunControlCountsMessage>;
 export declare function broadcastRunControlCountsSnapshot(): Promise<void>;
 export declare function hasActiveRun(dialogId: DialogID): boolean;
 export declare function getActiveRunSignal(dialogId: DialogID): AbortSignal | undefined;

package/dist/dialog-display-state.js

@@ -17,12 +17,14 @@
  *   so multi-tab views converge without polling.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRunControlCountsSnapshotEpoch = getRunControlCountsSnapshotEpoch;
 exports.setDisplayStateBroadcaster = setDisplayStateBroadcaster;
 exports.isStoppedReasonResumable = isStoppedReasonResumable;
 exports.isDisplayStateResumable = isDisplayStateResumable;
 exports.isExecutionMarkerResumable = isExecutionMarkerResumable;
 exports.isDialogLatestResumable = isDialogLatestResumable;
 exports.getRunControlCountsSnapshot = getRunControlCountsSnapshot;
+exports.createRunControlCountsMessage = createRunControlCountsMessage;
 exports.broadcastRunControlCountsSnapshot = broadcastRunControlCountsSnapshot;
 exports.hasActiveRun = hasActiveRun;
 exports.getActiveRunSignal = getActiveRunSignal;
@@ -44,6 +46,7 @@ exports.reconcileDisplayStatesAfterRestart = reconcileDisplayStatesAfterRestart;
 exports.requestInterruptDialog = requestInterruptDialog;
 exports.requestEmergencyStopAll = requestEmergencyStopAll;
 const time_1 = require("@longrun-ai/kernel/utils/time");
+const crypto_1 = require("crypto");
 const dialog_1 = require("./dialog");
 const dialog_generation_run_1 = require("./dialog-generation-run");
 const dialog_global_registry_1 = require("./dialog-global-registry");
@@ -58,8 +61,14 @@ const log = (0, log_1.createLogger)('dialog-display-state');
 let broadcastToClients;
 const activeRunsByDialogKey = new Map();
 const quarantiningMainDialogIds = new Set();
+const runControlCountsSnapshotEpoch = (0, crypto_1.randomUUID)();
+let runControlCountsSnapshotSeq = 0;
+let runControlCountsSnapshotQueue = Promise.resolve();
+function getRunControlCountsSnapshotEpoch() {
+    return runControlCountsSnapshotEpoch;
+}
 function setDisplayStateBroadcaster(fn) {
-    broadcastToClients = fn;
+    broadcastToClients = fn ?? undefined;
 }
 function syncRunControlCountsAfterActiveRunChange(trigger, dialogId) {
     void (async () => {
@@ -259,16 +268,27 @@ async function getRunControlCountsSnapshot() {
     }
     return { proceeding, resumable };
 }
-async function broadcastRunControlCountsSnapshot() {
-    if (!broadcastToClients)
-        return;
+async function createRunControlCountsMessageUnqueued() {
     const counts = await getRunControlCountsSnapshot();
-    broadcastToClients({
+    const snapshotSeq = ++runControlCountsSnapshotSeq;
+    return {
         type: 'run_control_counts_evt',
         proceeding: counts.proceeding,
         resumable: counts.resumable,
+        snapshotEpoch: runControlCountsSnapshotEpoch,
+        snapshotSeq,
         timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
-    });
+    };
+}
+function createRunControlCountsMessage() {
+    const nextSnapshot = runControlCountsSnapshotQueue.then(() => createRunControlCountsMessageUnqueued());
+    runControlCountsSnapshotQueue = nextSnapshot.then(() => undefined, () => undefined);
+    return nextSnapshot;
+}
+async function broadcastRunControlCountsSnapshot() {
+    if (!broadcastToClients)
+        return;
+    broadcastToClients(await createRunControlCountsMessage());
 }
 function hasActiveRun(dialogId) {
     return activeRunsByDialogKey.has(dialogId.key());

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

@@ -804,10 +804,15 @@ async function renderRemindersForContext(dlg) {
         return [];
     const language = (0, work_language_1.getWorkLanguage)();
     const renderedItems = [];
+    const maintenanceReferenceItems = [];
     for (const reminder of reminders) {
         if (!reminder || !(0, tool_1.reminderEchoBackEnabled)(reminder)) {
             continue;
         }
+        maintenanceReferenceItems.push({
+            id: reminder.id,
+            meta: reminder.meta,
+        });
         if (reminder.owner) {
             renderedItems.push(await reminder.owner.renderReminder(dlg, reminder));
             continue;
@@ -823,12 +828,22 @@ async function renderRemindersForContext(dlg) {
     }
     if (renderedItems.length === 0)
         return [];
+    const maintenanceReference = (0, driver_messages_1.formatReminderMaintenanceReference)(language, maintenanceReferenceItems);
     return [
         {
             type: 'environment_msg',
             role: 'user',
             content: (0, driver_messages_1.formatReminderContextGuide)(language),
         },
+        ...(maintenanceReference === undefined
+            ? []
+            : [
+                {
+                    type: 'transient_guide_msg',
+                    role: 'assistant',
+                    content: maintenanceReference,
+                },
+            ]),
         ...renderedItems,
     ];
 }

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

@@ -1676,6 +1676,9 @@ async function executeDriveRound(args) {
                 replyContinuationScope.target() ??
                 calleeDialogReplyTarget;
         activeTellaskReplyDirective = activeTellaskReplyDirective ?? replyContinuationScope.directive();
+        if (driveResult.lastFunctionCallGenseq !== null) {
+            activePromptWasReplyToolReminder = false;
+        }
         interruptedBySignal = (0, dialog_display_state_1.getActiveRunSignal)(dialog.id)?.aborted === true;
         if (!interruptedBySignal) {
             const queuedFollowUp = dialog.peekQueuedPrompt();

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

@@ -381,15 +381,7 @@ async function supplyResponseToAskerDialog(args) {
             }), callerDialog.status);
             if (maybeSideDialog) {
                 const displayState = await (0, dialog_display_state_1.computeIdleDisplayState)(maybeSideDialog);
-                await persistence_1.DialogPersistence.mutateDialogLatest(sideDialogId, () => ({
-                    kind: 'patch',
-                    patch: {
-                        displayState,
-                        executionMarker: displayState.kind === 'stopped'
-                            ? { kind: 'interrupted', reason: displayState.reason }
-                            : undefined,
-                    },
-                }), callerDialog.status);
+                await (0, dialog_display_state_1.setDialogDisplayState)(sideDialogId, displayState, callerDialog.status);
             }
         }
         await syncPendingTellaskReminderBestEffort(callerDialog, 'kernel-driver:supplyResponseToAskerDialog');

package/dist/mcp/supervisor.js

@@ -101,14 +101,12 @@ function ensureLeaseReminder(dlg, serverId) {
         ? [
             `已租用 MCP 工具集：${serverId}`,
             '',
-            '该 MCP server 被视为非“真正无状态”。当你确认短期内不再需要它时，请释放以回收底层进程/连接：',
-            `mcp_release({"serverId":"${serverId}"})`,
+            '该 MCP server 被视为非“真正无状态”；当前对话持有一个需要显式生命周期管理的底层进程/连接。',
         ].join('\n')
         : [
             `MCP toolset leased: ${serverId}`,
             '',
-            `This MCP server is treated as non-stateless. When you are confident you won't need it again soon, release it:`,
-            `mcp_release({"serverId":"${serverId}"})`,
+            `This MCP server is treated as non-stateless; the current dialog holds an underlying process/connection with explicit lifecycle management.`,
         ].join('\n');
     dlg.addReminder(content, owner, makeLeaseReminderMeta(serverId));
 }

package/dist/minds/system-prompt.js

@@ -99,8 +99,8 @@ function buildTeammateTellaskPhaseContract(language) {
             '- 队友诉请必须遵循“发起 → 等待 → 判定 → 续推”四段协议：若目标未达成，立即发出下一轮诉请推进。',
             '- 对队友诉请而言，收到回贴即表示该轮调用已结束；不存在“回贴已送达后，对方仍在后台继续执行同一诉请”的默认语义。要继续必须显式再发一轮诉请函数（通常 `tellask` 复用同一 `sessionSlug`）。',
             '- 若被诉请者在回贴送达前因 `clear_mind` 开启新一程，同一进行中诉请默认继续有效；新一程会自然承接，直到产生回贴或明确失败。不要仅因对方换程就把该轮诉请当作失效重发。',
-            '- 只有在存在明确进行中诉请时，才可声明“等待回贴/等待结果”（通常应可在“⏳ 进行中诉请（共 N 路，自动维护；仅 0 路时可手动删除）”这类提醒项中观测到）；若该提醒项不存在，或提醒项已明确“当前没有执行中的诉请”，则“等待”是错误动作，必须执行下一动作（直接诉请或本地执行）。',
-            '- “⏳ 进行中诉请”提醒项只是系统状态窗，不是控制面：内容不可手改；当存在非 0 路进行中诉请时，不可删除，误删会被拒绝并返回引导文案。若某一路诉请需要改要求、提前收口或纠偏，只能更新那一路诉请的“任务安排”（对长线诉请通常复用同一 `sessionSlug` 再发 `tellask`），让对应主理人按最新安排自行最终回复并自然结束。',
+            '- 只有在存在明确进行中诉请时，才可声明“等待回贴/等待结果”（通常应可在“⏳ 进行中诉请（共 N 路，自动维护）”这类提醒项中观测到）；若该提醒项不存在，或提醒项已明确“当前没有执行中的诉请”，则“等待”是错误动作，必须执行下一动作（直接诉请或本地执行）。',
+            '- “⏳ 进行中诉请”提醒项只是系统状态窗，不是控制面；用它判断是否确实存在仍在执行的诉请。若某一路诉请需要改要求、提前收口或纠偏，更新那一路诉请的“任务安排”（对长线诉请通常复用同一 `sessionSlug` 再发 `tellask`），让对应主理人按最新安排自行最终回复并自然结束。',
             '- 只有长线诉请（`tellask` + `sessionSlug`）能接着同一件事说、更新同一件正在做的事；一次性诉请（`tellaskSessionless`）做不到。再次发起 `tellaskSessionless` 只是另一件独立任务，不会更新、更不会要求旧任务停止；若你后来发现可能需要改要求/提前收口，一开始就不该选择 `tellaskSessionless`。',
             '- 不要把智能体队友当成真人同事：祂不会因为你又发一条诉请而被打扰。同一个队友可以同时做多件独立任务，系统会分开处理。记住这个简单规则：同一个队友 + 同一个 `sessionSlug` = 接着同一件事说，并更新那件正在做的事；`tellaskSessionless` 或不同 `sessionSlug` = 另一件独立任务。只要任务独立、目标清楚，就直接并行诉请。',
             '- 能由队友诉请完成的执行性工作，禁止转交 `askHuman` 做“转发员”；当你写“让 @X 执行 Y”时，必须在同一回复内直接发出 `tellask` 或 `tellaskSessionless`。',
@@ -112,8 +112,8 @@ function buildTeammateTellaskPhaseContract(language) {
             '- Teammate Tellasks MUST follow four phases: “initiate -> wait -> judge -> continue”. If the objective is not met, immediately send the next Tellask round.',
             '- For teammate Tellasks, a delivered response closes that call round; there is no default “still running in background after the reply is already delivered” state for the same Tellask. To continue, emit a new Tellask function call explicitly (usually `tellask` with the same `sessionSlug`).',
             '- If the tellaskee starts a new course via `clear_mind` before delivering the reply, the same in-flight Tellask stays live by default; the new course naturally continues it until a reply is delivered or an explicit failure is returned. Do not re-tellask solely because the tellaskee changed course.',
-            '- You may claim “waiting for reply/result” only when a concrete pending Tellask exists (normally observable in a “⏳ In-flight Tellasks (N total, auto-maintained; manually deletable only at zero in-flight)” reminder). If that reminder is absent, or it explicitly states there are no in-flight Tellasks, waiting is a wrong action; execute the next action now (direct Tellask or local action).',
-            '- The “⏳ In-flight Tellasks” reminder is only a system status window, not a control surface: its content is not hand-editable; while any Tellask is still active, it is not deletable, and mistaken deletion will be rejected with guidance. If one Tellask needs a changed scope, earlier closure, or correction, update that Tellask’s assignment instead (for a sessioned Tellask, usually send another `tellask` with the same `sessionSlug`) so the tellaskee can deliver a final reply naturally under the latest assignment.',
+            '- You may claim “waiting for reply/result” only when a concrete pending Tellask exists (normally observable in a “⏳ In-flight Tellasks (N total, auto-maintained)” reminder). If that reminder is absent, or it explicitly states there are no in-flight Tellasks, waiting is a wrong action; execute the next action now (direct Tellask or local action).',
+            '- The “⏳ In-flight Tellasks” reminder is only a system status window, not a control surface; use it to determine whether any Tellask is truly still in flight. If one Tellask needs a changed scope, earlier closure, or correction, update that Tellask’s assignment (for a sessioned Tellask, usually send another `tellask` with the same `sessionSlug`) so the tellaskee can deliver a final reply naturally under the latest assignment.',
             '- Only a sessioned Tellask (`tellask` + `sessionSlug`) can continue the same task and update that task. A one-shot Tellask (`tellaskSessionless`) cannot: another `tellaskSessionless` is a separate task and does not update, stop, or instruct the earlier task to stop. If you may need later correction or earlier wrap-up, do not choose `tellaskSessionless` in the first place.',
             '- Do not treat an agent teammate like a human coworker who can only handle one conversation at a time. The same teammate can work on several independent tasks at once, and the system keeps them separate. Simple rule: same teammate + same `sessionSlug` = continue the same task and update that task; `tellaskSessionless` or a different `sessionSlug` = another independent task. When tasks are independent and clear, tellask in parallel.',
             '- Do not use `askHuman` as a relay for executable teammate work. If you write “ask @X to do Y”, emit `tellask` or `tellaskSessionless` in the same response.',

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

@@ -20,6 +20,11 @@ export type ReminderContextFooterState = Readonly<{
     interDialogReplyObligation: ReminderContextReplyObligationState;
 }>;
 export declare function formatReminderContextFooter(language: LanguageCode, state: ReminderContextFooterState): string;
+export type ReminderMaintenanceReferenceItem = Readonly<{
+    id: string;
+    meta?: unknown;
+}>;
+export declare function formatReminderMaintenanceReference(language: LanguageCode, reminders: readonly ReminderMaintenanceReferenceItem[]): string | undefined;
 export declare function formatReminderItemGuide(language: LanguageCode, reminderId: string, content: string, options?: {
     meta?: unknown;
     scope?: 'dialog' | 'task' | 'agent' | 'runtime';

package/dist/runtime/driver-messages.js

@@ -11,6 +11,7 @@ exports.formatNewCourseStartPrompt = formatNewCourseStartPrompt;
 exports.formatDiligenceAutoContinuePrompt = formatDiligenceAutoContinuePrompt;
 exports.formatReminderContextGuide = formatReminderContextGuide;
 exports.formatReminderContextFooter = formatReminderContextFooter;
+exports.formatReminderMaintenanceReference = formatReminderMaintenanceReference;
 exports.formatReminderItemGuide = formatReminderItemGuide;
 exports.formatQ4HDiligencePushBudgetExhausted = formatQ4HDiligencePushBudgetExhausted;
 exports.formatDomindsNoteTellaskForTeammatesOnly = formatDomindsNoteTellaskForTeammatesOnly;
@@ -236,53 +237,121 @@ function formatReminderContextFooter(language, state) {
         'Judge the next step from the existing task state: if there is a clear, relevant, valuable action, continue with it; 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}`);
 }
-function formatReminderItemGuide(language, reminderId, content, options) {
-    function isRecord(value) {
-        return typeof value === 'object' && value !== null && !Array.isArray(value);
-    }
-    // `options.meta` is persisted JSON coming from tools. Runtime shape checks are unavoidable here
-    // to keep reminder ownership/management loosely coupled and extensible.
-    const metaValue = options && 'meta' in options ? options.meta : undefined;
-    const scope = options?.scope;
-    const isContinuationPackageReminder = isRecord(metaValue) && metaValue['kind'] === 'continuation_package';
-    const isPendingTellaskReminder = isRecord(metaValue) && metaValue['kind'] === 'pending_tellask';
+function isReminderGuideMetaRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function getReminderMaintenanceInstructions(language, reminderId, meta) {
+    const metaValue = meta;
+    const isPendingTellaskReminder = isReminderGuideMetaRecord(metaValue) && metaValue['kind'] === 'pending_tellask';
     const pendingTellaskCount = isPendingTellaskReminder && typeof metaValue['pendingCount'] === 'number'
         ? metaValue['pendingCount']
         : undefined;
-    const managerValue = isRecord(metaValue) ? metaValue['manager'] : undefined;
-    const managementTool = isRecord(managerValue) && typeof managerValue['tool'] === 'string'
+    const managerValue = isReminderGuideMetaRecord(metaValue) ? metaValue['manager'] : undefined;
+    const managementTool = isReminderGuideMetaRecord(managerValue) && typeof managerValue['tool'] === 'string'
         ? managerValue['tool'].trim()
         : undefined;
-    const updateValue = isRecord(metaValue) ? metaValue['update'] : undefined;
-    const updateAltInstruction = isRecord(updateValue) && typeof updateValue['altInstruction'] === 'string'
+    const updateValue = isReminderGuideMetaRecord(metaValue) ? metaValue['update'] : undefined;
+    const updateAltInstruction = isReminderGuideMetaRecord(updateValue) && typeof updateValue['altInstruction'] === 'string'
         ? updateValue['altInstruction'].trim()
         : undefined;
-    const updateInstruction = updateAltInstruction && updateAltInstruction.length > 0
-        ? updateAltInstruction
-        : managementTool
-            ? `${managementTool}({ ... })`
-            : undefined;
-    const deleteValue = isRecord(metaValue) ? metaValue['delete'] : undefined;
-    const deleteAltInstruction = isRecord(deleteValue) && typeof deleteValue['altInstruction'] === 'string'
+    const metaKind = isReminderGuideMetaRecord(metaValue) ? metaValue['kind'] : undefined;
+    const serverIdValue = isReminderGuideMetaRecord(metaValue) ? metaValue['serverId'] : undefined;
+    const mcpReleaseInstruction = typeof serverIdValue === 'string' && serverIdValue.trim() !== ''
+        ? `mcp_release({"serverId":"${serverIdValue.trim()}"})`
+        : 'mcp_release({"serverId":"<serverId>"})';
+    const updateInstruction = metaKind === 'mcp_lease'
+        ? language === 'zh'
+            ? 'MCP lease 状态由系统维护，不用 update_reminder 修改'
+            : 'MCP lease state is system-maintained; I do not edit it with update_reminder'
+        : updateAltInstruction && updateAltInstruction.length > 0
+            ? updateAltInstruction
+            : managementTool
+                ? `${managementTool}({ ... })`
+                : undefined;
+    const deleteValue = isReminderGuideMetaRecord(metaValue) ? metaValue['delete'] : undefined;
+    const deleteAltInstruction = isReminderGuideMetaRecord(deleteValue) && typeof deleteValue['altInstruction'] === 'string'
         ? deleteValue['altInstruction'].trim()
         : undefined;
+    const daemonCompleted = metaKind === 'daemon' && isReminderGuideMetaRecord(metaValue) && metaValue['completed'] === true;
     const deleteInstruction = language === 'zh'
-        ? deleteAltInstruction
-            ? `删除通道：不要用 delete_reminder；请执行：${deleteAltInstruction}`
-            : isPendingTellaskReminder && pendingTellaskCount === 0
-                ? `清理噪音时可删除：delete_reminder({ "reminder_id": "${reminderId}" })`
-                : `删除通道：delete_reminder({ "reminder_id": "${reminderId}" })`
-        : deleteAltInstruction
-            ? `Delete path: do not use delete_reminder; run: ${deleteAltInstruction}`
-            : isPendingTellaskReminder && pendingTellaskCount === 0
-                ? `Noise cleanup delete path: delete_reminder({ "reminder_id": "${reminderId}" })`
-                : `Delete path: delete_reminder({ "reminder_id": "${reminderId}" })`;
+        ? isPendingTellaskReminder && pendingTellaskCount !== undefined && pendingTellaskCount > 0
+            ? '删除通道：当前仍有进行中诉请；我不能用 delete_reminder 删除。要改变某一路长线诉请时，我复用同一 sessionSlug 再发 tellask；tellaskSessionless 不能修改或停止旧任务。'
+            : deleteAltInstruction
+                ? `删除通道：我不用 delete_reminder；我执行：${deleteAltInstruction}`
+                : metaKind === 'mcp_lease'
+                    ? `删除通道：我不用 delete_reminder 释放资源；确认当前对话近期不再需要该 MCP runtime 时，我执行：${mcpReleaseInstruction}`
+                    : daemonCompleted
+                        ? `删除通道：确认已知悉 daemon 终态后，可清理：delete_reminder({ "reminder_id": "${reminderId}" })`
+                        : isPendingTellaskReminder && pendingTellaskCount === 0
+                            ? `清理噪音时我可删除：delete_reminder({ "reminder_id": "${reminderId}" })`
+                            : `删除通道：delete_reminder({ "reminder_id": "${reminderId}" })`
+        : isPendingTellaskReminder && pendingTellaskCount !== undefined && pendingTellaskCount > 0
+            ? 'Delete path: there are still in-flight Tellasks; I cannot delete this reminder with delete_reminder. To change a sessioned tellask, I send another tellask with the same sessionSlug; tellaskSessionless cannot modify or stop an earlier task.'
+            : deleteAltInstruction
+                ? `Delete path: I do not use delete_reminder; I run: ${deleteAltInstruction}`
+                : metaKind === 'mcp_lease'
+                    ? `Delete path: I do not release resources by deleting the reminder; when this dialog will not need the MCP runtime soon, I run: ${mcpReleaseInstruction}`
+                    : daemonCompleted
+                        ? `Delete path: after I have acknowledged the daemon terminal state, I may clean up: delete_reminder({ "reminder_id": "${reminderId}" })`
+                        : isPendingTellaskReminder && pendingTellaskCount === 0
+                            ? `Noise cleanup delete path: I may run delete_reminder({ "reminder_id": "${reminderId}" })`
+                            : `Delete path: delete_reminder({ "reminder_id": "${reminderId}" })`;
+    return { updateInstruction, deleteInstruction };
+}
+function formatReminderMaintenanceReference(language, reminders) {
+    const lines = [];
+    for (const reminder of reminders) {
+        const { updateInstruction, deleteInstruction } = getReminderMaintenanceInstructions(language, reminder.id, reminder.meta);
+        if (language === 'zh') {
+            if (updateInstruction) {
+                lines.push(`- reminder_id=${reminder.id}：我若要更新/调整这条提醒项，参考：${updateInstruction}`);
+            }
+            else {
+                lines.push(`- reminder_id=${reminder.id}：我若要更新/调整这条提醒项，参考：update_reminder({ "reminder_id": "${reminder.id}", "content": "..." })`);
+            }
+            lines.push(`- reminder_id=${reminder.id}：我若要删除/清理这条提醒项，参考：${deleteInstruction}`);
+        }
+        else {
+            if (updateInstruction) {
+                lines.push(`- reminder_id=${reminder.id}: if I update/change this reminder, I follow: ${updateInstruction}`);
+            }
+            else {
+                lines.push(`- reminder_id=${reminder.id}: if I update/change this reminder, I follow: update_reminder({ "reminder_id": "${reminder.id}", "content": "..." })`);
+            }
+            lines.push(`- reminder_id=${reminder.id}: if I delete/clean up this reminder, I follow: ${deleteInstruction}`);
+        }
+    }
+    if (lines.length === 0)
+        return undefined;
+    if (language === 'zh') {
+        return [
+            `${formatSystemNoticePrefix(language)} 我把下面的提醒项维护通道仅作为操作参考；如果我需要维护某条 reminder，我会按对应 reminder_id 选择工具。我不会把这些参考当成当前轮必须立即执行的动作，也不会因此延迟回应后续真实用户消息。`,
+            '',
+            ...lines,
+        ].join('\n');
+    }
+    return [
+        `${formatSystemNoticePrefix(language)} I treat the following reminder-maintenance channels as an operational reference only. If I need to maintain a reminder, 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, and I do not let them delay my response to any following real user message.`,
+        '',
+        ...lines,
+    ].join('\n');
+}
+function formatReminderItemGuide(language, reminderId, content, options) {
+    // `options.meta` is persisted JSON coming from tools. Runtime shape checks are unavoidable here
+    // to keep reminder ownership/management loosely coupled and extensible.
+    const metaValue = options && 'meta' in options ? options.meta : undefined;
+    const scope = options?.scope;
+    const isContinuationPackageReminder = isReminderGuideMetaRecord(metaValue) && metaValue['kind'] === 'continuation_package';
+    const managerValue = isReminderGuideMetaRecord(metaValue) ? metaValue['manager'] : undefined;
+    const managementTool = isReminderGuideMetaRecord(managerValue) && typeof managerValue['tool'] === 'string'
+        ? managerValue['tool'].trim()
+        : undefined;
+    const { updateInstruction } = getReminderMaintenanceInstructions(language, reminderId, metaValue);
     const projectionNote = formatReminderItemProjectionNote(language);
     const enProjectionPrefix = `${projectionNote} `;
     const systemPrefix = formatSystemNoticePrefix(language);
     if (language === 'zh') {
         if (managementTool) {
-            const updateInstructionSafe = updateInstruction ?? `${managementTool}({ ... })`;
             return [
                 `${systemPrefix} 提醒项 [${reminderId}]（工具状态）`,
                 '',
@@ -291,11 +360,6 @@ function formatReminderItemGuide(language, reminderId, content, options) {
                 '',
                 '默认不要在对外回复里专门确认、复述或总结它；只有它实际改变你的判断、计划或风险时，才提炼真正相关的部分。',
                 '',
-                `调整通道：使用 ${managementTool}；不要用 update_reminder。`,
-                '',
-                `更新通道：${updateInstructionSafe}`,
-                deleteInstruction,
-                '',
                 '---',
                 content,
             ].join('\n');
@@ -304,12 +368,9 @@ function formatReminderItemGuide(language, reminderId, content, options) {
             return [
                 `${systemPrefix} 提醒项 [${reminderId}]`,
                 '',
-                `${projectionNote}当前运行环境中有一条带有 meta 控制更新规则的提醒项。请把它当作状态参考，不要用 update_reminder 直接改写内容。`,
+                `${projectionNote}当前运行环境中有一条带有 meta 控制更新规则的提醒项。请把它当作状态参考，具体维护通道以前置维护参考为准。`,
                 formatAutoMaintainedReminderManualMirrorBan(language),
                 '',
-                `更新通道：不要用 update_reminder；请按此处理：${updateInstruction}`,
-                deleteInstruction,
-                '',
                 '---',
                 content,
             ].join('\n');
@@ -322,9 +383,6 @@ function formatReminderItemGuide(language, reminderId, content, options) {
                 '',
                 '你应优先保留下一步行动、关键定位、运行/验证信息、容易丢的临时细节；不要重复差遣牒已覆盖的内容。进入新一程后，你的第一步是以清醒头脑重新审视并整理更新：删除冗余、纠正偏激/失真思路、压缩成高质量提醒项。若目前只是粗略过桥笔记，进入新一程后必须尽快收敛。',
                 '',
-                `如果你要更新这份接续包，可执行：update_reminder({ "reminder_id": "${reminderId}", "content": "..." })`,
-                deleteInstruction,
-                '',
                 '---',
                 content,
             ].join('\n');
@@ -347,15 +405,11 @@ function formatReminderItemGuide(language, reminderId, content, options) {
             '',
             scopeMaintenance,
             '',
-            `如果你要更新这条提醒项，可执行：update_reminder({ "reminder_id": "${reminderId}", "content": "..." })`,
-            deleteInstruction,
-            '',
             '---',
             content,
         ].join('\n');
     }
     if (managementTool) {
-        const updateInstructionSafe = updateInstruction ?? `${managementTool}({ ... })`;
         return `${systemPrefix} REMINDER [${reminderId}] (TOOL STATE)
 
 ${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.
@@ -364,22 +418,16 @@ ${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.
 
-Change path: use ${managementTool}; do not use update_reminder.
-
-Update path: ${updateInstructionSafe}
-${deleteInstruction}
 ---
 ${content}`;
     }
     if (updateInstruction) {
         return `${systemPrefix} REMINDER [${reminderId}]
 
-${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.
+${enProjectionPrefix}The current runtime environment has a reminder with a meta-controlled update path. Treat it as state/reference; use the preceding maintenance reference for its maintenance channel.
 
 ${formatAutoMaintainedReminderManualMirrorBan(language)}
 
-Update path: do not use update_reminder; follow instead: ${updateInstruction}
-${deleteInstruction}
 ---
 ${content}`;
     }
@@ -390,8 +438,6 @@ ${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.
 
-Update path: update_reminder({ "reminder_id": "${reminderId}", "content": "..." })
-${deleteInstruction}
 ---
 ${content}`;
     }
@@ -412,8 +458,6 @@ ${scopeGuide}
 
 ${scopeMaintenance}
 
-Update path: update_reminder({ "reminder_id": "${reminderId}", "content": "..." })
-${deleteInstruction}
 ---
 ${content}`;
 }

package/dist/server/api-routes.js

@@ -2282,12 +2282,15 @@ async function handleGetDialogs(res, status) {
 }
 async function handleGetRunControlCounts(res) {
     try {
-        const counts = await (0, dialog_display_state_1.getRunControlCountsSnapshot)();
+        const counts = await (0, dialog_display_state_1.createRunControlCountsMessage)();
         respondJson(res, 200, {
             success: true,
             counts: {
                 proceeding: counts.proceeding,
                 resumable: counts.resumable,
+                snapshotEpoch: counts.snapshotEpoch,
+                snapshotSeq: counts.snapshotSeq,
+                timestamp: counts.timestamp,
             },
         });
         return true;
@@ -2771,13 +2774,7 @@ function broadcastDialogDeletes(clients, message) {
 async function broadcastRunControlCounts(clients) {
     if (!clients)
         return;
-    const counts = await (0, dialog_display_state_1.getRunControlCountsSnapshot)();
-    const data = JSON.stringify({
-        type: 'run_control_counts_evt',
-        proceeding: counts.proceeding,
-        resumable: counts.resumable,
-        timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
-    });
+    const data = JSON.stringify(await (0, dialog_display_state_1.createRunControlCountsMessage)());
     for (const ws of clients) {
         if (ws.readyState === 1) {
             ws.send(data);