dominds 1.25.14 → 1.25.15

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

@@ -804,10 +804,15 @@ async function renderRemindersForContext(dlg) {
         return [];
     const language = (0, work_language_1.getWorkLanguage)();
     const renderedItems = [];
+    const maintenanceReferenceItems = [];
     for (const reminder of reminders) {
         if (!reminder || !(0, tool_1.reminderEchoBackEnabled)(reminder)) {
             continue;
         }
+        maintenanceReferenceItems.push({
+            id: reminder.id,
+            meta: reminder.meta,
+        });
         if (reminder.owner) {
             renderedItems.push(await reminder.owner.renderReminder(dlg, reminder));
             continue;
@@ -823,12 +828,22 @@ async function renderRemindersForContext(dlg) {
     }
     if (renderedItems.length === 0)
         return [];
+    const maintenanceReference = (0, driver_messages_1.formatReminderMaintenanceReference)(language, maintenanceReferenceItems);
     return [
         {
             type: 'environment_msg',
             role: 'user',
             content: (0, driver_messages_1.formatReminderContextGuide)(language),
         },
+        ...(maintenanceReference === undefined
+            ? []
+            : [
+                {
+                    type: 'transient_guide_msg',
+                    role: 'assistant',
+                    content: maintenanceReference,
+                },
+            ]),
         ...renderedItems,
     ];
 }

package/dist/mcp/supervisor.js

@@ -101,14 +101,12 @@ function ensureLeaseReminder(dlg, serverId) {
         ? [
             `已租用 MCP 工具集：${serverId}`,
             '',
-            '该 MCP server 被视为非“真正无状态”。当你确认短期内不再需要它时，请释放以回收底层进程/连接：',
-            `mcp_release({"serverId":"${serverId}"})`,
+            '该 MCP server 被视为非“真正无状态”；当前对话持有一个需要显式生命周期管理的底层进程/连接。',
         ].join('\n')
         : [
             `MCP toolset leased: ${serverId}`,
             '',
-            `This MCP server is treated as non-stateless. When you are confident you won't need it again soon, release it:`,
-            `mcp_release({"serverId":"${serverId}"})`,
+            `This MCP server is treated as non-stateless; the current dialog holds an underlying process/connection with explicit lifecycle management.`,
         ].join('\n');
     dlg.addReminder(content, owner, makeLeaseReminderMeta(serverId));
 }

package/dist/minds/system-prompt.js

@@ -99,8 +99,8 @@ function buildTeammateTellaskPhaseContract(language) {
             '- 队友诉请必须遵循“发起 → 等待 → 判定 → 续推”四段协议：若目标未达成，立即发出下一轮诉请推进。',
             '- 对队友诉请而言，收到回贴即表示该轮调用已结束；不存在“回贴已送达后，对方仍在后台继续执行同一诉请”的默认语义。要继续必须显式再发一轮诉请函数（通常 `tellask` 复用同一 `sessionSlug`）。',
             '- 若被诉请者在回贴送达前因 `clear_mind` 开启新一程，同一进行中诉请默认继续有效；新一程会自然承接，直到产生回贴或明确失败。不要仅因对方换程就把该轮诉请当作失效重发。',
-            '- 只有在存在明确进行中诉请时，才可声明“等待回贴/等待结果”（通常应可在“⏳ 进行中诉请（共 N 路，自动维护；仅 0 路时可手动删除）”这类提醒项中观测到）；若该提醒项不存在，或提醒项已明确“当前没有执行中的诉请”，则“等待”是错误动作，必须执行下一动作（直接诉请或本地执行）。',
-            '- “⏳ 进行中诉请”提醒项只是系统状态窗，不是控制面：内容不可手改；当存在非 0 路进行中诉请时，不可删除，误删会被拒绝并返回引导文案。若某一路诉请需要改要求、提前收口或纠偏，只能更新那一路诉请的“任务安排”（对长线诉请通常复用同一 `sessionSlug` 再发 `tellask`），让对应主理人按最新安排自行最终回复并自然结束。',
+            '- 只有在存在明确进行中诉请时，才可声明“等待回贴/等待结果”（通常应可在“⏳ 进行中诉请（共 N 路，自动维护）”这类提醒项中观测到）；若该提醒项不存在，或提醒项已明确“当前没有执行中的诉请”，则“等待”是错误动作，必须执行下一动作（直接诉请或本地执行）。',
+            '- “⏳ 进行中诉请”提醒项只是系统状态窗，不是控制面；用它判断是否确实存在仍在执行的诉请。若某一路诉请需要改要求、提前收口或纠偏，更新那一路诉请的“任务安排”（对长线诉请通常复用同一 `sessionSlug` 再发 `tellask`），让对应主理人按最新安排自行最终回复并自然结束。',
             '- 只有长线诉请（`tellask` + `sessionSlug`）能接着同一件事说、更新同一件正在做的事；一次性诉请（`tellaskSessionless`）做不到。再次发起 `tellaskSessionless` 只是另一件独立任务，不会更新、更不会要求旧任务停止；若你后来发现可能需要改要求/提前收口，一开始就不该选择 `tellaskSessionless`。',
             '- 不要把智能体队友当成真人同事：祂不会因为你又发一条诉请而被打扰。同一个队友可以同时做多件独立任务，系统会分开处理。记住这个简单规则：同一个队友 + 同一个 `sessionSlug` = 接着同一件事说，并更新那件正在做的事；`tellaskSessionless` 或不同 `sessionSlug` = 另一件独立任务。只要任务独立、目标清楚，就直接并行诉请。',
             '- 能由队友诉请完成的执行性工作，禁止转交 `askHuman` 做“转发员”；当你写“让 @X 执行 Y”时，必须在同一回复内直接发出 `tellask` 或 `tellaskSessionless`。',
@@ -112,8 +112,8 @@ function buildTeammateTellaskPhaseContract(language) {
             '- Teammate Tellasks MUST follow four phases: “initiate -> wait -> judge -> continue”. If the objective is not met, immediately send the next Tellask round.',
             '- For teammate Tellasks, a delivered response closes that call round; there is no default “still running in background after the reply is already delivered” state for the same Tellask. To continue, emit a new Tellask function call explicitly (usually `tellask` with the same `sessionSlug`).',
             '- If the tellaskee starts a new course via `clear_mind` before delivering the reply, the same in-flight Tellask stays live by default; the new course naturally continues it until a reply is delivered or an explicit failure is returned. Do not re-tellask solely because the tellaskee changed course.',
-            '- You may claim “waiting for reply/result” only when a concrete pending Tellask exists (normally observable in a “⏳ In-flight Tellasks (N total, auto-maintained; manually deletable only at zero in-flight)” reminder). If that reminder is absent, or it explicitly states there are no in-flight Tellasks, waiting is a wrong action; execute the next action now (direct Tellask or local action).',
-            '- The “⏳ In-flight Tellasks” reminder is only a system status window, not a control surface: its content is not hand-editable; while any Tellask is still active, it is not deletable, and mistaken deletion will be rejected with guidance. If one Tellask needs a changed scope, earlier closure, or correction, update that Tellask’s assignment instead (for a sessioned Tellask, usually send another `tellask` with the same `sessionSlug`) so the tellaskee can deliver a final reply naturally under the latest assignment.',
+            '- You may claim “waiting for reply/result” only when a concrete pending Tellask exists (normally observable in a “⏳ In-flight Tellasks (N total, auto-maintained)” reminder). If that reminder is absent, or it explicitly states there are no in-flight Tellasks, waiting is a wrong action; execute the next action now (direct Tellask or local action).',
+            '- The “⏳ In-flight Tellasks” reminder is only a system status window, not a control surface; use it to determine whether any Tellask is truly still in flight. If one Tellask needs a changed scope, earlier closure, or correction, update that Tellask’s assignment (for a sessioned Tellask, usually send another `tellask` with the same `sessionSlug`) so the tellaskee can deliver a final reply naturally under the latest assignment.',
             '- Only a sessioned Tellask (`tellask` + `sessionSlug`) can continue the same task and update that task. A one-shot Tellask (`tellaskSessionless`) cannot: another `tellaskSessionless` is a separate task and does not update, stop, or instruct the earlier task to stop. If you may need later correction or earlier wrap-up, do not choose `tellaskSessionless` in the first place.',
             '- Do not treat an agent teammate like a human coworker who can only handle one conversation at a time. The same teammate can work on several independent tasks at once, and the system keeps them separate. Simple rule: same teammate + same `sessionSlug` = continue the same task and update that task; `tellaskSessionless` or a different `sessionSlug` = another independent task. When tasks are independent and clear, tellask in parallel.',
             '- Do not use `askHuman` as a relay for executable teammate work. If you write “ask @X to do Y”, emit `tellask` or `tellaskSessionless` in the same response.',

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

@@ -20,6 +20,11 @@ export type ReminderContextFooterState = Readonly<{
     interDialogReplyObligation: ReminderContextReplyObligationState;
 }>;
 export declare function formatReminderContextFooter(language: LanguageCode, state: ReminderContextFooterState): string;
+export type ReminderMaintenanceReferenceItem = Readonly<{
+    id: string;
+    meta?: unknown;
+}>;
+export declare function formatReminderMaintenanceReference(language: LanguageCode, reminders: readonly ReminderMaintenanceReferenceItem[]): string | undefined;
 export declare function formatReminderItemGuide(language: LanguageCode, reminderId: string, content: string, options?: {
     meta?: unknown;
     scope?: 'dialog' | 'task' | 'agent' | 'runtime';

package/dist/runtime/driver-messages.js

@@ -11,6 +11,7 @@ exports.formatNewCourseStartPrompt = formatNewCourseStartPrompt;
 exports.formatDiligenceAutoContinuePrompt = formatDiligenceAutoContinuePrompt;
 exports.formatReminderContextGuide = formatReminderContextGuide;
 exports.formatReminderContextFooter = formatReminderContextFooter;
+exports.formatReminderMaintenanceReference = formatReminderMaintenanceReference;
 exports.formatReminderItemGuide = formatReminderItemGuide;
 exports.formatQ4HDiligencePushBudgetExhausted = formatQ4HDiligencePushBudgetExhausted;
 exports.formatDomindsNoteTellaskForTeammatesOnly = formatDomindsNoteTellaskForTeammatesOnly;
@@ -236,53 +237,121 @@ function formatReminderContextFooter(language, state) {
         '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. ${businessTail}`);
 }
-function formatReminderItemGuide(language, reminderId, content, options) {
-    function isRecord(value) {
-        return typeof value === 'object' && value !== null && !Array.isArray(value);
-    }
-    // `options.meta` is persisted JSON coming from tools. Runtime shape checks are unavoidable here
-    // to keep reminder ownership/management loosely coupled and extensible.
-    const metaValue = options && 'meta' in options ? options.meta : undefined;
-    const scope = options?.scope;
-    const isContinuationPackageReminder = isRecord(metaValue) && metaValue['kind'] === 'continuation_package';
-    const isPendingTellaskReminder = isRecord(metaValue) && metaValue['kind'] === 'pending_tellask';
+function isReminderGuideMetaRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function getReminderMaintenanceInstructions(language, reminderId, meta) {
+    const metaValue = meta;
+    const isPendingTellaskReminder = isReminderGuideMetaRecord(metaValue) && metaValue['kind'] === 'pending_tellask';
     const pendingTellaskCount = isPendingTellaskReminder && typeof metaValue['pendingCount'] === 'number'
         ? metaValue['pendingCount']
         : undefined;
-    const managerValue = isRecord(metaValue) ? metaValue['manager'] : undefined;
-    const managementTool = isRecord(managerValue) && typeof managerValue['tool'] === 'string'
+    const managerValue = isReminderGuideMetaRecord(metaValue) ? metaValue['manager'] : undefined;
+    const managementTool = isReminderGuideMetaRecord(managerValue) && typeof managerValue['tool'] === 'string'
         ? managerValue['tool'].trim()
         : undefined;
-    const updateValue = isRecord(metaValue) ? metaValue['update'] : undefined;
-    const updateAltInstruction = isRecord(updateValue) && typeof updateValue['altInstruction'] === 'string'
+    const updateValue = isReminderGuideMetaRecord(metaValue) ? metaValue['update'] : undefined;
+    const updateAltInstruction = isReminderGuideMetaRecord(updateValue) && typeof updateValue['altInstruction'] === 'string'
         ? updateValue['altInstruction'].trim()
         : undefined;
-    const updateInstruction = updateAltInstruction && updateAltInstruction.length > 0
-        ? updateAltInstruction
-        : managementTool
-            ? `${managementTool}({ ... })`
-            : undefined;
-    const deleteValue = isRecord(metaValue) ? metaValue['delete'] : undefined;
-    const deleteAltInstruction = isRecord(deleteValue) && typeof deleteValue['altInstruction'] === 'string'
+    const metaKind = isReminderGuideMetaRecord(metaValue) ? metaValue['kind'] : undefined;
+    const serverIdValue = isReminderGuideMetaRecord(metaValue) ? metaValue['serverId'] : undefined;
+    const mcpReleaseInstruction = typeof serverIdValue === 'string' && serverIdValue.trim() !== ''
+        ? `mcp_release({"serverId":"${serverIdValue.trim()}"})`
+        : 'mcp_release({"serverId":"<serverId>"})';
+    const updateInstruction = metaKind === 'mcp_lease'
+        ? language === 'zh'
+            ? 'MCP lease 状态由系统维护，不用 update_reminder 修改'
+            : 'MCP lease state is system-maintained; I do not edit it with update_reminder'
+        : updateAltInstruction && updateAltInstruction.length > 0
+            ? updateAltInstruction
+            : managementTool
+                ? `${managementTool}({ ... })`
+                : undefined;
+    const deleteValue = isReminderGuideMetaRecord(metaValue) ? metaValue['delete'] : undefined;
+    const deleteAltInstruction = isReminderGuideMetaRecord(deleteValue) && typeof deleteValue['altInstruction'] === 'string'
         ? deleteValue['altInstruction'].trim()
         : undefined;
+    const daemonCompleted = metaKind === 'daemon' && isReminderGuideMetaRecord(metaValue) && metaValue['completed'] === true;
     const deleteInstruction = language === 'zh'
-        ? deleteAltInstruction
-            ? `删除通道：不要用 delete_reminder；请执行：${deleteAltInstruction}`
-            : isPendingTellaskReminder && pendingTellaskCount === 0
-                ? `清理噪音时可删除：delete_reminder({ "reminder_id": "${reminderId}" })`
-                : `删除通道：delete_reminder({ "reminder_id": "${reminderId}" })`
-        : deleteAltInstruction
-            ? `Delete path: do not use delete_reminder; run: ${deleteAltInstruction}`
-            : isPendingTellaskReminder && pendingTellaskCount === 0
-                ? `Noise cleanup delete path: delete_reminder({ "reminder_id": "${reminderId}" })`
-                : `Delete path: delete_reminder({ "reminder_id": "${reminderId}" })`;
+        ? isPendingTellaskReminder && pendingTellaskCount !== undefined && pendingTellaskCount > 0
+            ? '删除通道：当前仍有进行中诉请；我不能用 delete_reminder 删除。要改变某一路长线诉请时，我复用同一 sessionSlug 再发 tellask；tellaskSessionless 不能修改或停止旧任务。'
+            : deleteAltInstruction
+                ? `删除通道：我不用 delete_reminder；我执行：${deleteAltInstruction}`
+                : metaKind === 'mcp_lease'
+                    ? `删除通道：我不用 delete_reminder 释放资源；确认当前对话近期不再需要该 MCP runtime 时，我执行：${mcpReleaseInstruction}`
+                    : daemonCompleted
+                        ? `删除通道：确认已知悉 daemon 终态后，可清理：delete_reminder({ "reminder_id": "${reminderId}" })`
+                        : isPendingTellaskReminder && pendingTellaskCount === 0
+                            ? `清理噪音时我可删除：delete_reminder({ "reminder_id": "${reminderId}" })`
+                            : `删除通道：delete_reminder({ "reminder_id": "${reminderId}" })`
+        : isPendingTellaskReminder && pendingTellaskCount !== undefined && pendingTellaskCount > 0
+            ? 'Delete path: there are still in-flight Tellasks; I cannot delete this reminder with delete_reminder. To change a sessioned tellask, I send another tellask with the same sessionSlug; tellaskSessionless cannot modify or stop an earlier task.'
+            : deleteAltInstruction
+                ? `Delete path: I do not use delete_reminder; I run: ${deleteAltInstruction}`
+                : metaKind === 'mcp_lease'
+                    ? `Delete path: I do not release resources by deleting the reminder; when this dialog will not need the MCP runtime soon, I run: ${mcpReleaseInstruction}`
+                    : daemonCompleted
+                        ? `Delete path: after I have acknowledged the daemon terminal state, I may clean up: delete_reminder({ "reminder_id": "${reminderId}" })`
+                        : isPendingTellaskReminder && pendingTellaskCount === 0
+                            ? `Noise cleanup delete path: I may run delete_reminder({ "reminder_id": "${reminderId}" })`
+                            : `Delete path: delete_reminder({ "reminder_id": "${reminderId}" })`;
+    return { updateInstruction, deleteInstruction };
+}
+function formatReminderMaintenanceReference(language, reminders) {
+    const lines = [];
+    for (const reminder of reminders) {
+        const { updateInstruction, deleteInstruction } = getReminderMaintenanceInstructions(language, reminder.id, reminder.meta);
+        if (language === 'zh') {
+            if (updateInstruction) {
+                lines.push(`- reminder_id=${reminder.id}：我若要更新/调整这条提醒项，参考：${updateInstruction}`);
+            }
+            else {
+                lines.push(`- reminder_id=${reminder.id}：我若要更新/调整这条提醒项，参考：update_reminder({ "reminder_id": "${reminder.id}", "content": "..." })`);
+            }
+            lines.push(`- reminder_id=${reminder.id}：我若要删除/清理这条提醒项，参考：${deleteInstruction}`);
+        }
+        else {
+            if (updateInstruction) {
+                lines.push(`- reminder_id=${reminder.id}: if I update/change this reminder, I follow: ${updateInstruction}`);
+            }
+            else {
+                lines.push(`- reminder_id=${reminder.id}: if I update/change this reminder, I follow: update_reminder({ "reminder_id": "${reminder.id}", "content": "..." })`);
+            }
+            lines.push(`- reminder_id=${reminder.id}: if I delete/clean up this reminder, I follow: ${deleteInstruction}`);
+        }
+    }
+    if (lines.length === 0)
+        return undefined;
+    if (language === 'zh') {
+        return [
+            `${formatSystemNoticePrefix(language)} 我把下面的提醒项维护通道仅作为操作参考；如果我需要维护某条 reminder，我会按对应 reminder_id 选择工具。我不会把这些参考当成当前轮必须立即执行的动作，也不会因此延迟回应后续真实用户消息。`,
+            '',
+            ...lines,
+        ].join('\n');
+    }
+    return [
+        `${formatSystemNoticePrefix(language)} I treat the following reminder-maintenance channels as an operational reference only. If I need to maintain a reminder, I match the corresponding reminder_id and choose the tool from there. I do not treat these references as actions I must perform immediately in this turn, and I do not let them delay my response to any following real user message.`,
+        '',
+        ...lines,
+    ].join('\n');
+}
+function formatReminderItemGuide(language, reminderId, content, options) {
+    // `options.meta` is persisted JSON coming from tools. Runtime shape checks are unavoidable here
+    // to keep reminder ownership/management loosely coupled and extensible.
+    const metaValue = options && 'meta' in options ? options.meta : undefined;
+    const scope = options?.scope;
+    const isContinuationPackageReminder = isReminderGuideMetaRecord(metaValue) && metaValue['kind'] === 'continuation_package';
+    const managerValue = isReminderGuideMetaRecord(metaValue) ? metaValue['manager'] : undefined;
+    const managementTool = isReminderGuideMetaRecord(managerValue) && typeof managerValue['tool'] === 'string'
+        ? managerValue['tool'].trim()
+        : undefined;
+    const { updateInstruction } = getReminderMaintenanceInstructions(language, reminderId, metaValue);
     const projectionNote = formatReminderItemProjectionNote(language);
     const enProjectionPrefix = `${projectionNote} `;
     const systemPrefix = formatSystemNoticePrefix(language);
     if (language === 'zh') {
         if (managementTool) {
-            const updateInstructionSafe = updateInstruction ?? `${managementTool}({ ... })`;
             return [
                 `${systemPrefix} 提醒项 [${reminderId}]（工具状态）`,
                 '',
@@ -291,11 +360,6 @@ function formatReminderItemGuide(language, reminderId, content, options) {
                 '',
                 '默认不要在对外回复里专门确认、复述或总结它；只有它实际改变你的判断、计划或风险时，才提炼真正相关的部分。',
                 '',
-                `调整通道：使用 ${managementTool}；不要用 update_reminder。`,
-                '',
-                `更新通道：${updateInstructionSafe}`,
-                deleteInstruction,
-                '',
                 '---',
                 content,
             ].join('\n');
@@ -304,12 +368,9 @@ function formatReminderItemGuide(language, reminderId, content, options) {
             return [
                 `${systemPrefix} 提醒项 [${reminderId}]`,
                 '',
-                `${projectionNote}当前运行环境中有一条带有 meta 控制更新规则的提醒项。请把它当作状态参考，不要用 update_reminder 直接改写内容。`,
+                `${projectionNote}当前运行环境中有一条带有 meta 控制更新规则的提醒项。请把它当作状态参考，具体维护通道以前置维护参考为准。`,
                 formatAutoMaintainedReminderManualMirrorBan(language),
                 '',
-                `更新通道：不要用 update_reminder；请按此处理：${updateInstruction}`,
-                deleteInstruction,
-                '',
                 '---',
                 content,
             ].join('\n');
@@ -322,9 +383,6 @@ function formatReminderItemGuide(language, reminderId, content, options) {
                 '',
                 '你应优先保留下一步行动、关键定位、运行/验证信息、容易丢的临时细节；不要重复差遣牒已覆盖的内容。进入新一程后，你的第一步是以清醒头脑重新审视并整理更新：删除冗余、纠正偏激/失真思路、压缩成高质量提醒项。若目前只是粗略过桥笔记，进入新一程后必须尽快收敛。',
                 '',
-                `如果你要更新这份接续包，可执行：update_reminder({ "reminder_id": "${reminderId}", "content": "..." })`,
-                deleteInstruction,
-                '',
                 '---',
                 content,
             ].join('\n');
@@ -347,15 +405,11 @@ function formatReminderItemGuide(language, reminderId, content, options) {
             '',
             scopeMaintenance,
             '',
-            `如果你要更新这条提醒项，可执行：update_reminder({ "reminder_id": "${reminderId}", "content": "..." })`,
-            deleteInstruction,
-            '',
             '---',
             content,
         ].join('\n');
     }
     if (managementTool) {
-        const updateInstructionSafe = updateInstruction ?? `${managementTool}({ ... })`;
         return `${systemPrefix} REMINDER [${reminderId}] (TOOL STATE)
 
 ${enProjectionPrefix}The current runtime environment has a tool-managed state reminder from ${managementTool}. Treat it as environment/tool state, not as your self-authored work note.
@@ -364,22 +418,16 @@ ${formatAutoMaintainedReminderManualMirrorBan(language)}
 
 By default, do not explicitly acknowledge, restate, or summarize it in your outward reply; only extract the parts that materially change your current judgment, plan, or risk.
 
-Change path: use ${managementTool}; do not use update_reminder.
-
-Update path: ${updateInstructionSafe}
-${deleteInstruction}
 ---
 ${content}`;
     }
     if (updateInstruction) {
         return `${systemPrefix} REMINDER [${reminderId}]
 
-${enProjectionPrefix}The current runtime environment has a reminder with a meta-controlled update path. Treat it as state/reference, and do not rewrite it directly with update_reminder.
+${enProjectionPrefix}The current runtime environment has a reminder with a meta-controlled update path. Treat it as state/reference; use the preceding maintenance reference for its maintenance channel.
 
 ${formatAutoMaintainedReminderManualMirrorBan(language)}
 
-Update path: do not use update_reminder; follow instead: ${updateInstruction}
-${deleteInstruction}
 ---
 ${content}`;
     }
@@ -390,8 +438,6 @@ ${enProjectionPrefix}You set a continuation reminder so the runtime system can r
 
 Keep the next step, key pointers, run/verify info, and easy-to-lose volatile details here. Do not duplicate Taskdoc content. In the new course, your first step is to review and rewrite this with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress it into a high-quality reminder. If this is only a rough bridge note, reconcile it early in the new course.
 
-Update path: update_reminder({ "reminder_id": "${reminderId}", "content": "..." })
-${deleteInstruction}
 ---
 ${content}`;
     }
@@ -412,8 +458,6 @@ ${scopeGuide}
 
 ${scopeMaintenance}
 
-Update path: update_reminder({ "reminder_id": "${reminderId}", "content": "..." })
-${deleteInstruction}
 ---
 ${content}`;
 }