dominds 1.27.2 → 1.27.3

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

@@ -7,11 +7,15 @@ exports.buildFbrToolAvailabilityNotice = buildFbrToolAvailabilityNotice;
 exports.buildFbrSystemPrompt = buildFbrSystemPrompt;
 exports.buildFbrConvergencePrompt = buildFbrConvergencePrompt;
 exports.buildFbrFinalizationPrompt = buildFbrFinalizationPrompt;
+exports.buildFbrContextCautionFinalizationPrompt = buildFbrContextCautionFinalizationPrompt;
+exports.buildProgrammaticFbrContextCriticalContent = buildProgrammaticFbrContextCriticalContent;
 exports.buildProgrammaticFbrUnreasonableSituationContent = buildProgrammaticFbrUnreasonableSituationContent;
 exports.inspectFbrConclusionAttempt = inspectFbrConclusionAttempt;
 exports.createInitialFbrState = createInitialFbrState;
 exports.markFbrPromptDelivered = markFbrPromptDelivered;
 exports.isFbrFinalizationState = isFbrFinalizationState;
+exports.isFbrContextCautionFinalizationState = isFbrContextCautionFinalizationState;
+exports.forceFbrContextCautionFinalizationState = forceFbrContextCautionFinalizationState;
 exports.advanceFbrState = advanceFbrState;
 exports.buildFbrPromptForState = buildFbrPromptForState;
 const fbr_body_1 = require("../../runtime/fbr-body");
@@ -196,6 +200,78 @@ function buildFbrFinalizationPrompt(args) {
         '- Earlier wild ideas that never gained independent support must be discarded as noise and must not appear in the final content.',
     ].join('\n');
 }
