dominds 1.18.2 → 1.19.2

package/dist/dialog-fork.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.forkRootDialogTreeAtGeneration = forkRootDialogTreeAtGeneration;
+exports.forkMainDialogTreeAtGeneration = forkMainDialogTreeAtGeneration;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const storage_1 = require("@longrun-ai/kernel/types/storage");
@@ -49,8 +49,8 @@ function cloneQuestions(questions) {
         callSiteRef: { ...question.callSiteRef },
     }));
 }
-function clonePendingSubdialogs(pendingSubdialogs) {
-    return pendingSubdialogs.map((entry) => ({
+function clonePendingSideDialogs(pendingSideDialogs) {
+    return pendingSideDialogs.map((entry) => ({
         ...entry,
         mentionList: entry.mentionList ? [...entry.mentionList] : undefined,
     }));
@@ -58,7 +58,7 @@ function clonePendingSubdialogs(pendingSubdialogs) {
 function cloneRegistryEntries(entries) {
     return entries.map((entry) => ({ ...entry }));
 }
-function cloneSubdialogResponses(responses) {
+function cloneSideDialogResponses(responses) {
     return responses.map((response) => ({
         ...response,
         mentionList: response.mentionList ? [...response.mentionList] : undefined,
@@ -67,31 +67,53 @@ function cloneSubdialogResponses(responses) {
 function rewriteForkTreeDialogSelfId(sourceDialogSelfId, sourceRootId, targetRootId) {
     return sourceDialogSelfId === sourceRootId ? targetRootId : sourceDialogSelfId;
 }
-function rewriteAssignmentFromSupForFork(assignmentFromSup, sourceRootId, targetRootId) {
+function rewriteAssignmentFromAskerForFork(assignmentFromAsker, sourceRootId, targetRootId) {
     return {
-        ...assignmentFromSup,
-        callerDialogId: rewriteForkTreeDialogSelfId(assignmentFromSup.callerDialogId, sourceRootId, targetRootId),
-        mentionList: assignmentFromSup.mentionList ? [...assignmentFromSup.mentionList] : undefined,
-        collectiveTargets: assignmentFromSup.collectiveTargets
-            ? [...assignmentFromSup.collectiveTargets]
+        ...assignmentFromAsker,
+        askerDialogId: rewriteForkTreeDialogSelfId(assignmentFromAsker.askerDialogId, sourceRootId, targetRootId),
+        mentionList: assignmentFromAsker.mentionList ? [...assignmentFromAsker.mentionList] : undefined,
+        collectiveTargets: assignmentFromAsker.collectiveTargets
+            ? [...assignmentFromAsker.collectiveTargets]
             : undefined,
     };
 }
-function rewriteSubdialogMetadataForFork(metadata, sourceRootId, targetRootId) {
+function rewriteSideDialogMetadataForFork(metadata) {
     return {
         ...metadata,
-        supdialogId: rewriteForkTreeDialogSelfId(metadata.supdialogId, sourceRootId, targetRootId),
-        assignmentFromSup: rewriteAssignmentFromSupForFork(metadata.assignmentFromSup, sourceRootId, targetRootId),
+    };
+}
+function rewriteTellaskReplyDirectiveForFork(directive, sourceRootId, targetRootId) {
+    return {
+        ...directive,
+        targetDialogId: rewriteForkTreeDialogSelfId(directive.targetDialogId, sourceRootId, targetRootId),
+    };
+}
+function rewriteSideDialogAskerStackStateForFork(state, sourceRootId, targetRootId) {
+    return {
+        askerStack: state.askerStack.map((frame) => ({
+            kind: 'asker_dialog_stack_frame',
+            askerDialogId: rewriteForkTreeDialogSelfId(frame.askerDialogId, sourceRootId, targetRootId),
+            ...(frame.assignmentFromAsker === undefined
+                ? {}
+                : {
+                    assignmentFromAsker: rewriteAssignmentFromAskerForFork(frame.assignmentFromAsker, sourceRootId, targetRootId),
+                }),
+            ...(frame.tellaskReplyObligation === undefined
+                ? {}
+                : {
+                    tellaskReplyObligation: rewriteTellaskReplyDirectiveForFork(frame.tellaskReplyObligation, sourceRootId, targetRootId),
+                }),
+        })),
     };
 }
 function isForkStateRecord(record) {
     switch (record.type) {
-        case 'subdialog_created_record':
+        case 'sideDialog_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':
+        case 'pending_sideDialogs_reconciled_record':
+        case 'sideDialog_registry_reconciled_record':
+        case 'sideDialog_responses_reconciled_record':
             return record;
         default:
             return null;
@@ -116,17 +138,17 @@ function isPersistedMessageRecord(record) {
         case 'native_tool_call_record':
         case 'tool_result_image_ingest_record':
         case 'user_image_ingest_record':
-        case 'quest_for_sup_record':
+        case 'sideDialog_request_record':
         case 'tellask_reply_resolution_record':
         case 'tellask_call_anchor_record':
         case 'gen_start_record':
         case 'gen_finish_record':
-        case 'subdialog_created_record':
+        case 'sideDialog_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':
+        case 'pending_sideDialogs_reconciled_record':
+        case 'sideDialog_registry_reconciled_record':
+        case 'sideDialog_responses_reconciled_record':
             return false;
         default: {
             const _exhaustive = record;
@@ -188,7 +210,7 @@ function rewriteRecordForFork(record, newRootId) {
         // not part of baseline state reconciliation and must not make forking fail.
         case 'web_search_call_record':
         case 'native_tool_call_record':
-        case 'quest_for_sup_record':
+        case 'sideDialog_request_record':
         case 'tellask_reply_resolution_record':
         case 'tellask_call_anchor_record':
         case 'gen_start_record':
@@ -215,12 +237,12 @@ function rewriteRecordForFork(record, newRootId) {
                     rootId: newRootId,
                 },
             };
-        case 'subdialog_created_record':
+        case 'sideDialog_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':
+        case 'pending_sideDialogs_reconciled_record':
+        case 'sideDialog_registry_reconciled_record':
+        case 'sideDialog_responses_reconciled_record':
             throw new Error(`Fork transcript copy must not include state record ${record.type}`);
         default: {
             const _exhaustive = record;
@@ -251,15 +273,15 @@ function computeRootForkDisplayState(args) {
         return { kind: 'idle_waiting_user' };
     }
     const hasQ4H = args.questions.length > 0;
-    const hasSubdialogs = args.pendingSubdialogs.length > 0;
-    if (hasQ4H && hasSubdialogs) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+    const hasSideDialogs = args.pendingSideDialogs.length > 0;
+    if (hasQ4H && hasSideDialogs) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
     }
     if (hasQ4H) {
         return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
     }
-    if (hasSubdialogs) {
-        return { kind: 'blocked', reason: { kind: 'waiting_for_subdialogs' } };
+    if (hasSideDialogs) {
+        return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
     }
     return { kind: 'stopped', reason: { kind: 'fork_continue_ready' }, continueEnabled: true };
 }
@@ -323,16 +345,16 @@ async function collectForkSnapshot(dialogId, status, cutoffAnchor) {
                 case 'questions4human_reconciled_record':
                     latestQuestions = cloneQuestions(stateRecord.questions);
                     break;
-                case 'pending_subdialogs_reconciled_record':
-                    latestPending = clonePendingSubdialogs(stateRecord.pendingSubdialogs);
+                case 'pending_sideDialogs_reconciled_record':
+                    latestPending = clonePendingSideDialogs(stateRecord.pendingSideDialogs);
                     break;
-                case 'subdialog_registry_reconciled_record':
+                case 'sideDialog_registry_reconciled_record':
                     latestRegistry = cloneRegistryEntries(stateRecord.entries);
                     break;
-                case 'subdialog_responses_reconciled_record':
-                    latestResponses = cloneSubdialogResponses(stateRecord.responses);
+                case 'sideDialog_responses_reconciled_record':
+                    latestResponses = cloneSideDialogResponses(stateRecord.responses);
                     break;
-                case 'subdialog_created_record':
+                case 'sideDialog_created_record':
                     break;
                 default: {
                     const _exhaustive = stateRecord;
@@ -344,12 +366,12 @@ async function collectForkSnapshot(dialogId, status, cutoffAnchor) {
     return {
         reminders: latestReminders !== null ? latestReminders.map((item) => cloneReminderSnapshot(item)) : [],
         questions: latestQuestions ?? [],
-        pendingSubdialogs: latestPending ?? [],
+        pendingSideDialogs: latestPending ?? [],
         registryEntries: latestRegistry ?? [],
-        subdialogResponses: latestResponses ?? [],
+        sideDialogResponses: latestResponses ?? [],
     };
 }
-async function collectIncludedSubdialogs(args) {
+async function collectIncludedSideDialogs(args) {
     const queue = [new dialog_1.DialogID(args.sourceRootId)];
     const scannedDialogSelfIds = new Set();
     const included = new Map();
@@ -364,21 +386,23 @@ async function collectIncludedSubdialogs(args) {
         for (const course of courseNumbers) {
             const events = await persistence_1.DialogPersistence.readCourseEvents(ownerDialogId, course, args.sourceStatus);
             for (const event of events) {
-                if (event.type !== 'subdialog_created_record')
+                if (event.type !== 'sideDialog_created_record')
                     continue;
                 if (!anchorAtOrBefore(event, args.cutoffAnchor))
                     continue;
-                if (included.has(event.subdialogId))
+                if (included.has(event.sideDialogId))
                     continue;
-                const sourceId = new dialog_1.DialogID(event.subdialogId, args.sourceRootId);
+                const sourceId = new dialog_1.DialogID(event.sideDialogId, args.sourceRootId);
                 const metadata = await persistence_1.DialogPersistence.loadDialogMetadata(sourceId, args.sourceStatus);
-                if (!metadata || metadata.supdialogId === undefined) {
-                    throw new Error(`Missing included subdialog metadata for ${sourceId.valueOf()}`);
+                if (!metadata) {
+                    throw new Error(`Missing included sideDialog metadata for ${sourceId.valueOf()}`);
                 }
-                included.set(event.subdialogId, {
+                const assignmentFromAsker = await persistence_1.DialogPersistence.loadSideDialogAssignmentFromAsker(sourceId, args.sourceStatus);
+                included.set(event.sideDialogId, {
                     sourceId,
-                    targetId: new dialog_1.DialogID(event.subdialogId, args.targetRootId),
+                    targetId: new dialog_1.DialogID(event.sideDialogId, args.targetRootId),
                     metadata,
+                    assignmentFromAsker,
                 });
                 queue.push(sourceId);
             }
@@ -389,7 +413,7 @@ async function collectIncludedSubdialogs(args) {
     for (const selfId of orderedSelfIds) {
         const item = included.get(selfId);
         if (!item) {
-            throw new Error(`Missing ordered included subdialog for ${selfId}`);
+            throw new Error(`Missing ordered included sideDialog for ${selfId}`);
         }
         orderedIncluded.push(item);
     }
@@ -400,18 +424,18 @@ async function buildDialogForkPlan(args) {
     const retainedCourses = [];
     for (const course of courseNumbers) {
         const events = await persistence_1.DialogPersistence.readCourseEvents(args.sourceId, course, args.sourceStatus);
-        const isRootDialog = args.sourceId.selfId === args.sourceId.rootId;
+        const isMainDialog = args.sourceId.selfId === args.sourceId.rootId;
         const retained = events.filter((event, index) => {
             if (isForkStateRecord(event)) {
                 return false;
             }
-            if (args.truncateRootCourse && course === args.truncateRootCourse.course && isRootDialog) {
+            if (args.truncateRootCourse && course === args.truncateRootCourse.course && isMainDialog) {
                 return index < args.truncateRootCourse.keepCount;
             }
-            if (!isRootDialog) {
+            if (!isMainDialog) {
                 const recordAnchor = getRecordRootAnchor(event);
                 if (recordAnchor === null) {
-                    throw new Error(`fork dialog requires root anchor on subdialog transcript record: dialog=${args.sourceId.valueOf()} course=${String(course)} type=${event.type}`);
+                    throw new Error(`fork dialog requires root anchor on sideDialog transcript record: dialog=${args.sourceId.valueOf()} course=${String(course)} type=${event.type}`);
                 }
                 return anchorAtOrBefore(recordAnchor, args.cutoffAnchor);
             }
@@ -431,15 +455,15 @@ async function buildDialogForkPlan(args) {
         currentCourse: retainedCurrentCourse,
         reminders: snapshot.reminders,
         questions: snapshot.questions,
-        pendingSubdialogs: snapshot.pendingSubdialogs,
+        pendingSideDialogs: snapshot.pendingSideDialogs,
         registryEntries: snapshot.registryEntries,
-        subdialogResponses: snapshot.subdialogResponses,
+        sideDialogResponses: snapshot.sideDialogResponses,
         childCount: args.childCount,
     };
 }
-async function appendForkBaselineState(plan, baselineSubdialogCreatedRecords) {
+async function appendForkBaselineState(plan, baselineSideDialogCreatedRecords) {
     const baselineTs = (0, time_1.formatUnifiedTimestamp)(new Date());
-    for (const record of baselineSubdialogCreatedRecords) {
+    for (const record of baselineSideDialogCreatedRecords) {
         await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, record, 'running');
     }
     const remindersRecord = {
@@ -465,21 +489,21 @@ async function appendForkBaselineState(plan, baselineSubdialogCreatedRecords) {
     };
     const pendingRecord = {
         ts: baselineTs,
-        type: 'pending_subdialogs_reconciled_record',
+        type: 'pending_sideDialogs_reconciled_record',
         ...FORK_BASELINE_ANCHOR,
-        pendingSubdialogs: clonePendingSubdialogs(plan.pendingSubdialogs),
+        pendingSideDialogs: clonePendingSideDialogs(plan.pendingSideDialogs),
     };
     const registryRecord = {
         ts: baselineTs,
-        type: 'subdialog_registry_reconciled_record',
+        type: 'sideDialog_registry_reconciled_record',
         ...FORK_BASELINE_ANCHOR,
         entries: cloneRegistryEntries(plan.registryEntries),
     };
     const responsesRecord = {
         ts: baselineTs,
-        type: 'subdialog_responses_reconciled_record',
+        type: 'sideDialog_responses_reconciled_record',
         ...FORK_BASELINE_ANCHOR,
-        responses: cloneSubdialogResponses(plan.subdialogResponses),
+        responses: cloneSideDialogResponses(plan.sideDialogResponses),
     };
     await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, remindersRecord, 'running');
     await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, q4hRecord, 'running');
@@ -490,27 +514,30 @@ async function appendForkBaselineState(plan, baselineSubdialogCreatedRecords) {
 async function persistForkPlan(args) {
     const { plan } = args;
     if (plan.targetId.selfId === plan.targetId.rootId) {
-        if (plan.metadata.supdialogId !== undefined ||
-            plan.metadata.sessionSlug !== undefined ||
-            plan.metadata.assignmentFromSup !== undefined) {
-            throw new Error(`fork root plan received subdialog metadata: ${plan.targetId.valueOf()}`);
-        }
+        const priming = 'priming' in plan.metadata ? plan.metadata.priming : undefined;
         const rewrittenMetadata = {
             id: plan.targetId.selfId,
             agentId: plan.metadata.agentId,
             taskDocPath: plan.metadata.taskDocPath,
             createdAt: args.now,
-            ...(plan.metadata.priming ? { priming: plan.metadata.priming } : {}),
+            ...(priming ? { priming } : {}),
         };
-        await persistence_1.DialogPersistence.saveRootDialogMetadata(plan.targetId, rewrittenMetadata, 'running');
+        await persistence_1.DialogPersistence.saveMainDialogMetadata(plan.targetId, rewrittenMetadata, 'running');
     }
     else {
-        if (plan.metadata.supdialogId === undefined) {
-            throw new Error(`fork subdialog plan missing supdialog metadata: ${plan.targetId.valueOf()}`);
+        const rewrittenMetadata = rewriteSideDialogMetadataForFork(plan.metadata);
+        const sourceAskerStackState = await persistence_1.DialogPersistence.loadSideDialogAskerStackState(plan.sourceId, args.sourceStatus);
+        if (!sourceAskerStackState) {
+            throw new Error(`fork sideDialog plan missing asker stack: ${plan.sourceId.valueOf()}`);
         }
-        const rewrittenMetadata = rewriteSubdialogMetadataForFork(plan.metadata, plan.sourceId.rootId, plan.targetId.rootId);
-        await persistence_1.DialogPersistence.ensureSubdialogDirectory(plan.targetId, 'running');
-        await persistence_1.DialogPersistence.saveSubdialogMetadata(plan.targetId, rewrittenMetadata, 'running');
+        const rewrittenAskerStackState = rewriteSideDialogAskerStackStateForFork(sourceAskerStackState, plan.sourceId.rootId, plan.targetId.rootId);
+        await persistence_1.DialogPersistence.ensureSideDialogDirectory(plan.targetId, 'running');
+        await persistence_1.DialogPersistence.saveSideDialogAskerStackState(plan.targetId, rewrittenAskerStackState, 'running');
+        await persistence_1.DialogPersistence.saveSideDialogMetadata(plan.targetId, rewrittenMetadata, 'running');
+    }
+    const sourceAskerStack = await persistence_1.DialogPersistence.loadDialogAskerStack(plan.sourceId, args.sourceStatus);
+    if (sourceAskerStack.askerStack.length > 0) {
+        await persistence_1.DialogPersistence.saveDialogAskerStack(plan.targetId, rewriteSideDialogAskerStackStateForFork(sourceAskerStack, plan.sourceId.rootId, plan.targetId.rootId), 'running');
     }
     for (const course of plan.retainedCourses) {
         for (const event of course.events) {
@@ -520,21 +547,21 @@ async function persistForkPlan(args) {
     await appendForkBaselineState(plan, args.baselineRecordsByParentSelfId.get(plan.targetId.selfId) ?? []);
     await persistence_1.DialogPersistence._saveReminderState(plan.targetId, [...plan.reminders], 'running');
     await persistence_1.DialogPersistence._saveQuestions4HumanState(plan.targetId, [...plan.questions], 'running');
-    await persistence_1.DialogPersistence.savePendingSubdialogs(plan.targetId, [...plan.pendingSubdialogs], undefined, 'running');
-    await persistence_1.DialogPersistence.saveSubdialogRegistry(plan.targetId, plan.registryEntries.map((entry) => ({
+    await persistence_1.DialogPersistence.savePendingSideDialogs(plan.targetId, [...plan.pendingSideDialogs], undefined, 'running');
+    await persistence_1.DialogPersistence.saveSideDialogRegistry(plan.targetId, plan.registryEntries.map((entry) => ({
         key: entry.key,
-        subdialogId: new dialog_1.DialogID(entry.subdialogId, plan.targetId.rootId),
+        sideDialogId: new dialog_1.DialogID(entry.sideDialogId, plan.targetId.rootId),
         agentId: entry.agentId,
         sessionSlug: entry.sessionSlug,
     })), 'running');
-    await persistence_1.DialogPersistence.saveSubdialogResponses(plan.targetId, [...plan.subdialogResponses], undefined, 'running');
+    await persistence_1.DialogPersistence.saveSideDialogResponses(plan.targetId, [...plan.sideDialogResponses], undefined, 'running');
     await copyArtifactsIfPresent(plan.sourceId, plan.targetId, args.sourceStatus);
     const currentCourseEvents = plan.retainedCourses.find((item) => item.course === plan.currentCourse)?.events ?? [];
     const displayState = plan.targetId.selfId === plan.targetId.rootId
         ? computeRootForkDisplayState({
             action: args.action,
             questions: plan.questions,
-            pendingSubdialogs: plan.pendingSubdialogs,
+            pendingSideDialogs: plan.pendingSideDialogs,
         })
         : { kind: 'idle_waiting_user' };
     await persistence_1.DialogPersistence.mutateDialogLatest(plan.targetId, () => ({
@@ -545,7 +572,7 @@ async function persistForkPlan(args) {
             status: 'active',
             messageCount: countMessages(currentCourseEvents),
             functionCallCount: countFunctionCalls(currentCourseEvents),
-            subdialogCount: plan.childCount,
+            sideDialogCount: plan.childCount,
             generating: false,
             needsDrive: false,
             displayState,
@@ -556,7 +583,7 @@ async function persistForkPlan(args) {
         },
     }));
 }
-async function forkRootDialogTreeAtGeneration(args) {
+async function forkMainDialogTreeAtGeneration(args) {
     const sourceRootId = args.sourceRootId.trim();
     if (sourceRootId === '') {
         throw new Error('sourceRootId is required');
@@ -567,17 +594,14 @@ async function forkRootDialogTreeAtGeneration(args) {
     if (!Number.isFinite(args.genseq) || args.genseq <= 0) {
         throw new Error('genseq must be a positive integer');
     }
-    const sourceRootDialogId = new dialog_1.DialogID(sourceRootId);
-    const sourceMetadata = await persistence_1.DialogPersistence.loadDialogMetadata(sourceRootDialogId, args.sourceStatus);
+    const sourceMainDialogId = new dialog_1.DialogID(sourceRootId);
+    const sourceMetadata = await persistence_1.DialogPersistence.loadDialogMetadata(sourceMainDialogId, args.sourceStatus);
     if (!sourceMetadata) {
-        throw new Error(`Root dialog not found: ${sourceRootId} (${args.sourceStatus})`);
-    }
-    if (sourceMetadata.supdialogId !== undefined) {
-        throw new Error(`fork dialog only supports root dialogs: ${sourceRootId}`);
+        throw new Error(`Main dialog not found: ${sourceRootId} (${args.sourceStatus})`);
     }
     const targetCourse = Math.floor(args.course);
     const targetGenseq = Math.floor(args.genseq);
-    const rootEvents = await persistence_1.DialogPersistence.readCourseEvents(sourceRootDialogId, targetCourse, args.sourceStatus);
+    const rootEvents = await persistence_1.DialogPersistence.readCourseEvents(sourceMainDialogId, targetCourse, args.sourceStatus);
     const targetStartIndex = rootEvents.findIndex((event) => 'genseq' in event && typeof event.genseq === 'number' && event.genseq === targetGenseq);
     if (targetStartIndex < 0) {
         throw new Error(`Target genseq ${String(targetGenseq)} not found in dialog ${sourceRootId} course ${String(targetCourse)}`);
@@ -591,21 +615,22 @@ async function forkRootDialogTreeAtGeneration(args) {
         rootGenseq: targetGenseq - 1,
     });
     const draftUserText = normalizeDraftUserText(rootEvents, targetGenseq);
-    const latest = await persistence_1.DialogPersistence.loadDialogLatest(sourceRootDialogId, args.sourceStatus);
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(sourceMainDialogId, args.sourceStatus);
     const targetRootId = (0, id_1.generateDialogID)();
     const now = (0, time_1.formatUnifiedTimestamp)(new Date());
-    const includedSubdialogs = await collectIncludedSubdialogs({
+    const includedSideDialogs = await collectIncludedSideDialogs({
         sourceRootId,
         sourceStatus: args.sourceStatus,
         cutoffAnchor,
         targetRootId,
     });
     const childCountByParentSelfId = new Map();
-    for (const subdialog of includedSubdialogs) {
-        childCountByParentSelfId.set(subdialog.metadata.supdialogId, (childCountByParentSelfId.get(subdialog.metadata.supdialogId) ?? 0) + 1);
+    for (const sideDialog of includedSideDialogs) {
+        const askerDialogId = sideDialog.assignmentFromAsker.askerDialogId;
+        childCountByParentSelfId.set(askerDialogId, (childCountByParentSelfId.get(askerDialogId) ?? 0) + 1);
     }
     const rootPlan = await buildDialogForkPlan({
-        sourceId: sourceRootDialogId,
+        sourceId: sourceMainDialogId,
         targetId: new dialog_1.DialogID(targetRootId),
         sourceStatus: args.sourceStatus,
         sourceMetadata,
@@ -615,48 +640,48 @@ async function forkRootDialogTreeAtGeneration(args) {
     });
     const action = draftUserText !== null
         ? { kind: 'draft_user_text', userText: draftUserText }
-        : rootPlan.questions.length > 0 || rootPlan.pendingSubdialogs.length > 0
+        : rootPlan.questions.length > 0 || rootPlan.pendingSideDialogs.length > 0
             ? {
                 kind: 'restore_pending',
                 pendingQ4H: rootPlan.questions.length > 0,
-                pendingSubdialogs: rootPlan.pendingSubdialogs.length > 0,
+                pendingSideDialogs: rootPlan.pendingSideDialogs.length > 0,
             }
             : { kind: 'auto_continue' };
-    const subdialogPlans = [];
-    for (const subdialog of includedSubdialogs) {
-        subdialogPlans.push(await buildDialogForkPlan({
-            sourceId: subdialog.sourceId,
-            targetId: subdialog.targetId,
+    const sideDialogPlans = [];
+    for (const sideDialog of includedSideDialogs) {
+        sideDialogPlans.push(await buildDialogForkPlan({
+            sourceId: sideDialog.sourceId,
+            targetId: sideDialog.targetId,
             sourceStatus: args.sourceStatus,
-            sourceMetadata: subdialog.metadata,
+            sourceMetadata: sideDialog.metadata,
             cutoffAnchor,
-            childCount: childCountByParentSelfId.get(subdialog.sourceId.selfId) ?? 0,
+            childCount: childCountByParentSelfId.get(sideDialog.sourceId.selfId) ?? 0,
         }));
     }
     const baselineRecordsByParentSelfId = new Map();
-    for (const subdialog of includedSubdialogs) {
-        const rewrittenSupdialogId = rewriteForkTreeDialogSelfId(subdialog.metadata.supdialogId, sourceRootId, targetRootId);
+    for (const sideDialog of includedSideDialogs) {
+        const rewrittenAskerDialogId = rewriteForkTreeDialogSelfId(sideDialog.assignmentFromAsker.askerDialogId, sourceRootId, targetRootId);
         const rewrittenRecord = {
             ts: now,
-            type: 'subdialog_created_record',
+            type: 'sideDialog_created_record',
             ...FORK_BASELINE_ANCHOR,
-            subdialogId: subdialog.targetId.selfId,
-            supdialogId: rewrittenSupdialogId,
-            agentId: subdialog.metadata.agentId,
-            taskDocPath: subdialog.metadata.taskDocPath,
-            createdAt: subdialog.metadata.createdAt,
-            sessionSlug: subdialog.metadata.sessionSlug,
-            assignmentFromSup: rewriteAssignmentFromSupForFork(subdialog.metadata.assignmentFromSup, sourceRootId, targetRootId),
+            sideDialogId: sideDialog.targetId.selfId,
+            askerDialogId: rewrittenAskerDialogId,
+            agentId: sideDialog.metadata.agentId,
+            taskDocPath: sideDialog.metadata.taskDocPath,
+            createdAt: sideDialog.metadata.createdAt,
+            sessionSlug: sideDialog.metadata.sessionSlug,
+            assignmentFromAsker: rewriteAssignmentFromAskerForFork(sideDialog.assignmentFromAsker, sourceRootId, targetRootId),
         };
-        const existing = baselineRecordsByParentSelfId.get(rewrittenSupdialogId);
+        const existing = baselineRecordsByParentSelfId.get(rewrittenAskerDialogId);
         if (existing) {
             existing.push(rewrittenRecord);
         }
         else {
-            baselineRecordsByParentSelfId.set(rewrittenSupdialogId, [rewrittenRecord]);
+            baselineRecordsByParentSelfId.set(rewrittenAskerDialogId, [rewrittenRecord]);
         }
     }
-    const allPlans = [rootPlan, ...subdialogPlans];
+    const allPlans = [rootPlan, ...sideDialogPlans];
     for (const plan of allPlans) {
         await persistForkPlan({
             plan,

package/dist/dialog-global-registry.d.ts

@@ -1,4 +1,4 @@
-import type { RootDialog } from './dialog';
+import type { MainDialog } from './dialog';
 export type DriveTriggerEvent = Readonly<{
     type: 'drive_trigger_evt';
     action: 'mark_needs_drive' | 'mark_not_needing_drive' | 'active_run_cleared';
@@ -21,8 +21,8 @@ declare class GlobalDialogRegistry {
     private readonly driveTriggerPubChan;
     private driveTriggerSubChan;
     static getInstance(): GlobalDialogRegistry;
-    get(rootId: string): RootDialog | undefined;
-    register(rootDialog: RootDialog): void;
+    get(rootId: string): MainDialog | undefined;
+    register(mainDialog: MainDialog): void;
     unregister(rootId: string): void;
     private publishDriveTrigger;
     waitForDriveTrigger(): Promise<DriveTriggerEvent>;
@@ -32,9 +32,9 @@ declare class GlobalDialogRegistry {
     noteActiveRunBlockedQueuedDrive(rootId: string): void;
     hasPendingActiveRunClearedWake(rootId: string): boolean;
     isMarkedNeedingDrive(rootId: string): boolean;
-    getDialogsNeedingDrive(): RootDialog[];
+    getDialogsNeedingDrive(): MainDialog[];
     getLastDriveTrigger(rootId: string): DriveTriggerEvent | undefined;
-    getAll(): RootDialog[];
+    getAll(): MainDialog[];
     get size(): number;
 }
 export declare const globalDialogRegistry: GlobalDialogRegistry;

package/dist/dialog-global-registry.js

@@ -17,28 +17,28 @@ class GlobalDialogRegistry {
         return GlobalDialogRegistry.instance;
     }
     get(rootId) {
-        return this.entries.get(rootId)?.rootDialog;
+        return this.entries.get(rootId)?.mainDialog;
     }
-    register(rootDialog) {
+    register(mainDialog) {
         // This registry is keyed by the *tree root id*.
-        // Only the canonical root dialog (selfId === rootId) should be stored here.
-        if (rootDialog.id.selfId !== rootDialog.id.rootId) {
+        // Only the canonical main dialog (selfId === rootId) should be stored here.
+        if (mainDialog.id.selfId !== mainDialog.id.rootId) {
             return;
         }
-        const existing = this.entries.get(rootDialog.id.rootId);
+        const existing = this.entries.get(mainDialog.id.rootId);
         if (existing) {
             return;
         }
-        this.entries.set(rootDialog.id.rootId, {
-            rootDialog,
+        this.entries.set(mainDialog.id.rootId, {
+            mainDialog,
             needsDrive: false,
             activeRunClearedWakePending: false,
         });
         void (async () => {
             try {
-                const needsDrive = await persistence_1.DialogPersistence.getNeedsDrive(rootDialog.id);
+                const needsDrive = await persistence_1.DialogPersistence.getNeedsDrive(mainDialog.id);
                 if (needsDrive) {
-                    this.markNeedsDrive(rootDialog.id.rootId, {
+                    this.markNeedsDrive(mainDialog.id.rootId, {
                         source: 'dialog_registry_hydration',
                         reason: 'persisted_needs_drive_true',
                     });
@@ -158,13 +158,13 @@ class GlobalDialogRegistry {
     getDialogsNeedingDrive() {
         return Array.from(this.entries.values())
             .filter((entry) => entry.needsDrive)
-            .map((entry) => entry.rootDialog);
+            .map((entry) => entry.mainDialog);
     }
     getLastDriveTrigger(rootId) {
         return this.lastDriveTriggerByRootId.get(rootId);
     }
     getAll() {
-        return Array.from(this.entries.values()).map((entry) => entry.rootDialog);
+        return Array.from(this.entries.values()).map((entry) => entry.mainDialog);
     }
     get size() {
         return this.entries.size;

package/dist/dialog-instance-registry.d.ts

@@ -1,4 +1,4 @@
-import { Dialog, DialogID, RootDialog } from './dialog';
+import { Dialog, DialogID, MainDialog } from './dialog';
 export type DialogPersistenceStatus = 'running' | 'completed' | 'archived';
-export declare function getOrRestoreRootDialog(rootId: string, status: DialogPersistenceStatus): Promise<RootDialog | undefined>;
-export declare function ensureDialogLoaded(rootDialog: RootDialog, targetId: DialogID, status: DialogPersistenceStatus, visitedSelfIds?: Set<string>): Promise<Dialog | undefined>;
+export declare function getOrRestoreMainDialog(rootId: string, status: DialogPersistenceStatus): Promise<MainDialog | undefined>;
+export declare function ensureDialogLoaded(mainDialog: MainDialog, targetId: DialogID, status: DialogPersistenceStatus, visitedSelfIds?: Set<string>): Promise<Dialog | undefined>;