dominds 1.4.2 → 1.5.1

package/dist/dialog-fork.js

@@ -0,0 +1,608 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forkRootDialogTreeAtGeneration = forkRootDialogTreeAtGeneration;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const dialog_1 = require("./dialog");
+const persistence_1 = require("./persistence");
+const time_1 = require("./shared/utils/time");
+const id_1 = require("./utils/id");
+const FORK_BASELINE_ANCHOR = {
+    rootCourse: 1,
+    rootGenseq: 0,
+};
+function compareRootAnchor(left, right) {
+    if (left.rootCourse < right.rootCourse)
+        return -1;
+    if (left.rootCourse > right.rootCourse)
+        return 1;
+    if (left.rootGenseq < right.rootGenseq)
+        return -1;
+    if (left.rootGenseq > right.rootGenseq)
+        return 1;
+    return 0;
+}
+function anchorAtOrBefore(candidate, cutoff) {
+    return compareRootAnchor(candidate, cutoff) <= 0;
+}
+function cloneReminderSnapshot(snapshot) {
+    return {
+        content: snapshot.content,
+        owner: undefined,
+        meta: snapshot.meta,
+        echoback: snapshot.echoback,
+    };
+}
+function cloneQuestions(questions) {
+    return questions.map((question) => ({
+        ...question,
+        remainingCallIds: question.remainingCallIds ? [...question.remainingCallIds] : undefined,
+        callSiteRef: { ...question.callSiteRef },
+    }));
+}
+function clonePendingSubdialogs(pendingSubdialogs) {
+    return pendingSubdialogs.map((entry) => ({
+        ...entry,
+        mentionList: entry.mentionList ? [...entry.mentionList] : undefined,
+    }));
+}
+function cloneRegistryEntries(entries) {
+    return entries.map((entry) => ({ ...entry }));
+}
+function cloneSubdialogResponses(responses) {
+    return responses.map((response) => ({
+        ...response,
+        mentionList: response.mentionList ? [...response.mentionList] : undefined,
+    }));
+}
+function rewriteForkTreeDialogSelfId(sourceDialogSelfId, sourceRootId, targetRootId) {
+    return sourceDialogSelfId === sourceRootId ? targetRootId : sourceDialogSelfId;
+}
+function rewriteAssignmentFromSupForFork(assignmentFromSup, sourceRootId, targetRootId) {
+    return {
+        ...assignmentFromSup,
+        callerDialogId: rewriteForkTreeDialogSelfId(assignmentFromSup.callerDialogId, sourceRootId, targetRootId),
+        mentionList: assignmentFromSup.mentionList ? [...assignmentFromSup.mentionList] : undefined,
+        collectiveTargets: assignmentFromSup.collectiveTargets
+            ? [...assignmentFromSup.collectiveTargets]
+            : undefined,
+    };
+}
+function rewriteSubdialogMetadataForFork(metadata, sourceRootId, targetRootId) {
+    return {
+        ...metadata,
+        supdialogId: rewriteForkTreeDialogSelfId(metadata.supdialogId, sourceRootId, targetRootId),
+        assignmentFromSup: rewriteAssignmentFromSupForFork(metadata.assignmentFromSup, sourceRootId, targetRootId),
+    };
+}
+function isForkStateRecord(record) {
+    switch (record.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 record;
+        default:
+            return null;
+    }
+}
+function isPersistedMessageRecord(record) {
+    switch (record.type) {
+        case 'agent_thought_record':
+        case 'agent_words_record':
+        case 'ui_only_markdown_record':
+        case 'human_text_record':
+        case 'func_call_record':
+        case 'func_result_record':
+        case 'teammate_call_result_record':
+        case 'teammate_response_record':
+            return true;
+        case 'web_search_call_record':
+        case 'quest_for_sup_record':
+        case 'teammate_call_anchor_record':
+        case 'gen_start_record':
+        case 'gen_finish_record':
+        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 false;
+        default: {
+            const _exhaustive = record;
+            throw new Error(`Unhandled persisted record while counting messages: ${String(_exhaustive)}`);
+        }
+    }
+}
+function getRecordRootAnchor(record) {
+    const rootCourse = 'rootCourse' in record && typeof record.rootCourse === 'number' ? record.rootCourse : null;
+    const rootGenseq = 'rootGenseq' in record && typeof record.rootGenseq === 'number' ? record.rootGenseq : null;
+    if (rootCourse === null || rootGenseq === null) {
+        return null;
+    }
+    return {
+        rootCourse,
+        rootGenseq,
+    };
+}
+function normalizeDraftUserText(events, targetGenseq) {
+    const texts = events
+        .filter((event) => event.type === 'human_text_record' && event.genseq === targetGenseq)
+        .map((event) => event.content.trim())
+        .filter((value) => value !== '');
+    if (texts.length === 0)
+        return null;
+    return texts.join('\n\n');
+}
+function rewriteFuncResultContentItems(items, newRootId) {
+    if (!items)
+        return undefined;
+    return items.map((item) => {
+        switch (item.type) {
+            case 'input_text':
+                return item;
+            case 'input_image':
+                return {
+                    ...item,
+                    artifact: {
+                        ...item.artifact,
+                        rootId: newRootId,
+                    },
+                };
+            default: {
+                const _exhaustive = item;
+                return _exhaustive;
+            }
+        }
+    });
+}
+function rewriteRecordForFork(record, newRootId) {
+    switch (record.type) {
+        case 'agent_thought_record':
+        case 'agent_words_record':
+        case 'ui_only_markdown_record':
+        case 'func_call_record':
+        case 'web_search_call_record':
+        case 'human_text_record':
+        case 'quest_for_sup_record':
+        case 'teammate_call_result_record':
+        case 'teammate_call_anchor_record':
+        case 'teammate_response_record':
+        case 'gen_start_record':
+        case 'gen_finish_record':
+            return record;
+        case 'func_result_record':
+            return {
+                ...record,
+                contentItems: rewriteFuncResultContentItems(record.contentItems, newRootId),
+            };
+        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(`Fork transcript copy must not include state record ${record.type}`);
+        default: {
+            const _exhaustive = record;
+            return _exhaustive;
+        }
+    }
+}
+function countMessages(events) {
+    let count = 0;
+    for (const event of events) {
+        if (isPersistedMessageRecord(event)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function countFunctionCalls(events) {
+    let count = 0;
+    for (const event of events) {
+        if (event.type === 'func_call_record') {
+            count += 1;
+        }
+    }
+    return count;
+}
+function computeRootForkRunState(args) {
+    if (args.action.kind === 'draft_user_text') {
+        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' } };
+    }
+    if (hasQ4H) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
+    }
+    if (hasSubdialogs) {
+        return { kind: 'blocked', reason: { kind: 'waiting_for_subdialogs' } };
+    }
+    return { kind: 'interrupted', reason: { kind: 'system_stop', detail: 'fork_dialog_continue' } };
+}
+async function copyArtifactsIfPresent(sourceId, targetId, sourceStatus) {
+    const sourceDir = node_path_1.default.join(persistence_1.DialogPersistence.getDialogEventsPath(sourceId, sourceStatus), 'artifacts');
+    const targetDir = node_path_1.default.join(persistence_1.DialogPersistence.getDialogEventsPath(targetId, 'running'), 'artifacts');
+    try {
+        await promises_1.default.access(sourceDir);
+    }
+    catch (error) {
+        const code = typeof error === 'object' && error !== null ? error.code : undefined;
+        if (code === 'ENOENT')
+            return;
+        throw error;
+    }
+    await promises_1.default.mkdir(node_path_1.default.dirname(targetDir), { recursive: true });
+    await promises_1.default.cp(sourceDir, targetDir, { recursive: true });
+}
+async function listDialogCourseNumbers(dialogId, status) {
+    const dialogDir = persistence_1.DialogPersistence.getDialogEventsPath(dialogId, status);
+    let entries = [];
+    try {
+        entries = (await promises_1.default.readdir(dialogDir, { withFileTypes: true }));
+    }
+    catch (error) {
+        const code = typeof error === 'object' && error !== null ? error.code : undefined;
+        if (code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const courses = [];
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        if (!/^course-\d+\.jsonl$/.test(entry.name))
+            continue;
+        courses.push(persistence_1.DialogPersistence.getCourseFromFilename(entry.name));
+    }
+    courses.sort((a, b) => a - b);
+    return courses;
+}
+async function collectForkSnapshot(dialogId, status, cutoffAnchor) {
+    const courseNumbers = await listDialogCourseNumbers(dialogId, status);
+    let latestReminders = null;
+    let latestQuestions = null;
+    let latestPending = null;
+    let latestRegistry = null;
+    let latestResponses = null;
+    for (const course of courseNumbers) {
+        const events = await persistence_1.DialogPersistence.readCourseEvents(dialogId, course, status);
+        for (const event of events) {
+            const stateRecord = isForkStateRecord(event);
+            if (!stateRecord)
+                continue;
+            if (!anchorAtOrBefore(stateRecord, cutoffAnchor))
+                continue;
+            switch (stateRecord.type) {
+                case 'reminders_reconciled_record':
+                    latestReminders = stateRecord.reminders.map((item) => ({ ...item }));
+                    break;
+                case 'questions4human_reconciled_record':
+                    latestQuestions = cloneQuestions(stateRecord.questions);
+                    break;
+                case 'pending_subdialogs_reconciled_record':
+                    latestPending = clonePendingSubdialogs(stateRecord.pendingSubdialogs);
+                    break;
+                case 'subdialog_registry_reconciled_record':
+                    latestRegistry = cloneRegistryEntries(stateRecord.entries);
+                    break;
+                case 'subdialog_responses_reconciled_record':
+                    latestResponses = cloneSubdialogResponses(stateRecord.responses);
+                    break;
+                case 'subdialog_created_record':
+                    break;
+                default: {
+                    const _exhaustive = stateRecord;
+                    throw new Error(`Unhandled fork snapshot record ${String(_exhaustive)}`);
+                }
+            }
+        }
+    }
+    return {
+        reminders: latestReminders !== null ? latestReminders.map((item) => cloneReminderSnapshot(item)) : [],
+        questions: latestQuestions ?? [],
+        pendingSubdialogs: latestPending ?? [],
+        registryEntries: latestRegistry ?? [],
+        subdialogResponses: latestResponses ?? [],
+    };
+}
+async function collectIncludedSubdialogs(args) {
+    const sourceRootDialogId = new dialog_1.DialogID(args.sourceRootId);
+    const courseNumbers = await listDialogCourseNumbers(sourceRootDialogId, args.sourceStatus);
+    const includedSelfIds = new Set();
+    for (const course of courseNumbers) {
+        const events = await persistence_1.DialogPersistence.readCourseEvents(sourceRootDialogId, course, args.sourceStatus);
+        for (const event of events) {
+            if (event.type !== 'subdialog_created_record')
+                continue;
+            if (!anchorAtOrBefore(event, args.cutoffAnchor))
+                continue;
+            includedSelfIds.add(event.subdialogId);
+        }
+    }
+    const included = [];
+    const orderedSelfIds = Array.from(includedSelfIds).sort();
+    for (const selfId of orderedSelfIds) {
+        const sourceId = new dialog_1.DialogID(selfId, 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()}`);
+        }
+        included.push({
+            sourceId,
+            targetId: new dialog_1.DialogID(selfId, args.targetRootId),
+            metadata,
+        });
+    }
+    return included;
+}
+async function buildDialogForkPlan(args) {
+    const courseNumbers = await listDialogCourseNumbers(args.sourceId, args.sourceStatus);
+    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 retained = events.filter((event, index) => {
+            if (isForkStateRecord(event)) {
+                return false;
+            }
+            if (args.truncateRootCourse && course === args.truncateRootCourse.course && isRootDialog) {
+                return index < args.truncateRootCourse.keepCount;
+            }
+            if (!isRootDialog) {
+                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}`);
+                }
+                return anchorAtOrBefore(recordAnchor, args.cutoffAnchor);
+            }
+            return true;
+        });
+        if (retained.length > 0) {
+            retainedCourses.push({ course, events: retained });
+        }
+    }
+    const snapshot = await collectForkSnapshot(args.sourceId, args.sourceStatus, args.cutoffAnchor);
+    const retainedCurrentCourse = retainedCourses.length > 0 ? retainedCourses[retainedCourses.length - 1].course : 1;
+    return {
+        sourceId: args.sourceId,
+        targetId: args.targetId,
+        metadata: args.sourceMetadata,
+        retainedCourses,
+        currentCourse: retainedCurrentCourse,
+        reminders: snapshot.reminders,
+        questions: snapshot.questions,
+        pendingSubdialogs: snapshot.pendingSubdialogs,
+        registryEntries: snapshot.registryEntries,
+        subdialogResponses: snapshot.subdialogResponses,
+        childCount: args.childCount,
+    };
+}
+async function appendForkBaselineState(plan, rootBaselineRecords) {
+    const baselineTs = (0, time_1.formatUnifiedTimestamp)(new Date());
+    for (const record of rootBaselineRecords) {
+        await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, record, 'running');
+    }
+    const remindersRecord = {
+        ts: baselineTs,
+        type: 'reminders_reconciled_record',
+        ...FORK_BASELINE_ANCHOR,
+        reminders: plan.reminders.map((reminder) => ({
+            content: reminder.content,
+            ownerName: reminder.owner?.name,
+            meta: reminder.meta,
+            echoback: reminder.echoback,
+            createdAt: reminder.createdAt ?? baselineTs,
+            priority: reminder.priority ?? 'medium',
+        })),
+    };
+    const q4hRecord = {
+        ts: baselineTs,
+        type: 'questions4human_reconciled_record',
+        ...FORK_BASELINE_ANCHOR,
+        questions: cloneQuestions(plan.questions),
+    };
+    const pendingRecord = {
+        ts: baselineTs,
+        type: 'pending_subdialogs_reconciled_record',
+        ...FORK_BASELINE_ANCHOR,
+        pendingSubdialogs: clonePendingSubdialogs(plan.pendingSubdialogs),
+    };
+    const registryRecord = {
+        ts: baselineTs,
+        type: 'subdialog_registry_reconciled_record',
+        ...FORK_BASELINE_ANCHOR,
+        entries: cloneRegistryEntries(plan.registryEntries),
+    };
+    const responsesRecord = {
+        ts: baselineTs,
+        type: 'subdialog_responses_reconciled_record',
+        ...FORK_BASELINE_ANCHOR,
+        responses: cloneSubdialogResponses(plan.subdialogResponses),
+    };
+    await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, remindersRecord, 'running');
+    await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, q4hRecord, 'running');
+    await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, pendingRecord, 'running');
+    await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, registryRecord, 'running');
+    await persistence_1.DialogPersistence.appendEvent(plan.targetId, 1, responsesRecord, 'running');
+}
+async function persistForkPlan(args) {
+    const { plan } = args;
+    let rewrittenMetadata;
+    if (plan.targetId.selfId === plan.targetId.rootId) {
+        rewrittenMetadata = {
+            ...plan.metadata,
+            id: plan.targetId.selfId,
+            createdAt: args.now,
+        };
+    }
+    else {
+        if (plan.metadata.supdialogId === undefined) {
+            throw new Error(`fork subdialog plan missing supdialog metadata: ${plan.targetId.valueOf()}`);
+        }
+        rewrittenMetadata = rewriteSubdialogMetadataForFork(plan.metadata, plan.sourceId.rootId, plan.targetId.rootId);
+    }
+    await persistence_1.DialogPersistence.saveDialogMetadata(plan.targetId, rewrittenMetadata, 'running');
+    for (const course of plan.retainedCourses) {
+        for (const event of course.events) {
+            await persistence_1.DialogPersistence.appendEvent(plan.targetId, course.course, rewriteRecordForFork(event, plan.targetId.rootId), 'running');
+        }
+    }
+    await appendForkBaselineState(plan, plan.targetId.selfId === plan.targetId.rootId ? args.rootBaselineRecords : []);
+    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) => ({
+        key: entry.key,
+        subdialogId: new dialog_1.DialogID(entry.subdialogId, plan.targetId.rootId),
+        agentId: entry.agentId,
+        sessionSlug: entry.sessionSlug,
+    })), 'running');
+    await persistence_1.DialogPersistence.saveSubdialogResponses(plan.targetId, [...plan.subdialogResponses], undefined, 'running');
+    await copyArtifactsIfPresent(plan.sourceId, plan.targetId, args.sourceStatus);
+    const currentCourseEvents = plan.retainedCourses.find((item) => item.course === plan.currentCourse)?.events ?? [];
+    const runState = plan.targetId.selfId === plan.targetId.rootId
+        ? computeRootForkRunState({
+            action: args.action,
+            questions: plan.questions,
+            pendingSubdialogs: plan.pendingSubdialogs,
+        })
+        : { kind: 'idle_waiting_user' };
+    await persistence_1.DialogPersistence.mutateDialogLatest(plan.targetId, () => ({
+        kind: 'replace',
+        next: {
+            currentCourse: plan.currentCourse,
+            lastModified: args.now,
+            status: 'active',
+            messageCount: countMessages(currentCourseEvents),
+            functionCallCount: countFunctionCalls(currentCourseEvents),
+            subdialogCount: plan.childCount,
+            generating: false,
+            needsDrive: false,
+            runState,
+            disableDiligencePush: plan.targetId.selfId === plan.targetId.rootId ? args.latestDisableDiligencePush : false,
+            diligencePushRemainingBudget: plan.targetId.selfId === plan.targetId.rootId
+                ? args.latestDiligencePushRemainingBudget
+                : undefined,
+        },
+    }));
+}
+async function forkRootDialogTreeAtGeneration(args) {
+    const sourceRootId = args.sourceRootId.trim();
+    if (sourceRootId === '') {
+        throw new Error('sourceRootId is required');
+    }
+    if (!Number.isFinite(args.course) || args.course <= 0) {
+        throw new Error('course must be a positive integer');
+    }
+    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);
+    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}`);
+    }
+    const targetCourse = Math.floor(args.course);
+    const targetGenseq = Math.floor(args.genseq);
+    const rootEvents = await persistence_1.DialogPersistence.readCourseEvents(sourceRootDialogId, 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)}`);
+    }
+    const targetStartEvent = rootEvents[targetStartIndex];
+    if (!targetStartEvent) {
+        throw new Error(`Target genseq ${String(targetGenseq)} missing start event in dialog ${sourceRootId} course ${String(targetCourse)}`);
+    }
+    const cutoffAnchor = {
+        rootCourse: targetCourse,
+        rootGenseq: targetGenseq - 1,
+    };
+    const draftUserText = normalizeDraftUserText(rootEvents, targetGenseq);
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(sourceRootDialogId, args.sourceStatus);
+    const targetRootId = (0, id_1.generateDialogID)();
+    const now = (0, time_1.formatUnifiedTimestamp)(new Date());
+    const includedSubdialogs = await collectIncludedSubdialogs({
+        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);
+    }
+    const rootPlan = await buildDialogForkPlan({
+        sourceId: sourceRootDialogId,
+        targetId: new dialog_1.DialogID(targetRootId),
+        sourceStatus: args.sourceStatus,
+        sourceMetadata,
+        cutoffAnchor,
+        truncateRootCourse: { course: targetCourse, keepCount: targetStartIndex },
+        childCount: childCountByParentSelfId.get(sourceRootId) ?? 0,
+    });
+    const action = draftUserText !== null
+        ? { kind: 'draft_user_text', userText: draftUserText }
+        : rootPlan.questions.length > 0 || rootPlan.pendingSubdialogs.length > 0
+            ? {
+                kind: 'restore_pending',
+                pendingQ4H: rootPlan.questions.length > 0,
+                pendingSubdialogs: rootPlan.pendingSubdialogs.length > 0,
+            }
+            : { kind: 'auto_continue' };
+    const subdialogPlans = [];
+    for (const subdialog of includedSubdialogs) {
+        subdialogPlans.push(await buildDialogForkPlan({
+            sourceId: subdialog.sourceId,
+            targetId: subdialog.targetId,
+            sourceStatus: args.sourceStatus,
+            sourceMetadata: subdialog.metadata,
+            cutoffAnchor,
+            childCount: childCountByParentSelfId.get(subdialog.sourceId.selfId) ?? 0,
+        }));
+    }
+    const rootBaselineRecords = includedSubdialogs.map((subdialog) => ({
+        ts: now,
+        type: 'subdialog_created_record',
+        ...FORK_BASELINE_ANCHOR,
+        subdialogId: subdialog.targetId.selfId,
+        supdialogId: rewriteForkTreeDialogSelfId(subdialog.metadata.supdialogId, sourceRootId, targetRootId),
+        agentId: subdialog.metadata.agentId,
+        taskDocPath: subdialog.metadata.taskDocPath,
+        createdAt: subdialog.metadata.createdAt,
+        sessionSlug: subdialog.metadata.sessionSlug,
+        assignmentFromSup: rewriteAssignmentFromSupForFork(subdialog.metadata.assignmentFromSup, sourceRootId, targetRootId),
+    }));
+    const allPlans = [rootPlan, ...subdialogPlans];
+    for (const plan of allPlans) {
+        await persistForkPlan({
+            plan,
+            sourceStatus: args.sourceStatus,
+            now,
+            action,
+            rootBaselineRecords,
+            latestDisableDiligencePush: latest?.disableDiligencePush,
+            latestDiligencePushRemainingBudget: latest?.diligencePushRemainingBudget,
+        });
+    }
+    return {
+        rootId: targetRootId,
+        selfId: targetRootId,
+        agentId: sourceMetadata.agentId,
+        taskDocPath: sourceMetadata.taskDocPath,
+        action,
+    };
+}

package/dist/dialog.js

@@ -1041,7 +1041,7 @@ class RootDialog extends Dialog {
             agentId: subdialog.agentId,
             sessionSlug: subdialog.sessionSlug,
         }));
-        await this.dlgStore.saveSubdialogRegistry(this.id, entries, this.status);
+        await this.dlgStore.saveSubdialogRegistry(this, this.id, entries, this.status);
     }
     /**
      * Load subdialog registry from disk (registry.yaml).
@@ -1124,7 +1124,7 @@ class DialogStore {
     async loadPendingSubdialogs(_dialogId, _status) {
         return [];
     }
-    async saveSubdialogRegistry(_rootDialogId, _entries, _status) { }
+    async saveSubdialogRegistry(_dialog, _rootDialogId, _entries, _status) { }
     async loadSubdialogRegistry(_rootDialog, _status) { }
     /**
      * Clear Questions for Human state in storage