+function buildFbrContextCautionFinalizationPrompt(args) {
+    if (args.language === 'zh') {
+        const retryLine = args.attempt <= 1
+            ? 'FBR 上下文状态：🟡 吃紧'
+            : `FBR 上下文仍然吃紧；这是第 ${args.attempt} 次要求你用结论函数收口。`;
+        return [
+            retryLine,
+            '',
+            '当前 FBR 已经因为上下文压力提前进入最终收口。把这视为问题复杂度、推理成本或噪音累积已经不适合继续发散/收敛的信号。',
+            '',
+            `现在必须且只能调用以下两个函数之一结束本次 FBR：`,
+            `- \`${exports.FBR_LOW_NOISE_CONCLUSION_TOOL_NAME}({ content })\``,
+            `- \`${exports.FBR_UNREASONABLE_SITUATION_TOOL_NAME}({ content })\``,
+            '',
+            '选择规则：',
+            '- 如果基于已经完成的发散、收敛推演，仍能形成稳定共识：调用低噪高信息结论函数。',
+            '- 如果已有推演仍相互矛盾、证据不足、关键上下文缺失，或上下文吃紧本身说明问题过于复杂：调用“不合理现状”函数。',
+            '',
+            '强制要求：',
+            '- 不要 clear_mind，不要继续发散/收敛，不要调用其它函数，不要输出普通文本。',
+            '- content 必须由你基于已经做过的推演自行形成；运行时不会替你程序化转译或代写结论。',
+            '- 最终 content 只保留稳定共识、关键未知项、最重要的下一步；未获独立支撑的离谱想法必须当噪音丢弃。',
+        ].join('\n');
+    }
+    const retryLine = args.attempt <= 1
+        ? 'FBR context state: 🟡 caution'
+        : `FBR context is still tight; this is reminder ${args.attempt} requiring you to close through a conclusion function.`;
+    return [
+        retryLine,
+        '',
+        'This FBR is entering final closure early because of context pressure. Treat that as a signal that problem complexity, reasoning cost, or accumulated noise is no longer suitable for continued divergence/convergence.',
+        '',
+        'You must now end this FBR by calling exactly one of:',
+        `- \`${exports.FBR_LOW_NOISE_CONCLUSION_TOOL_NAME}({ content })\``,
+        `- \`${exports.FBR_UNREASONABLE_SITUATION_TOOL_NAME}({ content })\``,
+        '',
+        'Choose as follows:',
+        '- If the divergence/convergence already performed still supports stable consensus, call the low-noise highly-informative conclusion function.',
+        '- If the existing reasoning remains contradictory, under-evidenced, missing key context, or context pressure itself shows the problem is too complex, call the unreasonable-situation function.',
+        '',
+        'Hard requirements:',
+        '- Do not clear_mind, do not keep diverging/converging, do not call any other function, and do not output plain text.',
+        '- The content must be formed by you from the reasoning already performed; the runtime will not programmatically translate or write the conclusion for you.',
+        '- Keep only stable consensus, key unknowns, and the single most important next steps; discard unsupported wild ideas as noise.',
+    ].join('\n');
+}
+function buildProgrammaticFbrContextCriticalContent(args) {
+    if (args.language === 'zh') {
+        return [
+            '当前 FBR 问题过于复杂，不能继续负责地扩展推理，也不能在剩余上下文内形成可靠的低噪结论。',
+            '',
+            '原因：',
+            '- 上下文已经达到告急水平；这本身应视为问题复杂度、证据需求或推理分支数量超过当前 FBR 可控范围的信号。',
+            '- Dominds 不会在告急状态下程序化总结对话、抽取已有推演或替模型转译结论；那会显著提高遗漏、失真和幻觉风险。',
+            '',
+            '建议：',
+            '- 将诉请拆解为更小、更清晰的子问题。',
+            '- 为每个子问题分别固定 Goal / Facts / Constraints / Evidence / Unknowns 后，各自重新发起 FBR。',
+        ].join('\n');
+    }
+    return [
+        'This FBR problem is too complex to keep expanding reasoning responsibly or produce a reliable low-noise conclusion within the remaining context.',
+        '',
+        'Reasons:',
+        '- Context has reached the critical level; this should itself be treated as a signal that problem complexity, evidence needs, or branch count exceeded what the current FBR can control.',
+        '- Dominds will not programmatically summarize the dialog, extract existing reasoning, or translate it into a conclusion under critical context pressure; doing so would materially increase omission, distortion, and hallucination risk.',
+        '',
+        'Suggested next steps:',
+        '- Split the request into smaller, clearer subproblems.',
+        '- For each subproblem, stabilize Goal / Facts / Constraints / Evidence / Unknowns, then run its own FBR pass.',
+    ].join('\n');
+}
 function buildProgrammaticFbrUnreasonableSituationContent(args) {
     if (args.language === 'zh') {
         return [
@@ -308,85 +384,136 @@ function markFbrPromptDelivered(state) {
 function isFbrFinalizationState(state) {
     return state.phase === 'finalization';
 }
+function isFbrContextCautionFinalizationState(state) {
+    return state.phase === 'finalization' && state.finalizationReason === 'context_caution';
+}
+function forceFbrContextCautionFinalizationState(state) {
+    if (state.phase === 'finalization') {
+        return {
+            ...state,
+            finalizationReason: 'context_caution',
+            promptDelivered: false,
+        };
+    }
+    return {
+        kind: 'serial',
+        effort: state.effort,
+        phase: 'finalization',
+        iteration: 1,
+        promptDelivered: false,
+        finalizationReason: 'context_caution',
+    };
+}
 function advanceFbrState(state) {
-    if (state.phase === 'divergence') {
-        if (state.iteration < state.effort) {
+    switch (state.phase) {
+        case 'divergence': {
+            if (state.iteration < state.effort) {
+                return {
+                    kind: 'serial',
+                    effort: state.effort,
+                    phase: 'divergence',
+                    iteration: state.iteration + 1,
+                    promptDelivered: false,
+                };
+            }
             return {
                 kind: 'serial',
                 effort: state.effort,
-                phase: 'divergence',
-                iteration: state.iteration + 1,
+                phase: 'convergence',
+                iteration: 1,
                 promptDelivered: false,
             };
         }
-        return {
-            kind: 'serial',
-            effort: state.effort,
-            phase: 'convergence',
-            iteration: 1,
-            promptDelivered: false,
-        };
-    }
-    if (state.phase === 'convergence') {
-        if (state.iteration < state.effort) {
+        case 'convergence': {
+            if (state.iteration < state.effort) {
+                return {
+                    kind: 'serial',
+                    effort: state.effort,
+                    phase: 'convergence',
+                    iteration: state.iteration + 1,
+                    promptDelivered: false,
+                };
+            }
             return {
                 kind: 'serial',
                 effort: state.effort,
-                phase: 'convergence',
+                phase: 'finalization',
+                iteration: 1,
+                promptDelivered: false,
+                finalizationReason: 'planned',
+            };
+        }
+        case 'finalization': {
+            if (state.finalizationReason === 'context_caution') {
+                return {
+                    kind: 'serial',
+                    effort: state.effort,
+                    phase: 'finalization',
+                    iteration: state.iteration + 1,
+                    promptDelivered: false,
+                    finalizationReason: 'context_caution',
+                };
+            }
+            if (state.iteration >= state.effort) {
+                return undefined;
+            }
+            return {
+                kind: 'serial',
+                effort: state.effort,
+                phase: 'finalization',
                 iteration: state.iteration + 1,
                 promptDelivered: false,
+                finalizationReason: 'planned',
             };
         }
-        return {
-            kind: 'serial',
-            effort: state.effort,
-            phase: 'finalization',
-            iteration: 1,
-            promptDelivered: false,
-        };
-    }
-    if (state.iteration >= state.effort) {
-        return undefined;
+        default: {
+            const _exhaustive = state;
+            return _exhaustive;
+        }
     }
-    return {
-        kind: 'serial',
-        effort: state.effort,
-        phase: 'finalization',
-        iteration: state.iteration + 1,
-        promptDelivered: false,
-    };
 }
 function buildFbrPromptForState(args) {
-    if (args.state.phase === 'divergence') {
-        return (0, inter_dialog_format_1.formatAssignmentFromAskerDialog)({
-            callName: 'freshBootsReasoning',
-            fromAgentId: args.fromAgentId,
-            toAgentId: args.toAgentId,
-            tellaskContent: (0, fbr_body_1.appendDistinctPerspectiveFbrBody)({
-                body: args.tellaskContent,
+    switch (args.state.phase) {
+        case 'divergence':
+            return (0, inter_dialog_format_1.formatAssignmentFromAskerDialog)({
+                callName: 'freshBootsReasoning',
+                fromAgentId: args.fromAgentId,
+                toAgentId: args.toAgentId,
+                tellaskContent: (0, fbr_body_1.appendDistinctPerspectiveFbrBody)({
+                    body: args.tellaskContent,
+                    iteration: args.state.iteration,
+                    total: args.state.effort,
+                    language: args.language,
+                    isFinalRound: args.state.iteration === args.state.effort,
+                }),
+                language: args.language,
+                collectiveTargets: args.collectiveTargets,
+                fbrRound: {
+                    iteration: args.state.iteration,
+                    total: args.state.effort,
+                },
+            });
+        case 'convergence':
+            return buildFbrConvergencePrompt({
                 iteration: args.state.iteration,
                 total: args.state.effort,
                 language: args.language,
-                isFinalRound: args.state.iteration === args.state.effort,
-            }),
-            language: args.language,
-            collectiveTargets: args.collectiveTargets,
-            fbrRound: {
-                iteration: args.state.iteration,
+            });
+        case 'finalization':
+            if (args.state.finalizationReason === 'context_caution') {
+                return buildFbrContextCautionFinalizationPrompt({
+                    attempt: args.state.iteration,
+                    language: args.language,
+                });
+            }
+            return buildFbrFinalizationPrompt({
+                attempt: args.state.iteration,
                 total: args.state.effort,
-            },
-        });
-    }
-    if (args.state.phase === 'convergence') {
-        return buildFbrConvergencePrompt({
-            iteration: args.state.iteration,
-            total: args.state.effort,
-            language: args.language,
-        });
+                language: args.language,
+            });
+        default: {
+            const _exhaustive = args.state;
+            return _exhaustive;
+        }
     }
-    return buildFbrFinalizationPrompt({
-        attempt: args.state.iteration,
-        total: args.state.effort,
-        language: args.language,
-    });
 }

package/dist/minds/load.js

@@ -223,6 +223,7 @@ async function loadAgentMinds(agentId, dialog, options) {
         ctrl_1.addReminderTool,
         ctrl_1.deleteReminderTool,
         ctrl_1.updateReminderTool,
+        ctrl_1.migrateReminderTool,
         ctrl_1.clearMindTool,
         ctrl_1.recallTaskdocTool,
     ];

package/dist/persistence.js

@@ -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)

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;
@@ -562,6 +564,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 +671,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 +725,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.'

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>;

package/dist/runtime/shared-reminder-update-impact.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchSharedReminderUpdateImpact = dispatchSharedReminderUpdateImpact;
+exports.dispatchSharedReminderMigrationImpact = dispatchSharedReminderMigrationImpact;
+const id_1 = require("@longrun-ai/kernel/utils/id");
+const dialog_global_registry_1 = require("../dialog-global-registry");
+const driver_messages_1 = require("./driver-messages");
+function sharedReminderUpdateImpactsDialog(args) {
+    if (args.candidate.id.equals(args.updater.id)) {
+        return false;
+    }
+    if (args.candidate.agentId !== args.updater.agentId) {
+        return false;
+    }
+    return args.scope === 'task' ? args.candidate.taskDocPath === args.updater.taskDocPath : true;
+}
+function collectSharedReminderUpdatePeerDialogs(args) {
+    const peers = [];
+    for (const candidate of dialog_global_registry_1.globalDialogRegistry.getLoadedInFlightDialogsForSharedReminderImpact()) {
+        if (sharedReminderUpdateImpactsDialog({
+            scope: args.scope,
+            updater: args.updater,
+            candidate,
+        })) {
+            peers.push(candidate);
+        }
+    }
+    return peers;
+}
+async function queueSharedReminderUpdateImpactPrompt(args) {
+    await args.targetDialog.queueRuntimeGuidePrompt({
+        prompt: (0, driver_messages_1.formatSharedReminderUpdateImpactNotice)(args.language, {
+            reminderId: args.reminderId,
+            scope: args.scope,
+            audience: 'peer',
+        }),
+        msgId: (0, id_1.generateShortId)(),
+        grammar: 'markdown',
+        userLanguageCode: args.language,
+        skipTaskdoc: true,
+    });
+    dialog_global_registry_1.globalDialogRegistry.queueRootDrive(args.targetDialog.id.rootId, {
+        source: 'shared_reminder_update_impact',
+        reason: `reminder_id:${args.reminderId}`,
+    });
+}
+async function queueSharedReminderMigrationImpactPrompt(args) {
+    await args.targetDialog.queueRuntimeGuidePrompt({
+        prompt: (0, driver_messages_1.formatSharedReminderMigrationImpactNotice)(args.language, {
+            reminderId: args.reminderId,
+            scope: args.scope,
+        }),
+        msgId: (0, id_1.generateShortId)(),
+        grammar: 'markdown',
+        userLanguageCode: args.language,
+        skipTaskdoc: true,
+    });
+    dialog_global_registry_1.globalDialogRegistry.queueRootDrive(args.targetDialog.id.rootId, {
+        source: 'shared_reminder_migration_impact',
+        reason: `migrated_reminder_id:${args.reminderId}`,
+    });
+}
+async function dispatchSharedReminderUpdateImpact(args) {
+    const peerDialogs = collectSharedReminderUpdatePeerDialogs({
+        updater: args.updater,
+        scope: args.scope,
+    });
+    if (peerDialogs.length === 0) {
+        return undefined;
+    }
+    let dispatchedDialogCount = 0;
+    for (const peerDialog of peerDialogs) {
+        await queueSharedReminderUpdateImpactPrompt({
+            targetDialog: peerDialog,
+            reminderId: args.reminderId,
+            scope: args.scope,
+            language: args.language,
+        });
+        dispatchedDialogCount += 1;
+    }
+    return {
+        scope: args.scope,
+        peerDialogCount: peerDialogs.length,
+        dispatchedDialogCount,
+    };
+}
+async function dispatchSharedReminderMigrationImpact(args) {
+    const peerDialogs = collectSharedReminderUpdatePeerDialogs({
+        updater: args.updater,
+        scope: args.scope,
+    });
+    if (peerDialogs.length === 0) {
+        return undefined;
+    }
+    let dispatchedDialogCount = 0;
+    for (const peerDialog of peerDialogs) {
+        await queueSharedReminderMigrationImpactPrompt({
+            targetDialog: peerDialog,
+            reminderId: args.reminderId,
+            scope: args.scope,
+            language: args.language,
+        });
+        dispatchedDialogCount += 1;
+    }
+    return {
+        scope: args.scope,
+        peerDialogCount: peerDialogs.length,
+        dispatchedDialogCount,
+    };
+}

package/dist/tool-availability.js

@@ -225,6 +225,7 @@ function buildIntrinsicControlToolset(dialog) {
         ctrl_1.addReminderTool,
         ctrl_1.deleteReminderTool,
         ctrl_1.updateReminderTool,
+        ctrl_1.migrateReminderTool,
         ctrl_1.clearMindTool,
         ctrl_1.recallTaskdocTool,
     ];

package/dist/tools/builtins.js

@@ -118,6 +118,7 @@ function manualSpecFor(toolsetId) {
 (0, registry_1.registerTool)(ctrl_1.addReminderTool);
 (0, registry_1.registerTool)(ctrl_1.deleteReminderTool);
 (0, registry_1.registerTool)(ctrl_1.updateReminderTool);
+(0, registry_1.registerTool)(ctrl_1.migrateReminderTool);
 (0, registry_1.registerTool)(ctrl_1.clearMindTool);
 (0, registry_1.registerTool)(ctrl_1.doMindTool);
 (0, registry_1.registerTool)(ctrl_1.changeMindTool);
@@ -190,6 +191,7 @@ for (const tool of team_mgmt_1.teamMgmtTools) {
     ctrl_1.addReminderTool,
     ctrl_1.deleteReminderTool,
     ctrl_1.updateReminderTool,
+    ctrl_1.migrateReminderTool,
     ctrl_1.clearMindTool,
     ctrl_1.doMindTool,
     ctrl_1.changeMindTool,

package/dist/tools/cmd-runner-protocol.d.ts

@@ -1,3 +1,4 @@
+export declare const MAX_CMD_RUNNER_OUTPUT_WAIT_TIMEOUT_MS: number;
 export type CmdRunnerSpawnSpec = Readonly<{
     command: string;
     args: string[];
@@ -38,6 +39,8 @@ export type CmdRunnerRequest = Readonly<{
     type: 'get_output';
     stdout: boolean;
     stderr: boolean;
+    waitForNewOutput: boolean;
+    timeoutMs?: number;
 }> | Readonly<{
     type: 'stop';
     entirePg: boolean;
@@ -45,7 +48,9 @@ export type CmdRunnerRequest = Readonly<{
 export type CmdRunnerStreamSnapshot = Readonly<{
     content: string;
     linesScrolledOut: number;
+    version: number;
 }>;
+export type CmdRunnerOutputWaitStatus = 'output' | 'timeout' | 'exited';
 export type CmdRunnerStatusPayload = Readonly<{
     daemonPid: number;
     daemonCommandLine: string;
@@ -69,6 +74,7 @@ export type CmdRunnerResponse = (Readonly<{
 }> & CmdRunnerStatusPayload) | (Readonly<{
     type: 'output';
     ok: true;
+    waitStatus?: CmdRunnerOutputWaitStatus;
 }> & CmdRunnerStatusPayload) | (Readonly<{
     type: 'stop_result';
     ok: true;