@polymorphism-tech/morph-spec 8.45.0 → 8.47.0

package/framework/templates/infrastructure/github/README.md

@@ -39,7 +39,8 @@ infrastructure/github/
 - Push to container registry (GHCR or Docker Hub)
 
 ### Deploy Coolify (`deploy-coolify.yml.hbs`)
-- SSHes into the VPS and calls the local Coolify API (`localhost:8000/api/v1/deploy?uuid=...`) after Docker push
+- SSHes into the VPS and calls the local Coolify API (`POST localhost:8000/api/v1/deploy?uuid=...`) after Docker push; the step fails unless the response carries a `deployment_uuid`
+- The token is read on the VPS from `~/<token-file>` (secret `COOLIFY_TOKEN_FILE` holds the file name) and never leaves the SSH session
 - Runs health check after deployment
 - Supports staging + production environments
 

package/framework/templates/infrastructure/github/workflows/deploy-coolify.yml.hbs

@@ -25,7 +25,8 @@ jobs:
       - name: Trigger Coolify Deploy (via SSH — the Coolify API is not publicly exposed)
         run: |
           ssh -i ~/.ssh/id_ed25519 ${{{{ secrets.COOLIFY_SSH_USER }}}}@${{{{ secrets.COOLIFY_SSH_HOST }}}} \
-            'T=$(cat ~/.coolify-token); curl -s -X GET -H "Authorization: Bearer $T" "http://localhost:8000/api/v1/deploy?uuid=${{{{ secrets.COOLIFY_APPLICATION_UUID }}}}"'
+            'T=$(cat ~/${{{{ secrets.COOLIFY_TOKEN_FILE }}}}); curl -s --fail-with-body -X POST -H "Authorization: Bearer $T" "http://localhost:8000/api/v1/deploy?uuid=${{{{ secrets.COOLIFY_APPLICATION_UUID }}}}"' \
+            | grep -q deployment_uuid
 
       - name: Health Check
         run: |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "8.45.0",
