dominds 1.11.2 → 1.12.1

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 {
@@ -63,6 +64,9 @@ function getGlobalDialogMutex(dialogId) {
     globalDialogMutexes.set(key, created);
     return created;
 }
+function compareVisibleReminderTargetOrder(a, b) {
+    return (0, tool_1.compareReminderDisplayOrder)(a.reminder, b.reminder);
+}
 /**
  * Abstract base class for all dialog types.
  * Contains common properties and methods shared between RootDialog and SubDialog.
@@ -146,6 +150,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 +333,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 +361,67 @@ 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,
+            });
+        }
+        // Visible reminders are always merged into a single newest-first stream regardless of
+        // storage scope, so UI rendering, reminder injection, and reminder-id targeting agree.
+        targets.sort(compareVisibleReminderTargetOrder);
+        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 +430,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,12 +486,26 @@ 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,
+        ];
+        visibleReminders.sort(tool_1.compareReminderDisplayOrder);
+        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),
+            scope: r.scope,
         }));
         // Emit full_reminders_update event with complete reminder list including metadata
         const fullRemindersEvt = {

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/gen/mock.d.ts

@@ -49,7 +49,7 @@
  *
  * // Turn 2: Tool error (func_result_msg with role='tool'), LLM self-corrects
  * # docs/e2e-story-test/reminders.md: Tool syntax error recovery
- * - message: "Error: Invalid args. Use: add_reminder({ content: string, position: number }) (position=0 means append)."
+ * - message: "Error: Invalid args. Use: add_reminder({ content: string, position?: number, scope?: \"dialog\" | \"personal\" }) (omit position to append)."
  *   role: "tool"
  *   response: "Call the function tool `add_reminder` with {\"content\":\"Goals...\",\"position\":1}"
  */

package/dist/llm/gen/mock.js

@@ -50,7 +50,7 @@
  *
  * // Turn 2: Tool error (func_result_msg with role='tool'), LLM self-corrects
  * # docs/e2e-story-test/reminders.md: Tool syntax error recovery
- * - message: "Error: Invalid args. Use: add_reminder({ content: string, position: number }) (position=0 means append)."
+ * - message: "Error: Invalid args. Use: add_reminder({ content: string, position?: number, scope?: \"dialog\" | \"personal\" }) (omit position to append)."
  *   role: "tool"
  *   response: "Call the function tool `add_reminder` with {\"content\":\"Goals...\",\"position\":1}"
  */

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,29 +487,25 @@ 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,
+                scope: reminder.scope,
             }),
         });
     }

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;