dominds 1.18.2 → 1.19.3

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/cli/team-definition-audit.d.ts

@@ -8,10 +8,11 @@ export type McpDeclaredToolsets = Readonly<{
     kind: 'loaded';
     declaredServerIds: ReadonlySet<string>;
     invalidServerIds: ReadonlySet<string>;
+    disabledServerIds: ReadonlySet<string>;
 }>;
 export type ToolsetAuditItem = Readonly<{
     toolsetName: string;
-    status: 'registered' | 'mcp_declared_unloaded' | 'mcp_declared_invalid' | 'missing';
+    status: 'registered' | 'mcp_declared_unloaded' | 'mcp_declared_invalid' | 'mcp_declared_disabled' | 'missing';
 }>;
 export type ToolsetAuditReport = Readonly<{
     mcp: McpDeclaredToolsets;

package/dist/cli/team-definition-audit.js

@@ -45,6 +45,7 @@ async function readMcpDeclaredToolsets() {
         kind: 'loaded',
         declaredServerIds: new Set(parsed.serverIdsInYamlOrder),
         invalidServerIds: new Set(parsed.invalidServers.map((s) => s.serverId)),
+        disabledServerIds: new Set(parsed.disabledServerIdsInYamlOrder),
     };
 }
 function buildToolsetAuditReport(params) {
@@ -58,20 +59,28 @@ function buildToolsetAuditReport(params) {
         const explicitToolsets = listExplicitToolsets(member);
         const items = [];
         for (const toolsetName of explicitToolsets) {
-            if (registeredToolsets.has(toolsetName)) {
-                items.push({ toolsetName, status: 'registered' });
-                continue;
-            }
             if (params.mcp.kind === 'loaded' && params.mcp.declaredServerIds.has(toolsetName)) {
                 if (params.mcp.invalidServerIds.has(toolsetName)) {
                     items.push({ toolsetName, status: 'mcp_declared_invalid' });
                     warnings.push(`@${member.id}: toolset '${toolsetName}' is declared in mcp.yaml but server config is invalid.`);
                 }
+                else if (params.mcp.disabledServerIds.has(toolsetName)) {
+                    items.push({ toolsetName, status: 'mcp_declared_disabled' });
+                }
                 else {
-                    items.push({ toolsetName, status: 'mcp_declared_unloaded' });
+                    if (registeredToolsets.has(toolsetName)) {
+                        items.push({ toolsetName, status: 'registered' });
+                    }
+                    else {
+                        items.push({ toolsetName, status: 'mcp_declared_unloaded' });
+                    }
                 }
                 continue;
             }
+            if (registeredToolsets.has(toolsetName)) {
+                items.push({ toolsetName, status: 'registered' });
+                continue;
+            }
             items.push({ toolsetName, status: 'missing' });
             warnings.push(`@${member.id}: toolset '${toolsetName}' is neither registered nor declared in mcp.yaml.`);
         }
@@ -91,6 +100,7 @@ function countByStatus(report) {
         registered: 0,
         mcp_declared_unloaded: 0,
         mcp_declared_invalid: 0,
+        mcp_declared_disabled: 0,
         missing: 0,
     };
     for (const memberReport of report.byMember) {
@@ -107,6 +117,8 @@ function statusLabel(status) {
         return 'DEFERRED';
     if (status === 'mcp_declared_invalid')
         return 'INVALID';
+    if (status === 'mcp_declared_disabled')
+        return 'DISABLED';
     return 'MISS';
 }
 function hasHardToolsetAuditFailures(report) {
@@ -125,12 +137,12 @@ function printToolsetAudit(report, options) {
         process.stdout.write('- MCP config: invalid (`.minds/mcp.yaml` parse/read failed)\n');
     }
     else {
-        process.stdout.write(`- MCP config: loaded (declared servers: ${report.mcp.declaredServerIds.size}, invalid server configs: ${report.mcp.invalidServerIds.size})\n`);
+        process.stdout.write(`- MCP config: loaded (declared servers: ${report.mcp.declaredServerIds.size}, invalid server configs: ${report.mcp.invalidServerIds.size}, disabled servers: ${report.mcp.disabledServerIds.size})\n`);
     }
-    process.stdout.write(`- Summary: ${counts.registered} OK, ${counts.mcp_declared_unloaded} DEFERRED, ${counts.mcp_declared_invalid} INVALID, ${counts.missing} MISS\n`);
+    process.stdout.write(`- Summary: ${counts.registered} OK, ${counts.mcp_declared_unloaded} DEFERRED, ${counts.mcp_declared_disabled} DISABLED, ${counts.mcp_declared_invalid} INVALID, ${counts.missing} MISS\n`);
     if (options?.includeTransientLegend !== false) {
         process.stdout.write('- Status notes: `DEFERRED` means the toolset is declared via `.minds/mcp.yaml` but is not currently loaded into the registry. This is often temporary (for example MCP server down/unreachable); if the MCP service recovers, rerun validation and it may clear without editing `team.yaml`.\n');
-        process.stdout.write('- Status notes: `INVALID` means the MCP server declaration itself is invalid and needs a config fix. `MISS` means the toolset is neither registered nor declared in `.minds/mcp.yaml`.\n');
+        process.stdout.write('- Status notes: `DISABLED` means the MCP server has `enabled: false`; it remains declared but intentionally exposes zero tools until `mcp_restart` enables it. `INVALID` means the MCP server declaration itself is invalid and needs a config fix. `MISS` means the toolset is neither registered nor declared in `.minds/mcp.yaml`.\n');
     }
     if (report.byMember.length === 0) {
         process.stdout.write('- Members: none\n');

package/dist/cli/validate-team-def.js

@@ -8,10 +8,10 @@ function printUsage() {
     console.log('Usage: dominds validate_team_def [<member-id>]');
     console.log('');
     console.log('Validate explicit toolset declarations in `.minds/team.yaml` against the current toolset registry and `.minds/mcp.yaml` declarations.');
-    console.log('MCP-declared but currently unloaded toolsets are reported as `DEFERRED` because they are often transient runtime availability issues rather than permanent team-definition errors.');
+    console.log('MCP-declared but currently unloaded toolsets are reported as `DEFERRED`; disabled MCP toolsets are reported as `DISABLED` when `enabled: false` is set in `.minds/mcp.yaml`.');
     console.log('');
     console.log('Exit codes:');
-    console.log('  0  No hard definition errors (`OK` / `DEFERRED` only)');
+    console.log('  0  No hard definition errors (`OK` / `DEFERRED` / `DISABLED` only)');
     console.log('  2  Hard definition errors found (`INVALID` / `MISS`)');
     console.log('');
     console.log('Examples:');
@@ -70,7 +70,7 @@ async function main() {
             mcp: await (0, team_definition_audit_1.readMcpDeclaredToolsets)(),
         });
         process.stdout.write('# Team Definition Validation\n');
-        process.stdout.write('This command checks explicit toolset references in `.minds/team.yaml`. `DEFERRED` usually means the toolset is declared through MCP but is not currently loaded; if the MCP service recovers, rerun this command before editing `team.yaml`.\n');
+        process.stdout.write('This command checks explicit toolset references in `.minds/team.yaml`. `DEFERRED` usually means the toolset is declared through MCP but is not currently loaded; `DISABLED` means the server is intentionally `enabled: false` and exposes zero tools until `mcp_restart` enables it.\n');
         (0, team_definition_audit_1.printToolsetAudit)(report, { heading: '## Definition Audit' });
         if ((0, team_definition_audit_1.hasHardToolsetAuditFailures)(report)) {
             process.exit(2);

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;