dominds 1.27.2 → 1.27.4

package/dist/persistence.js

@@ -697,8 +697,8 @@ function serializeReminderSnapshot(reminder) {
         ownerName: reminder.owner?.name,
         meta: reminder.meta,
         echoback: reminder.echoback,
-        scope: reminder.scope ?? 'dialog',
-        renderMode: reminder.renderMode ?? 'markdown',
+        scope: reminder.scope,
+        renderMode: reminder.renderMode,
         createdAt: reminder.createdAt ?? (0, time_1.formatUnifiedTimestamp)(new Date()),
         priority: reminder.priority ?? 'medium',
     };
@@ -2234,17 +2234,34 @@ function parseDialogLatestFile(value) {
         if (typeof fbrStateRaw.iteration !== 'number' || !Number.isInteger(fbrStateRaw.iteration)) {
             return null;
         }
-        if (fbrStateRaw.iteration < 1 || fbrStateRaw.iteration > fbrStateRaw.effort) {
+        if (fbrStateRaw.iteration < 1) {
             return null;
         }
         if (typeof fbrStateRaw.promptDelivered !== 'boolean')
             return null;
+        if (phase !== 'finalization' && fbrStateRaw.iteration > fbrStateRaw.effort) {
+            return null;
+        }
+        if (phase !== 'finalization') {
+            return {
+                kind: 'serial',
+                effort: fbrStateRaw.effort,
+                phase,
+                iteration: fbrStateRaw.iteration,
+                promptDelivered: fbrStateRaw.promptDelivered,
+            };
+        }
+        const finalizationReason = fbrStateRaw.finalizationReason;
+        if (finalizationReason !== 'planned' && finalizationReason !== 'context_caution') {
+            return null;
+        }
         return {
             kind: 'serial',
             effort: fbrStateRaw.effort,
             phase,
             iteration: fbrStateRaw.iteration,
             promptDelivered: fbrStateRaw.promptDelivered,
+            finalizationReason,
         };
     })();
     if (fbrState === null)
