@hongmaple0820/scale-engine 0.15.0 → 0.16.0

package/dist/api/cli.js

@@ -23,6 +23,8 @@ import { Doctor } from './doctor.js';
 import { quickStart, detectPlatform } from './quickstart.js';
 import { SkillDiscovery } from '../skills/SkillDiscovery.js';
 import { inspectRequiredWorkflowSkills, inspectWorkflowSkills } from '../skills/SkillDoctor.js';
+import { evaluateSkillInstallSafety, listSkillRepositoryEntries, recommendSkillWorkflow, renderSkillRepositoryMarkdown, } from '../skills/SkillRepository.js';
+import { listLeadershipPresets, renderLeadershipPresetsMarkdown } from '../agents/LeadershipPresets.js';
 import { listWorkflowPresets, getPresetsByScenario } from '../workflows/presets.js';
 import { EvidenceStore } from '../workflow/EvidenceStore.js';
 import { OutOfScopeStore } from '../workflow/OutOfScopeStore.js';
@@ -31,13 +33,22 @@ import { WorkflowEngine } from '../workflow/WorkflowEngine.js';
 import { resolveVerificationTargets } from '../workflow/VerificationProfile.js';
 import { writeGovernanceTemplates } from '../workflow/GovernanceTemplates.js';
 import { computeGovernanceDrift } from '../workflow/GovernanceLock.js';
+import { baselineEngineeringStandards, doctorEngineeringStandards, scanEngineeringStandards, settleEngineeringStandards, } from '../workflow/EngineeringStandards.js';
+import { doctorResourceAssets, scanResourceAssets, settleResourceAssets } from '../workflow/ResourceGovernance.js';
 import { TaskMetricsStore } from '../workflow/TaskMetricsStore.js';
 import { checkTaskArtifactCompleteness } from '../workflow/TaskArtifactScaffolder.js';
 import { WorkflowArtifactWriter } from '../workflow/WorkflowArtifactWriter.js';
+import { inspectToolCapabilities } from '../tools/ToolCapabilityRegistry.js';
+import { evaluateToolEvidenceGate } from '../tools/ToolEvidenceGate.js';
+import { ToolEvidenceStore } from '../tools/ToolEvidenceStore.js';
+import { ToolOrchestrator } from '../tools/ToolOrchestrator.js';
+import { loadToolPolicy, toolPolicyTemplate } from '../tools/ToolPolicy.js';
 import { cleanupWorkspaceLifecycle, inspectWorkspaceLifecycle, } from '../workflow/WorkspaceLifecycle.js';
 import { resolveWorkspaceTopology, workspaceTopologyPath, workspaceTopologyTemplate, } from '../workflow/WorkspaceTopology.js';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { SCALE_ENGINE_VERSION } from '../version.js';
 // ============================================================================
 // Engine bootstrap (单例 + lazy init)
 // ============================================================================
@@ -69,6 +80,42 @@ function gatesForPreflightProfile(profile) {
         return ['G3', 'G0', 'G4', 'G5'];
     return ['G3', 'G0', 'G4', 'G5', 'G6', 'G7'];
 }
