dominds 1.18.2 → 1.19.2

package/dist/runtime/reply-prompt-copy.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REPLY_SUPPRESSION_PREFIX_ZH = exports.REPLY_SUPPRESSION_PREFIX_EN = exports.REPLY_REASSERTION_PREFIX_ZH = exports.REPLY_REASSERTION_PREFIX_EN = exports.ACTIVE_REPLY_TOOL_PREFIX_ZH = exports.ACTIVE_REPLY_TOOL_PREFIX_EN = void 0;
 exports.buildActiveReplyToolNote = buildActiveReplyToolNote;
-exports.buildSidelineCompletionRule = buildSidelineCompletionRule;
-exports.buildSubdialogRoleHeaderCopy = buildSubdialogRoleHeaderCopy;
+exports.buildActiveReplyObligationContextText = buildActiveReplyObligationContextText;
+exports.buildSideDialogCompletionRule = buildSideDialogCompletionRule;
+exports.buildSideDialogRoleHeaderCopy = buildSideDialogRoleHeaderCopy;
 exports.buildReplyObligationSuppressionGuideText = buildReplyObligationSuppressionGuideText;
 exports.buildReplyObligationReassertionText = buildReplyObligationReassertionText;
 exports.buildReplyToolReminderText = buildReplyToolReminderText;
@@ -50,26 +51,50 @@ function buildActiveReplyToolNote(args) {
         return [
             exports.ACTIVE_REPLY_TOOL_PREFIX_ZH,
             '先专注处理眼前这轮任务，不要被 `reply*` 选择分心。',
-            `若这轮最终需要对上游完成交付，精确调用 \`${args.toolName}\`；不要改选其他 \`reply*\`，也不要提前收口。`,
+            `若这轮最终需要对诉请者完成交付，精确调用 \`${args.toolName}\`；不要改选其他 \`reply*\`，也不要提前收口。`,
         ].join('\n');
     }
     return [
         exports.ACTIVE_REPLY_TOOL_PREFIX_EN,
         'Stay focused on the task in front of you for this turn; do not get distracted by choosing among `reply*` variants.',
-        `If this turn truly reaches final delivery back upstream, call \`${args.toolName}\` exactly; do not switch to another \`reply*\` variant or close early.`,
+        `If this turn truly reaches final delivery back to the tellasker, call \`${args.toolName}\` exactly; do not switch to another \`reply*\` variant or close early.`,
     ].join('\n');
 }
