dominds 1.27.3 → 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',
     };
@@ -9308,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')
@@ -9321,6 +9322,7 @@ class DialogPersistence {
                     genseq: (0, storage_1.toCallSiteGenseqNo)(event.genseq),
                 };
                 visibleReplySettled = false;
+                visibleReplyGenseq = undefined;
                 continue;
             }
             if (pendingUserInterjectionReply === undefined) {
@@ -9328,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 = {
@@ -9352,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) {
@@ -9379,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.js

@@ -135,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);
@@ -795,14 +797,16 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
                     '',
                     '影响：对话历史中的工具调用/结果信息很多已经过时，成为你的思考负担。',
                     '',
-                    '行动：你当前处于支线对话。本程不要维护差遣牒，也不要整理差遣牒更新提案；当前目标是维护足够详尽的接续包提醒项，然后主动 clear_mind 开启新一程继续工作。',
+                    '行动：你当前处于支线对话。本程不要维护差遣牒，也不要整理差遣牒更新提案；当前目标是维护足够详尽的当前对话范围（scope=dialog）接续包提醒项，然后主动 clear_mind 开启新一程继续工作。',
                     '',
-                    '提醒项应覆盖：当前对话历史中下一程需要知道的讨论细节、下一步行动、关键定位信息、运行/验证信息、临时路径/ID/样例输入，以及任何恢复工作容易丢的判断依据。提醒项没有固定长度限制，宁可完整一些；允许写成多条粗略提醒项，不必在当前程强行压成单条。',
+                    '重点提醒：接续包提醒项必须写明当前这一路支线对话的任务目标；同一差遣牒下可能还有同一智能体的其它主线/支线对话，下一程要靠 scope=dialog 提醒项继续本路对话，不能靠共享差遣牒猜目标。',
+                    '',
+                    '提醒项应覆盖：当前对话历史中下一程需要知道的任务目标、讨论细节、下一步行动、关键定位信息、运行/验证信息、临时路径/ID/样例输入，以及任何恢复工作容易丢的判断依据。提醒项没有固定长度限制，宁可完整一些；允许写成多条粗略提醒项，不必在当前程强行压成单条。',
                     '',
                     'Dominds 已提醒当前上下文吃紧：不要继续扩张上下文，也不要提前进入“按接续包做清醒复核”的模式；真正清理冗余、合并提醒项，放到 Dominds 开启新一程后再做。',
                     '',
                     '操作：',
-                    '- 优先新增详尽接续包提醒项：add_reminder({ "content": "..." })',
+                    '- 优先新增详尽接续包提醒项：add_reminder({ "content": "...", "scope": "dialog" })',
                     '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
                 ].join('\n');
             }
@@ -813,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');
         }
