dominds 1.18.2 → 1.19.2

package/dist/access-control.js

@@ -18,7 +18,7 @@ function isMindsPath(targetPath) {
     const normalized = targetPath.replace(/\\/g, '/').replace(/^\/+/, '');
     return normalized === '.minds' || normalized.startsWith('.minds/');
 }
-function isRootDialogsPath(targetPath) {
+function isMainDialogsPath(targetPath) {
     // Only deny `.dialogs/**` at rtws root; allow nested `foo/.dialogs/**` for dev rtws layouts.
     const normalized = targetPath.replace(/\\/g, '/').replace(/^\/+/, '');
     return normalized === '.dialogs' || normalized.startsWith('.dialogs/');
@@ -188,9 +188,9 @@ function hasReadAccess(member, targetPath) {
     if (isEncapsulatedTaskPath(relativePath)) {
         return false;
     }
-    // Root dialogs (`.dialogs/**`) are reserved runtime state.
+    // Main dialogs (`.dialogs/**`) are reserved runtime state.
     // Hard-denied for all general file tools at rtws root (but allowed under nested workspaces).
-    if (isRootDialogsPath(relativePath)) {
+    if (isMainDialogsPath(relativePath)) {
         return false;
     }
     // Minds (`.minds/**`) is reserved rtws state.
@@ -251,9 +251,9 @@ function hasWriteAccess(member, targetPath) {
     if (isEncapsulatedTaskPath(relativePath)) {
         return false;
     }
-    // Root dialogs (`.dialogs/**`) are reserved runtime state.
+    // Main dialogs (`.dialogs/**`) are reserved runtime state.
     // Hard-denied for all general file tools at rtws root (but allowed under nested workspaces).
-    if (isRootDialogsPath(relativePath)) {
+    if (isMainDialogsPath(relativePath)) {
         return false;
     }
     // Minds (`.minds/**`) is reserved rtws state.
@@ -336,7 +336,7 @@ function getAccessDeniedMessage(operation, targetPath, language = 'en') {
             lines.push(`- Hint: If your team configured the \`team_mgmt\` toolset, use its tools (\`team_mgmt_*\`); otherwise (or if you lack access), tellask a team-admin / a member with \`team_mgmt\` access to manage it for you.`);
         }
     }
-    if (isRootDialogsPath(targetPath)) {
+    if (isMainDialogsPath(targetPath)) {
         lines.push('');
         if (language === 'zh') {
             lines.push(`- 说明：\`.dialogs/\` 是 rtws 根目录下的“对话/运行态持久化”目录，通用文件工具无法读写（硬编码无条件拒绝）。`);

package/dist/apps/runtime.d.ts

@@ -21,7 +21,7 @@ export declare function listDynamicAppToolsetsForMember(_params: {
     taskDocPath: string;
     memberId: string;
     dialogId?: string;
-    rootDialogId?: string;
+    mainDialogId?: string;
     agentId?: string;
     sessionSlug?: string;
 }): Promise<readonly string[]>;
@@ -30,7 +30,7 @@ export declare function resolveDynamicAppToolAvailabilityForMember(_params: {
     taskDocPath: string;
     memberId: string;
     dialogId?: string;
-    rootDialogId?: string;
+    mainDialogId?: string;
     agentId?: string;
     sessionSlug?: string;
 }): Promise<DynamicAppToolAvailabilityResult>;

package/dist/apps/runtime.js

@@ -42,41 +42,41 @@ function formatAppCapabilityUnavailableMessage(params) {
         'This app-specific capability is unavailable for now. Continue with other available tools unless this app is required.',
     ].join('\n');
 }
-function resolveRootDialogFor(dlg) {
-    if (dlg instanceof dialog_1.RootDialog) {
+function resolveMainDialogFor(dlg) {
+    if (dlg instanceof dialog_1.MainDialog) {
         return dlg;
     }
-    if (dlg instanceof dialog_1.SubDialog) {
-        return dlg.rootDialog;
+    if (dlg instanceof dialog_1.SideDialog) {
+        return dlg.mainDialog;
     }
     throw new Error(`Unsupported dialog type for app runtime: ${dlg.constructor.name}`);
 }
-async function ensureRootDialogLoaded(rootId) {
+async function ensureMainDialogLoaded(rootId) {
     const existing = dialog_global_registry_1.globalDialogRegistry.get(rootId);
     if (existing) {
-        await existing.loadSubdialogRegistry();
-        await existing.loadPendingSubdialogsFromPersistence();
+        await existing.loadSideDialogRegistry();
+        await existing.loadPendingSideDialogsFromPersistence();
         return existing;
     }
-    return await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(rootId, 'running');
+    return await (0, dialog_instance_registry_1.getOrRestoreMainDialog)(rootId, 'running');
 }
-async function ensureDialogLoadedBySelfId(rootDialog, dialogSelfId) {
-    if (dialogSelfId === rootDialog.id.rootId) {
-        return rootDialog;
+async function ensureDialogLoadedBySelfId(mainDialog, dialogSelfId) {
+    if (dialogSelfId === mainDialog.id.rootId) {
+        return mainDialog;
     }
-    const existing = rootDialog.lookupDialog(dialogSelfId);
+    const existing = mainDialog.lookupDialog(dialogSelfId);
     if (existing) {
         return existing;
     }
-    return await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, new dialog_1.DialogID(dialogSelfId, rootDialog.id.rootId), 'running');
+    return await (0, dialog_instance_registry_1.ensureDialogLoaded)(mainDialog, new dialog_1.DialogID(dialogSelfId, mainDialog.id.rootId), 'running');
 }
 function describeTarget(target) {
     if ('dialogId' in target) {
         return `dialogId=${target.dialogId}`;
     }
     const parts = [`agentId=${target.agentId}`];
-    if (target.rootDialogId) {
-        parts.push(`rootDialogId=${target.rootDialogId}`);
+    if (target.mainDialogId) {
+        parts.push(`mainDialogId=${target.mainDialogId}`);
     }
     if (target.sessionSlug) {
         parts.push(`sessionSlug=${target.sessionSlug}`);
@@ -84,7 +84,7 @@ function describeTarget(target) {
     return parts.join(' ');
 }
 async function resolveTargetDialog(sourceDlg, target) {
-    const sourceRoot = resolveRootDialogFor(sourceDlg);
+    const sourceRoot = resolveMainDialogFor(sourceDlg);
     if ('dialogId' in target) {
         const matches = [];
         const seenDialogKeys = new Set();
@@ -102,7 +102,7 @@ async function resolveTargetDialog(sourceDlg, target) {
             pushMatch(await ensureDialogLoadedBySelfId(loadedRoot, target.dialogId));
         }
         if (target.dialogId !== sourceRoot.id.rootId) {
-            pushMatch(await ensureRootDialogLoaded(target.dialogId));
+            pushMatch(await ensureMainDialogLoaded(target.dialogId));
         }
         if (matches.length === 1) {
             return matches[0];
@@ -112,19 +112,19 @@ async function resolveTargetDialog(sourceDlg, target) {
         }
         throw new Error(`dialog reminder target is ambiguous (${describeTarget(target)})`);
     }
-    const targetRootId = target.rootDialogId ?? sourceRoot.id.rootId;
-    const targetRoot = targetRootId === sourceRoot.id.rootId ? sourceRoot : await ensureRootDialogLoaded(targetRootId);
+    const targetRootId = target.mainDialogId ?? sourceRoot.id.rootId;
+    const targetRoot = targetRootId === sourceRoot.id.rootId ? sourceRoot : await ensureMainDialogLoaded(targetRootId);
     if (!targetRoot) {
         throw new Error(`dialog reminder target root not found (${describeTarget(target)})`);
     }
-    await targetRoot.loadSubdialogRegistry();
-    await targetRoot.loadPendingSubdialogsFromPersistence();
+    await targetRoot.loadSideDialogRegistry();
+    await targetRoot.loadPendingSideDialogsFromPersistence();
     if (target.sessionSlug) {
-        const subdialog = targetRoot.lookupSubdialog(target.agentId, target.sessionSlug);
-        if (!subdialog) {
+        const sideDialog = targetRoot.lookupSideDialog(target.agentId, target.sessionSlug);
+        if (!sideDialog) {
             throw new Error(`dialog reminder target not found (${describeTarget(target)})`);
         }
-        return subdialog;
+        return sideDialog;
     }
     const matches = targetRoot.getAllDialogs().filter((dialog) => dialog.agentId === target.agentId);
     if (matches.length === 1) {
@@ -286,10 +286,10 @@ function registerAppArtifacts(app) {
                     const host = await ensureAppsHostReadyForToolCalls();
                     const result = await host.callTool(t.name, args, {
                         dialogId: dlg.id.selfId,
-                        rootDialogId: dlg.id.rootId,
+                        mainDialogId: dlg.id.rootId,
                         agentId: dlg.agentId,
                         taskDocPath: dlg.taskDocPath,
-                        sessionSlug: dlg instanceof dialog_1.SubDialog ? dlg.sessionSlug : undefined,
+                        sessionSlug: dlg instanceof dialog_1.SideDialog ? dlg.sessionSlug : undefined,
                         callerId: caller.id,
                     });
                     if (Array.isArray(result.reminderRequests) && result.reminderRequests.length > 0) {
@@ -476,8 +476,8 @@ async function resolveDynamicAppToolAvailabilityForMember(_params) {
             ...(typeof _params.dialogId === 'string' && _params.dialogId.trim() !== ''
                 ? { dialogId: _params.dialogId.trim() }
                 : {}),
-            ...(typeof _params.rootDialogId === 'string' && _params.rootDialogId.trim() !== ''
-                ? { rootDialogId: _params.rootDialogId.trim() }
+            ...(typeof _params.mainDialogId === 'string' && _params.mainDialogId.trim() !== ''
+                ? { mainDialogId: _params.mainDialogId.trim() }
                 : {}),
             ...(typeof _params.agentId === 'string' && _params.agentId.trim() !== ''
                 ? { agentId: _params.agentId.trim() }

package/dist/apps-host/client.d.ts

@@ -12,7 +12,7 @@ export type EnabledAppForHost = Readonly<{
 export type AppsHostClient = Readonly<{
     callTool: (toolName: string, args: ToolArguments, ctx: Readonly<{
         dialogId: string;
-        rootDialogId: string;
+        mainDialogId: string;
         agentId: string;
         taskDocPath: string;
         sessionSlug?: string;

package/dist/apps-host/host.js

@@ -106,14 +106,14 @@ function parseDialogTargetRef(value) {
     if (typeof agentId !== 'string' || agentId.trim() === '') {
         throw new Error('Invalid dialog reminder target: agentId required when dialogId is absent');
     }
-    const rootDialogIdRaw = value['rootDialogId'];
-    const rootDialogId = rootDialogIdRaw === undefined
+    const mainDialogIdRaw = value['mainDialogId'];
+    const mainDialogId = mainDialogIdRaw === undefined
         ? undefined
-        : typeof rootDialogIdRaw === 'string' && rootDialogIdRaw.trim() !== ''
-            ? rootDialogIdRaw
+        : typeof mainDialogIdRaw === 'string' && mainDialogIdRaw.trim() !== ''
+            ? mainDialogIdRaw
             : null;
-    if (rootDialogId === null) {
-        throw new Error('Invalid dialog reminder target: rootDialogId must be non-empty string');
+    if (mainDialogId === null) {
+        throw new Error('Invalid dialog reminder target: mainDialogId must be non-empty string');
     }
     const sessionSlugRaw = value['sessionSlug'];
     const sessionSlug = sessionSlugRaw === undefined
@@ -124,7 +124,7 @@ function parseDialogTargetRef(value) {
     if (sessionSlug === null) {
         throw new Error('Invalid dialog reminder target: sessionSlug must be non-empty string');
     }
-    return { agentId, rootDialogId, sessionSlug };
+    return { agentId, mainDialogId, sessionSlug };
 }
 function parseDialogReminderRequestBatch(value) {
     if (!isRecord(value))

package/dist/apps-host/ipc-types.d.ts

@@ -23,7 +23,7 @@ export type AppsHostKernelToolCallMessage = Readonly<{
     args: ToolArguments;
     ctx: Readonly<{
         dialogId: string;
-        rootDialogId: string;
+        mainDialogId: string;
         agentId: string;
         taskDocPath: string;
         sessionSlug?: string;
@@ -37,7 +37,7 @@ export type AppsHostKernelDynamicToolsetsMessage = Readonly<{
         memberId: string;
         taskDocPath: string;
         dialogId?: string;
-        rootDialogId?: string;
+        mainDialogId?: string;
         agentId?: string;
         sessionSlug?: string;
     }>;

package/dist/apps-host/ipc-types.js

@@ -173,7 +173,7 @@ function parseAppsHostMessageFromKernel(v) {
         if (!isRecord(ctx))
             throw new Error('Invalid tool_call message: ctx must be object');
         const dialogId = asString(ctx['dialogId']);
-        const rootDialogId = asString(ctx['rootDialogId']);
+        const mainDialogId = asString(ctx['mainDialogId']);
         const agentId = asString(ctx['agentId']);
         const taskDocPath = asString(ctx['taskDocPath']);
         const sessionSlugRaw = ctx['sessionSlug'];
@@ -185,8 +185,8 @@ function parseAppsHostMessageFromKernel(v) {
         const callerId = asString(ctx['callerId']);
         if (!dialogId)
             throw new Error('Invalid tool_call message: ctx.dialogId required');
-        if (!rootDialogId)
-            throw new Error('Invalid tool_call message: ctx.rootDialogId required');
+        if (!mainDialogId)
+            throw new Error('Invalid tool_call message: ctx.mainDialogId required');
         if (!agentId)
             throw new Error('Invalid tool_call message: ctx.agentId required');
         if (!taskDocPath)
@@ -204,7 +204,7 @@ function parseAppsHostMessageFromKernel(v) {
             args: args,
             ctx: {
                 dialogId,
-                rootDialogId,
+                mainDialogId,
                 agentId,
                 taskDocPath,
                 sessionSlug: normalizedSessionSlug,
@@ -223,8 +223,8 @@ function parseAppsHostMessageFromKernel(v) {
         const taskDocPath = asString(ctx['taskDocPath']);
         const dialogIdRaw = ctx['dialogId'];
         const dialogId = dialogIdRaw === undefined ? undefined : asString(dialogIdRaw);
-        const rootDialogIdRaw = ctx['rootDialogId'];
-        const rootDialogId = rootDialogIdRaw === undefined ? undefined : asString(rootDialogIdRaw);
+        const mainDialogIdRaw = ctx['mainDialogId'];
+        const mainDialogId = mainDialogIdRaw === undefined ? undefined : asString(mainDialogIdRaw);
         const agentIdRaw = ctx['agentId'];
         const agentId = agentIdRaw === undefined ? undefined : asString(agentIdRaw);
         const sessionSlugRaw = ctx['sessionSlug'];
@@ -236,8 +236,8 @@ function parseAppsHostMessageFromKernel(v) {
         if (dialogIdRaw !== undefined && dialogId === null) {
             throw new Error('Invalid dynamic_toolsets message: ctx.dialogId must be string when present');
         }
-        if (rootDialogIdRaw !== undefined && rootDialogId === null) {
-            throw new Error('Invalid dynamic_toolsets message: ctx.rootDialogId must be string when present');
+        if (mainDialogIdRaw !== undefined && mainDialogId === null) {
+            throw new Error('Invalid dynamic_toolsets message: ctx.mainDialogId must be string when present');
         }
         if (agentIdRaw !== undefined && agentId === null) {
             throw new Error('Invalid dynamic_toolsets message: ctx.agentId must be string when present');
@@ -246,7 +246,7 @@ function parseAppsHostMessageFromKernel(v) {
             throw new Error('Invalid dynamic_toolsets message: ctx.sessionSlug must be string when present');
         }
         const normalizedDialogId = dialogId ?? undefined;
-        const normalizedRootDialogId = rootDialogId ?? undefined;
+        const normalizedMainDialogId = mainDialogId ?? undefined;
         const normalizedAgentId = agentId ?? undefined;
         const normalizedSessionSlug = sessionSlug ?? undefined;
         return {
@@ -256,7 +256,7 @@ function parseAppsHostMessageFromKernel(v) {
                 memberId,
                 taskDocPath,
                 dialogId: normalizedDialogId,
-                rootDialogId: normalizedRootDialogId,
+                mainDialogId: normalizedMainDialogId,
                 agentId: normalizedAgentId,
                 sessionSlug: normalizedSessionSlug,
             },

package/dist/cli/read.d.ts

@@ -6,7 +6,6 @@
  *   dominds read [options] [<member-id>]
  *
  * Options:
- *   --no-hints           Don't show hints
  *   --only-prompt        Show only system prompt
  *   --only-mem           Show only memories
  *   --audit              Run prompt audit via hidden teammate @fuxi (skip when default LLM unavailable)

package/dist/cli/read.js

@@ -7,7 +7,6 @@
  *   dominds read [options] [<member-id>]
  *
  * Options:
- *   --no-hints           Don't show hints
  *   --only-prompt        Show only system prompt
  *   --only-mem           Show only memories
  *   --audit              Run prompt audit via hidden teammate @fuxi (skip when default LLM unavailable)
@@ -54,7 +53,7 @@ const load_1 = require("../minds/load");
 const team_1 = require("../team");
 const team_definition_audit_1 = require("./team-definition-audit");
 function printUsage() {
-    console.log('Usage: dominds read [<member-id>] [--no-hints] [--only-prompt|--only-mem] [--audit] [--find <pattern>]');
+    console.log('Usage: dominds read [<member-id>] [--only-prompt|--only-mem] [--audit] [--find <pattern>]');
     console.log('');
     console.log('Print agent system prompt and memories with filtering flags.');
     console.log('`--audit` runs prompt audit via hidden teammate @fuxi using default LLM config (skips when unavailable), and also includes static toolset checks (registry vs `.minds/mcp.yaml` declarations).');
@@ -401,10 +400,6 @@ function parseArgs(args) {
             findPatterns.push(next);
             i++;
         }
-        else if (arg === '--no-hints') {
-            // Deprecated, but keep for compatibility
-            console.warn('Warning: --no-hints is deprecated, use --only-prompt or --only-mem instead');
-        }
         else if (arg === '-h' || arg === '--help') {
             printUsage();
             process.exit(0);

package/dist/dialog-display-state.d.ts

@@ -7,7 +7,7 @@
  * Design constraints:
  * - `displayState` is a UI/diagnostic projection, not a business source of truth.
  * - Primary control flow must rely on underlying facts (active runs, stop requests,
- *   pending Q4H, pending subdialogs, queued prompts, persisted status, explicit
+ *   pending Q4H, pending sideDialogs, queued prompts, persisted status, explicit
  *   interruption/death markers).
  * - The projection is persisted to latest.yaml (`DialogLatestFile.displayState`) so it survives
  *   restarts and multi-tab views can converge quickly.
@@ -37,10 +37,10 @@ export declare function createActiveRun(dialogId: DialogID): AbortSignal;
 export declare function clearActiveRun(dialogId: DialogID, options?: Readonly<{
     notifyBackendLoop?: boolean;
 }>): void;
-export declare function clearRootDialogQuarantiningIfIdle(rootDialogId: DialogID): void;
-export declare function markRootDialogQuarantining(rootDialogId: DialogID): void;
-export declare function clearRootDialogQuarantining(rootDialogId: DialogID): void;
-export declare function forceStopActiveRunsForRootDialog(rootDialogId: DialogID): Promise<void>;
+export declare function clearMainDialogQuarantiningIfIdle(mainDialogId: DialogID): void;
+export declare function markMainDialogQuarantining(mainDialogId: DialogID): void;
+export declare function clearMainDialogQuarantining(mainDialogId: DialogID): void;
+export declare function forceStopActiveRunsForMainDialog(mainDialogId: DialogID): Promise<void>;
 export declare function getStopRequestedReason(dialogId: DialogID): StopRequestedReason | undefined;
 export declare function loadDialogExecutionMarker(dialogId: DialogID, status?: 'running' | 'completed' | 'archived'): Promise<DialogExecutionMarker | undefined>;
 export declare function setDialogExecutionMarker(dialogId: DialogID, executionMarker: DialogExecutionMarker | undefined): Promise<void>;
@@ -51,7 +51,7 @@ export declare function broadcastDisplayStateMarker(dialogId: DialogID, marker:
     reason?: DialogInterruptionReason;
 }): void;
 export declare function computeIdleDisplayState(dlg: Dialog): Promise<DialogDisplayState>;
-export declare function refreshRunControlProjectionFromPersistenceFacts(dialogId: DialogID, trigger: 'resume_dialog' | 'resume_all' | 'run_control_snapshot' | 'pending_subdialogs_changed' | 'q4h_changed'): Promise<DialogLatestFile | null>;
+export declare function refreshRunControlProjectionFromPersistenceFacts(dialogId: DialogID, trigger: 'resume_dialog' | 'resume_all' | 'run_control_snapshot' | 'pending_sideDialogs_changed' | 'q4h_changed'): Promise<DialogLatestFile | null>;
 export declare function reconcileDisplayStatesAfterRestart(): Promise<void>;
 export declare function requestInterruptDialog(dialogId: DialogID, reason: StopRequestedReason): Promise<{
     applied: boolean;

package/dist/dialog-display-state.js

@@ -8,7 +8,7 @@
  * Design constraints:
  * - `displayState` is a UI/diagnostic projection, not a business source of truth.
  * - Primary control flow must rely on underlying facts (active runs, stop requests,
- *   pending Q4H, pending subdialogs, queued prompts, persisted status, explicit
+ *   pending Q4H, pending sideDialogs, queued prompts, persisted status, explicit
  *   interruption/death markers).
  * - The projection is persisted to latest.yaml (`DialogLatestFile.displayState`) so it survives
  *   restarts and multi-tab views can converge quickly.
@@ -28,10 +28,10 @@ exports.hasActiveRun = hasActiveRun;
 exports.getActiveRunSignal = getActiveRunSignal;
 exports.createActiveRun = createActiveRun;
 exports.clearActiveRun = clearActiveRun;
-exports.clearRootDialogQuarantiningIfIdle = clearRootDialogQuarantiningIfIdle;
-exports.markRootDialogQuarantining = markRootDialogQuarantining;
-exports.clearRootDialogQuarantining = clearRootDialogQuarantining;
-exports.forceStopActiveRunsForRootDialog = forceStopActiveRunsForRootDialog;
+exports.clearMainDialogQuarantiningIfIdle = clearMainDialogQuarantiningIfIdle;
+exports.markMainDialogQuarantining = markMainDialogQuarantining;
+exports.clearMainDialogQuarantining = clearMainDialogQuarantining;
+exports.forceStopActiveRunsForMainDialog = forceStopActiveRunsForMainDialog;
 exports.getStopRequestedReason = getStopRequestedReason;
 exports.loadDialogExecutionMarker = loadDialogExecutionMarker;
 exports.setDialogExecutionMarker = setDialogExecutionMarker;
@@ -55,7 +55,7 @@ const interjection_pause_stop_1 = require("./runtime/interjection-pause-stop");
 const log = (0, log_1.createLogger)('dialog-display-state');
 let broadcastToClients;
 const activeRunsByDialogKey = new Map();
-const quarantiningRootDialogIds = new Set();
+const quarantiningMainDialogIds = new Set();
 function setDisplayStateBroadcaster(fn) {
     broadcastToClients = fn;
 }
@@ -113,7 +113,7 @@ async function getRunControlCountsSnapshot() {
         try {
             const dialogKey = dialogId.key();
             seenDialogKeys.add(dialogKey);
-            if (quarantiningRootDialogIds.has(dialogId.rootId)) {
+            if (quarantiningMainDialogIds.has(dialogId.rootId)) {
                 continue;
             }
             // listAllDialogIds() is intentionally a candidate scan. Per-dialog latest reads below may
@@ -139,8 +139,8 @@ async function getRunControlCountsSnapshot() {
                 }
                 else {
                     const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
-                    const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
-                    if (q4h.length === 0 && pendingSubdialogs.length === 0) {
+                    const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
+                    if (q4h.length === 0 && pendingSideDialogs.length === 0) {
                         resumable++;
                     }
                 }
@@ -161,7 +161,7 @@ async function getRunControlCountsSnapshot() {
             continue;
         }
         const [rootId] = dialogKey.includes('#') ? dialogKey.split('#') : [dialogKey];
-        if (!rootId || quarantiningRootDialogIds.has(rootId)) {
+        if (!rootId || quarantiningMainDialogIds.has(rootId)) {
             continue;
         }
         if (!seenDialogKeys.has(dialogKey)) {
@@ -202,10 +202,10 @@ function createActiveRun(dialogId) {
 function clearActiveRun(dialogId, options) {
     const deleted = activeRunsByDialogKey.delete(dialogId.key());
     if (!deleted) {
-        clearQuarantiningRootDialogIfIdle(dialogId.rootId);
+        clearQuarantiningMainDialogIfIdle(dialogId.rootId);
         return;
     }
-    clearQuarantiningRootDialogIfIdle(dialogId.rootId);
+    clearQuarantiningMainDialogIfIdle(dialogId.rootId);
     if (dialogId.selfId === dialogId.rootId && options?.notifyBackendLoop !== false) {
         dialog_global_registry_1.globalDialogRegistry.notifyActiveRunCleared(dialogId.rootId, {
             source: 'dialog_display_state_active_run_clear',
@@ -214,30 +214,30 @@ function clearActiveRun(dialogId, options) {
     }
     syncRunControlCountsAfterActiveRunChange('clear_active_run', dialogId);
 }
-function clearQuarantiningRootDialogIfIdle(rootId) {
+function clearQuarantiningMainDialogIfIdle(rootId) {
     for (const key of activeRunsByDialogKey.keys()) {
         const [candidateRootId] = key.includes('#') ? key.split('#') : [key];
         if (candidateRootId === rootId) {
             return;
         }
     }
-    quarantiningRootDialogIds.delete(rootId);
+    quarantiningMainDialogIds.delete(rootId);
 }
-function clearRootDialogQuarantiningIfIdle(rootDialogId) {
-    clearQuarantiningRootDialogIfIdle(rootDialogId.selfId);
+function clearMainDialogQuarantiningIfIdle(mainDialogId) {
+    clearQuarantiningMainDialogIfIdle(mainDialogId.selfId);
 }
-function markRootDialogQuarantining(rootDialogId) {
-    quarantiningRootDialogIds.add(rootDialogId.selfId);
+function markMainDialogQuarantining(mainDialogId) {
+    quarantiningMainDialogIds.add(mainDialogId.selfId);
 }
-function clearRootDialogQuarantining(rootDialogId) {
-    quarantiningRootDialogIds.delete(rootDialogId.selfId);
+function clearMainDialogQuarantining(mainDialogId) {
+    quarantiningMainDialogIds.delete(mainDialogId.selfId);
 }
-async function forceStopActiveRunsForRootDialog(rootDialogId) {
+async function forceStopActiveRunsForMainDialog(mainDialogId) {
     for (const key of Array.from(activeRunsByDialogKey.keys())) {
         const [rootId, selfId] = key.includes('#') ? key.split('#') : [key, key];
         if (!rootId || !selfId)
             continue;
-        if (rootId !== rootDialogId.selfId)
+        if (rootId !== mainDialogId.selfId)
             continue;
         const dialogId = new dialog_1.DialogID(selfId, rootId);
         const run = activeRunsByDialogKey.get(key);
@@ -252,9 +252,9 @@ async function forceStopActiveRunsForRootDialog(rootDialogId) {
                 });
             }
             catch (error) {
-                log.warn('Failed to persist stop-requested state while forcing root dialog stop', error, {
+                log.warn('Failed to persist stop-requested state while forcing main dialog stop', error, {
                     dialogId: dialogId.valueOf(),
-                    rootDialogId: rootDialogId.valueOf(),
+                    mainDialogId: mainDialogId.valueOf(),
                 });
             }
         }
@@ -262,9 +262,9 @@ async function forceStopActiveRunsForRootDialog(rootDialogId) {
             run.abortController.abort();
         }
         catch (error) {
-            log.warn('Failed to abort active run while forcing root dialog stop', error, {
+            log.warn('Failed to abort active run while forcing main dialog stop', error, {
                 dialogId: dialogId.valueOf(),
-                rootDialogId: rootDialogId.valueOf(),
+                mainDialogId: mainDialogId.valueOf(),
             });
         }
     }
@@ -278,7 +278,7 @@ async function loadDialogExecutionMarker(dialogId, status = 'running') {
 }
 async function setDialogExecutionMarker(dialogId, executionMarker) {
     if (executionMarker?.kind === 'dead' && dialogId.selfId === dialogId.rootId) {
-        log.warn('Rejecting dead executionMarker for root dialog (root dialogs must not be dead)', undefined, {
+        log.warn('Rejecting dead executionMarker for main dialog (main dialogs must not be dead)', undefined, {
             dialogId: dialogId.valueOf(),
         });
         return;
@@ -315,7 +315,7 @@ async function clearDialogInterruptedExecutionMarker(dialogId) {
 }
 async function setDialogDisplayState(dialogId, displayState) {
     if (displayState.kind === 'dead' && dialogId.selfId === dialogId.rootId) {
-        log.warn('Rejecting dead displayState for root dialog (root dialogs must not be dead)', undefined, {
+        log.warn('Rejecting dead displayState for main dialog (main dialogs must not be dead)', undefined, {
             dialogId: dialogId.valueOf(),
         });
         return;
@@ -425,15 +425,15 @@ async function computeIdleDisplayState(dlg) {
         };
     }
     const hasQ4H = await dlg.hasPendingQ4H();
-    const hasSubdialogs = await dlg.hasPendingSubdialogs();
-    if (hasQ4H && hasSubdialogs) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+    const hasSideDialogs = await dlg.hasPendingSideDialogs();
+    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: 'idle_waiting_user' };
 }
@@ -464,17 +464,17 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
         };
     }
     const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
-    const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
+    const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
     const hasQ4H = q4h.length > 0;
-    const hasSubdialogs = pendingSubdialogs.length > 0;
-    if (hasQ4H && hasSubdialogs) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+    const hasSideDialogs = 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: 'idle_waiting_user' };
 }
@@ -501,7 +501,7 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
             // This is the one place where the projection intentionally preserves the paused-interjection
             // stopped state ahead of the current blocker facts. That is not a bug: after a user
             // interjection we want the UI to keep showing "original task paused; click Continue" even if
-            // the underlying dialog is still waiting on Q4H/subdialogs.
+            // the underlying dialog is still waiting on Q4H/sideDialogs.
             //
             // The true source-of-truth decision about what Continue should do next lives in
             // `flow.ts`'s resume path, which performs a fresh fact scan at resume time and then either:
@@ -524,17 +524,17 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
             };
         }
         const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
-        const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
+        const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
         const hasQ4H = q4h.length > 0;
-        const hasSubdialogs = pendingSubdialogs.length > 0;
-        if (hasQ4H && hasSubdialogs) {
-            return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+        const hasSideDialogs = 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' } };
         }
         if (latest.executionMarker?.kind === 'interrupted') {
             return {