@hongmaple0820/scale-engine 0.15.0 → 0.16.0

package/dist/cli/phaseCommands.js

@@ -20,10 +20,17 @@ import { EvidenceStore } from '../workflow/EvidenceStore.js';
 import { ReviewStore } from '../workflow/ReviewStore.js';
 import { TaskMetricsStore } from '../workflow/TaskMetricsStore.js';
 import { appendVerificationArtifact, checkTaskArtifactCompleteness, scaffoldTaskArtifacts } from '../workflow/TaskArtifactScaffolder.js';
+import { doctorEngineeringStandards, settleEngineeringStandards } from '../workflow/EngineeringStandards.js';
 import { analyzeReview, parseChangedFiles, shouldReviewFile, summarizeFindings } from '../workflow/ReviewAnalyzer.js';
+import { inspectWorkspaceLifecycle } from '../workflow/WorkspaceLifecycle.js';
+import { evaluateToolEvidenceGate } from '../tools/ToolEvidenceGate.js';
+import { ToolEvidenceStore } from '../tools/ToolEvidenceStore.js';
+import { ToolOrchestrator } from '../tools/ToolOrchestrator.js';
+import { loadToolPolicy } from '../tools/ToolPolicy.js';
 import { join } from 'node:path';
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { HTMLDocumentRenderer } from '../output/HTMLDocumentRenderer.js';
+import { SCALE_ENGINE_VERSION } from '../version.js';
 const SCALE_DIR = process.env.SCALE_DIR ?? '.scale';
 const PROJECT_DIR = process.env.SCALE_PROJECT_DIR ?? process.cwd();
 function validateVerificationEvidence(ids) {
@@ -188,6 +195,85 @@ function evaluateArtifactGate(options) {
         blocked: mode === 'block' && checked && complete === false,
     };
 }