@@ -9291,6 +9308,7 @@ class DialogPersistence {
     static resolvePendingUserInterjectionReplyFromCourseEvents(events, course) {
         let pendingUserInterjectionReply;
         let visibleReplySettled = false;
+        let visibleReplyGenseq;
         for (const event of events) {
             if (event.type === 'human_text_record') {
                 if (event.origin !== 'user')
@@ -9304,6 +9322,7 @@ class DialogPersistence {
                     genseq: (0, storage_1.toCallSiteGenseqNo)(event.genseq),
                 };
                 visibleReplySettled = false;
+                visibleReplyGenseq = undefined;
                 continue;
             }
             if (pendingUserInterjectionReply === undefined) {
@@ -9311,23 +9330,38 @@ class DialogPersistence {
             }
             if (event.type === 'agent_words_record') {
                 visibleReplySettled = true;
+                visibleReplyGenseq = event.genseq;
                 continue;
             }
             if (event.type === 'func_call_record' || event.type === 'tellask_call_record') {
-                visibleReplySettled = false;
+                if (visibleReplyGenseq === undefined || event.genseq <= visibleReplyGenseq) {
+                    visibleReplySettled = false;
+                    visibleReplyGenseq = undefined;
+                }
             }
         }
         return visibleReplySettled ? undefined : pendingUserInterjectionReply;
     }
     static resolveAnsweredUserInterjectionA2HFromCourseEvents(args) {
         let pendingUserInterjectionReply;
-        let lastVisibleAnswer;
-        let visibleReplySettled = false;
+        let visibleAnswer;
+        let hasAutoDriveAfterVisibleAnswer = false;
+        let possibleAutoDriveStartGenseq;
         for (const event of args.events) {
             if (event.type === 'human_text_record') {
-                if (event.origin !== 'user')
+                if (event.origin !== 'user') {
+                    if (visibleAnswer !== undefined &&
+                        possibleAutoDriveStartGenseq !== undefined &&
+                        event.genseq === possibleAutoDriveStartGenseq) {
+                        hasAutoDriveAfterVisibleAnswer = true;
+                    }
                     continue;
+                }
                 if (typeof event.q4hAnswerCallId === 'string' && event.q4hAnswerCallId.trim() !== '') {
+                    pendingUserInterjectionReply = undefined;
+                    visibleAnswer = undefined;
+                    hasAutoDriveAfterVisibleAnswer = false;
+                    possibleAutoDriveStartGenseq = undefined;
                     continue;
                 }
                 pendingUserInterjectionReply = {
@@ -9335,24 +9369,56 @@ class DialogPersistence {
                     course: (0, storage_1.toDialogCourseNumber)(args.course),
                     genseq: (0, storage_1.toCallSiteGenseqNo)(event.genseq),
                 };
-                visibleReplySettled = false;
-                lastVisibleAnswer = undefined;
+                visibleAnswer = undefined;
+                hasAutoDriveAfterVisibleAnswer = false;
+                possibleAutoDriveStartGenseq = undefined;
                 continue;
             }
             if (pendingUserInterjectionReply === undefined) {
                 continue;
             }
             if (event.type === 'agent_words_record') {
-                visibleReplySettled = true;
-                lastVisibleAnswer = { content: event.content, genseq: event.genseq };
+                if (visibleAnswer !== undefined &&
+                    (hasAutoDriveAfterVisibleAnswer ||
+                        (possibleAutoDriveStartGenseq !== undefined &&
+                            event.genseq === possibleAutoDriveStartGenseq))) {
+                    hasAutoDriveAfterVisibleAnswer = true;
+                    continue;
+                }
+                visibleAnswer = { content: event.content, genseq: event.genseq };
+                continue;
+            }
+            if (event.type === 'gen_start_record') {
+                if (visibleAnswer !== undefined &&
+                    (typeof event.msgId !== 'string' || event.msgId.trim() === '')) {
+                    hasAutoDriveAfterVisibleAnswer = true;
+                    possibleAutoDriveStartGenseq = undefined;
+                }
+                else if (visibleAnswer !== undefined) {
+                    possibleAutoDriveStartGenseq = event.genseq;
+                }
+                continue;
+            }
+            if (event.type === 'agent_thought_record' || event.type === 'runtime_guide_record') {
+                if (visibleAnswer !== undefined &&
+                    possibleAutoDriveStartGenseq !== undefined &&
+                    event.genseq === possibleAutoDriveStartGenseq) {
+                    hasAutoDriveAfterVisibleAnswer = true;
+                }
                 continue;
             }
             if (event.type === 'func_call_record' || event.type === 'tellask_call_record') {
-                visibleReplySettled = false;
-                lastVisibleAnswer = undefined;
+                if (visibleAnswer !== undefined && event.genseq > visibleAnswer.genseq) {
+                    hasAutoDriveAfterVisibleAnswer = true;
+                    continue;
+                }
+                visibleAnswer = undefined;
+                possibleAutoDriveStartGenseq = undefined;
             }
         }
-        if (!visibleReplySettled || pendingUserInterjectionReply === undefined || !lastVisibleAnswer) {
+        if (pendingUserInterjectionReply === undefined ||
+            visibleAnswer === undefined ||
+            !hasAutoDriveAfterVisibleAnswer) {
             return undefined;
         }
         if (pendingUserInterjectionReply.msgId !== args.pending?.msgId) {
@@ -9362,16 +9428,16 @@ class DialogPersistence {
             args.dialogId.rootId,
             args.dialogId.selfId,
             `c${String(args.course)}`,
-            `g${String(lastVisibleAnswer.genseq)}`,
+            `g${String(visibleAnswer.genseq)}`,
             pendingUserInterjectionReply.msgId,
         ].join('|');
         return {
             id: `a2h-${Buffer.from(answerIdSource).toString('base64url')}`,
-            content: lastVisibleAnswer.content,
+            content: visibleAnswer.content,
             answeredAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
             answerRef: {
                 course: (0, storage_1.toDialogCourseNumber)(args.course),
-                genseq: (0, storage_1.toCallSiteGenseqNo)(lastVisibleAnswer.genseq),
+                genseq: (0, storage_1.toCallSiteGenseqNo)(visibleAnswer.genseq),
             },
         };
     }

package/dist/priming.js

@@ -227,7 +227,7 @@ function reminderToSnapshot(reminder) {
         meta: reminder.meta,
         echoback: reminder.echoback,
         scope: reminder.scope,
-        renderMode: reminder.renderMode ?? 'markdown',
+        renderMode: reminder.renderMode,
         createdAt: reminder.createdAt,
         priority: reminder.priority,
     };
@@ -2203,8 +2203,7 @@ async function applyPrimingRemindersToDialog(args) {
     const taskReminders = [];
     const agentReminders = [];
     for (const reminder of args.reminders) {
-        const scope = reminder.scope ?? 'task';
-        switch (scope) {
+        switch (reminder.scope) {
             case 'dialog':
                 dialogReminders.push(reminder);
                 break;

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

@@ -56,6 +56,15 @@ export type ReminderMaintenanceReferenceItem = Readonly<{
     meta?: unknown;
 }>;
 export declare function formatReminderMaintenanceReference(language: LanguageCode, reminders: readonly ReminderMaintenanceReferenceItem[]): string | undefined;
+export declare function formatSharedReminderUpdateImpactNotice(language: LanguageCode, args: {
+    reminderId: string;
+    scope: 'task' | 'agent' | 'runtime';
+    audience: 'updater' | 'peer';
+}): string;
+export declare function formatSharedReminderMigrationImpactNotice(language: LanguageCode, args: {
+    reminderId: string;
+    scope: 'task' | 'agent' | 'runtime';
+}): string;
 export declare function formatReminderItemGuide(language: LanguageCode, reminderId: string, content: string, options?: {
     meta?: unknown;
     scope?: 'dialog' | 'task' | 'agent' | 'runtime';

package/dist/runtime/driver-messages.js

@@ -12,6 +12,8 @@ exports.formatDiligenceAutoContinuePrompt = formatDiligenceAutoContinuePrompt;
 exports.formatReminderContextGuide = formatReminderContextGuide;
 exports.formatReminderContextFooter = formatReminderContextFooter;
 exports.formatReminderMaintenanceReference = formatReminderMaintenanceReference;
+exports.formatSharedReminderUpdateImpactNotice = formatSharedReminderUpdateImpactNotice;
+exports.formatSharedReminderMigrationImpactNotice = formatSharedReminderMigrationImpactNotice;
 exports.formatReminderItemGuide = formatReminderItemGuide;
 exports.formatQ4HDiligencePushBudgetExhausted = formatQ4HDiligencePushBudgetExhausted;
 exports.formatDomindsNoteTellaskForTeammatesOnly = formatDomindsNoteTellaskForTeammatesOnly;
@@ -133,16 +135,18 @@ function formatNewCourseStartPrompt(language, args) {
             : `Dominds 因上下文已告急而自动开启了第 ${args.nextCourse} 程对话。`;
         return (`${noticePrefix} ${prefix} ` +
             '这是 Dominds 的换程提示，不是新的用户诉求；不要把这条提示当成新的待办，也不要只回复“收到/好的/我会先整理提醒项”。' +
-            '现在已经进入新一程：上下文已经不再吃紧，告急状况已改观。第一步先复核并在必要时整理接续包提醒项，以清醒头脑删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项；若提醒项已经足够清晰，就不要为了整理而整理。' +
-            '完成这一步后，直接继续推进原任务本身；除非任务自然需要对用户交付结果，否则不要为这条提示单独回复。');
+            '现在已经进入新一程：如果见到上一程的上下文吃紧/告急状况记录，此时既已消除。第一步先读取当前对话范围（scope=dialog）的接续包提醒项，尤其是其中写明的当前对话任务目标，并按这个目标恢复当前这一路主线对话/支线对话，不要仅凭同一差遣牒里的其它主线或支线内容改道。' +
+            '随后复核并在必要时整理接续包提醒项，以清醒头脑删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项；若提醒项已经足够清晰，就不要为了整理而整理。' +
+            '完成这一步后，直接按照当前对话范围提醒项里的任务目标继续推进；除非任务自然需要对用户交付结果，否则不要为这条提示单独回复。');
     }
     const prefix = args.source === 'clear_mind'
         ? `This is dialog course #${args.nextCourse}. You just cleared your mind.`
         : `Dominds auto-started dialog course #${args.nextCourse} because context was critical.`;
     return (`${noticePrefix} ${prefix} ` +
         'This is a Dominds course-transition notice, not a new user request; do not treat it as a new to-do, and do not reply with a standalone "acknowledged/ok/I will reorganize the reminders first". ' +
-        'You are now in a new course: your first step is to review and, if needed, rewrite any continuation-package reminders with a clear head, remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders; if the reminders are already clear enough, do not churn on them. ' +
-        'After that, continue the underlying task itself directly; unless the task naturally calls for a user-facing delivery, do not send a standalone reply just for this notice.');
+        'You are now in a new course: if you see records that the previous course was context-tight or context-critical, that condition is now resolved. First read the current-dialog scoped (scope=dialog) continuation-package reminders, especially the current dialog task goal written there, and resume this specific Main Dialog or Side Dialog from that goal instead of drifting into other Main/Side Dialog work that shares the same Taskdoc. ' +
+        'Then review and, if needed, rewrite any continuation-package reminders with a clear head, remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders; if the reminders are already clear enough, do not churn on them. ' +
+        'After that, continue directly from the task goal in the current-dialog scoped reminders; unless the task naturally calls for a user-facing delivery, do not send a standalone reply just for this notice.');
 }
 function formatDiligenceAutoContinuePrompt(language, diligenceText) {
     const noticePrefix = formatSystemNoticePrefix(language);
@@ -562,6 +566,60 @@ function formatReminderMaintenanceReference(language, reminders) {
         ...lines,
     ].join('\n');
 }
+function formatSharedReminderUpdateImpactNotice(language, args) {
+    const reminderId = args.reminderId;
+    const scope = args.scope;
+    if (language === 'zh') {
+        const scopeName = scope === 'task' ? '任务范围' : scope === 'agent' ? '智能体范围' : '运行时范围';
+        const impactedDialogs = scope === 'task'
+            ? '当前进行时存在同一智能体在当前差遣牒任务内的其它并行对话'
+            : '当前进行时存在同一智能体的其它并行对话';
+        if (args.audience === 'updater') {
+            return `共享范围影响：你刚更新的 reminder_id=${reminderId} 是${scopeName}提醒项，不是当前对话私有；${impactedDialogs}，其它能看到这条提醒项的对话也会看到这次更新。请考虑使用 migrate_reminder({ "reminder_id": "${reminderId}", "scope": "dialog" }) 确保提醒项的影响范围合理；若新内容只应影响当前对话，迁移后系统会从共享范围撤下，并保留为仅本对话可见的提醒项。`;
+        }
+        return [
+            `${formatSystemNoticePrefix(language)} 共享范围提醒项已更新`,
+            '',
+            `reminder_id=${reminderId} 是${scopeName}提醒项，不是当前对话私有；${impactedDialogs}。同一智能体的某个并行对话刚更新了它，你所在对话也会看到这次更新。`,
+            '这条共享提醒项这次实际上由另一对话维护；你应自行判断它与本对话当前上下文是否有关，只采纳确实相关的部分。',
+            `请把它作为最新共享参考。若这次更新看起来只适合更新者所在对话，不要在本对话替它修正共享内容；可提醒更新者在其对话中使用 migrate_reminder({ "reminder_id": "${reminderId}", "scope": "dialog" }) 迁回对话范围，从而从其它并行对话撤下。本对话若另有私有状态，请另建对话范围提醒项。`,
+        ].join('\n');
+    }
+    const scopeName = scope === 'task' ? 'task-scope' : scope === 'agent' ? 'agent-scope' : 'runtime-scope';
+    const impactedDialogs = scope === 'task'
+        ? 'The current in-flight work has other parallel dialogs for the same agent and Taskdoc'
+        : 'The current in-flight work has other parallel dialogs for the same agent';
+    if (args.audience === 'updater') {
+        return `Shared-scope impact: the reminder you just updated, reminder_id=${reminderId}, is ${scopeName}, not private to the current dialog. ${impactedDialogs}, so other dialogs that can see this reminder will see this update too. Consider running migrate_reminder({ "reminder_id": "${reminderId}", "scope": "dialog" }) to make sure the reminder's impact scope is appropriate; if the new content should affect only the current dialog, Dominds will withdraw it from shared scope and keep it visible only in this dialog after migration.`;
+    }
+    return [
+        `${formatSystemNoticePrefix(language)} Shared-scope reminder updated`,
+        '',
+        `reminder_id=${reminderId} is ${scopeName}, not private to the current dialog. ${impactedDialogs}. Another parallel dialog for the same agent just updated it, so this dialog will see the update too.`,
+        'This shared reminder was actually maintained by another dialog this time; decide for yourself whether it is relevant to this dialog context, and use only the parts that are truly relevant.',
+        `Use it as the latest shared reference. If this update appears to fit only the updater's dialog, do not correct the shared content from this dialog; you may ask the updater to run migrate_reminder({ "reminder_id": "${reminderId}", "scope": "dialog" }) in that dialog so Dominds withdraws it from other parallel dialogs. If this dialog has its own private state, create a separate dialog-scope reminder here.`,
+    ].join('\n');
+}
+function formatSharedReminderMigrationImpactNotice(language, args) {
+    const reminderId = args.reminderId;
+    const scope = args.scope;
+    if (language === 'zh') {
+        const scopeName = scope === 'task' ? '任务范围' : scope === 'agent' ? '智能体范围' : '运行时范围';
+        return [
+            `${formatSystemNoticePrefix(language)} 共享范围提醒项已迁回其它对话`,
+            '',
+            `reminder_id=${reminderId} 原本是${scopeName}提醒项；更新者对话已将它迁回自己的对话范围，因此它不再是你所在对话可见的共享参考。`,
+            '若本对话仍需要类似内容，请按本对话当前状态另建对话范围或任务范围提醒项；不要假设迁走后的内容仍适用于这里。',
+        ].join('\n');
+    }
+    const scopeName = scope === 'task' ? 'task-scope' : scope === 'agent' ? 'agent-scope' : 'runtime-scope';
+    return [
+        `${formatSystemNoticePrefix(language)} Shared-scope reminder migrated back to another dialog`,
+        '',
+        `reminder_id=${reminderId} was ${scopeName}. The updater dialog has moved it back into its own dialog scope, so it is no longer a shared reference visible to this dialog.`,
+        'If this dialog still needs similar content, create a dialog-scope or task-scope reminder that matches this dialog now; do not assume the migrated content still applies here.',
+    ].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.
@@ -615,12 +673,12 @@ function formatReminderItemGuide(language, reminderId, content, options) {
         }
         const scopeLabel = scope === 'task' ? '（任务范围）' : scope === 'agent' ? '（智能体范围）' : '';
         const scopeGuide = scope === 'task'
-            ? `${projectionNote}你设置了任务范围提醒项，Dominds 会在当前差遣牒任务内、所有由你主理的对话里提醒你。请把它当作当前任务的手头工作提示，不要自动当成系统下发的下一步动作。`
+            ? `${projectionNote}你设置了任务范围提醒项，Dominds 会在当前差遣牒任务内的相关对话里提醒你。请把它当作当前任务的手头工作提示，不要自动当成系统下发的下一步动作。`
             : scope === 'agent'
-                ? `${projectionNote}你设置了智能体范围提醒项，Dominds 会在所有由你主理的对话里提醒你。它只适合紧急、短期、全局刺眼提醒；不要用来记录普通任务状态，也不要自动当成系统下发的下一步动作。`
+                ? `${projectionNote}你设置了智能体范围提醒项，Dominds 会在由你主理的后续对话里提醒你。它只适合紧急、短期、全局刺眼提醒；不要用来记录普通任务状态，也不要自动当成系统下发的下一步动作。`
                 : `${projectionNote}你设置了提醒项，Dominds 会在需要时提醒你。请把它当作用来保留当前对话里容易丢的手头工作信息的提示，不要自动当成系统下发的下一步动作。`;
         const scopeMaintenance = scope === 'task'
-            ? '你应保持简洁、及时更新；不再需要时就删除。若它只对当前对话有效，应改写成 dialog 范围提醒；若需要全队同步当前任务状态，应写入差遣牒 progress，而不是扩大提醒范围。'
+            ? '你应保持简洁、及时更新；不再需要时就删除。若它只对当前对话有效，应改写成对话范围提醒；若需要全队同步当前任务状态，应写入差遣牒 progress，而不是扩大提醒范围。'
             : scope === 'agent'
                 ? '你应主动保持极少量、短期、强相关；不再需要时必须删除。普通任务进展不要放在 agent 范围，当前任务内跨对话可见请改用 task 范围。'
                 : '你应保持简洁、及时更新；不再需要时就删除。若后续准备换程，也可以把它整理成接续包。';
@@ -669,9 +727,9 @@ ${content}`;
     }
     const scopeLabel = scope === 'task' ? ' (TASK SCOPE)' : scope === 'agent' ? ' (AGENT SCOPE)' : '';
     const scopeGuide = scope === 'task'
-        ? `${enProjectionPrefix}You set a task-scope reminder so Dominds can remind you in every dialog you lead for the current Taskdoc. Treat it as a current-work reference for this task, not as an automatically assigned next action.`
+        ? `${enProjectionPrefix}You set a task-scope reminder so Dominds can remind you across relevant dialogs for the current Taskdoc. Treat it as a current-work reference for this task, not as an automatically assigned next action.`
         : scope === 'agent'
-            ? `${enProjectionPrefix}You set an agent-scope reminder so Dominds can remind you in every dialog you lead. This is only for urgent, short-lived, globally visible cues; do not use it for ordinary task state, and do not treat it as an automatically assigned next action.`
+            ? `${enProjectionPrefix}You set an agent-scope reminder so Dominds can remind you across later dialogs you lead. This is only for urgent, short-lived, globally visible cues; do not use it for ordinary task state, and do not treat it as an automatically assigned next action.`
             : `${enProjectionPrefix}You set a reminder so Dominds can remind you when needed. Treat it as a current-work reference for easy-to-lose details in the current dialog, not as an automatically assigned next action.`;
     const scopeMaintenance = scope === 'task'
         ? '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; if the team must synchronize current task state, update Taskdoc progress instead of broadening reminder scope.'
@@ -739,14 +797,16 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
                     '',
                     '影响：对话历史中的工具调用/结果信息很多已经过时，成为你的思考负担。',
                     '',
-                    '行动：你当前处于支线对话。本程不要维护差遣牒，也不要整理差遣牒更新提案；当前目标是维护足够详尽的接续包提醒项，然后主动 clear_mind 开启新一程继续工作。',
+                    '行动：你当前处于支线对话。本程不要维护差遣牒，也不要整理差遣牒更新提案；当前目标是维护足够详尽的当前对话范围（scope=dialog）接续包提醒项，然后主动 clear_mind 开启新一程继续工作。',
+                    '',
+                    '重点提醒：接续包提醒项必须写明当前这一路支线对话的任务目标；同一差遣牒下可能还有同一智能体的其它主线/支线对话，下一程要靠 scope=dialog 提醒项继续本路对话，不能靠共享差遣牒猜目标。',
                     '',
-                    '提醒项应覆盖：当前对话历史中下一程需要知道的讨论细节、下一步行动、关键定位信息、运行/验证信息、临时路径/ID/样例输入，以及任何恢复工作容易丢的判断依据。提醒项没有固定长度限制，宁可完整一些；允许写成多条粗略提醒项，不必在当前程强行压成单条。',
+                    '提醒项应覆盖：当前对话历史中下一程需要知道的任务目标、讨论细节、下一步行动、关键定位信息、运行/验证信息、临时路径/ID/样例输入，以及任何恢复工作容易丢的判断依据。提醒项没有固定长度限制，宁可完整一些；允许写成多条粗略提醒项，不必在当前程强行压成单条。',
                     '',
                     'Dominds 已提醒当前上下文吃紧：不要继续扩张上下文，也不要提前进入“按接续包做清醒复核”的模式；真正清理冗余、合并提醒项，放到 Dominds 开启新一程后再做。',
                     '',
                     '操作：',
-                    '- 优先新增详尽接续包提醒项：add_reminder({ "content": "..." })',
+                    '- 优先新增详尽接续包提醒项：add_reminder({ "content": "...", "scope": "dialog" })',
                     '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
                 ].join('\n');
             }
@@ -757,14 +817,15 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
                 '',
                 '影响：对话历史中的工具调用/结果信息很多已经过时，成为你的思考负担。',
                 '',
-                '行动：你当前处于主线对话。先把当前对话历史中尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节。然后再把差遣牒仍未覆盖、但恢复工作会丢的信息记进新提醒项过桥（下一步行动 + 关键定位信息 + 运行/验证信息 + 容易丢的临时细节）；允许先带着一定冗余，也允许先写成多条粗略提醒项，不必在当前程强行压成单条。',
+                '行动：你当前处于主线对话。先新增或更新当前对话范围（scope=dialog）接续包提醒项，并把当前这一路主线对话的任务目标写清楚。然后只把确实需要同一差遣牒下其它对话/队友知会的讨论事实落到差遣牒合适章节；再把差遣牒仍未覆盖、但恢复本路对话会丢的信息记进 scope=dialog 新提醒项过桥（任务目标 + 下一步行动 + 关键定位信息 + 运行/验证信息 + 容易丢的临时细节）；允许先带着一定冗余，也允许先写成多条粗略提醒项，不必在当前程强行压成单条。',
                 '',
-                'Dominds 已提醒当前上下文吃紧：不要继续扩张上下文，也不要提前进入“按接续包做清醒复核”的模式；那是 Dominds 真正开启新一程后的第一步。当前程的目标是先把未落文档的讨论细节补进差遣牒，再把差遣牒仍未覆盖、但恢复工作会丢的信息带过桥；真正清理冗余、合并提醒项，放到新一程再做。然后主动 clear_mind，开启新一程对话继续工作。',
+                'Dominds 已提醒当前上下文吃紧：不要继续扩张上下文，也不要提前进入“按接续包做清醒复核”的模式；那是 Dominds 真正开启新一程后的第一步。当前程的目标是先用 scope=dialog 提醒项保住本路对话目标，再把需要共享的事实补进差遣牒，最后把差遣牒仍未覆盖、但恢复本路对话会丢的信息带过桥；真正清理冗余、合并提醒项，放到新一程再做。然后主动 clear_mind，开启新一程对话继续工作。',
                 '',
                 '操作：',
+                '- 必须确保当前对话范围提醒项写明本路任务目标：add_reminder({ "content": "...", "scope": "dialog" }) 或 update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
                 '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
                 '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并时，才先调用 recall_taskdoc({"selector":"<selector>"}) 取得 content_hash，再更新：change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})',
-                '- 优先新增过桥提醒项：add_reminder({ "content": "..." })',
+                '- 优先新增当前对话 scope=dialog 过桥提醒项：add_reminder({ "content": "...", "scope": "dialog" })',
                 '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
             ].join('\n');
         }
@@ -776,12 +837,14 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
                 '',
                 `Dominds 最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
                 '',
-                '行动：你当前处于支线对话。本程不要维护差遣牒，也不要整理差遣牒更新提案；当前目标是尽快维护足够详尽的接续包提醒项，然后 clear_mind。',
+                '行动：你当前处于支线对话。本程不要维护差遣牒，也不要整理差遣牒更新提案；当前目标是尽快维护足够详尽的当前对话范围（scope=dialog）接续包提醒项，然后 clear_mind。',
                 '',
-                '提醒项应覆盖：当前对话历史中下一程需要知道的讨论细节、下一步行动、关键定位信息、运行/验证信息、临时路径/ID/样例输入，以及任何恢复工作容易丢的判断依据。提醒项没有固定长度限制，宁可完整一些；允许写成多条粗略提醒项，甚至带一定冗余也可以，不必在当前程强行整理干净。',
+                '重点提醒：接续包提醒项必须写明当前这一路支线对话的任务目标；同一差遣牒下可能还有同一智能体的其它主线/支线对话，下一程要靠 scope=dialog 提醒项继续本路对话，不能靠共享差遣牒猜目标。',
+                '',
+                '提醒项应覆盖：当前对话历史中下一程需要知道的任务目标、讨论细节、下一步行动、关键定位信息、运行/验证信息、临时路径/ID/样例输入，以及任何恢复工作容易丢的判断依据。提醒项没有固定长度限制，宁可完整一些；允许写成多条粗略提醒项，甚至带一定冗余也可以，不必在当前程强行整理干净。',
                 '',
                 '操作：',
-                '- 优先新增详尽接续包提醒项：add_reminder({ "content": "..." })',
+                '- 优先新增详尽接续包提醒项：add_reminder({ "content": "...", "scope": "dialog" })',
                 '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
                 '- clear_mind({})',
                 '',
@@ -795,16 +858,17 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '',
             `Dominds 最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
             '',
-            '行动：你当前处于主线对话。尽快保住易丢信息，然后 clear_mind。Dominds 已提醒当前上下文告急：先把当前对话历史中尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节。然后再把差遣牒仍未覆盖、但恢复工作会丢的信息新增提醒项带过桥；允许先保留多条粗略提醒项，甚至带一定冗余也可以，不必在当前程强行整理干净。',
+            '行动：你当前处于主线对话。尽快保住易丢信息，然后 clear_mind。Dominds 已提醒当前上下文告急：先新增或更新当前对话范围（scope=dialog）接续包提醒项，并把当前这一路主线对话的任务目标写清楚。然后只把确实需要同一差遣牒下其它对话/队友知会的讨论事实落到差遣牒合适章节；再把差遣牒仍未覆盖、但恢复本路对话会丢的信息新增 scope=dialog 提醒项带过桥；允许先保留多条粗略提醒项，甚至带一定冗余也可以，不必在当前程强行整理干净。',
             '',
             '操作：',
+            '- 必须确保当前对话范围提醒项写明本路任务目标：add_reminder({ "content": "...", "scope": "dialog" }) 或 update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
             '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
             '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并时，才先调用 recall_taskdoc({"selector":"<selector>"}) 取得 content_hash，再更新：change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})',
-            '- 优先新增过桥提醒项：add_reminder({ "content": "..." })',
+            '- 优先新增当前对话 scope=dialog 过桥提醒项：add_reminder({ "content": "...", "scope": "dialog" })',
             '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
             '- clear_mind({})',
             '',
-            '接续包要点：下一步行动 + 关键定位信息 + 运行验证方式 + 容易丢的临时细节；不要重复差遣牒已有内容，本程刚落入差遣牒的讨论细节只需提示下一程先查差遣牒。Dominds 已提醒当前上下文告急：不要提前做“新一程清醒复核”；Dominds 真正开启新一程后，第一步才是重新审视并整理：删除冗余、纠正偏激/失真思路、合并并压缩成高质量提醒项。',
+            '接续包要点：当前对话任务目标 + 下一步行动 + 关键定位信息 + 运行验证方式 + 容易丢的临时细节；不要重复差遣牒已有内容，本程刚落入差遣牒的讨论细节只需提示下一程先查差遣牒。Dominds 已提醒当前上下文告急：不要提前做“新一程清醒复核”；Dominds 真正开启新一程后，第一步才是按当前对话范围提醒项里的任务目标继续本路对话，并重新审视整理：删除冗余、纠正偏激/失真思路、合并并压缩成高质量提醒项。',
         ].join('\n');
     }
     if (args.kind === 'caution' && args.mode === 'soft') {
@@ -816,14 +880,16 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
                 '',
                 'Impact: stale call/results in dialog history are creating cognitive noise.',
                 '',
-                'Action: you are in a Side Dialog. Do not maintain Taskdoc in this course, and do not draft Taskdoc update proposals. The current goal is to maintain sufficiently detailed continuation-package reminders, then proactively clear_mind to start a new dialog course.',
+                'Action: you are in a Side Dialog. Do not maintain Taskdoc in this course, and do not draft Taskdoc update proposals. The current goal is to maintain sufficiently detailed current-dialog scoped (scope=dialog) continuation-package reminders, then proactively clear_mind to start a new dialog course.',
+                '',
+                'Priority reminder: the continuation-package reminder must state this specific Side Dialog task goal. The same Taskdoc may have other Main/Side Dialogs for the same agent, so the next course must continue this dialog from scope=dialog reminders instead of guessing the goal from the shared Taskdoc.',
                 '',
-                'Reminders should cover: discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and any reasoning needed to resume safely. Reminders have no fixed length limit, so prefer being complete; rough multi-reminder carry-over is acceptable, and you do not need to force everything into one clean reminder in the current course.',
+                'Reminders should cover: the task goal, discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and any reasoning needed to resume safely. Reminders have no fixed length limit, so prefer being complete; rough multi-reminder carry-over is acceptable, and you do not need to force everything into one clean reminder in the current course.',
                 '',
                 'Dominds has already warned that context is tight for the current course, so do not keep expanding context and do not switch early into “clear-headed continuation-package review” mode; reminder cleanup and dedup belong to the new course.',
                 '',
                 'Operations:',
-                '- Prefer adding a detailed continuation-package reminder first: add_reminder({ "content": "..." })',
+                '- Prefer adding a detailed continuation-package reminder first: add_reminder({ "content": "...", "scope": "dialog" })',
                 '- Only if an existing reminder is clearly the right place, and updating it would not add extra cognitive load in the current course: update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
             ].join('\n');
         }
@@ -834,14 +900,15 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '',
             'Impact: stale call/results in dialog history are creating cognitive noise.',
             '',
-            'Action: you are in the Main Dialog. First record current-dialog discussion details that are not yet documented but the next course needs to know into the appropriate Taskdoc sections. Then write information still not covered by Taskdoc but easy to lose into new bridge reminders (next step + key pointers + run/verify info + easy-to-lose volatile details). Some redundancy is acceptable, and rough multi-reminder carry-over is acceptable too; do not force everything into one clean reminder in the current course.',
+            'Action: you are in the Main Dialog. First add or update a current-dialog scoped (scope=dialog) continuation-package reminder and state this specific Main Dialog task goal clearly. Then record only discussion facts that other dialogs/teammates sharing the same Taskdoc truly need to know into the appropriate Taskdoc sections. After that, write information still not covered by Taskdoc but easy to lose for resuming this dialog into scope=dialog bridge reminders (task goal + next step + key pointers + run/verify info + easy-to-lose volatile details). Some redundancy is acceptable, and rough multi-reminder carry-over is acceptable too; do not force everything into one clean reminder in the current course.',
             '',
-            'Dominds has already warned that context is tight for the current course, so do not keep expanding context and do not switch early into “clear-headed continuation-package review” mode; that is the first step only after Dominds actually starts the new course. In the current course, the goal is to first fill Taskdoc with undocumented discussion details, then carry forward details still not covered by Taskdoc; reminder cleanup and dedup belong to the new course. Then proactively clear_mind to start a new dialog course.',
+            'Dominds has already warned that context is tight for the current course, so do not keep expanding context and do not switch early into “clear-headed continuation-package review” mode; that is the first step only after Dominds actually starts the new course. In the current course, the goal is to first preserve this dialog goal in a scope=dialog reminder, then fill Taskdoc only with facts that need to be shared, and finally carry forward details still not covered by Taskdoc but needed to resume this dialog; reminder cleanup and dedup belong to the new course. Then proactively clear_mind to start a new dialog course.',
             '',
             'Operations:',
+            '- Ensure a current-dialog scoped reminder states this dialog task goal: add_reminder({ "content": "...", "scope": "dialog" }) or update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
             '- Prefer creating a new Taskdoc section for discussion details: do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
             '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content: first call recall_taskdoc({"selector":"<selector>"}) for content_hash, then change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})',
-            '- Prefer adding a bridge reminder first: add_reminder({ "content": "..." })',
+            '- Prefer adding a current-dialog scope=dialog bridge reminder first: add_reminder({ "content": "...", "scope": "dialog" })',
             '- Only if an existing reminder is clearly the right place, and updating it would not add extra cognitive load in the current course: update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
         ].join('\n');
     }
@@ -853,12 +920,14 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '',
             `Dominds will remind you ${args.promptsRemainingAfterThis} more time(s), then automatically clear mind.`,
             '',
-            'Action: you are in a Side Dialog. Do not maintain Taskdoc in this course, and do not draft Taskdoc update proposals. The current goal is to maintain sufficiently detailed continuation-package reminders as soon as possible, then clear_mind.',
+            'Action: you are in a Side Dialog. Do not maintain Taskdoc in this course, and do not draft Taskdoc update proposals. The current goal is to maintain sufficiently detailed current-dialog scoped (scope=dialog) continuation-package reminders as soon as possible, then clear_mind.',
+            '',
+            'Priority reminder: the continuation-package reminder must state this specific Side Dialog task goal. The same Taskdoc may have other Main/Side Dialogs for the same agent, so the next course must continue this dialog from scope=dialog reminders instead of guessing the goal from the shared Taskdoc.',
             '',
-            'Reminders should cover: discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and any reasoning needed to resume safely. Reminders have no fixed length limit, so prefer being complete; multiple rough reminders, including some redundancy, are acceptable as a bridge.',
+            'Reminders should cover: the task goal, discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and any reasoning needed to resume safely. Reminders have no fixed length limit, so prefer being complete; multiple rough reminders, including some redundancy, are acceptable as a bridge.',
             '',
             'Operations:',
-            '- Prefer adding a detailed continuation-package reminder first: add_reminder({ "content": "..." })',
+            '- Prefer adding a detailed continuation-package reminder first: add_reminder({ "content": "...", "scope": "dialog" })',
             '- Only if an existing reminder is clearly the right place, and updating it would not add extra cognitive load in the current course: update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
             '- clear_mind({})',
             '',
@@ -872,16 +941,17 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
         '',
         `Dominds will remind you ${args.promptsRemainingAfterThis} more time(s), then automatically clear mind.`,
         '',
-        'Action: you are in the Main Dialog. Preserve easy-to-lose information, then clear_mind. Because Dominds has warned that context is critical, first record current-dialog discussion details that are not yet documented but the next course needs to know into the appropriate Taskdoc sections. Then add bridge reminders for information still not covered by Taskdoc but easy to lose. Multiple rough reminders, including some redundancy, are acceptable as a bridge; do not spend the current course forcing them into a clean final package.',
+        'Action: you are in the Main Dialog. Preserve easy-to-lose information, then clear_mind. Because Dominds has warned that context is critical, first add or update a current-dialog scoped (scope=dialog) continuation-package reminder and state this specific Main Dialog task goal clearly. Then record only discussion facts that other dialogs/teammates sharing the same Taskdoc truly need to know into the appropriate Taskdoc sections. After that, add scope=dialog bridge reminders for information still not covered by Taskdoc but easy to lose when resuming this dialog. Multiple rough reminders, including some redundancy, are acceptable as a bridge; do not spend the current course forcing them into a clean final package.',
         '',
         'Operations:',
+        '- Ensure a current-dialog scoped reminder states this dialog task goal: add_reminder({ "content": "...", "scope": "dialog" }) or update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
         '- Prefer creating a new Taskdoc section for discussion details: do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
         '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content: first call recall_taskdoc({"selector":"<selector>"}) for content_hash, then change_mind({"selector":"<selector>","content":"...","previous_content_hash":"crc32:..."})',
-        '- Prefer adding a bridge reminder first: add_reminder({ "content": "..." })',
+        '- Prefer adding a current-dialog scope=dialog bridge reminder first: add_reminder({ "content": "...", "scope": "dialog" })',
         '- Only if an existing reminder is clearly the right place, and updating it would not add extra cognitive load in the current course: update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
         '- clear_mind({})',
         '',
-        'Continuation package: next step + key pointers + run/verify info + easy-to-lose volatile details. Do not duplicate Taskdoc content; for discussion details just written into Taskdoc in this course, only remind the next course to review Taskdoc first. Because Dominds has warned that context is critical in the current course, do not start the new-course cleanup early; once Dominds actually starts the new course, the first step is to reconcile rough bridge reminders by removing redundancy, correcting biased or distorted bridge notes, and merging/compressing them into high-quality reminders.',
+        'Continuation package: current dialog task goal + next step + key pointers + run/verify info + easy-to-lose volatile details. Do not duplicate Taskdoc content; for discussion details just written into Taskdoc in this course, only remind the next course to review Taskdoc first. Because Dominds has warned that context is critical in the current course, do not start the new-course cleanup early; once Dominds actually starts the new course, the first step is to continue this dialog from the task goal in current-dialog scoped reminders and reconcile rough bridge reminders by removing redundancy, correcting biased or distorted bridge notes, and merging/compressing them into high-quality reminders.',
     ].join('\n');
 }
 function formatAgentFacingCriticalUserInterjectionRemediationGuide(language, args) {

package/dist/runtime/shared-reminder-update-impact.d.ts

@@ -0,0 +1,20 @@
+import type { LanguageCode } from '@longrun-ai/kernel/types/language';
+import type { Dialog } from '../dialog';
+export type SharedReminderUpdateImpactScope = 'task' | 'agent' | 'runtime';
+export type SharedReminderUpdateImpactDispatch = Readonly<{
+    scope: SharedReminderUpdateImpactScope;
+    peerDialogCount: number;
+    dispatchedDialogCount: number;
+}>;
+export declare function dispatchSharedReminderUpdateImpact(args: {
+    updater: Dialog;
+    reminderId: string;
+    scope: SharedReminderUpdateImpactScope;
+    language: LanguageCode;
+}): Promise<SharedReminderUpdateImpactDispatch | undefined>;
+export declare function dispatchSharedReminderMigrationImpact(args: {
+    updater: Dialog;
+    reminderId: string;
+    scope: SharedReminderUpdateImpactScope;
+    language: LanguageCode;
+}): Promise<SharedReminderUpdateImpactDispatch | undefined>;