@polymorphism-tech/morph-spec 8.45.0 → 8.47.0

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

@@ -1,9 +1,9 @@
 /**
  * The reading material of the framework — the charter, the runtime
- * instructions, the CLI reference and the rubrics the evaluator scores with —
- * for the dashboard's Guide and Rubrics pages.
+ * instructions, the CLI reference and the Gate 3 evaluator checklist — for the
+ * dashboard's Guide page.
  */
-import { readFileSync, readdirSync, existsSync } from 'fs';
+import { readFileSync } from 'fs';
 import { join } from 'path';
 
 function read(path) {
@@ -23,26 +23,11 @@ export function headingsOf(content) {
   return out;
 }
 
-function titleOf(content, fallback) {
-  const h = headingsOf(content || '').find((x) => x.depth === 1);
-  return h?.text || fallback;
-}
-
-function mdDir(dir) {
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir)
-    .filter((f) => f.endsWith('.md'))
-    .sort()
-    .map((f) => {
-      const content = read(join(dir, f)) || '';
-      return { id: f.replace(/\.md$/, ''), file: f, title: titleOf(content, f.replace(/\.md$/, '')), content };
-    });
-}
-
 const GUIDE = [
   { id: 'morph', path: 'MORPH.md', title: 'Carta do harness (MORPH.md)', summary: 'Como o Claude trabalha: papéis, fases, gates, sub-agents. É a fonte única do comportamento.' },
   { id: 'runtime', path: 'CLAUDE.md', title: 'Instruções de runtime (CLAUDE.md)', summary: 'O que é injetado no CLAUDE.md do projeto: como começar cada sessão, regras críticas, comandos.' },
   { id: 'cli', path: 'docs/CLI.md', title: 'Referência do CLI', summary: 'Todos os comandos morph-spec: gates, verify, worktrees, grafo, telemetria.' },
+  { id: 'review-checklist', path: 'evals/review-checklist.md', title: 'Checklist do avaliador (Gate 3)', summary: 'O que o avaliador independente procura antes do ship: veredito SHIP/FIX e bloqueador com evidência.' },
 ];
 
 export function scanDocs(frameworkDir) {
@@ -51,8 +36,5 @@ export function scanDocs(frameworkDir) {
     return { ...g, content, headings: headingsOf(content).filter((h) => h.depth <= 3) };
   }).filter((g) => g.content);
 
-  return {
-    guide,
-    rubrics: mdDir(join(frameworkDir, 'evals')).filter((d) => d.id === 'review-checklist'),
-  };
+  return { guide };
 }

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

