dominds 1.4.2 → 1.5.1

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

@@ -562,7 +562,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, {
+                            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 +790,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, {
+                            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 +972,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, {
+                        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

@@ -59,6 +59,48 @@ 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 {
+        rootCourse: rootDialog.currentCourse,
+        rootGenseq: rootDialog.activeGenSeqOrUndefined ?? 0,
+    };
+}
+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 +501,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 +539,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 +601,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',
@@ -607,7 +671,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) {
@@ -736,7 +800,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 +875,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 +892,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 +931,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 +993,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 +1040,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 +1150,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 +1206,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      */
     async persistReminders(dialog, reminders) {
         await DialogPersistence._saveReminderState(this.dialogId, reminders);
+        await DialogPersistence.appendRemindersReconciledRecord(this.dialogId, reminders, resolveRootGenerationAnchor(dialog), dialog.status);
     }
     /**
      * Persist a user message to storage
@@ -1178,7 +1243,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 +1266,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 +1276,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 +1291,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 +1300,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      */
     async updateQuestions4Human(dialog, questions) {
         await DialogPersistence._saveQuestions4HumanState(this.dialogId, questions);
+        await DialogPersistence.appendQuestions4HumanReconciledRecord(this.dialogId, questions, resolveRootGenerationAnchor(dialog), dialog.status);
     }
     /**
      * Load Questions for Human state from storage
@@ -1259,8 +1325,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,
+        })), resolveRootGenerationAnchor(dialog), status);
     }
     async loadSubdialogRegistry(rootDialog, status) {
         const entries = await DialogPersistence.loadSubdialogRegistry(rootDialog.id, status);
@@ -1405,6 +1477,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         const previousCount = previousQuestions.length;
         if (previousCount > 0) {
             await DialogPersistence.clearQuestions4HumanState(dialog.id);
+            await DialogPersistence.appendQuestions4HumanReconciledRecord(dialog.id, [], resolveRootGenerationAnchor(dialog), dialog.status);
             // Emit q4h_answered events for each removed question
             for (const q of previousQuestions) {
                 const answeredEvent = {
@@ -1961,6 +2034,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 +2214,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, anchor, status) {
+        const record = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'reminders_reconciled_record',
+            ...cloneRootGenerationAnchor(anchor),
+            reminders: reminders.map((reminder) => serializeReminderSnapshot(reminder)),
+        };
+        await this.appendEvent(dialogId, anchor.rootCourse, record, status);
+    }
+    static async appendQuestions4HumanReconciledRecord(dialogId, questions, anchor, status) {
+        const record = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'questions4human_reconciled_record',
+            ...cloneRootGenerationAnchor(anchor),
+            questions: this.cloneQuestions4Human(questions),
+        };
+        await this.appendEvent(dialogId, anchor.rootCourse, record, status);
+    }
+    static async appendPendingSubdialogsReconciledRecord(dialogId, pendingSubdialogs, anchor, status) {
+        const record = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'pending_subdialogs_reconciled_record',
+            ...cloneRootGenerationAnchor(anchor),
+            pendingSubdialogs: this.clonePendingSubdialogRecords(pendingSubdialogs),
+        };
+        await this.appendEvent(dialogId, anchor.rootCourse, record, status);
+    }
+    static async appendSubdialogRegistryReconciledRecord(dialogId, entries, anchor, status) {
+        const record = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'subdialog_registry_reconciled_record',
+            ...cloneRootGenerationAnchor(anchor),
+            entries: this.cloneRegistryEntries(entries),
+        };
+        await this.appendEvent(dialogId, anchor.rootCourse, record, status);
+    }
+    static async appendSubdialogResponsesReconciledRecord(dialogId, responses, anchor, status) {
+        const record = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'subdialog_responses_reconciled_record',
+            ...cloneRootGenerationAnchor(anchor),
+            responses: this.cloneSubdialogResponses(responses),
+        };
+        await this.appendEvent(dialogId, anchor.rootCourse, record, status);
+    }
     /**
      * Get the base dialogs directory path
      */
@@ -3091,9 +3240,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 +3330,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 +3395,23 @@ class DialogPersistence {
                 if (pending.kind === 'flushing')
                     pending.dirty = true;
             }
+            if (rootAnchor) {
+                await this.appendPendingSubdialogsReconciledRecord(rootDialogId, nextRecords, 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 +3540,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 +3550,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, rootAnchor, status);
+            }
         }
         catch (error) {
             log_1.log.error(`Failed to save subdialog responses for dialog ${rootDialogId}:`, error);
@@ -3471,10 +3626,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 +4395,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;

package/dist/priming.js

@@ -1656,6 +1656,13 @@ function stripTimestampFromRecord(event) {
             const { ts: _unusedTs, ...withoutTs } = event;
             return withoutTs;
         }
+        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':
+            throw new Error(`Record type ${event.type} is not supported in priming scripts`);
         default: {
             const _exhaustive = event;
             throw new Error(`Unhandled persisted record type: ${String(_exhaustive)}`);
@@ -1663,7 +1670,19 @@ function stripTimestampFromRecord(event) {
     }
 }
 function extractPrimingRecordsFromEvents(events) {
-    return events.map((event) => stripTimestampFromRecord(event));
+    return events.flatMap((event) => {
+        switch (event.type) {
+            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':
+                return [];
+            default:
+                return [stripTimestampFromRecord(event)];
+        }
+    });
 }
 async function saveDialogCourseAsIndividualPrimingScript(args) {
     const normalizedSlug = normalizeSlug(args.slug);

package/dist/server/api-routes.js

@@ -45,7 +45,9 @@ exports.handleApiRoute = handleApiRoute;
  */
 const promises_1 = __importDefault(require("fs/promises"));
 const path = __importStar(require("path"));
+const runtime_1 = require("../apps/runtime");
 const dialog_1 = require("../dialog");
+const dialog_fork_1 = require("../dialog-fork");
 const dialog_global_registry_1 = require("../dialog-global-registry");
 const dialog_run_state_1 = require("../dialog-run-state");
 const log_1 = require("../log");
@@ -1044,9 +1046,21 @@ async function handleApiRoute(req, res, pathname, context) {
         if (pathname === '/api/dialogs/move' && req.method === 'POST') {
             return await handleMoveDialogs(req, res, context);
         }
+        if (pathname.startsWith('/api/dialogs/') &&
+            pathname.endsWith('/fork') &&
+            req.method === 'POST') {
+            const parts = pathname.split('/');
+            const rawRoot = parts[3];
+            if (!rawRoot) {
+                respondJson(res, 400, { success: false, error: 'Missing root dialog id' });
+                return true;
+            }
+            return await handleForkDialog(req, res, context, rawRoot.replace(/%2F/g, '/'));
+        }
         // Delete a dialog (root dialogs only for now)
         if (pathname.startsWith('/api/dialogs/') &&
             !pathname.endsWith('/hierarchy') &&
+            !pathname.endsWith('/fork') &&
             req.method === 'DELETE') {
             const parts = pathname.split('/');
             const rawRoot = parts[3];
@@ -1606,6 +1620,7 @@ async function handleReadWorkspaceEntry(req, res) {
 }
 async function handleGetToolsRegistry(res) {
     try {
+        await (0, runtime_1.registerEnabledAppsToolProxies)({ rtwsRootAbs: process.cwd() });
         const snapshot = (0, registry_snapshot_1.createToolsRegistrySnapshot)();
         res.writeHead(200, {
             'Content-Type': 'application/json',
@@ -1975,6 +1990,73 @@ async function handleCreateDialog(req, res, context) {
         return true;
     }
 }
+async function handleForkDialog(req, res, context, rootIdRaw) {
+    try {
+        const body = await readRequestBody(req);
+        const parsed = JSON.parse(body);
+        if (!isRecord(parsed)) {
+            const payload = { success: false, error: 'Invalid JSON body' };
+            respondJson(res, 400, payload);
+            return true;
+        }
+        const courseRaw = parsed['course'];
+        const genseqRaw = parsed['genseq'];
+        const statusRaw = parsed['status'];
+        const rootId = rootIdRaw.trim();
+        const course = typeof courseRaw === 'number' && Number.isFinite(courseRaw) ? Math.floor(courseRaw) : 0;
+        const genseq = typeof genseqRaw === 'number' && Number.isFinite(genseqRaw) ? Math.floor(genseqRaw) : 0;
+        const status = parseDialogStatusKind(statusRaw) ?? 'running';
+        if (rootId === '') {
+            const payload = { success: false, error: 'rootId is required' };
+            respondJson(res, 400, payload);
+            return true;
+        }
+        if (course <= 0 || genseq <= 0) {
+            const payload = {
+                success: false,
+                error: 'course and genseq must be positive integers',
+            };
+            respondJson(res, 400, payload);
+            return true;
+        }
+        const result = await (0, dialog_fork_1.forkRootDialogTreeAtGeneration)({
+            sourceRootId: rootId,
+            sourceStatus: status,
+            course,
+            genseq,
+        });
+        const payload = {
+            success: true,
+            dialog: {
+                rootId: result.rootId,
+                selfId: result.selfId,
+                agentId: result.agentId,
+                agentName: result.agentId,
+                taskDocPath: result.taskDocPath,
+                status: 'running',
+            },
+            action: result.action,
+        };
+        respondJson(res, 201, payload);
+        broadcastDialogCreates(context.clients, {
+            type: 'dialogs_created',
+            scope: { kind: 'root', rootId: result.rootId },
+            status: 'running',
+            createdRootIds: [result.rootId],
+            timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        });
+        return true;
+    }
+    catch (error) {
+        log.error('Error forking dialog:', error);
+        const payload = {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to fork dialog',
+        };
+        respondJson(res, 500, payload);
+        return true;
+    }
+}
 async function handleMoveDialogs(req, res, context) {
     try {
         const body = await readRequestBody(req);

package/dist/server/setup-routes.js

@@ -371,11 +371,26 @@ function extractProminentEnumModelParams(modelParamOptions) {
             const defaultValue = typeof opt.default === 'string' && opt.values.includes(opt.default)
                 ? opt.default
                 : undefined;
+            const rawValueLabels = opt.value_labels;
+            let valueLabels;
+            if (rawValueLabels && typeof rawValueLabels === 'object' && !Array.isArray(rawValueLabels)) {
+                const next = {};
+                for (const [rawKey, rawLabel] of Object.entries(rawValueLabels)) {
+                    if (!opt.values.includes(rawKey))
+                        continue;
+                    if (typeof rawLabel !== 'string' || rawLabel.length === 0)
+                        continue;
+                    next[rawKey] = rawLabel;
+                }
+                if (Object.keys(next).length > 0)
+                    valueLabels = next;
+            }
             out.push({
                 namespace,
                 key,
                 description: opt.description,
                 values: opt.values,
+                ...(valueLabels ? { valueLabels } : {}),
                 ...(defaultValue ? { defaultValue } : {}),
             });
         }