@hongmaple0820/scale-engine 0.15.1 → 0.17.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,15 +33,25 @@ 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 { doctorEngineeringStandards, scanEngineeringStandards, settleEngineeringStandards, } from '../workflow/EngineeringStandards.js';
+import { baselineEngineeringStandards, doctorEngineeringStandards, scanEngineeringStandards, settleEngineeringStandards, } from '../workflow/EngineeringStandards.js';
 import { doctorResourceAssets, scanResourceAssets, settleResourceAssets } from '../workflow/ResourceGovernance.js';
+import { analyzeContextGovernance, renderContextGrillPrompt, writeContextGovernanceTemplates, } from '../workflow/ContextGovernance.js';
+import { createDiagnosticLoop, renderDiagnosticLoopMarkdown, validateDiagnosticLoop, } from '../workflow/DiagnosticLoop.js';
+import { createTddSlice, evaluateTddSlice, renderTddSliceMarkdown, } from '../workflow/TddLoop.js';
+import { nextWorkflowOpenTask, removeWorkflowOpenTask, toolEvidenceRunCompletesOpenTask } from '../workflow/WorkflowOpenTasks.js';
 import { TaskMetricsStore } from '../workflow/TaskMetricsStore.js';
-import { checkTaskArtifactCompleteness } from '../workflow/TaskArtifactScaffolder.js';
+import { appendContextGrillArtifact, appendDiagnosticLoopArtifact, appendTddSliceArtifact, 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)
@@ -61,6 +73,18 @@ function ensureDir(dir) {
 function isTruthyFlag(value) {
     return value === true || value === '' || value === 'true' || value === '1';
 }
+function commandEvidence(command, exitCode, summary) {
+    if (exitCode === undefined || exitCode === null || exitCode === '')
+        return undefined;
+    const parsed = Number.parseInt(String(exitCode), 10);
+    if (Number.isNaN(parsed))
+        return undefined;
+    return {
+        command,
+        exitCode: parsed,
+        outputSummary: summary ? String(summary) : `Command exited ${parsed}`,
+    };
+}
 function normalizePreflightProfile(value) {
     const normalized = String(value ?? 'quick').trim().toLowerCase();
     if (normalized === 'full' || normalized === 'ci')
@@ -768,9 +792,239 @@ const contextGlossary = defineCommand({
         }
     },
 });
