@hongmaple0820/scale-engine 0.12.3 → 0.14.0

package/dist/api/cli.js

@@ -12,26 +12,62 @@ import { DangerousCommandDetector, SecretLeakDetector, RoleGateDetector, ScopeCr
 import { SQLiteKnowledgeBase } from '../knowledge/SQLiteKnowledgeBase.js';
 import { ContextBuilder } from '../context/ContextBuilder.js';
 import { FSMAgentBridge } from '../fsm/FSMAgentBridge.js';
+import { CapabilityRegistry } from '../capabilities/CapabilityRegistry.js';
+import { SkillRegistry } from '../skills/SkillRegistry.js';
+import { registerCoreSkills } from '../skills/coreSkills.js';
+import { registerExternalSkills } from '../skills/ExternalSkills.js';
+import { createSkillPlan, evaluateSkillGate, loadSkillRoutingPolicy, skillPlanMarkdown } from '../skills/routing/index.js';
 import { createAdapter, SUPPORTED_AGENTS } from '../adapters/index.js';
 import { LessonExtractor, RuleProposer, HookGenerator, EvolutionEngine } from '../evolution/EvolutionEngine.js';
 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 { listWorkflowPresets, getPresetsByScenario } from '../workflows/presets.js';
 import { EvidenceStore } from '../workflow/EvidenceStore.js';
 import { OutOfScopeStore } from '../workflow/OutOfScopeStore.js';
 import { ReviewStore } from '../workflow/ReviewStore.js';
-import { existsSync, mkdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+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 { TaskMetricsStore } from '../workflow/TaskMetricsStore.js';
+import { checkTaskArtifactCompleteness } from '../workflow/TaskArtifactScaffolder.js';
+import { WorkflowArtifactWriter } from '../workflow/WorkflowArtifactWriter.js';
+import { cleanupWorkspaceLifecycle, inspectWorkspaceLifecycle, } from '../workflow/WorkspaceLifecycle.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 // ============================================================================
 // Engine bootstrap (单例 + lazy init)
 // ============================================================================
 const SCALE_DIR = process.env.SCALE_DIR ?? '.scale';
+const PROJECT_DIR = process.env.SCALE_PROJECT_DIR ?? process.cwd();
 const DB_PATH = join(SCALE_DIR, 'scale.db');
+function governanceModeFromScenario(scenario) {
+    if (scenario === 'critical')
+        return 'critical';
+    if (scenario === 'sandbox')
+        return 'minimal';
+    return 'standard';
+}
 function ensureDir(dir) {
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
 }
+function isTruthyFlag(value) {
+    return value === true || value === '' || value === 'true' || value === '1';
+}
+function normalizePreflightProfile(value) {
+    const normalized = String(value ?? 'quick').trim().toLowerCase();
+    if (normalized === 'full' || normalized === 'ci')
+        return normalized;
+    return 'quick';
+}
+function gatesForPreflightProfile(profile) {
+    if (profile === 'quick')
+        return ['G3', 'G0', 'G4', 'G5'];
+    return ['G3', 'G0', 'G4', 'G5', 'G6', 'G7'];
+}
 let _engine = null;
 function getEngine() {
     if (!_engine)
@@ -60,7 +96,17 @@ function createEngine() {
     const kb = new SQLiteKnowledgeBase(eventBus, { dbPath: join(SCALE_DIR, 'knowledge.db') });
     const ctx = new ContextBuilder(store, kb, eventBus);
     const fsmAgentBridge = new FSMAgentBridge(fsm, store);
-    return { eventBus, store, fsm, gateway, roleGate, kb, ctx, fsmAgentBridge };
+    const capabilityRegistry = new CapabilityRegistry(eventBus);
+    const skillRegistry = new SkillRegistry(eventBus);
+    registerCoreSkills(skillRegistry);
+    registerExternalSkills(skillRegistry, eventBus);
+    const workflowEngine = new WorkflowEngine({
+        eventBus,
+        capabilityRegistry,
+        skillRegistry,
+        scaleDir: SCALE_DIR,
+    });
+    return { eventBus, store, fsm, gateway, roleGate, kb, ctx, fsmAgentBridge, workflowEngine };
 }
 // ============================================================================
 // session commands
@@ -699,6 +745,286 @@ const stats = defineCommand({
         console.log(JSON.stringify({ ...s, eventCount: events.length }, null, 2));
     },
 });
+const metricsList = defineCommand({
+    meta: { name: 'list', description: 'List M/L task workflow metrics' },
+    args: {
+        json: { type: 'boolean', default: false },
+    },
+    async run({ args }) {
+        const store = new TaskMetricsStore(SCALE_DIR);
+        const records = store.list();
+        const summary = store.summarize();
+        if (args.json) {
+            console.log(JSON.stringify({ summary, records }, null, 2));
+            return;
+        }
+        console.log('\nWorkflow Metrics');
+        console.log(`  Total tasks: ${summary.total}`);
+        console.log(`  First-pass verification rate: ${(summary.firstPassRate * 100).toFixed(1)}%`);
+        console.log(`  Average fix iterations: ${summary.averageFixIterations.toFixed(2)}`);
+        console.log(`  Artifact completeness: ${(summary.artifactCompletenessRate * 100).toFixed(1)}%`);
+        for (const record of records.slice(-10)) {
+            console.log(`  - ${record.date} ${record.level} ${record.taskName}: ${record.finalGateStatus}`);
+        }
+    },
+});
+const metrics = defineCommand({
+    meta: { name: 'metrics', description: 'Inspect workflow task metrics' },
+    subCommands: { list: metricsList },
+});
+function normalizeTaskArtifactLevel(value) {
+    const normalized = String(value ?? 'M').trim().toUpperCase();
+    if (normalized === 'S' || normalized === 'M' || normalized === 'L' || normalized === 'CRITICAL') {
+        return normalized;
+    }
+    throw new Error(`Invalid task level "${String(value)}"; expected S, M, L, or CRITICAL.`);
+}
+const taskArtifactsCheck = defineCommand({
+    meta: { name: 'check', description: 'Check task artifact completeness' },
+    args: {
+        dir: { type: 'string', description: 'Task artifact directory; defaults to .scale/state/current.json artifactsDir' },
+        level: { type: 'string', description: 'Task level: S, M, L, or CRITICAL; defaults to current state level or M' },
+        'warn-only': { type: 'boolean', default: false, description: 'Return zero even when artifacts are incomplete' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const state = new WorkflowArtifactWriter(SCALE_DIR).readCurrentState();
+        let level;
+        try {
+            level = normalizeTaskArtifactLevel(args.level ?? state?.level ?? 'M');
+        }
+        catch (e) {
+            console.error(e.message);
+            process.exit(1);
+        }
+        const result = checkTaskArtifactCompleteness({
+            projectDir: PROJECT_DIR,
+            artifactsDir: args.dir ?? state?.artifactsDir,
+            level,
+            skillRequiredArtifacts: state?.requiredSkillArtifacts,
+        });
+        if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`\nTask Artifacts: ${result.complete ? 'COMPLETE' : 'INCOMPLETE'}`);
+            if (result.artifactsDir)
+                console.log(`  Directory: ${result.artifactsDir}`);
+            console.log(`  Required: ${result.required.join(', ') || 'none'}`);
+            for (const file of result.missing)
+                console.log(`  [MISSING] ${file}`);
+            for (const item of result.incomplete)
+                console.log(`  [INCOMPLETE] ${item.file}: ${item.reason}`);
+        }
+        if (!result.complete && !args['warn-only'])
+            process.exitCode = 1;
+    },
+});
+const taskArtifacts = defineCommand({
+    meta: { name: 'task-artifacts', description: 'Inspect task artifact completeness' },
+    subCommands: { check: taskArtifactsCheck },
+});
+function printWorkspaceLifecycle(report) {
+    console.log('\nSCALE Workspace Lifecycle');
+    console.log(`  Root: ${report.root.path}`);
+    console.log(`  Branch: ${report.root.branch ?? '(detached)'}`);
+    console.log(`  Linked worktree: ${report.root.isLinkedWorktree ? 'yes' : 'no'}`);
+    console.log(`  Root status: ${report.root.clean ? 'clean' : 'dirty'}`);
+    if (!report.root.clean) {
+        console.log(`    staged=${report.root.staged} unstaged=${report.root.unstaged} untracked=${report.root.untracked}`);
+    }
+    if (report.childRepositories.length) {
+        console.log('\n  Child repositories:');
+        for (const child of report.childRepositories) {
+            console.log(`    ${child.clean ? '[CLEAN]' : '[DIRTY]'} ${child.relativePath} (${child.kind}) branch=${child.branch ?? '(detached)'}`);
+            if (!child.clean)
+                console.log(`      staged=${child.staged} unstaged=${child.unstaged} untracked=${child.untracked}`);
+        }
+    }
+    else {
+        console.log('\n  Child repositories: none');
+    }
+    console.log(`\n  Cleanup candidate: ${report.finish.canCleanup ? 'yes' : 'no'}`);
+    for (const blocker of report.finish.blockers)
+        console.log(`  [BLOCKER] ${blocker}`);
+    for (const warning of report.finish.warnings)
+        console.log(`  [WARN] ${warning}`);
+    for (const action of report.finish.nextActions)
+        console.log(`  [NEXT] ${action}`);
+}
+function printWorkspaceCleanup(result) {
+    printWorkspaceLifecycle(result.report);
+    console.log('\n  Cleanup plan:');
+    console.log(`    Mode: ${result.mode}`);
+    console.log(`    Target: ${result.targetPath}`);
+    console.log(`    Can apply: ${result.canApply ? 'yes' : 'no'}`);
+    console.log(`    Applied: ${result.applied ? 'yes' : 'no'}`);
+    console.log(`    Confirmation token: ${result.confirmationToken ?? '(unavailable)'}`);
+    for (const command of result.commands)
+        console.log(`    Command: ${command}`);
+    for (const blocker of result.blockers)
+        console.log(`  [BLOCKER] ${blocker}`);
+    for (const warning of result.warnings)
+        console.log(`  [WARN] ${warning}`);
+}
+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' },
+        json: { type: 'boolean', default: false },
+    },
+    async run({ args }) {
+        const report = await inspectWorkspaceLifecycle({ projectDir: args.dir ?? PROJECT_DIR });
+        if (args.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            printWorkspaceLifecycle(report);
+        }
+        if (report.finish.blockers.length > 0)
+            process.exitCode = 1;
+    },
+});
+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' },
+        json: { type: 'boolean', default: false },
+    },
+    async run({ args }) {
+        const report = await inspectWorkspaceLifecycle({ projectDir: args.dir ?? PROJECT_DIR });
+        const result = {
+            root: report.root,
+            childRepositories: report.childRepositories,
+            finish: report.finish,
+        };
+        if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            printWorkspaceLifecycle(report);
+        }
+        if (report.finish.blockers.length > 0)
+            process.exitCode = 1;
+    },
+});
+const workspaceCleanup = defineCommand({
+    meta: { name: 'cleanup', description: 'Dry-run or apply safe removal of a linked temporary worktree' },
+    args: {
+        dir: { type: 'string', description: 'Linked worktree directory; defaults to current project directory' },
+        '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' },
+        json: { type: 'boolean', default: false },
+    },
+    async run({ args }) {
+        const result = await cleanupWorkspaceLifecycle({
+            projectDir: args.dir ?? PROJECT_DIR,
+            apply: isTruthyFlag(args.apply),
+            confirm: args.confirm,
+        });
+        if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            printWorkspaceCleanup(result);
+        }
+        if (!result.canApply || (isTruthyFlag(args.apply) && !result.applied))
+            process.exitCode = 1;
+    },
+});
+const workspace = defineCommand({
+    meta: { name: 'workspace', description: 'Inspect worktree, branch, and child repository lifecycle safety' },
+    subCommands: {
+        status: workspaceStatus,
+        finish: workspaceFinish,
+        cleanup: workspaceCleanup,
+    },
+});
+const preflight = defineCommand({
+    meta: { name: 'preflight', description: 'Run service-aware verification without a task artifact' },
+    args: {
+        'build-cmd': { type: 'string', description: 'Override build command' },
+        'lint-cmd': { type: 'string', description: 'Override lint command' },
+        'test-cmd': { type: 'string', description: 'Override test command' },
+        'coverage-cmd': { type: 'string', description: 'Override coverage command' },
+        profile: { type: 'string', description: 'Verification profile from .scale/verification.json' },
+        'preflight-profile': { type: 'string', default: 'quick', description: 'Gate intensity profile (quick/full/ci); quick skips coverage and security' },
+        service: { type: 'string', description: 'Service name from .scale/verification.json; use all for required services' },
+        'tdd-evidence': { type: 'string', description: 'Path to JSON TDD evidence with red/green/refactor/testFirst=true' },
+        'tdd-strict': { type: 'boolean', default: false, description: 'Require TDD evidence before other gates' },
+        json: { type: 'boolean', default: false },
+    },
+    async run({ args }) {
+        const { workflowEngine } = getEngine();
+        const preflightProfile = normalizePreflightProfile(args['preflight-profile']);
+        const gateStages = gatesForPreflightProfile(preflightProfile);
+        const resolved = resolveVerificationTargets({
+            projectDir: PROJECT_DIR,
+            scaleDir: SCALE_DIR,
+            profile: args.profile,
+            service: args.service,
+        });
+        const targetResults = [];
+        if (!args.json) {
+            console.log('\nSCALE Preflight');
+            for (const warning of resolved.warnings)
+                console.log(`  [WARN] ${warning}`);
+            console.log(`  Profile: ${resolved.profileName}`);
+            console.log(`  Preflight profile: ${preflightProfile}`);
+            console.log(`  Gates: ${gateStages.join(', ')}`);
+        }
+        for (const target of resolved.targets) {
+            if (!args.json) {
+                const label = target.service ? `${target.service.name} (${target.service.path})` : 'root';
+                console.log(`\n  Target: ${label}`);
+            }
+            const gates = await workflowEngine.verify({
+                cwd: target.config.cwd,
+                build: args['build-cmd'] ?? target.config.build,
+                lint: args['lint-cmd'] ?? target.config.lint,
+                test: args['test-cmd'] ?? target.config.test,
+                coverage: args['coverage-cmd'] ?? target.config.coverage,
+                tddEvidence: args['tdd-evidence'],
+                tddStrict: isTruthyFlag(args['tdd-strict']),
+                gates: gateStages,
+            });
+            const passed = gates.every(gate => gate.passed);
+            targetResults.push({
+                service: target.service?.name,
+                cwd: target.config.cwd ?? PROJECT_DIR,
+                gates,
+                passed,
+            });
+            if (!args.json) {
+                for (const gate of gates) {
+                    console.log(`    ${gate.passed ? '[PASS]' : '[FAIL]'} ${gate.gate}: ${gate.evidence.slice(0, 80)}`);
+                    for (const blocker of gate.blockers)
+                        console.log(`      [BLOCKER] ${blocker.slice(0, 120)}`);
+                }
+            }
+        }
+        const passed = targetResults.length > 0 && targetResults.every(target => target.passed);
+        const result = {
+            phase: 'PREFLIGHT',
+            profile: resolved.profileName,
+            preflightProfile,
+            gates: gateStages,
+            services: targetResults.map(target => target.service).filter(Boolean),
+            policy: resolved.policy,
+            targets: targetResults,
+            passed,
+        };
+        if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`\nPREFLIGHT: ${passed ? 'PASSED' : 'FAILED'}\n`);
+        }
+        if (!passed)
+            process.exitCode = 1;
+    },
+});
 const status = defineCommand({
     meta: { name: 'status', description: 'Show current SCALE workflow status' },
     args: {
@@ -819,13 +1145,116 @@ const init = defineCommand({
     args: {
         agent: { type: 'string', default: '', description: `Agent type (${SUPPORTED_AGENTS.join('/')}) - auto-detected if not specified` },
         dir: { type: 'string', default: '.', description: 'Project directory' },
+        json: { type: 'boolean', default: false, description: 'Output initialization result as JSON' },
         scenario: { type: 'string', default: 'standard', description: 'Scenario mode (sandbox/standard/critical)' },
+        'governance-pack': {
+            type: 'string',
+            default: 'standard',
+            description: 'Governance template pack (standard/project-scaffold/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' },
+        'coverage-threshold': { type: 'string', default: '80', description: 'Coverage threshold (default 80%)' },
+        'retry-threshold': { type: 'string', default: '3', description: 'Brute retry threshold (default 3)' },
+        'block-severity': { type: 'string', default: 'CRITICAL', description: 'Block severity level (CRITICAL/HIGH/MEDIUM)' },
     },
     async run({ args }) {
+        // Interactive configuration mode
+        if (args.interactive) {
+            console.log('\n🔧 SCALE Engine Interactive Configuration\n');
+            console.log('='.repeat(50));
+            // Step 1: Detect and suggest agent platform
+            const detection = detectPlatform(args.dir);
+            console.log('\n📋 Step 1: Agent Platform Selection');
+            console.log(`   Detected suggestions: ${detection.suggestions.join(', ') || 'none'}`);
+            const agentType = args.agent || detection.suggestions[0] || 'claude-code';
+            console.log(`   Using: ${agentType}`);
+            // Step 2: Scenario mode
+            console.log('\n📋 Step 2: Scenario Mode');
+            console.log('   sandbox    - No quality gates (POC/prototype)');
+            console.log('   standard   - Default quality gates');
+            console.log('   critical   - Hardened gates + manual approval');
+            const scenarioMode = args.scenario;
+            console.log(`   Using: ${scenarioMode}`);
+            // Step 3: Quality Gate Thresholds (quantified)
+            console.log('\n📋 Step 3: Quality Gate Thresholds');
+            const coverageThreshold = parseInt(args['coverage-threshold'], 10) || 80;
+            const retryThreshold = parseInt(args['retry-threshold'], 10) || 3;
+            const blockSeverity = args['block-severity'] || 'CRITICAL';
+            console.log(`   Coverage threshold:   ${coverageThreshold}%`);
+            console.log(`   Retry threshold:      ${retryThreshold} (brute retry block)`);
+            console.log(`   Block severity:       ${blockSeverity}`);
+            // Step 4: Write thresholds to .scale/thresholds.json
+            const thresholdsPath = join(args.dir, '.scale', 'thresholds.json');
+            ensureDir(join(args.dir, '.scale'));
+            writeFileSync(thresholdsPath, JSON.stringify({
+                coverage: { minimum: coverageThreshold, unit: 'percent' },
+                retry: { bruteMaximum: retryThreshold, unit: 'count' },
+                severity: { blockLevel: blockSeverity },
+                gates: {
+                    G3_build: { required: scenarioMode !== 'sandbox', exitCode: 0 },
+                    G4_lint: { required: scenarioMode !== 'sandbox', exitCode: 0 },
+                    G5_tests: { required: scenarioMode !== 'sandbox', allPass: true },
+                    G6_coverage: { required: scenarioMode !== 'sandbox', minimum: coverageThreshold },
+                    G7_security: { required: scenarioMode === 'critical', noCritical: true },
+                },
+            }, null, 2));
+            console.log(`\n   ✓ Thresholds written to: ${thresholdsPath}`);
+            // Initialize with adapter
+            const adapter = createAdapter(agentType);
+            const result = await adapter.init({
+                projectDir: args.dir,
+                agentType: agentType,
+                scenarioMode,
+                thresholdsPath,
+            });
+            const projectName = args.dir.split(/[/\\]/).pop() || 'Project';
+            const governance = writeGovernanceTemplates(args.dir, {
+                mode: governanceModeFromScenario(scenarioMode),
+                projectName,
+                pack: args['governance-pack'],
+            });
+            result.created.push(...governance.created);
+            result.skipped.push(...governance.skipped);
+            console.log(`\n✅ SCALE Engine initialized for ${agentType} (interactive mode)`);
+            console.log(`\n📁 Created:`);
+            for (const f of result.created)
+                console.log(`   + ${f}`);
+            if (result.skipped.length > 0) {
+                console.log(`\n⏭️  Skipped (already exist):`);
+                for (const f of result.skipped)
+                    console.log(`   - ${f}`);
+            }
+            console.log(`\n🔧 Configuration Summary:`);
+            console.log(`   Settings:      ${result.settingsPath}`);
+            console.log(`   Knowledge:     ${result.knowledgeDocPath}`);
+            console.log(`   Thresholds:    ${thresholdsPath}`);
+            console.log(`   Data dir:      ${result.scaleDir}`);
+            console.log(`   Scenario:      ${scenarioMode}`);
+            console.log(`\n📋 Next steps:`);
+            console.log(`   → scale doctor`);
+            console.log(`   → scale create Spec "<feature name>"`);
+            return;
+        }
         // One-click quick start mode
-        if (args.quick || !args.agent) {
-            const qsResult = await quickStart(args.dir);
+        if (!args.agent) {
+            const qsResult = await quickStart(args.dir, { governancePack: args['governance-pack'] });
+            if (args.json) {
+                const detection = qsResult.success ? undefined : detectPlatform(args.dir);
+                console.log(JSON.stringify({
+                    ok: qsResult.success,
+                    mode: 'quick',
+                    platform: qsResult.platform,
+                    created: qsResult.created,
+                    skipped: qsResult.skipped,
+                    constraintsApplied: qsResult.constraintsApplied,
+                    capabilitiesEnabled: qsResult.capabilitiesEnabled,
+                    knowledgeGraph: qsResult.knowledgeGraph,
+                    nextSteps: qsResult.nextSteps,
+                    suggestions: detection?.suggestions ?? [],
+                }, null, 2));
+                return;
+            }
             if (qsResult.success && qsResult.platform) {
                 console.log(`\n✅ SCALE Engine Quick Start completed for ${qsResult.platform}`);
                 console.log(`\n📁 Created (${qsResult.created.length}):`);
@@ -853,6 +1282,30 @@ const init = defineCommand({
         // Manual agent specification mode
         const adapter = createAdapter(args.agent);
         const result = await adapter.init({ projectDir: args.dir, agentType: args.agent, scenarioMode: args.scenario });
+        const projectName = args.dir.split(/[/\\]/).pop() || 'Project';
+        const governance = writeGovernanceTemplates(args.dir, {
+            mode: governanceModeFromScenario(args.scenario),
+            projectName,
+            pack: args['governance-pack'],
+        });
+        result.created.push(...governance.created);
+        result.skipped.push(...governance.skipped);
+        if (args.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                mode: args.quick ? 'quick-agent' : 'manual',
+                agent: args.agent,
+                scenario: args.scenario,
+                governancePack: args['governance-pack'],
+                settingsPath: result.settingsPath,
+                knowledgeDocPath: result.knowledgeDocPath,
+                scaleDir: result.scaleDir,
+                created: result.created,
+                skipped: result.skipped,
+                nextSteps: ['scale doctor', 'scale create Spec "<feature name>"'],
+            }, null, 2));
+            return;
+        }
         console.log(`\n✅ SCALE Engine initialized for ${args.agent} (scenario: ${args.scenario})`);
         console.log(`\n📁 Created:`);
         for (const f of result.created)
@@ -871,6 +1324,39 @@ const init = defineCommand({
     },
 });
 // ============================================================================
+// governance command — Generated governance asset tooling
+// ============================================================================
+const governanceDiff = defineCommand({
+    meta: { name: 'diff', description: 'Check generated governance files for drift' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        json: { type: 'boolean', default: false, description: 'Print JSON output' },
+    },
+    run({ args }) {
+        const report = computeGovernanceDrift(args.dir);
+        if (args.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        if (!report.lockExists) {
+            console.log('No governance lock found. Run: scale init --governance-pack <pack>');
+            return;
+        }
+        if (report.missing.length === 0 && report.changed.length === 0) {
+            console.log('Governance generated files are clean.');
+            return;
+        }
+        for (const item of report.missing)
+            console.log(`missing: ${item.path}`);
+        for (const item of report.changed)
+            console.log(`changed: ${item.path}`);
+    },
+});
+const governance = defineCommand({
+    meta: { name: 'governance', description: 'Governance template pack tools' },
+    subCommands: { diff: governanceDiff },
+});
+// ============================================================================
 // evolve command
 // ============================================================================
 const evolve = defineCommand({
@@ -914,11 +1400,29 @@ const workflowList = defineCommand({
     meta: { name: 'list', description: 'List all workflow presets' },
     args: {
         scenario: { type: 'string', description: 'Filter by scenario mode (sandbox/standard/critical)' },
+        json: { type: 'boolean', default: false, description: 'Output workflow presets as JSON' },
     },
     async run({ args }) {
         const presets = args.scenario
             ? getPresetsByScenario(args.scenario)
             : listWorkflowPresets();
+        if (args.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                scenario: args.scenario ?? null,
+                count: presets.length,
+                presets: presets.map(preset => ({
+                    id: preset.id,
+                    name: preset.name,
+                    nameZh: preset.nameZh,
+                    description: preset.description,
+                    scenarioMode: preset.scenarioMode,
+                    requiredArtifacts: preset.requiredArtifacts,
+                    steps: preset.steps,
+                })),
+            }, null, 2));
+            return;
+        }
         if (presets.length === 0) {
             console.log('No workflow presets found.');
             return;
@@ -1092,15 +1596,34 @@ const skillScan = defineCommand({
     meta: { name: 'scan', description: 'Scan for installed skills' },
     args: {
         dir: { type: 'string', default: '.', description: 'Project directory' },
+        json: { type: 'boolean', default: false, description: 'Output scan result as JSON' },
     },
     async run({ args }) {
         const discovery = new SkillDiscovery(args.dir);
         const platform = discovery.detectPlatform();
+        if (!platform && args.json) {
+            console.log(JSON.stringify({
+                ok: false,
+                platform: null,
+                skills: [],
+                message: 'No agent platform detected. Run `scale init` first.',
+            }, null, 2));
+            return;
+        }
         if (!platform) {
             console.log('\n⚠️  No agent platform detected. Run `scale init` first.');
             return;
         }
         const result = discovery.scanSkills(platform);
+        if (args.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                platform: result.platform,
+                count: result.skills.length,
+                skills: result.skills,
+            }, null, 2));
+            return;
+        }
         console.log(`\n🔍 Platform: ${result.platform}`);
         console.log(`📦 Skills found: ${result.skills.length}`);
         if (result.skills.length > 0) {
@@ -1115,18 +1638,170 @@ const skillScan = defineCommand({
         }
     },
 });
+const skillPlanCommand = defineCommand({
+    meta: { name: 'plan', description: 'Create or refresh a task skill plan' },
+    args: {
+        'task-id': { type: 'positional', required: true },
+        dir: { type: 'string', description: 'Task artifact directory; defaults to current state artifactsDir' },
+        json: { type: 'boolean', default: false },
+    },
+    async run({ args }) {
+        const { store } = getEngine();
+        const task = await store.get(args['task-id']);
+        if (!task || task.type !== 'Task') {
+            console.error(`Task not found: ${args['task-id']}`);
+            process.exit(1);
+        }
+        const payload = task.payload;
+        const level = normalizeTaskArtifactLevel(payload.workflowLevel ?? 'M');
+        const policy = loadSkillRoutingPolicy(PROJECT_DIR, SCALE_DIR);
+        const plan = createSkillPlan({
+            taskId: task.id,
+            taskName: task.title,
+            description: payload.description,
+            level,
+            services: payload.servicesTouched ?? [],
+            files: payload.filesInvolved ?? [],
+            policy,
+        });
+        const updatedPayload = {
+            ...payload,
+            skillIntents: plan.intents.map(intent => intent.domain),
+            skillRoutingMode: plan.mode,
+            skillPlanRequired: plan.required,
+            requiredSkills: plan.requiredSkills,
+            recommendedSkills: plan.recommendedSkills,
+            requiredSkillArtifacts: plan.requiredArtifacts,
+            requiredSkillVerification: plan.requiredVerification,
+        };
+        await store.update(task.id, { payload: updatedPayload });
+        const state = new WorkflowArtifactWriter(SCALE_DIR).readCurrentState();
+        const artifactsDir = args.dir ?? (state?.taskId === task.id ? state.artifactsDir : undefined);
+        let writtenPath;
+        if (artifactsDir) {
+            const dir = resolve(PROJECT_DIR, artifactsDir);
+            ensureDir(dir);
+            writtenPath = join(dir, 'skill-plan.md');
+            writeFileSync(writtenPath, skillPlanMarkdown(plan), 'utf-8');
+        }
+        new WorkflowArtifactWriter(SCALE_DIR).updateCurrentState({
+            taskId: task.id,
+            level,
+            phase: 'plan',
+            artifactsDir,
+            skillIntents: plan.intents.map(intent => intent.domain),
+            skillRoutingMode: plan.mode,
+            skillPlanRequired: plan.required,
+            skillPlanPath: writtenPath,
+            requiredSkills: plan.requiredSkills,
+            recommendedSkills: plan.recommendedSkills,
+            requiredSkillArtifacts: plan.requiredArtifacts,
+            requiredSkillVerification: plan.requiredVerification,
+        });
+        if (args.json) {
+            console.log(JSON.stringify({ plan, writtenPath }, null, 2));
+            return;
+        }
+        console.log('\nSkill Plan');
+        console.log(`  Task: ${task.id}`);
+        console.log(`  Intents: ${plan.intents.map(intent => intent.domain).join(', ') || 'none'}`);
+        console.log(`  Required skills: ${plan.requiredSkills.join(', ') || 'none'}`);
+        console.log(`  Recommended skills: ${plan.recommendedSkills.join(', ') || 'none'}`);
+        console.log(`  Required artifacts: ${plan.requiredArtifacts.join(', ') || 'none'}`);
+        if (writtenPath)
+            console.log(`  Written: ${writtenPath}`);
+    },
+});
+const skillDoctorCommand = defineCommand({
+    meta: { name: 'doctor', description: 'Check workflow skill installation status' },
+    args: {
+        dir: { type: 'string', default: '.', description: 'Project directory' },
+        json: { type: 'boolean', default: false, description: 'Output skill doctor report as JSON' },
+    },
+    run({ args }) {
+        const report = inspectWorkflowSkills({ projectDir: args.dir });
+        if (args.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log('\nSCALE Skill Doctor');
+        console.log(`  Installed: ${report.installed}/${report.total}`);
+        for (const skill of report.skills) {
+            console.log(`  ${skill.installed ? '[OK]' : '[MISSING]'} ${skill.id}`);
+            if (skill.detectedPath)
+                console.log(`    path: ${skill.detectedPath}`);
+            if (!skill.installed)
+                console.log(`    install: ${skill.installCommand}`);
+        }
+        if (!report.ok)
+            process.exitCode = 1;
+    },
+});
+const skillCheckCommand = defineCommand({
+    meta: { name: 'check', description: 'Check required skill evidence artifacts' },
+    args: {
+        dir: { type: 'string', description: 'Task artifact directory; defaults to current state artifactsDir' },
+        level: { type: 'string', description: 'Task level: S, M, L, or CRITICAL; defaults to current state level or M' },
+        'require-installed': { type: 'boolean', default: false, description: 'Fail when required workflow skills are not installed locally' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const state = new WorkflowArtifactWriter(SCALE_DIR).readCurrentState();
+        const level = normalizeTaskArtifactLevel(args.level ?? state?.level ?? 'M');
+        const policy = loadSkillRoutingPolicy(PROJECT_DIR, SCALE_DIR);
+        const result = evaluateSkillGate({
+            projectDir: PROJECT_DIR,
+            artifactsDir: args.dir ?? state?.artifactsDir,
+            level,
+            requiredArtifacts: state?.requiredSkillArtifacts,
+            mode: state?.skillRoutingMode ?? policy.policy.mode,
+            enforceLevels: policy.policy.enforceLevels,
+        });
+        const skillInstallation = inspectRequiredWorkflowSkills(state?.requiredSkills ?? [], { projectDir: PROJECT_DIR });
+        const requireInstalled = isTruthyFlag(args['require-installed']);
+        const blocked = result.blocked || (requireInstalled && !skillInstallation.ok);
+        const output = {
+            ...result,
+            complete: result.complete && (!requireInstalled || skillInstallation.ok),
+            blocked,
+            skillInstallation: {
+                ...skillInstallation,
+                checked: requireInstalled,
+            },
+        };
+        if (args.json) {
+            console.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        console.log(`\nSkill Gate: ${output.complete ? 'COMPLETE' : 'INCOMPLETE'}`);
+        console.log(`  Mode: ${output.mode}`);
+        console.log(`  Required artifacts: ${output.required.join(', ') || 'none'}`);
+        console.log(`  Required skills: ${skillInstallation.required.join(', ') || 'none'}`);
+        for (const file of output.missing)
+            console.log(`  [MISSING] ${file}`);
+        for (const item of output.incomplete)
+            console.log(`  [INCOMPLETE] ${item.file}: ${item.reason}`);
+        if (requireInstalled && !skillInstallation.ok) {
+            for (const skill of skillInstallation.skills.filter(skill => !skill.installed)) {
+                console.log(`  [MISSING_SKILL] ${skill.id}: ${skill.installCommand}`);
+            }
+            for (const skill of skillInstallation.unknown)
+                console.log(`  [UNKNOWN_SKILL] ${skill}`);
+        }
+        if (blocked)
+            process.exitCode = 1;
+    },
+});
 const skill = defineCommand({
     meta: { name: 'skill', description: 'Skill discovery and management' },
-    subCommands: { scan: skillScan },
+    subCommands: { scan: skillScan, doctor: skillDoctorCommand, plan: skillPlanCommand, check: skillCheckCommand },
 });
 // ============================================================================
 // agent commands — Multi-Agent 协作系统 (Phase 9)
 // ============================================================================
 import { AgentPool } from '../agents/AgentPool.js';
-import { AgentChannel } from '../agents/AgentChannel.js';
 import { PROFESSIONAL_AGENTS, getProfile, listProfiles } from '../agents/profiles.js';
 const agentPool = new AgentPool();
-const agentChannel = new AgentChannel(getEngine().eventBus);
 const agentSpawn = defineCommand({
     meta: { name: 'spawn', description: 'Spawn a new agent instance' },
     args: {
@@ -1244,7 +1919,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.12.2', description: 'SCALE Engine v0.12.2 CLI - hardened phase workflow gates: define/plan/build/verify/review/ship; Vibe templates: scale vibe; 16 platform adapters; 12 agents; 10 workflows; 19 detectors' },
+    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' },
     subCommands: {
         // Lite Mode (agent-skills style interactive entry)
         lite: liteCommands.liteCommand,
@@ -1274,10 +1949,16 @@ const main = defineCommand({
         context,
         evolve,
         stats,
+        preflight,
+        governance,
+        metrics,
+        'task-artifacts': taskArtifacts,
+        workspace,
         status,
         workflow,
         evidence,
         skill,
+        skills: skill,
         agent,
         team,
         'create-prd': createPRD,