dominds 1.4.2 → 1.5.2

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

@@ -9,6 +9,7 @@ const dialog_instance_registry_1 = require("../../dialog-instance-registry");
 const log_1 = require("../../log");
 const persistence_1 = require("../../persistence");
 const runtime_language_1 = require("../../shared/runtime-language");
+const storage_1 = require("../../shared/types/storage");
 const inter_dialog_format_1 = require("../../shared/utils/inter-dialog-format");
 const time_1 = require("../../shared/utils/time");
 const pending_tellask_reminder_1 = require("../../tools/pending-tellask-reminder");
@@ -235,7 +236,14 @@ async function supplyResponseToSupdialog(args) {
                 (!Array.isArray(mentionList) || mentionList.length < 1)) {
                 mentionList = [`@${responderId}`];
             }
-            await persistence_1.DialogPersistence.savePendingSubdialogs(parentDialog.id, filteredPending, parentDialog.status);
+            await persistence_1.DialogPersistence.savePendingSubdialogs(parentDialog.id, filteredPending, (0, storage_1.toRootGenerationAnchor)({
+                rootCourse: parentDialog instanceof dialog_1.SubDialog
+                    ? parentDialog.rootDialog.currentCourse
+                    : parentDialog.currentCourse,
+                rootGenseq: parentDialog instanceof dialog_1.SubDialog
+                    ? (parentDialog.rootDialog.activeGenSeqOrUndefined ?? 0)
+                    : (parentDialog.activeGenSeqOrUndefined ?? 0),
+            }), parentDialog.status);
             const hasQ4H = await parentDialog.hasPendingQ4H();
             const shouldRevive = !hasQ4H && filteredPending.length === 0;
             if (shouldRevive && parentDialog instanceof dialog_1.RootDialog) {
@@ -250,12 +258,7 @@ async function supplyResponseToSupdialog(args) {
                 originMemberId,
                 sessionSlug,
                 callId: pendingRecord?.callId,
-                callingCourse: pendingRecord &&
-                    typeof pendingRecord.callingCourse === 'number' &&
-                    Number.isFinite(pendingRecord.callingCourse) &&
-                    pendingRecord.callingCourse > 0
-                    ? Math.floor(pendingRecord.callingCourse)
-                    : undefined,
+                callingCourse: pendingRecord?.callingCourse,
                 shouldRevive,
             };
         });
@@ -307,10 +310,14 @@ async function supplyResponseToSupdialog(args) {
                 anchorRole: 'response',
                 callId: resolvedCallId,
                 genseq: calleeResponseRef.genseq,
-                assignmentCourse: assignmentRef?.course,
-                assignmentGenseq: assignmentRef?.genseq,
+                assignmentCourse: assignmentRef !== undefined ? (0, storage_1.toAssignmentCourseNumber)(assignmentRef.course) : undefined,
+                assignmentGenseq: assignmentRef !== undefined
+                    ? (0, storage_1.toAssignmentGenerationSeqNumber)(assignmentRef.genseq)
+                    : undefined,
                 callerDialogId: parentDialog.id.selfId,
-                callerCourse: result.callingCourse,
+                callerCourse: result.callingCourse !== undefined
+                    ? (0, storage_1.toCallerCourseNumber)(result.callingCourse)
+                    : undefined,
             };
             await persistence_1.DialogPersistence.appendEvent(subdialogId, calleeResponseRef.course, anchorRecord, parentDialog.status);
         }