+const contextInit = defineCommand({
+    meta: { name: 'init', description: 'Create CONTEXT.md and CONTEXT-MAP.md starter templates' },
+    args: {
+        dir: { type: 'string', default: PROJECT_DIR, description: 'Project directory' },
+        name: { type: 'string', description: 'Project display name' },
+        force: { type: 'boolean', default: false, description: 'Overwrite existing templates' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const result = writeContextGovernanceTemplates({
+            projectDir: resolve(String(args.dir ?? PROJECT_DIR)),
+            projectName: args.name ? String(args.name) : undefined,
+            force: isTruthyFlag(args.force),
+        });
+        if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log('\nSCALE Context Templates');
+        for (const file of result.created)
+            console.log(`  [CREATED] ${file}`);
+        for (const file of result.skipped)
+            console.log(`  [SKIPPED] ${file}`);
+    },
+});
+const contextGrill = defineCommand({
+    meta: { name: 'grill', description: 'Check project context docs and generate request-specific grill questions' },
+    args: {
+        dir: { type: 'string', default: PROJECT_DIR, description: 'Project directory' },
+        'task-id': { type: 'string', description: 'Task id for workflow state and artifact linkage' },
+        task: { type: 'string', required: true, description: 'Task or requirement description' },
+        files: { type: 'string', description: 'Comma-separated changed or target files' },
+        'artifact-dir': { type: 'string', description: 'Task artifact directory where explore.md should be updated' },
+        write: { type: 'boolean', default: false, description: 'Append context grill output to the task explore artifact' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const projectDir = resolve(String(args.dir ?? PROJECT_DIR));
+        const taskId = String(args['task-id'] ?? `context-${Date.now()}`);
+        const changedFiles = parseCommaList(args.files);
+        const report = analyzeContextGovernance({
+            projectDir,
+            request: String(args.task ?? ''),
+            changedFiles,
+        });
+        const artifactPath = isTruthyFlag(args.write)
+            ? appendContextGrillArtifact({
+                projectDir,
+                artifactsDir: args['artifact-dir'] ? String(args['artifact-dir']) : undefined,
+                report,
+            }) ?? undefined
+            : undefined;
+        if (args['task-id'] || artifactPath) {
+            const writer = new WorkflowArtifactWriter(SCALE_DIR);
+            const current = writer.readCurrentState();
+            const currentOpenTasks = current?.taskId === taskId ? current.openTasks : [];
+            writer.updateCurrentState({
+                taskId,
+                phase: 'explore',
+                artifactsDir: args['artifact-dir'] ? String(args['artifact-dir']).replace(/\\/g, '/') : undefined,
+                exploredFiles: changedFiles,
+                fileCount: changedFiles.length,
+                mainContradiction: report.findings[0]?.message ?? 'context governance ready',
+                openTasks: removeWorkflowOpenTask(currentOpenTasks, 'context-grill'),
+            });
+        }
+        if (args.json) {
+            console.log(JSON.stringify({ ...report, artifactPath }, null, 2));
+            return;
+        }
+        console.log(renderContextGrillPrompt(report));
+        if (artifactPath)
+            console.log(`\nArtifact: ${artifactPath}`);
+    },
+});
 const context = defineCommand({
     meta: { name: 'context', description: 'Context assembly' },
-    subCommands: { build: contextBuild, status: contextStatus, inject: contextInject, glossary: contextGlossary },
+    subCommands: { build: contextBuild, status: contextStatus, inject: contextInject, glossary: contextGlossary, init: contextInit, grill: contextGrill },
+});
+// ============================================================================
+// diagnose command - evidence-first debugging loop
+// ============================================================================
+const diagnosePlanCommand = defineCommand({
+    meta: { name: 'plan', description: 'Create a reproducible diagnostic loop before fixing a bug' },
+    args: {
+        'task-id': { type: 'string', required: true },
+        symptom: { type: 'string', required: true },
+        repro: { type: 'string', description: 'Command that reproduces the current failure' },
+        'expected-failure': { type: 'string', description: 'Expected failing behavior or assertion' },
+        files: { type: 'string', description: 'Comma-separated changed or suspicious files' },
+        verify: { type: 'string', description: 'Comma-separated verification commands after the fix' },
+        'artifact-dir': { type: 'string', description: 'Task artifact directory where plan.md should be updated' },
+        write: { type: 'boolean', default: false, description: 'Append diagnostic loop output to the task plan artifact' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const changedFiles = parseCommaList(args.files);
+        const loop = createDiagnosticLoop({
+            taskId: String(args['task-id']),
+            symptom: String(args.symptom),
+            reproductionCommand: args.repro ? String(args.repro) : undefined,
+            expectedFailure: args['expected-failure'] ? String(args['expected-failure']) : undefined,
+            changedFiles,
+            verificationCommands: parseCommaList(args.verify),
+        });
+        const validation = validateDiagnosticLoop(loop);
+        const artifactPath = isTruthyFlag(args.write)
+            ? appendDiagnosticLoopArtifact({
+                projectDir: PROJECT_DIR,
+                artifactsDir: args['artifact-dir'] ? String(args['artifact-dir']) : undefined,
+                loop,
+                validation,
+            }) ?? undefined
+            : undefined;
+        if (artifactPath || args['artifact-dir']) {
+            const writer = new WorkflowArtifactWriter(SCALE_DIR);
+            const current = writer.readCurrentState();
+            const currentOpenTasks = current?.taskId === loop.taskId ? current.openTasks : [];
+            writer.updateCurrentState({
+                taskId: loop.taskId,
+                phase: 'plan',
+                artifactsDir: args['artifact-dir'] ? String(args['artifact-dir']).replace(/\\/g, '/') : undefined,
+                filesModified: changedFiles,
+                openTasks: validation.ready
+                    ? removeWorkflowOpenTask(currentOpenTasks.filter(task => task.trim().startsWith('scale ')), 'diagnostic-loop')
+                    : uniqueStrings([
+                        ...currentOpenTasks,
+                        ...validation.blockers,
+                    ]),
+            });
+        }
+        if (args.json) {
+            console.log(JSON.stringify({ loop, validation, artifactPath }, null, 2));
+            return;
+        }
+        console.log(renderDiagnosticLoopMarkdown(loop));
+        if (!validation.ready) {
+            console.log('\nBlockers:');
+            for (const blocker of validation.blockers)
+                console.log(`  - ${blocker}`);
+        }
+        if (artifactPath)
+            console.log(`\nArtifact: ${artifactPath}`);
+    },
+});
+const diagnose = defineCommand({
+    meta: { name: 'diagnose', description: 'Evidence-first debugging workflows' },
+    subCommands: { plan: diagnosePlanCommand },
+});
+// ============================================================================
+// tdd command - vertical slice RED/GREEN/REFACTOR loop
+// ============================================================================
+const tddSliceCommand = defineCommand({
+    meta: { name: 'slice', description: 'Create and evaluate a TDD vertical slice' },
+    args: {
+        'task-id': { type: 'string', required: true },
+        behavior: { type: 'string', required: true },
+        'public-interface': { type: 'string', required: true },
+        'failing-test': { type: 'string', required: true },
+        'test-file': { type: 'string', required: true },
+        'impl-files': { type: 'string', required: true },
+        'red-exit-code': { type: 'string', description: 'Exit code from the RED command' },
+        'red-summary': { type: 'string', description: 'Short RED output summary' },
+        'green-exit-code': { type: 'string', description: 'Exit code from the GREEN command' },
+        'green-summary': { type: 'string', description: 'Short GREEN output summary' },
+        'refactor-exit-code': { type: 'string', description: 'Exit code from the REFACTOR command' },
+        'refactor-summary': { type: 'string', description: 'Short REFACTOR output summary' },
+        'artifact-dir': { type: 'string', description: 'Task artifact directory where verification.md should be updated' },
+        write: { type: 'boolean', default: false, description: 'Append TDD slice output to the task verification artifact' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const failingTest = String(args['failing-test']);
+        const slice = createTddSlice({
+            taskId: String(args['task-id']),
+            behavior: String(args.behavior),
+            publicInterface: String(args['public-interface']),
+            failingTestCommand: failingTest,
+            testFile: String(args['test-file']),
+            implementationFiles: parseCommaList(args['impl-files']),
+            redEvidence: commandEvidence(failingTest, args['red-exit-code'], args['red-summary']),
+            greenEvidence: commandEvidence(failingTest, args['green-exit-code'], args['green-summary']),
+            refactorEvidence: commandEvidence(failingTest, args['refactor-exit-code'], args['refactor-summary']),
+        });
+        const evaluation = evaluateTddSlice(slice);
+        const artifactPath = isTruthyFlag(args.write)
+            ? appendTddSliceArtifact({
+                projectDir: PROJECT_DIR,
+                artifactsDir: args['artifact-dir'] ? String(args['artifact-dir']) : undefined,
+                slice,
+            }) ?? undefined
+            : undefined;
+        let tddStatePath;
+        if (slice.redEvidence && slice.greenEvidence && slice.refactorEvidence) {
+            const writer = new WorkflowArtifactWriter(SCALE_DIR);
+            writer.writeTDDEvidence({
+                timestamp: new Date().toISOString(),
+                taskId: slice.taskId,
+                red: slice.redEvidence.exitCode !== 0,
+                green: slice.greenEvidence.exitCode === 0,
+                refactor: slice.refactorEvidence.exitCode === 0,
+                testFirst: slice.redEvidence.exitCode !== 0,
+                testFile: slice.testFile,
+                implFile: slice.implementationFiles[0] ?? '',
+            });
+            writer.updateCurrentState({
+                taskId: slice.taskId,
+                phase: 'verify',
+                artifactsDir: args['artifact-dir'] ? String(args['artifact-dir']).replace(/\\/g, '/') : undefined,
+                filesModified: slice.implementationFiles,
+                openTasks: removeWorkflowOpenTask(writer.readCurrentState()?.openTasks, 'tdd-slice'),
+            });
+            tddStatePath = join(writer.getStateDir(), `tdd-${slice.taskId}.json`);
+        }
+        if (args.json) {
+            console.log(JSON.stringify({ slice, evaluation, artifactPath, tddStatePath }, null, 2));
+            return;
+        }
+        console.log(renderTddSliceMarkdown(slice));
+        if (evaluation.blockers.length > 0) {
+            console.log('\nBlockers:');
+            for (const blocker of evaluation.blockers)
+                console.log(`  - ${blocker}`);
+        }
+        if (artifactPath)
+            console.log(`\nArtifact: ${artifactPath}`);
+        if (tddStatePath)
+            console.log(`TDD state: ${tddStatePath}`);
+    },
+});
+const tdd = defineCommand({
+    meta: { name: 'tdd', description: 'TDD vertical slice workflows' },
+    subCommands: { slice: tddSliceCommand },
 });
 // ============================================================================
 // stats
@@ -893,6 +1147,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)'}`);
@@ -925,6 +1225,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 }) {
@@ -932,6 +1233,9 @@ const workspaceStatus = defineCommand({
         if (args.json) {
             console.log(JSON.stringify(report, null, 2));
         }
+        else if (isTruthyFlag(args.summary)) {
+            printWorkspaceSummary(report);
+        }
         else {
             printWorkspaceLifecycle(report);
         }
@@ -972,6 +1276,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 }) {
@@ -985,6 +1290,9 @@ const workspaceFinish = defineCommand({
         if (args.json) {
             console.log(JSON.stringify(result, null, 2));
         }
+        else if (isTruthyFlag(args.summary)) {
+            printWorkspaceSummary(report);
+        }
         else {
             printWorkspaceLifecycle(report);
         }
@@ -999,6 +1307,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 }) {
@@ -1010,6 +1319,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);
         }
@@ -1153,6 +1470,9 @@ const status = defineCommand({
         const latestReviews = reviewStore.listReviews(5);
         const latestTask = tasks[0];
         const taskPayload = latestTask?.payload;
+        const workflowState = new WorkflowArtifactWriter(SCALE_DIR).readCurrentState();
+        const currentOpenTasks = workflowState?.taskId === latestTask?.id ? workflowState.openTasks ?? [] : [];
+        const nextOpenTask = nextWorkflowOpenTask(currentOpenTasks);
         const blockers = [];
         const latestBlockingEvidence = latestEvidence.find(record => !record.passed);
         const latestBlockingReview = latestReviews.find(record => !record.passed);
@@ -1173,6 +1493,10 @@ const status = defineCommand({
                 return `scale plan ${specs[0].id}`;
             if (!latestTask)
                 return `scale build ${plans[0].id}`;
+            if (nextOpenTask?.kind === 'command')
+                return nextOpenTask.value;
+            if (nextOpenTask?.kind === 'blocker')
+                return `Resolve workflow blocker: ${nextOpenTask.value}`;
             if (!taskPayload?.verificationEvidenceIds?.length)
                 return `scale verify ${latestTask.id}`;
             if (latestTask.status !== 'COMPLETED')
@@ -1214,6 +1538,14 @@ const status = defineCommand({
                 summary: record.summary,
                 createdAt: record.createdAt,
             })),
+            workflowState: workflowState ? {
+                taskId: workflowState.taskId,
+                level: workflowState.level,
+                phase: workflowState.phase,
+                artifactsDir: workflowState.artifactsDir,
+                openTasks: workflowState.openTasks,
+                skillIntents: workflowState.skillIntents,
+            } : null,
             blockers,
             nextCommand,
         };
@@ -1243,6 +1575,11 @@ const status = defineCommand({
             for (const blocker of blockers)
                 console.log(`  - ${blocker}`);
         }
+        if (result.workflowState?.openTasks.length) {
+            console.log('\nOpen Tasks:');
+            for (const task of result.workflowState.openTasks)
+                console.log(`  - ${task}`);
+        }
         console.log(`\nNext: ${nextCommand}`);
     },
 });
@@ -1559,14 +1896,48 @@ const assets = defineCommand({
 // ============================================================================
 // 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 });
+        const report = scanEngineeringStandards({ projectDir: args.dir, changedFiles: resolveChangedFilesArg(args) });
         if (args.json) {
             console.log(JSON.stringify(report, null, 2));
             return;
@@ -1588,10 +1959,12 @@ 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 });
+        const report = doctorEngineeringStandards({ projectDir: args.dir, changedFiles: resolveChangedFilesArg(args) });
         if (args.json) {
             console.log(JSON.stringify(report, null, 2));
             if (!report.ok)
@@ -1619,6 +1992,8 @@ const standardsSettle = defineCommand({
         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 }) {
@@ -1626,6 +2001,7 @@ const standardsSettle = defineCommand({
             projectDir: args.dir,
             taskId: args['task-id'],
             artifactsDir: args['artifact-dir'],
+            changedFiles: resolveChangedFilesArg(args),
         });
         if (args.json) {
             console.log(JSON.stringify(report, null, 2));
@@ -1643,9 +2019,41 @@ const standardsSettle = defineCommand({
             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 },
+    subCommands: { scan: standardsScan, doctor: standardsDoctor, settle: standardsSettle, baseline: standardsBaseline },
 });
 // ============================================================================
 // evolve command
@@ -2083,9 +2491,341 @@ 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 (toolEvidenceRunCompletesOpenTask(report)) {
+            const writer = new WorkflowArtifactWriter(SCALE_DIR);
+            const current = writer.readCurrentState();
+            if (current?.taskId === report.taskId) {
+                writer.updateCurrentState({
+                    taskId: report.taskId,
+                    openTasks: removeWorkflowOpenTask(current.openTasks, 'tool-evidence'),
+                });
+            }
+        }
+        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)
@@ -2142,9 +2882,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)
@@ -2250,6 +3013,9 @@ const main = defineCommand({
         status,
         workflow,
         evidence,
+        diagnose,
+        tdd,
+        tool,
         skill,
         skills: skill,
         agent,