-function buildSidelineCompletionRule(language) {
+function buildActiveReplyObligationContextText(args) {
+    if (args.language === 'zh') {
+        return [
+            '[Dominds 当前跨对话回复义务]',
+            '这是运行时状态，不是新的用户请求。',
+            `必须回复的目标对话：${args.directive.targetDialogId}`,
+            `必须结清的调用：${args.directive.targetCallId}`,
+            `最终交付时精确调用：\`${args.directive.expectedReplyCallName}({ replyContent })\``,
+            '',
+            '原始诉请内容：',
+            args.directive.tellaskContent,
+        ].join('\n');
+    }
+    return [
+        '[Dominds active inter-dialog reply obligation]',
+        'This is runtime state, not a new user request.',
+        `Target dialog to reply to: ${args.directive.targetDialogId}`,
+        `Call to settle: ${args.directive.targetCallId}`,
+        `At final delivery, call exactly: \`${args.directive.expectedReplyCallName}({ replyContent })\``,
+        '',
+        'Original request content:',
+        args.directive.tellaskContent,
+    ].join('\n');
+}
+function buildSideDialogCompletionRule(language) {
     return language === 'zh'
         ? '当前支线已完成并能给出最终交付时：先专注把当前任务做对；若运行时点名了精确 reply 函数，就只在最终交付收口时调用那个函数，不要改选其他 `reply*`，也不要再走 `tellaskBack`。'
-        : 'If the current sideline is complete and can deliver the final result: stay focused on finishing the actual task first; if runtime names an exact reply function, call that function only at final upstream delivery, do not switch among `reply*` variants, and do not use `tellaskBack` for final delivery.';
+        : 'If the current Side Dialog is complete and can deliver the final result: stay focused on finishing the actual task first; if runtime names an exact reply function, call that function only at final tellasker delivery, do not switch among `reply*` variants, and do not use `tellaskBack` for final delivery.';
 }
-function buildSubdialogRoleHeaderCopy(args) {
-    const requester = `@${args.requesterId}`;
+function buildSideDialogRoleHeaderCopy(args) {
+    const tellaskerTag = `@${args.tellaskerId}`;
     if (args.expectedReplyTool === undefined) {
         return args.language === 'zh'
-            ? `${requester} 已通过诉请安排你处理下述诉请内容。只有确实需要向上游回问、且现有规程无法直接判责时，才调用 \`tellaskBack\`。`
-            : `${requester} has assigned you to handle the request content below. Call \`tellaskBack\` only when you truly need to ask upstream back and existing SOP cannot directly identify another owner.`;
+            ? `${tellaskerTag} 已通过诉请安排你处理下述诉请内容。只有确实需要向诉请者回问、且现有规程无法直接判责时，才调用 \`tellaskBack\`。`
+            : `${tellaskerTag} has assigned you to handle the request content below. Call \`tellaskBack\` only when you truly need to ask the tellasker back and existing SOP cannot directly identify another owner.`;
     }
     const kindLabel = (0, tellask_labels_1.getTellaskKindLabel)({
         language: args.language,
@@ -77,8 +102,8 @@ function buildSubdialogRoleHeaderCopy(args) {
         bracketed: true,
     });
     return args.language === 'zh'
-        ? `${requester} 已通过${kindLabel}安排你处理下述诉请内容。等你准备好回复内容后，调用 \`${args.expectedReplyTool}\` 完成回复。只有确实需要向上游回问、且现有规程无法直接判责时，才调用 \`tellaskBack\`。`
-        : `${requester} has assigned you, via this ${kindLabel}, to handle the request content below. Once your reply content is ready, call \`${args.expectedReplyTool}\` to deliver it. Call \`tellaskBack\` only when you truly need to ask upstream back and existing SOP cannot directly identify another owner.`;
+        ? `${tellaskerTag} 已通过${kindLabel}安排你处理下述诉请内容。等你准备好回复内容后，调用 \`${args.expectedReplyTool}\` 完成回复。只有确实需要向诉请者回问、且现有规程无法直接判责时，才调用 \`tellaskBack\`。`
+        : `${tellaskerTag} has assigned you, via this ${kindLabel}, to handle the request content below. Once your reply content is ready, call \`${args.expectedReplyTool}\` to deliver it. Call \`tellaskBack\` only when you truly need to ask the tellasker back and existing SOP cannot directly identify another owner.`;
 }
 function buildReplyObligationSuppressionGuideText(language) {
     if (language === 'zh') {
@@ -121,7 +146,7 @@ function buildReplyToolReminderText(args) {
             `你刚才已经写了正文，但还没调用 \`${args.directive.expectedReplyCallName}\`。`,
             '',
             buildReplyToolReminderLine(args),
-            '如果你再次直接输出最终消息而仍不调用该工具，运行时当前会暂按 direct-reply fallback 投递，并在 UI/传递正文中明确标注。',
+            '如果你再次直接输出最终消息而仍不调用该工具，运行时会按 direct-reply fallback 投递，并在 UI/传递正文中明确标注。',
         ].join('\n')
         : [
             args.prefix,
@@ -129,7 +154,7 @@ function buildReplyToolReminderText(args) {
             `You already wrote the reply body, but you still have not called \`${args.directive.expectedReplyCallName}\`.`,
             '',
             buildReplyToolReminderLine(args),
-            'If you still emit a plain final message without the tool, runtime will currently deliver it via direct-reply fallback and label that path explicitly in UI and transfer text.',
+            'If you still emit a plain final message without the tool, runtime will deliver it via direct-reply fallback and label that path explicitly in UI and transfer text.',
         ].join('\n');
 }
 function isStandaloneRuntimeGuidePromptContent(content) {

package/dist/server/api-routes.js

@@ -133,15 +133,15 @@ async function loadDialogMetadataForLookup(dialogId, status, context) {
         return null;
     }
 }
-async function loadRootDialogMetadataForLookup(dialogId, status, context) {
+async function loadMainDialogMetadataForLookup(dialogId, status, context) {
     try {
-        return await persistence_1.DialogPersistence.loadRootDialogMetadata(dialogId, status);
+        return await persistence_1.DialogPersistence.loadMainDialogMetadata(dialogId, status);
     }
     catch (error) {
         if (!(0, persistence_errors_1.findDomindsPersistenceFileError)(error)) {
             throw error;
         }
-        log.warn(`${context}: root dialog metadata quarantined during lazy lookup`, error, {
+        log.warn(`${context}: main dialog metadata quarantined during lazy lookup`, error, {
             dialogId: dialogId.valueOf(),
             status,
         });
@@ -165,17 +165,17 @@ async function loadDialogLatestForLookup(dialogId, status, context) {
 }
 async function detectWaitingForFreshBootsReasoning(dialogId, status) {
     try {
-        // Pending-subdialogs is also lazy-loaded per dialog. A malformed queue should quarantine just
+        // Pending-sideDialogs is also lazy-loaded per dialog. A malformed queue should quarantine just
         // that dialog and degrade this derived flag to "unknown/false" instead of taking down the
         // surrounding list or hierarchy response.
-        const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, status);
+        const pending = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, status);
         return pending.some((entry) => entry.callName === 'freshBootsReasoning');
     }
     catch (error) {
         if (!(0, persistence_errors_1.findDomindsPersistenceFileError)(error)) {
             throw error;
         }
-        log.warn('detectWaitingForFreshBootsReasoning: pending-subdialogs quarantined during lookup', error, {
+        log.warn('detectWaitingForFreshBootsReasoning: pending-sideDialogs quarantined during lookup', error, {
             dialogId: dialogId.valueOf(),
             status,
         });
@@ -1197,12 +1197,12 @@ async function handleApiRoute(req, res, pathname, context) {
             const parts = pathname.split('/');
             const rawRoot = parts[3];
             if (!rawRoot) {
-                respondJson(res, 400, { success: false, error: 'Missing root dialog id' });
+                respondJson(res, 400, { success: false, error: 'Missing main dialog id' });
                 return true;
             }
             return await handleForkDialog(req, res, context, rawRoot.replace(/%2F/g, '/'));
         }
-        // Delete a dialog (root dialogs only for now)
+        // Delete a dialog (main dialogs only for now)
         if (pathname.startsWith('/api/dialogs/') &&
             !pathname.endsWith('/hierarchy') &&
             !pathname.endsWith('/fork') &&
@@ -1210,7 +1210,7 @@ async function handleApiRoute(req, res, pathname, context) {
             const parts = pathname.split('/');
             const rawRoot = parts[3];
             if (!rawRoot) {
-                respondJson(res, 400, { error: 'Missing root dialog id' });
+                respondJson(res, 400, { error: 'Missing main dialog id' });
                 return true;
             }
             const rawSelf = parts[4];
@@ -1226,7 +1226,7 @@ async function handleApiRoute(req, res, pathname, context) {
             }
             return await handleDeleteDialog(res, { rootId, selfId, fromStatus: fromStatusRaw }, context);
         }
-        // Get full hierarchy for a single root dialog
+        // Get full hierarchy for a single main dialog
         if (pathname.startsWith('/api/dialogs/') &&
             pathname.endsWith('/hierarchy') &&
             req.method === 'GET') {
@@ -1241,7 +1241,7 @@ async function handleApiRoute(req, res, pathname, context) {
             const status = parsedStatus.kind === 'missing' ? 'running' : parsedStatus.status;
             return await handleGetDialogHierarchy(res, rootId, status);
         }
-        // Get one subdialog node specifically for dialog-list backfill
+        // Get one sideDialog node specifically for dialog-list backfill
         if (pathname.startsWith('/api/dialogs/') &&
             pathname.endsWith('/list-node') &&
             req.method === 'GET') {
@@ -1256,9 +1256,9 @@ async function handleApiRoute(req, res, pathname, context) {
                 respondJson(res, 400, { success: false, error: 'Invalid dialog id path encoding' });
                 return true;
             }
-            const subdialogsSeg = parts[4];
+            const sideDialogsSeg = parts[4];
             const listNodeSeg = parts[6];
-            if (!rootId || subdialogsSeg !== 'subdialogs' || !selfId || listNodeSeg !== 'list-node') {
+            if (!rootId || sideDialogsSeg !== 'sideDialogs' || !selfId || listNodeSeg !== 'list-node') {
                 respondJson(res, 404, { success: false, error: 'Not Found' });
                 return true;
             }
@@ -1269,7 +1269,7 @@ async function handleApiRoute(req, res, pathname, context) {
                 return true;
             }
             const status = parsedStatus.kind === 'missing' ? 'running' : parsedStatus.status;
-            return await handleGetDialogListSubdialogNode(res, { rootId, selfId, status });
+            return await handleGetDialogListSideDialogNode(res, { rootId, selfId, status });
         }
         // Serve persisted dialog artifacts (binary)
         if (pathname.startsWith('/api/dialogs/') &&
@@ -1280,7 +1280,7 @@ async function handleApiRoute(req, res, pathname, context) {
             const rawMaybeSelf = parts[4];
             const rawTail = parts[5];
             if (!rawRoot) {
-                respondJson(res, 400, { error: 'Missing root dialog id' });
+                respondJson(res, 400, { error: 'Missing main dialog id' });
                 return true;
             }
             const rootId = rawRoot.replace(/%2F/g, '/');
@@ -2104,38 +2104,38 @@ async function handleGetTeamConfig(res) {
     }
 }
 /**
- * Get dialog list - returns root dialogs with subdialogCount
+ * Get dialog list - returns main dialogs with sideDialogCount
  */
 async function handleGetDialogs(res, status) {
     try {
-        const rootDialogs = [];
+        const mainDialogs = [];
         const allDialogIds = await persistence_1.DialogPersistence.listAllDialogIds(status);
-        const subdialogCountByRootId = new Map();
+        const sideDialogCountByRootId = new Map();
         for (const dialogId of allDialogIds) {
             if (dialogId.selfId === dialogId.rootId)
                 continue;
-            subdialogCountByRootId.set(dialogId.rootId, (subdialogCountByRootId.get(dialogId.rootId) ?? 0) + 1);
+            sideDialogCountByRootId.set(dialogId.rootId, (sideDialogCountByRootId.get(dialogId.rootId) ?? 0) + 1);
         }
         const ids = await persistence_1.DialogPersistence.listDialogs(status);
         for (const id of ids) {
             const dialogId = new dialog_1.DialogID(id);
-            const meta = await loadRootDialogMetadataForLookup(dialogId, status, 'handleListDialogs');
+            const meta = await loadMainDialogMetadataForLookup(dialogId, status, 'handleListDialogs');
             if (!meta)
                 continue;
             // listDialogs() only yields candidate IDs. Metadata/latest stay lazy so one malformed dialog
             // can quarantine itself here without taking down the whole list response.
             const latest = await loadDialogLatestForLookup(dialogId, status, 'handleListDialogs');
-            const rootPath = persistence_1.DialogPersistence.getRootDialogPath(dialogId, status);
+            const rootPath = persistence_1.DialogPersistence.getMainDialogPath(dialogId, status);
             const rootStillExists = await pathStillExistsForLookup(rootPath);
             if (!rootStillExists) {
                 continue;
             }
             const waitingForFreshBootsReasoning = await detectWaitingForFreshBootsReasoning(dialogId, status);
-            const subdialogCount = subdialogCountByRootId.get(meta.id) ?? 0;
+            const sideDialogCount = sideDialogCountByRootId.get(meta.id) ?? 0;
             if (!(await pathStillExistsForLookup(rootPath))) {
                 continue;
             }
-            rootDialogs.push({
+            mainDialogs.push({
                 rootId: meta.id,
                 agentId: meta.agentId,
                 taskDocPath: meta.taskDocPath,
@@ -2145,15 +2145,15 @@ async function handleGetDialogs(res, status) {
                 lastModified: latest?.lastModified || meta.createdAt,
                 displayState: latest?.displayState,
                 waitingForFreshBootsReasoning,
-                subdialogCount,
+                sideDialogCount,
             });
         }
-        respondJson(res, 200, { success: true, dialogs: rootDialogs });
+        respondJson(res, 200, { success: true, dialogs: mainDialogs });
         return true;
     }
     catch (error) {
-        log.error('Error getting root dialogs:', error);
-        respondJson(res, 500, { success: false, error: 'Failed to get root dialogs' });
+        log.error('Error getting main dialogs:', error);
+        respondJson(res, 500, { success: false, error: 'Failed to get main dialogs' });
         return true;
     }
 }
@@ -2176,26 +2176,26 @@ async function handleGetRunControlCounts(res) {
     }
 }
 /**
- * Get full hierarchy (root + subdialogs) for a single root dialog
+ * Get full hierarchy (main dialog + sideDialogs) for a single main dialog
  */
 async function handleGetDialogHierarchy(res, rootId, status) {
     try {
-        const rootMeta = await loadRootDialogMetadataForLookup(new dialog_1.DialogID(rootId), status, 'handleGetDialogHierarchy:root');
+        const rootMeta = await loadMainDialogMetadataForLookup(new dialog_1.DialogID(rootId), status, 'handleGetDialogHierarchy:root');
         if (!rootMeta) {
             respondJson(res, 404, {
                 success: false,
-                error: `Root dialog ${rootId} not found in ${status}`,
+                error: `Main dialog ${rootId} not found in ${status}`,
             });
             return true;
         }
-        // Load latest.yaml for root dialog currentCourse and lastModified timestamp
+        // Load latest.yaml for main dialog currentCourse and lastModified timestamp
         const rootLatest = await loadDialogLatestForLookup(new dialog_1.DialogID(rootId), status, 'handleGetDialogHierarchy:root');
-        const rootPath = persistence_1.DialogPersistence.getRootDialogPath(new dialog_1.DialogID(rootId), status);
+        const rootPath = persistence_1.DialogPersistence.getMainDialogPath(new dialog_1.DialogID(rootId), status);
         const rootStillExists = await pathStillExistsForLookup(rootPath);
         if (!rootStillExists) {
             respondJson(res, 404, {
                 success: false,
-                error: `Root dialog ${rootId} was quarantined as malformed`,
+                error: `Main dialog ${rootId} was quarantined as malformed`,
             });
             return true;
         }
@@ -2213,36 +2213,38 @@ async function handleGetDialogHierarchy(res, rootId, status) {
         if (!(await pathStillExistsForLookup(rootPath))) {
             respondJson(res, 404, {
                 success: false,
-                error: `Root dialog ${rootId} was quarantined as malformed`,
+                error: `Main dialog ${rootId} was quarantined as malformed`,
             });
             return true;
         }
-        let subdialogs = [];
+        let sideDialogs = [];
         const dialogIds = await persistence_1.DialogPersistence.listAllDialogIds(status);
         for (const dialogId of dialogIds) {
             if (dialogId.rootId !== rootId || dialogId.selfId === rootId) {
                 continue;
             }
-            const meta = await loadDialogMetadataForLookup(dialogId, status, 'handleGetDialogHierarchy:subdialog');
+            const meta = await loadDialogMetadataForLookup(dialogId, status, 'handleGetDialogHierarchy:sideDialog');
             if (!meta) {
                 continue;
             }
-            const subLatest = await loadDialogLatestForLookup(dialogId, status, 'handleGetDialogHierarchy:subdialog');
+            const subLatest = await loadDialogLatestForLookup(dialogId, status, 'handleGetDialogHierarchy:sideDialog');
             const waitingForFreshBootsReasoning = await detectWaitingForFreshBootsReasoning(dialogId, status);
-            const subdialogPath = persistence_1.DialogPersistence.getSubdialogPath(dialogId, status);
-            if (!(await pathStillExistsForLookup(subdialogPath))) {
+            const sideDialogPath = persistence_1.DialogPersistence.getSideDialogPath(dialogId, status);
+            if (!(await pathStillExistsForLookup(sideDialogPath))) {
                 continue;
             }
-            const derivedSupdialogId = meta.assignmentFromSup?.callerDialogId &&
-                meta.assignmentFromSup.callerDialogId.trim() !== ''
-                ? meta.assignmentFromSup.callerDialogId
-                : typeof meta.supdialogId === 'string' && meta.supdialogId.trim() !== ''
-                    ? meta.supdialogId
-                    : undefined;
-            subdialogs.push({
+            const assignmentFromAsker = await persistence_1.DialogPersistence.loadSideDialogAssignmentFromAsker(dialogId, status);
+            const derivedAskerDialogId = assignmentFromAsker.askerDialogId.trim();
+            if (!derivedAskerDialogId) {
+                const error = new Error(`sideDialog hierarchy invariant violation: missing assignmentFromAsker.askerDialogId ` +
+                    `(rootId=${rootId}, selfId=${dialogId.selfId}, status=${status})`);
+                log.error('sideDialog hierarchy invariant violation: missing assignmentFromAsker.askerDialogId', error, { rootId, selfId: dialogId.selfId, status });
+                throw error;
+            }
+            sideDialogs.push({
                 selfId: meta.id,
                 rootId,
-                supdialogId: derivedSupdialogId,
+                askerDialogId: derivedAskerDialogId,
                 agentId: meta.agentId,
                 taskDocPath: meta.taskDocPath,
                 status,
@@ -2251,15 +2253,15 @@ async function handleGetDialogHierarchy(res, rootId, status) {
                 lastModified: subLatest?.lastModified || meta.createdAt,
                 displayState: subLatest?.displayState,
                 sessionSlug: meta.sessionSlug,
-                assignmentFromSup: meta.assignmentFromSup,
+                assignmentFromAsker,
                 waitingForFreshBootsReasoning,
             });
         }
         respondJson(res, 200, {
             success: true,
             hierarchy: {
-                root: { ...rootInfo, subdialogCount: subdialogs.length },
-                subdialogs,
+                root: { ...rootInfo, sideDialogCount: sideDialogs.length },
+                sideDialogs,
             },
         });
         return true;
@@ -2271,51 +2273,53 @@ async function handleGetDialogHierarchy(res, rootId, status) {
     }
 }
 /**
- * Get one subdialog node for dialog-list backfill without reloading the whole hierarchy.
+ * Get one sideDialog node for dialog-list backfill without reloading the whole hierarchy.
  */
-async function handleGetDialogListSubdialogNode(res, dialog) {
+async function handleGetDialogListSideDialogNode(res, dialog) {
     try {
         const status = dialog.status;
         if (dialog.selfId === dialog.rootId) {
             respondJson(res, 400, {
                 success: false,
-                error: 'Dialog-list subdialog node requires a subdialog selfId',
+                error: 'Dialog-list sideDialog node requires a sideDialog selfId',
             });
             return true;
         }
         const dialogId = new dialog_1.DialogID(dialog.selfId, dialog.rootId);
-        const metadata = await loadDialogMetadataForLookup(dialogId, status, 'handleGetDialogListSubdialogNode');
+        const metadata = await loadDialogMetadataForLookup(dialogId, status, 'handleGetDialogListSideDialogNode');
         if (!metadata) {
             respondJson(res, 404, { success: false, error: `Dialog not found in ${status}` });
             return true;
         }
         if (metadata.id !== dialog.selfId) {
-            throw new Error(`CRITICAL: dialog-list subdialog node metadata id mismatch. expected=${dialog.selfId} actual=${metadata.id} rootId=${dialog.rootId} status=${status}`);
+            throw new Error(`CRITICAL: dialog-list sideDialog node metadata id mismatch. expected=${dialog.selfId} actual=${metadata.id} rootId=${dialog.rootId} status=${status}`);
         }
         if (metadata.id === dialog.rootId) {
-            throw new Error(`CRITICAL: dialog-list subdialog node lookup resolved root dialog. rootId=${dialog.rootId} selfId=${dialog.selfId} status=${status}`);
+            throw new Error(`CRITICAL: dialog-list sideDialog node lookup resolved main dialog. rootId=${dialog.rootId} selfId=${dialog.selfId} status=${status}`);
         }
-        const latest = await loadDialogLatestForLookup(dialogId, status, 'handleGetDialogListSubdialogNode');
+        const latest = await loadDialogLatestForLookup(dialogId, status, 'handleGetDialogListSideDialogNode');
         const waitingForFreshBootsReasoning = await detectWaitingForFreshBootsReasoning(dialogId, status);
-        const rootSubdialogCount = await persistence_1.DialogPersistence.countAllSubdialogsUnderRoot(new dialog_1.DialogID(dialog.rootId), status);
-        const subdialogPath = persistence_1.DialogPersistence.getSubdialogPath(dialogId, status);
-        if (!(await pathStillExistsForLookup(subdialogPath))) {
+        const rootSideDialogCount = await persistence_1.DialogPersistence.countAllSideDialogsUnderRoot(new dialog_1.DialogID(dialog.rootId), status);
+        const sideDialogPath = persistence_1.DialogPersistence.getSideDialogPath(dialogId, status);
+        if (!(await pathStillExistsForLookup(sideDialogPath))) {
             respondJson(res, 404, { success: false, error: `Dialog not found in ${status}` });
             return true;
         }
-        const derivedSupdialogId = metadata.assignmentFromSup?.callerDialogId &&
-            metadata.assignmentFromSup.callerDialogId.trim() !== ''
-            ? metadata.assignmentFromSup.callerDialogId
-            : typeof metadata.supdialogId === 'string' && metadata.supdialogId.trim() !== ''
-                ? metadata.supdialogId
-                : undefined;
+        const assignmentFromAsker = await persistence_1.DialogPersistence.loadSideDialogAssignmentFromAsker(dialogId, status);
+        const derivedAskerDialogId = assignmentFromAsker.askerDialogId.trim();
+        if (!derivedAskerDialogId) {
+            const error = new Error(`dialog-list sideDialog node invariant violation: missing assignmentFromAsker.askerDialogId ` +
+                `(rootId=${dialog.rootId}, selfId=${dialog.selfId}, status=${status})`);
+            log.error('dialog-list sideDialog node invariant violation: missing assignmentFromAsker.askerDialogId', error, { rootId: dialog.rootId, selfId: dialog.selfId, status });
+            throw error;
+        }
         respondJson(res, 200, {
             success: true,
-            subdialogNode: {
+            sideDialogNode: {
                 selfId: metadata.id,
                 rootId: dialog.rootId,
-                rootSubdialogCount,
-                supdialogId: derivedSupdialogId,
+                rootSideDialogCount,
+                askerDialogId: derivedAskerDialogId,
                 agentId: metadata.agentId,
                 taskDocPath: metadata.taskDocPath,
                 status,
@@ -2324,17 +2328,17 @@ async function handleGetDialogListSubdialogNode(res, dialog) {
                 lastModified: latest?.lastModified ?? metadata.createdAt,
                 displayState: latest?.displayState,
                 sessionSlug: metadata.sessionSlug,
-                assignmentFromSup: metadata.assignmentFromSup,
+                assignmentFromAsker,
                 waitingForFreshBootsReasoning,
             },
         });
         return true;
     }
     catch (error) {
-        log.error('Error getting dialog-list subdialog node:', error);
+        log.error('Error getting dialog-list sideDialog node:', error);
         respondJson(res, 500, {
             success: false,
-            error: 'Failed to get dialog-list subdialog node',
+            error: 'Failed to get dialog-list sideDialog node',
         });
         return true;
     }
@@ -2368,8 +2372,8 @@ async function handleCreateDialog(req, res, context) {
         // Create dialog UI based on context
         // Always use DiskFileDialogStore for file-based persistence
         const dialogUI = new persistence_1.DiskFileDialogStore(dialogId);
-        // Create RootDialog
-        const dialog = new dialog_1.RootDialog(dialogUI, taskDocPath, dialogId, agentId);
+        // Create MainDialog
+        const dialog = new dialog_1.MainDialog(dialogUI, taskDocPath, dialogId, agentId);
         dialog.setPersistenceStatus('running');
         dialog_global_registry_1.globalDialogRegistry.register(dialog);
         const team = await team_1.Team.load();
@@ -2383,7 +2387,7 @@ async function handleCreateDialog(req, res, context) {
             agentId: agentId,
             taskDocPath: taskDocPath,
             createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-            priming: (0, priming_1.buildRootDialogPrimingMetadata)(priming),
+            priming: (0, priming_1.buildMainDialogPrimingMetadata)(priming),
         };
         await persistence_1.DialogPersistence.saveDialogMetadata(new dialog_1.DialogID(dialogId.selfId), metadata);
         // Initialize latest.yaml via the mutation API (write-back will flush).
@@ -2395,7 +2399,7 @@ async function handleCreateDialog(req, res, context) {
                 status: 'active',
                 messageCount: 0,
                 functionCallCount: 0,
-                subdialogCount: 0,
+                sideDialogCount: 0,
                 displayState: { kind: 'idle_waiting_user' },
                 disableDiligencePush: defaultDisableDiligencePush,
                 diligencePushRemainingBudget: dialog.diligencePushRemainingBudget,
@@ -2474,7 +2478,7 @@ async function handleForkDialog(req, res, context, rootIdRaw) {
             respondJson(res, 400, payload);
             return true;
         }
-        const result = await (0, dialog_fork_1.forkRootDialogTreeAtGeneration)({
+        const result = await (0, dialog_fork_1.forkMainDialogTreeAtGeneration)({
             sourceRootId: rootId,
             sourceStatus: status,
             course,
@@ -2548,11 +2552,11 @@ async function handleMoveDialogs(req, res, context) {
                 respondJson(res, 400, { success: false, error: 'rootId must be a non-empty string' });
                 return true;
             }
-            const meta = await loadRootDialogMetadataForLookup(new dialog_1.DialogID(rootId), fromStatus, 'handleMoveDialogs:root');
+            const meta = await loadMainDialogMetadataForLookup(new dialog_1.DialogID(rootId), fromStatus, 'handleMoveDialogs:root');
             if (!meta) {
                 respondJson(res, 404, {
                     success: false,
-                    error: `Root dialog ${rootId} not found in ${fromStatus}`,
+                    error: `Main dialog ${rootId} not found in ${fromStatus}`,
                 });
                 return true;
             }
@@ -2585,7 +2589,7 @@ async function handleMoveDialogs(req, res, context) {
         for (const id of ids) {
             if (typeof id !== 'string' || id.trim() === '')
                 continue;
-            const meta = await loadRootDialogMetadataForLookup(new dialog_1.DialogID(id), fromStatus, 'handleMoveDialogs:task-scan');
+            const meta = await loadMainDialogMetadataForLookup(new dialog_1.DialogID(id), fromStatus, 'handleMoveDialogs:task-scan');
             if (!meta)
                 continue;
             if (meta.taskDocPath !== taskDocPath)
@@ -2675,7 +2679,7 @@ async function handleDeleteDialog(res, dialog, context) {
     try {
         const { rootId, selfId, fromStatus } = dialog;
         if (typeof rootId !== 'string' || rootId.trim() === '') {
-            respondJson(res, 400, { error: 'Invalid root dialog id' });
+            respondJson(res, 400, { error: 'Invalid main dialog id' });
             return true;
         }
         if (typeof selfId !== 'string' || selfId.trim() === '') {
@@ -2684,11 +2688,11 @@ async function handleDeleteDialog(res, dialog, context) {
         }
         if (selfId !== rootId) {
             respondJson(res, 400, {
-                error: 'Only root dialog deletion is supported (use /api/dialogs/:root)',
+                error: 'Only main dialog deletion is supported (use /api/dialogs/:root)',
             });
             return true;
         }
-        const deleted = await persistence_1.DialogPersistence.deleteRootDialog(new dialog_1.DialogID(rootId), fromStatus);
+        const deleted = await persistence_1.DialogPersistence.deleteMainDialog(new dialog_1.DialogID(rootId), fromStatus);
         if (!deleted) {
             respondJson(res, 404, { error: `Dialog not found in ${fromStatus}` });
             return true;

package/dist/server/static-server.js

@@ -39,7 +39,7 @@ Available API endpoints:
 • GET /api/team/config - Team configuration
 • GET /api/dialogs - List all dialogs
 • POST /api/dialogs - Create new dialog
-• GET /api/dialogs/:root/subdialogs/:self/list-node - Get one dialog-list subdialog node
+• GET /api/dialogs/:root/sideDialogs/:self/list-node - Get one dialog-list sideDialog node
 • GET /api/dialogs/:root/hierarchy - Get dialog hierarchy
 • GET /api/task-documents - Taskdoc listing