@polymorphism-tech/morph-spec 8.44.0 → 8.46.0

package/src/commands/validation/verify.js

@@ -4,7 +4,7 @@ import { getFeature, updateFeature } from '../../core/state/state-manager.js';
 import { runVerify, readTask, VerifyUsageError } from '../../lib/validators/verify-runner.js';
 import { resolvePrimaryRoot } from '../project/worktree.js';
 import { resolveFeatureTree } from '../../lib/worktree/feature-truth.js';
-import { canonicalPath } from '../../lib/tasks/test-runner.js';
+import { canonicalPath, readMorphConfig } from '../../lib/tasks/test-runner.js';
 import { getHeadSha } from '../../lib/git/default-branch.js';
 import { EVAL_RUNNER } from '../../lib/tasks/eval-node.js';
 import { buildVerifyEvent, recordVerifyEvent, findRepeatedVerify } from '../../lib/telemetry/verify-event.js';
@@ -12,6 +12,7 @@ import { treeFingerprint } from '../../lib/git/tree-fingerprint.js';
 import { HeavyBusyError } from '../../lib/heavy/gate.js';
 import { afterHeavyRun } from '../../lib/heavy/cleanup.js';
 import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
+import { runCiVerify, CiUsageError } from '../../lib/ci/ci-verify.js';
 
 /** ✓ pass · ✗ fail · – skip */
 function statusIcon(status) {
@@ -190,6 +191,54 @@ function evalsStatusOf(result) {
  */
 const PARTIAL_RUN_FLAGS = [['filter', 'filtered'], ['skipTests', 'skip-tests'], ['skipBuild', 'skip-build']];
 
+const CI_EXCLUSIVE_FLAGS = [
+  ['filter', '--filter'], ['skipTests', '--skip-tests'], ['skipBuild', '--skip-build'], ['skipE2e', '--skip-e2e'],
+  ['freshE2e', '--fresh-e2e'], ['linux', '--linux'], ['recordBaseline', '--record-baseline'], ['refreshCache', '--refresh-cache'],
+  ['noPersist', '--no-persist'],
+];
+
+async function runLocalVerify(featureName, taskId, options) {
+  try {
+    return await runVerify(process.cwd(), featureName, taskId || null, {
+      rubric: options.rubric,
+      timeout: options.timeout,
+      skipTests: options.skipTests,
+      skipBuild: options.skipBuild,
+      skipE2e: options.skipE2e,
+      freshE2e: options.freshE2e,
+      filter: options.filter,
+      recordBaseline: options.recordBaseline,
+      refreshCache: options.refreshCache,
+      linux: options.linux,
+      linuxImage: options.linuxImage,
+      // Task scope: switch the recorte off (#87). At feature scope nothing is
+      // ever narrowed, so the flag is a documented no-op there, not an error.
+      full: options.full,
+    });
+  } catch (err) {
+    // A wrong invocation is exit 2, like an unknown feature or task — never a
+    // verdict. `--filter` that selects nothing must not print green (or red):
+    // there is no verification to report, only a command to fix.
+    if (err instanceof VerifyUsageError) {
+      console.error(chalk.red(`\n❌ ${err.message}\n`));
+      process.exit(2);
+    }
+    // Ocupado não é veredito: nada foi verificado, então não há stamp nem
+    // evento, e o exit 3 nunca é "vermelho".
+    if (err instanceof HeavyBusyError) {
+      if (options.json) {
+        const holders = err.holders.map(({ pid, label, feature, node, since }) => ({ pid, label, feature, node, since }));
+        console.log(JSON.stringify({
+          status: 'busy', persisted: false, busy: { reason: err.reason, holders, freeGb: err.freeGb, waitedMs: err.waitedMs },
+        }, null, 2));
+      }
+      console.error(chalk.yellow(`\n⏳ verify não rodou: ${err.message}. Não é vermelho — a fila já esperou o prazo dela: não repita em laço — siga sem esta rodada e avise o usuário (\`morph-spec heavy status\` mostra quem segura os slots).\n`));
+      process.exit(3);
+    }
+    throw err;
+  }
+}
+
 /**
  * `morph-spec verify <feature> [task]` — the deterministic code-before-judge
  * gate: build + tests + validators, BEFORE the LLM eval. See verify-runner.js
@@ -203,8 +252,7 @@ const PARTIAL_RUN_FLAGS = [['filter', 'filtered'], ['skipTests', 'skip-tests'],
  * paths to it — never a verdict, because a verdict about nothing is worse
  * than a refusal:
  *   - unknown feature, or unknown task id (the task's `group` decides the
- *     rubric, so it is a hard usage error here, unlike the advisory warning
- *     `morph-spec score` gives for the same situation);
+ *     rubric, so it is a hard usage error here);
  *   - `--filter` that matches no declared node (a filtered-to-empty run is
  *     green and proves nothing);
  *   - `--record-baseline` with nowhere to write (no `config.json`), or with a
@@ -224,6 +272,14 @@ export async function verifyCommand(featureName, taskId, options = {}) {
     process.exit(2);
   }
 
+  if (options.ci) {
+    const conflict = taskId ? `a task ${taskId} (o loop por task é local)` : CI_EXCLUSIVE_FLAGS.find(([flag]) => options[flag])?.[1];
+    if (conflict) {
+      console.error(chalk.red(`\n❌ --ci roda a suíte inteira da feature no CI; não combina com ${conflict}\n`));
+      process.exit(2);
+    }
+  }
+
   // The runner's own reader (one reader of tasks.json for verify, #87): null
   // means tasks.json or the task is missing, and both are this usage error.
   if (taskId) {
@@ -233,51 +289,36 @@ export async function verifyCommand(featureName, taskId, options = {}) {
     }
   }
 
-  // Taken before the run: it is the tree the run is about to read.
-  const fingerprint = treeFingerprint(process.cwd());
-
-  let result;
-  try {
-    result = await runVerify(process.cwd(), featureName, taskId || null, {
-      rubric: options.rubric,
-      timeout: options.timeout,
-      skipTests: options.skipTests,
-      skipBuild: options.skipBuild,
-      skipE2e: options.skipE2e,
-      freshE2e: options.freshE2e,
-      filter: options.filter,
-      recordBaseline: options.recordBaseline,
-      refreshCache: options.refreshCache,
-      linux: options.linux,
-      linuxImage: options.linuxImage,
-      // Task scope: switch the recorte off (#87). At feature scope nothing is
-      // ever narrowed, so the flag is a documented no-op there, not an error.
-      full: options.full,
-    });
-  } catch (err) {
-    // A wrong invocation is exit 2, like an unknown feature or task — never a
-    // verdict. `--filter` that selects nothing must not print green (or red):
-    // there is no verification to report, only a command to fix.
-    if (err instanceof VerifyUsageError) {
-      console.error(chalk.red(`\n❌ ${err.message}\n`));
-      process.exit(2);
-    }
-    // Ocupado não é veredito: nada foi verificado, então não há stamp nem
-    // evento, e o exit 3 diz "tente de novo", nunca "vermelho".
-    if (err instanceof HeavyBusyError) {
-      if (options.json) {
-        const holders = err.holders.map(({ pid, label, feature, node, since }) => ({ pid, label, feature, node, since }));
-        console.log(JSON.stringify({
-          status: 'busy', persisted: false, busy: { reason: err.reason, holders, freeGb: err.freeGb, waitedMs: err.waitedMs },
-        }, null, 2));
+  let ci = null;
+  if (options.ci) {
+    try {
+      const outcome = await runCiVerify(process.cwd(), featureName, readMorphConfig(process.cwd()), {
+        log: (line) => console.error(chalk.gray(`   ${line}`)),
+      });
+      if (outcome.mode === 'ci') {
+        ci = outcome;
+      } else if (outcome.mode === 'pending') {
+        if (options.json) console.log(JSON.stringify({ status: 'pending', persisted: false, reason: outcome.reason }, null, 2));
+        console.error(chalk.yellow(`\n⏳ ${outcome.reason}. Não é vermelho e não há stamp: não repita em laço — siga e deixe o gate-check decidir.\n`));
+        process.exit(3);
+      } else {
+        console.error(chalk.yellow(`\n↪ CI indisponível (${outcome.reason}) — verify local.\n`));
       }
-      console.error(chalk.yellow(`\n⏳ verify não rodou: ${err.message}. Não é vermelho — tente de novo quando liberar (\`morph-spec heavy status\`).\n`));
-      process.exit(3);
+    } catch (err) {
+      if (err instanceof CiUsageError) {
+        console.error(chalk.red(`\n❌ ${err.message}\n`));
+        process.exit(2);
+      }
+      throw err;
     }
-    throw err;
   }
 
-  const cleanup = afterHeavyRun({
+  // Taken before the run: it is the tree the run is about to read.
+  const fingerprint = treeFingerprint(process.cwd());
+
+  const result = ci ? ci.result : await runLocalVerify(featureName, taskId, options);
+
+  const cleanup = ci ? { status: 'skipped', reason: 'ci' } : afterHeavyRun({
     projectPath: process.cwd(),
     config: readHeavyConfig(process.cwd()),
     scope: taskId ? 'task' : 'feature',
@@ -330,9 +371,10 @@ export async function verifyCommand(featureName, taskId, options = {}) {
       status: result.status,
       nodes: nodeStatuses(result),
       e2eReason: result.nodes.e2e.status === 'skip' ? (result.nodes.e2e.reason ?? null) : null,
-      sha: getHeadSha(process.cwd()),
+      sha: ci ? ci.run.headSha : getHeadSha(process.cwd()),
       ts: now,
       scope: taskId ? `task:${taskId}` : 'feature',
+      ...(ci ? { source: 'ci', ciRun: ci.run.url } : {}),
     };
     await updateFeature(featureName, 'verification', stamp);
   }
@@ -342,9 +384,9 @@ export async function verifyCommand(featureName, taskId, options = {}) {
   let repeatOf = null;
   try {
     const cwd = process.cwd();
-    if (!taskId && persist) repeatOf = findRepeatedVerify(cwd, { feature: featureName, task: null, scope: result.scope, fingerprint });
+    if (!taskId && persist && !ci) repeatOf = findRepeatedVerify(cwd, { feature: featureName, task: null, scope: result.scope, fingerprint });
     const tree = resolve(cwd).replace(/\\/g, '/') === resolvePrimaryRoot(cwd) ? 'root' : 'worktree';
-    recordVerifyEvent(cwd, buildVerifyEvent(result, { sha: getHeadSha(cwd), tree, persisted: persist, reason, fingerprint }));
+    recordVerifyEvent(cwd, buildVerifyEvent(result, { sha: ci ? ci.run.headSha : getHeadSha(cwd), tree, persisted: persist, reason, fingerprint, source: ci ? 'ci' : 'local' }));
   } catch { /* telemetry never changes the verdict */ }
 
   // The refusal always goes to stderr, so it survives --json (whose stdout has
@@ -356,10 +398,18 @@ export async function verifyCommand(featureName, taskId, options = {}) {
   }
 
   if (options.json) {
-    const output = { ...result, persisted: persist, ...(persist ? {} : { reason }), repeatOf, cleanup };
+    const output = {
+      ...result, persisted: persist, ...(persist ? {} : { reason }), repeatOf, cleanup,
+      ...(ci ? { source: 'ci', ciRun: { id: ci.run.databaseId, url: ci.run.url, sha: ci.run.headSha }, workflowCreated: ci.created } : {}),
+    };
     console.log(JSON.stringify(output, null, 2));
   } else {
     console.log(formatVerifyResult(result));
+    if (ci) {
+      console.log(chalk.cyan(`fonte: CI ${ci.run.url}`));
+      if (result.status === 'fail') console.log(chalk.gray(`   log das falhas: gh run view ${ci.run.databaseId} --log-failed`));
+      console.log('');
+    }
     if (cleanup.status !== 'skipped') {
       const mark = cleanup.status === 'ran' ? chalk.green('✓') : chalk.yellow('⚠');
       console.log(chalk.gray(`${mark} dotnet build-server shutdown: ${cleanup.status}${cleanup.reason ? ` (${cleanup.reason})` : ''}\n`));

package/src/core/paths/output-schema.js

@@ -46,7 +46,6 @@ export const OUTPUT_SCHEMA = {
 
   // 2-plan/
   spec:           { filename: 'spec.md',               phaseDir: '2-plan',      phase: 'plan',      protected: true,  approvalGate: 'plan' },
-  mandate:        { filename: 'mandate.md',            phaseDir: '2-plan',      phase: 'plan',      protected: true,  approvalGate: 'plan' },
   tasks:          { filename: 'tasks.json',            phaseDir: '2-plan',      phase: 'plan',      protected: true,  approvalGate: 'plan', mutableFields: ['status', 'outputs', 'notes'] },
   decisions:      { filename: 'decisions.md',          phaseDir: '2-plan',      phase: 'plan',      protected: false },
   // Veredito REUSAR/ESTENDER/CRIAR por conceito que a feature introduz, com a
@@ -55,7 +54,6 @@ export const OUTPUT_SCHEMA = {
   // como decisions.md: é registro vivo — o implementador que descobre um alvo
   // melhor no meio da task precisa poder anotar, e congelá-lo transformaria a
   // correção num bloqueio de gate.
-  reuseMap:       { filename: 'reuse-map.md',          phaseDir: '2-plan',      phase: 'plan',      protected: false },
   // N files, one per system use case — the behaviour layer the plan distils
   // BEFORE spec.md/tasks.json. Deliberately NOT protected: editing a use case
   // after Gate 2 is the supported way to change behaviour and re-run implement;

package/src/core/state/state-manager.js

@@ -581,7 +581,6 @@ export async function createFeature(featureName, options = {}) {
       review: { approved: false, timestamp: null, approvedBy: null }
     },
     gateDecisions: {},
-    taskScores: {},
     tasks: {
       total: 0,
       completed: 0,
@@ -782,7 +781,7 @@ function findClosestMatch(inputType, validTypes) {
 /**
  * Mark output as created
  * @param {string} featureName - Feature name
- * @param {string} outputType - Output type (proposal, spec, mandate, etc.)
+ * @param {string} outputType - Output type (proposal, spec, tasks, etc.)
  */
 export async function markOutput(featureName, outputType) {
   await ensureFeature(featureName);