dominds 1.11.2 → 1.12.0

package/dist/apps-host/ipc-types.d.ts

@@ -98,7 +98,7 @@ export type AppsHostKernelReminderRenderMessage = Readonly<{
     ctx: Readonly<{
         dialogId: string;
         reminder: DomindsAppReminderState;
-        reminderNo: number;
+        reminderId: string;
         workLanguage: LanguageCode;
     }>;
 }>;

package/dist/apps-host/ipc-types.js

@@ -319,15 +319,12 @@ function parseAppsHostMessageFromKernel(v) {
         if (!isRecord(ctx))
             throw new Error('Invalid reminder_render message: ctx must be object');
         const dialogId = asString(ctx['dialogId']);
-        const reminderNoRaw = ctx['reminderNo'];
-        const reminderNo = typeof reminderNoRaw === 'number' && Number.isFinite(reminderNoRaw)
-            ? Math.floor(reminderNoRaw)
-            : null;
+        const reminderId = asString(ctx['reminderId']);
         const workLanguage = asLanguageCode(ctx['workLanguage']);
         if (!dialogId)
             throw new Error('Invalid reminder_render message: ctx.dialogId required');
-        if (reminderNo === null || reminderNo <= 0) {
-            throw new Error('Invalid reminder_render message: ctx.reminderNo must be positive integer');
+        if (!reminderId) {
+            throw new Error('Invalid reminder_render message: ctx.reminderId required');
         }
         if (!workLanguage)
             throw new Error('Invalid reminder_render message: ctx.workLanguage invalid');
@@ -339,7 +336,7 @@ function parseAppsHostMessageFromKernel(v) {
             ctx: {
                 dialogId,
                 reminder: parseReminderState(ctx['reminder'], 'reminder_render.ctx.reminder'),
-                reminderNo,
+                reminderId,
                 workLanguage,
             },
         };

package/dist/dialog-fork.js

@@ -10,6 +10,7 @@ const storage_1 = require("@longrun-ai/kernel/types/storage");
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const dialog_1 = require("./dialog");
 const persistence_1 = require("./persistence");
+const tool_1 = require("./tool");
 const id_1 = require("./utils/id");
 const FORK_BASELINE_ANCHOR = (0, storage_1.toRootGenerationAnchor)({
     rootCourse: 1,
@@ -30,12 +31,16 @@ function anchorAtOrBefore(candidate, cutoff) {
     return compareRootAnchor(candidate, cutoff) <= 0;
 }
 function cloneReminderSnapshot(snapshot) {
-    return {
+    return (0, tool_1.materializeReminder)({
+        id: snapshot.id,
         content: snapshot.content,
         owner: undefined,
         meta: snapshot.meta,
         echoback: snapshot.echoback,
-    };
+        scope: snapshot.scope ?? 'dialog',
+        createdAt: snapshot.createdAt,
+        priority: snapshot.priority,
+    });
 }
 function cloneQuestions(questions) {
     return questions.map((question) => ({
@@ -425,10 +430,12 @@ async function appendForkBaselineState(plan, baselineSubdialogCreatedRecords) {
         type: 'reminders_reconciled_record',
         ...FORK_BASELINE_ANCHOR,
         reminders: plan.reminders.map((reminder) => ({
+            id: reminder.id,
             content: reminder.content,
             ownerName: reminder.owner?.name,
             meta: reminder.meta,
             echoback: reminder.echoback,
+            scope: reminder.scope ?? 'dialog',
             createdAt: reminder.createdAt ?? baselineTs,
             priority: reminder.priority ?? 'medium',
         })),

package/dist/dialog.d.ts

@@ -107,6 +107,16 @@ export interface DialogInitParams {
         contextHealth?: ContextHealthSnapshot;
     };
 }
+export type VisibleReminderTarget = Readonly<{
+    source: 'dialog';
+    index: number;
+    reminder: Reminder;
+}> | Readonly<{
+    source: 'agent_shared';
+    index: number;
+    reminder: Reminder;
+    agentId: string;
+}>;
 /**
  * Assignment from supdialog for subdialogs
  */
@@ -161,6 +171,7 @@ export declare abstract class Dialog {
     getLastContextHealth(): ContextHealthSnapshot | undefined;
     getLastContextHealthGenseq(): number | undefined;
     get remindersVer(): number;
+    touchReminders(): void;
     get supdialog(): Dialog | undefined;
     getUiLanguage(): LanguageCode;
     setUiLanguage(language: LanguageCode): void;
@@ -250,10 +261,14 @@ export declare abstract class Dialog {
      * Post a dialog event using the standard event registry.
      */
     postEvent(event: DialogEvent): void;
-    addReminder(content: string, owner?: ReminderOwner, meta?: JsonValue, position?: number, options?: ReminderOptions): void;
+    addReminder(content: string, owner?: ReminderOwner, meta?: JsonValue, position?: number, options?: ReminderOptions): Reminder;
     deleteReminder(index: number): Reminder;
     updateReminder(index: number, content: string, meta?: JsonValue, options?: ReminderOptions): Reminder;
     clearReminders(): void;
+    listVisibleReminderTargets(): Promise<VisibleReminderTarget[]>;
+    listVisibleReminders(): Promise<Reminder[]>;
+    resolveReminderTargetById(reminderId: string): Promise<VisibleReminderTarget | null>;
+    private processReminderCollection;
     /**
      * Process reminder updates before LLM generation.
      * Calls updateReminder on each tool that owns reminders to allow them to update/drop/keep their reminders.

package/dist/dialog.js

@@ -10,6 +10,7 @@ const async_fifo_mutex_1 = require("./runtime/async-fifo-mutex");
 const driver_messages_1 = require("./runtime/driver-messages");
 const inter_dialog_format_1 = require("./runtime/inter-dialog-format");
 const work_language_1 = require("./runtime/work-language");
+const shared_reminders_1 = require("./shared-reminders");
 const tool_1 = require("./tool");
 const id_2 = require("./utils/id");
 class DialogID {
@@ -146,6 +147,10 @@ class Dialog {
     get remindersVer() {
         return this._remindersVer;
     }
+    touchReminders() {
+        this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+        this._remindersVer++;
+    }
     get supdialog() {
         return undefined;
     }
@@ -325,29 +330,27 @@ class Dialog {
     //
     // Reminder management methods
     addReminder(content, owner, meta, position, options) {
-        const reminder = {
+        const reminder = (0, tool_1.materializeReminder)({
             content,
             owner,
             meta,
             echoback: options?.echoback,
-        };
+            scope: options?.scope ?? 'dialog',
+        });
         const insertIndex = position !== undefined ? position : this.reminders.length;
         if (insertIndex < 0 || insertIndex > this.reminders.length) {
             throw new Error(`Invalid reminder position ${insertIndex}. Valid range: 0-${this.reminders.length}`);
         }
         this.reminders.splice(insertIndex, 0, reminder);
-        this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
-        // Increment version for conditional event emission in driver
-        this._remindersVer++;
+        this.touchReminders();
+        return reminder;
     }
     deleteReminder(index) {
         if (index < 0 || index >= this.reminders.length) {
             throw new Error(`Reminder index ${index} does not exist. Available reminders: 0-${this.reminders.length - 1}`);
         }
         const deleted = this.reminders.splice(index, 1)[0];
-        this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
-        // Increment version for conditional event emission in driver
-        this._remindersVer++;
+        this.touchReminders();
         return deleted;
     }
     updateReminder(index, content, meta, options) {
@@ -355,34 +358,64 @@ class Dialog {
             throw new Error(`Reminder index ${index} does not exist. Available reminders: 0-${this.reminders.length - 1}`);
         }
         const oldReminder = this.reminders[index];
-        const updatedReminder = {
+        const updatedReminder = (0, tool_1.materializeReminder)({
+            id: oldReminder.id,
             content,
             owner: oldReminder.owner,
             meta: meta !== undefined ? meta : oldReminder.meta,
             echoback: options?.echoback ?? oldReminder.echoback,
-        };
+            scope: oldReminder.scope,
+            createdAt: oldReminder.createdAt,
+            priority: oldReminder.priority,
+        });
         this.reminders[index] = updatedReminder;
-        this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
-        // Increment version for conditional event emission in driver
-        this._remindersVer++;
+        this.touchReminders();
         return oldReminder;
     }
     clearReminders() {
         this.reminders.length = 0;
-        this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
-        // Increment version for conditional event emission in driver
-        this._remindersVer++;
+        this.touchReminders();
     }
-    /**
-     * Process reminder updates before LLM generation.
-     * Calls updateReminder on each tool that owns reminders to allow them to update/drop/keep their reminders.
-     * Returns reminder contents with metadata for the frontend.
-     */
-    async processReminderUpdates() {
+    async listVisibleReminderTargets() {
+        const targets = this.reminders.map((reminder, index) => ({
+            source: 'dialog',
+            index,
+            reminder,
+        }));
+        const sharedReminders = await (0, shared_reminders_1.loadAgentSharedReminders)(this.agentId);
+        for (let index = 0; index < sharedReminders.length; index += 1) {
+            const reminder = sharedReminders[index];
+            if (!reminder)
+                continue;
+            targets.push({
+                source: 'agent_shared',
+                index,
+                reminder,
+                agentId: this.agentId,
+            });
+        }
+        return targets;
+    }
+    async listVisibleReminders() {
+        return (await this.listVisibleReminderTargets()).map((target) => target.reminder);
+    }
+    async resolveReminderTargetById(reminderId) {
+        const trimmed = reminderId.trim();
+        if (trimmed === '')
+            return null;
+        const visibleTargets = await this.listVisibleReminderTargets();
+        for (const target of visibleTargets) {
+            if (target.reminder.id === trimmed) {
+                return target;
+            }
+        }
+        return null;
+    }
+    async processReminderCollection(reminders) {
+        let changed = false;
         const indicesToRemove = [];
-        for (let i = 0; i < this.reminders.length; i++) {
-            const reminder = this.reminders[i];
-            // Skip if the reminder has no owner or the owner doesn't have an updateReminder method
+        for (let i = 0; i < reminders.length; i++) {
+            const reminder = reminders[i];
             if (!reminder.owner || !reminder.owner.updateReminder) {
                 continue;
             }
@@ -391,34 +424,53 @@ class Dialog {
                 switch (result.treatment) {
                     case 'drop':
                         indicesToRemove.push(i);
+                        changed = true;
                         break;
-                    case 'update':
-                        if (result.updatedContent !== undefined) {
-                            const updatedReminder = {
-                                content: result.updatedContent,
-                                owner: reminder.owner,
-                                meta: result.updatedMeta !== undefined ? result.updatedMeta : reminder.meta,
-                                echoback: reminder.echoback,
-                            };
-                            this.reminders[i] = updatedReminder;
+                    case 'update': {
+                        const nextContent = result.updatedContent ?? reminder.content;
+                        const nextMeta = result.updatedMeta !== undefined ? result.updatedMeta : reminder.meta;
+                        const updatedReminder = (0, tool_1.materializeReminder)({
+                            id: reminder.id,
+                            content: nextContent,
+                            owner: reminder.owner,
+                            meta: nextMeta,
+                            echoback: reminder.echoback,
+                            scope: reminder.scope,
+                            createdAt: reminder.createdAt,
+                            priority: reminder.priority,
+                        });
+                        const contentChanged = updatedReminder.content !== reminder.content;
+                        const metaChanged = updatedReminder.meta !== reminder.meta;
+                        if (contentChanged || metaChanged) {
+                            reminders[i] = updatedReminder;
+                            changed = true;
                         }
                         break;
+                    }
                     case 'keep':
-                        // No action needed
                         break;
                 }
             }
             catch (error) {
                 log_1.log.error(`Error updating reminder from tool ${reminder.owner}:`, error);
-                // Continue processing other reminders even if one fails
             }
         }
-        // Remove reminders marked for deletion (in reverse order to maintain indices)
         for (let i = indicesToRemove.length - 1; i >= 0; i--) {
-            this.reminders.splice(indicesToRemove[i], 1);
+            reminders.splice(indicesToRemove[i], 1);
         }
-        if (indicesToRemove.length > 0) {
-            this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+        return changed;
+    }
+    /**
+     * Process reminder updates before LLM generation.
+     * Calls updateReminder on each tool that owns reminders to allow them to update/drop/keep their reminders.
+     * Returns reminder contents with metadata for the frontend.
+     */
+    async processReminderUpdates() {
+        const sharedReminders = await (0, shared_reminders_1.loadAgentSharedReminders)(this.agentId);
+        const localChanged = await this.processReminderCollection(this.reminders);
+        const sharedChanged = await this.processReminderCollection(sharedReminders);
+        if (localChanged || sharedChanged) {
+            this.touchReminders();
         }
         // Centralized persistence - called when emitting event.
         // Must be awaited to preserve ordering (avoid out-of-date writes winning).
@@ -428,11 +480,23 @@ class Dialog {
         catch (err) {
             log_1.log.warn('Failed to persist reminders', err, { dialogId: this.id.valueOf() });
         }
-        const reminderNoByIndex = (0, tool_1.computeReminderNoByIndex)(this.reminders);
-        const reminders = this.reminders.map((r, index) => ({
+        try {
+            await (0, shared_reminders_1.replaceAgentSharedReminders)(this.agentId, sharedReminders);
+        }
+        catch (err) {
+            log_1.log.warn('Failed to persist agent-shared reminders', err, {
+                dialogId: this.id.valueOf(),
+                agentId: this.agentId,
+            });
+        }
+        const visibleReminders = [
+            ...this.reminders.map((reminder) => (0, tool_1.cloneReminder)(reminder)),
+            ...sharedReminders,
+        ];
+        const reminders = visibleReminders.map((r) => ({
             content: r.content,
             meta: r.meta,
-            reminder_no: reminderNoByIndex.get(index),
+            reminder_id: r.id,
             echoback: (0, tool_1.reminderEchoBackEnabled)(r),
         }));
         // Emit full_reminders_update event with complete reminder list including metadata

package/dist/llm/defaults.yaml

@@ -1,8 +1,8 @@
 # Optional provider-level retry controls for kernel dialog driving:
-# - llm_retry_max_retries: extra retries after the initial attempt (default 5).
+# - llm_retry_max_retries: extra retries after the initial attempt (default 99; ~41.2h total retry window with current backoff defaults).
 # - llm_retry_initial_delay_ms: delay before the 1st retry (default 1000).
-# - llm_retry_backoff_multiplier: exponential factor between retries (default 2; e.g. 1.5).
-# - llm_retry_max_delay_ms: upper bound for retry delay (default 30000).
+# - llm_retry_backoff_multiplier: exponential factor between retries (default 1.5).
+# - llm_retry_max_delay_ms: upper bound for retry delay (default 1800000 / 30m).
 # - tool_result_max_chars: optional transport-level cap for a single tool-result text payload
 #   before Dominds projects it into the provider request. Use this when a provider/gateway enforces
 #   a stricter per-item string limit than Dominds' built-in defaults.

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

@@ -28,10 +28,10 @@ const reply_guidance_1 = require("./reply-guidance");
 const runtime_1 = require("./runtime");
 const tellask_special_1 = require("./tellask-special");
 const KERNEL_DRIVER_DEFAULT_RETRY_POLICY = {
-    maxRetries: 5,
+    maxRetries: 99, // long total retry window to survive major down-time by llm providers
     initialDelayMs: 1000,
-    backoffMultiplier: 2,
-    maxDelayMs: 30000,
+    backoffMultiplier: 1.5,
+    maxDelayMs: 30 * 60 * 1000, // 30 minutes
 };
 const KERNEL_DRIVER_EMPTY_LLM_RESPONSE_ERROR_CODE = 'DOMINDS_LLM_EMPTY_RESPONSE';
 class KernelDriverInterruptedError extends Error {
@@ -487,28 +487,23 @@ function resolveUpNextPrompt(dlg) {
     };
 }
 async function renderRemindersForContext(dlg) {
-    if (dlg.reminders.length === 0)
+    const reminders = await dlg.listVisibleReminders();
+    if (reminders.length === 0)
         return [];
     const language = (0, work_language_1.getWorkLanguage)();
-    const reminderNoByIndex = (0, tool_1.computeReminderNoByIndex)(dlg.reminders);
     const rendered = [];
-    for (let index = 0; index < dlg.reminders.length; index += 1) {
-        const reminder = dlg.reminders[index];
+    for (const reminder of reminders) {
         if (!reminder || !(0, tool_1.reminderEchoBackEnabled)(reminder)) {
             continue;
         }
-        const reminderNo = reminderNoByIndex.get(index);
-        if (reminderNo === undefined) {
-            continue;
-        }
         if (reminder.owner) {
-            rendered.push(await reminder.owner.renderReminder(dlg, reminder, reminderNo - 1));
+            rendered.push(await reminder.owner.renderReminder(dlg, reminder));
             continue;
         }
         rendered.push({
             type: 'transient_guide_msg',
             role: 'assistant',
-            content: (0, driver_messages_1.formatReminderItemGuide)(language, reminderNo, reminder.content, {
+            content: (0, driver_messages_1.formatReminderItemGuide)(language, reminder.id, reminder.content, {
                 meta: reminder.meta,
             }),
         });

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

@@ -354,10 +354,18 @@ async function sleepWithAbort(ms, abortSignal) {
     if (abortSignal?.aborted) {
         throw new Error('AbortError');
     }
-    await new Promise((resolve) => setTimeout(resolve, ms));
-    if (abortSignal?.aborted) {
-        throw new Error('AbortError');
-    }
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            abortSignal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            abortSignal?.removeEventListener('abort', onAbort);
+            reject(new Error('AbortError'));
+        };
+        abortSignal?.addEventListener('abort', onAbort, { once: true });
+    });
 }
 function normalizeRetryInitialDelayMs(value) {
     if (!Number.isFinite(value))

package/dist/minds/system-prompt-parts.js

@@ -167,7 +167,7 @@ function getMemoryPromptCopy(ctx) {
             progressLine: '- 更新 `progress` 时：它必须始终是可供全队扫读的完整当前快照，而不是只追加自己这一轮的零散笔记。',
             injectedTaskdocLine: '- 重要：差遣牒内容会被系统以内联形式注入到上下文中（本轮生成视角下即为最新；注入内容不包括全局约束）。需要回顾时请直接基于上下文里的差遣牒内容回顾与决策，不要试图用通用文件工具读取 `*.tsk/` 下的文件（会被拒绝）。',
             constraintsLine: '- 约定：`constraints` 只写任务特有的硬要求，不得写入系统提示/工具文档里已明确且由系统强制执行的通用规则（例如 `*.tsk/` 封装禁止通用文件工具）。一经发现重复，必须删除并告知用户。',
-            remindersLine: '- 提醒项（即编号提醒，工作集）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。准备 `clear_mind` 开启新一程对话时，默认整理成“结构化接续包提醒项”；其中只保留差遣牒未覆盖、但恢复工作容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。若系统已把当前程切到吃紧/告急处置态，则允许先保留多条粗略提醒项把信息带过桥；当前程只做保信息 + clear_mind；只有系统实际开启新一程后，第一步才是以清醒头脑复核并整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。',
+            remindersLine: '- 提醒项（以 `reminder_id` 标识，工作集）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。准备 `clear_mind` 开启新一程对话时，默认整理成“结构化接续包提醒项”；其中只保留差遣牒未覆盖、但恢复工作容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。若系统已把当前程切到吃紧/告急处置态，则允许先保留多条粗略提醒项把信息带过桥；当前程只做保信息 + clear_mind；只有系统实际开启新一程后，第一步才是以清醒头脑复核并整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。',
             teamMemoryLine: '- 团队记忆：稳定的团队约定/工程规约（跨任务共享）。',
             personalMemoryLine: '- 个人记忆：稳定的个人习惯/偏好与职责域知识；记忆会在每次生成时自动注入上下文，应保持少量且准确（关键文档/代码的精确路径 + 最小必要事实）。不要记录具体任务状态。',
             subdialogDutyLine: `你当前处于支线对话：此处不允许 \`change_mind\`。当你判断需要更新差遣牒（尤其是 progress 公告牌）时，请在合适时机直接诉请差遣牒维护人 \`@${ctx.taskdocMaintainerId}\` 执行更新，并给出你已合并好的“新全文/替换稿”（用于替换对应章节全文）。不要声称已更新，除非看到回执。`,
@@ -191,7 +191,7 @@ function getMemoryPromptCopy(ctx) {
         progressLine: '- When updating `progress`, keep it as a complete, team-scannable current snapshot instead of appending only your own latest notes.',
         injectedTaskdocLine: '- Important: the Taskdoc content is injected inline into the context (the latest as of this generation; injected content excludes global constraints). Review the injected Taskdoc instead of trying to read files under `*.tsk/` via general file tools (they will be rejected).',
         constraintsLine: '- Convention: Taskdoc `constraints` must contain task-specific requirements only; do not include global, system-enforced rules already stated in system prompt/tool docs (e.g. `.tsk/` encapsulation bans general file tools). If duplication is found, you MUST remove it and notify the user.',
-        remindersLine: '- Reminders (i.e. numbered reminders, working set): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. When preparing `clear_mind` to start a new course, default to a structured continuation-package reminder that keeps only details not already covered by Taskdoc but easy to lose during resume (first step, key pointers, run/verify info, volatile ids/paths). If the system has already put the current course into caution/critical remediation, rough multi-reminder bridge notes are acceptable; in the current course, only preserve volatile information and clear_mind. Only after the system actually starts the new course does the mandatory first step become reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.',
+        remindersLine: '- Reminders (addressed by `reminder_id`, working set): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. When preparing `clear_mind` to start a new course, default to a structured continuation-package reminder that keeps only details not already covered by Taskdoc but easy to lose during resume (first step, key pointers, run/verify info, volatile ids/paths). If the system has already put the current course into caution/critical remediation, rough multi-reminder bridge notes are acceptable; in the current course, only preserve volatile information and clear_mind. Only after the system actually starts the new course does the mandatory first step become reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.',
         teamMemoryLine: '- Team memory: stable shared conventions (cross-task).',
         personalMemoryLine: '- Personal memory: stable personal habits/preferences and responsibility-scope knowledge. Memory is automatically injected into context on each generation: keep it small and accurate (exact key doc/code paths + minimal key facts); do not store per-task state.',
         subdialogDutyLine: `You are currently in a subdialog: \`change_mind\` is not allowed here. When Taskdoc should be updated (especially the shared progress bulletin board), tellask the Taskdoc maintainer \`@${ctx.taskdocMaintainerId}\` with a fully merged replacement draft (full-section replacement). Do not claim it is updated until you see a receipt.`,

package/dist/persistence.js

@@ -52,6 +52,7 @@ const log_1 = require("./log");
 const async_fifo_mutex_1 = require("./runtime/async-fifo-mutex");
 const reply_prompt_copy_1 = require("./runtime/reply-prompt-copy");
 const work_language_1 = require("./runtime/work-language");
+const tool_1 = require("./tool");
 const registry_1 = require("./tools/registry");
 function getErrorCode(error) {
     if (typeof error !== 'object' || error === null)
@@ -63,22 +64,25 @@ function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
 function serializeReminderSnapshot(reminder) {
-    const persistedReminder = reminder;
     return {
+        id: reminder.id,
         content: reminder.content,
         ownerName: reminder.owner?.name,
         meta: reminder.meta,
         echoback: reminder.echoback,
-        createdAt: persistedReminder.createdAt ?? (0, time_1.formatUnifiedTimestamp)(new Date()),
-        priority: persistedReminder.priority ?? 'medium',
+        scope: reminder.scope ?? 'dialog',
+        createdAt: reminder.createdAt ?? (0, time_1.formatUnifiedTimestamp)(new Date()),
+        priority: reminder.priority ?? 'medium',
     };
 }
 function cloneReminderSnapshot(snapshot) {
     return {
+        id: snapshot.id,
         content: snapshot.content,
         ownerName: snapshot.ownerName,
         meta: snapshot.meta,
         echoback: snapshot.echoback,
+        scope: snapshot.scope,
         createdAt: snapshot.createdAt,
         priority: snapshot.priority,
     };
@@ -3471,14 +3475,15 @@ class DialogPersistence {
             await fs.promises.mkdir(dialogPath, { recursive: true });
             const remindersFilePath = path.join(dialogPath, 'reminders.json');
             const reminderState = {
-                reminders: reminders.map((r, index) => ({
-                    id: `reminder-${index}`,
+                reminders: reminders.map((r) => ({
+                    id: r.id,
                     content: r.content,
                     ownerName: r.owner ? r.owner.name : undefined,
                     meta: r.meta,
                     echoback: r.echoback,
-                    createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                    priority: 'medium',
+                    scope: r.scope ?? 'dialog',
+                    createdAt: r.createdAt ?? (0, time_1.formatUnifiedTimestamp)(new Date()),
+                    priority: r.priority ?? 'medium',
                 })),
                 updatedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
             };
@@ -3505,16 +3510,18 @@ class DialogPersistence {
                 const reminderState = JSON.parse(content);
                 return reminderState.reminders.map((r) => {
                     const ownerNameFromFile = typeof r.ownerName === 'string' ? r.ownerName : undefined;
+                    // Reminder metadata is owner-private. Rebind strictly through persisted ownerName.
                     const owner = ownerNameFromFile ? (0, registry_1.getReminderOwner)(ownerNameFromFile) : undefined;
-                    return {
+                    return (0, tool_1.materializeReminder)({
                         id: r.id,
                         content: r.content,
                         owner,
                         meta: r.meta,
                         echoback: r.echoback,
+                        scope: r.scope ?? 'dialog',
                         createdAt: r.createdAt,
                         priority: r.priority,
-                    };
+                    });
                 });
             }
             catch (error) {

package/dist/priming.d.ts

@@ -3,7 +3,7 @@ import type { PersistedDialogRecord } from '@longrun-ai/kernel/types/storage';
 import type { DialogPrimingInput, DialogStatusKind } from '@longrun-ai/kernel/types/wire';
 import type { Dialog } from './dialog';
 import { DialogID } from './dialog';
-import type { Reminder } from './tool';
+import { type Reminder } from './tool';
 type StripTs<T> = T extends {
     ts: string;
 } ? Omit<T, 'ts'> : never;

package/dist/priming.js

@@ -22,6 +22,7 @@ const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
 const frontmatter_1 = require("./markdown/frontmatter");
 const persistence_1 = require("./persistence");
+const tool_1 = require("./tool");
 const registry_1 = require("./tools/registry");
 const PRIMING_ROOT_DIR = path_1.default.resolve(process.cwd(), '.minds', 'priming');
 const PRIMING_INDIVIDUAL_DIR = path_1.default.resolve(PRIMING_ROOT_DIR, 'individual');
@@ -158,6 +159,10 @@ function parseReminderSnapshots(frontmatter) {
         if (content.trim() === '') {
             throw new Error(`${context}.content must be a non-empty string`);
         }
+        const id = item['id'];
+        if (id !== undefined && typeof id !== 'string') {
+            throw new Error(`${context}.id must be a string when provided`);
+        }
         const ownerName = item['ownerName'];
         if (ownerName !== undefined && (typeof ownerName !== 'string' || ownerName.trim() === '')) {
             throw new Error(`${context}.ownerName must be a non-empty string when provided`);
@@ -170,16 +175,22 @@ function parseReminderSnapshots(frontmatter) {
         if (echoback !== undefined && typeof echoback !== 'boolean') {
             throw new Error(`${context}.echoback must be a boolean when provided`);
         }
+        const scope = item['scope'];
+        if (scope !== undefined && scope !== 'dialog' && scope !== 'agent_shared') {
+            throw new Error(`${context}.scope must be "dialog" or "agent_shared" when provided`);
+        }
         const createdAt = item['createdAt'];
         if (createdAt !== undefined && typeof createdAt !== 'string') {
             throw new Error(`${context}.createdAt must be a string when provided`);
         }
         const priority = parseReminderPriority(item['priority'], context);
         reminders.push({
+            id: typeof id === 'string' ? id : undefined,
             content,
             ownerName: typeof ownerName === 'string' ? ownerName.trim() : undefined,
             meta,
             echoback,
+            scope: scope === 'dialog' || scope === 'agent_shared' ? scope : undefined,
             createdAt: typeof createdAt === 'string' ? createdAt : undefined,
             priority,
         });
@@ -187,14 +198,15 @@ function parseReminderSnapshots(frontmatter) {
     return reminders;
 }
 function reminderToSnapshot(reminder) {
-    const persistedReminder = reminder;
     return {
+        id: reminder.id,
         content: reminder.content,
         ownerName: reminder.owner?.name,
         meta: reminder.meta,
         echoback: reminder.echoback,
-        createdAt: persistedReminder.createdAt,
-        priority: persistedReminder.priority,
+        scope: reminder.scope,
+        createdAt: reminder.createdAt,
+        priority: reminder.priority,
     };
 }
 function materializeReminderSnapshot(snapshot, context) {
@@ -207,17 +219,16 @@ function materializeReminderSnapshot(snapshot, context) {
             }
             return resolved;
         })();
-    const reminder = {
+    return (0, tool_1.materializeReminder)({
+        id: snapshot.id,
         content: snapshot.content,
         owner,
         meta: snapshot.meta,
         echoback: snapshot.echoback,
-    };
-    if (snapshot.createdAt !== undefined)
-        reminder.createdAt = snapshot.createdAt;
-    if (snapshot.priority !== undefined)
-        reminder.priority = snapshot.priority;
-    return reminder;
+        scope: snapshot.scope,
+        createdAt: snapshot.createdAt,
+        priority: snapshot.priority,
+    });
 }
 function isPrimingRecordType(raw) {
     return (raw === 'agent_thought_record' ||

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

@@ -9,7 +9,7 @@ export declare function formatNewCourseStartPrompt(language: LanguageCode, args:
     source: 'clear_mind' | 'critical_auto_clear';
 }): string;
 export declare function formatDiligenceAutoContinuePrompt(language: LanguageCode, diligenceText: string): string;
-export declare function formatReminderItemGuide(language: LanguageCode, index: number, content: string, options?: {
+export declare function formatReminderItemGuide(language: LanguageCode, reminderId: string, content: string, options?: {
     meta?: unknown;
 }): string;
 export declare function formatQ4HDiligencePushBudgetExhausted(language: LanguageCode, args: {