@@ -832,12 +837,14 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
                 '',
                 `Dominds 最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
                 '',
-                '行动：你当前处于支线对话。本程不要维护差遣牒，也不要整理差遣牒更新提案；当前目标是尽快维护足够详尽的接续包提醒项，然后 clear_mind。',
+                '行动：你当前处于支线对话。本程不要维护差遣牒，也不要整理差遣牒更新提案；当前目标是尽快维护足够详尽的当前对话范围（scope=dialog）接续包提醒项，然后 clear_mind。',
+                '',
+                '重点提醒：接续包提醒项必须写明当前这一路支线对话的任务目标；同一差遣牒下可能还有同一智能体的其它主线/支线对话，下一程要靠 scope=dialog 提醒项继续本路对话，不能靠共享差遣牒猜目标。',
                 '',
-                '提醒项应覆盖：当前对话历史中下一程需要知道的讨论细节、下一步行动、关键定位信息、运行/验证信息、临时路径/ID/样例输入，以及任何恢复工作容易丢的判断依据。提醒项没有固定长度限制，宁可完整一些；允许写成多条粗略提醒项，甚至带一定冗余也可以，不必在当前程强行整理干净。',
+                '提醒项应覆盖：当前对话历史中下一程需要知道的任务目标、讨论细节、下一步行动、关键定位信息、运行/验证信息、临时路径/ID/样例输入，以及任何恢复工作容易丢的判断依据。提醒项没有固定长度限制，宁可完整一些；允许写成多条粗略提醒项，甚至带一定冗余也可以，不必在当前程强行整理干净。',
                 '',
                 '操作：',
-                '- 优先新增详尽接续包提醒项：add_reminder({ "content": "..." })',
+                '- 优先新增详尽接续包提醒项：add_reminder({ "content": "...", "scope": "dialog" })',
                 '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
                 '- clear_mind({})',
                 '',
@@ -851,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') {
@@ -872,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.',
                 '',
-                '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.',
+                '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: 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');
         }
@@ -890,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');
     }
@@ -909,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({})',
             '',
@@ -928,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/shared-reminders.js

@@ -106,8 +106,8 @@ function serializeReminder(reminder) {
         ownerName: reminder.owner?.name,
         meta: reminder.meta,
         echoback: reminder.echoback,
-        scope: reminder.scope ?? 'agent',
-        renderMode: reminder.renderMode ?? 'markdown',
+        scope: reminder.scope,
+        renderMode: reminder.renderMode,
         createdAt: reminder.createdAt ?? (0, time_1.formatUnifiedTimestamp)(new Date()),
         priority: reminder.priority ?? 'medium',
     };

package/dist/tool.d.ts

@@ -50,7 +50,11 @@ type PreparedRawToolArguments = Readonly<{
 }>;
 export interface ReminderOptions {
     readonly echoback?: boolean;
-    readonly scope?: ReminderScope;
+    readonly scope: ReminderScope;
+    readonly renderMode: ReminderRenderMode;
+}
+export interface ReminderUpdateOptions {
+    readonly echoback?: boolean;
     readonly renderMode?: ReminderRenderMode;
 }
 export type ReminderScope = 'dialog' | 'task' | 'agent' | 'runtime';
@@ -63,7 +67,6 @@ export interface Reminder extends ReminderOptions {
     readonly meta?: JsonValue;
     readonly createdAt?: string;
     readonly priority?: ReminderPriority;
-    readonly renderMode?: ReminderRenderMode;
 }
 export declare function reminderEchoBackEnabled(reminder: Reminder): boolean;
 export declare function reminderIsVirtual(reminder: Reminder): boolean;
@@ -75,10 +78,10 @@ export declare function materializeReminder(input: Readonly<{
     owner?: ReminderOwner;
     meta?: JsonValue;
     echoback?: boolean;
-    scope?: ReminderScope;
+    scope: ReminderScope;
     createdAt?: string;
     priority?: ReminderPriority;
-    renderMode?: ReminderRenderMode;
+    renderMode: ReminderRenderMode;
 }>): Reminder;
 export declare function cloneReminder(reminder: Reminder): Reminder;
 export declare function computeReminderRenderRevision(reminder: Reminder): string;

package/dist/tool.js

@@ -63,16 +63,22 @@ function ensureReminderId(value) {
     return trimmed && trimmed.length > 0 ? trimmed : generateReminderId();
 }
 function materializeReminder(input) {
+    if (input.scope === undefined) {
+        throw new Error('materializeReminder requires explicit scope');
+    }
+    if (input.renderMode === undefined) {
+        throw new Error('materializeReminder requires explicit renderMode');
+    }
     return {
         id: ensureReminderId(input.id),
         content: input.content,
         owner: input.owner,
         meta: input.meta,
         echoback: input.echoback,
-        scope: input.scope ?? 'dialog',
+        scope: input.scope,
         createdAt: input.createdAt,
         priority: input.priority,
-        renderMode: input.renderMode ?? 'markdown',
+        renderMode: input.renderMode,
     };
 }
 function cloneReminder(reminder) {
@@ -94,8 +100,8 @@ function computeReminderRenderRevision(reminder) {
         content: reminder.content,
         meta: reminder.meta ?? null,
         echoback: reminder.echoback ?? true,
-        scope: reminder.scope ?? 'dialog',
-        renderMode: reminder.renderMode ?? 'markdown',
+        scope: reminder.scope,
+        renderMode: reminder.renderMode,
     });
     return `sha256:${(0, crypto_1.createHash)('sha256').update(payload, 'utf8').digest('hex')}`;
 }

package/dist/tools/app-reminders.js

@@ -139,7 +139,7 @@ function toReminderState(reminder) {
         content: reminder.content,
         meta: extractOwnerMeta(reminder.meta),
         echoback: reminder.echoback,
-        renderMode: reminder.renderMode ?? 'markdown',
+        renderMode: reminder.renderMode,
     };
 }
 function findOwnedReminderEntries(dlg, descriptor, owner) {
@@ -201,7 +201,7 @@ async function persistAndPublishReminders(dlg) {
         renderRevision: (0, tool_1.computeReminderRenderRevision)(reminder),
         echoback: (0, tool_1.reminderEchoBackEnabled)(reminder),
         scope: reminder.scope,
-        renderMode: reminder.renderMode ?? 'markdown',
+        renderMode: reminder.renderMode,
     }));
     const evt = { type: 'full_reminders_update', reminders };
     (0, evt_registry_1.postDialogEvent)(dlg, evt);
@@ -321,6 +321,7 @@ async function applyAppReminderRequests(dlg, params) {
             case 'add': {
                 dlg.addReminder(result.reminder.content, owner, buildAppReminderMeta(descriptor, result.reminder.meta), normalizeInsertPosition(dlg.reminders.length, result.position), {
                     echoback: result.reminder.echoback,
+                    scope: 'dialog',
                     renderMode: result.reminder.renderMode ?? 'markdown',
                 });
                 changed = true;
@@ -334,7 +335,7 @@ async function applyAppReminderRequests(dlg, params) {
                 dlg.updateReminder(target.index, result.reminder.content, buildAppReminderMeta(descriptor, result.reminder.meta), {
                     echoback: result.reminder.echoback,
                     // Preserve the existing render mode when the app does not explicitly override it.
-                    renderMode: result.reminder.renderMode ?? target.reminder.renderMode ?? 'markdown',
+                    renderMode: result.reminder.renderMode ?? target.reminder.renderMode,
                 });
                 changed = true;
                 break;

package/dist/tools/ctrl.js

@@ -815,7 +815,10 @@ exports.clearMindTool = {
                 createdBy: 'clear_mind',
                 contextHealthLevel,
             });
-            dlg.addReminder(reminderContent, undefined, continuationMeta);
+            dlg.addReminder(reminderContent, undefined, continuationMeta, undefined, {
+                scope: 'dialog',
+                renderMode: 'markdown',
+            });
         }
         await dlg.startNewCourse(t.clearedCoursePrompt(dlg.currentCourse + 1));
         // Context health snapshot is inherently tied to the previous prompt/context.

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

@@ -193,6 +193,7 @@ async function syncPendingTellaskReminderState(dlg) {
                 return false;
             }
             dlg.addReminder(content, exports.pendingTellaskReminderOwner, nextMeta, 0, {
+                scope: 'dialog',
                 renderMode: 'markdown',
             });
             return true;

package/dist/tools/prompts/control/en/index.md

@@ -26,7 +26,7 @@
 
 control is Dominds' **dialog control toolset** for managing dialog state, reminders, taskdocs, and inter-dialog reply closure semantics:
 
-- **Reminder management**: Three reminder scopes: `dialog` / `task` / `agent`. Default to `task` for current work under the same Taskdoc; use `dialog` only for truly dialog-local notes; use `agent` only for urgent, short-lived, globally visible cues
+- **Reminder management**: Three reminder scopes: `dialog` / `task` / `agent`. Default to `task` for ordinary current work under the same Taskdoc; use `dialog` for truly dialog-local notes, and continuation packages before `clear_mind` must explicitly use `scope=dialog` and state this dialog task goal; use `agent` only for urgent, short-lived, globally visible cues
 - **Taskdoc operations**: Append to, replace, or delete task contract sections (goals/constraints/progress); within Taskdoc, `progress` is the team-shared, quasi-real-time, scannable task bulletin board
 - **Context maintenance**: Reduce cognitive load without losing key resume state
 - **Reply routing**: Separate asking the tellasker back, sending the final reply, and ordinary plain text in Side Dialog / ask-back flows
@@ -56,13 +56,13 @@ Reminders are temporary current-work information for:
 - Marking pending tasks
 - Tracking current next steps / blockers
 - Recording blocking issues
-- Holding continuation-package bridge notes before `clear_mind`
+- Holding current-dialog scoped continuation-package bridge notes before `clear_mind`
 
 Reminders are not for manually copying environment state automatically maintained by Dominds, such as background process status, in-flight background asks/collaboration, or browser/session attachment state. Dominds-managed reminders, panels, and tool outputs are the authoritative place for that state; manual notes go stale easily and create cognitive noise.
 
 Scope rule:
 
-- `dialog`: current-dialog current work
+- `dialog`: current-dialog current work; continuation packages before `clear_mind` must explicitly use this scope and state this dialog task goal
 - `task`: current work under the current Taskdoc, and the default scope
 - `agent`: urgent, short-lived, globally visible cues you should keep seeing across later dialogs you lead
 

package/dist/tools/prompts/control/en/principles.md

@@ -42,7 +42,7 @@ Default to `task`. Use `dialog` only when the note is truly dialog-local; use `a
 - `agent` reminders stay visible in later dialogs you lead
 - Can be added, modified, or deleted at any time
 - Should stay compact, scannable, and directly actionable by default