+  "version": "8.47.0",
   "description": "MORPH-SPEC: NLH (Natural Language Harness) for spec-driven development with Claude Code",
   "keywords": [
     "claude-code",

package/src/commands/observability/telemetry.js

@@ -12,12 +12,10 @@
 import chalk from 'chalk';
 import { loadTelemetry, aggregateTelemetry } from '../../lib/telemetry/telemetry-reader.js';
 
-// The knowledge-base count reflects EXPLICIT reads only. The core standards
-// load via @-refs in rules (Layer 0/1 auto-load) — those are injected by
-// Claude Code's rules system, not via the Read tool, so no hook ever sees them.
-// A low count here means "few on-demand reads", NOT "standards barely used".
+// A rule injects its standards' digests through Claude Code's rules system,
+// not the Read tool, so no hook sees them: a low count means "few full-text reads".
 const STANDARDS_CAVEAT =
-  'Só reads explícitos (via Read) são observáveis; standards auto-carregados por @-ref nas rules (Layer 0/1) não passam por tool call e ficam invisíveis aqui.';
+  'Só reads explícitos (via Read) são observáveis; o resumo que uma rule injeta ao tocar arquivo casado por `paths:` não passa por tool call: não observável aqui.';
 
 function section(title, rows, fmt) {
   if (!rows.length) return;

package/src/commands/project/init.js

@@ -28,7 +28,7 @@ import {
   setupStitch,
   loadMcpRegistry
 } from '../../lib/installers/mcp-installer.js';
-import { setupInfra, installRulesForStack } from '../../scripts/setup-infra.js';
+import { setupInfra, installRulesForStack, installCommandsForStack } from '../../scripts/setup-infra.js';
 import { installSkills } from '../../utils/skills-installer.js';
 import { installAgents, installDomainAgents } from '../../utils/agents-installer.js';
 import { getProjectTags } from '../../lib/stack-filter.js';
@@ -263,6 +263,7 @@ export async function initCommand(options) {
             const rulesSrc = join(fwSrcDir, 'rules');
             const rulesDest = join(targetPath, '.claude', 'rules');
             installRulesForStack(rulesSrc, rulesDest, stackTags);
+            installCommandsForStack(join(fwSrcDir, 'commands'), join(targetPath, '.claude', 'commands'), stackTags);
 
             // Skills
             await installSkills(targetPath, { projectTags: stackTags });

package/src/commands/project/update.js

@@ -30,7 +30,7 @@ import { installSkills } from '../../utils/skills-installer.js';
 import { installAgents, installDomainAgents } from '../../utils/agents-installer.js';
 import { injectMorphImport } from '../../utils/claude-md-injector.js';
 import { getProjectTags } from '../../lib/stack-filter.js';
-import { updateClaudeMdAgentsBlock, installRulesForStack } from '../../scripts/setup-infra.js';
+import { updateClaudeMdAgentsBlock, installRulesForStack, installCommandsForStack } from '../../scripts/setup-infra.js';
 import { reconcileLegacyTemplatesCopy } from '../../lib/installers/templates-reconcile.js';
 import { createEffects } from '../../lib/installers/effects.js';
 import { applyEditorSettings } from '../../lib/worktree/vscode-settings.js';
@@ -84,6 +84,7 @@ export function frameworkDirsToClean(morphPath, targetPath) {
     join(morphPath, 'framework', 'standards'),
     join(morphPath, 'framework', 'hooks'),
     join(morphPath, 'framework', 'schemas'),
+    // Não é mais instalado: fica na lista para apagar o de instalações antigas.
     join(morphPath, 'framework', 'rubrics'),
     join(morphPath, 'framework', 'evals'),
     join(morphPath, 'config'),
@@ -594,10 +595,8 @@ export async function updateCommand(options = {}) {
       fx.copyFile(agentsSrc, agentsDest);
     }
 
-    // Update the remaining framework payloads (parity with setup-infra 7b/7c/8b/8c/8d) —
-    // MORPH.md, phases.json, schemas/, rubrics/, evals/. Without this, upgrades left
-    // the installed charter/rubrics/eval assets stale forever.
-    updateSpinner.text = 'Updating charter, schemas, rubrics and evals...';
+    // Paridade com setup-infra 7c/8b/8c/8d: sem isto o charter e os evals instalados ficam velhos.
+    updateSpinner.text = 'Updating charter, schemas and evals...';
     const canonicalFrameworkDir = join(__dirname, '..', '..', '..', 'framework');
     for (const file of ['MORPH.md', 'phases.json']) {
       const src = join(canonicalFrameworkDir, file);
@@ -605,7 +604,7 @@ export async function updateCommand(options = {}) {
         fx.copyFile(src, join(morphPath, 'framework', file));
       }
     }
-    for (const dir of ['schemas', 'rubrics', 'evals']) {
+    for (const dir of ['schemas', 'evals']) {
       const src = join(canonicalFrameworkDir, dir);
       if (await pathExists(src)) {
         fx.copyDir(src, join(morphPath, 'framework', dir));
@@ -644,18 +643,6 @@ export async function updateCommand(options = {}) {
     const frameworkDir = join(__dirname, '..', '..', '..', 'framework');
     const claudeDest = join(targetPath, '.claude');
 
-    let commandsCopied = false;
-
-    // Copy commands directory (slash commands): framework/commands/ → .claude/commands/
-    const commandsSrc = join(frameworkDir, 'commands');
-    const commandsDest = join(claudeDest, 'commands');
-    if (await pathExists(commandsSrc)) {
-      fx.copyDir(commandsSrc, commandsDest);
-      commandsCopied = true;
-    } else {
-      logger.warn('  ⚠ framework/commands/ source missing — commands not updated');
-    }
-
     // Compute project tags for stack-aware installation of skills, agents, and rules.
     // MUST come from the pre-clean backup: cleanFrameworkDirs() deleted .morph/config/
     // above and restoreUserConfig() only runs at the end — re-reading the file here
@@ -666,6 +653,17 @@ export async function updateCommand(options = {}) {
       if (configBackup) projectTags = getProjectTags(configBackup);
     } catch { /* ignore — malformed config */ }
 
+    let commandsCopied = false;
+    const commandsSrc = join(frameworkDir, 'commands');
+    if (await pathExists(commandsSrc)) {
+      const commandsDest = join(claudeDest, 'commands');
+      fx.ensureDir(commandsDest);
+      installCommandsForStack(commandsSrc, commandsDest, projectTags, fx);
+      commandsCopied = true;
+    } else {
+      logger.warn('  ⚠ framework/commands/ source missing — commands not updated');
+    }
+
     // Sync morph skills to .claude/skills/ for native Claude Code discovery
     updateSpinner.text = 'Syncing morph skills to .claude/skills/...';
     const skillsResult = await installSkills(targetPath, { projectTags, fx });

package/src/commands/state/approve.js

@@ -6,6 +6,9 @@ import { join } from 'path';
 import { getFeature, setApprovalGate, getApprovalGate, getApprovalHistory, derivePhase } from '../../core/state/state-manager.js';
 import { unmetPrereqs } from '../../core/state/gate-order.js';
 import { evaluatorReportState, VERDICT_TOKEN } from '../../lib/evaluator-report.js';
+import { shouldPauseGate } from '../../lib/risk-detector.js';
+import { collectSignals } from './gate-check.js';
+import { readTrustFromConfig } from './gate-decision.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
 import { uiuxAutoApprovalBlock } from '../../lib/specs/screen-checklist.js';
 import { treeMovedSince } from '../../lib/git/evidence-staleness.js';
@@ -351,6 +354,20 @@ export async function approveCommand(featureName, gateName, options = {}) {
           selfAssessed = true;
         }
 
+        // Sem gate-check prévio não há `gateDecisions.review` para o backstop acima morder; em
+        // campo, ships passaram assim com verify vermelho ou ausente. A auto-aprovação recalcula
+        // a decisão pela MESMA régua do gate-check. --self-assessed já dispensou o veredito.
+        if (approvedBy === 'auto') {
+          const signals = collectSignals(featureName, feature, process.cwd(), 'review');
+          if (selfAssessed) signals.evaluatorVerdict = { status: 'ok', verdict: 'SHIP', blockers: 0, untyped: 0 };
+          const { pause, reason } = shouldPauseGate({ trust: readTrustFromConfig() }, signals);
+          if (pause) {
+            console.error(chalk.red(`\n❌ Gate 3 não pode ser auto-aprovado — ${reason}.`));
+            console.error(chalk.gray('   Corrija e rode de novo, ou leve a decisão ao humano (--approver <nome>).\n'));
+            process.exit(1);
+          }
+        }
+
         if (report.status === 'ok' && report.superseded.length > 0) {
           console.log(chalk.yellow(`\n⚠️  O relatório do avaliador tem ${report.superseded.length + 1} vereditos (append-only).`));
           console.log(chalk.gray(`   Vigente: ${report.verdict}, ${report.blockers.length} bloqueador(es). Superados: ${report.superseded.join(', ')}\n`));

package/src/commands/state/gate-check.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync } from 'fs';
 import { getFeature } from '../../core/state/state-manager.js';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { shouldPauseGate, getRiskSignals, classifyE2eSkip } from '../../lib/risk-detector.js';
-import { evaluatorReportState, evaluatorMediaSection } from '../../lib/evaluator-report.js';
+import { evaluatorReportState, evaluatorMediaSection, verdictSignal } from '../../lib/evaluator-report.js';
 import { collectScreenChecklist } from '../../lib/specs/screen-checklist.js';
 import { persistGateDecision, VALID_GATES, readTrustFromConfig } from './gate-decision.js';
 import { minimatch } from 'minimatch';
@@ -151,7 +151,7 @@ function collectPromptModel(cwd, defaultBranch) {
  * @param {string} gateName
  * @returns {object}
  */
-function collectSignals(featureName, feature, cwd, gateName) {
+export function collectSignals(featureName, feature, cwd, gateName) {
   const tasks = readTasks(featureName);
   const defaultBranch = detectDefaultBranch(cwd);
   const sha = getHeadSha(cwd);
@@ -179,17 +179,7 @@ function collectSignals(featureName, feature, cwd, gateName) {
   }
 
   if (gateName === 'review') {
-    const report = evaluatorReportState(cwd, featureName);
-    signals.evaluatorVerdict = report.status === 'ok'
-      ? {
-        status: 'ok',
-        verdict: report.verdict,
-        blockers: report.blockers.length,
-        blockerIds: report.blockers.map((b) => b.id),
-        untyped: report.untyped.length,
-        superseded: report.superseded,
-      }
-      : { status: report.status };
+    signals.evaluatorVerdict = verdictSignal(evaluatorReportState(cwd, featureName));
     signals.mediaClaims = {
       section: evaluatorMediaSection(cwd, featureName),
       featureGeneratesMedia: featureGeneratesMedia(tasks),
@@ -269,7 +259,7 @@ export async function gateCheckCommand(featureName, gateName, options = {}) {
       process.exit(1);
     }
 
-    // Owner-tree guard: gate-check reads workType/tasks/scores/git off cwd
+    // Owner-tree guard: gate-check reads workType/tasks/verdict/git off cwd
     // AND writes the resulting decision through persistGateDecision — both
     // halves are wrong from a tree that isn't this feature's own, so refuse
     // rather than compute a decision from stale reads and then fail to save it.

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) {
@@ -42,18 +43,13 @@ function selectionLines(runs = []) {
     });
 }
 
-/**
- * Human-readable rendering of a runVerify() result — mirrors the
- * ✓/✗-per-node + feedback-list style of formatScoreBreakdown() in
- * score-aggregator.js, adapted to verify's build/tests/validators nodes.
- */
 function formatVerifyResult(result) {
   const lines = [];
   const scopeLabel = result.scope === 'task' ? `${result.feature}/${result.task}` : result.feature;
 
   lines.push('');
   lines.push(chalk.bold(`Verify — ${scopeLabel}`));
-  lines.push(chalk.gray(`rubric: ${result.rubric}${result.stack ? ` | stack: ${result.stack}` : ''}`));
+  if (result.stack) lines.push(chalk.gray(`stack: ${result.stack}`));
   lines.push('');
   lines.push(result.status === 'pass' ? chalk.green.bold('✓ PASS') : chalk.red.bold('✗ FAIL'));
   lines.push('');
@@ -68,8 +64,6 @@ function formatVerifyResult(result) {
     let detail;
     if (node.status === 'skip') {
       detail = node.reason || '';
-    } else if (name === 'validators' && node.score != null) {
-      detail = `score ${node.score}/10`;
     } else if (node.reason) {
       // A green e2e still carries meaning worth showing: smoke-only vs specs,
       // warm reuse vs rebuild. Without it, "pass" hides how much was proven.
@@ -190,6 +184,53 @@ 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, {
+      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
@@ -202,8 +243,8 @@ const PARTIAL_RUN_FLAGS = [['filter', 'filtered'], ['skipTests', 'skip-tests'],
  * Exit 2 is "the command cannot mean what you typed", and there are four
  * 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);
+ *   - unknown feature, or unknown task id (the task's `group` and `outputs`
+ *     decide the scope, 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
@@ -223,6 +264,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) {
@@ -232,51 +281,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 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 — 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);
+    } 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',
@@ -303,7 +337,6 @@ export async function verifyCommand(featureName, taskId, options = {}) {
     compact = {
       status: result.status,
       nodes: nodeStatuses(result),
-      score: result.nodes.validators.score ?? null,
       attempts: (prevEntry?.attempts ?? 0) + 1,
       updatedAt: now,
     };
@@ -329,9 +362,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);
   }
@@ -341,9 +375,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
@@ -355,10 +389,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

@@ -74,7 +74,7 @@ export const OUTPUT_SCHEMA = {
   // (morph-plan §5). Runtime evidence: input, model, output, verdict — pointing
   // at the `runner: "evals"` node when the stack declares one. CONDITIONAL by
   // construction: never in phases.json requiredOutputs. Readers: morph-review
-  // dispatch prompt, proof rubric eval-de-modelo, test-coverage Q7.
+  // dispatch prompt.
   evidencias:     { dirname: 'evidencias', filenamePattern: '^T\\d+\\.md$', displayFilename: '{taskId}.md',
                     phaseDir: '3-implement', phase: 'implement', protected: false, multi: true },
 

package/src/dashboard/app/App.jsx

@@ -14,7 +14,6 @@ import SkillsLibrary from './pages/SkillsLibrary.jsx';
 import RulesMap from './pages/RulesMap.jsx';
 import Standards from './pages/Standards.jsx';
 import Guide from './pages/Guide.jsx';
-import Rubrics from './pages/Rubrics.jsx';
 import { useNow } from './hooks/usePref.js';
 import { useProjects, useCurrentProject, projectHref } from './lib/project.js';
 
@@ -77,7 +76,6 @@ export default function App() {
             <Route path="/p/:project/activity" element={<Activity />} />
             <Route path="/guide" element={<Guide />} />
             <Route path="/guide/:doc" element={<Guide />} />
-            <Route path="/rubrics" element={<Rubrics />} />
             <Route path="/agents" element={<AgentMap />} />
             <Route path="/phases" element={<PhasePipeline />} />
             <Route path="/hooks" element={<HookInspector />} />

package/src/dashboard/app/components/CommandPalette.jsx

@@ -9,12 +9,12 @@ import { apiBase, projectHref, featureHref } from '../lib/project.js';
 
 const KIND_LABEL = {
   page: 'Página', project: 'Projeto', feature: 'Feature', task: 'Task', skill: 'Skill', persona: 'Persona',
-  standard: 'Standard', rule: 'Rule', hook: 'Hook', guide: 'Guia', rubric: 'Rubrica',
+  standard: 'Standard', rule: 'Rule', hook: 'Hook', guide: 'Guia',
 };
 
 const PAGES = [
   ['Portfólio', '/'], ['Guia', '/guide'], ['Fases', '/phases'], ['Skills', '/skills'],
-  ['Personas', '/agents'], ['Standards', '/standards'], ['Rules', '/rules'], ['Hooks', '/hooks'], ['Rubricas', '/rubrics'],
+  ['Personas', '/agents'], ['Standards', '/standards'], ['Rules', '/rules'], ['Hooks', '/hooks'],
 ];
 
 /** Everything the framework knows that has a page — built once. */
@@ -35,7 +35,6 @@ function knowledgeIndex() {
       out.push({ kind: 'guide', title: h.text, hint: d.title, to: `/guide/${d.id}#${h.slug}`, hay: `${h.text} ${d.title}` });
     }
   }
-  for (const r of morphData.docs?.rubrics || []) out.push({ kind: 'rubric', title: r.title, to: `/rubrics?sel=${encodeURIComponent(`dim:${r.id}`)}`, hay: r.title });
   return out;
 }
 

package/src/dashboard/app/components/EntityLink.jsx

@@ -16,7 +16,6 @@ export function entityHref(kind, id) {
     case 'hook': return q('hooks');
     case 'phase': return q('phases');
     case 'guide': return `/guide/${encodeURIComponent(id)}`;
-    case 'rubric': return q('rubrics');
     default: return '#';
   }
 }

package/src/dashboard/app/components/Markdown.jsx

@@ -7,7 +7,7 @@ const REMARK = [remarkGfm];
 const REHYPE = [rehypeSlug];
 
 /** Frontmatter keys worth showing, in the order a reader wants them. */
-const META_ORDER = ['name', 'description', 'when-to-invoke', 'user-invokable', 'stacks', 'version', 'cliVersion'];
+const META_ORDER = ['name', 'description', 'when_to_use', 'user-invocable', 'stacks', 'version', 'cliVersion'];
 
 function MetaBlock({ meta }) {
   const keys = Object.keys(meta).sort((a, b) => {

package/src/dashboard/app/components/Sidebar.jsx

@@ -1,6 +1,6 @@
 import { NavLink, useLocation, useNavigate } from 'react-router-dom';
 import {
-  MagnifyingGlass, SquaresFour, Kanban, Pulse, BookOpen, FlowArrow, PuzzlePiece, UsersThree, Books, Ruler, Plug, Scales,
+  MagnifyingGlass, SquaresFour, Kanban, Pulse, BookOpen, FlowArrow, PuzzlePiece, UsersThree, Books, Ruler, Plug,
 } from '@phosphor-icons/react';
 import { projectHref } from '../lib/project.js';
 
@@ -12,7 +12,6 @@ const KNOWLEDGE = [
   { to: '/standards', label: 'Standards', icon: Books },
   { to: '/rules', label: 'Rules', icon: Ruler },
   { to: '/hooks', label: 'Hooks', icon: Plug },
-  { to: '/rubrics', label: 'Rubricas', icon: Scales },
 ];
 
 function Badge({ pulse }) {

package/src/dashboard/app/pages/RulesMap.jsx

@@ -15,7 +15,7 @@ const NODE_W = 260;
 // ─── Standard resolution ──────────────────────────────────────────────────────
 
 /**
- * A rule's @-import → the standard it names in the registry. `id` is what the
+ * A rule's route → the standard it names in the registry. `id` is what the
  * Standards page selects by; with no registry match the path itself is passed,
  * so the link still says which file the rule meant.
  */
@@ -196,7 +196,7 @@ function RuleDetail({ rule, byPath }) {
         )}
       </Section>
 
-      <Section title="Standards importados">
+      <Section title="Standards roteados (resumo)">
         {rule.standardRefs.length > 0 ? (
           <div className="flex flex-wrap gap-1.5">
             {rule.standardRefs.map((ref) => {
@@ -209,7 +209,7 @@ function RuleDetail({ rule, byPath }) {
             })}
           </div>
         ) : (
-          <p className="text-xs">Esta regra não importa nenhum standard.</p>
+          <p className="text-xs">Esta regra não roteia nenhum standard.</p>
         )}
       </Section>
 

package/src/dashboard/app/pages/SkillsLibrary.jsx

@@ -315,10 +315,10 @@ export function SkillDetail({ skill, phases = morphData.phases?.list || [] }) {
       {skill.description && <p className="leading-relaxed text-[var(--color-fg)]">{skill.description}</p>}
 
       <dl className="grid grid-cols-[max-content_1fr] gap-x-4 gap-y-2 rounded-xl bg-white/[0.03] px-4 py-3 shadow-[inset_0_0_0_1px_var(--color-hair)]">
-        {skill.whenToInvoke && (
+        {skill.whenToUse && (
           <>
             <dt className="text-xs leading-6 text-[var(--color-faint)]">Quando usar</dt>
-            <dd className="leading-6">{skill.whenToInvoke}</dd>
+            <dd className="leading-6">{skill.whenToUse}</dd>
           </>
         )}
         <dt className="text-xs leading-6 text-[var(--color-faint)]">Fase</dt>
@@ -389,7 +389,7 @@ export default function SkillsLibrary() {
   const isMatch = useCallback((s) => {
     const q = search.trim().toLowerCase();
     if (q) {
-      const hay = [s.id, s.name, s.description, s.whenToInvoke].filter(Boolean).join(' ').toLowerCase();
+      const hay = [s.id, s.name, s.description, s.whenToUse].filter(Boolean).join(' ').toLowerCase();
       if (!hay.includes(q)) return false;
     }
     if (phaseFilter) {

package/src/dashboard/scanner/activity-scanner.js

@@ -18,7 +18,7 @@ import { isFailedToolCall } from '../../../framework/hooks/shared/telemetry-logg
 export const DEFAULT_KINDS = ['prompt', 'question', 'skill', 'dispatch', 'handback', 'task', 'verify', 'gate', 'failure'];
 export const ALL_KINDS = [...DEFAULT_KINDS, 'write', 'read', 'command', 'tool'];
 
-const GATE_COMMAND = /\bmorph-spec\s+(approve|gate-check|gate-decision|advance|score|finish)\b/;
+const GATE_COMMAND = /\bmorph-spec\s+(approve|gate-check|gate-decision|advance|finish)\b/;
 const MORPH_PERSONA = /^morph-(.+)$/;
 const SHELL_TOOLS = new Set(['Bash', 'PowerShell']);
 const SILENT_EVENTS = new Set(['ToolBatch', 'SessionUsage', 'AgentUsage']);