@polymorphism-tech/morph-spec 8.43.0 → 8.44.0

package/src/lib/risk-detector.js

@@ -15,8 +15,8 @@
  *   - e2eStatus + e2eReason + gate    — nó e2e do último verify. Um `skip`
  *     cuja razão NÃO seja dispensa legítima pausa SÓ no ship (gate 'review').
  *     Sem escopo (stamp sem o campo) cai do mesmo lado seguro que `unknown`
- *   - verificationStale + gate: bool/str — stamp com sha != HEAD pausa SÓ no
- *     ship (gate 'review') — código mudou depois do último verify
+ *   - verificationStale + gate: bool/str — stamp de um commit cujo código já mudou
+ *     (fora de .morph/) pausa SÓ no ship (gate 'review')
  *   - evalScoreSource + gate: str     — no ship, score que NÃO veio do avaliador
  *     independente pausa (auto-avaliação não decide o Gate 3)
  *   - mutationProof + gate: object    — { section, min, productionCode } lido do
@@ -274,7 +274,7 @@ export function shouldPauseGate(config, signals) {
   if (signals.gate === 'review' && signals.verificationStale === true) {
     return {
       pause: true,
-      reason: 'verification stamp desatualizado (sha difere do HEAD) — rode `morph-spec verify` de novo antes do ship',
+      reason: 'verification stamp desatualizado (o código mudou depois do commit do stamp) — rode `morph-spec verify` de novo antes do ship',
     };
   }
 

package/src/lib/tasks/eval-node.js

@@ -36,7 +36,7 @@ import { join, resolve, sep } from 'path';
 import { tmpdir } from 'os';
 
 import { isInside } from './test-runner.js';
-import { readAiPin } from '../standards/verified-against.js';
+import { resolveAiPin } from '../ai/pin-drift.js';
 
 /** The runner kind. One spelling, imported by every reader. */
 export const EVAL_RUNNER = 'evals';
@@ -72,34 +72,6 @@ export function cacheRelevantPackages(packages) {
   return out;
 }
 
-/**
- * Read the pin from a project, wherever the framework lives.
- *
- * Two roots, ONE reader: this repository carries `framework/ai-pin.json` at the
- * top; an installed project carries it under `.morph/framework/`. `readAiPin`
- * appends `framework/ai-pin.json` to whatever root it is given, so both cases
- * are the same function with a different argument — never a second parser.
- *
- * Returns null when neither exists: a project with no pin simply has no stamp
- * ruler, and refusing to run there would make the eval node unusable outside
- * this framework's own stack.
- *
- * @param {string} projectPath
- * @returns {{pinnedAt: string, packages: object}|null}
- */
-export function readProjectPin(projectPath) {
-  for (const root of [projectPath, join(projectPath, '.morph')]) {
-    try {
-      return readAiPin(root);
-    } catch {
-      // Next candidate. The throw is readAiPin's contract for "no pin here",
-      // and it is the reason this loop exists instead of an existsSync probe
-      // that would duplicate the path knowledge.
-    }
-  }
-  return null;
-}
-
 /**
  * Resolve every path an eval node names, against the project root.
  *
@@ -256,11 +228,9 @@ export function evalPreflight(projectPath, node, options = {}) {
     return { status: 'fail', reason: `eval-cache-empty: ${cacheRoot} não contém nenhuma entrada de cache` };
   }
 
-  const pin = readProjectPin(projectPath);
+  const pin = resolveAiPin(projectPath);
   if (!pin) {
-    // No pin, no ruler — and a project without one is a legitimate case, not a
-    // failure: the stamp check simply does not apply. Saying so is the point;
-    // silently treating it as "stamp ok" would be the same thing said badly.
+    // No pin in the project or in the CLI package: nothing to stamp against.
     return { status: null, reason: null };
   }
 
@@ -315,7 +285,7 @@ export function evalNodeEnv(node, projectPath, options = {}) {
     MORPH_EVAL_ENVFILE: envFile,
   };
 
-  const pin = readProjectPin(projectPath);
+  const pin = resolveAiPin(projectPath);
   if (pin) {
     // Compact, and only the packages that decide the cache format. The fixture
     // stamps from THIS, so it never has to read (or parse) the pin itself.

package/src/lib/validators/contracts/contract-compliance-validator.js

@@ -1,56 +1,21 @@
-/**
- * Contract Compliance Validator
- *
- * Parses contracts.cs from feature outputs and verifies that the project code
- * actually implements all defined interfaces, methods, DTOs, and enums.
- *
- * MORPH-SPEC 3.0 - Phase A: Active Validation Pipeline
- */
-
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { glob } from 'glob';
 import chalk from 'chalk';
 import { getAbsoluteOutputPath, resolveContractsOutputType } from '../../../core/paths/output-schema.js';
 
-/**
- * Validate that contracts.cs interfaces are implemented in project code
- *
- * @param {string} projectPath - Project root path
- * @param {string} featureName - Feature name
- * @param {Object} options - Options
- * @returns {Object} { status, errors, warnings, issues, coverage }
- */
 export async function validateContracts(projectPath, featureName, options = {}) {
-  // `'contracts'` is not an output type — `getAbsoluteOutputPath` threw
-  // "Unknown output type" on every call. The runner already resolves this the
-  // right way before deciding to schedule this validator
-  // (`resolveContractsOutputType()`); using the same resolver here is what
-  // keeps the two from disagreeing again.
   const contractsPath = getAbsoluteOutputPath(projectPath, featureName, resolveContractsOutputType());
 
-  if (!existsSync(contractsPath)) {
-    return {
-      status: 'ok',
-      errors: 0,
-      warnings: 0,
-      issues: [],
-      coverage: null,
-      message: 'No contracts.cs found — skipping'
-    };
-  }
+  const skipped = (message) => ({ status: 'ok', errors: 0, warnings: 0, issues: [], coverage: null, message });
+
+  if (!existsSync(contractsPath)) return skipped('No spec.md found — skipping');
 
   const contractsContent = readFileSync(contractsPath, 'utf-8');
   const contracts = parseContracts(contractsContent);
 
   if (contracts.interfaces.length === 0 && contracts.records.length === 0 && contracts.enums.length === 0) {
-    return {
-      status: 'ok',
-      errors: 0,
-      warnings: 1,
-      issues: [{ level: 'warning', message: 'contracts.cs exists but no interfaces/records/enums found' }],
-      coverage: null
-    };
+    return skipped('spec.md declares no interfaces/records/enums — skipping');
   }
 
   // Find all .cs files in the project (excluding .morph outputs, bin, obj)
@@ -168,9 +133,6 @@ export async function validateContracts(projectPath, featureName, options = {})
   };
 }
 
