@polymorphism-tech/morph-spec 8.46.0 → 9.0.0

package/src/commands/validation/verify.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import { resolve } from 'path';
 import { getFeature, updateFeature } from '../../core/state/state-manager.js';
-import { runVerify, readTask, VerifyUsageError } from '../../lib/validators/verify-runner.js';
+import { runVerify, VerifyUsageError } from '../../lib/validators/verify-runner.js';
 import { resolvePrimaryRoot } from '../project/worktree.js';
 import { resolveFeatureTree } from '../../lib/worktree/feature-truth.js';
 import { canonicalPath, readMorphConfig } from '../../lib/tasks/test-runner.js';
@@ -12,7 +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';
+import { runCiVerify, CiUsageError, reusableLocalStamp } from '../../lib/ci/ci-verify.js';
 
 /** ✓ pass · ✗ fail · – skip */
 function statusIcon(status) {
@@ -21,40 +21,12 @@ function statusIcon(status) {
   return chalk.gray('–');
 }
 
-/**
- * One line per test run naming what the task-scope recorte did to it (#87):
- * narrowed (how many selectors, from how many test files), whole, out of scope
- * or full, each with its reason. A green `tests` line alone cannot say that the
- * task ran 12 tests instead of 3.082. Feature-scope runs carry no selection and
- * print nothing extra; `feedback[]` is untouched either way.
- *
- * @param {Array<{id: string, selection: object|null}>} [runs]
- * @returns {string[]}
- */
-function selectionLines(runs = []) {
-  return runs
-    .filter((run) => run.selection)
-    .map((run) => {
-      const { mode, reason, selectors = [], files = [] } = run.selection;
-      const detail = mode === 'narrowed'
-        ? `${selectors.length} selector(s) from ${files.length} test file(s)`
-        : (reason ?? '');
-      return chalk.gray(`      ↳ ${run.id.padEnd(10)} ${mode.padEnd(12)} ${detail}`);
-    });
-}
-
-/**
- * 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}` : ''}`));
+  lines.push(chalk.bold(`Verify — ${result.feature}`));
+  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('');
@@ -69,8 +41,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.
@@ -79,7 +49,6 @@ function formatVerifyResult(result) {
       detail = `${node.durationMs}ms`;
     }
     lines.push(`  ${icon} ${name.padEnd(11)} ${node.status.padEnd(5)} ${chalk.gray(detail)}`);
-    if (name === 'tests') lines.push(...selectionLines(node.runs));
   }
 
   if (result.feedback.length > 0) {
@@ -139,7 +108,7 @@ function baselineStampBlock(baseline) {
 
 /**
  * The per-node status map, in the shape `feature.schema.json` fixes for BOTH
- * writers of it — the per-scope history entry (`verifications.*`) and the
+ * writers of it — the history entry (`verifications.feature`) and the
  * singular gate stamp (`verification.nodes`). One function because they were
  * two literal copies twenty-five lines apart: a fifth node meant remembering
  * both, and a stamp missing a node the history has is precisely the kind of
@@ -163,7 +132,7 @@ function nodeStatuses(result) {
  *
  * The rollup cannot answer the question Gate 3 asks. A red eval and a red unit
  * test both arrive as `tests: 'fail'`, and — worse — an eval node that was
- * SKIPPED (task scope) leaves the rollup green, so a gate reading `tests` alone
+ * SKIPPED (`--filter`) leaves the rollup green, so a gate reading `tests` alone
  * cannot tell "the eval ran and passed" from "the eval never ran".
  *
  * Four values, and the distinction between the last two is the whole point:
@@ -186,7 +155,7 @@ function evalsStatusOf(result) {
 }
 
 /**
- * The options that make a FEATURE-scope run partial, each with the `reason` it
+ * The options that make a run partial, each with the `reason` it
  * reports when it keeps the stamp from being written — first match wins.
  */
 const PARTIAL_RUN_FLAGS = [['filter', 'filtered'], ['skipTests', 'skip-tests'], ['skipBuild', 'skip-build']];
@@ -197,10 +166,9 @@ const CI_EXCLUSIVE_FLAGS = [
   ['noPersist', '--no-persist'],
 ];
 
-async function runLocalVerify(featureName, taskId, options) {
+async function runLocalVerify(featureName, options) {
   try {
-    return await runVerify(process.cwd(), featureName, taskId || null, {
-      rubric: options.rubric,
+    return await runVerify(process.cwd(), featureName, {
       timeout: options.timeout,
       skipTests: options.skipTests,
       skipBuild: options.skipBuild,
@@ -211,12 +179,9 @@ async function runLocalVerify(featureName, taskId, options) {
       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
+    // A wrong invocation is exit 2, like an unknown feature — 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) {
@@ -240,7 +205,7 @@ async function runLocalVerify(featureName, taskId, options) {
 }
 
 /**
- * `morph-spec verify <feature> [task]` — the deterministic code-before-judge
+ * `morph-spec verify <feature>` — the deterministic code-before-judge
  * gate: build + tests + validators, BEFORE the LLM eval. See verify-runner.js
  * for the node cadence; this command wraps it with CLI ergonomics
  * (human/JSON output, exit codes) and context-aware persistence.
@@ -251,16 +216,14 @@ async function runLocalVerify(featureName, taskId, options) {
  * 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;
  *   - `--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
- *     task id (a recorte de task is never a fleet baseline, #87);
+ *   - `--record-baseline` with nowhere to write (no `config.json`);
  *   - `--linux` without Docker.
  * The last three arrive as `VerifyUsageError` from the runner.
  */
-export async function verifyCommand(featureName, taskId, options = {}) {
+export async function verifyCommand(featureName, options = {}) {
   let feature;
   try {
     feature = getFeature(featureName);
@@ -273,22 +236,13 @@ export async function verifyCommand(featureName, taskId, options = {}) {
   }
 
   if (options.ci) {
-    const conflict = taskId ? `a task ${taskId} (o loop por task é local)` : CI_EXCLUSIVE_FLAGS.find(([flag]) => options[flag])?.[1];
+    const conflict = 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) {
-    if (!readTask(process.cwd(), featureName, taskId)) {
-      console.error(chalk.red(`\n❌ Task "${taskId}" not found in tasks.json for feature "${featureName}"\n`));
-      process.exit(2);
-    }
-  }
-
   let ci = null;
   if (options.ci) {
     try {
@@ -302,6 +256,17 @@ export async function verifyCommand(featureName, taskId, options = {}) {
         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 {
+        const reused = reusableLocalStamp(process.cwd(), feature.verification);
+        if (reused) {
+          console.error(chalk.green(`\n↪ CI indisponível (${outcome.reason}) — stamp fresco reaproveitado (sha ${reused.sha.slice(0, 8)}, ${reused.ts}): nada mudou fora de .morph/ desde aquela rodada verde.\n`));
+          if (options.json) {
+            console.log(JSON.stringify({
+              feature: featureName, status: reused.status, nodes: reused.nodes, e2eReason: reused.e2eReason ?? null,
+              reused: { sha: reused.sha, ts: reused.ts, source: reused.source ?? 'local' }, persisted: false, reason: 'stamp-reused',
+            }, null, 2));
+          }
+          process.exit(0);
+        }
         console.error(chalk.yellow(`\n↪ CI indisponível (${outcome.reason}) — verify local.\n`));
       }
     } catch (err) {
@@ -316,45 +281,40 @@ 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());
 
-  const result = ci ? ci.result : await runLocalVerify(featureName, taskId, options);
+  const result = ci ? ci.result : await runLocalVerify(featureName, options);
 
   const cleanup = ci ? { status: 'skipped', reason: 'ci' } : afterHeavyRun({
     projectPath: process.cwd(),
     config: readHeavyConfig(process.cwd()),
-    scope: taskId ? 'task' : 'feature',
   });
 
-  const scopeKey = taskId ? `taskVerifications.${taskId}` : 'verifications.feature';
+  const historyKey = 'verifications.feature';
   // A run that measured only part of the suite must not stand in for the proof a gate asks for:
-  // --filter and --skip-* at feature scope, or a --record-baseline that recorded nothing. Task scope
-  // is unaffected (its stamp already says scope 'task:{id}'); --no-persist keeps its own reason.
-  const partialFeatureRun = (!options.noPersist && !taskId)
-    ? PARTIAL_RUN_FLAGS.find(([flag]) => options[flag])?.[1] ?? null
-    : null;
+  // --filter and --skip-*, or a --record-baseline that recorded nothing; --no-persist keeps its own reason.
+  const partialRun = options.noPersist ? null : PARTIAL_RUN_FLAGS.find(([flag]) => options[flag])?.[1] ?? null;
   const baselineBlock = options.recordBaseline ? baselineStampBlock(result.baseline) : null;
   const { persist, reason } = baselineBlock
     ? { persist: false, reason: baselineBlock }
-    : partialFeatureRun
-      ? { persist: false, reason: partialFeatureRun }
+    : partialRun
+      ? { persist: false, reason: partialRun }
       : decidePersistence({ cwd: process.cwd(), featureName, noPersist: options.noPersist });
 
   let compact = null;
   if (persist) {
-    const prevEntry = taskId ? feature.taskVerifications?.[taskId] : feature.verifications?.feature;
+    const prevEntry = feature.verifications?.feature;
     const now = new Date().toISOString();
     compact = {
       status: result.status,
       nodes: nodeStatuses(result),
-      score: result.nodes.validators.score ?? null,
       attempts: (prevEntry?.attempts ?? 0) + 1,
       updatedAt: now,
     };
-    await updateFeature(featureName, scopeKey, compact);
+    await updateFeature(featureName, historyKey, compact);
 
-    // Singular, scope-agnostic "latest stamp" — distinct from the
-    // verifications/taskVerifications history above. `sha` is what lets a
+    // Singular "latest stamp" — distinct from the `verifications.feature`
+    // history above. `sha` is what lets a
     // consumer (morph-spec gate-check) correlate this pass/fail with the
-    // EXACT commit it covers, the same way review-report.md's
+    // EXACT commit it covers, the same way a review report's
     // `**Reviewed-SHA:**` token lets approve.js detect a stale review. null
     // in a non-git checkout (or before the first commit) — fail-open, never
     // blocks persistence.
@@ -373,18 +333,17 @@ export async function verifyCommand(featureName, taskId, options = {}) {
       e2eReason: result.nodes.e2e.status === 'skip' ? (result.nodes.e2e.reason ?? null) : null,
       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);
   }
 
-  // A feature-scope run over the exact tree of the previous one proves nothing
+  // A run over the exact tree of the previous one proves nothing
   // new. Advisory only: the stamp and the exit code are the same either way.
   let repeatOf = null;
   try {
     const cwd = process.cwd();
-    if (!taskId && persist && !ci) repeatOf = findRepeatedVerify(cwd, { feature: featureName, task: null, scope: result.scope, fingerprint });
+    if (persist && !ci) repeatOf = findRepeatedVerify(cwd, { feature: featureName, fingerprint });
     const tree = resolve(cwd).replace(/\\/g, '/') === resolvePrimaryRoot(cwd) ? 'root' : 'worktree';
     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 */ }
@@ -415,7 +374,7 @@ export async function verifyCommand(featureName, taskId, options = {}) {
       console.log(chalk.gray(`${mark} dotnet build-server shutdown: ${cleanup.status}${cleanup.reason ? ` (${cleanup.reason})` : ''}\n`));
     }
     if (repeatOf) {
-      console.log(chalk.yellow(`⚠️  Mesma árvore do verify de feature de ${repeatOf.ts} (${repeatOf.status}): nada mudou fora de .morph/ desde então. `
+      console.log(chalk.yellow(`⚠️  Mesma árvore do verify de ${repeatOf.ts} (${repeatOf.status}): nada mudou fora de .morph/ desde então. `
         + 'Esta rodada não prova nada novo — reuse o resultado anterior, a menos que o ambiente (Docker, banco, serviço externo) tenha mudado.\n'));
     }
     if (result.baseline?.recorded) {
@@ -426,7 +385,7 @@ export async function verifyCommand(featureName, taskId, options = {}) {
 `));
     }
     if (persist) {
-      console.log(chalk.gray(`Persisted: ${scopeKey} (attempts: ${compact.attempts})\n`));
+      console.log(chalk.gray(`Persisted: ${historyKey} (attempts: ${compact.attempts})\n`));
     } else {
       console.log(chalk.yellow(`⚠️  Not persisted (${reason})\n`));
     }

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

@@ -15,28 +15,24 @@ import { join } from 'path';
  * Schema for output types produced by morph-spec NLH phases.
  *
  * Fields:
- *   filename     - The file's basename (e.g. 'spec.md'). Single-file types only.
+ *   filename     - The file's basename (e.g. 'plan.md'). Single-file types only.
  *   phaseDir     - Subdirectory within .morph/features/{feature}/
  *   phase        - The morph-spec phase that produces this output
  *   protected    - Whether the file requires an approval gate before editing
  *   approvalGate - (optional) Which gate protects this file
- *   mutableFields- (optional) For protected JSON files: top-level array-item
- *                  field names that MAY still change after the gate is approved.
- *                  Lets the implement phase update task progress without
- *                  unfreezing the plan contract. When present, the protect
- *                  hook does a semantic diff instead of a blanket block.
  *
  * Multi-file types (`multi: true`) hold N files in a directory instead of one
  * fixed basename. They carry `dirname` + `filenamePattern` + `displayFilename`
  * INSTEAD of `filename`, and every derivation keyed by basename
- * (FILENAME_TO_OUTPUT, PROTECTED_SPEC_FILES, MUTABLE_SPEC_FIELDS) skips them —
+ * (FILENAME_TO_OUTPUT, PROTECTED_SPEC_FILES) skips them —
  * there is no single basename to key on. `getOutputPath` returns the DIRECTORY
  * for these types.
  */
 export const OUTPUT_SCHEMA = {
-  // 0-proposal/
-  proposal:       { filename: 'proposal.md',           phaseDir: '0-proposal',  phase: 'proposal',  protected: false },
-  stackScan:      { filename: 'stack-scan.md',         phaseDir: '0-proposal',  phase: 'proposal',  protected: false },
+  // 2-plan/ — the plan gate freezes both: plan.md accepts only an append in
+  // `## Errata`, checks.json only a rewrite by `morph-spec plan-check`.
+  plan:           { filename: 'plan.md',               phaseDir: '2-plan',      phase: 'plan',      protected: true,  approvalGate: 'plan' },
+  checks:         { filename: 'checks.json',           phaseDir: '2-plan',      phase: 'plan',      protected: true,  approvalGate: 'plan' },
 
   // 1-design/ (optional)
   uiDesignSystem: { filename: 'design-system.md',      phaseDir: '1-design',    phase: 'uiux',      protected: true,  approvalGate: 'uiux' },
@@ -44,47 +40,20 @@ export const OUTPUT_SCHEMA = {
   uiComponents:   { filename: 'components.md',         phaseDir: '1-design',    phase: 'uiux',      protected: true,  approvalGate: 'uiux' },
   uiFlows:        { filename: 'flows.md',              phaseDir: '1-design',    phase: 'uiux',      protected: true,  approvalGate: 'uiux' },
 
-  // 2-plan/
-  spec:           { filename: 'spec.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
-  // justificativa de cada CRIAR. É o ARTEFATO do ciclo de reuso (a prosa está
-  // em morph-plan §2b, a cobrança em src/lib/validators/reuse/). NÃO protegido,
-  // 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.
-  // 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;
-  // the audit trail lives in git.
-  usecases:       {
-    dirname: 'usecases',
-    filenamePattern: '^UC-\\d+-[a-z0-9-]+\\.md$',
-    displayFilename: 'UC-{nn}-{slug}.md',
-    phaseDir: '2-plan',
-    phase: 'plan',
-    protected: false,
-    multi: true,
-  },
-
-  // 3-implement/
-  recap:          { filename: 'recap.md',              phaseDir: '3-implement', phase: 'implement', protected: false },
-  // N files, one per task whose doneCriteria judges what a MODEL answers
-  // (morph-plan §5). Runtime evidence: input, model, output, verdict — pointing
+  // 3-implement/ — the slice reports (`reports/F{n}.md`, see getTaskReportPath) are the record.
+  // N files, one per scenario whose proof judges what a MODEL answers
+  // (`prova: eval` in the plan). 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.
-  evidencias:     { dirname: 'evidencias', filenamePattern: '^T\\d+\\.md$', displayFilename: '{taskId}.md',
+  // dispatch prompt.
+  evidencias:     { dirname: 'evidencias', filenamePattern: '^C\\d+\\.md$', displayFilename: '{Cn}.md',
                     phaseDir: '3-implement', phase: 'implement', protected: false, multi: true },
 
   // 4-review/
-  reviewReport:   { filename: 'review-report.md',      phaseDir: '4-review',    phase: 'review',    protected: false },
-  // Durable report the dispatched morph-evaluator sub-agent writes itself
-  // (MORPH.md §6) — the orchestrator reads it and synthesizes reviewReport
-  // from it; the two never collide because one is raw sub-agent output and
-  // the other is the orchestrator's curated Gate 3 presentation.
-  evaluatorReport:{ filename: 'evaluator-report.md',   phaseDir: '4-review',    phase: 'review',    protected: false },
+  // Um relatório por papel; o canônico da fase é o do verificador.
+  verifierReport: { filename: 'verifier.md',           phaseDir: '4-review',    phase: 'review',    protected: false },
+  reviewerReport: { filename: 'reviewer.md',           phaseDir: '4-review',    phase: 'review',    protected: false },
+  securityReport: { filename: 'security.md',           phaseDir: '4-review',    phase: 'review',    protected: false },
 };
 
 // ============================================================================
@@ -104,11 +73,11 @@ function leafSegment(entry) {
  * Get the morph-relative path for a specific output type of a feature.
  *
  * For `multi` types this is the DIRECTORY holding the N files
- * (".morph/features/my-feature/2-plan/usecases"), not a single file.
+ * (".morph/features/my-feature/3-implement/evidencias"), not a single file.
  *
  * @param {string} featureName
  * @param {string} outputType  - camelCase output type key from OUTPUT_SCHEMA
- * @returns {string} e.g. ".morph/features/my-feature/2-plan/spec.md"
+ * @returns {string} e.g. ".morph/features/my-feature/2-plan/plan.md"
  */
 export function getOutputPath(featureName, outputType) {
   const entry = OUTPUT_SCHEMA[outputType];
@@ -205,27 +174,11 @@ export const PROTECTED_SPEC_FILES = Object.fromEntries(
     .map(([, entry]) => [entry.filename, entry.approvalGate])
 );
 
-/**
- * For protected files that carry mutable progress fields: filename → the
- * top-level array-item fields that may change after the gate is approved.
- * The protect-spec-files hook uses this to allow progress updates (e.g.
- * task status) while still freezing the plan contract.
- */
-export const MUTABLE_SPEC_FIELDS = Object.fromEntries(
-  Object.entries(OUTPUT_SCHEMA)
-    .filter(([, entry]) => entry.protected && entry.approvalGate && entry.mutableFields && !entry.multi)
-    .map(([, entry]) => [entry.filename, entry.mutableFields])
-);
-
 // ============================================================================
-// Backwards-compat shim (will be removed in v5.1)
+// Contracts
 // ============================================================================
 
-/**
- * v4 had separate contracts.cs / contracts.ts / contracts-vsa.cs output types.
- * In v5 contracts live inside spec.md (or in source files for VSA). This
- * function keeps callers happy until they're updated.
- */
+/** The output type whose code blocks declare the contracts the code must honour. */
 export function resolveContractsOutputType() {
-  return 'spec';
+  return 'plan';
 }

package/src/core/state/gate-order.js

@@ -2,12 +2,12 @@
  * Gate monotonicity — single source of truth.
  *
  * A gate may only be approved once its predecessors are approved. The strict
- * chain is proposal → plan → review. uiux is optional: it requires proposal but
- * gates nothing downstream, so a feature that skips UI/UX is never blocked.
+ * chain is plan → review. uiux is optional: it requires plan but gates nothing
+ * downstream, so a feature that skips UI/UX is never blocked.
  *
  * Policy-stamped gates (approvedBy: "policy:{type}", written at birth by
  * `morph-spec create` for a work type's skippedGates) count as approved, so
- * chore/hotfix (proposal+plan pre-stamped) satisfy prereqs naturally.
+ * chore/hotfix (plan pre-stamped) satisfy prereqs naturally.
  *
  * Pure module — no filesystem/CLI side effects. Consumed by
  * `approve`/`advance` (refuse), the state-sync hook (warn), and `list`/`doctor`
@@ -15,9 +15,8 @@
  */
 
 export const GATE_PREREQ = {
-  proposal: [],
-  uiux: ['proposal'],
-  plan: ['proposal'],
+  plan: [],
+  uiux: ['plan'],
   review: ['plan'],
 };
 

package/src/core/state/lifecycle-audit.js

@@ -103,7 +103,7 @@ function lastTouched(fdir, fj) {
  * Does the feature dir hold any FILE other than its own `feature.json`?
  *
  * Files, not entries: `create` scaffolds the phase folders empty, so an empty
- * `0-proposal/` is the absence of work, not evidence of it.
+ * `2-plan/` is the absence of work, not evidence of it.
  */
 function hasArtifacts(fdir) {
   let entries;
@@ -159,7 +159,7 @@ function ownCommitCount(baseDir, branch) {
  * mean nobody ever came back to it.
  *
  * The artifact test is deliberately broader than the "0 tasks" the report
- * named: a proposal drafted and waiting on Gate 1 also has zero tasks and is
+ * named: a plan drafted and waiting on its gate also has zero tasks and is
  * very much alive. What a dead scaffold has is NOTHING — checked in the root
  * and, if the feature registered one, in its worktree, where uncommitted work
  * would otherwise be invisible to both the disk scan and `rev-list`.