@hongmaple0820/scale-engine 0.13.0 → 0.15.0

package/dist/api/cli.js

@@ -22,6 +22,7 @@ import { LessonExtractor, RuleProposer, HookGenerator, EvolutionEngine } from '.
 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';
@@ -29,9 +30,12 @@ import { ReviewStore } from '../workflow/ReviewStore.js';
 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 { resolveWorkspaceTopology, workspaceTopologyPath, workspaceTopologyTemplate, } from '../workflow/WorkspaceTopology.js';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 // ============================================================================
@@ -54,6 +58,17 @@ function ensureDir(dir) {
 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)
@@ -810,6 +825,179 @@ 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(`  Topology: ${report.topology.topology}${report.topology.configured ? '' : ' (default)'}`);
+    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 printWorkspaceTopology(topology, written) {
+    console.log('\nSCALE Workspace Topology');
+    console.log(`  Topology: ${topology.topology}${topology.configured ? '' : ' (default)'}`);
+    console.log(`  Config: ${topology.configPath}`);
+    if (written)
+        console.log(`  Written: ${written}`);
+    console.log('\n  Repositories:');
+    for (const repo of topology.repositories) {
+        console.log(`    - ${repo.name}: ${repo.path} (${repo.role}) required=${repo.required !== false ? 'yes' : 'no'}`);
+    }
+    for (const warning of topology.warnings)
+        console.log(`  [WARN] ${warning}`);
+}
+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 workspaceMap = defineCommand({
+    meta: { name: 'map', description: 'Resolve or write explicit workspace topology for single, monorepo, polyrepo, submodule, or MOE projects' },
+    args: {
+        dir: { type: 'string', description: 'Project directory; defaults to current project directory' },
+        topology: { type: 'string', default: 'moe', description: 'Starter topology for --write (single/monorepo/polyrepo/submodule-workspace/moe)' },
+        write: { type: 'boolean', default: false, description: 'Create .scale/workspace.json when it does not exist' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const projectDir = resolve(args.dir ?? PROJECT_DIR);
+        const target = workspaceTopologyPath(projectDir);
+        let written = null;
+        if (isTruthyFlag(args.write) && !existsSync(target)) {
+            ensureDir(join(projectDir, '.scale'));
+            writeFileSync(target, workspaceTopologyTemplate({
+                topology: normalizeWorkspaceTopologyKind(args.topology),
+            }), 'utf-8');
+            written = target;
+        }
+        const topology = resolveWorkspaceTopology({ projectDir });
+        const result = { ...topology, written };
+        if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            printWorkspaceTopology(topology, written);
+        }
+    },
+});
+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,
+            topology: report.topology,
+            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: {
+        map: workspaceMap,
+        status: workspaceStatus,
+        finish: workspaceFinish,
+        cleanup: workspaceCleanup,
+    },
+});
+function normalizeWorkspaceTopologyKind(value) {
+    const normalized = String(value ?? 'moe').trim();
+    if (normalized === 'single'
+        || normalized === 'monorepo'
+        || normalized === 'polyrepo'
+        || normalized === 'submodule-workspace'
+        || normalized === 'moe') {
+        return normalized;
+    }
+    return 'moe';
+}
 const preflight = defineCommand({
     meta: { name: 'preflight', description: 'Run service-aware verification without a task artifact' },
     args: {
@@ -818,6 +1006,7 @@ const preflight = defineCommand({
         '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' },
@@ -825,6 +1014,8 @@ const preflight = defineCommand({
     },
     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,
@@ -837,6 +1028,8 @@ const preflight = defineCommand({
             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) {
@@ -851,6 +1044,7 @@ const preflight = defineCommand({
                 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({
@@ -871,6 +1065,8 @@ const preflight = defineCommand({
         const result = {
             phase: 'PREFLIGHT',
             profile: resolved.profileName,
+            preflightProfile,
+            gates: gateStages,
             services: targetResults.map(target => target.service).filter(Boolean),
             policy: resolved.policy,
             targets: targetResults,
@@ -1006,7 +1202,13 @@ 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/moe-workspace/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%)' },
@@ -1067,6 +1269,7 @@ const init = defineCommand({
             const governance = writeGovernanceTemplates(args.dir, {
                 mode: governanceModeFromScenario(scenarioMode),
                 projectName,
+                pack: args['governance-pack'],
             });
             result.created.push(...governance.created);
             result.skipped.push(...governance.skipped);
@@ -1091,8 +1294,24 @@ const init = defineCommand({
             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}):`);
@@ -1124,9 +1343,26 @@ const init = defineCommand({
         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)
@@ -1145,6 +1381,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({
@@ -1188,11 +1457,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;
@@ -1366,15 +1653,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) {
@@ -1463,11 +1769,37 @@ const skillPlanCommand = defineCommand({
             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 }) {
@@ -1482,33 +1814,51 @@ const skillCheckCommand = defineCommand({
             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(result, null, 2));
+            console.log(JSON.stringify(output, null, 2));
             return;
         }
-        console.log(`\nSkill Gate: ${result.complete ? 'COMPLETE' : 'INCOMPLETE'}`);
-        console.log(`  Mode: ${result.mode}`);
-        console.log(`  Required: ${result.required.join(', ') || 'none'}`);
-        for (const file of result.missing)
+        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 result.incomplete)
+        for (const item of output.incomplete)
             console.log(`  [INCOMPLETE] ${item.file}: ${item.reason}`);
-        if (result.blocked)
+        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, plan: skillPlanCommand, check: skillCheckCommand },
+    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: {
@@ -1626,7 +1976,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: 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,
@@ -1657,8 +2007,10 @@ const main = defineCommand({
         evolve,
         stats,
         preflight,
+        governance,
         metrics,
         'task-artifacts': taskArtifacts,
+        workspace,
         status,
         workflow,
         evidence,