-- Before `clear_mind`, the Main Dialog first records undocumented discussion details the next course needs to know into Taskdoc, then creates a structured continuation-package reminder; a Side Dialog directly maintains sufficiently detailed continuation-package reminders. If Dominds has already warned that context is tight or critical, Side Dialog reminders have no fixed length limit and rough multi-reminder carry-over is acceptable
+- Before `clear_mind`, first state this dialog task goal in a current-dialog scoped (`scope=dialog`) continuation-package reminder. A Main Dialog records only discussion facts that other dialogs/teammates sharing the same Taskdoc truly need to know into Taskdoc, then keeps resume-critical details for this dialog in `dialog` reminders; a Side Dialog directly maintains sufficiently detailed `dialog` continuation-package reminders. If Dominds has already warned that context is tight or critical, Side Dialog reminders have no fixed length limit and rough multi-reminder carry-over is acceptable
 
 **Difference from memory:**
 | Feature | dialog reminder | task reminder | agent reminder | personal memory |
@@ -124,7 +124,7 @@ Taskdoc is a **task contract** and the task's **team-shared source of current tr
 
 - **Current work**: next step, blockers, key pointers
 - **Easy-to-lose details**: temporary paths, ids, commands, sample inputs
-- **Course transition**: continuation-package notes before `clear_mind`, including rough multi-reminder carry-over when already degraded
+- **Course transition**: current-dialog scoped (`scope=dialog`) continuation-package notes before `clear_mind`; they must state this dialog task goal, including rough multi-reminder carry-over when already degraded
 - **Task carry-over**: if you should keep seeing the note under the current Taskdoc, use `task`
 - **Global urgent cue**: if you should keep seeing it across later dialogs you lead, and it is urgent, short-lived, and globally visible, use `agent`
 
