dominds 1.25.0 → 1.25.2

package/dist/priming.js

@@ -20,15 +20,25 @@ const time_1 = require("@longrun-ai/kernel/utils/time");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
+const zlib_1 = require("zlib");
 const frontmatter_1 = require("./markdown/frontmatter");
 const persistence_1 = require("./persistence");
+const shared_reminders_1 = require("./shared-reminders");
 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');
-const PRIMING_TEAM_SHARED_DIR = path_1.default.resolve(PRIMING_ROOT_DIR, 'team_shared');
-const RECENT_PRIMING_DIR = path_1.default.resolve(process.cwd(), '.dialogs', 'recent-priming');
 const RECENT_PRIMING_MAX = 20;
+function getPrimingRootDir() {
+    return path_1.default.resolve(process.cwd(), '.minds', 'priming');
+}
+function getPrimingIndividualDir() {
+    return path_1.default.resolve(getPrimingRootDir(), 'individual');
+}
+function getPrimingTeamSharedDir() {
+    return path_1.default.resolve(getPrimingRootDir(), 'team_shared');
+}
+function getRecentPrimingDir() {
+    return path_1.default.resolve(process.cwd(), '.dialogs', 'recent-priming');
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -104,8 +114,9 @@ function normalizeScriptRef(raw) {
     return null;
 }
 function scriptRefToAbsolutePath(scriptRef) {
-    const absPath = path_1.default.resolve(PRIMING_ROOT_DIR, `${scriptRef}.md`);
-    if (!ensureInside(PRIMING_ROOT_DIR, absPath)) {
+    const primingRootDir = getPrimingRootDir();
+    const absPath = path_1.default.resolve(primingRootDir, `${scriptRef}.md`);
+    if (!ensureInside(primingRootDir, absPath)) {
         throw new Error(`Priming script path escapes priming root: ${scriptRef}`);
     }
     return absPath;
@@ -178,9 +189,10 @@ function parseReminderSnapshots(frontmatter) {
         const scope = item['scope'];
         if (scope !== undefined &&
             scope !== 'dialog' &&
-            scope !== 'personal' &&
-            scope !== 'agent_shared') {
-            throw new Error(`${context}.scope must be "dialog", "personal", or "agent_shared" when provided`);
+            scope !== 'task' &&
+            scope !== 'agent' &&
+            scope !== 'runtime') {
+            throw new Error(`${context}.scope must be "dialog", "task", "agent", or "runtime" when provided`);
         }
         const createdAt = item['createdAt'];
         if (createdAt !== undefined && typeof createdAt !== 'string') {
@@ -197,7 +209,9 @@ function parseReminderSnapshots(frontmatter) {
             ownerName: typeof ownerName === 'string' ? ownerName.trim() : undefined,
             meta,
             echoback,
-            scope: scope === 'dialog' || scope === 'personal' || scope === 'agent_shared' ? scope : undefined,
+            scope: scope === 'dialog' || scope === 'task' || scope === 'agent' || scope === 'runtime'
+                ? scope
+                : undefined,
             renderMode: renderMode === 'plain' || renderMode === 'markdown' ? renderMode : undefined,
             createdAt: typeof createdAt === 'string' ? createdAt : undefined,
             priority,
@@ -218,7 +232,11 @@ function reminderToSnapshot(reminder) {
         priority: reminder.priority,
     };
 }
-function materializeReminderSnapshot(snapshot, context) {
+function generatePrimingReminderId(scriptRef, index) {
+    const checksum = (0, zlib_1.crc32)(`${scriptRef}\n${String(index)}`) >>> 0;
+    return `priming-${checksum.toString(16).padStart(8, '0')}`;
+}
+function materializeReminderSnapshot(snapshot, context, defaultScope, fallbackId) {
     const owner = snapshot.ownerName === undefined
         ? undefined
         : (() => {
@@ -229,12 +247,12 @@ function materializeReminderSnapshot(snapshot, context) {
             return resolved;
         })();
     return (0, tool_1.materializeReminder)({
-        id: snapshot.id,
+        id: snapshot.id ?? fallbackId,
         content: snapshot.content,
         owner,
         meta: snapshot.meta,
         echoback: snapshot.echoback,
-        scope: snapshot.scope,
+        scope: snapshot.scope ?? defaultScope,
         renderMode: snapshot.renderMode ?? 'markdown',
         createdAt: snapshot.createdAt,
         priority: snapshot.priority,
@@ -1537,9 +1555,6 @@ function parseRecordsFromBody(body) {
         }
         records.push(normalizedRecord);
     }
-    if (records.length === 0) {
-        throw new Error("Priming script must contain at least one '### record <type>' block");
-    }
     return records;
 }
 function parsePrimingScript(raw) {
@@ -1580,7 +1595,7 @@ async function listMarkdownFilesRecursively(dirPath) {
     return files;
 }
 async function validateAllPrimingScriptsInRtws() {
-    const absFiles = await listMarkdownFilesRecursively(PRIMING_ROOT_DIR);
+    const absFiles = await listMarkdownFilesRecursively(getPrimingRootDir());
     const sorted = [...absFiles].sort((a, b) => a.localeCompare(b));
     const issues = [];
     for (const absPath of sorted) {
@@ -1609,7 +1624,7 @@ async function validateAllPrimingScriptsInRtws() {
     };
 }
 function parseSummaryFromAbsolutePath(absPath) {
-    const rel = path_1.default.relative(PRIMING_ROOT_DIR, absPath).replace(/\\/g, '/');
+    const rel = path_1.default.relative(getPrimingRootDir(), absPath).replace(/\\/g, '/');
     const relNoExt = rel.toLowerCase().endsWith('.md') ? rel.slice(0, -'.md'.length) : rel;
     const parts = relNoExt.split('/');
     if (parts[0] === 'individual') {
@@ -1677,8 +1692,9 @@ function normalizeRecentUsageAgentId(agentIdRaw) {
 }
 function resolveRecentUsageFilePath(agentIdRaw) {
     const agentId = normalizeRecentUsageAgentId(agentIdRaw);
-    const absPath = path_1.default.resolve(RECENT_PRIMING_DIR, `${agentId}.json`);
-    if (!ensureInside(RECENT_PRIMING_DIR, absPath)) {
+    const recentPrimingDir = getRecentPrimingDir();
+    const absPath = path_1.default.resolve(recentPrimingDir, `${agentId}.json`);
+    if (!ensureInside(recentPrimingDir, absPath)) {
         throw new Error(`Recent-priming path escapes expected directory: ${absPath}`);
     }
     return absPath;
@@ -1725,7 +1741,7 @@ async function loadRecentUsage(agentIdRaw) {
 }
 async function saveRecentUsage(agentIdRaw, file) {
     const filePath = resolveRecentUsageFilePath(agentIdRaw);
-    await promises_1.default.mkdir(RECENT_PRIMING_DIR, { recursive: true });
+    await promises_1.default.mkdir(getRecentPrimingDir(), { recursive: true });
     await promises_1.default.writeFile(filePath, JSON.stringify(file, null, 2), 'utf-8');
 }
 async function recordRecentPrimingUsage(agentIdRaw, scriptRefs) {
@@ -1828,9 +1844,9 @@ async function searchApplicablePrimingScripts(args) {
     const limit = typeof args.limit === 'number' && Number.isFinite(args.limit) && args.limit > 0
         ? Math.floor(args.limit)
         : 50;
-    const individualDir = path_1.default.resolve(PRIMING_INDIVIDUAL_DIR, agentId);
+    const individualDir = path_1.default.resolve(getPrimingIndividualDir(), agentId);
     const individualFiles = await listMarkdownFilesRecursively(individualDir);
-    const teamSharedFiles = await listMarkdownFilesRecursively(PRIMING_TEAM_SHARED_DIR);
+    const teamSharedFiles = await listMarkdownFilesRecursively(getPrimingTeamSharedDir());
     const matched = [];
     const warnings = [];
     for (const absPath of [...individualFiles, ...teamSharedFiles]) {
@@ -1870,7 +1886,7 @@ async function loadPrimingScriptByRef(scriptRefRaw, agentIdRaw) {
         throw new Error(`Invalid priming script ref: ${scriptRefRaw}`);
     }
     const absPath = scriptRefToAbsolutePath(scriptRef);
-    if (!ensureInside(PRIMING_ROOT_DIR, absPath)) {
+    if (!ensureInside(getPrimingRootDir(), absPath)) {
         throw new Error(`Priming script path escapes priming root: ${scriptRef}`);
     }
     const loaded = await loadScriptFromAbsolutePath(absPath);
@@ -1879,7 +1895,7 @@ async function loadPrimingScriptByRef(scriptRefRaw, agentIdRaw) {
     }
     return {
         summary: loaded.summary,
-        reminders: (loaded.parsed.reminders ?? []).map((item, index) => materializeReminderSnapshot(item, `priming script '${scriptRef}' frontmatter.reminders[${String(index)}]`)),
+        reminders: (loaded.parsed.reminders ?? []).map((item, index) => materializeReminderSnapshot(item, `priming script '${scriptRef}' frontmatter.reminders[${String(index)}]`, 'task', generatePrimingReminderId(scriptRef, index))),
         records: loaded.parsed.records,
     };
 }
@@ -2152,11 +2168,79 @@ function primingRecordToChatMessage(record) {
         }
     }
 }
+function assertUniquePrimingReminderIds(reminders) {
+    const seen = new Set();
+    for (const reminder of reminders) {
+        if (seen.has(reminder.id)) {
+            throw new Error(`Duplicate reminder id in priming scripts: ${reminder.id}`);
+        }
+        seen.add(reminder.id);
+    }
+}
+async function upsertPrimingSharedReminders(target, incoming) {
+    if (incoming.length === 0)
+        return;
+    await (0, shared_reminders_1.mutateSharedReminders)(target, (reminders) => {
+        const byId = new Map();
+        reminders.forEach((reminder, index) => byId.set(reminder.id, index));
+        for (const reminder of incoming) {
+            const existingIndex = byId.get(reminder.id);
+            if (existingIndex === undefined) {
+                byId.set(reminder.id, reminders.length);
+                reminders.push(reminder);
+            }
+            else {
+                reminders[existingIndex] = reminder;
+            }
+        }
+    });
+}
+async function applyPrimingRemindersToDialog(args) {
+    if (args.reminders.length === 0)
+        return;
+    assertUniquePrimingReminderIds(args.reminders);
+    const dialogReminders = [];
+    const taskReminders = [];
+    const agentReminders = [];
+    for (const reminder of args.reminders) {
+        const scope = reminder.scope ?? 'task';
+        switch (scope) {
+            case 'dialog':
+                dialogReminders.push(reminder);
+                break;
+            case 'task':
+                taskReminders.push(reminder);
+                break;
+            case 'agent':
+            case 'runtime':
+                agentReminders.push(reminder);
+                break;
+        }
+    }
+    if (dialogReminders.length > 0) {
+        args.dialog.reminders.splice(0, args.dialog.reminders.length, ...dialogReminders);
+        await persistence_1.DialogPersistence._saveReminderState(args.dialog.id, [...args.dialog.reminders], args.status);
+        await persistence_1.DialogPersistence.appendRemindersReconciledRecord(args.dialog.id, args.dialog.reminders, {
+            kind: 'root_anchor',
+            rootAnchor: (0, storage_1.toRootGenerationAnchor)({ rootCourse: 1, rootGenseq: 0 }),
+        }, args.status);
+    }
+    await upsertPrimingSharedReminders({ kind: 'task', agentId: args.agentId, taskDocPath: args.dialog.taskDocPath }, taskReminders);
+    await upsertPrimingSharedReminders({ kind: 'agent', agentId: args.agentId }, agentReminders);
+    args.dialog.touchReminders();
+}
 async function applyPrimingScriptsToDialog(args) {
     const agentId = args.agentId.trim();
     if (agentId === '') {
         throw new Error('agentId is required');
     }
+    const dialogAgentId = args.dialog.agentId.trim();
+    if (dialogAgentId === '') {
+        throw new Error(`Dialog agentId missing for ${args.dialog.id.valueOf()}`);
+    }
+    if (dialogAgentId !== agentId) {
+        throw new Error(`applyPrimingScriptsToDialog agentId mismatch: dialog=${dialogAgentId} request=${agentId}`);
+    }
     const normalizedRefs = [];
     const seen = new Set();
     for (const raw of args.priming.scriptRefs) {
@@ -2182,16 +2266,13 @@ async function applyPrimingScriptsToDialog(args) {
         allReminders.push(...loaded.reminders);
         allRecords.push(...remapped.records);
     }
-    if (allRecords.length === 0) {
-        return { appliedScriptRefs: normalizedRefs, appendedMessageCount: 0 };
-    }
     if (allReminders.length > 0) {
-        args.dialog.reminders.splice(0, args.dialog.reminders.length, ...allReminders);
-        await persistence_1.DialogPersistence._saveReminderState(args.dialog.id, [...args.dialog.reminders], args.status);
-        await persistence_1.DialogPersistence.appendRemindersReconciledRecord(args.dialog.id, args.dialog.reminders, {
-            kind: 'root_anchor',
-            rootAnchor: (0, storage_1.toRootGenerationAnchor)({ rootCourse: 1, rootGenseq: 0 }),
-        }, args.status);
+        await applyPrimingRemindersToDialog({
+            dialog: args.dialog,
+            agentId,
+            status: args.status,
+            reminders: allReminders,
+        });
     }
     for (const record of allRecords) {
         const withSourceTag = addPrimingSourceTag(record);
@@ -2584,7 +2665,7 @@ async function saveDialogCourseAsIndividualPrimingScript(args) {
     const scriptRef = `individual/${ownerAgentId}/${normalizedSlug}`;
     const absPath = scriptRefToAbsolutePath(scriptRef);
     const parentDir = path_1.default.dirname(absPath);
-    if (!ensureInside(PRIMING_INDIVIDUAL_DIR, parentDir)) {
+    if (!ensureInside(getPrimingIndividualDir(), parentDir)) {
         throw new Error(`Priming script directory escapes individual scope: ${parentDir}`);
     }
     const now = (0, time_1.formatUnifiedTimestamp)(new Date());

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

@@ -16,7 +16,7 @@ export type ReminderContextFollowingDialogState = 'user_message' | 'runtime_noti
 export declare function formatReminderContextFooter(language: LanguageCode, followingState: ReminderContextFollowingDialogState): string;
 export declare function formatReminderItemGuide(language: LanguageCode, reminderId: string, content: string, options?: {
     meta?: unknown;
-    scope?: 'dialog' | 'personal' | 'agent_shared';
+    scope?: 'dialog' | 'task' | 'agent' | 'runtime';
 }): string;
 export declare function formatQ4HDiligencePushBudgetExhausted(language: LanguageCode, args: {
     maxInjectCount: number;

package/dist/runtime/driver-messages.js

@@ -127,7 +127,7 @@ function formatNewCourseStartPrompt(language, args) {
             : `系统因上下文已告急（critical）而自动开启了第 ${args.nextCourse} 程对话。`;
         return (`${noticePrefix} ${prefix} ` +
             '这是一条运行时换程指令，不是新的用户诉求；不要把这条提示当成新的待办，也不要只回复“收到/好的/我会先整理提醒项”。' +
-            '现在已经进入新一程：第一步先复核并在必要时整理接续包提醒项，以清醒头脑删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项；若提醒项已经足够清晰，就不要为了整理而整理。' +
+            '现在已经进入新一程：上下文已经不再吃紧，告急状况已改观。第一步先复核并在必要时整理接续包提醒项，以清醒头脑删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项；若提醒项已经足够清晰，就不要为了整理而整理。' +
             '完成这一步后，直接继续推进原任务本身；除非任务自然需要对用户交付结果，否则不要为这条提示单独回复。');
     }
     const prefix = args.source === 'clear_mind'
@@ -171,14 +171,14 @@ function formatReminderContextGuide(language) {
             `${formatSystemNoticePrefix(language)} 提醒项上下文块开始`,
             '以下是当前可见提醒项的运行时上下文投影。由于当前 LLM Provider 通常不支持 role=environment，Dominds 默认把系统运行时提醒包装投影为 role=user；个别提醒项可由其 owner 按自身契约选择 role。无论最终 role 如何，它们都不是用户的新诉求/指令，也不是聊天正文。',
             '在 WebUI 中，用户通过独立的 Reminder 小组件/面板项看到这些提醒，并能把它们和聊天正文区分开。',
-            '请把提醒项作为工作集/状态参考；只有实际改变你的判断、计划或风险的信息，才需要提炼进后续有实质内容的对外回复。不要为了提醒项单独回复“收到/已了解/静默吸收”。',
+            '请把提醒项作为手头工作/状态参考；只有实际改变你的判断、计划或风险的信息，才需要提炼进后续有实质内容的对外回复。不要为了提醒项单独回复“收到/已了解/静默吸收”。',
         ].join('\n');
     }
     return [
         `${formatSystemNoticePrefix(language)} Reminder context block begins`,
         'The following visible reminders are runtime-added context projections. Because current LLM providers usually do not support role=environment, Dominds projects default system-runtime reminder wrappers as role=user; individual reminder owners may choose the role required by their own contract. Regardless of their final role, these reminders are not new user requests/instructions, and not chat transcript text.',
         'In the WebUI, the user sees these reminders through a separate Reminder widget/panel item and can distinguish them from the chat transcript.',
-        'Use reminders as workset/state references; only carry information into a later substantive outward reply when it materially changes your current judgment, plan, or risk. Do not send a standalone "acknowledged/noted/silently absorbed" reply for reminder items.',
+        'Use reminders as current-work/state references; only carry information into a later substantive outward reply when it materially changes your current judgment, plan, or risk. Do not send a standalone "acknowledged/noted/silently absorbed" reply for reminder items.',
     ].join('\n');
 }
 function formatReminderItemProjectionNote(language) {
@@ -195,7 +195,9 @@ function formatReminderContextFooter(language, followingState) {
         if (followingState === 'runtime_notice') {
             return `${base}本轮提醒项块之后会接着出现一条运行时提示；它不是用户的新诉求/指令，请按其中的运行时要求继续推进。`;
         }
-        return `${base}本轮没有新的用户消息或运行时提示；这是工具调用后的自动续推，请基于已有任务状态继续推进，不要把“没有新消息”理解为空系统提示。`;
+        return (`${base}本轮没有新的用户消息或运行时提示；这是工具调用后的自动续推。` +
+            '请基于已有任务状态判断下一步：若已有明确、相关且有价值的动作，就继续执行；若当前确实只能等待外部结果或用户输入，不要为了避免“等待”而寻找无关小事。' +
+            '不要把“没有新消息”理解为空系统提示。');
     }
     const base = `${formatSystemNoticePrefix(language)} Reminder context block ends. The reminder items between ` +
         '"Reminder context block begins" and "Reminder context block ends" are system reminders, ' +
@@ -208,7 +210,9 @@ function formatReminderContextFooter(language, followingState) {
     if (followingState === 'runtime_notice') {
         return `${base}A runtime notice follows this reminder block in this round; it is not a new user request/instruction, so follow that runtime guidance and continue the work.`;
     }
-    return `${base}There is no new user message or runtime notice in this round; this is an automatic continuation after a tool call. Continue from the existing task state, and do not interpret the absence of a new message as an empty system notice.`;
+    return (`${base}There is no new user message or runtime notice in this round; this is an automatic continuation after a tool call. ` +
+        'Judge the next step from the existing task state: if there is a clear, relevant, valuable action, continue with it; if the work genuinely can only wait for an external result or user input, do not invent unrelated work just to avoid "waiting". ' +
+        'Do not interpret the absence of a new message as an empty system notice.');
 }
 function formatReminderItemGuide(language, reminderId, content, options) {
     function isRecord(value) {
@@ -303,16 +307,23 @@ function formatReminderItemGuide(language, reminderId, content, options) {
                 content,
             ].join('\n');
         }
+        const scopeLabel = scope === 'task' ? '（任务范围）' : scope === 'agent' ? '（智能体范围）' : '';
+        const scopeGuide = scope === 'task'
+            ? `${projectionNote}你设置了任务范围提醒项，让运行时系统在当前差遣牒任务内、所有由你主理的对话里提醒你。请把它当作当前任务的手头工作提示，不要自动当成系统下发的下一步动作。`
+            : scope === 'agent'
+                ? `${projectionNote}你设置了智能体范围提醒项，让运行时系统在所有由你主理的对话里提醒你。它只适合紧急、短期、全局刺眼提醒；不要用来记录普通任务状态，也不要自动当成系统下发的下一步动作。`
+                : `${projectionNote}你设置了提醒项，让运行时系统提醒你。请把它当作用来保留当前对话里容易丢的手头工作信息的提示，不要自动当成系统下发的下一步动作。`;
+        const scopeMaintenance = scope === 'task'
+            ? '你应保持简洁、及时更新；不再需要时就删除。若它只对当前对话有效，应改写成 dialog 范围提醒；若需要全队同步当前任务状态，应写入差遣牒 progress，而不是扩大提醒范围。'
+            : scope === 'agent'
+                ? '你应主动保持极少量、短期、强相关；不再需要时必须删除。普通任务进展不要放在 agent 范围，当前任务内跨对话可见请改用 task 范围。'
+                : '你应保持简洁、及时更新；不再需要时就删除。若后续准备换程，也可以把它整理成接续包。';
         return [
-            `${systemPrefix} 提醒项 [${reminderId}]${scope === 'personal' ? '（个人范围）' : ''}`,
+            `${systemPrefix} 提醒项 [${reminderId}]${scopeLabel}`,
             '',
-            scope === 'personal'
-                ? `${projectionNote}你设置了个人范围提醒项，让运行时系统在所有由你主理的后续对话里提醒你。请把它当作你的工作集提示，不要自动当成系统下发的下一步动作。`
-                : `${projectionNote}你设置了提醒项，让运行时系统提醒你。请把它当作用来保留当前对话里容易丢的工作信息的工作集提示，不要自动当成系统下发的下一步动作。`,
+            scopeGuide,
             '',
-            scope === 'personal'
-                ? '你应保持简洁、及时更新；不再需要时就删除。若它只对当前对话有效，应改写成 dialog 范围提醒而不是长期堆在个人范围里。'
-                : '你应保持简洁、及时更新；不再需要时就删除。若后续准备换程，也可以把它整理成接续包。',
+            scopeMaintenance,
             '',
             `如果你要更新这条提醒项，可执行：update_reminder({ "reminder_id": "${reminderId}", "content": "..." })`,
             deleteInstruction,
@@ -362,15 +373,22 @@ ${deleteInstruction}
 ---
 ${content}`;
     }
-    return `${systemPrefix} REMINDER [${reminderId}]${scope === 'personal' ? ' (PERSONAL SCOPE)' : ''}
+    const scopeLabel = scope === 'task' ? ' (TASK SCOPE)' : scope === 'agent' ? ' (AGENT SCOPE)' : '';
+    const scopeGuide = scope === 'task'
+        ? `${enProjectionPrefix}You set a task-scope reminder so the runtime system 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.`
+        : scope === 'agent'
+            ? `${enProjectionPrefix}You set an agent-scope reminder so the runtime system 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 a reminder so the runtime system can remind you. 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.'
+        : scope === 'agent'
+            ? 'Keep this scope rare, short-lived, and strongly relevant; delete it as soon as it is no longer needed. Ordinary task progress does not belong in agent scope; use task scope for current-task cross-dialog visibility.'
+            : 'Keep it concise, refresh it when needed, and delete it when obsolete. If you are preparing a new course, you can also rewrite it into a continuation package.';
+    return `${systemPrefix} REMINDER [${reminderId}]${scopeLabel}
 
-${scope === 'personal'
-        ? `${enProjectionPrefix}You set a personal-scope reminder so the runtime system can remind you in every later dialog you lead. Treat it as your workset reference, not as an automatically assigned next action.`
-        : `${enProjectionPrefix}You set a reminder so the runtime system can remind you. Treat it as your workset reference for easy-to-lose work details in the current dialog, not as an automatically assigned next action.`}
+${scopeGuide}
 
-${scope === 'personal'
-        ? '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 instead of letting personal scope accumulate noise.'
-        : 'Keep it concise, refresh it when needed, and delete it when obsolete. If you are preparing a new course, you can also rewrite it into a continuation package.'}
+${scopeMaintenance}
 
 Update path: update_reminder({ "reminder_id": "${reminderId}", "content": "..." })
 ${deleteInstruction}

package/dist/server/api-routes.js

@@ -66,6 +66,7 @@ const id_1 = require("../utils/id");
 const taskdoc_search_1 = require("../utils/taskdoc-search");
 const taskdoc_search_worker_client_1 = require("../utils/taskdoc-search-worker-client");
 const create_dialog_contract_1 = require("./create-dialog-contract");
+const dominds_runtime_status_1 = require("./dominds-runtime-status");
 const dominds_self_update_1 = require("./dominds-self-update");
 const mime_types_1 = require("./mime-types");
 const setup_routes_1 = require("./setup-routes");
@@ -1059,6 +1060,9 @@ async function handleApiRoute(req, res, pathname, context) {
         if (pathname === '/api/live-reload' && req.method === 'GET') {
             return await handleLiveReload(res, context);
         }
+        if (pathname === '/api/info' && req.method === 'GET') {
+            return await handleGetRuntimeInfo(res, context);
+        }
         if (pathname === '/api/dominds/self-update' && req.method === 'POST') {
             const body = await readRequestBody(req);
             let parsed;
@@ -2079,6 +2083,20 @@ async function handleLiveReload(res, context) {
         return true;
     }
 }
+/**
+ * Runtime info endpoint
+ */
+async function handleGetRuntimeInfo(res, context) {
+    try {
+        respondJson(res, 200, await (0, dominds_runtime_status_1.getDomindsRuntimeStatus)(context.mode));
+        return true;
+    }
+    catch (error) {
+        log.error('Runtime info failed:', error);
+        respondJson(res, 500, { success: false, error: 'Failed to get runtime info' });
+        return true;
+    }
+}
 /**
  * Team configuration endpoint
  * Returns full team configuration with member defaults, default responder,

package/dist/server/server-core.d.ts

@@ -45,6 +45,7 @@ export declare class HttpServerCore {
      */
     private sendError;
     private sendUnauthorized;
+    private sendApiNotFound;
     /**
      * Start the server on the configured port.
      */

package/dist/server/server-core.js

@@ -138,6 +138,8 @@ class HttpServerCore {
                 if (await (0, api_routes_1.handleApiRoute)(req, res, pathname, apiContext)) {
                     return;
                 }
+                this.sendApiNotFound(res);
+                return;
             }
             // Handle static files
             const staticHandled = await (0, static_server_1.serveStatic)(pathname, res, {
@@ -181,6 +183,15 @@ class HttpServerCore {
         });
         res.end(JSON.stringify({ error: 'unauthorized' }));
     }
+    sendApiNotFound(res) {
+        if (res.headersSent)
+            return;
+        res.writeHead(404, {
+            'Content-Type': 'application/json',
+            'Cache-Control': 'no-store',
+        });
+        res.end(JSON.stringify({ success: false, error: 'Not Found' }));
+    }
     /**
      * Start the server on the configured port.
      */

package/dist/server/websocket-handler.js

@@ -598,7 +598,8 @@ async function handleDeclareSideDialogDead(ws, packet) {
         return;
     const askerDialogIdObj = new dialog_1.DialogID(askerDialogId, dialogIdObj.rootId);
     const activeCalleeDispatches = await persistence_1.DialogPersistence.loadActiveCalleeDispatches(askerDialogIdObj, requestedStatus);
-    const activeCalleeDispatch = activeCalleeDispatches.find((dispatch) => dispatch.calleeDialogId === dialogIdObj.selfId);
+    const activeCalleeDispatch = activeCalleeDispatches.find((dispatch) => dispatch.calleeDialogId === dialogIdObj.selfId &&
+        dispatch.callId === assignmentFromAsker.callId);
     if (!activeCalleeDispatch) {
         // Asker is not waiting on this sideDialog anymore; do not schedule a continuation drive.
         return;

package/dist/shared-reminders.d.ts

@@ -1,4 +1,12 @@
 import { type Reminder } from './tool';
-export declare function loadAgentSharedReminders(agentId: string): Promise<Reminder[]>;
-export declare function replaceAgentSharedReminders(agentId: string, reminders: readonly Reminder[]): Promise<void>;
-export declare function mutateAgentSharedReminders<T>(agentId: string, mutate: (reminders: Reminder[]) => Promise<T> | T): Promise<T>;
+export type SharedReminderTarget = Readonly<{
+    kind: 'agent';
+    agentId: string;
+}> | Readonly<{
+    kind: 'task';
+    agentId: string;
+    taskDocPath: string;
+}>;
+export declare function loadSharedReminders(target: SharedReminderTarget): Promise<Reminder[]>;
+export declare function replaceSharedReminders(target: SharedReminderTarget, reminders: readonly Reminder[]): Promise<void>;
+export declare function mutateSharedReminders<T>(target: SharedReminderTarget, mutate: (reminders: Reminder[]) => Promise<T> | T): Promise<T>;