dominds 1.22.0 → 1.23.0

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

@@ -148,11 +148,11 @@ function getMemoryPromptCopy(ctx) {
     const taskdocLogLineZh = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
             ? '当前是告急处置态：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前对话历史中下一程需要知道的讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入接续包提醒项。提醒项长度没有技术限制，宁可完整一些；允许多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
-            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是告急处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、且已完成合并时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是告急处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并且能带上当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
                 ? '当前是吃紧处置态：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前对话历史中下一程需要知道的讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入接续包提醒项。提醒项长度没有技术限制，宁可完整一些；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
-                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是吃紧处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、且已完成合并时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是吃紧处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并且能带上当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
             : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步；提醒项也只留可扫读摘录。接续包提醒项默认应保持结构化、便于快速恢复。';
     const contextHealthLineEn = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
@@ -166,11 +166,11 @@ function getMemoryPromptCopy(ctx) {
     const taskdocLogLineEn = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
             ? 'Current mode is critical remediation: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into continuation-package reminders. Reminder length has no technical limit, so prefer being complete. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
-            : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is critical remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting and you have merged against the current content. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
+            : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is critical remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you can pass the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
                 ? 'Current mode is caution remediation: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into continuation-package reminders. Reminder length has no technical limit, so prefer being complete. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
-                : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is caution remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting and you have merged against the current content. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
+                : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is caution remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you can pass the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
             : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps; reminders should also keep only scannable excerpts. Keep continuation-package reminders structured and fast to resume from by default.';
     if (ctx.language === 'zh') {
         return {
@@ -181,7 +181,7 @@ function getMemoryPromptCopy(ctx) {
             taskdocSemanticsLine: '- 章节语义约定：`progress` 是全队共享、准实时、可扫读的任务公告牌，用来记录当前有效状态、关键决策、下一步与仍成立阻塞；不是流水账，也不是个人工作记录。`goals` / `constraints` 是较稳定的任务契约；每次更新都必须保留仍然有效的他人条目。',
             taskdocSectionReplaceLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
                 ? '- 当前处于支线对话的上下文健康处置态：本程不要维护差遣牒，也不要整理差遣牒更新提案；把下一程需要恢复的细节写入足够详尽的接续包提醒项。'
-                : `- 更新差遣牒时：少量新增条目可用 \`mind_more\` 追加（默认 progress）；缺失章节用 \`do_mind\` 创建；需要删除陈旧项、重排结构或压缩时，用 \`change_mind\` 整章替换并先对照“上下文中注入的当前内容”做合并；需要删除整章文件时用 \`never_mind\`；禁止覆盖/抹掉他人条目；自己负责维护的条目必须标注责任人（例如 \`- [owner:@${ctx.agentId}] ...\` 或用 \`### @${ctx.agentId}\` 分块）。`,
+                : `- 更新差遣牒时：少量新增条目可用 \`mind_more\` 追加（默认 progress）；缺失章节用 \`do_mind\` 创建；需要删除陈旧项、重排结构或压缩时，用 \`change_mind\` 整章替换并先对照“上下文中注入的当前内容”做合并，同时带上当前 \`content_hash\` 作为 \`previous_content_hash\`；需要删除整章文件时用 \`never_mind\`；禁止覆盖/抹掉他人条目；自己负责维护的条目必须标注责任人（例如 \`- [owner:@${ctx.agentId}] ...\` 或用 \`### @${ctx.agentId}\` 分块）。`,
             progressLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
                 ? '- 当前处于支线对话的上下文健康处置态：本程不更新 `progress`；只把下一程接续所需信息写入提醒项。'
                 : '- 更新 `progress` 时：它必须始终是可供全队扫读的完整当前快照，而不是只追加自己这一轮的零散笔记。',
@@ -202,7 +202,7 @@ function getMemoryPromptCopy(ctx) {
             sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'
                 ? `工作流：先做事 → 再提炼（\`update_reminder\`；必要时整理差遣牒追加条目/更新提案并诉请 \`@${ctx.taskdocMaintainerId}\` 合并写入）→ 然后 \`clear_mind\` 清空噪音。`
                 : '工作流：停止扩张上下文 → 维护足够详尽的接续包提醒项（`add_reminder` 或 `update_reminder`，长度没有技术限制）→ 然后 `clear_mind` 开启新一程。',
-            mainDialogWorkflowLine: '工作流：先做事 → 再提炼（`update_reminder` + `mind_more(progress)`；需要压缩/删旧时用 `change_mind(progress)`；要删除整章文件时用 `never_mind`）→ 然后 `clear_mind` 清空噪音。',
+            mainDialogWorkflowLine: '工作流：先做事 -> 再提炼（`update_reminder` + `mind_more(progress)`；需要压缩/删旧时用带 `previous_content_hash` 的 `change_mind`；要删除整章文件时用 `never_mind`）-> 然后 `clear_mind` 清空噪音。',
             contextHealthLine: contextHealthLineZh,
             taskdocLogLine: taskdocLogLineZh,
         };
@@ -215,7 +215,7 @@ function getMemoryPromptCopy(ctx) {
         taskdocSemanticsLine: '- Section semantics: `progress` is the team-shared, quasi-real-time, scannable task bulletin board for current effective state, key decisions, next steps, and still-active blockers; it is not a raw log or personal work record. `goals` / `constraints` are the more stable task contract; every update must preserve still-valid entries from others.',
         taskdocSectionReplaceLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
             ? '- Current mode is context-health remediation in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals in this course; put resume-critical details into sufficiently detailed continuation-package reminders.'
-            : `- When updating Taskdoc: use \`mind_more\` for small append-only additions (defaults to progress); create missing sections with \`do_mind\`; when stale entries must be removed, reordered, or compressed, use \`change_mind\` for a full-section replacement based on the current injected content; when a whole section file should be removed, use \`never_mind\`; do not overwrite other contributors; add an explicit owner tag for entries you maintain (e.g., \`- [owner:@${ctx.agentId}] ...\` or a \`### @${ctx.agentId}\` block).`,
+            : `- When updating Taskdoc: use \`mind_more\` for small append-only additions (defaults to progress); create missing sections with \`do_mind\`; when stale entries must be removed, reordered, or compressed, use \`change_mind\` for a full-section replacement based on the current injected content and include the current \`content_hash\` as \`previous_content_hash\`; when a whole section file should be removed, use \`never_mind\`; do not overwrite other contributors; add an explicit owner tag for entries you maintain (e.g., \`- [owner:@${ctx.agentId}] ...\` or a \`### @${ctx.agentId}\` block).`,
         progressLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
             ? '- Current mode is context-health remediation in a Side Dialog: do not update `progress` in this course; put resume-critical information into reminders only.'
             : '- When updating `progress`, keep it as a complete, team-scannable current snapshot instead of appending only your own latest notes.',
@@ -236,7 +236,7 @@ function getMemoryPromptCopy(ctx) {
         sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'
             ? `Workflow: do work → distill (\`update_reminder\`; when Taskdoc needs updates, draft append entries, a merged replacement, or a section deletion and ask \`@${ctx.taskdocMaintainerId}\`) → then \`clear_mind\` to drop noise.`
             : 'Workflow: stop expanding context → maintain sufficiently detailed continuation-package reminders (`add_reminder` or `update_reminder`, with no technical length limit) → then `clear_mind` to start a new course.',
-        mainDialogWorkflowLine: 'Workflow: do work → distill (`update_reminder` + `mind_more(progress)`; use `change_mind(progress)` when compression/deletion is needed; use `never_mind` when removing a whole section file) → then `clear_mind` to drop noise.',
+        mainDialogWorkflowLine: 'Workflow: do work -> distill (`update_reminder` + `mind_more(progress)`; use `change_mind` with `previous_content_hash` when compression/deletion is needed; use `never_mind` when removing a whole section file) -> then `clear_mind` to drop noise.',
         contextHealthLine: contextHealthLineEn,
         taskdocLogLine: taskdocLogLineEn,
     };

package/dist/persistence.d.ts

@@ -75,8 +75,7 @@ export declare class DiskFileDialogStore extends DialogStore {
      * Ensure sideDialog directory exists (delegate to DialogPersistence)
      */
     private ensureSideDialogDirectory;
-    private findExistingFuncResultRecord;
-    private findExistingCallRecord;
+    private findExistingTellaskCallRecord;
     private findExistingTellaskResultRecord;
     private raiseDuplicateCallInvariantViolation;
     private raiseDuplicateCallResultInvariantViolation;
@@ -157,7 +156,7 @@ export declare class DiskFileDialogStore extends DialogStore {
     /**
      * Persist a function call to storage
      */
-    persistFunctionCall(dialog: Dialog, id: string, name: string, rawArgumentsText: string, genseq: number): Promise<void>;
+    persistFunctionCall(dialog: Dialog, id: string, name: string, rawArgumentsText: string, genseq: number, rawId?: string): Promise<void>;
     persistTellaskCall(dialog: Dialog, id: string, name: 'tellaskBack' | 'tellask' | 'tellaskSessionless' | 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack' | 'askHuman' | 'freshBootsReasoning', rawArgumentsText: string, genseq: number, options?: {
         deliveryMode?: 'tellask_call_start' | 'func_call_requested';
     }): Promise<void>;

package/dist/persistence.js

@@ -549,6 +549,8 @@ function buildFuncCallRecord(args) {
         ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
         type: 'func_call_record',
         genseq: args.genseq,
+        ...(args.rawId !== undefined ? { rawId: args.rawId } : {}),
+        ...(args.effectiveId !== undefined ? { effectiveId: args.effectiveId } : {}),
         id: args.id,
         name: args.name,
         rawArgumentsText: args.rawArgumentsText,
@@ -559,6 +561,8 @@ function buildFuncResultRecord(funcResult, genseq) {
         ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
         type: 'func_result_record',
         id: funcResult.id,
+        ...(funcResult.rawId !== undefined ? { rawId: funcResult.rawId } : {}),
+        ...(funcResult.effectiveId !== undefined ? { effectiveId: funcResult.effectiveId } : {}),
         name: funcResult.name,
         content: funcResult.content,
         contentItems: funcResult.contentItems,
@@ -1882,19 +1886,6 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         if (!Number.isFinite(genseq) || genseq <= 0) {
             throw new Error(`receiveFuncResult invariant violation: missing valid genseq for func result ${funcResult.id}`);
         }
-        const existingFuncResult = await this.findExistingFuncResultRecord(dialog, funcResult.id);
-        if (existingFuncResult) {
-            await this.raiseDuplicateCallResultInvariantViolation({
-                dialog,
-                kind: 'func_result',
-                callId: funcResult.id,
-                callName: funcResult.name,
-                incomingCourse: course,
-                incomingGenseq: genseq,
-                existingCourse: existingFuncResult.course,
-                existingGenseq: existingFuncResult.record.genseq,
-            });
-        }
         const funcResultRecord = buildFuncResultRecord(funcResult, genseq);
         await this.appendEvent(dialog, course, funcResultRecord);
         // Send event to frontend
@@ -1905,6 +1896,8 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             const funcResultEvt = {
                 type: 'func_result_evt',
                 id: funcResult.id,
+                ...(funcResult.rawId !== undefined ? { rawId: funcResult.rawId } : {}),
+                ...(funcResult.effectiveId !== undefined ? { effectiveId: funcResult.effectiveId } : {}),
                 name: funcResult.name,
                 content: funcResult.content,
                 contentItems: funcResult.contentItems,
@@ -1916,7 +1909,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
     }
     async receiveTellaskResult(dialog, result) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
-        const existingTellaskResult = await this.findExistingTellaskResultRecord(dialog, result.callId);
+        const existingTellaskResult = await this.findExistingTellaskResultRecord(dialog, course, result.callId);
         if (existingTellaskResult) {
             await this.raiseDuplicateCallResultInvariantViolation({
                 dialog,
@@ -1925,7 +1918,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 callName: result.callName,
                 incomingCourse: course,
                 incomingGenseq: undefined,
-                existingCourse: existingTellaskResult.course,
+                existingCourse: course,
                 existingGenseq: undefined,
             });
         }
@@ -1954,53 +1947,29 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
     async ensureSideDialogDirectory(dialogId) {
         return await DialogPersistence.ensureSideDialogDirectory(dialogId);
     }
-    async findExistingFuncResultRecord(dialog, callId) {
-        const latest = await DialogPersistence.loadDialogLatest(dialog.id, dialog.status);
-        const maxCourse = latest?.currentCourse ?? dialog.currentCourse;
-        for (let course = 1; course <= maxCourse; course += 1) {
-            const events = await DialogPersistence.loadCourseEvents(dialog.id, course, dialog.status);
-            for (const event of events) {
-                if (event.type !== 'func_result_record') {
-                    continue;
-                }
-                if (event.id !== callId) {
-                    continue;
-                }
-                return { course, record: event };
+    async findExistingTellaskCallRecord(dialog, course, callId) {
+        const events = await DialogPersistence.loadCourseEvents(dialog.id, course, dialog.status);
+        for (const event of events) {
+            if (event.type !== 'tellask_call_record') {
+                continue;
             }
-        }
-        return undefined;
-    }
-    async findExistingCallRecord(dialog, callId) {
-        const latest = await DialogPersistence.loadDialogLatest(dialog.id, dialog.status);
-        const maxCourse = latest?.currentCourse ?? dialog.currentCourse;
-        for (let course = 1; course <= maxCourse; course += 1) {
-            const events = await DialogPersistence.loadCourseEvents(dialog.id, course, dialog.status);
-            for (const event of events) {
-                if (event.type === 'func_call_record' && event.id === callId) {
-                    return { course, record: event };
-                }
-                if (event.type === 'tellask_call_record' && event.id === callId) {
-                    return { course, record: event };
-                }
+            if (event.id !== callId) {
+                continue;
             }
+            return event;
         }
         return undefined;
     }
-    async findExistingTellaskResultRecord(dialog, callId) {
-        const latest = await DialogPersistence.loadDialogLatest(dialog.id, dialog.status);
-        const maxCourse = latest?.currentCourse ?? dialog.currentCourse;
-        for (let course = 1; course <= maxCourse; course += 1) {
-            const events = await DialogPersistence.loadCourseEvents(dialog.id, course, dialog.status);
-            for (const event of events) {
-                if (event.type !== 'tellask_result_record') {
-                    continue;
-                }
-                if (event.callId !== callId) {
-                    continue;
-                }
-                return { course, record: event };
+    async findExistingTellaskResultRecord(dialog, course, callId) {
+        const events = await DialogPersistence.loadCourseEvents(dialog.id, course, dialog.status);
+        for (const event of events) {
+            if (event.type !== 'tellask_result_record') {
+                continue;
+            }
+            if (event.callId !== callId) {
+                continue;
             }
+            return event;
         }
         return undefined;
     }
@@ -2763,30 +2732,26 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
     /**
      * Persist a function call to storage
      */
-    async persistFunctionCall(dialog, id, name, rawArgumentsText, genseq) {
+    async persistFunctionCall(dialog, id, name, rawArgumentsText, genseq, rawId) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
         if (!Number.isFinite(genseq) || genseq <= 0) {
             throw new Error(`persistFunctionCall invariant violation: missing valid genseq for func call ${id}`);
         }
-        const existingCall = await this.findExistingCallRecord(dialog, id);
-        if (existingCall) {
-            await this.raiseDuplicateCallInvariantViolation({
-                dialog,
-                kind: 'func_call',
-                callId: id,
-                callName: name,
-                incomingCourse: course,
-                incomingGenseq: genseq,
-                existingCourse: existingCall.course,
-                existingGenseq: existingCall.record.genseq,
-                existingName: existingCall.record.name,
-            });
-        }
-        const funcCallEvent = buildFuncCallRecord({ id, name, rawArgumentsText, genseq });
+        const normalizedRawId = typeof rawId === 'string' && rawId.trim() !== '' ? rawId : id;
+        const funcCallEvent = buildFuncCallRecord({
+            rawId: normalizedRawId,
+            effectiveId: id,
+            id,
+            name,
+            rawArgumentsText,
+            genseq,
+        });
         await this.appendEvent(dialog, course, funcCallEvent);
         const funcCallEvt = {
             type: 'func_call_requested_evt',
             funcId: id,
+            rawFuncId: normalizedRawId,
+            effectiveFuncId: id,
             funcName: name,
             arguments: rawArgumentsText,
             course,
@@ -2799,7 +2764,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         if (!Number.isFinite(genseq) || genseq <= 0) {
             throw new Error(`persistTellaskCall invariant violation: missing valid genseq for tellask call ${id}`);
         }
-        const existingCall = await this.findExistingCallRecord(dialog, id);
+        const existingCall = await this.findExistingTellaskCallRecord(dialog, course, id);
         if (existingCall) {
             await this.raiseDuplicateCallInvariantViolation({
                 dialog,
@@ -2808,9 +2773,9 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 callName: name,
                 incomingCourse: course,
                 incomingGenseq: genseq,
-                existingCourse: existingCall.course,
-                existingGenseq: existingCall.record.genseq,
-                existingName: existingCall.record.name,
+                existingCourse: course,
+                existingGenseq: existingCall.genseq,
+                existingName: existingCall.name,
             });
         }
         const tellaskCallEvent = buildTellaskCallRecord({
@@ -2826,6 +2791,8 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             const funcCallEvt = {
                 type: 'func_call_requested_evt',
                 funcId: id,
+                rawFuncId: id,
+                effectiveFuncId: id,
                 funcName: name,
                 arguments: formatTellaskCallArguments(tellaskCallEvent),
                 course,
@@ -3373,6 +3340,8 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 const funcCall = {
                     type: 'func_call_requested_evt',
                     funcId: event.id,
+                    rawFuncId: event.rawId,
+                    effectiveFuncId: event.effectiveId ?? event.id,
                     funcName: event.name,
                     arguments: event.rawArgumentsText,
                     course,
@@ -3393,6 +3362,8 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                     const replyCall = {
                         type: 'func_call_requested_evt',
                         funcId: event.id,
+                        rawFuncId: event.id,
+                        effectiveFuncId: event.id,
                         funcName: event.name,
                         arguments: formatTellaskCallArguments(event),
                         course,
@@ -3598,6 +3569,8 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 const funcResult = {
                     type: 'func_result_evt',
                     id: event.id,
+                    rawId: event.rawId,
+                    effectiveId: event.effectiveId ?? event.id,
                     name: event.name,
                     content: event.content,
                     contentItems: event.contentItems,
@@ -6894,6 +6867,8 @@ class DialogPersistence {
                         role: 'assistant',
                         genseq: event.genseq,
                         id: event.id,
+                        ...(event.rawId !== undefined ? { rawId: event.rawId } : {}),
+                        ...(event.effectiveId !== undefined ? { effectiveId: event.effectiveId } : {}),
                         name: event.name,
                         arguments: event.rawArgumentsText,
                     });
@@ -6933,6 +6908,8 @@ class DialogPersistence {
                         role: 'tool',
                         genseq: event.genseq,
                         id: event.id,
+                        ...(event.rawId !== undefined ? { rawId: event.rawId } : {}),
+                        ...(event.effectiveId !== undefined ? { effectiveId: event.effectiveId } : {}),
                         name: event.name,
                         content: event.content,
                         contentItems: event.contentItems,

package/dist/problems.js

@@ -207,9 +207,10 @@ function getProblemPath(problem) {
         case 'mcp_tool_blacklisted':
         case 'mcp_tool_not_whitelisted':
         case 'mcp_tool_invalid_name':
-        case 'llm_provider_rejected_request':
         case 'generic_problem':
             return null;
+        case 'llm_provider_rejected_request':
+            return problem.detail.requestPayloadPath ?? problem.detail.debugPath ?? null;
     }
 }
 function normalizeComparablePath(raw) {

package/dist/runtime/driver-messages.js

@@ -407,7 +407,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
                 '',
                 '操作：',
                 '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
-                '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并时，才更新：change_mind({ ... })',
+                '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并并带上 `previous_content_hash` 时，才更新：change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})',
                 '- 优先新增过桥提醒项：add_reminder({ "content": "..." })',
                 '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
             ].join('\n');
@@ -443,7 +443,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '',
             '操作：',
             '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
-            '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并时，才更新：change_mind({ ... })',
+            '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并并带上 `previous_content_hash` 时，才更新：change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})',
             '- 优先新增过桥提醒项：add_reminder({ "content": "..." })',
             '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
             '- clear_mind({})',
@@ -484,7 +484,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '',
             'Operations:',
             '- Prefer creating a new Taskdoc section for discussion details: do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
-            '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content: change_mind({ ... })',
+            '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content and can provide `previous_content_hash`: change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})',
             '- Prefer adding a bridge reminder first: add_reminder({ "content": "..." })',
             '- Only if an existing reminder is clearly the right place, and updating it would not add extra cognitive load in the current course: update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
         ].join('\n');
@@ -520,7 +520,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
         '',
         'Operations:',
         '- Prefer creating a new Taskdoc section for discussion details: do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
-        '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content: change_mind({ ... })',
+        '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content and can provide `previous_content_hash`: change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})',
         '- Prefer adding a bridge reminder first: add_reminder({ "content": "..." })',
         '- Only if an existing reminder is clearly the right place, and updating it would not add extra cognitive load in the current course: update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
         '- clear_mind({})',

package/dist/server/websocket-handler.js

@@ -717,11 +717,13 @@ async function maybeTriggerImmediateDiligencePrompt(mainDialog) {
             patch: { diligencePushRemainingBudget: mainDialog.diligencePushRemainingBudget },
         }));
         if (prepared.kind !== 'disabled') {
+            const maxInjectCount = Math.max(0, Math.floor(prepared.maxInjectCount));
+            const remainingCount = Math.max(0, Math.floor(prepared.nextRemainingBudget));
             (0, evt_registry_1.postDialogEvent)(mainDialog, {
                 type: 'diligence_budget_evt',
-                maxInjectCount: prepared.maxInjectCount,
-                injectedCount: Math.max(0, prepared.maxInjectCount - prepared.nextRemainingBudget),
-                remainingCount: Math.max(0, prepared.nextRemainingBudget),
+                maxInjectCount,
+                injectedCount: maxInjectCount > 0 ? Math.max(0, maxInjectCount - remainingCount) : 0,
+                remainingCount,
                 disableDiligencePush: mainDialog.disableDiligencePush,
             });
         }
@@ -730,6 +732,18 @@ async function maybeTriggerImmediateDiligencePrompt(mainDialog) {
                 source: 'ws_diligence_push',
                 reason: 'enable_keep_going_immediate_prompt',
             });
+            return;
+        }
+        if (prepared.kind === 'budget_exhausted') {
+            await (0, runtime_2.suspendForKeepGoingBudgetExhausted)({
+                dlg: mainDialog,
+                maxInjectCount: prepared.maxInjectCount,
+            });
+            mainDialog.diligencePushRemainingBudget = 0;
+            await persistence_1.DialogPersistence.mutateDialogLatest(mainDialog.id, () => ({
+                kind: 'patch',
+                patch: { diligencePushRemainingBudget: mainDialog.diligencePushRemainingBudget },
+            }));
         }
     }
     catch (error) {

package/dist/team.d.ts

@@ -55,6 +55,7 @@ export declare namespace Team {
         web_search_allowed_domains?: string[];
         web_search_include_sources?: boolean;
     };
+    type OpenAiCompatibleThinkingMode = 'auto' | 'off' | 'low' | 'medium' | 'high';
     type OpenAiCompatibleModelParams = {
         temperature?: number;
         service_tier?: 'auto' | 'default' | 'flex' | 'scale' | 'priority';
@@ -66,7 +67,7 @@ export declare namespace Team {
         text_format_json_schema?: string;
         text_format_json_schema_strict?: boolean;
         reasoning_effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
-        thinking?: boolean | Record<string, unknown>;
+        thinking?: boolean | OpenAiCompatibleThinkingMode | Record<string, unknown>;
     };
     type AnthropicThinkingConfig = {
         type: 'adaptive';

package/dist/team.js

@@ -2322,7 +2322,17 @@ exports.Team = Team;
             asOptionalString(params.text_format_json_schema_name, `${at2}.text_format_json_schema_name`);
             asOptionalString(params.text_format_json_schema, `${at2}.text_format_json_schema`);
             asOptionalBoolean(params.text_format_json_schema_strict, `${at2}.text_format_json_schema_strict`);
-            validateOptionalBooleanOrObject(params.thinking, `${at2}.thinking`);
+            const thinking = params.thinking;
+            if (thinking !== undefined &&
+                typeof thinking !== 'boolean' &&
+                !isRecordValue(thinking) &&
+                thinking !== 'auto' &&
+                thinking !== 'off' &&
+                thinking !== 'low' &&
+                thinking !== 'medium' &&
+                thinking !== 'high') {
+                throw new Error(`Invalid ${at2}.thinking: expected boolean|object|auto|off|low|medium|high (got ${describeValueType(thinking)})`);
+            }
             const serviceTier = params.service_tier;
             if (serviceTier !== undefined &&
                 serviceTier !== 'auto' &&