@polymorphism-tech/morph-spec 7.9.4 → 8.0.0

package/src/commands/state/advance.js

@@ -55,9 +55,24 @@ export async function advanceCommand(featureName, options = {}) {
 
     // 1) Approve the gate that completes the current phase.
     const gate = PHASE_GATE[phase];
+    const approvedBy = resolveApprovedBy(options);
+
+    // Hotfix backstop (defensive, mirrors approve.js): the phase==='review'
+    // early-return above already stops advance from ever reaching a
+    // gate==='review' approval, but guard the approval itself too so this
+    // stays true even if the early-return's shape changes later. Gate on the
+    // RESOLVED approvedBy — headless contexts have no TTY and resolve to
+    // "auto" regardless of --mode, so checking the raw --mode string alone
+    // would let them slip through (same bug the approve.js backstop had).
+    if (gate === 'review' && feature.workType === 'hotfix' && approvedBy === 'auto') {
+      console.error(chalk.red('\n❌ Hotfix exige aprovação humana no Gate 3 — trust:auto não se aplica.'));
+      console.error(chalk.gray('   Aprove com --approver <nome>, num terminal interativo, ou pela resposta humana "aprovado" (state-sync) ao review-report via AskUserQuestion.\n'));
+      process.exit(1);
+    }
+
     if (gate) {
       await setApprovalGate(featureName, gate, true, {
-        approvedBy: resolveApprovedBy(options),
+        approvedBy,
         approvedAt: new Date().toISOString(),
         notes: options.notes,
       });
@@ -72,7 +87,7 @@ export async function advanceCommand(featureName, options = {}) {
     }
 
     console.log(chalk.green(`\n✅ Advanced "${featureName}" past the ${phase} phase.`));
-    if (gate) console.log(chalk.gray(`   Gate "${gate}" approved (${resolveApprovedBy(options)}).`));
+    if (gate) console.log(chalk.gray(`   Gate "${gate}" approved (${approvedBy}).`));
     if (nextDir) console.log(chalk.gray(`   Scaffolded ${nextDir}/ — ready for the next phase's first artifact.\n`));
     else console.log('');
   } catch (error) {

package/src/commands/state/approve.js

@@ -99,7 +99,8 @@ export async function approveCommand(featureName, gateName, options = {}) {
       return;
     }
 
-    // Set approval.
+    // Resolve who approved BEFORE the hotfix backstop — the backstop gates on
+    // the resolved signature, not the raw --mode string (see below).
     //
     // approvedBy resolution (most explicit wins):
     //   1. --approver flag (CLI caller signalled who approved)
@@ -125,6 +126,22 @@ export async function approveCommand(featureName, gateName, options = {}) {
       approvedBy = 'auto';
     }
 
+    // Hotfix backstop: Gate 3 (review) requires a genuine HUMAN signature even
+    // in trust:auto — a work-type policy (forcedPauseGates in
+    // src/core/work-types.js, mirrored by risk-detector's
+    // FORCED_PAUSE_WORK_TYPES), enforced server-side rather than trusting the
+    // calling skill. It gates on the RESOLVED approvedBy, NOT the raw --mode
+    // string: every headless context (claude -p, CI, the Bash tool) runs
+    // without a TTY, so an omitted --mode — or any --mode ≠ 'auto' — still
+    // resolves to "auto" and would otherwise rubber-stamp the gate. A human
+    // approval is --approver <name> or an interactive TTY ($USER); anything
+    // resolving to "auto" is refused here.
+    if (gateName === 'review' && feature.workType === 'hotfix' && approvedBy === 'auto') {
+      console.error(chalk.red('\n❌ Hotfix exige aprovação humana no Gate 3 — trust:auto não se aplica.'));
+      console.error(chalk.gray('   Aprove com --approver <nome>, num terminal interativo, ou pela resposta humana "aprovado" (state-sync) ao review-report via AskUserQuestion.\n'));
+      process.exit(1);
+    }
+
     await setApprovalGate(featureName, gateName, true, {
       approvedBy,
       approvedAt: new Date().toISOString(),

package/src/commands/state/create.js

@@ -1,22 +1,85 @@
 import chalk from 'chalk';
-import { mkdirSync } from 'fs';
+import { mkdirSync, cpSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import { createFeature } from '../../core/state/state-manager.js';
+import { createFeature, setApprovalGate, getFeature } from '../../core/state/state-manager.js';
+import { WORK_TYPES, DEFAULT_WORK_TYPE, POLICY_APPROVER_PREFIX, isValidWorkType, getWorkType } from '../../core/work-types.js';
+import { detectWorkType } from '../../lib/work-type-detector.js';
+import { runWorktreeSetup, materializeState } from '../project/worktree.js';
 
 /** Feature names are kebab-case: lowercase alphanumerics and hyphens. */
 const FEATURE_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
 
 const VALID_STATUSES = ['draft', 'in_progress', 'completed'];
+const VALID_DETECT_SOURCES = ['deterministic', 'llm', 'user'];
 
 /**
- * `morph-spec create <feature>` — explicit feature birth: creates
- * `.morph/features/{feature}/0-proposal/` and the canonical feature.json
- * (shape documented in framework/schemas/feature.schema.json).
+ * Resolve the work type for a NEW feature from `--type`/`--request`, or fall
+ * back to the default. Never touches the filesystem/state — pure control
+ * flow so it can `process.exit` before any side effect happens.
+ *
+ * @param {{ type?: string, request?: string, detectSource?: string }} options
+ * @param {string} now - ISO timestamp, stamped into workTypeDetection.decidedAt
+ * @returns {{ workType: string, workTypeDetection?: object }}
+ */
+function resolveWorkType(options, now) {
+  if (options.type !== undefined) {
+    if (!isValidWorkType(options.type)) {
+      console.error(chalk.red(`\n❌ Invalid --type: "${options.type}"`));
+      console.error(chalk.gray(`Valid types: ${Object.keys(WORK_TYPES).join(', ')}\n`));
+      process.exit(1);
+    }
+    if (options.detectSource !== undefined && !VALID_DETECT_SOURCES.includes(options.detectSource)) {
+      console.error(chalk.red(`\n❌ Invalid --detect-source: "${options.detectSource}"`));
+      console.error(chalk.gray(`Valid sources: ${VALID_DETECT_SOURCES.join(', ')}\n`));
+      process.exit(1);
+    }
+    return {
+      workType: options.type,
+      workTypeDetection: {
+        source: options.detectSource || 'user',
+        confidence: 'high',
+        decidedAt: now,
+      },
+    };
+  }
+
+  if (options.request !== undefined) {
+    const d = detectWorkType({ text: options.request });
+    if (d.confidence !== 'high') {
+      // Router contract: determinism first, ambiguity escalates to the
+      // LLM/HCOP caller (which re-runs `create --type <chosen>`). The
+      // feature must NOT be created on this path — always JSON, regardless
+      // of --json, since this is the machine-consumable half of the contract.
+      console.log(JSON.stringify({ needsDecision: true, candidates: d.candidates, matched: d.matched }));
+      process.exit(2);
+    }
+    return {
+      workType: d.workType,
+      workTypeDetection: {
+        source: 'deterministic',
+        confidence: 'high',
+        matched: d.matched,
+        decidedAt: now,
+      },
+    };
+  }
+
+  return { workType: DEFAULT_WORK_TYPE };
+}
+
+/**
+ * `morph-spec create <feature>` — explicit feature birth: classifies the
+ * work type (`--type`/`--request`), creates `.morph/features/{feature}/`
+ * scaffolded per the type's dimensioned pipeline, stamps policy-approved
+ * gates (`approvedBy: "policy:{type}"`) for the gates that type skips, and
+ * (with `--worktree`) births the feature already inside its own git
+ * worktree on branch `morph/{feature}`.
  *
  * Replaces the implicit birth via the state-sync hook on the first Write —
  * the skills call this at proposal start so the authoritative state exists
  * with the full canonical shape before any artifact lands. Idempotent: an
- * existing feature is reported and left untouched.
+ * existing feature is reported and left untouched — no re-stamping, no
+ * re-scaffolding, no worktree setup.
  */
 export async function createCommand(featureName, options = {}) {
   try {
@@ -32,24 +95,105 @@ export async function createCommand(featureName, options = {}) {
       process.exit(1);
     }
 
-    const { feature, created } = await createFeature(featureName, { status: options.status });
+    const now = new Date().toISOString();
+    const { workType, workTypeDetection } = resolveWorkType(options, now);
+
+    const { feature, created } = await createFeature(featureName, {
+      status: options.status,
+      workType,
+      workTypeDetection,
+    });
 
-    // The proposal folder is the first working directory of every feature.
     const featureDir = join(process.cwd(), '.morph', 'features', featureName);
-    mkdirSync(join(featureDir, '0-proposal'), { recursive: true });
+    const wt = getWorkType(feature);
+
+    let worktreeResult = null;
+
+    if (created) {
+      // Scaffold the phase folders this work type starts with.
+      for (const folder of wt.scaffold) {
+        mkdirSync(join(featureDir, folder), { recursive: true });
+      }
+
+      // Stamp the gates this type skips by policy — NEVER "auto" (the
+      // gate-guard hook only special-cases approvedBy === "auto"; policy:{type}
+      // keeps the audit trail honest while staying silent to the guard).
+      for (const gate of wt.skippedGates) {
+        await setApprovalGate(featureName, gate, true, {
+          approvedBy: `${POLICY_APPROVER_PREFIX}${workType}`,
+          approvedAt: now,
+        });
+      }
+
+      if (options.worktree) {
+        worktreeResult = await runWorktreeSetup(featureName, {});
+        if (worktreeResult?.created && worktreeResult.path) {
+          try {
+            // feature.json in the root is NOT committed yet (create just
+            // wrote it), so the branch `runWorktreeSetup` checked out from
+            // HEAD does not have it — copy the freshly-scaffolded folder
+            // into the worktree and re-materialize its local state.json.
+            cpSync(featureDir, join(worktreeResult.path, '.morph', 'features', featureName), { recursive: true });
+            // The `.worktree` registration is ROOT-OWNED metadata (runWorktreeSetup
+            // stamped it onto the root's feature.json, which cpSync just copied in).
+            // Strip it from the worktree's branch-local copy so the branch commits a
+            // clean feature.json — otherwise it merges back into the root at
+            // `worktree finish` and the post-merge cleanup leaves the root dirty.
+            // verify.decidePersistence reads the registration from the ROOT's copy,
+            // never this branch-local one (see verify.js), so stripping is safe and
+            // restores the invariant that comment relies on.
+            try {
+              const wtFeatureJson = join(worktreeResult.path, '.morph', 'features', featureName, 'feature.json');
+              const fj = JSON.parse(readFileSync(wtFeatureJson, 'utf8'));
+              if (fj.worktree) {
+                delete fj.worktree;
+                writeFileSync(wtFeatureJson, JSON.stringify(fj, null, 2), 'utf8');
+              }
+            } catch { /* fail-open — root copy still carries the registration for verify */ }
+            // Re-materialize now that the feature.json exists in the worktree, and
+            // report THIS result — runWorktreeSetup's earlier materialize ran before
+            // the copy (no features yet), so its `materialized:false` was stale.
+            const remat = await materializeState(worktreeResult.path);
+            worktreeResult.materialized = remat.materialized;
+          } catch { /* fail-open — the feature already exists in root */ }
+        }
+      }
+    }
+
+    // `feature` is a snapshot from BEFORE the gate-stamping/worktree steps —
+    // setApprovalGate/runWorktreeSetup each do their own loadState()/saveState()
+    // round-trip on disk, so re-read the authoritative copy for reporting.
+    const finalFeature = created ? (getFeature(featureName) || feature) : feature;
 
     if (options.json) {
-      console.log(JSON.stringify({ feature: featureName, created, ...feature }, null, 2));
+      const out = { feature: featureName, created, ...finalFeature };
+      if (worktreeResult) out.worktree = worktreeResult;
+      console.log(JSON.stringify(out, null, 2));
       return;
     }
 
     if (created) {
-      console.log(chalk.green(`\n✅ Feature created: ${featureName}`));
-      console.log(chalk.gray(`   .morph/features/${featureName}/feature.json (canonical shape) + 0-proposal/`));
-      console.log(chalk.gray(`   status: ${feature.status} | createdAt: ${feature.createdAt}\n`));
+      console.log(chalk.green(`\n✅ Feature created: ${featureName} (type: ${finalFeature.workType})`));
+      console.log(chalk.gray(`   .morph/features/${featureName}/feature.json (canonical shape)`));
+      console.log(chalk.gray(`   status: ${finalFeature.status} | createdAt: ${finalFeature.createdAt}`));
+      console.log(chalk.gray(`   scaffolded: ${wt.scaffold.join(', ')}`));
+      if (wt.skippedGates.length) {
+        console.log(chalk.yellow(`   gates skipped by policy:${finalFeature.workType}: ${wt.skippedGates.join(', ')}`));
+      }
+      console.log(chalk.cyan(`   next: ${wt.entrySkill}\n`));
+
+      if (worktreeResult) {
+        if (worktreeResult.created) {
+          console.log(chalk.green(`   worktree: ${worktreeResult.path} (branch ${worktreeResult.branch})`));
+          console.log(chalk.gray(`   ${worktreeResult.nextStep}\n`));
+        } else {
+          const why = worktreeResult.error || (worktreeResult.alreadyExists ? 'already exists' : 'unknown');
+          console.log(chalk.yellow(`   ⚠️  worktree setup skipped (${why}) — feature stays in the root worktree\n`));
+        }
+      }
     } else {
       console.log(chalk.yellow(`\n⚠️  Feature "${featureName}" already exists — left untouched`));
-      console.log(chalk.gray(`   status: ${feature.status} | createdAt: ${feature.createdAt || 'unknown'}\n`));
+      console.log(chalk.gray(`   status: ${finalFeature.status} | workType: ${finalFeature.workType || 'feature'} | createdAt: ${finalFeature.createdAt || 'unknown'}\n`));
     }
   } catch (error) {
     console.error(chalk.red(`\n❌ Error creating feature: ${error.message}\n`));

package/src/commands/state/retype.js

@@ -0,0 +1,126 @@
+import chalk from 'chalk';
+import { mkdirSync } from 'fs';
+import { join } from 'path';
+import { getFeature, setApprovalGate, updateFeature } from '../../core/state/state-manager.js';
+import { WORK_TYPES, isValidWorkType, POLICY_APPROVER_PREFIX } from '../../core/work-types.js';
+
+/**
+ * `morph-spec retype <feature> <newType>` — mid-flight work-type change with
+ * asymmetric gate rules that preserve GENUINE human/auto approvals and only
+ * ever undo policy stamps:
+ *
+ *  - Blocked outright once Gate 3 (review) is approved — the feature already
+ *    shipped its pipeline, retyping it retroactively would be revisionist.
+ *  - Downgrade (fewer skipped gates → more skipped gates, e.g. feature/bug
+ *    → chore/hotfix) is blocked once Gate 2 (plan) carries a genuine
+ *    (non-policy) approval — the plan was already accepted under the old
+ *    type's scrutiny; retyping around it would erase that judgment call.
+ *  - Upgrade (more skipped gates → fewer, e.g. chore/hotfix → feature/bug)
+ *    is always allowed before review: it only ever ADDS scrutiny.
+ *
+ * Applying a retype resets exactly the gates that were stamped
+ * `policy:{oldType}` and the NEW type no longer skips (so the human is asked
+ * again), stamps `policy:{newType}` on any of the new type's skippedGates
+ * that aren't already approved (a prior genuine approval is left standing —
+ * that's the "preserves human approvals" half of the contract), scaffolds
+ * any phase folders the new type needs that don't exist yet, and appends an
+ * audit entry to `workTypeHistory`.
+ */
+export async function retypeCommand(featureName, newType, options = {}) {
+  try {
+    if (!isValidWorkType(newType)) {
+      console.error(chalk.red(`\n❌ Invalid work type: "${newType}"`));
+      console.error(chalk.gray(`Valid types: ${Object.keys(WORK_TYPES).join(', ')}\n`));
+      process.exit(1);
+    }
+
+    const feature = getFeature(featureName);
+    if (!feature) {
+      console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
+      process.exit(1);
+    }
+
+    const oldType = feature.workType || 'feature';
+
+    if (oldType === newType) {
+      console.log(chalk.yellow(`\n⚠️  Feature "${featureName}" already is type "${newType}" — no-op\n`));
+      return;
+    }
+
+    if (feature.approvalGates?.review?.approved === true) {
+      console.error(chalk.red(`\n❌ Feature "${featureName}" já passou pelo Gate 3 (review); retype bloqueado\n`));
+      process.exit(1);
+    }
+
+    const oldWorkType = WORK_TYPES[oldType] || WORK_TYPES.feature;
+    const newWorkType = WORK_TYPES[newType];
+    const isDowngrade = newWorkType.skippedGates.length > oldWorkType.skippedGates.length;
+
+    if (isDowngrade) {
+      const planGate = feature.approvalGates?.plan;
+      const genuinelyApproved = planGate?.approved === true
+        && !String(planGate.approvedBy || '').startsWith(POLICY_APPROVER_PREFIX);
+      if (genuinelyApproved) {
+        console.error(chalk.red(`\n❌ Gate 2 (plan) já aprovado por "${planGate.approvedBy}"; downgrade bloqueado — o plano já foi aceito\n`));
+        process.exit(1);
+      }
+    }
+
+    const now = new Date().toISOString();
+
+    // Reset gates that were stamped policy:{oldType} and the new type no
+    // longer skips — a genuine (non-policy) approval is never touched.
+    const resetGates = [];
+    for (const [gate, data] of Object.entries(feature.approvalGates || {})) {
+      const isPolicyStamped = String(data?.approvedBy || '').startsWith(POLICY_APPROVER_PREFIX);
+      if (isPolicyStamped && !newWorkType.skippedGates.includes(gate)) {
+        await setApprovalGate(featureName, gate, false, { approvedBy: null, approvedAt: null });
+        resetGates.push(gate);
+      }
+    }
+
+    // Stamp the new type's skipped gates — but only the ones not already
+    // approved (preserves a prior genuine approval untouched).
+    const stampedGates = [];
+    for (const gate of newWorkType.skippedGates) {
+      if (!feature.approvalGates?.[gate]?.approved) {
+        await setApprovalGate(featureName, gate, true, {
+          approvedBy: `${POLICY_APPROVER_PREFIX}${newType}`,
+          approvedAt: now,
+        });
+        stampedGates.push(gate);
+      }
+    }
+
+    const featureDir = join(process.cwd(), '.morph', 'features', featureName);
+    for (const folder of newWorkType.scaffold) {
+      mkdirSync(join(featureDir, folder), { recursive: true });
+    }
+
+    await updateFeature(featureName, 'workType', newType);
+    await updateFeature(featureName, 'workTypeHistory', [
+      ...(feature.workTypeHistory || []),
+      { from: oldType, to: newType, reason: options.reason || null, at: now },
+    ]);
+
+    const finalFeature = getFeature(featureName);
+
+    if (options.json) {
+      console.log(JSON.stringify({ feature: featureName, from: oldType, to: newType, resetGates, stampedGates, ...finalFeature }, null, 2));
+      return;
+    }
+
+    console.log(chalk.green(`\n✅ Feature retyped: ${featureName} (${oldType} → ${newType})`));
+    if (resetGates.length) {
+      console.log(chalk.yellow(`   gates reset (were policy-stamped, no longer skipped): ${resetGates.join(', ')}`));
+    }
+    if (stampedGates.length) {
+      console.log(chalk.yellow(`   gates stamped policy:${newType}: ${stampedGates.join(', ')}`));
+    }
+    console.log(chalk.gray(`   scaffolded: ${newWorkType.scaffold.join(', ')}`));
+    console.log('');
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Error retyping feature: ${error.message}\n`));
+    process.exit(1);
+  }
+}

package/src/commands/state/score.js

@@ -33,6 +33,10 @@ export async function scoreCommand(featureName, taskId, scoreArg, options = {})
       process.exit(1);
     }
 
+    if (feature.taskVerifications?.[taskId]?.status === 'fail') {
+      console.error(chalk.yellow(`⚠️  Último verify de ${taskId} está VERMELHO — score sendo gravado sobre código que não passou no verify determinístico`));
+    }
+
     let dimensions;
     if (options.dims) {
       const parts = String(options.dims).split(',').map(s => s.trim());

package/src/commands/tasks/dag.js

@@ -3,6 +3,7 @@ import { existsSync } from 'fs';
 import { join } from 'path';
 import { parseTasksJson } from '../../lib/tasks/tasks-json-parser.js';
 import { planDispatch } from '../../lib/tasks/dispatch-planner.js';
+import { renderMermaidFlowchart } from '../../lib/tasks/mermaid-renderer.js';
 
 /**
  * `morph-spec dag <feature>` — analyze the tasks.json DAG and print the
@@ -10,6 +11,9 @@ import { planDispatch } from '../../lib/tasks/dispatch-planner.js';
  *
  * This is the command morph-apply §2 runs instead of re-deriving the rules
  * (and instead of the old inline JS snippets the LLM could not execute).
+ *
+ * `--mermaid` emits the DAG as a Mermaid `flowchart TD` instead (for
+ * visualizing the plan at Gate 2), bypassing the dispatch analysis entirely.
  */
 export async function dagCommand(featureName, options = {}) {
   try {
@@ -22,6 +26,14 @@ export async function dagCommand(featureName, options = {}) {
 
     // parseTasksJson validates the schema and throws with the error list.
     const data = await parseTasksJson(tasksPath);
+
+    // --mermaid short-circuits before the dispatch analysis: visualizing the
+    // plan's DAG doesn't need a sequential-vs-parallel decision.
+    if (options.mermaid) {
+      console.log(renderMermaidFlowchart(data));
+      return;
+    }
+
     const plan = planDispatch(data);
 
     if (options.json) {
@@ -60,6 +72,26 @@ export async function dagCommand(featureName, options = {}) {
       console.log(`  ${chalk.gray('→')} Sequencial: ${plan.sequentialRemainder.join(', ')}`);
     }
 
+    // Isolamento — only meaningful when there IS a parallel batch. In a shared
+    // working tree two agents writing the same path corrupt each other; the
+    // dag recommends `isolation: "worktree"` so each runs in its own worktree
+    // (morph-apply §3b-w).
+    const iso = plan.isolation;
+    if (iso && (iso.recommended === 'worktree' || iso.unknownFootprint.length > 0)) {
+      console.log(chalk.bold('\nIsolamento:'));
+      if (iso.recommended === 'worktree') {
+        console.log(`  ${chalk.yellow('⚠')} recomendado: ${chalk.bold('worktree')} — ${iso.reason}`);
+        for (const c of iso.collisions) {
+          console.log(chalk.gray(`      colisão em "${c.path}": ${c.units.join(' ‖ ')} (${c.tasks.join(', ')})`));
+        }
+      } else {
+        console.log(`  ${chalk.gray('○')} ${iso.reason}`);
+      }
+      if (iso.unknownFootprint.length > 0) {
+        console.log(chalk.gray(`      footprint desconhecido (sem outputs): ${iso.unknownFootprint.join(', ')}`));
+      }
+    }
+
     console.log('\n' + '━'.repeat(60) + '\n');
   } catch (error) {
     console.error(chalk.red(`\n❌ Error analyzing DAG: ${error.message}\n`));

package/src/commands/validation/index.js

@@ -2,3 +2,4 @@
  * Validation Commands
  */
 export { validateFeatureCommand } from './validate-feature.js';
+export { verifyCommand } from './verify.js';

package/src/commands/validation/validate-feature.js

@@ -132,6 +132,14 @@ const PHASE_OUTPUTS = {
   review: ['review-report.md'],
 };
 
+// Work types whose plan phase (see src/core/work-types.js) skips proposal.md/
+// spec.md/mandate.md — chore and hotfix stamp proposal+plan gates at birth
+// (policy-approved, no human deliberation over those docs) and go straight to
+// tasks.json. Validating the full plan doc set against a feature that was
+// never asked to write those docs would be a false failure, not a real gap.
+const LEAN_PLAN_WORK_TYPES = ['chore', 'hotfix'];
+const LEAN_PLAN_OUTPUTS = ['tasks.json'];
+
 /**
  * Phase-to-folder mapping (v5 filesystem convention)
  */
@@ -295,11 +303,16 @@ function validateMarkdownSections(content, sections, result) {
  *
  * @param {string} featurePath  Absolute path to the feature directory.
  * @param {string|null} phase   Phase key, or null to validate everything.
+ * @param {string|undefined} workType  Feature's workType (see src/core/work-types.js).
+ *   When `phase === 'plan'` and workType is 'chore'/'hotfix', only tasks.json
+ *   is required (see LEAN_PLAN_WORK_TYPES above).
  * @returns {{ outputFiles?: Array<{file:string, dir:string}>, error?: string }}
  */
-function resolveOutputFiles(featurePath, phase) {
+function resolveOutputFiles(featurePath, phase, workType) {
   if (phase) {
-    const files = PHASE_OUTPUTS[phase];
+    const files = (phase === 'plan' && LEAN_PLAN_WORK_TYPES.includes(workType))
+      ? LEAN_PLAN_OUTPUTS
+      : PHASE_OUTPUTS[phase];
     if (!files) return { error: `Unknown phase: ${phase}` };
     const phaseFolder = PHASE_FOLDERS[phase];
     const searchPath = phaseFolder ? path.join(featurePath, phaseFolder) : featurePath;
@@ -327,7 +340,7 @@ function resolveOutputFiles(featurePath, phase) {
  * Pure validation core — no console output, no process.exit.
  *
  * @param {string} featurePath  Absolute path to the feature directory.
- * @param {{ phase?: string }} [options]
+ * @param {{ phase?: string, workType?: string }} [options]
  * @returns {{
  *   feature: string, phase: string, valid: boolean, error?: string,
  *   totalErrors: number, totalWarnings: number, totalFound: number,
@@ -336,9 +349,10 @@ function resolveOutputFiles(featurePath, phase) {
  */
 export function runFeatureValidation(featurePath, options = {}) {
   const phase = options.phase || null;
+  const workType = options.workType || null;
   const feature = path.basename(featurePath);
 
-  const { outputFiles, error } = resolveOutputFiles(featurePath, phase);
+  const { outputFiles, error } = resolveOutputFiles(featurePath, phase, workType);
   if (error) {
     return {
       feature,
@@ -392,7 +406,21 @@ export async function validateFeatureCommand(featureName, options = {}) {
     process.exit(1);
   }
 
-  const validation = runFeatureValidation(featurePath, { phase });
+  // workType is read straight off the feature's own feature.json (not via
+  // state-manager's getFeature/loadState) so a broken/missing root state.json
+  // elsewhere in the project can never make `validate` itself throw — it just
+  // falls back to the full (non-lean) output set, same as today.
+  let workType;
+  try {
+    const fjPath = path.join(featurePath, 'feature.json');
+    if (fs.existsSync(fjPath)) {
+      workType = JSON.parse(fs.readFileSync(fjPath, 'utf8')).workType;
+    }
+  } catch {
+    workType = undefined;
+  }
+
+  const validation = runFeatureValidation(featurePath, { phase, workType });
   const { results, totalErrors, totalWarnings, totalFound } = validation;
   const schemaWarnings = []; // v5: cross-validation removed (contracts in spec.md)