-/**
- * Parse contracts.cs content and extract interfaces, records, and enums
- */
 function parseContracts(content) {
   const interfaces = [];
   const records = [];

package/src/lib/worktree/env-allocator.js

@@ -168,10 +168,10 @@ export const PORT_OFFSETS = Object.freeze({ web: 0, api: 1, postgres: 2, redis:
  * not in the root's. Every value is a string (env-safe); key order is stable.
  *
  * @param {{ base: number, range: [number, number] }} block
- * @param {{ stack?: string, feature?: string }} [opts]
+ * @param {{ stack?: string, feature?: string, aliases?: Record<string, string> }} [opts] - aliases: resolvePortAliases()
  * @returns {Record<string,string>}
  */
-export function portLayout(block, { stack = '', feature = '' } = {}) {
+export function portLayout(block, { stack = '', feature = '', aliases = {} } = {}) {
   const env = {};
   if (feature) env.COMPOSE_PROJECT_NAME = composeProjectName(feature);
   env.MORPH_PORT_BASE = String(block.base);
@@ -183,9 +183,39 @@ export function portLayout(block, { stack = '', feature = '' } = {}) {
   if (/\bdotnet\b/i.test(String(stack))) {
     env.ASPNETCORE_URLS = `http://localhost:${block.base + PORT_OFFSETS.api}`;
   }
+  for (const [alias, port] of Object.entries(aliases)) env[alias] = String(block.base + PORT_OFFSETS[port]);
   return env;
 }
 
+const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const RESERVED_ENV_NAMES = new Set([
+  ...Object.keys(portLayout({ base: 0, range: [0, 0] }, { stack: 'dotnet', feature: 'x' })),
+  'PLAYWRIGHT_BASE_URL',
+  'MORPH_FEATURE',
+]);
+
+// e2e.portEnvNames: extra env names for the same four ports, so a compose file reading
+// ${PG_PORT} is fed by the block, not by its own default. An entry that cannot be
+// honoured is dropped and named in `problems`.
+export function resolvePortAliases(config) {
+  const declared = config?.e2e?.portEnvNames;
+  const aliases = {};
+  const problems = [];
+  if (declared === undefined || declared === null) return { aliases, problems };
+  if (typeof declared !== 'object' || Array.isArray(declared)) {
+    return { aliases, problems: [`e2e.portEnvNames deve ser um objeto { ${Object.keys(PORT_OFFSETS).join('|')}: "NOME" }`] };
+  }
+  for (const [port, name] of Object.entries(declared)) {
+    const at = `e2e.portEnvNames.${port}`;
+    if (!Object.hasOwn(PORT_OFFSETS, port)) problems.push(`${at}: porta desconhecida (use ${Object.keys(PORT_OFFSETS).join('|')})`);
+    else if (typeof name !== 'string' || !ENV_NAME.test(name)) problems.push(`${at}: ${JSON.stringify(name)} não é um nome de variável de ambiente válido`);
+    else if (RESERVED_ENV_NAMES.has(name)) problems.push(`${at}: "${name}" já é uma variável do layout`);
+    else if (Object.hasOwn(aliases, name)) problems.push(`${at}: "${name}" já é o alias de ${aliases[name]}`);
+    else aliases[name] = port;
+  }
+  return { aliases, problems };
+}
+
 /**
  * Render the `.morph/worktree.env` contents for a block: a header, the
  * feature, and exactly the `portLayout()` pairs — nothing else, so the file
@@ -199,15 +229,15 @@ export function portLayout(block, { stack = '', feature = '' } = {}) {
  * @param {string} feature - the env-registry key: `<feature>` or `task/<name>`
  * @param {{ base: number, range: [number, number] }} block
  * @param {string} [stack] - config.json `project.stack` (e.g. "nextjs+dotnet")
- * @param {{ morphFeature?: string|null }} [opts]
+ * @param {{ morphFeature?: string|null, aliases?: Record<string, string> }} [opts]
  * @returns {string}
  */
-export function buildEnvFileContent(feature, block, stack = '', { morphFeature = null } = {}) {
+export function buildEnvFileContent(feature, block, stack = '', { morphFeature = null, aliases = {} } = {}) {
   const lines = [
     `# Managed by morph-spec — ambiente dedicado desta worktree (feature: ${feature}).`,
     '# Derivado, git-invisível, regenerado por `worktree setup|link`; nunca editar nem commitar.',
     `MORPH_FEATURE=${morphFeature || feature}`,
-    ...Object.entries(portLayout(block, { stack, feature })).map(([k, v]) => `${k}=${v}`),
+    ...Object.entries(portLayout(block, { stack, feature, aliases })).map(([k, v]) => `${k}=${v}`),
   ];
   return `${lines.join('\n')}\n`;
 }