@@ -141,7 +141,7 @@ Taskdoc is a **task contract** and the task's **team-shared source of current tr
 - Do not duplicate system state: background process status, in-flight background asks/collaboration, browser/session attachment state, and similar environment state automatically maintained by Dominds do not belong in manual reminders. Dominds-managed reminders, panels, and tool outputs are the authoritative place for that state; manual copies go stale easily and create cognitive noise
 - Team-facing: keep `progress` scannable and centered on what is still effective now; do not let it degrade into a personal log, raw chronology, scratchpad, or stale history pile. Use `mind_more` for small additions; when cleanup/reordering/compression is needed, call `recall_taskdoc` first and then use `change_mind` with the returned `content_hash` as `previous_content_hash`
 - Condense when needed: `mind_more` is not the default bookkeeping move. If one topic already has several phase notes, prefer `change_mind` to merge them into the current summary; put the detailed expansion in formal rtws documentation and keep a document pointer in Taskdoc. If the replacement would overwrite existing content, proceed only with direct human confirmation or after applying a human-approved SOP/acceptance standard that considers the existing content
-- Collapse before clearing: the Main Dialog first records undocumented discussion details the next course needs to know into the appropriate Taskdoc sections, then creates a structured continuation-package reminder; a Side Dialog must not maintain Taskdoc or draft Taskdoc update proposals, and should directly maintain sufficiently detailed continuation-package reminders. If Dominds has already warned that context is tight or critical, rough multi-reminder carry-over is acceptable but must be reconciled first in the new course
+- Collapse before clearing: the Main Dialog first states this dialog task goal in a `scope=dialog` continuation-package reminder, then writes only facts that other dialogs/teammates sharing the same Taskdoc truly need into the appropriate Taskdoc sections, and keeps resume-critical details for this dialog in `dialog` reminders; a Side Dialog must not maintain Taskdoc or draft Taskdoc update proposals, and should directly maintain sufficiently detailed `dialog` continuation-package reminders. If Dominds has already warned that context is tight or critical, rough multi-reminder carry-over is acceptable; once the new course starts, continue this dialog from the task goal in `scope=dialog` reminders before reconciling
 - Avoid raw-material dumps: do not paste long logs or large tool outputs into reminders
 - Documentation layering: Taskdoc says “what the team should sync on / do next now”; formal rtws documentation carries “why, how, detailed evidence, and the full process”. When Taskdoc references formal rtws documentation, use a stable path/section name/relevant command instead of copying the full content
 
