@hongmaple0820/scale-engine 0.49.0 → 0.50.1

package/dist/cli/phaseCommands.js

@@ -22,6 +22,8 @@ import { JudgePromptStore, LlmJudge } from '../review/LlmJudge.js';
 import { JsonLlmClient } from '../review/JsonLlmClient.js';
 import { FreshContextVerifier } from '../review/FreshContextVerifier.js';
 import { TaskMetricsStore } from '../workflow/TaskMetricsStore.js';
+import { ReleaseDeploymentLedger } from '../workflow/ReleaseDeploymentLedger.js';
+import { recordRuntimeInstinctApplications } from '../cortex/InstinctApplicationRecorder.js';
 import { appendVerificationArtifact, checkTaskArtifactCompleteness, scaffoldTaskArtifacts } from '../workflow/TaskArtifactScaffolder.js';
 import { createWorkflowGuidance, renderWorkflowGuidance } from '../workflow/WorkflowGuidance.js';
 import { blockingWorkflowOpenTasks, removeWorkflowOpenTask } from '../workflow/WorkflowOpenTasks.js';
@@ -62,6 +64,7 @@ function validateReviewEvidence(ids) {
     const reviewStore = new ReviewStore(SCALE_DIR);
     const missing = [];
     const failed = [];
+    const records = [];
     for (const id of ids ?? []) {
         const record = reviewStore.getReview(id);
         if (!record) {
@@ -69,9 +72,14 @@ function validateReviewEvidence(ids) {
         }
         else if (!record.passed) {
             failed.push(id);
+            records.push(record);
+        }
+        else {
+            records.push(record);
         }
     }
-    return { ok: (ids?.length ?? 0) > 0 && missing.length === 0 && failed.length === 0, missing, failed };
+    const latest = records.sort((a, b) => b.createdAt - a.createdAt)[0];
+    return { ok: (ids?.length ?? 0) > 0 && missing.length === 0 && latest?.passed === true, missing, failed };
 }
 function getValidatedReviewRecords(ids) {
     const reviewStore = new ReviewStore(SCALE_DIR);
@@ -326,6 +334,50 @@ async function recordVerificationMetric(options) {
     metricsStore.writeMarkdownReport(PROJECT_DIR);
     return record;
 }
+async function recordShipDeployment(options) {
+    const version = optionalString(options.args['deploy-version']) ?? readPackageVersion(PROJECT_DIR);
+    const completedAt = optionalString(options.args['deployed-at']);
+    const commitTimestamp = await resolveCommitTimestamp(options.commitHash);
+    const notes = [
+        `task=${options.taskId}`,
+        options.taskTitle ? `title=${options.taskTitle}` : undefined,
+        options.taskPayload.verificationEvidenceIds?.length ? `verificationEvidence=${options.taskPayload.verificationEvidenceIds.join(',')}` : undefined,
+        options.taskPayload.reviewEvidenceIds?.length ? `reviewEvidence=${options.taskPayload.reviewEvidenceIds.join(',')}` : undefined,
+    ].filter((value) => Boolean(value)).join('; ');
+    return new ReleaseDeploymentLedger(SCALE_DIR).record({
+        service: optionalString(options.args['deploy-service']) ?? 'scale-engine',
+        environment: optionalString(options.args['deploy-environment']) ?? 'production',
+        status: 'succeeded',
+        version,
+        commitSha: options.commitHash,
+        commitTimestamp,
+        completedAt,
+        source: 'ship',
+        notes,
+    });
+}
+function optionalString(value) {
+    const normalized = typeof value === 'string' ? value.trim() : '';
+    return normalized ? normalized : undefined;
+}
+function readPackageVersion(projectDir) {
+    const pkgPath = join(projectDir, 'package.json');
+    if (!existsSync(pkgPath))
+        return undefined;
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return optionalString(pkg.version);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolveCommitTimestamp(commitHash) {
+    const result = await runGit(['show', '-s', '--format=%cI', commitHash]);
+    if (result.exitCode !== 0)
+        return undefined;
+    return optionalString(result.stdout);
+}
 // Helper: Generate spec markdown file
 function generateSpecMarkdown(id, title, payload, status = 'FROZEN') {
     return `# Spec: ${title}
@@ -1295,7 +1347,12 @@ export const phaseVerify = defineCommand({
             !boundaryBlocked &&
             !workflowOpenTasksBlocked;
         let transitionResult = null;
-        if (completionEligible) {
+        const alreadyCompleted = task.status === 'COMPLETED';
+        if (completionEligible && alreadyCompleted) {
+            if (!args.json)
+                console.log('\n   FSM: already COMPLETED');
+        }
+        else if (completionEligible) {
             const completeResult = await fsm.canTransition(args['task-id'], 'complete');
             if (!completeResult.allowed) {
                 if (!args.json) {
@@ -1337,7 +1394,7 @@ export const phaseVerify = defineCommand({
         else if (!args.json && workflowOpenTasksBlocked) {
             console.log('\n   Workflow open tasks blocked completion - finish required workflow commands first');
         }
-        const passed = completionEligible && (transitionResult?.success ?? false);
+        const passed = completionEligible && (alreadyCompleted || (transitionResult?.success ?? false));
         if (passed) {
             workflowState = workflowWriter.updateCurrentState({
                 openTasks: removeWorkflowOpenTask(workflowState.openTasks, 'verification'),
@@ -1402,6 +1459,12 @@ export const phaseVerify = defineCommand({
             artifactCheck,
             finalGateStatus: metricGateStatus,
         });
+        const cortexInstinctApplications = recordRuntimeInstinctApplications({
+            projectDir: PROJECT_DIR,
+            scaleDir: SCALE_DIR,
+            phase: 'verify',
+            success: passed,
+        });
         // P0 (Decision C1): soft-map the Spec's verificationSurface against evidence.
         // Unmapped items are reported as warnings only — never blocking in P0.
         // (`spec`, `boundaryEnforcement` and `constraintCoverage` were resolved
@@ -1445,6 +1508,7 @@ export const phaseVerify = defineCommand({
                 blocked: skillInstallationBlocked,
             },
             metric: metricRecord,
+            cortexInstinctApplications,
             verificationSurfaceCoverage: surfaceCoverage,
             boundaryEnforcement,
             constraintCoverage,
@@ -1464,6 +1528,9 @@ export const phaseVerify = defineCommand({
                 console.log(`   ${line}`);
             if (metricRecord)
                 console.log(`   Metrics: ${metricRecord.taskId} ${metricRecord.finalGateStatus} (fix iterations: ${metricRecord.fixIterations})`);
+            if (cortexInstinctApplications.recorded.length > 0) {
+                console.log(`   Cortex instincts: ${cortexInstinctApplications.recorded.length} outcome(s) recorded`);
+            }
             if (artifactCheck && !artifactCheck.complete) {
                 console.log(`   Artifact gaps: ${artifactCheck.missing.length} missing, ${artifactCheck.incomplete.length} incomplete`);
             }
@@ -1525,7 +1592,13 @@ function readUntrackedFileAsDiff(path) {
         return '';
     }
 }
-async function reviewGitChanges(taskPayload) {
+function normalizeMaxDiffFiles(value) {
+    const parsed = Number.parseInt(String(value ?? ''), 10);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return 200;
+    return Math.min(parsed, 1000);
+}
+async function reviewGitChanges(taskPayload, maxDiffFiles = 200) {
     const status = await runGit(['status', '--short']);
     const untracked = await runGit(['ls-files', '--others', '--exclude-standard']);
     let statusOutput = mergeUntrackedFilesIntoStatus(status.stdout, untracked.stdout);
@@ -1548,7 +1621,7 @@ async function reviewGitChanges(taskPayload) {
     const verificationEvidence = getVerificationEvidenceSummary(taskPayload?.verificationEvidenceIds);
     const changedFiles = analyzeReview({ statusOutput, diffs: [], taskPayload, verificationEvidence }).changedFiles;
     const diffs = [];
-    for (const file of changedFiles.slice(0, 50)) {
+    for (const file of changedFiles.slice(0, maxDiffFiles)) {
         if (file.status === '??') {
             diffs.push({ file: file.path, text: readUntrackedFileAsDiff(file.path) });
         }
@@ -1787,6 +1860,7 @@ export const phaseReview = defineCommand({
         brand: { type: 'string', description: 'Brand theme for HTML output (vercel/stripe/notion/linear/github)' },
         judge: { type: 'boolean', default: true, description: 'Run the advisory LLM-as-Judge spec-conformance check (P1.4)' },
         mode: { type: 'string', default: 'ai-self', description: 'Review mode: ai-self (default) | fresh-subagent | hybrid (P2.2)' },
+        'max-diff-files': { type: 'string', default: '200', description: 'Maximum changed files whose diffs are scanned during deterministic review' },
         json: { type: 'boolean', default: false },
     },
     async run({ args }) {
@@ -1803,7 +1877,7 @@ export const phaseReview = defineCommand({
             }
             taskPayload = task.payload;
         }
-        const review = await reviewGitChanges(taskPayload);
+        const review = await reviewGitChanges(taskPayload, normalizeMaxDiffFiles(args['max-diff-files']));
         const karpathyContext = deriveReviewKarpathyContext(review, taskPayload);
         const karpathyResult = workflowEngine.checkKarpathy(karpathyContext);
         const karpathyReport = {
@@ -1960,6 +2034,11 @@ export const phaseShip = defineCommand({
         message: { type: 'string', alias: 'm', description: 'Commit message' },
         'no-commit': { type: 'boolean', default: false, description: 'Skip git commit' },
         'skip-commit': { type: 'boolean', default: false, description: 'Skip git commit' },
+        'record-deployment': { type: 'boolean', default: false, description: 'Record a deployment event after a successful ship commit' },
+        'deploy-service': { type: 'string', default: 'scale-engine', description: 'Deployment service name' },
+        'deploy-environment': { type: 'string', default: 'production', description: 'Deployment environment name' },
+        'deploy-version': { type: 'string', description: 'Deployment version override' },
+        'deployed-at': { type: 'string', description: 'Deployment completion timestamp override' },
         json: { type: 'boolean', default: false },
     },
     async run({ args }) {
@@ -2036,10 +2115,12 @@ export const phaseShip = defineCommand({
             process.exit(1);
         }
         // Git operations
+        const skipCommit = shouldSkipCommit(args['skip-commit']);
         let commitHash = null;
         let stagedFiles = [];
         let workspaceBoundary = null;
-        if (!shouldSkipCommit(args['skip-commit'])) {
+        let deploymentRecord = null;
+        if (!skipCommit) {
             const commitMessage = args.message ?? `feat: ${task.title ?? args['task-id']}`;
             try {
                 workspaceBoundary = await validateWorkspaceShipBoundary();
@@ -2070,7 +2151,11 @@ export const phaseShip = defineCommand({
                     }
                 }
                 else {
-                    commitHash = result.stdout.split('\n')[0]; // First line contains hash
+                    const head = await runGit(['rev-parse', 'HEAD']);
+                    if (head.exitCode !== 0 || !head.stdout.trim()) {
+                        throw new Error(head.stderr || 'git rev-parse HEAD failed after commit');
+                    }
+                    commitHash = head.stdout.trim();
                 }
             }
             catch (e) {
@@ -2083,7 +2168,10 @@ export const phaseShip = defineCommand({
         if (task.parents.length > 0) {
             const planId = task.parents[0];
             try {
-                await fsm.transition(planId, 'complete', { actor: { kind: 'system', component: 'phase-ship' } });
+                const plan = await store.get(planId);
+                if (plan?.status !== 'DONE') {
+                    await fsm.transition(planId, 'complete', { actor: { kind: 'system', component: 'phase-ship' } });
+                }
             }
             catch (e) {
                 console.error("Warning: Plan completion transition failed:", e.message);
@@ -2098,6 +2186,46 @@ export const phaseShip = defineCommand({
         const shipSurfaceCoverage = shipSpec?.payload.verificationSurface?.length
             ? computeSurfaceCoverage(shipSpec.payload.verificationSurface, shipSignals)
             : undefined;
+        if (isTruthyFlag(args['record-deployment'])) {
+            if (!commitHash) {
+                process.stderr.write('\nDeployment recording requires a new ship commit. Re-run without --no-commit/--skip-commit, or record a real deployment explicitly with scale workflow deploy record.\n\n');
+                process.exit(1);
+            }
+            try {
+                deploymentRecord = await recordShipDeployment({
+                    taskId: args['task-id'],
+                    taskTitle: task.title,
+                    taskPayload: payload,
+                    commitHash,
+                    args,
+                });
+            }
+            catch (error) {
+                process.stderr.write(`\nDeployment record failed: ${error.message}\n`);
+                process.exit(1);
+            }
+        }
+        const cortexInstinctApplications = recordRuntimeInstinctApplications({
+            projectDir: PROJECT_DIR,
+            scaleDir: SCALE_DIR,
+            phase: 'ship',
+            success: true,
+        });
+        const shippedAt = Date.now();
+        const shipMode = skipCommit
+            ? 'no-commit'
+            : commitHash
+                ? 'commit'
+                : 'commit-skipped';
+        const shippedPayload = {
+            ...payload,
+            shipPassed: true,
+            shippedAt,
+            shipMode,
+            shipCommitHash: commitHash ?? undefined,
+            shipDeploymentRecordId: deploymentRecord?.id,
+        };
+        await store.update(task.id, { payload: shippedPayload });
         // === WorkflowEngine Integration ===
         // Generate HonestDelivery report
         if (!args.json) {
@@ -2108,6 +2236,11 @@ export const phaseShip = defineCommand({
             console.log(`  - Status: COMPLETED`);
             if (commitHash)
                 console.log(`  - Commit: ${commitHash}`);
+            if (deploymentRecord)
+                process.stdout.write(`  - Deployment evidence: ${deploymentRecord.id}\n`);
+            if (cortexInstinctApplications.recorded.length > 0) {
+                console.log(`  - Cortex instinct outcomes: ${cortexInstinctApplications.recorded.length}`);
+            }
             if (stagedFiles.length)
                 console.log(`  - Files committed: ${stagedFiles.length}`);
             console.log('');
@@ -2148,7 +2281,10 @@ export const phaseShip = defineCommand({
             reviewEvidenceIds: payload.reviewEvidenceIds ?? [],
             reviewValidation,
             commitHash,
+            deploymentRecord,
             stagedFiles,
+            shippedAt,
+            shipMode,
             workspaceBoundary: workspaceBoundary ? {
                 topology: workspaceBoundary.report?.topology.topology ?? null,
                 configured: workspaceBoundary.report?.topology.configured ?? false,
@@ -2157,6 +2293,7 @@ export const phaseShip = defineCommand({
                 blockers: workspaceBoundary.blockers,
                 warnings: workspaceBoundary.warnings,
             } : null,
+            cortexInstinctApplications,
             verificationSurfaceCoverage: shipSurfaceCoverage,
         };
         if (args.json)
@@ -2166,6 +2303,8 @@ export const phaseShip = defineCommand({
             console.log('\nTask COMPLETED: ' + args['task-id']);
             if (commitHash)
                 console.log('   Commit: ' + commitHash);
+            if (deploymentRecord)
+                process.stdout.write('   Deployment evidence: ' + deploymentRecord.id + '\n');
             console.log('\nDone. Feature shipped.\n');
         }
     },