@@ -310,7 +310,7 @@ export function scanFeatures(projectDir, { resolveTree = resolveFeatureTree } =
 }
 
 /**
- * One feature in full: summary + tasks with their verify/score, the gate
+ * One feature in full: summary + tasks with their verify, the gate
  * decisions, the verify nodes and the document tree.
  */
 export function readFeatureDetail(projectDir, name, { resolveTree = resolveFeatureTree, known } = {}) {

package/src/dashboard/scanner/index.js

@@ -4,7 +4,6 @@ import { scanHooks } from './hooks-scanner.js';
 import { scanSkills } from './skills-scanner.js';
 import { scanStandards } from './standards-scanner.js';
 import { scanRules } from './rules-scanner.js';
-import { scanRubrics } from './rubrics-scanner.js';
 import { scanDocs } from './docs-scanner.js';
 
 /**
@@ -21,7 +20,6 @@ export function scanAll(frameworkDir) {
     skills: scanSkills(frameworkDir, phases.list),
     standards: scanStandards(frameworkDir, agents.list),
     rules: scanRules(frameworkDir),
-    rubrics: scanRubrics(frameworkDir),
     docs: scanDocs(frameworkDir),
   };
 }

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

@@ -18,17 +18,22 @@ function parseFrontmatter(content) {
   return { paths, stacks };
 }
 
-/**
- * Standards a rule imports, each once. RulesMap keys an edge per ref, so a
- * rule that imports the same standard twice (infrastructure-standards.md did,
- * up to 8.38.0) drew two edges under one React key.
- */
+const ROUTE_LINE = /^- \*\*([a-z0-9-]+)\*\* \(`([^`]+\.md)`\)/;
+
+// Bullet form: - **<id>** (`<path under standards/>`) — <digest>. An `@path`
+// import inside .claude/rules resolves relative to the rule file and never loads.
+export function parseStandardRoutes(content) {
+  const routes = [];
+  for (const line of content.split(/\r?\n/)) {
+    const m = ROUTE_LINE.exec(line);
+    if (m) routes.push({ id: m[1], path: m[2] });
+  }
+  return routes;
+}
+
+// RulesMap keys one edge per ref, so a repeated path would collide.
 export function extractStandardRefs(content) {
-  const refs = new Set();
-  const regex = /@\.morph\/framework\/standards\/(.+\.md)/g;
-  let m;
-  while ((m = regex.exec(content)) !== null) refs.add(m[1]);
-  return [...refs];
+  return [...new Set(parseStandardRoutes(content).map((r) => r.path))];
 }
 
 export function scanRules(frameworkDir) {

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

@@ -84,13 +84,12 @@ export function scanSkills(frameworkDir, phases = []) {
       if (!existsSync(skillPath)) continue;
       const content = readFileSync(skillPath, 'utf8');
       const fm = parseFrontmatter(content);
-      // The framework spells it `user-invokable`; the Claude Code docs say `user-invocable`.
-      const invocable = fm['user-invokable'] ?? fm['user-invocable'];
+      const invocable = fm['user-invocable'];
       skills.push({
         id: skillDir.name,
         name: fm.name || skillDir.name,
         description: fm.description || '',
-        whenToInvoke: fm['when-to-invoke'] || '',
+        whenToUse: fm.when_to_use || '',
         level: levelDir.name,
         userInvocable: invocable === true || invocable === 'true',
         stacks: typeof fm.stacks === 'string' ? fm.stacks.replace(/[[\]]/g, '').split(',').map((s) => s.trim()).filter(Boolean) : [],

package/src/lib/ci/ci-verify.js

@@ -0,0 +1,118 @@
+import { execFileSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getHeadSha } from '../git/default-branch.js';
+import { treeMovedSince } from '../git/evidence-staleness.js';
+import { resolveGh } from '../git/gh.js';
+import {
+  CI_WORKFLOW_DIR, CI_WORKFLOW_FILE, ciAvailability, downloadResult, findCiWorkflow, pushBranch,
+  uncommittedCode, waitForRun, workflowPushProblem,
+} from './github-ci.js';
+import { renderCiWorkflow } from './workflow-scaffold.js';
+
+export const CI_WAIT_MS = 50 * 60 * 1000;
+const APPEAR_MS = Number(process.env.MORPH_CI_APPEAR_MS ?? 90 * 1000);
+
+export class CiUsageError extends Error {}
+
+const NODE_KEYS = ['build', 'tests', 'validators', 'e2e'];
+
+function isVerifyResult(result) {
+  return Boolean(result) && ['pass', 'fail'].includes(result.status) && result.scope === 'feature'
+    && NODE_KEYS.every((k) => typeof result.nodes?.[k]?.status === 'string');
+}
+
+function scaffoldWorkflow(root, config) {
+  const rel = `${CI_WORKFLOW_DIR}/${CI_WORKFLOW_FILE}`;
+  const abs = join(root, rel);
+  if (existsSync(abs)) return { error: `${rel} já existe e não chama morph-spec verify publicando o JSON` };
+  try {
+    mkdirSync(join(root, CI_WORKFLOW_DIR), { recursive: true });
+    writeFileSync(abs, renderCiWorkflow(root, config));
+    execFileSync('git', ['add', '--', rel], { cwd: root, stdio: 'pipe' });
+    execFileSync('git', ['commit', '-m', 'ci: workflow morph-verify (prova do Gate 3 no CI)', '--', rel], { cwd: root, stdio: 'pipe' });
+    return { path: rel };
+  } catch (err) {
+    return { error: `não consegui criar ${rel}: ${(err.stderr?.toString() || err.message).trim()}` };
+  }
+}
+
+function dispatchWorkflow(root, workflow, branch) {
+  try {
+    const { bin, prefix } = resolveGh();
+    execFileSync(bin, [...prefix, 'workflow', 'run', workflow, '--ref', branch], { cwd: root, stdio: 'pipe', timeout: 15000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * `verify {f} --ci`: the feature-scope proof, run by the project's CI over the pushed commit.
+ * Every way CI cannot answer is `mode: 'local'` with the reason, and the caller runs the local
+ * verify: no CI is never a pause. Only the uploaded `verify --json` becomes a result, so the
+ * gate judges a CI run by the same stamp and the same rules as a local one.
+ *
+ * @returns {Promise<
+ *   { mode: 'local', reason: string } |
+ *   { mode: 'pending', reason: string, run: object|null } |
+ *   { mode: 'ci', result: object, run: object, created: string|null }>}
+ * @throws {CiUsageError} code CI would not see (uncommitted work)
+ */
+export async function runCiVerify(root, featureName, config, { log = () => {}, waitMs = CI_WAIT_MS, wait = waitForRun } = {}) {
+  const avail = ciAvailability(root, featureName, config);
+  if (!avail.ok) return { mode: 'local', reason: avail.reason };
+
+  const dirty = uncommittedCode(root);
+  if (dirty === null) return { mode: 'local', reason: 'git status não respondeu' };
+  if (dirty.length > 0) {
+    const shown = dirty.slice(0, 5).join(', ') + (dirty.length > 5 ? ` (+${dirty.length - 5})` : '');
+    throw new CiUsageError(`o CI só vê commits e há trabalho fora deles: ${shown}. Commite na branch da feature (git add <paths> && git commit) e rode de novo, ou rode sem --ci`);
+  }
+
+  let workflow = findCiWorkflow(root);
+  let created = null;
+  if (!workflow) {
+    const problem = workflowPushProblem(avail);
+    if (problem) return { mode: 'local', reason: problem };
+    const scaffold = scaffoldWorkflow(root, config);
+    if (scaffold.error) return { mode: 'local', reason: scaffold.error };
+    created = scaffold.path;
+    workflow = CI_WORKFLOW_FILE;
+    log(`workflow criado e commitado: ${created}`);
+  }
+
+  const pushError = pushBranch(root, avail.branch);
+  if (pushError) return { mode: 'local', reason: `push de ${avail.branch} falhou: ${pushError}` };
+
+  const head = getHeadSha(root);
+  const waitOpts = {
+    branch: avail.branch,
+    workflow,
+    isCurrent: (sha) => !treeMovedSince(root, sha, head),
+    timeoutMs: waitMs,
+    appearMs: APPEAR_MS,
+    onPending: (run) => log(`CI rodando: ${run.url}`),
+  };
+  let outcome = await wait(root, waitOpts);
+  if (outcome.state === 'no-run' && dispatchWorkflow(root, workflow, avail.branch)) {
+    log(`nenhum run para este commit; disparei ${workflow} manualmente`);
+    outcome = await wait(root, waitOpts);
+  }
+  if (outcome.state === 'no-run') return { mode: 'local', reason: `${workflow} não rodou para este commit` };
+  if (outcome.state === 'unknown') return { mode: 'local', reason: 'gh run list não respondeu' };
+  if (outcome.state === 'timeout') {
+    return { mode: 'pending', reason: `o CI não terminou em ${Math.round(waitMs / 60000)} min`, run: outcome.run ?? null };
+  }
+
+  const { run } = outcome;
+  const result = downloadResult(root, run.databaseId);
+  if (!isVerifyResult(result)) {
+    return {
+      mode: 'local',
+      reason: `run ${run.conclusion} sem o JSON do verify (${run.url}; gh run view ${run.databaseId} --log-failed)`,
+    };
+  }
+  const { persisted, reason, repeatOf, cleanup, ...verdict } = result;
+  return { mode: 'ci', result: verdict, run, created };
+}

package/src/lib/ci/github-ci.js

@@ -0,0 +1,192 @@
+import { execFileSync, spawnSync } from 'child_process';
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { resolveGh } from '../git/gh.js';
+
+export const CI_WORKFLOW_DIR = '.github/workflows';
+export const CI_WORKFLOW_FILE = 'morph-verify.yml';
+export const CI_ARTIFACT = 'morph-verify';
+export const CI_RESULT_FILE = 'morph-verify.json';
+
+// A run that never judged the code (superseded, filtered out, quota) is no proof either way.
+const NO_VERDICT = new Set(['cancelled', 'skipped', 'startup_failure', 'stale', 'neutral']);
+
+const VERIFY_CALL = /morph-spec\S*\s+verify\b/;
+
+const git = (cwd, args) => execFileSync('git', args, { cwd, stdio: 'pipe' }).toString();
+
+function gh(cwd, args, timeout = 15000) {
+  const { bin, prefix } = resolveGh();
+  return execFileSync(bin, [...prefix, ...args], { cwd, stdio: 'pipe', timeout }).toString();
+}
+
+/**
+ * The workflow that can stand in for `verify {feature}`: it must call `morph-spec verify` AND
+ * publish its JSON, because only that artifact becomes a stamp. A green run of any other
+ * workflow (lint, deploy) proves nothing about the suite.
+ *
+ * @param {string} root
+ * @returns {string|null} workflow file name, as `gh run list --workflow` takes it
+ */
+export function findCiWorkflow(root) {
+  const dir = join(root, CI_WORKFLOW_DIR);
+  if (!existsSync(dir)) return null;
+  const files = readdirSync(dir).filter((f) => /\.ya?ml$/i.test(f)).sort((a, b) =>
+    (a === CI_WORKFLOW_FILE ? -1 : b === CI_WORKFLOW_FILE ? 1 : a.localeCompare(b)));
+  for (const file of files) {
+    let text;
+    try {
+      text = readFileSync(join(dir, file), 'utf8');
+    } catch {
+      continue;
+    }
+    if (VERIFY_CALL.test(text) && text.includes(CI_RESULT_FILE)) return file;
+  }
+  return null;
+}
+
+export function currentBranch(root) {
+  try {
+    return git(root, ['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+  } catch {
+    return null;
+  }
+}
+
+function originUrl(root) {
+  try {
+    return git(root, ['config', '--get', 'remote.origin.url']).trim();
+  } catch {
+    return null;
+  }
+}
+
+function ghAuthText(root) {
+  const { bin, prefix } = resolveGh();
+  const res = spawnSync(bin, [...prefix, 'auth', 'status'], { cwd: root, stdio: 'pipe', timeout: 10000 });
+  if (res.error || res.status !== 0) return null;
+  return `${res.stdout ?? ''}${res.stderr ?? ''}`;
+}
+
+/**
+ * Whether CI can answer for this feature, and why not. Never throws: every "no" is a reason the
+ * caller prints before falling back to the local verify.
+ *
+ * @param {string} root - the feature's tree
+ * @param {string} featureName
+ * @param {object|null} config - `.morph/config/config.json`
+ * @returns {{ ok: true, branch: string, https: boolean, scopes: string|null } | { ok: false, reason: string }}
+ */
+export function ciAvailability(root, featureName, config) {
+  if (config?.project?.ci === false) return { ok: false, reason: 'project.ci = false no config.json' };
+  const url = originUrl(root);
+  if (!url) return { ok: false, reason: 'sem remote origin' };
+  if (!/github\.com/i.test(url)) return { ok: false, reason: 'origin não é GitHub' };
+  const branch = currentBranch(root);
+  if (branch !== `morph/${featureName}`) {
+    return { ok: false, reason: `branch atual "${branch}" não é morph/${featureName}` };
+  }
+  const auth = ghAuthText(root);
+  if (auth === null) return { ok: false, reason: 'gh ausente ou não autenticado' };
+  const scopes = auth.match(/Token scopes:\s*(.*)/i)?.[1] ?? null;
+  return { ok: true, branch, https: /^https?:/i.test(url), scopes };
+}
+
+/**
+ * Creating a workflow file over HTTPS needs the token's `workflow` scope; without it GitHub
+ * rejects the whole push. Unknown scopes (fine-grained token, SSH remote) are not a refusal.
+ */
+export function workflowPushProblem({ https, scopes }) {
+  if (!https || scopes === null) return null;
+  return /\bworkflow\b/.test(scopes) ? null : 'o token do gh não tem o escopo "workflow" (gh auth refresh -s workflow)';
+}
+
+/**
+ * Paths CI would not see: uncommitted or untracked files outside `.morph/`, plus the config,
+ * which names the test commands.
+ *
+ * @returns {string[]|null} null when git did not answer
+ */
+export function uncommittedCode(root) {
+  let out;
+  try {
+    out = git(root, ['status', '--porcelain', '-z', '--untracked-files=all', '--no-renames']);
+  } catch {
+    return null;
+  }
+  return out.split('\0').filter(Boolean).map((line) => line.slice(3))
+    .filter((path) => !path.startsWith('.morph/') || path === '.morph/config/config.json');
+}
+
+export function pushBranch(root, branch) {
+  try {
+    git(root, ['push', '-u', 'origin', branch]);
+    return null;
+  } catch (err) {
+    return (err.stderr?.toString() || err.message).trim().split('\n').slice(-3).join(' ');
+  }
+}
+
+/** @returns {Array<object>|null} newest first; null = gh did not answer */
+export function listRuns(root, branch, workflow) {
+  try {
+    return JSON.parse(gh(root, ['run', 'list', '--branch', branch, '--workflow', workflow, '--limit', '20',
+      '--json', 'databaseId,status,conclusion,headSha,url,createdAt']));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The newest run over the same code as HEAD. `isCurrent` is a tree comparison, not SHA equality:
+ * the evaluator and the archive commit only `.morph/`, and the workflow does not re-run for them.
+ */
+export function pickRun(runs, isCurrent) {
+  return (runs || []).find((run) => !(run.status === 'completed' && NO_VERDICT.has(run.conclusion))
+    && run.headSha && isCurrent(run.headSha)) ?? null;
+}
+
+/** @returns {object|null} the parsed `verify --json` the run uploaded; null when absent or unreadable */
+export function downloadResult(root, runId) {
+  const dir = mkdtempSync(join(tmpdir(), 'morph-ci-'));
+  try {
+    gh(root, ['run', 'download', String(runId), '--name', CI_ARTIFACT, '--dir', dir], 120000);
+    return JSON.parse(readFileSync(join(dir, CI_RESULT_FILE), 'utf8'));
+  } catch {
+    return null;
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Polls until the run over the current tree completes. Never decides: the caller turns
+ * `timeout`/`no-run`/`unknown` into "no CI proof", never into red.
+ *
+ * @returns {Promise<{ state: 'completed'|'timeout'|'no-run'|'unknown', run?: object }>}
+ */
+export async function waitForRun(root, { branch, workflow, isCurrent, timeoutMs, appearMs, pollMs = 15000,
+  sleep = (ms) => new Promise((r) => setTimeout(r, ms)), now = Date.now, onPending = () => {}, list = listRuns }) {
+  const start = now();
+  let seen = false;
+  let misses = 0;
+  for (;;) {
+    const runs = list(root, branch, workflow);
+    if (runs === null) {
+      if (++misses >= 3) return { state: 'unknown' };
+    } else {
+      misses = 0;
+      const run = pickRun(runs, isCurrent);
+      if (run?.status === 'completed') return { state: 'completed', run };
+      if (run) {
+        if (!seen) onPending(run);
+        seen = true;
+      }
+    }
+    const elapsed = now() - start;
+    if (!seen && elapsed >= appearMs) return { state: 'no-run' };
+    if (elapsed >= timeoutMs) return { state: 'timeout' };
+    await sleep(pollMs);
+  }
+}

package/src/lib/ci/workflow-scaffold.js

@@ -0,0 +1,122 @@
+import { existsSync, readdirSync } from 'fs';
+import { join, posix, relative, resolve } from 'path';
+import { PACKAGE_LOCATIONS } from '../detectors/index.js';
+import { CI_ARTIFACT, CI_RESULT_FILE } from './github-ci.js';
+
+const LOCKFILES = [
+  ['package-lock.json', 'npm ci'],
+  ['pnpm-lock.yaml', 'corepack enable && pnpm install --frozen-lockfile'],
+  ['yarn.lock', 'corepack enable && yarn install --frozen-lockfile'],
+];
+const PLAYWRIGHT_CONFIGS = ['playwright.config.ts', 'playwright.config.js', 'playwright.config.mjs'];
+
+function packageDirs(root, config) {
+  const dirs = [...PACKAGE_LOCATIONS];
+  if (typeof config?.project?.frontendPath === 'string') dirs.push(config.project.frontendPath);
+  for (const node of Array.isArray(config?.project?.tests) ? config.project.tests : []) {
+    if (typeof node?.cwd === 'string') dirs.push(node.cwd);
+  }
+  const seen = new Set();
+  const out = [];
+  for (const dir of dirs) {
+    const abs = resolve(root, dir.trim() || '.');
+    const rel = relative(root, abs).split('\\').join('/') || '.';
+    if (rel.startsWith('..') || seen.has(rel)) continue;
+    seen.add(rel);
+    const lock = LOCKFILES.find(([file]) => existsSync(join(abs, file)));
+    if (lock) out.push({ dir: rel, install: lock[1], playwright: PLAYWRIGHT_CONFIGS.some((f) => existsSync(join(abs, f))) });
+  }
+  return out;
+}
+
+function usesDotnet(root, config) {
+  if (existsSync(join(root, 'global.json'))) return true;
+  if (/dotnet/i.test(String(config?.project?.stack ?? ''))) return true;
+  if ((config?.project?.tests ?? []).some?.((node) => node?.runner === 'dotnet' || /\bdotnet\b/.test(node?.command ?? ''))) return true;
+  try {
+    return readdirSync(root).some((f) => /\.(sln|slnx|csproj)$/i.test(f));
+  } catch {
+    return false;
+  }
+}
+
+function dotnetSetup(root, config) {
+  if (!usesDotnet(root, config)) return [];
+  const hasGlobalJson = existsSync(join(root, 'global.json'));
+  return [
+    '      - uses: actions/setup-dotnet@v4',
+    '        with:',
+    hasGlobalJson ? '          global-json-file: global.json' : "          dotnet-version: '10.0.x'",
+  ];
+}
+
+const step = (name, dir, run) => [
+  `      - name: ${name}`,
+  ...(dir === '.' ? [] : [`        working-directory: ${posix.normalize(dir)}`]),
+  `        run: ${run}`,
+];
+
+/**
+ * The workflow `verify {f} --ci` relies on. Same judge as the local run: it calls the project's
+ * pinned morph-spec, so the suite is whatever `project.tests` says, not a second definition here.
+ * `.morph/` is out of the trigger (bookkeeping commits would cancel the run over the code) except
+ * the config, which names the commands.
+ *
+ * @param {string} root
+ * @param {object|null} config
+ * @returns {string}
+ */
+export function renderCiWorkflow(root, config) {
+  const packages = packageDirs(root, config);
+  const lines = [
+    '# Gerado por morph-spec: a prova do Gate 3 roda aqui (verify {feature} --ci).',
+    'name: morph-verify',
+    '',
+    'on:',
+    '  push:',
+    "    branches: ['morph/**']",
+    '    paths:',
+    "      - '**'",
+    "      - '!.morph/**'",
+    "      - '.morph/config/config.json'",
+    '  workflow_dispatch:',
+    '',
+    'concurrency:',
+    '  group: morph-verify-${{ github.ref }}',
+    '  cancel-in-progress: true',
+    '',
+    'jobs:',
+    '  verify:',
+    '    runs-on: ubuntu-latest',
+    '    timeout-minutes: 45',
+    '    env:',
+    "      MORPH_HEAVY: 'off'",
+    '    steps:',
+    '      - uses: actions/checkout@v4',
+    '      - uses: actions/setup-node@v4',
+    '        with:',
+    "          node-version: '22'",
+    ...dotnetSetup(root, config),
+  ];
+  for (const pkg of packages) {
+    lines.push(...step(`install (${pkg.dir})`, pkg.dir, pkg.install));
+    if (pkg.playwright) lines.push(...step(`playwright browsers (${pkg.dir})`, pkg.dir, 'npx playwright install --with-deps chromium'));
+  }
+  lines.push(
+    '      - name: morph-spec verify',
+    '        shell: bash',
+    '        run: |',
+    '          feature="${GITHUB_REF_NAME#morph/}"',
+    "          version=$(node -p \"try { require('./.morph/.morphversion').morphVersion } catch { 'latest' }\")",
+    `          npx -y "@polymorphism-tech/morph-spec@\${version}" verify "$feature" --json --no-persist > ${CI_RESULT_FILE}`,
+    '      - uses: actions/upload-artifact@v4',
+    '        if: always()',
+    '        with:',
+    `          name: ${CI_ARTIFACT}`,
+    `          path: ${CI_RESULT_FILE}`,
+    '          if-no-files-found: ignore',
+    '          retention-days: 7',
+    '',
+  );
+  return lines.join('\n');
+}

package/src/lib/evaluator-report.js

@@ -79,6 +79,19 @@ export function evaluatorReportState(cwd, featureName) {
   return { status: 'ok', path, ...parsed };
 }
 
+/** O sinal `evaluatorVerdict` que `verdictPause` (risk-detector) lê — gate-check e approve leem o mesmo. */
+export function verdictSignal(report) {
+  if (report.status !== 'ok') return { status: report.status };
+  return {
+    status: 'ok',
+    verdict: report.verdict,
+    blockers: report.blockers.length,
+    blockerIds: report.blockers.map((b) => b.id),
+    untyped: report.untyped.length,
+    superseded: report.superseded,
+  };
+}
+
 export function evaluatorMediaSection(cwd, featureName) {
   const text = readReport(cwd, featureName);
   return text !== null && MEDIA_SECTION_RE.test(text);

package/src/lib/risk-detector.js

@@ -244,6 +244,14 @@ export function shouldPauseGate(config, signals) {
     };
   }
 
+  // No ship, ausência de stamp não é "verde": uma feature foi aprovada em campo sem verify nenhum.
+  if (signals.gate === 'review' && !signals.verificationStatus) {
+    return {
+      pause: true,
+      reason: 'nenhum `morph-spec verify` carimbado nesta feature — rode `morph-spec verify {feature}` antes do ship',
+    };
+  }
+
   // No gate de SHIP: um `verification` PRESENTE cujo escopo não é o da feature
   // é um recorte parcial — de UMA task, nunca da app inteira. O stamp é
   // SINGULAR, sobrescrito por qualquer verify de qualquer escopo, e vale

package/src/lib/stack/stack-profile.js

@@ -19,7 +19,7 @@ const NO_VALIDATOR_STACKS = new Set(['nodejs-cli', 'node-cli', 'cli']);
 const PROFILES = {
   dotnet: {
     isDotnet: true, isNextjs: false,
-    defaultValidators: ['architecture', 'packages'],
+    defaultValidators: ['packages'],
     buildCommand: 'dotnet build --no-restore',
   },
   nextjs: {

package/src/lib/telemetry/verify-event.js

@@ -14,10 +14,10 @@ const NODE_NAMES = ['build', 'tests', 'validators', 'e2e'];
 /**
  * @param {Object} result - runVerify() output
  * @param {{ sha: string|null, tree: 'root'|'worktree', persisted: boolean, reason: string|null,
- *   fingerprint?: string|null }} context
+ *   fingerprint?: string|null, source?: 'local'|'ci' }} context
  * @returns {Object}
  */
-export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerprint = null }) {
+export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerprint = null, source = 'local' }) {
   const nodes = {};
   for (const name of NODE_NAMES) {
     const node = result.nodes?.[name];
@@ -40,6 +40,7 @@ export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerp
     tree,
     persisted,
     reason: persisted ? null : (reason ?? null),
+    source,
     nodes,
   };
 }

package/src/lib/validators/reuse/reuse-validator.js

@@ -1,15 +1,14 @@
 /**
  * Reuse Validator — símbolo novo cujo nome já existe no codebase.
  *
- * A terceira camada do ciclo de reuso, no molde do `design-system-validator`:
+ * A terceira camada do ciclo de reuso:
  *
  *   PROSA (morph-plan, personas)  ──►  ARTEFATO (`reuse` em tasks.json)
  *   ──►  COBRANÇA (este arquivo)
  *
  * Prosa sozinha não segura — `morph-brainstorming/SKILL.md:39` já manda olhar
  * o que existe, e o ProspectPRO redefiniu `SimpleBuilding` em cinco arquivos da
- * MESMA pasta assim mesmo. O único ciclo que funciona no framework (design
- * tokens) tem verificação em código; este é o equivalente para código.
+ * MESMA pasta assim mesmo: só a verificação em código segura o ciclo.
  *
  * Regras, na ordem em que reduzem ruído:
  *

package/src/lib/validators/reuse/symbol-scanner.js

@@ -9,8 +9,7 @@
  * papéis produziria um validador cego justamente na janela em que ele precisa
  * morder — ver graph-loader.js `getFreshness`.
  *
- * A varredura é por linha, com regex ancorada no início da declaração. Mesma
- * limitação (e mesmo grau de tolerância) do design-system-validator: uma
+ * A varredura é por linha, com regex ancorada no início da declaração: uma
  * declaração citada dentro de uma string ou de um comentário de bloco pode
  * passar. O custo de errar é um aviso a mais, nunca um bloqueio silencioso.
  *
@@ -28,8 +27,7 @@ import { isProjectSource } from '../../../../framework/hooks/shared/source-files
  *
  * A lista é curta de propósito e só admite nome genérico de UMA palavra: assim
  * que há qualificador de domínio (`BuildingFiltersProps`, `FilterOption`) o
- * nome volta a ser um conceito e a regra vale. Mesmo papel da allowlist de
- * cores de sistema no design-system-validator.
+ * nome volta a ser um conceito e a regra vale.
  */
 const IDIOMATIC_LOCAL_NAMES = new Set([
   'props', 'state', 'row', 'item', 'column', 'context', 'params', 'options',