dominds 1.10.3 → 1.11.2

package/dist/cli/doctor.js

@@ -71,6 +71,11 @@ function summarizeIssue(params) {
 async function runDoctor(params) {
     const declaredDeps = await (0, manifest_1.loadRtwsDeclaredAppDependencies)({ rtwsRootAbs: params.rtwsRootAbs });
     const declaredAppIds = new Set(declaredDeps.map((dep) => dep.id));
+    const loadedSelfManifest = await (0, manifest_1.loadDomindsAppManifest)({
+        packageRootAbs: params.rtwsRootAbs,
+        manifestRelPath: manifest_1.DEFAULT_DOMINDS_APP_MANIFEST_REL_PATH,
+    });
+    const selfManifest = loadedSelfManifest.kind === 'ok' ? loadedSelfManifest.manifest : null;
     const loadedLock = await (0, app_lock_file_1.loadAppLockFile)({ rtwsRootAbs: params.rtwsRootAbs });
     if (loadedLock.kind === 'error') {
         throw new Error(`Failed to read .minds/app-lock.yaml: ${loadedLock.errorText}`);
@@ -115,14 +120,16 @@ async function runDoctor(params) {
     for (const appId of [...appIds].sort()) {
         if (params.appId !== null && appId !== params.appId)
             continue;
+        const isSelfTarget = appId === '.';
         const dep = declaredDeps.find((item) => item.id === appId) ?? null;
+        const declaredSelf = isSelfTarget && selfManifest !== null;
         const locked = lockById.get(appId) ?? null;
         const disabled = disabledApps.has(appId);
         const resolutionEntry = resolutionById.get(appId) ?? null;
         const freshEntry = freshResolutionById.get(appId) ?? null;
         const reasons = [];
         const nextActions = [];
-        if (!dep) {
+        if (!dep && !declaredSelf) {
             addReason(reasons, 'not declared in .minds/app.yaml dependencies');
             addNextAction(nextActions, `Add '${appId}' to .minds/app.yaml dependencies if this app should be active in the rtws.`);
         }
@@ -167,7 +174,7 @@ async function runDoctor(params) {
         diagnoses.push({
             appId,
             status: reasons.length === 0 ? 'healthy' : 'degraded',
-            declared: dep !== null,
+            declared: dep !== null || declaredSelf,
             declaredAsOptional: dep?.optional === true,
             lockedPackage: locked ? formatLockedPackage(locked.name, locked.version) : null,
             disabled,

package/dist/cli/manual.d.ts

@@ -3,12 +3,12 @@
  * Manual subcommand for dominds CLI
  *
  * Usage:
- *   dominds manual <toolsetId> [--topic <name>|--topics <a,b,c>|--all] [--lang <en|zh>]
- *   dominds manual --list
+ *   dominds man <toolsetId> [--topic <name>|--topics <a,b,c>|--all] [--lang <en|zh>]
+ *   dominds man --list
  *
  * Examples:
- *   dominds manual ws_read --lang zh --all
- *   dominds manual team_mgmt --topics index,tools
+ *   dominds man ws_read --lang zh --all
+ *   dominds man team_mgmt --topics index,tools
  */
 import '../tools/builtins';
 export declare function main(): Promise<void>;

package/dist/cli/manual.js

@@ -4,28 +4,32 @@
  * Manual subcommand for dominds CLI
  *
  * Usage:
- *   dominds manual <toolsetId> [--topic <name>|--topics <a,b,c>|--all] [--lang <en|zh>]
- *   dominds manual --list
+ *   dominds man <toolsetId> [--topic <name>|--topics <a,b,c>|--all] [--lang <en|zh>]
+ *   dominds man --list
  *
  * Examples:
- *   dominds manual ws_read --lang zh --all
- *   dominds manual team_mgmt --topics index,tools
+ *   dominds man ws_read --lang zh --all
+ *   dominds man team_mgmt --topics index,tools
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
 require("../tools/builtins");
-const render_1 = require("../tools/manual/render");
 const spec_1 = require("../tools/manual/spec");
 const registry_1 = require("../tools/registry");
+const toolset_manual_1 = require("../tools/toolset-manual");
 function printUsage() {
-    console.log('Usage: dominds manual <toolsetId> [--topic <name>|--topics <a,b,c>|--all] [--lang <en|zh>]');
-    console.log('       dominds manual --list');
+    console.log('Usage: dominds man <toolsetId> [--topic <name>|--topics <a,b,c>|--all] [--lang <en|zh>]');
+    console.log('       dominds man --list');
+    console.log('Alias: dominds manual ...');
+    console.log('');
+    console.log("Note: the topic list below shows common manual topics. Some toolsets (for example `team_mgmt`) expose additional toolset-specific topic keys; run `dominds man <toolsetId> --all` to see that toolset's dedicated index.");
     console.log('');
     console.log('Examples:');
-    console.log('  dominds manual ws_read --lang zh --all');
-    console.log('  dominds manual team_mgmt --topics index,tools');
+    console.log('  dominds man ws_read --lang zh --all');
+    console.log('  dominds man team_mgmt --topics index,tools');
+    console.log('  dominds man team_mgmt --all');
     console.log('');
-    console.log(`Topics: ${spec_1.MANUAL_TOPICS.join(', ')} (or 'all')`);
+    console.log(`Common topics: ${spec_1.MANUAL_TOPICS.join(', ')} (or 'all')`);
 }
 function normalizeLanguage(raw) {
     if (!raw)
@@ -157,21 +161,14 @@ async function main() {
             process.exit(1);
         }
         const availableToolNames = toAvailableToolNames(toolsetId);
-        const result = (0, render_1.renderToolsetManual)({
+        const content = await (0, toolset_manual_1.renderToolsetManualContent)({
             toolsetId,
             language: parsed.language,
-            request: {
-                requestedTopic: parsed.topic,
-                requestedTopics: parsed.topics,
-            },
+            topic: parsed.topic,
+            topics: parsed.topics,
             availableToolNames,
         });
-        if (!result.foundToolset) {
-            console.error(`Error: Toolset '${toolsetId}' not found.`);
-            listAvailableToolsets();
-            process.exit(1);
-        }
-        console.log(result.content);
+        console.log(content);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);

package/dist/cli/read.js

@@ -50,11 +50,9 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
-const promises_1 = require("fs/promises");
-const config_1 = require("../mcp/config");
 const load_1 = require("../minds/load");
 const team_1 = require("../team");
-const registry_1 = require("../tools/registry");
+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('');
@@ -343,128 +341,6 @@ function printPromptAudit(report) {
         process.stdout.write(`${report.rewriteSuggestion.trim()}\n`);
     }
 }
-function listExplicitToolsets(member) {
-    if (!member.toolsets)
-        return [];
-    const out = [];
-    const seen = new Set();
-    for (const entry of member.toolsets) {
-        if (entry === '*' || entry.startsWith('!'))
-            continue;
-        if (seen.has(entry))
-            continue;
-        seen.add(entry);
-        out.push(entry);
-    }
-    return out;
-}
-async function readMcpDeclaredToolsets() {
-    const mcpPath = '.minds/mcp.yaml';
-    let raw;
-    try {
-        raw = await (0, promises_1.readFile)(mcpPath, 'utf8');
-    }
-    catch (err) {
-        if (typeof err === 'object' &&
-            err !== null &&
-            'code' in err &&
-            err.code === 'ENOENT') {
-            return { kind: 'missing' };
-        }
-        return { kind: 'invalid', errorText: err instanceof Error ? err.message : String(err) };
-    }
-    const parsed = (0, config_1.parseMcpYaml)(raw);
-    if (!parsed.ok) {
-        return { kind: 'invalid', errorText: parsed.errorText };
-    }
-    return {
-        kind: 'loaded',
-        declaredServerIds: new Set(parsed.serverIdsInYamlOrder),
-        invalidServerIds: new Set(parsed.invalidServers.map((s) => s.serverId)),
-    };
-}
-function buildToolsetAuditReport(params) {
-    const registeredToolsets = new Set(Object.keys((0, registry_1.listToolsets)()));
-    const byMember = [];
-    const warnings = [];
-    for (const memberId of params.targetMemberIds) {
-        const member = params.team.getMember(memberId);
-        if (!member)
-            continue;
-        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 {
-                    items.push({ toolsetName, status: 'mcp_declared_unloaded' });
-                }
-                continue;
-            }
-            items.push({ toolsetName, status: 'missing' });
-            warnings.push(`@${member.id}: toolset '${toolsetName}' is neither registered nor declared in mcp.yaml.`);
-        }
-        byMember.push({ memberId: member.id, memberName: member.name, items });
-    }
-    if (params.mcp.kind === 'invalid') {
-        warnings.push(`Invalid .minds/mcp.yaml; cannot reliably classify unresolved MCP toolsets: ${params.mcp.errorText}`);
-    }
-    return {
-        mcp: params.mcp,
-        byMember,
-        warnings,
-    };
-}
-function printToolsetAudit(report) {
-    process.stdout.write('\n## Toolset Audit\n');
-    if (report.mcp.kind === 'missing') {
-        process.stdout.write('- MCP config: missing (`.minds/mcp.yaml` not found)\n');
-    }
-    else if (report.mcp.kind === 'invalid') {
-        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`);
-    }
-    if (report.byMember.length === 0) {
-        process.stdout.write('- Members: none\n');
-    }
-    else {
-        for (const memberReport of report.byMember) {
-            process.stdout.write(`- @${memberReport.memberId} (${memberReport.memberName}):\n`);
-            if (memberReport.items.length === 0) {
-                process.stdout.write('  - no explicit toolset declarations\n');
-                continue;
-            }
-            for (const item of memberReport.items) {
-                const label = item.status === 'registered'
-                    ? 'OK'
-                    : item.status === 'mcp_declared_unloaded'
-                        ? 'DEFERRED'
-                        : item.status === 'mcp_declared_invalid'
-                            ? 'INVALID'
-                            : 'MISS';
-                process.stdout.write(`  - [${label}] ${item.toolsetName}\n`);
-            }
-        }
-    }
-    if (report.warnings.length > 0) {
-        process.stdout.write('- Warnings:\n');
-        for (const warning of report.warnings) {
-            process.stdout.write(`  - ${warning}\n`);
-        }
-    }
-    else {
-        process.stdout.write('- Warnings: none\n');
-    }
-}
 function collectFindMatches(text, pattern) {
     const normalizedPattern = pattern.toLowerCase();
     const lines = text.split('\n');
@@ -584,10 +460,10 @@ async function main() {
         const isMultiMemberRun = targetMemberIds.length > 1;
         const promptAuditRuntime = parsed.audit ? await preparePromptAuditRuntime(team) : undefined;
         const toolsetAudit = parsed.audit
-            ? buildToolsetAuditReport({
+            ? (0, team_definition_audit_1.buildToolsetAuditReport)({
                 team,
                 targetMemberIds,
-                mcp: await readMcpDeclaredToolsets(),
+                mcp: await (0, team_definition_audit_1.readMcpDeclaredToolsets)(),
             })
             : undefined;
         let auditWarningCount = 0;
@@ -638,7 +514,7 @@ async function main() {
             }
         }
         if (parsed.audit && toolsetAudit) {
-            printToolsetAudit(toolsetAudit);
+            (0, team_definition_audit_1.printToolsetAudit)(toolsetAudit);
             auditWarningCount += toolsetAudit.warnings.length;
         }
         if (parsed.failOnAuditWarning && auditWarningCount > 0) {

package/dist/cli/team-definition-audit.d.ts

@@ -0,0 +1,35 @@
+import { Team } from '../team';
+export type McpDeclaredToolsets = Readonly<{
+    kind: 'missing';
+}> | Readonly<{
+    kind: 'invalid';
+    errorText: string;
+}> | Readonly<{
+    kind: 'loaded';
+    declaredServerIds: ReadonlySet<string>;
+    invalidServerIds: ReadonlySet<string>;
+}>;
+export type ToolsetAuditItem = Readonly<{
+    toolsetName: string;
+    status: 'registered' | 'mcp_declared_unloaded' | 'mcp_declared_invalid' | 'missing';
+}>;
+export type ToolsetAuditReport = Readonly<{
+    mcp: McpDeclaredToolsets;
+    byMember: ReadonlyArray<Readonly<{
+        memberId: string;
+        memberName: string;
+        items: ReadonlyArray<ToolsetAuditItem>;
+    }>>;
+    warnings: string[];
+}>;
+export declare function readMcpDeclaredToolsets(): Promise<McpDeclaredToolsets>;
+export declare function buildToolsetAuditReport(params: {
+    team: Team;
+    targetMemberIds: ReadonlyArray<string>;
+    mcp: McpDeclaredToolsets;
+}): ToolsetAuditReport;
+export declare function hasHardToolsetAuditFailures(report: ToolsetAuditReport): boolean;
+export declare function printToolsetAudit(report: ToolsetAuditReport, options?: Readonly<{
+    heading?: string;
+    includeTransientLegend?: boolean;
+}>): void;

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readMcpDeclaredToolsets = readMcpDeclaredToolsets;
+exports.buildToolsetAuditReport = buildToolsetAuditReport;
+exports.hasHardToolsetAuditFailures = hasHardToolsetAuditFailures;
+exports.printToolsetAudit = printToolsetAudit;
+const promises_1 = require("fs/promises");
+const config_1 = require("../mcp/config");
+const registry_1 = require("../tools/registry");
+function listExplicitToolsets(member) {
+    if (!member.toolsets)
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const entry of member.toolsets) {
+        if (entry === '*' || entry.startsWith('!'))
+            continue;
+        if (seen.has(entry))
+            continue;
+        seen.add(entry);
+        out.push(entry);
+    }
+    return out;
+}
+async function readMcpDeclaredToolsets() {
+    const mcpPath = '.minds/mcp.yaml';
+    let raw;
+    try {
+        raw = await (0, promises_1.readFile)(mcpPath, 'utf8');
+    }
+    catch (err) {
+        if (typeof err === 'object' &&
+            err !== null &&
+            'code' in err &&
+            err.code === 'ENOENT') {
+            return { kind: 'missing' };
+        }
+        return { kind: 'invalid', errorText: err instanceof Error ? err.message : String(err) };
+    }
+    const parsed = (0, config_1.parseMcpYaml)(raw);
+    if (!parsed.ok) {
+        return { kind: 'invalid', errorText: parsed.errorText };
+    }
+    return {
+        kind: 'loaded',
+        declaredServerIds: new Set(parsed.serverIdsInYamlOrder),
+        invalidServerIds: new Set(parsed.invalidServers.map((s) => s.serverId)),
+    };
+}
+function buildToolsetAuditReport(params) {
+    const registeredToolsets = new Set(Object.keys((0, registry_1.listToolsets)()));
+    const byMember = [];
+    const warnings = [];
+    for (const memberId of params.targetMemberIds) {
+        const member = params.team.getMember(memberId);
+        if (!member)
+            continue;
+        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 {
+                    items.push({ toolsetName, status: 'mcp_declared_unloaded' });
+                }
+                continue;
+            }
+            items.push({ toolsetName, status: 'missing' });
+            warnings.push(`@${member.id}: toolset '${toolsetName}' is neither registered nor declared in mcp.yaml.`);
+        }
+        byMember.push({ memberId: member.id, memberName: member.name, items });
+    }
+    if (params.mcp.kind === 'invalid') {
+        warnings.push(`Invalid .minds/mcp.yaml; cannot reliably classify unresolved MCP toolsets: ${params.mcp.errorText}`);
+    }
+    return {
+        mcp: params.mcp,
+        byMember,
+        warnings,
+    };
+}
+function countByStatus(report) {
+    const counts = {
+        registered: 0,
+        mcp_declared_unloaded: 0,
+        mcp_declared_invalid: 0,
+        missing: 0,
+    };
+    for (const memberReport of report.byMember) {
+        for (const item of memberReport.items) {
+            counts[item.status] += 1;
+        }
+    }
+    return counts;
+}
+function statusLabel(status) {
+    if (status === 'registered')
+        return 'OK';
+    if (status === 'mcp_declared_unloaded')
+        return 'DEFERRED';
+    if (status === 'mcp_declared_invalid')
+        return 'INVALID';
+    return 'MISS';
+}
+function hasHardToolsetAuditFailures(report) {
+    if (report.mcp.kind === 'invalid')
+        return true;
+    return report.byMember.some((memberReport) => memberReport.items.some((item) => item.status === 'mcp_declared_invalid' || item.status === 'missing'));
+}
+function printToolsetAudit(report, options) {
+    const heading = options?.heading ?? '## Toolset Audit';
+    const counts = countByStatus(report);
+    process.stdout.write(`\n${heading}\n`);
+    if (report.mcp.kind === 'missing') {
+        process.stdout.write('- MCP config: missing (`.minds/mcp.yaml` not found)\n');
+    }
+    else if (report.mcp.kind === 'invalid') {
+        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(`- Summary: ${counts.registered} OK, ${counts.mcp_declared_unloaded} DEFERRED, ${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');
+    }
+    if (report.byMember.length === 0) {
+        process.stdout.write('- Members: none\n');
+    }
+    else {
+        for (const memberReport of report.byMember) {
+            process.stdout.write(`- @${memberReport.memberId} (${memberReport.memberName}):\n`);
+            if (memberReport.items.length === 0) {
+                process.stdout.write('  - no explicit toolset declarations\n');
+                continue;
+            }
+            for (const item of memberReport.items) {
+                process.stdout.write(`  - [${statusLabel(item.status)}] ${item.toolsetName}\n`);
+            }
+        }
+    }
+    if (report.warnings.length > 0) {
+        process.stdout.write('- Warnings:\n');
+        for (const warning of report.warnings) {
+            process.stdout.write(`  - ${warning}\n`);
+        }
+    }
+    else {
+        process.stdout.write('- Warnings: none\n');
+    }
+}

package/dist/cli/validate-team-def.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(): Promise<void>;

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

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const team_1 = require("../team");
+const team_definition_audit_1 = require("./team-definition-audit");
+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('');
+    console.log('Exit codes:');
+    console.log('  0  No hard definition errors (`OK` / `DEFERRED` only)');
+    console.log('  2  Hard definition errors found (`INVALID` / `MISS`)');
+    console.log('');
+    console.log('Examples:');
+    console.log('  dominds validate_team_def');
+    console.log('  dominds validate_team_def mentor');
+}
+function parseArgs(args) {
+    let memberId;
+    for (const arg of args) {
+        if (arg === '-h' || arg === '--help') {
+            printUsage();
+            process.exit(0);
+        }
+        if (arg.startsWith('-')) {
+            throw new Error(`Unknown option '${arg}'.`);
+        }
+        if (!memberId) {
+            memberId = arg;
+            continue;
+        }
+        throw new Error(`Unexpected argument '${arg}'.`);
+    }
+    return { memberId };
+}
+function resolveTargetMemberIds(team, memberId) {
+    if (memberId)
+        return [memberId];
+    const visibleIds = Object.values(team.members)
+        .filter((member) => member.hidden !== true)
+        .map((member) => member.id)
+        .sort((a, b) => a.localeCompare(b));
+    if (visibleIds.length > 0)
+        return visibleIds;
+    const fallback = team.getDefaultResponder();
+    if (!fallback)
+        throw new Error('No team members found.');
+    return [fallback.id];
+}
+async function main() {
+    let parsed;
+    try {
+        parsed = parseArgs(process.argv.slice(2));
+    }
+    catch (err) {
+        console.error('Error:', err instanceof Error ? err.message : String(err));
+        printUsage();
+        process.exit(1);
+        return;
+    }
+    try {
+        const team = await team_1.Team.load();
+        const targetMemberIds = resolveTargetMemberIds(team, parsed.memberId);
+        const report = (0, team_definition_audit_1.buildToolsetAuditReport)({
+            team,
+            targetMemberIds,
+            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');
+        (0, team_definition_audit_1.printToolsetAudit)(report, { heading: '## Definition Audit' });
+        if ((0, team_definition_audit_1.hasHardToolsetAuditFailures)(report)) {
+            process.exit(2);
+        }
+    }
+    catch (err) {
+        console.error('Error validating team definition:', err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+if (require.main === module) {
+    main().catch((err) => {
+        console.error('Unhandled error:', err);
+        process.exit(1);
+    });
+}

package/dist/cli.d.ts

@@ -10,7 +10,9 @@
  *   tui      - Start Text User Interface
  *   run      - Run task dialog (alias for tui)
  *   read     - Read team configuration
- *   manual   - Render toolset manual to stdout
+ *   man      - Render toolset manual to stdout
+ *   manual   - Alias for man
+ *   validate_team_def - Validate explicit team toolset declarations
  *   create   - Create a new runtime workspace (rtws) from a template
  *   install  - Install a Dominds App into this rtws
  *   doctor   - Diagnose Dominds App state in this rtws

package/dist/cli.js

@@ -11,7 +11,9 @@
  *   tui      - Start Text User Interface
  *   run      - Run task dialog (alias for tui)
  *   read     - Read team configuration
- *   manual   - Render toolset manual to stdout
+ *   man      - Render toolset manual to stdout
+ *   manual   - Alias for man
+ *   validate_team_def - Validate explicit team toolset declarations
  *   create   - Create a new runtime workspace (rtws) from a template
  *   install  - Install a Dominds App into this rtws
  *   doctor   - Diagnose Dominds App state in this rtws
@@ -76,6 +78,7 @@ const read_1 = require("./cli/read");
 const tui_1 = require("./cli/tui");
 const uninstall_1 = require("./cli/uninstall");
 const update_1 = require("./cli/update");
+const validate_team_def_1 = require("./cli/validate-team-def");
 const webui_1 = require("./cli/webui");
 require("./tools/builtins");
 function printHelp() {
@@ -93,7 +96,9 @@ Subcommands:
   tui [options]      Start Text User Interface
   run [options]      Run task dialog (alias for tui)
   read [options]     Read team configuration
-  manual [options]   Render toolset manual to stdout
+  man [options]      Render toolset manual to stdout
+  manual [options]   Alias for man
+  validate_team_def [options] Validate explicit team toolset declarations
   create [options]   Create a new runtime workspace (rtws) from a template
   install [options]  Install a Dominds App into this rtws
   doctor [options]   Read-only diagnosis across manifest/lock/configuration/resolution/handshake
@@ -111,7 +116,8 @@ Examples:
   dominds tui --help         # Show TUI help
   dominds run task.tsk       # Run task dialog
   dominds read               # Read team configuration
-  dominds manual ws_read --lang zh --all
+  dominds man ws_read --lang zh --all
+  dominds validate_team_def  # Validate toolset references in .minds/team.yaml
   dominds create web-scaffold my-project   # Create rtws from a template
   dominds doctor @longrun-ai/web-dev       # Diagnose a single app across all app-state layers
 
@@ -175,6 +181,8 @@ async function main() {
         (subcommand === 'tui' && subcommandArgs.includes('-h')) ||
         (subcommand === 'run' && subcommandArgs.includes('-h')) ||
         (subcommand === 'read' && subcommandArgs.includes('-h')) ||
+        (subcommand === 'validate_team_def' && subcommandArgs.includes('-h')) ||
+        (subcommand === 'man' && subcommandArgs.includes('-h')) ||
         (subcommand === 'manual' && subcommandArgs.includes('-h')) ||
         ((subcommand === 'create' || subcommand === 'new') && subcommandArgs.includes('-h')) ||
         (subcommand === 'install' &&
@@ -218,9 +226,9 @@ async function main() {
         subcommand !== 'update';
     if (!shouldSkipRtwsSetup && shouldLoadApps) {
         try {
-            // Register toolset proxies so Team.load() can validate toolset bindings (read/manual included).
+            // Register toolset proxies so Team.load() can validate toolset bindings (read/man/manual included).
             await (0, runtime_1.registerEnabledAppsToolProxies)({ rtwsRootAbs: process.cwd() });
-            // Start apps-host only for interactive runtime commands (do not auto-start app frontends for read/manual).
+            // Start apps-host only for interactive runtime commands (do not auto-start app frontends for read/man/manual).
             const shouldStartAppsHost = subcommand === 'tui' || subcommand === 'run';
             if (shouldStartAppsHost) {
                 await (0, runtime_1.initAppsRuntime)({
@@ -246,9 +254,15 @@ async function main() {
         case 'read':
             await runSubcommand('read', subcommandArgs);
             break;
+        case 'man':
+            await runSubcommand('manual', subcommandArgs);
+            break;
         case 'manual':
             await runSubcommand('manual', subcommandArgs);
             break;
+        case 'validate_team_def':
+            await runSubcommand('validate_team_def', subcommandArgs);
+            break;
         case 'create':
         case 'new':
             await runSubcommand('create', subcommandArgs);
@@ -295,6 +309,9 @@ async function runSubcommand(subcommand, args) {
         else if (subcommand === 'manual') {
             await (0, manual_1.main)();
         }
+        else if (subcommand === 'validate_team_def') {
+            await (0, validate_team_def_1.main)();
+        }
         else if (subcommand === 'create') {
             await (0, create_1.main)();
         }