@@ -321,8 +328,12 @@ async function supplyResponseToSupdialog(args) {
             callId: resolvedCallId,
             originMemberId: requesterId,
             sessionSlug: result.sessionSlug,
-            calleeCourse: calleeResponseRef?.course,
-            calleeGenseq: calleeResponseRef?.genseq,
+            calleeCourse: calleeResponseRef !== undefined
+                ? (0, storage_1.toCalleeCourseNumber)(calleeResponseRef.course)
+                : undefined,
+            calleeGenseq: calleeResponseRef !== undefined
+                ? (0, storage_1.toCalleeGenerationSeqNumber)(calleeResponseRef.genseq)
+                : undefined,
         });
         const immediateMirror = {
             type: 'tellask_result_msg',

package/dist/llm/kernel-driver/tellask-special.js

@@ -10,6 +10,7 @@ const log_1 = require("../../log");
 const persistence_1 = require("../../persistence");
 const driver_messages_1 = require("../../shared/i18n/driver-messages");
 const runtime_language_1 = require("../../shared/runtime-language");
+const storage_1 = require("../../shared/types/storage");
 const fbr_1 = require("../../shared/utils/fbr");
 const id_1 = require("../../shared/utils/id");
 const inter_dialog_format_1 = require("../../shared/utils/inter-dialog-format");
@@ -439,7 +440,7 @@ async function executeTellaskCall(dlg, agent, mentionList, body, callId, callbac
         const subdialogCallName = callName === 'tellaskBack' ? 'freshBootsReasoning' : callName;
         const rawCallingCourse = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
         const callingCourse = Number.isFinite(rawCallingCourse) && rawCallingCourse > 0
-            ? Math.floor(rawCallingCourse)
+            ? (0, storage_1.toCallingCourseNumber)(rawCallingCourse)
             : undefined;
         const firstMentionForError = options.targetForError ?? parseResult.agentId;
         if (parseResult.type !== 'A' && member === null) {
@@ -562,7 +563,12 @@ async function executeTellaskCall(dlg, agent, mentionList, body, callId, callbac
                         callType: 'C',
                     };
                     await (0, subdialog_txn_1.withSubdialogTxnLock)(dlg.id, async () => {
-                        await persistence_1.DialogPersistence.appendPendingSubdialog(dlg.id, pendingRecord);
+                        await persistence_1.DialogPersistence.appendPendingSubdialog(dlg.id, pendingRecord, (0, storage_1.toRootGenerationAnchor)({
+                            rootCourse: dlg instanceof dialog_1.SubDialog ? dlg.rootDialog.currentCourse : dlg.currentCourse,
+                            rootGenseq: dlg instanceof dialog_1.SubDialog
+                                ? (dlg.rootDialog.activeGenSeqOrUndefined ?? 0)
+                                : (dlg.activeGenSeqOrUndefined ?? 0),
+                        }));
                     });
                     await syncPendingTellaskReminderBestEffort(dlg, 'kernel-driver:executeTellaskCall:FBR-TypeC:appendPending:lastRound');
                 }
@@ -785,7 +791,12 @@ async function executeTellaskCall(dlg, agent, mentionList, body, callId, callbac
                         sessionSlug: parseResult.sessionSlug,
                     };
                     await (0, subdialog_txn_1.withSubdialogTxnLock)(dlg.id, async () => {
-                        await persistence_1.DialogPersistence.appendPendingSubdialog(dlg.id, pendingRecord);
+                        await persistence_1.DialogPersistence.appendPendingSubdialog(dlg.id, pendingRecord, (0, storage_1.toRootGenerationAnchor)({
+                            rootCourse: dlg instanceof dialog_1.SubDialog ? dlg.rootDialog.currentCourse : dlg.currentCourse,
+                            rootGenseq: dlg instanceof dialog_1.SubDialog
+                                ? (dlg.rootDialog.activeGenSeqOrUndefined ?? 0)
+                                : (dlg.activeGenSeqOrUndefined ?? 0),
+                        }));
                     });
                     await syncPendingTellaskReminderBestEffort(dlg, 'kernel-driver:executeTellaskCall:TypeB-fallback:appendPending');
                     const initPrompt = {
@@ -962,7 +973,12 @@ async function executeTellaskCall(dlg, agent, mentionList, body, callId, callbac
                     callType: 'C',
                 };
                 await (0, subdialog_txn_1.withSubdialogTxnLock)(dlg.id, async () => {
-                    await persistence_1.DialogPersistence.appendPendingSubdialog(dlg.id, pendingRecord);
+                    await persistence_1.DialogPersistence.appendPendingSubdialog(dlg.id, pendingRecord, (0, storage_1.toRootGenerationAnchor)({
+                        rootCourse: dlg instanceof dialog_1.SubDialog ? dlg.rootDialog.currentCourse : dlg.currentCourse,
+                        rootGenseq: dlg instanceof dialog_1.SubDialog
+                            ? (dlg.rootDialog.activeGenSeqOrUndefined ?? 0)
+                            : (dlg.activeGenSeqOrUndefined ?? 0),
+                    }));
                 });
                 await syncPendingTellaskReminderBestEffort(dlg, 'kernel-driver:executeTellaskCall:TypeC:appendPending');
                 const initPrompt = {

package/dist/minds/load.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadAgentMinds = loadAgentMinds;
 const promises_1 = require("fs/promises");
 const path_1 = __importDefault(require("path"));
+const runtime_1 = require("../apps/runtime");
 const dialog_1 = require("../dialog");
 const log_1 = require("../log");
 const runtime_language_1 = require("../shared/runtime-language");
@@ -106,6 +107,12 @@ async function readMindsTextPreferred(options) {
 async function loadAgentMinds(agentId, dialog, options) {
     const workingLanguage = (0, runtime_language_1.getWorkLanguage)();
     const missingToolsetPolicy = options?.missingToolsetPolicy ?? 'warn';
+    try {
+        await (0, runtime_1.registerEnabledAppsToolProxies)({ rtwsRootAbs: process.cwd() });
+    }
+    catch (error) {
+        log_1.log.warn(`Failed to refresh enabled app tool proxies before loading agent minds: ${error instanceof Error ? error.message : String(error)}`);
+    }
     let team = await team_1.Team.load();
     const agent = agentId === undefined ? team.getDefaultResponder() : team.getMember(agentId);
     if (!agent)

package/dist/persistence.js

@@ -48,6 +48,7 @@ const dialog_1 = require("./dialog");
 const evt_registry_1 = require("./evt-registry");
 const log_1 = require("./log");
 const async_fifo_mutex_1 = require("./shared/async-fifo-mutex");
+const storage_1 = require("./shared/types/storage");
 const time_1 = require("./shared/utils/time");
 const registry_1 = require("./tools/registry");
 function getErrorCode(error) {
@@ -59,6 +60,67 @@ function getErrorCode(error) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
+function serializeReminderSnapshot(reminder) {
+    const persistedReminder = reminder;
+    return {
+        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',
+    };
+}
+function cloneReminderSnapshot(snapshot) {
+    return {
+        content: snapshot.content,
+        ownerName: snapshot.ownerName,
+        meta: snapshot.meta,
+        echoback: snapshot.echoback,
+        createdAt: snapshot.createdAt,
+        priority: snapshot.priority,
+    };
+}
+function cloneRootGenerationAnchor(anchor) {
+    return {
+        rootCourse: anchor.rootCourse,
+        rootGenseq: anchor.rootGenseq,
+    };
+}
+function resolveRootGenerationAnchor(dialog) {
+    const rootDialog = dialog instanceof dialog_1.SubDialog ? dialog.rootDialog : dialog;
+    return (0, storage_1.toRootGenerationAnchor)({
+        rootCourse: rootDialog.currentCourse,
+        rootGenseq: rootDialog.activeGenSeqOrUndefined ?? 0,
+    });
+}
+function resolveReconciledRecordWriteTarget(dialog) {
+    return {
+        kind: 'dialog_course',
+        rootAnchor: resolveRootGenerationAnchor(dialog),
+        dialogCourse: (0, storage_1.toDialogCourseNumber)(dialog.activeGenCourseOrUndefined ?? dialog.currentCourse),
+    };
+}
+function rootAnchorWriteTarget(rootAnchor) {
+    return {
+        kind: 'root_anchor',
+        rootAnchor,
+    };
+}
+function resolveTargetCourseFromWriteTarget(writeTarget) {
+    if (writeTarget.kind === 'dialog_course') {
+        return writeTarget.dialogCourse;
+    }
+    return writeTarget.rootAnchor.rootCourse;
+}
+function attachRootGenerationRef(dialog, record) {
+    const anchor = resolveRootGenerationAnchor(dialog);
+    return {
+        ...record,
+        rootCourse: anchor.rootCourse,
+        rootGenseq: anchor.rootGenseq,
+    };
+}
 function isRootDialogMetadataFile(value) {
     if (!isRecord(value))
         return false;
@@ -459,6 +521,29 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         };
         await DialogPersistence.saveSubdialogMetadata(subdialogId, metadata);
         await DialogPersistence.saveDialogMetadata(subdialogId, metadata);
+        const rootAnchor = resolveRootGenerationAnchor(supdialog);
+        const parentCourse = supdialog.activeGenCourseOrUndefined ?? supdialog.currentCourse;
+        const subdialogCreatedRecord = {
+            ts: nowTs,
+            type: 'subdialog_created_record',
+            ...cloneRootGenerationAnchor(rootAnchor),
+            subdialogId: subdialogId.selfId,
+            supdialogId: supdialog.id.selfId,
+            agentId: targetAgentId,
+            taskDocPath: supdialog.taskDocPath,
+            createdAt: nowTs,
+            sessionSlug: options.sessionSlug,
+            assignmentFromSup: {
+                callName: options.callName,
+                mentionList,
+                tellaskContent,
+                originMemberId: options.originMemberId,
+                callerDialogId: options.callerDialogId,
+                callId: options.callId,
+                collectiveTargets: options.collectiveTargets,
+            },
+        };
+        await this.appendEvent(supdialog, parentCourse, subdialogCreatedRecord);
         // Initialize latest.yaml via the mutation API (write-back will flush).
         await DialogPersistence.mutateDialogLatest(subdialogId, () => ({
             kind: 'replace',
@@ -474,7 +559,6 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             },
         }));
         // Supdialog clarification context is persisted in subdialog metadata (supdialogCall)
-        const parentCourse = await DialogPersistence.getCurrentCourseNumber(supdialog.id);
         const subdialogCreatedEvt = {
             type: 'subdialog_created_evt',
             dialog: {
@@ -537,7 +621,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             contentItems: funcResult.contentItems,
             genseq: dialog.activeGenSeq,
         };
-        await this.appendEvent(course, funcResultRecord);
+        await this.appendEvent(dialog, course, funcResultRecord);
         // Send event to frontend
         const funcResultEvt = {
             type: 'func_result_evt',
@@ -573,7 +657,9 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      */
     async receiveTeammateCallResult(dialog, responderId, callName, mentionList, tellaskContent, result, status, callId) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
-        const calling_genseq = dialog.activeGenSeqOrUndefined;
+        const calling_genseq = dialog.activeGenSeqOrUndefined !== undefined
+            ? (0, storage_1.toCallingGenerationSeqNumber)(dialog.activeGenSeqOrUndefined)
+            : undefined;
         // Persist record WITH callId for replay correlation
         const ev = (() => {
             switch (callName) {
@@ -607,7 +693,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                     };
             }
         })();
-        await this.appendEvent(course, ev);
+        await this.appendEvent(dialog, course, ev);
         // Emit TeammateCallResponseEvent WITH callId for UI correlation
         const toolResponseEvt = (() => {
             switch (callName) {
@@ -661,7 +747,9 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      */
     async receiveTeammateResponse(dialog, responderId, callName, mentionList, tellaskContent, status, calleeDialogId, options) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
-        const calling_genseq = dialog.activeGenSeqOrUndefined;
+        const calling_genseq = dialog.activeGenSeqOrUndefined !== undefined
+            ? (0, storage_1.toCallingGenerationSeqNumber)(dialog.activeGenSeqOrUndefined)
+            : undefined;
         const calleeDialogSelfId = calleeDialogId ? calleeDialogId.selfId : undefined;
         const response = options.response;
         const agentId = options.agentId;
@@ -736,7 +824,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                     };
             }
         })();
-        await this.appendEvent(course, ev);
+        await this.appendEvent(dialog, course, ev);
         const teammateResponseEvt = (() => {
             switch (callName) {
                 case 'tellask':
@@ -811,8 +899,8 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
     /**
      * Append event to course JSONL file (delegate to DialogPersistence)
      */
-    async appendEvent(course, event) {
-        await DialogPersistence.appendEvent(this.dialogId, course, event);
+    async appendEvent(dialog, course, event) {
+        await DialogPersistence.appendEvent(this.dialogId, course, attachRootGenerationRef(dialog, event));
     }
     /**
      * Notify start of LLM generation for frontend bubble management
@@ -828,7 +916,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 type: 'gen_start_record',
                 genseq: genseq,
             };
-            await this.appendEvent(course, ev);
+            await this.appendEvent(dialog, course, ev);
             // Emit generating_start_evt event
             // This event MUST be emitted and processed before any substream events
             // to ensure the frontend has created the generation bubble before receiving
@@ -867,7 +955,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 contextHealth,
                 llmGenModel,
             };
-            await this.appendEvent(course, ev);
+            await this.appendEvent(dialog, course, ev);
             // Emit generating_finish_evt event (this was missing, causing double triggering issue)
             const genFinishEvt = {
                 type: 'generating_finish_evt',
@@ -929,7 +1017,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 genseq: dialog.activeGenSeq,
                 content: sayingContent,
             };
-            await this.appendEvent(course, sayingMessageEvent);
+            await this.appendEvent(dialog, course, sayingMessageEvent);
         }
         const evt = {
             type: 'markdown_finish_evt',
@@ -976,7 +1064,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 content: thinkingContent,
                 reasoning: this.thinkingReasoning,
             };
-            await this.appendEvent(course, thinkingMessageEvent);
+            await this.appendEvent(dialog, course, thinkingMessageEvent);
         }
         const thinkingFinishEvt = {
             type: 'thinking_finish_evt',
@@ -1086,7 +1174,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             status: payload.status,
             action: payload.action,
         };
-        await this.appendEvent(course, record);
+        await this.appendEvent(dialog, course, record);
         const evt = {
             type: 'web_search_call_evt',
             course,
@@ -1142,6 +1230,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      */
     async persistReminders(dialog, reminders) {
         await DialogPersistence._saveReminderState(this.dialogId, reminders);
+        await DialogPersistence.appendRemindersReconciledRecord(this.dialogId, reminders, resolveReconciledRecordWriteTarget(dialog), dialog.status);
     }
     /**
      * Persist a user message to storage
@@ -1178,7 +1267,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             userLanguageCode,
             q4hAnswerCallIds: normalizedQ4HAnswerCallIds,
         };
-        await this.appendEvent(course, humanEv);
+        await this.appendEvent(dialog, course, humanEv);
         // Note: end_of_user_saying_evt is now emitted by llm/driver.ts after tellask calls complete
     }
     /**
@@ -1201,7 +1290,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 genseq,
                 content: content || '',
             };
-        await this.appendEvent(course, event);
+        await this.appendEvent(dialog, course, event);
     }
     async persistUiOnlyMarkdown(dialog, content, genseq) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
@@ -1211,7 +1300,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             genseq,
             content: content || '',
         };
-        await this.appendEvent(course, ev);
+        await this.appendEvent(dialog, course, ev);
     }
     /**
      * Persist a function call to storage
@@ -1226,7 +1315,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             name,
             arguments: arguments_,
         };
-        await this.appendEvent(course, funcCallEvent);
+        await this.appendEvent(dialog, course, funcCallEvent);
         // NOTE: func_call_evt REMOVED - persistence uses FuncCallRecord directly
         // UI display uses func_call_requested_evt instead
     }
@@ -1235,6 +1324,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      */
     async updateQuestions4Human(dialog, questions) {
         await DialogPersistence._saveQuestions4HumanState(this.dialogId, questions);
+        await DialogPersistence.appendQuestions4HumanReconciledRecord(this.dialogId, questions, resolveReconciledRecordWriteTarget(dialog), dialog.status);
     }
     /**
      * Load Questions for Human state from storage
@@ -1259,8 +1349,14 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             sessionSlug: record.sessionSlug,
         }));
     }
-    async saveSubdialogRegistry(rootDialogId, entries, status) {
+    async saveSubdialogRegistry(dialog, rootDialogId, entries, status) {
         await DialogPersistence.saveSubdialogRegistry(rootDialogId, entries, status);
+        await DialogPersistence.appendSubdialogRegistryReconciledRecord(rootDialogId, entries.map((entry) => ({
+            key: entry.key,
+            subdialogId: entry.subdialogId.selfId,
+            agentId: entry.agentId,
+            sessionSlug: entry.sessionSlug,
+        })), resolveReconciledRecordWriteTarget(dialog), status);
     }
     async loadSubdialogRegistry(rootDialog, status) {
         const entries = await DialogPersistence.loadSubdialogRegistry(rootDialog.id, status);
@@ -1405,6 +1501,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         const previousCount = previousQuestions.length;
         if (previousCount > 0) {
             await DialogPersistence.clearQuestions4HumanState(dialog.id);
+            await DialogPersistence.appendQuestions4HumanReconciledRecord(dialog.id, [], resolveReconciledRecordWriteTarget(dialog), dialog.status);
             // Emit q4h_answered events for each removed question
             for (const q of previousQuestions) {
                 const answeredEvent = {
@@ -1961,6 +2058,13 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 }
                 break;
             }
+            case 'subdialog_created_record':
+            case 'reminders_reconciled_record':
+            case 'questions4human_reconciled_record':
+            case 'pending_subdialogs_reconciled_record':
+            case 'subdialog_registry_reconciled_record':
+            case 'subdialog_responses_reconciled_record':
+                break;
             case 'teammate_response_record': {
                 // Handle teammate response events (separate bubble for @teammate tellasks)
                 const mentionList = (() => {
@@ -2134,6 +2238,75 @@ class DialogPersistence {
     static getPendingSubdialogsWriteBackKey(rootDialogId, status) {
         return `${this.getDialogsRootDir()}|${status}|${rootDialogId.valueOf()}|pending-subdialogs`;
     }
+    static clonePendingSubdialogRecords(records) {
+        return records.map((record) => ({
+            ...record,
+            mentionList: record.mentionList ? [...record.mentionList] : undefined,
+        }));
+    }
+    static cloneQuestions4Human(questions) {
+        return questions.map((question) => ({
+            ...question,
+            remainingCallIds: question.remainingCallIds ? [...question.remainingCallIds] : undefined,
+            callSiteRef: { ...question.callSiteRef },
+        }));
+    }
+    static cloneRegistryEntries(entries) {
+        return entries.map((entry) => ({
+            ...entry,
+        }));
+    }
+    static cloneSubdialogResponses(responses) {
+        return responses.map((response) => ({
+            ...response,
+            mentionList: response.mentionList ? [...response.mentionList] : undefined,
+        }));
+    }
+    static async appendRemindersReconciledRecord(dialogId, reminders, writeTarget, status) {
+        const record = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'reminders_reconciled_record',
+            ...cloneRootGenerationAnchor(writeTarget.rootAnchor),
+            reminders: reminders.map((reminder) => serializeReminderSnapshot(reminder)),
+        };
+        await this.appendEvent(dialogId, resolveTargetCourseFromWriteTarget(writeTarget), record, status);
+    }
+    static async appendQuestions4HumanReconciledRecord(dialogId, questions, writeTarget, status) {
+        const record = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'questions4human_reconciled_record',
+            ...cloneRootGenerationAnchor(writeTarget.rootAnchor),
+            questions: this.cloneQuestions4Human(questions),
+        };
+        await this.appendEvent(dialogId, resolveTargetCourseFromWriteTarget(writeTarget), record, status);
+    }
+    static async appendPendingSubdialogsReconciledRecord(dialogId, pendingSubdialogs, writeTarget, status) {
+        const record = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'pending_subdialogs_reconciled_record',
+            ...cloneRootGenerationAnchor(writeTarget.rootAnchor),
+            pendingSubdialogs: this.clonePendingSubdialogRecords(pendingSubdialogs),
+        };
+        await this.appendEvent(dialogId, resolveTargetCourseFromWriteTarget(writeTarget), record, status);
+    }
+    static async appendSubdialogRegistryReconciledRecord(dialogId, entries, writeTarget, status) {
+        const record = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'subdialog_registry_reconciled_record',
+            ...cloneRootGenerationAnchor(writeTarget.rootAnchor),
+            entries: this.cloneRegistryEntries(entries),
+        };
+        await this.appendEvent(dialogId, resolveTargetCourseFromWriteTarget(writeTarget), record, status);
+    }
+    static async appendSubdialogResponsesReconciledRecord(dialogId, responses, writeTarget, status) {
+        const record = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'subdialog_responses_reconciled_record',
+            ...cloneRootGenerationAnchor(writeTarget.rootAnchor),
+            responses: this.cloneSubdialogResponses(responses),
+        };
+        await this.appendEvent(dialogId, resolveTargetCourseFromWriteTarget(writeTarget), record, status);
+    }
     /**
      * Get the base dialogs directory path
      */
@@ -3091,9 +3264,9 @@ class DialogPersistence {
      * Save pending subdialogs for Type A supply mechanism.
      * Tracks subdialogs that were created but not yet completed.
      */
-    static async savePendingSubdialogs(rootDialogId, pendingSubdialogs, status = 'running') {
+    static async savePendingSubdialogs(rootDialogId, pendingSubdialogs, rootAnchor, status = 'running') {
         const next = pendingSubdialogs.map((r) => ({ ...r }));
-        await this.mutatePendingSubdialogs(rootDialogId, () => ({ kind: 'replace', records: next }), status);
+        await this.mutatePendingSubdialogs(rootDialogId, () => ({ kind: 'replace', records: next }), rootAnchor, status);
     }
     /**
      * Load pending subdialogs for Type A supply mechanism.
@@ -3181,7 +3354,7 @@ class DialogPersistence {
             throw error;
         }
     }
-    static async mutatePendingSubdialogs(rootDialogId, mutator, status = 'running') {
+    static async mutatePendingSubdialogs(rootDialogId, mutator, rootAnchor, status = 'running') {
         const key = this.getPendingSubdialogsWriteBackKey(rootDialogId, status);
         const mutex = this.getPendingSubdialogsWriteBackMutex(key);
         const release = await mutex.acquire();
@@ -3246,20 +3419,23 @@ class DialogPersistence {
                 if (pending.kind === 'flushing')
                     pending.dirty = true;
             }
+            if (rootAnchor) {
+                await this.appendPendingSubdialogsReconciledRecord(rootDialogId, nextRecords, rootAnchorWriteTarget(rootAnchor), status);
+            }
             return { previousRecords, records: nextRecords, removedRecords };
         }
         finally {
             release();
         }
     }
-    static async appendPendingSubdialog(rootDialogId, record, status = 'running') {
-        await this.mutatePendingSubdialogs(rootDialogId, () => ({ kind: 'append', record }), status);
+    static async appendPendingSubdialog(rootDialogId, record, rootAnchor, status = 'running') {
+        await this.mutatePendingSubdialogs(rootDialogId, () => ({ kind: 'append', record }), rootAnchor, status);
     }
-    static async removePendingSubdialog(rootDialogId, subdialogId, status = 'running') {
-        await this.mutatePendingSubdialogs(rootDialogId, () => ({ kind: 'removeBySubdialogId', subdialogId }), status);
+    static async removePendingSubdialog(rootDialogId, subdialogId, rootAnchor, status = 'running') {
+        await this.mutatePendingSubdialogs(rootDialogId, () => ({ kind: 'removeBySubdialogId', subdialogId }), rootAnchor, status);
     }
-    static async clearPendingSubdialogs(rootDialogId, status = 'running') {
-        await this.mutatePendingSubdialogs(rootDialogId, () => ({ kind: 'clear' }), status);
+    static async clearPendingSubdialogs(rootDialogId, rootAnchor, status = 'running') {
+        await this.mutatePendingSubdialogs(rootDialogId, () => ({ kind: 'clear' }), rootAnchor, status);
     }
     static async flushPendingSubdialogsWriteBack(key) {
         const mutex = this.getPendingSubdialogsWriteBackMutex(key);
@@ -3388,7 +3564,7 @@ class DialogPersistence {
      * Save subdialog responses for Type A supply mechanism.
      * Tracks responses from completed subdialogs.
      */
-    static async saveSubdialogResponses(rootDialogId, responses, status = 'running') {
+    static async saveSubdialogResponses(rootDialogId, responses, rootAnchor, status = 'running') {
         try {
             const dialogPath = this.getDialogResponsesPath(rootDialogId, status);
             await fs.promises.mkdir(dialogPath, { recursive: true });
@@ -3398,6 +3574,9 @@ class DialogPersistence {
             const tempFile = path.join(dialogPath, `.${path.basename(filePath)}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
             await fs.promises.writeFile(tempFile, jsonContent, 'utf-8');
             await this.renameWithRetry(tempFile, filePath, jsonContent);
+            if (rootAnchor) {
+                await this.appendSubdialogResponsesReconciledRecord(rootDialogId, responses, rootAnchorWriteTarget(rootAnchor), status);
+            }
         }
         catch (error) {
             log_1.log.error(`Failed to save subdialog responses for dialog ${rootDialogId}:`, error);
@@ -3471,10 +3650,10 @@ class DialogPersistence {
             throw error;
         }
     }
-    static async appendSubdialogResponse(dialogId, response, status = 'running') {
+    static async appendSubdialogResponse(dialogId, response, rootAnchor, status = 'running') {
         const existing = await this.loadSubdialogResponsesQueue(dialogId, status);
         existing.push(response);
-        await this.saveSubdialogResponses(dialogId, existing, status);
+        await this.saveSubdialogResponses(dialogId, existing, rootAnchor, status);
     }
     static async takeSubdialogResponses(dialogId, status = 'running') {
         const dialogPath = this.getDialogResponsesPath(dialogId, status);
@@ -4240,6 +4419,13 @@ class DialogPersistence {
                     // This record is UI navigation metadata for deep links in callee dialogs.
                     // It does not contribute to model context or chat transcript reconstruction.
                     break;
+                case 'subdialog_created_record':
+                case 'reminders_reconciled_record':
+                case 'questions4human_reconciled_record':
+                case 'pending_subdialogs_reconciled_record':
+                case 'subdialog_registry_reconciled_record':
+                case 'subdialog_responses_reconciled_record':
+                    break;
                 default:
                     log_1.log.warn(`Unknown event type in rebuildFromEvents`, undefined, { event });
                     break;