+function evaluateEngineeringStandardsGate(options) {
+    const mode = normalizeEngineeringStandardsGateMode(options.policy.engineeringStandardsGate);
+    if (mode === 'off') {
+        return {
+            mode,
+            checked: false,
+            blocked: false,
+            ok: true,
+            findings: [],
+        };
+    }
+    const settlement = options.settle && options.artifactsDir
+        ? settleEngineeringStandards({
+            projectDir: PROJECT_DIR,
+            scaleDir: SCALE_DIR,
+            taskId: options.taskId,
+            artifactsDir: options.artifactsDir,
+        })
+        : undefined;
+    const doctor = settlement?.doctor ?? doctorEngineeringStandards({
+        projectDir: PROJECT_DIR,
+        scaleDir: SCALE_DIR,
+    });
+    return {
+        mode,
+        checked: true,
+        blocked: mode === 'block' && !doctor.ok,
+        ok: doctor.ok,
+        findings: doctor.findings,
+        summary: doctor.scan.summary,
+        standardsImpactPath: settlement?.standardsImpactPath,
+    };
+}
+function normalizeEngineeringStandardsGateMode(value) {
+    return value === 'off' || value === 'block' ? value : 'warn';
+}
+function normalizeToolGateMode(value) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    const normalized = String(value).trim().toLowerCase();
+    if (normalized === 'warn')
+        return 'advisory';
+    if (normalized === 'off' || normalized === 'advisory' || normalized === 'evidence-required' || normalized === 'block')
+        return normalized;
+    throw new Error(`Invalid tool gate mode "${String(value)}"; expected off, advisory, evidence-required, or block.`);
+}
+function resolvePhaseToolGateMode(options) {
+    if (isTruthyFlag(options.requireEvidence))
+        return 'evidence-required';
+    const cliMode = normalizeToolGateMode(options.cliMode);
+    if (cliMode)
+        return cliMode;
+    return options.policy.mode === 'block' ? 'block' : 'off';
+}
+function evaluateTaskToolEvidenceGate(options) {
+    if (!options.level || !options.skillPlan)
+        return undefined;
+    const policy = loadToolPolicy(PROJECT_DIR, SCALE_DIR);
+    const mode = resolvePhaseToolGateMode({
+        cliMode: options.cliMode,
+        requireEvidence: options.requireEvidence,
+        policy,
+    });
+    const effectivePolicy = { ...policy, mode };
+    const evidenceStore = new ToolEvidenceStore({ projectDir: PROJECT_DIR, scaleDir: SCALE_DIR });
+    const plan = new ToolOrchestrator({
+        projectDir: PROJECT_DIR,
+        policy: effectivePolicy,
+        evidenceStore,
+    }).plan({ skillPlan: options.skillPlan });
+    return evaluateToolEvidenceGate({
+        projectDir: PROJECT_DIR,
+        level: options.level,
+        plan,
+        evidenceStore,
+        mode,
+        allowSkipped: isTruthyFlag(options.allowSkipped),
+    });
+}
 async function countChangedFiles(taskPayload) {
     const filesInvolved = taskPayload.filesInvolved ?? [];
     if (filesInvolved.length > 0)
@@ -394,7 +480,7 @@ export const phaseDefine = defineCommand({
             const renderer = new HTMLDocumentRenderer({
                 title: args.title,
                 brand: args.brand,
-                version: '0.13.0',
+                version: SCALE_ENGINE_VERSION,
                 status: 'FROZEN',
             });
             const html = renderer.renderSpec({
@@ -544,7 +630,7 @@ export const phasePlan = defineCommand({
             const planRenderer = new HTMLDocumentRenderer({
                 title: `Plan ${plan.id}`,
                 brand: args.brand,
-                version: '0.13.0',
+                version: SCALE_ENGINE_VERSION,
                 status: 'APPROVED',
             });
             const planHtml = planRenderer.renderPlan({
@@ -771,6 +857,9 @@ export const phaseVerify = defineCommand({
         'artifact-gate': { type: 'string', description: 'Task artifact policy override: off, warn, or block' },
         'require-artifacts': { type: 'boolean', default: false, description: 'Fail verification when required M/L/CRITICAL artifacts are incomplete' },
         'require-installed-skills': { type: 'boolean', default: false, description: 'Fail verification when required workflow skills are not installed locally' },
+        'tool-gate': { type: 'string', description: 'Tool evidence policy override: off, advisory, evidence-required, or block' },
+        'require-tool-evidence': { type: 'boolean', default: false, description: 'Fail verification when required tool execution evidence is missing or skipped' },
+        'allow-skipped-tool-evidence': { type: 'boolean', default: false, description: 'Allow skipped/manual fallback tool evidence to satisfy the tool gate' },
         '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' },
         'residual-risk': { type: 'string', description: 'Residual risk statement to record in task metrics' },
@@ -920,6 +1009,12 @@ export const phaseVerify = defineCommand({
             requiredSkillArtifacts: updatedPayload.requiredSkillArtifacts,
             requiredSkillVerification: updatedPayload.requiredSkillVerification,
         });
+        const engineeringStandards = evaluateEngineeringStandardsGate({
+            policy: resolvedVerification.policy,
+            taskId: args['task-id'],
+            artifactsDir: workflowState.artifactsDir,
+            settle: Boolean(workflowState.artifactsDir),
+        });
         const metricLevel = metricLevelFromPayload(updatedPayload);
         const preArtifactCheck = metricLevel ? checkCurrentTaskArtifacts(metricLevel) : undefined;
         const artifactGate = evaluateArtifactGate({
@@ -942,6 +1037,13 @@ export const phaseVerify = defineCommand({
         const requireInstalledSkills = isTruthyFlag(args['require-installed-skills']);
         const skillInstallation = inspectRequiredWorkflowSkills(updatedPayload.requiredSkills ?? [], { projectDir: PROJECT_DIR });
         const skillInstallationBlocked = requireInstalledSkills && !skillInstallation.ok;
+        const toolEvidenceGate = evaluateTaskToolEvidenceGate({
+            skillPlan: verificationSkillPlan,
+            level: metricLevel,
+            cliMode: args['tool-gate'],
+            requireEvidence: args['require-tool-evidence'],
+            allowSkipped: args['allow-skipped-tool-evidence'],
+        });
         // Attempt FSM transition to COMPLETED
         // Guards: build_passed, lint_passed, tests_passed, and optional artifact policy.
         const codePassed = results.buildStatus === 'success' &&
@@ -950,7 +1052,12 @@ export const phaseVerify = defineCommand({
             results.testPassed === true &&
             (results.testCoverage ?? 0) >= 80 &&
             results.securityPassed === true;
-        const completionEligible = codePassed && !artifactGate.blocked && !(skillGate?.blocked ?? false) && !skillInstallationBlocked;
+        const completionEligible = codePassed &&
+            !artifactGate.blocked &&
+            !(skillGate?.blocked ?? false) &&
+            !skillInstallationBlocked &&
+            !engineeringStandards.blocked &&
+            !(toolEvidenceGate?.blocked ?? false);
         let transitionResult = null;
         if (completionEligible) {
             const completeResult = await fsm.canTransition(args['task-id'], 'complete');
@@ -982,6 +1089,12 @@ export const phaseVerify = defineCommand({
         else if (!args.json && skillInstallationBlocked) {
             console.log('\n   Skill installation gate blocked completion - required workflow skills are missing');
         }
+        else if (!args.json && engineeringStandards.blocked) {
+            console.log('\n   Engineering standards gate blocked completion - fix blocking standards findings');
+        }
+        else if (!args.json && toolEvidenceGate?.blocked) {
+            console.log('\n   Tool evidence gate blocked completion - required tools need passed execution evidence');
+        }
         const passed = completionEligible && (transitionResult?.success ?? false);
         const verificationArtifactPath = appendVerificationArtifact({
             projectDir: PROJECT_DIR,
@@ -1011,15 +1124,29 @@ export const phaseVerify = defineCommand({
                 enforceLevels: skillPolicy.policy.enforceLevels,
             })
             : skillGate;
+        const finalToolEvidenceGate = evaluateTaskToolEvidenceGate({
+            skillPlan: verificationSkillPlan,
+            level: metricLevel,
+            cliMode: args['tool-gate'],
+            requireEvidence: args['require-tool-evidence'],
+            allowSkipped: args['allow-skipped-tool-evidence'],
+        }) ?? toolEvidenceGate;
         const finalPayload = {
             ...updatedPayload,
             artifactGateMode: finalArtifactGate.mode,
             artifactGatePassed: !finalArtifactGate.blocked,
             artifactComplete: artifactCheck?.complete,
             skillGatePassed: finalSkillGate ? !finalSkillGate.blocked && !skillInstallationBlocked : !skillInstallationBlocked,
+            toolOrchestrationMode: finalToolEvidenceGate?.mode,
+            requiredTools: finalToolEvidenceGate?.requiredTools,
+            toolEvidenceIds: finalToolEvidenceGate?.passed.map(item => item.evidenceId).filter((id) => Boolean(id)),
+            toolEvidenceGatePassed: finalToolEvidenceGate ? !finalToolEvidenceGate.blocked : true,
         };
         await store.update(args['task-id'], { payload: finalPayload });
-        const metricGateStatus = codePassed && (finalArtifactGate.blocked || finalSkillGate?.blocked || skillInstallationBlocked) ? 'blocked' : undefined;
+        const metricGateStatus = codePassed &&
+            (finalArtifactGate.blocked || finalSkillGate?.blocked || skillInstallationBlocked || engineeringStandards.blocked || finalToolEvidenceGate?.blocked)
+            ? 'blocked'
+            : undefined;
         const metricRecord = await recordVerificationMetric({
             taskId: args['task-id'],
             taskName: task.title,
@@ -1040,7 +1167,9 @@ export const phaseVerify = defineCommand({
             verificationArtifactPath,
             artifactCheck,
             artifactGate: finalArtifactGate,
+            engineeringStandards,
             skillGate: finalSkillGate,
+            toolEvidenceGate: finalToolEvidenceGate,
             skillInstallation: {
                 ...skillInstallation,
                 checked: requireInstalledSkills,
@@ -1064,6 +1193,12 @@ export const phaseVerify = defineCommand({
             if (skillInstallationBlocked) {
                 console.log(`   Missing required workflow skills: ${skillInstallation.missing.join(', ')}`);
             }
+            if (engineeringStandards.blocked) {
+                console.log(`   Engineering standards blockers: ${engineeringStandards.findings.filter(finding => finding.severity === 'fail').length}`);
+            }
+            if (finalToolEvidenceGate?.blocked) {
+                console.log(`   Tool evidence gaps: ${finalToolEvidenceGate.missing.length} missing, ${finalToolEvidenceGate.failed.length} failed, ${finalToolEvidenceGate.skipped.length} skipped`);
+            }
             if (passed)
                 console.log(`\n   Next: scale review\n`);
             else
@@ -1194,6 +1329,57 @@ async function stageReviewedFiles(reviewRecords) {
     }
     return { stagedFiles, unreviewedFiles: [] };
 }
+function isMultiRepositoryTopology(topology) {
+    return topology === 'moe' || topology === 'submodule-workspace' || topology === 'polyrepo';
+}
+function hasChildRepositoryChange(path, childPath) {
+    const normalized = normalizeGitPath(path);
+    const child = normalizeGitPath(childPath).replace(/\/+$/, '');
+    return normalized === child || normalized.startsWith(`${child}/`);
+}
+async function validateWorkspaceShipBoundary() {
+    try {
+        const report = await inspectWorkspaceLifecycle({ projectDir: PROJECT_DIR });
+        const blockers = [];
+        const warnings = [...report.topology.warnings];
+        const policy = report.topology.finishPolicy;
+        const rootChanges = await getReviewableGitChanges();
+        if (!report.topology.configured && report.childRepositories.length > 0) {
+            const changedChildRepositories = report.childRepositories
+                .filter(child => rootChanges.some(file => hasChildRepositoryChange(file.path, child.relativePath)))
+                .map(child => child.relativePath);
+            const dirtyChildRepositories = report.childRepositories
+                .filter(child => !child.clean || child.ahead > 0)
+                .map(child => child.relativePath);
+            const affected = Array.from(new Set([...changedChildRepositories, ...dirtyChildRepositories]));
+            if (affected.length > 0) {
+                blockers.push(`Workspace topology is not configured; child repository state is present at ${affected.join(', ')}. Create .scale/workspace.json with scale workspace map --write --topology moe before shipping.`);
+            }
+        }
+        if (report.topology.configured && isMultiRepositoryTopology(report.topology.topology)) {
+            for (const child of report.childRepositories) {
+                if (policy.requireCleanRepositories && !child.clean) {
+                    blockers.push(`Child repository ${child.relativePath} has uncommitted changes`);
+                }
+                if (policy.requirePushedBranches && child.upstream && child.ahead > 0) {
+                    blockers.push(`Child repository ${child.relativePath} has unpushed commits`);
+                }
+                if (policy.requirePushedBranches && report.topology.topology === 'moe' && !child.upstream && child.branch) {
+                    blockers.push(`Child repository ${child.relativePath} has no upstream; push or explicitly disable requirePushedBranches before shipping`);
+                }
+            }
+        }
+        return { report, blockers, warnings };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            report: null,
+            blockers: [`Workspace boundary check could not inspect Git repositories: ${message}`],
+            warnings: [],
+        };
+    }
+}
 function collectTaskReviewText(taskPayload) {
     if (!taskPayload)
         return '';
@@ -1357,7 +1543,7 @@ export const phaseReview = defineCommand({
             const reviewRenderer = new HTMLDocumentRenderer({
                 title: `Review ${record.id}`,
                 brand: args.brand,
-                version: '0.13.0',
+                version: SCALE_ENGINE_VERSION,
                 status: passed ? 'PASS' : 'FAIL',
             });
             const reviewHtml = reviewRenderer.renderReview({
@@ -1450,6 +1636,7 @@ export const phaseShip = defineCommand({
         const reviewPassed = payload.reviewPassed === true && reviewValidation.ok;
         const artifactGatePassed = payload.artifactGateMode !== 'block' || payload.artifactGatePassed !== false;
         const skillGatePassed = payload.skillGatePassed !== false;
+        const toolEvidenceGatePassed = payload.toolEvidenceGatePassed !== false;
         if (!artifactGatePassed) {
             console.error('\nTask artifact gate did not pass. Complete required task artifacts and re-run: scale verify ' + args['task-id'] + ' --artifact-gate block\n');
             if (payload.artifactComplete === false) {
@@ -1461,6 +1648,13 @@ export const phaseShip = defineCommand({
             console.error('\nTask skill gate did not pass. Complete required skill evidence artifacts and re-run: scale verify ' + args['task-id'] + '\n');
             process.exit(1);
         }
+        if (!toolEvidenceGatePassed) {
+            console.error('\nTask tool evidence gate did not pass. Run required tools and re-run: scale verify ' + args['task-id'] + ' --tool-gate ' + (payload.toolOrchestrationMode ?? 'evidence-required') + '\n');
+            if (payload.requiredTools?.length) {
+                console.error('Required tools: ' + payload.requiredTools.join(', '));
+            }
+            process.exit(1);
+        }
         if (task.status !== 'COMPLETED') {
             if (!verificationPassed) {
                 console.error('\nTask not verified with persisted evidence. Run: scale verify ' + args['task-id'] + '\n');
@@ -1497,9 +1691,17 @@ export const phaseShip = defineCommand({
         // Git operations
         let commitHash = null;
         let stagedFiles = [];
+        let workspaceBoundary = null;
         if (!shouldSkipCommit(args['skip-commit'])) {
             const commitMessage = args.message ?? `feat: ${task.title ?? args['task-id']}`;
             try {
+                workspaceBoundary = await validateWorkspaceShipBoundary();
+                if (workspaceBoundary.blockers.length > 0) {
+                    console.error('\nWorkspace boundary check failed. Resolve child repositories before shipping the root commit.');
+                    workspaceBoundary.blockers.forEach(blocker => console.error('  - ' + blocker));
+                    console.error('\nRun scale workspace finish --summary for the shortest fix list, or --json for the full workspace state.\n');
+                    process.exit(1);
+                }
                 const reviewRecords = getValidatedReviewRecords(payload.reviewEvidenceIds);
                 const stageResult = await stageReviewedFiles(reviewRecords);
                 if (stageResult.unreviewedFiles.length > 0) {
@@ -1587,6 +1789,13 @@ export const phaseShip = defineCommand({
             reviewValidation,
             commitHash,
             stagedFiles,
+            workspaceBoundary: workspaceBoundary ? {
+                topology: workspaceBoundary.report?.topology.topology ?? null,
+                configured: workspaceBoundary.report?.topology.configured ?? false,
+                childRepositories: workspaceBoundary.report?.childRepositories.length ?? 0,
+                blockers: workspaceBoundary.blockers,
+                warnings: workspaceBoundary.warnings,
+            } : null,
         };
         if (args.json)
             console.log(JSON.stringify(result, null, 2));