@hongmaple0820/scale-engine 0.15.1 → 0.17.0

package/dist/cli/phaseCommands.js

@@ -20,8 +20,15 @@ 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 { createWorkflowGuidance, renderWorkflowGuidance } from '../workflow/WorkflowGuidance.js';
+import { blockingWorkflowOpenTasks, removeWorkflowOpenTask } from '../workflow/WorkflowOpenTasks.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';
@@ -226,6 +233,49 @@ function evaluateEngineeringStandardsGate(options) {
 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)
@@ -729,6 +779,15 @@ export const phaseBuild = defineCommand({
                 skillPlan,
             });
         }
+        const workflowGuidance = createWorkflowGuidance({
+            taskId: task.id,
+            description: taskPayloadWithSkills.description,
+            level: workflowLevel,
+            artifactDir: taskArtifacts?.relativeDir,
+            files: taskPayloadWithSkills.filesInvolved,
+            skillIntents: taskPayloadWithSkills.skillIntents,
+            requiredSkillVerification: taskPayloadWithSkills.requiredSkillVerification,
+        });
         new WorkflowArtifactWriter(SCALE_DIR).updateCurrentState({
             taskId: task.id,
             level: workflowLevel,
@@ -743,6 +802,7 @@ export const phaseBuild = defineCommand({
             recommendedSkills: skillPlan.recommendedSkills,
             requiredSkillArtifacts: skillPlan.requiredArtifacts,
             requiredSkillVerification: skillPlan.requiredVerification,
+            openTasks: workflowGuidance.items.filter(item => item.required).map(item => item.command),
         });
         // FSM transitions: PENDING -> READY -> RUNNING
         // Phase 1: schedule (PENDING -> READY) - no guards
@@ -765,7 +825,7 @@ export const phaseBuild = defineCommand({
         if (implResult.allowed) {
             await fsm.transition(args['plan-id'], 'implement', { actor: { kind: 'system', component: 'phase-build' } });
         }
-        const result = { phase: 'BUILD', task: { ...task, payload: taskPayloadWithSkills }, status: 'RUNNING', artifactDir: taskArtifacts?.relativeDir, artifactFiles: taskArtifacts?.created ?? [], skillPlan };
+        const result = { phase: 'BUILD', task: { ...task, payload: taskPayloadWithSkills }, status: 'RUNNING', artifactDir: taskArtifacts?.relativeDir, artifactFiles: taskArtifacts?.created ?? [], skillPlan, workflowGuidance };
         if (args.json)
             console.log(JSON.stringify(result, null, 2));
         else {
@@ -780,7 +840,8 @@ export const phaseBuild = defineCommand({
                 console.log(`   Recommended skills: ${skillPlan.recommendedSkills.join(', ')}`);
             if (taskArtifacts?.relativeDir)
                 console.log(`   Artifacts: ${taskArtifacts.relativeDir}`);
-            console.log(`\n   Implement now, then run: scale verify ${task.id}\n`);
+            console.log(`\n${renderWorkflowGuidance(workflowGuidance)}`);
+            console.log('');
         }
     },
 });
@@ -809,6 +870,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' },
@@ -945,7 +1009,8 @@ export const phaseVerify = defineCommand({
             verifiedAt: Date.now(),
         };
         await store.update(args['task-id'], { payload: updatedPayload });
-        const workflowState = new WorkflowArtifactWriter(SCALE_DIR).updateCurrentState({
+        const workflowWriter = new WorkflowArtifactWriter(SCALE_DIR);
+        let workflowState = workflowWriter.updateCurrentState({
             taskId: args['task-id'],
             phase: 'verify',
             lastTaskId: args['task-id'],
@@ -986,8 +1051,17 @@ 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'],
+        });
+        const workflowOpenTaskBlockers = blockingWorkflowOpenTasks(workflowState.openTasks, args['task-id']);
+        const workflowOpenTasksBlocked = workflowOpenTaskBlockers.length > 0;
         // Attempt FSM transition to COMPLETED
-        // Guards: build_passed, lint_passed, tests_passed, and optional artifact policy.
+        // Guards: build_passed, lint_passed, tests_passed, open workflow tasks, and optional artifact policy.
         const codePassed = results.buildStatus === 'success' &&
             (results.buildExitCode ?? 1) === 0 &&
             results.lintStatus === 'success' &&
@@ -998,7 +1072,9 @@ export const phaseVerify = defineCommand({
             !artifactGate.blocked &&
             !(skillGate?.blocked ?? false) &&
             !skillInstallationBlocked &&
-            !engineeringStandards.blocked;
+            !engineeringStandards.blocked &&
+            !(toolEvidenceGate?.blocked ?? false) &&
+            !workflowOpenTasksBlocked;
         let transitionResult = null;
         if (completionEligible) {
             const completeResult = await fsm.canTransition(args['task-id'], 'complete');
@@ -1033,7 +1109,18 @@ export const phaseVerify = defineCommand({
         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');
+        }
+        else if (!args.json && workflowOpenTasksBlocked) {
+            console.log('\n   Workflow open tasks blocked completion - finish required workflow commands first');
+        }
         const passed = completionEligible && (transitionResult?.success ?? false);
+        if (passed) {
+            workflowState = workflowWriter.updateCurrentState({
+                openTasks: removeWorkflowOpenTask(workflowState.openTasks, 'verification'),
+            });
+        }
         const verificationArtifactPath = appendVerificationArtifact({
             projectDir: PROJECT_DIR,
             artifactsDir: workflowState.artifactsDir,
@@ -1062,16 +1149,27 @@ 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 || engineeringStandards.blocked)
+            (finalArtifactGate.blocked || finalSkillGate?.blocked || skillInstallationBlocked || engineeringStandards.blocked || finalToolEvidenceGate?.blocked || workflowOpenTasksBlocked)
             ? 'blocked'
             : undefined;
         const metricRecord = await recordVerificationMetric({
@@ -1096,6 +1194,12 @@ export const phaseVerify = defineCommand({
             artifactGate: finalArtifactGate,
             engineeringStandards,
             skillGate: finalSkillGate,
+            toolEvidenceGate: finalToolEvidenceGate,
+            workflowOpenTasks: {
+                blocked: workflowOpenTasksBlocked,
+                blockers: workflowOpenTaskBlockers,
+                openTasks: workflowState.openTasks ?? [],
+            },
             skillInstallation: {
                 ...skillInstallation,
                 checked: requireInstalledSkills,
@@ -1122,6 +1226,9 @@ export const phaseVerify = defineCommand({
             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
@@ -1252,6 +1359,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 '';
@@ -1508,6 +1666,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) {
@@ -1519,6 +1678,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');
@@ -1555,9 +1721,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) {
@@ -1645,6 +1819,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));