+function evaluateEngineeringStandardsGate(options) {
+    const mode = normalizeEngineeringStandardsGateMode(options.policy.engineeringStandardsGate);
+    if (mode === 'off') {
+        return {
+            mode,
+            checked: false,
+            blocked: false,
+            ok: true,
+            findings: [],
+        };
+    }
+    const settlement = options.settle && options.artifactsDir
+        ? settleEngineeringStandards({
+            projectDir: PROJECT_DIR,
+            scaleDir: SCALE_DIR,
+            taskId: options.taskId,
+            artifactsDir: options.artifactsDir,
+        })
+        : undefined;
+    const doctor = settlement?.doctor ?? doctorEngineeringStandards({
+        projectDir: PROJECT_DIR,
+        scaleDir: SCALE_DIR,
+    });
+    return {
+        mode,
+        checked: true,
+        blocked: mode === 'block' && !doctor.ok,
+        ok: doctor.ok,
+        findings: doctor.findings,
+        summary: doctor.scan.summary,
+        standardsImpactPath: settlement?.standardsImpactPath,
+    };
+}
+function normalizeEngineeringStandardsGateMode(value) {
+    return value === 'off' || value === 'block' ? value : 'warn';
+}
 let _engine = null;
 function getEngine() {
     if (!_engine)
@@ -854,6 +901,52 @@ function printWorkspaceLifecycle(report) {
     for (const action of report.finish.nextActions)
         console.log(`  [NEXT] ${action}`);
 }
+function compactList(values, limit = 5) {
+    if (values.length <= limit)
+        return values.join(', ');
+    return `${values.slice(0, limit).join(', ')} (+${values.length - limit} more)`;
+}
+function printWorkspaceSummary(report) {
+    const dirtyChildren = report.childRepositories
+        .filter(child => !child.clean)
+        .map(child => child.relativePath);
+    const unpushedChildren = report.childRepositories
+        .filter(child => child.ahead > 0 || (report.topology.finishPolicy.requirePushedBranches && report.topology.topology === 'moe' && !child.upstream && Boolean(child.branch)))
+        .map(child => child.relativePath);
+    const noUpstreamChildren = report.childRepositories
+        .filter(child => !child.upstream && Boolean(child.branch))
+        .map(child => child.relativePath);
+    const rootStatus = report.root.clean
+        ? 'clean'
+        : `dirty (staged=${report.root.staged}, unstaged=${report.root.unstaged}, untracked=${report.root.untracked})`;
+    const status = report.finish.blockers.length > 0 ? 'BLOCKED' : 'READY';
+    console.log('\nSCALE Workspace Summary');
+    console.log(`  Status: ${status}`);
+    console.log(`  Topology: ${report.topology.topology}${report.topology.configured ? '' : ' (default)'}`);
+    console.log(`  Root: ${rootStatus}`);
+    console.log(`  Children: ${report.childRepositories.length} total, ${dirtyChildren.length} dirty, ${unpushedChildren.length} unpushed, ${noUpstreamChildren.length} no upstream`);
+    if (dirtyChildren.length > 0)
+        console.log(`  Dirty child repositories: ${compactList(dirtyChildren)}`);
+    if (unpushedChildren.length > 0)
+        console.log(`  Unpushed child repositories: ${compactList(unpushedChildren)}`);
+    if (report.finish.blockers.length > 0) {
+        console.log('\n  Blockers:');
+        for (const blocker of report.finish.blockers.slice(0, 8))
+            console.log(`    - ${blocker}`);
+        if (report.finish.blockers.length > 8)
+            console.log(`    - ... ${report.finish.blockers.length - 8} more blocker(s)`);
+    }
+    if (report.finish.warnings.length > 0) {
+        console.log(`\n  Warnings: ${report.finish.warnings.length} warning(s); run scale workspace finish --json for details`);
+    }
+    console.log('\n  Next:');
+    const nextActions = report.finish.blockers.length > 0
+        ? report.finish.nextActions
+        : ['Proceed with scale ship <task-id> or cleanup when the branch policy is satisfied'];
+    for (const action of nextActions.slice(0, 3))
+        console.log(`    - ${action}`);
+    console.log('    - Run scale workspace finish --json for full details');
+}
 function printWorkspaceTopology(topology, written) {
     console.log('\nSCALE Workspace Topology');
     console.log(`  Topology: ${topology.topology}${topology.configured ? '' : ' (default)'}`);
@@ -886,6 +979,7 @@ const workspaceStatus = defineCommand({
     meta: { name: 'status', description: 'Inspect root worktree and child repository lifecycle state' },
     args: {
         dir: { type: 'string', description: 'Repository or worktree directory; defaults to current project directory' },
+        summary: { type: 'boolean', default: false, description: 'Print concise human summary instead of the full repository listing' },
         json: { type: 'boolean', default: false },
     },
     async run({ args }) {
@@ -893,6 +987,9 @@ const workspaceStatus = defineCommand({
         if (args.json) {
             console.log(JSON.stringify(report, null, 2));
         }
+        else if (isTruthyFlag(args.summary)) {
+            printWorkspaceSummary(report);
+        }
         else {
             printWorkspaceLifecycle(report);
         }
@@ -933,6 +1030,7 @@ const workspaceFinish = defineCommand({
     meta: { name: 'finish', description: 'Check whether a temporary worktree can be safely finished or cleaned up' },
     args: {
         dir: { type: 'string', description: 'Repository or worktree directory; defaults to current project directory' },
+        summary: { type: 'boolean', default: false, description: 'Print concise human summary instead of the full repository listing' },
         json: { type: 'boolean', default: false },
     },
     async run({ args }) {
@@ -946,6 +1044,9 @@ const workspaceFinish = defineCommand({
         if (args.json) {
             console.log(JSON.stringify(result, null, 2));
         }
+        else if (isTruthyFlag(args.summary)) {
+            printWorkspaceSummary(report);
+        }
         else {
             printWorkspaceLifecycle(report);
         }
@@ -960,6 +1061,7 @@ const workspaceCleanup = defineCommand({
         'dry-run': { type: 'boolean', default: false, description: 'Preview cleanup; this is the default unless --apply is set' },
         apply: { type: 'boolean', default: false, description: 'Actually run git worktree remove after safety checks' },
         confirm: { type: 'string', description: 'Required confirmation token for --apply, usually the worktree branch name' },
+        summary: { type: 'boolean', default: false, description: 'Print concise human summary before the cleanup plan' },
         json: { type: 'boolean', default: false },
     },
     async run({ args }) {
@@ -971,6 +1073,14 @@ const workspaceCleanup = defineCommand({
         if (args.json) {
             console.log(JSON.stringify(result, null, 2));
         }
+        else if (isTruthyFlag(args.summary)) {
+            printWorkspaceSummary(result.report);
+            console.log('\n  Cleanup:');
+            console.log(`    Mode: ${result.mode}`);
+            console.log(`    Can apply: ${result.canApply ? 'yes' : 'no'}`);
+            console.log(`    Applied: ${result.applied ? 'yes' : 'no'}`);
+            console.log(`    Confirmation token: ${result.confirmationToken ?? '(unavailable)'}`);
+        }
         else {
             printWorkspaceCleanup(result);
         }
@@ -1022,6 +1132,9 @@ const preflight = defineCommand({
             profile: args.profile,
             service: args.service,
         });
+        const engineeringStandards = evaluateEngineeringStandardsGate({
+            policy: resolved.policy,
+        });
         const targetResults = [];
         if (!args.json) {
             console.log('\nSCALE Preflight');
@@ -1030,6 +1143,13 @@ const preflight = defineCommand({
             console.log(`  Profile: ${resolved.profileName}`);
             console.log(`  Preflight profile: ${preflightProfile}`);
             console.log(`  Gates: ${gateStages.join(', ')}`);
+            if (engineeringStandards.checked) {
+                const status = engineeringStandards.blocked ? 'BLOCKED' : engineeringStandards.ok ? 'OK' : 'WARN';
+                console.log(`  Engineering standards: ${status} (${engineeringStandards.mode})`);
+            }
+            else {
+                console.log('  Engineering standards: skipped');
+            }
         }
         for (const target of resolved.targets) {
             if (!args.json) {
@@ -1061,7 +1181,9 @@ const preflight = defineCommand({
                 }
             }
         }
-        const passed = targetResults.length > 0 && targetResults.every(target => target.passed);
+        const passed = targetResults.length > 0 &&
+            targetResults.every(target => target.passed) &&
+            !engineeringStandards.blocked;
         const result = {
             phase: 'PREFLIGHT',
             profile: resolved.profileName,
@@ -1069,6 +1191,7 @@ const preflight = defineCommand({
             gates: gateStages,
             services: targetResults.map(target => target.service).filter(Boolean),
             policy: resolved.policy,
+            engineeringStandards,
             targets: targetResults,
             passed,
         };
@@ -1207,7 +1330,7 @@ const init = defineCommand({
         'governance-pack': {
             type: 'string',
             default: 'standard',
-            description: 'Governance template pack (standard/project-scaffold/moe-workspace/go-service-matrix/node-library/frontend-app)',
+            description: 'Governance template pack (standard/project-scaffold/moe-workspace/resource-governance/go-service-matrix/node-library/frontend-app)',
         },
         quick: { type: 'boolean', default: false, description: 'Quick start with auto-detection' },
         interactive: { type: 'boolean', default: false, description: 'Interactive configuration mode with prompts' },
@@ -1414,6 +1537,259 @@ const governance = defineCommand({
     subCommands: { diff: governanceDiff },
 });
 // ============================================================================
+// assets command - Resource lifecycle governance
+// ============================================================================
+const assetsScan = defineCommand({
+    meta: { name: 'scan', description: 'Classify project docs, reports, media, scripts, and temporary outputs' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        json: { type: 'boolean', default: false, description: 'Print JSON output' },
+    },
+    run({ args }) {
+        const report = scanResourceAssets({ projectDir: args.dir });
+        if (args.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log('SCALE Asset Scan');
+        console.log(`  Project: ${report.projectDir}`);
+        console.log(`  Total resources: ${report.summary.total}`);
+        console.log(`  Tracked forbidden: ${report.summary.trackedForbidden}`);
+        console.log(`  Large tracked: ${report.summary.largeTracked}`);
+        console.log(`  Expired: ${report.summary.expired}`);
+        console.log('\nBy type:');
+        for (const [type, count] of Object.entries(report.summary.byType)) {
+            if (count > 0)
+                console.log(`  ${type}: ${count}`);
+        }
+    },
+});
+const assetsDoctor = defineCommand({
+    meta: { name: 'doctor', description: 'Find resource lifecycle and Git policy problems' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        json: { type: 'boolean', default: false, description: 'Print JSON output' },
+    },
+    run({ args }) {
+        const report = doctorResourceAssets({ projectDir: args.dir });
+        if (args.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log(`SCALE Asset Doctor: ${report.ok ? 'OK' : 'FAILED'}`);
+        if (report.findings.length === 0) {
+            console.log('  No resource lifecycle findings.');
+            return;
+        }
+        for (const finding of report.findings) {
+            const path = finding.path ? ` ${finding.path}` : '';
+            console.log(`  [${finding.severity.toUpperCase()}] ${finding.code}${path}: ${finding.message}`);
+            if (finding.fix)
+                console.log(`    fix: ${finding.fix}`);
+        }
+        if (!report.ok)
+            process.exitCode = 1;
+    },
+});
+const assetsSettle = defineCommand({
+    meta: { name: 'settle', description: 'Record resource lifecycle settlement evidence for a task' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        'task-id': { type: 'string', description: 'Task id for the settlement record' },
+        'artifact-dir': { type: 'string', description: 'Task artifact directory where resource-impact.md should be updated' },
+        json: { type: 'boolean', default: false, description: 'Print JSON output' },
+    },
+    run({ args }) {
+        const report = settleResourceAssets({
+            projectDir: args.dir,
+            taskId: args['task-id'],
+            artifactsDir: args['artifact-dir'],
+        });
+        if (args.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`SCALE Asset Settlement: ${report.ok ? 'OK' : 'FAILED'}`);
+            if (report.resourceImpactPath)
+                console.log(`  Resource impact: ${report.resourceImpactPath}`);
+            if (report.doctor.findings.length > 0) {
+                for (const finding of report.doctor.findings) {
+                    const path = finding.path ? ` ${finding.path}` : '';
+                    console.log(`  [${finding.severity.toUpperCase()}] ${finding.code}${path}: ${finding.message}`);
+                }
+            }
+        }
+        if (!report.ok)
+            process.exitCode = 1;
+    },
+});
+const assets = defineCommand({
+    meta: { name: 'assets', description: 'Resource lifecycle governance for generated and maintained project assets' },
+    subCommands: { scan: assetsScan, doctor: assetsDoctor, settle: assetsSettle },
+});
+// ============================================================================
+// standards command - Engineering standards governance
+// ============================================================================
+function resolveChangedFilesArg(args) {
+    const explicit = splitChangedFiles(args['changed-files']);
+    if (explicit.length > 0)
+        return explicit;
+    if (!args.changed)
+        return undefined;
+    return readGitChangedFiles(args.dir ?? '.');
+}
+function splitChangedFiles(value) {
+    if (!value)
+        return [];
+    return value
+        .split(/[\n,]/)
+        .map(item => item.trim())
+        .filter(Boolean);
+}
+function readGitChangedFiles(projectDir) {
+    const tracked = readGitPathList(projectDir, ['diff', '--name-only', '--diff-filter=ACMRTUXB', 'HEAD', '--']);
+    const untracked = readGitPathList(projectDir, ['ls-files', '--others', '--exclude-standard']);
+    return Array.from(new Set([...tracked, ...untracked]));
+}
+function readGitPathList(projectDir, args) {
+    try {
+        return execFileSync('git', ['-C', projectDir, ...args], { encoding: 'utf-8' })
+            .split(/\r?\n/)
+            .map(item => item.trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+const standardsScan = defineCommand({
+    meta: { name: 'scan', description: 'Scan source files for engineering standard violations' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        changed: { type: 'boolean', default: false, description: 'Scan changed Git files only' },
+        'changed-files': { type: 'string', description: 'Comma or newline separated file list to scan' },
+        json: { type: 'boolean', default: false, description: 'Print JSON output' },
+    },
+    run({ args }) {
+        const report = scanEngineeringStandards({ projectDir: args.dir, changedFiles: resolveChangedFilesArg(args) });
+        if (args.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log('SCALE Standards Scan');
+        console.log(`  Project: ${report.projectDir}`);
+        console.log(`  Files scanned: ${report.summary.filesScanned}`);
+        console.log(`  Findings: ${report.summary.totalFindings}`);
+        console.log(`  Blocking findings: ${report.summary.blockingFindings}`);
+        for (const finding of report.findings.slice(0, 20)) {
+            const line = finding.line ? `:${finding.line}` : '';
+            console.log(`  [${finding.severity.toUpperCase()}] ${finding.ruleId} ${finding.path}${line}: ${finding.message}`);
+        }
+        if (report.findings.length > 20)
+            console.log(`  ... ${report.findings.length - 20} more finding(s)`);
+    },
+});
+const standardsDoctor = defineCommand({
+    meta: { name: 'doctor', description: 'Find blocking engineering standards problems' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        changed: { type: 'boolean', default: false, description: 'Scan changed Git files only' },
+        'changed-files': { type: 'string', description: 'Comma or newline separated file list to scan' },
+        json: { type: 'boolean', default: false, description: 'Print JSON output' },
+    },
+    run({ args }) {
+        const report = doctorEngineeringStandards({ projectDir: args.dir, changedFiles: resolveChangedFilesArg(args) });
+        if (args.json) {
+            console.log(JSON.stringify(report, null, 2));
+            if (!report.ok)
+                process.exitCode = 1;
+            return;
+        }
+        console.log(`SCALE Standards Doctor: ${report.ok ? 'OK' : 'FAILED'}`);
+        if (report.findings.length === 0) {
+            console.log('  No engineering standards findings.');
+            return;
+        }
+        for (const finding of report.findings) {
+            const line = finding.line ? `:${finding.line}` : '';
+            console.log(`  [${finding.severity.toUpperCase()}] ${finding.ruleId} ${finding.path}${line}: ${finding.message}`);
+            if (finding.fix)
+                console.log(`    fix: ${finding.fix}`);
+        }
+        if (!report.ok)
+            process.exitCode = 1;
+    },
+});
+const standardsSettle = defineCommand({
+    meta: { name: 'settle', description: 'Record engineering standards settlement evidence for a task' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        'task-id': { type: 'string', description: 'Task id for the settlement record' },
+        'artifact-dir': { type: 'string', description: 'Task artifact directory where standards-impact.md should be updated' },
+        changed: { type: 'boolean', default: false, description: 'Scan changed Git files only' },
+        'changed-files': { type: 'string', description: 'Comma or newline separated file list to scan' },
+        json: { type: 'boolean', default: false, description: 'Print JSON output' },
+    },
+    run({ args }) {
+        const report = settleEngineeringStandards({
+            projectDir: args.dir,
+            taskId: args['task-id'],
+            artifactsDir: args['artifact-dir'],
+            changedFiles: resolveChangedFilesArg(args),
+        });
+        if (args.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`SCALE Standards Settlement: ${report.ok ? 'OK' : 'FAILED'}`);
+            if (report.standardsImpactPath)
+                console.log(`  Standards impact: ${report.standardsImpactPath}`);
+            for (const finding of report.doctor.findings) {
+                const line = finding.line ? `:${finding.line}` : '';
+                console.log(`  [${finding.severity.toUpperCase()}] ${finding.ruleId} ${finding.path}${line}: ${finding.message}`);
+            }
+        }
+        if (!report.ok)
+            process.exitCode = 1;
+    },
+});
+const standardsBaseline = defineCommand({
+    meta: { name: 'baseline', description: 'Generate a legacy standards baseline and classification report' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        write: { type: 'boolean', default: false, description: 'Write .scale/engineering-standards-baseline.json' },
+        'task-id': { type: 'string', description: 'Task id for the legacy debt report' },
+        'artifact-dir': { type: 'string', description: 'Directory where standards-legacy-debt.md should be written' },
+        reason: { type: 'string', default: 'legacy standards debt accepted for staged remediation', description: 'Reason recorded on generated baseline entries' },
+        json: { type: 'boolean', default: false, description: 'Print JSON output' },
+    },
+    run({ args }) {
+        const report = baselineEngineeringStandards({
+            projectDir: args.dir,
+            writeBaseline: args.write,
+            taskId: args['task-id'],
+            artifactsDir: args['artifact-dir'],
+            reason: args.reason,
+        });
+        if (args.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log(`Standards baseline: ${report.wroteBaseline ? 'written' : 'dry-run'}`);
+        console.log(`  Baseline entries: ${report.baselineEntries.length}`);
+        console.log(`  Blocking findings: ${report.debt.blockingFindings}`);
+        console.log(`  Baseline path: ${report.baselinePath}`);
+        if (report.legacyDebtPath)
+            console.log(`  Legacy debt report: ${report.legacyDebtPath}`);
+        if (!report.wroteBaseline)
+            console.log('  Re-run with --write to update .scale/engineering-standards-baseline.json.');
+    },
+});
+const standards = defineCommand({
+    meta: { name: 'standards', description: 'Engineering standards governance for logs, security, architecture, database, and code quality' },
+    subCommands: { scan: standardsScan, doctor: standardsDoctor, settle: standardsSettle, baseline: standardsBaseline },
+});
+// ============================================================================
 // evolve command
 // ============================================================================
 const evolve = defineCommand({
@@ -1849,9 +2225,331 @@ const skillCheckCommand = defineCommand({
             process.exitCode = 1;
     },
 });
+const skillRepoCommand = defineCommand({
+    meta: { name: 'repo', description: 'Show SCALE progressive skill repository guide' },
+    args: {
+        category: { type: 'string', description: 'Filter by category: ui/browser/desktop/testing/review/docs/agent-cli/role-library/discovery' },
+        output: { type: 'string', alias: 'o', description: 'Write markdown guide to file' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        if (args.json) {
+            console.log(JSON.stringify(listSkillRepositoryEntries(args.category ? { category: args.category } : undefined), null, 2));
+            return;
+        }
+        const markdown = renderSkillRepositoryMarkdown();
+        if (args.output) {
+            const outputPath = resolve(PROJECT_DIR, args.output);
+            ensureDir(resolve(outputPath, '..'));
+            writeFileSync(outputPath, markdown, 'utf-8');
+            console.log(`[OK] Skill 仓库指南已生成: ${outputPath}`);
+            return;
+        }
+        console.log(markdown);
+    },
+});
+const skillSafetyCommand = defineCommand({
+    meta: { name: 'safety', description: 'Evaluate skill install command and source safety' },
+    args: {
+        source: { type: 'string', description: 'Skill source URL' },
+        command: { type: 'string', description: 'Install command to review' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const report = evaluateSkillInstallSafety({
+            sourceUrl: args.source,
+            installCommand: args.command,
+        });
+        if (args.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log('\nSCALE Skill Safety');
+        console.log(`  Risk: ${report.risk}`);
+        console.log(`  Blocked: ${report.blocked}`);
+        for (const finding of report.findings) {
+            console.log(`  [${finding.severity.toUpperCase()}] ${finding.rule}: ${finding.message}`);
+        }
+        console.log('  Required checks:');
+        for (const check of report.requiredChecks)
+            console.log(`  - ${check}`);
+        if (report.blocked)
+            process.exitCode = 1;
+    },
+});
+const skillRecommendCommand = defineCommand({
+    meta: { name: 'recommend', description: 'Recommend a composable skill workflow for a task' },
+    args: {
+        task: { type: 'string', required: true, description: 'Task description' },
+        phase: { type: 'string', description: 'Workflow phase' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const plan = recommendSkillWorkflow({
+            description: args.task,
+            phase: args.phase,
+        });
+        if (args.json) {
+            console.log(JSON.stringify(plan, null, 2));
+            return;
+        }
+        console.log('\nSCALE Skill Recommendation');
+        console.log(`  Primary: ${plan.primarySkills.join(', ') || 'none'}`);
+        console.log(`  Supporting: ${plan.supportingSkills.join(', ') || 'none'}`);
+        console.log(`  Safety required: ${plan.safetyRequired}`);
+        console.log(`  Evidence: ${plan.requiredEvidence.join(', ') || 'none'}`);
+        for (const reason of plan.rationale)
+            console.log(`  - ${reason}`);
+    },
+});
 const skill = defineCommand({
     meta: { name: 'skill', description: 'Skill discovery and management' },
-    subCommands: { scan: skillScan, doctor: skillDoctorCommand, plan: skillPlanCommand, check: skillCheckCommand },
+    subCommands: {
+        scan: skillScan,
+        doctor: skillDoctorCommand,
+        plan: skillPlanCommand,
+        check: skillCheckCommand,
+        repo: skillRepoCommand,
+        safety: skillSafetyCommand,
+        recommend: skillRecommendCommand,
+    },
+});
+// ============================================================================
+// tool command - Skills/MCP/CLI orchestration governance
+// ============================================================================
+function normalizeToolMode(value) {
+    const normalized = String(value ?? 'evidence-required');
+    if (normalized === 'off' || normalized === 'advisory' || normalized === 'evidence-required' || normalized === 'block')
+        return normalized;
+    return 'evidence-required';
+}
+function parseToolIds(value) {
+    const raw = String(value ?? '').trim();
+    if (!raw)
+        return undefined;
+    return raw.split(',').map(item => item.trim()).filter(Boolean);
+}
+function parseCommaList(value) {
+    return parseToolIds(value) ?? [];
+}
+function createToolExecutionPlanFromArgs(args) {
+    const projectDir = resolve(String(args.dir ?? PROJECT_DIR));
+    const level = normalizeTaskArtifactLevel(args.level ?? 'M');
+    const skillPolicy = loadSkillRoutingPolicy(projectDir, SCALE_DIR);
+    const skillPlan = createSkillPlan({
+        taskId: String(args['task-id'] ?? `TOOL-${Date.now()}`),
+        taskName: String(args.task ?? 'Tool orchestration task'),
+        description: String(args.task ?? ''),
+        level,
+        files: parseCommaList(args.files),
+        services: parseCommaList(args.services),
+        policy: skillPolicy,
+    });
+    const toolPolicy = loadToolPolicy(projectDir, SCALE_DIR);
+    const toolIds = uniqueStrings([
+        ...skillPlan.requiredSkills,
+        ...skillPlan.recommendedSkills,
+        ...Object.keys(toolPolicy.tools).filter(toolId => {
+            const config = toolPolicy.tools[toolId];
+            const domains = new Set(skillPlan.intents.map(intent => intent.domain));
+            return config.enabled && (config.requiredFor.some(domain => domains.has(domain)) ||
+                (config.recommendedFor ?? []).some(domain => domains.has(domain)));
+        }),
+    ]);
+    const capabilityReport = inspectToolCapabilities({
+        projectDir,
+        toolIds,
+    });
+    const orchestrator = new ToolOrchestrator({
+        projectDir,
+        policy: toolPolicy,
+        capabilityReport,
+        evidenceStore: new ToolEvidenceStore({ projectDir, scaleDir: SCALE_DIR }),
+    });
+    return {
+        projectDir,
+        skillPlan,
+        orchestrator,
+        plan: orchestrator.plan({ skillPlan }),
+        capabilityReport,
+    };
+}
+function uniqueStrings(items) {
+    return [...new Set(items)];
+}
+const toolPolicyCommand = defineCommand({
+    meta: { name: 'policy', description: 'Show resolved tool orchestration policy' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        mode: { type: 'string', description: 'Render a starter policy mode instead of reading .scale/tools.json' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const policy = args.mode
+            ? JSON.parse(toolPolicyTemplate(normalizeToolMode(args.mode)))
+            : loadToolPolicy(args.dir, SCALE_DIR);
+        if (args.json) {
+            console.log(JSON.stringify(policy, null, 2));
+            return;
+        }
+        console.log('\nSCALE Tool Policy');
+        console.log(`  Mode: ${policy.mode}`);
+        console.log(`  Tools: ${Object.keys(policy.tools).length}`);
+        for (const [id, config] of Object.entries(policy.tools)) {
+            const state = config.enabled ? '[ON]' : '[OFF]';
+            console.log(`  ${state} ${id}: requiredFor=${config.requiredFor.join(',') || 'none'}`);
+        }
+    },
+});
+const toolDoctorCommand = defineCommand({
+    meta: { name: 'doctor', description: 'Check skill, MCP, and CLI tool availability' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        tools: { type: 'string', description: 'Comma-separated tool ids to check' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const report = inspectToolCapabilities({
+            projectDir: args.dir,
+            toolIds: parseToolIds(args.tools),
+        });
+        if (args.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log('\nSCALE Tool Doctor');
+            console.log(`  Installed: ${report.summary.installed}/${report.summary.total}`);
+            for (const entry of report.tools) {
+                console.log(`  ${entry.installed ? '[OK]' : '[MISSING]'} ${entry.id}`);
+                if (entry.detectedPath)
+                    console.log(`    path: ${entry.detectedPath}`);
+                if (entry.version)
+                    console.log(`    version: ${entry.version}`);
+                if (entry.missingReason)
+                    console.log(`    reason: ${entry.missingReason}`);
+            }
+        }
+        if (!report.ok)
+            process.exitCode = 1;
+    },
+});
+const toolPlanCommand = defineCommand({
+    meta: { name: 'plan', description: 'Create a tool execution plan from task intent' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        'task-id': { type: 'string', required: true, description: 'Task id for evidence linkage' },
+        task: { type: 'string', required: true, description: 'Task description' },
+        level: { type: 'string', default: 'M', description: 'Task level: S, M, L, or CRITICAL' },
+        files: { type: 'string', description: 'Comma-separated changed or target files' },
+        services: { type: 'string', description: 'Comma-separated affected services' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const result = createToolExecutionPlanFromArgs(args);
+        if (args.json) {
+            console.log(JSON.stringify(result.plan, null, 2));
+            return;
+        }
+        console.log('\nSCALE Tool Plan');
+        console.log(`  Task: ${result.plan.taskId}`);
+        console.log(`  Mode: ${result.plan.mode}`);
+        console.log(`  Steps: ${result.plan.steps.length}`);
+        for (const step of result.plan.steps) {
+            console.log(`  ${step.status === 'ready' ? '[READY]' : '[MISSING]'} ${step.toolId} (${step.adapter}) required=${step.required}`);
+        }
+        for (const blocker of result.plan.blockers)
+            console.log(`  [BLOCKER] ${blocker}`);
+        for (const warning of result.plan.warnings)
+            console.log(`  [WARN] ${warning}`);
+    },
+});
+const toolRunCommand = defineCommand({
+    meta: { name: 'run', description: 'Run or dry-run a tool execution plan and write tool evidence' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        'task-id': { type: 'string', required: true, description: 'Task id for evidence linkage' },
+        task: { type: 'string', required: true, description: 'Task description' },
+        level: { type: 'string', default: 'M', description: 'Task level: S, M, L, or CRITICAL' },
+        files: { type: 'string', description: 'Comma-separated changed or target files' },
+        services: { type: 'string', description: 'Comma-separated affected services' },
+        'dry-run': { type: 'boolean', default: false, description: 'Plan and record skipped evidence without executing tools' },
+        json: { type: 'boolean', default: false },
+    },
+    async run({ args }) {
+        const result = createToolExecutionPlanFromArgs(args);
+        const report = await result.orchestrator.run(result.plan, {
+            dryRun: isTruthyFlag(args['dry-run']),
+        });
+        if (args.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log('\nSCALE Tool Run');
+            console.log(`  Task: ${report.taskId}`);
+            console.log(`  Dry-run: ${report.dryRun}`);
+            console.log(`  Evidence: ${report.evidence.length}`);
+            for (const record of report.evidence) {
+                console.log(`  [${record.status.toUpperCase()}] ${record.tool} -> ${record.id}`);
+            }
+            for (const blocker of report.blockers)
+                console.log(`  [BLOCKER] ${blocker}`);
+            for (const warning of report.warnings)
+                console.log(`  [WARN] ${warning}`);
+        }
+        if (!report.ok)
+            process.exitCode = 1;
+    },
+});
+const toolEvidenceCommand = defineCommand({
+    meta: { name: 'evidence', description: 'Check required tool execution evidence for a task' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        'task-id': { type: 'string', required: true, description: 'Task id for evidence linkage' },
+        task: { type: 'string', required: true, description: 'Task description' },
+        level: { type: 'string', default: 'M', description: 'Task level: S, M, L, or CRITICAL' },
+        files: { type: 'string', description: 'Comma-separated changed or target files' },
+        services: { type: 'string', description: 'Comma-separated affected services' },
+        mode: { type: 'string', description: 'Override tool gate mode: off, advisory, evidence-required, or block' },
+        'allow-skipped': { type: 'boolean', default: false, description: 'Allow skipped/manual fallback evidence to satisfy required tools' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const result = createToolExecutionPlanFromArgs(args);
+        const gate = evaluateToolEvidenceGate({
+            projectDir: result.projectDir,
+            level: normalizeTaskArtifactLevel(args.level ?? 'M'),
+            plan: result.plan,
+            evidenceStore: new ToolEvidenceStore({ projectDir: result.projectDir, scaleDir: SCALE_DIR }),
+            mode: args.mode ? normalizeToolMode(args.mode) : result.plan.mode,
+            allowSkipped: isTruthyFlag(args['allow-skipped']),
+        });
+        if (args.json) {
+            console.log(JSON.stringify(gate, null, 2));
+        }
+        else {
+            console.log('\nSCALE Tool Evidence Gate');
+            console.log(`  Task: ${gate.taskId ?? args['task-id']}`);
+            console.log(`  Mode: ${gate.mode}`);
+            console.log(`  Complete: ${gate.complete}`);
+            console.log(`  Required tools: ${gate.requiredTools.join(', ') || 'none'}`);
+            for (const item of gate.missing)
+                console.log(`  [MISSING] ${item.toolId}: ${item.reason}`);
+            for (const item of gate.failed)
+                console.log(`  [FAILED] ${item.toolId}: ${item.reason}`);
+            for (const item of gate.skipped)
+                console.log(`  [SKIPPED] ${item.toolId}: ${item.reason}`);
+            for (const item of gate.passed)
+                console.log(`  [PASS] ${item.toolId}: ${item.evidenceId ?? 'evidence'}`);
+            for (const warning of gate.warnings)
+                console.log(`  [WARN] ${warning}`);
+        }
+        if (gate.blocked)
+            process.exitCode = 1;
+    },
+});
+const tool = defineCommand({
+    meta: { name: 'tool', description: 'Skills, MCP, browser, desktop, and external CLI governance' },
+    subCommands: { policy: toolPolicyCommand, doctor: toolDoctorCommand, plan: toolPlanCommand, run: toolRunCommand, evidence: toolEvidenceCommand },
 });
 // ============================================================================
 // agent commands — Multi-Agent 协作系统 (Phase 9)
@@ -1908,9 +2606,32 @@ const agentProfiles = defineCommand({
         }
     },
 });
+const agentLeaders = defineCommand({
+    meta: { name: 'leaders', description: 'List SCALE leader presets such as CEO and CTO' },
+    args: {
+        output: { type: 'string', alias: 'o', description: 'Write markdown guide to file' },
+        json: { type: 'boolean', default: false },
+    },
+    async run({ args }) {
+        const presets = listLeadershipPresets();
+        if (args.json) {
+            console.log(JSON.stringify(presets, null, 2));
+            return;
+        }
+        const markdown = renderLeadershipPresetsMarkdown();
+        if (args.output) {
+            const outputPath = resolve(PROJECT_DIR, args.output);
+            ensureDir(resolve(outputPath, '..'));
+            writeFileSync(outputPath, markdown, 'utf-8');
+            console.log(`[OK] 领导者角色指南已生成: ${outputPath}`);
+            return;
+        }
+        console.log(markdown);
+    },
+});
 const agent = defineCommand({
     meta: { name: 'agent', description: 'Multi-Agent system management' },
-    subCommands: { spawn: agentSpawn, list: agentList, profiles: agentProfiles },
+    subCommands: { spawn: agentSpawn, list: agentList, profiles: agentProfiles, leaders: agentLeaders },
 });
 // ============================================================================
 // team commands — 团队协作 (Phase 9)
@@ -1976,7 +2697,7 @@ import * as phaseCommands from '../cli/phaseCommands.js';
 import * as liteCommands from '../cli/liteCommands.js';
 import * as vibeCommands from '../cli/vibeCommands.js';
 const main = defineCommand({
-    meta: { name: 'scale', version: '0.13.0', description: 'SCALE Engine v0.13.0 CLI - hardened phase workflow gates, governance templates, platform adapters, skill routing, and verification automation' },
+    meta: { name: 'scale', version: SCALE_ENGINE_VERSION, description: `SCALE Engine v${SCALE_ENGINE_VERSION} CLI - hardened phase workflow gates, governance templates, platform adapters, skill routing, and verification automation` },
     subCommands: {
         // Lite Mode (agent-skills style interactive entry)
         lite: liteCommands.liteCommand,
@@ -2008,12 +2729,15 @@ const main = defineCommand({
         stats,
         preflight,
         governance,
+        assets,
+        standards,
         metrics,
         'task-artifacts': taskArtifacts,
         workspace,
         status,
         workflow,
         evidence,
+        tool,
         skill,
         skills: skill,
         agent,