@@ -165,5 +165,5 @@ Taskdoc is a **task contract** and the task's **team-shared source of current tr
 1. `dialog` reminders end with the dialog; `task` reminders stay visible under the current Taskdoc; `agent` reminders stay visible in later dialogs you lead
 2. Use `do_mind` to create missing Taskdoc sections; use `mind_more` for small Taskdoc additions; use `change_mind` for full-section replacement of existing sections only after merging existing content and calling `recall_taskdoc` for the current `content_hash`; use `never_mind` when a whole section file should be deleted. Do not treat `mind_more` as a chronology tool; when cleanup, stale-entry removal, or same-topic consolidation is needed, use `recall_taskdoc` then `change_mind`
 3. `do_mind` / `mind_more` / `change_mind` / `never_mind` do not start a new course
-4. A continuation-package reminder should keep only details still not covered by Taskdoc but easy to lose during resume; in the Main Dialog, undocumented discussion details from current dialog history that the next course needs to know should be written to the appropriate Taskdoc sections first; in a Side Dialog after Dominds warns that context is tight or critical, maintain sufficiently detailed continuation-package reminders only
+4. A continuation-package reminder must be current-dialog scoped (`scope=dialog`) and state this dialog task goal. In the Main Dialog, write only facts that other dialogs/teammates sharing the same Taskdoc truly need into Taskdoc, while reminders keep details still not covered by Taskdoc but easy to lose when resuming this dialog; in a Side Dialog after Dominds warns that context is tight or critical, maintain sufficiently detailed `dialog` continuation-package reminders only
 5. Do not turn `task` / `agent` reminders into a long-term fact dump; move durable knowledge into `personal_memory`