@polymorphism-tech/morph-spec 7.9.3 → 8.0.0

package/src/commands/validation/verify.js

@@ -0,0 +1,190 @@
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import { resolve, join } from 'path';
+import { getFeature, updateFeature } from '../../core/state/state-manager.js';
+import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
+import { runVerify } from '../../lib/validators/verify-runner.js';
+import { resolvePrimaryRoot } from '../project/worktree.js';
+
+/** ✓ pass · ✗ fail · – skip */
+function statusIcon(status) {
+  if (status === 'pass') return chalk.green('✓');
+  if (status === 'fail') return chalk.red('✗');
+  return chalk.gray('–');
+}
+
+/**
+ * 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('');
+  lines.push(result.status === 'pass' ? chalk.green.bold('✓ PASS') : chalk.red.bold('✗ FAIL'));
+  lines.push('');
+  lines.push('Nodes:');
+  for (const [name, node] of Object.entries(result.nodes)) {
+    const icon = statusIcon(node.status);
+    let detail;
+    if (node.status === 'skip') {
+      detail = node.reason || '';
+    } else if (name === 'validators' && node.score != null) {
+      detail = `score ${node.score}/10`;
+    } else {
+      detail = `${node.durationMs}ms`;
+    }
+    lines.push(`  ${icon} ${name.padEnd(11)} ${node.status.padEnd(5)} ${chalk.gray(detail)}`);
+  }
+
+  if (result.feedback.length > 0) {
+    lines.push('');
+    lines.push('Feedback:');
+    for (const line of result.feedback) lines.push(`  ${line}`);
+  }
+
+  lines.push('');
+  return lines.join('\n');
+}
+
+/**
+ * Decide whether it's safe to persist a verify result to feature.json.
+ *
+ * Safe contexts: the primary git root, or the feature's own REGISTERED
+ * worktree (`worktree.path` — where feature.json is authoritative and
+ * travels with the branch). Any other worktree (e.g. a harness subagent's
+ * temporary scratch worktree) must never write feature.json — that would
+ * risk a merge conflict / violate the single-writer clause.
+ *
+ * Worktree registration is ROOT-OWNED data: `runWorktreeSetup` (see
+ * src/commands/project/worktree.js) writes `.worktree` ONLY into the PRIMARY
+ * ROOT's copy of feature.json (via saveState after chdir'ing back to root) —
+ * it never touches the worktree's own branch-local copy. So this must read
+ * the ROOT's feature.json to find the registration, never the cwd-local one
+ * (`getFeature(featureName)` resolves relative to `process.cwd()`, which
+ * inside a worktree is the branch-local copy and will never carry
+ * `.worktree` — reading it here would make this branch permanently dead code
+ * for the exact case it exists to handle: verify running from inside a
+ * registered worktree).
+ *
+ * @param {{ cwd: string, featureName: string, noPersist: boolean }} params
+ * @returns {{ persist: boolean, reason: string|null }}
+ */
+function decidePersistence({ cwd, featureName, noPersist }) {
+  if (noPersist) return { persist: false, reason: 'no-persist-flag' };
+
+  const root = resolvePrimaryRoot(cwd);
+  const normalizedCwd = resolve(cwd).replace(/\\/g, '/');
+
+  if (normalizedCwd === root) return { persist: true, reason: null };
+
+  // cwd is (or looks like) a worktree — consult the ROOT's feature.json for
+  // the registration. Fail-open: an unreadable/missing root feature.json
+  // means we can't confirm registration, so treat as unregistered.
+  let registeredWt = null;
+  try {
+    const rootFeatureJsonPath = join(root, '.morph', 'features', featureName, 'feature.json');
+    const rootFeature = JSON.parse(readFileSync(rootFeatureJsonPath, 'utf8'));
+    registeredWt = rootFeature.worktree?.path
+      ? String(rootFeature.worktree.path).replace(/\\/g, '/')
+      : null;
+  } catch {
+    registeredWt = null;
+  }
+
+  if (registeredWt && normalizedCwd === registeredWt) return { persist: true, reason: null };
+  return { persist: false, reason: 'unregistered-worktree' };
+}
+
+/** Read tasks.json's task list for a feature; [] if missing/corrupt. */
+function readTasks(featureName) {
+  try {
+    const tasksPath = getAbsoluteOutputPath(process.cwd(), featureName, 'tasks');
+    if (!existsSync(tasksPath)) return [];
+    return JSON.parse(readFileSync(tasksPath, 'utf8')).tasks || [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * `morph-spec verify <feature> [task]` — 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.
+ *
+ * Exit codes: 0 = pass (including all-skip) · 1 = fail (>=1 red node) ·
+ * 2 = usage error (unknown feature or task — the task's `group` decides the
+ * rubric, so an unknown task id is a hard usage error here, unlike the
+ * advisory warning `morph-spec score` gives for the same situation).
+ */
+export async function verifyCommand(featureName, taskId, options = {}) {
+  let feature;
+  try {
+    feature = getFeature(featureName);
+  } catch {
+    feature = null;
+  }
+  if (!feature) {
+    console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
+    process.exit(2);
+  }
+
+  if (taskId) {
+    const tasks = readTasks(featureName);
+    if (!tasks.some((t) => t.id === taskId)) {
+      console.error(chalk.red(`\n❌ Task "${taskId}" not found in tasks.json for feature "${featureName}"\n`));
+      process.exit(2);
+    }
+  }
+
+  const result = await runVerify(process.cwd(), featureName, taskId || null, {
+    rubric: options.rubric,
+    timeout: options.timeout,
+    skipTests: options.skipTests,
+    skipBuild: options.skipBuild,
+  });
+
+  const scopeKey = taskId ? `taskVerifications.${taskId}` : 'verifications.feature';
+  const { persist, reason } = decidePersistence({
+    cwd: process.cwd(),
+    featureName,
+    noPersist: options.noPersist,
+  });
+
+  let compact = null;
+  if (persist) {
+    const prevEntry = taskId ? feature.taskVerifications?.[taskId] : feature.verifications?.feature;
+    compact = {
+      status: result.status,
+      nodes: {
+        build: result.nodes.build.status,
+        tests: result.nodes.tests.status,
+        validators: result.nodes.validators.status,
+      },
+      score: result.nodes.validators.score ?? null,
+      attempts: (prevEntry?.attempts ?? 0) + 1,
+      updatedAt: new Date().toISOString(),
+    };
+    await updateFeature(featureName, scopeKey, compact);
+  }
+
+  if (options.json) {
+    const output = { ...result, persisted: persist, ...(persist ? {} : { reason }) };
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(formatVerifyResult(result));
+    if (persist) {
+      console.log(chalk.gray(`Persisted: ${scopeKey} (attempts: ${compact.attempts})\n`));
+    } else {
+      console.log(chalk.yellow(`⚠️  Not persisted (${reason})\n`));
+    }
+  }
+
+  process.exit(result.status === 'pass' ? 0 : 1);
+}

package/src/core/state/phase-state-machine.js

@@ -1,197 +1,197 @@
-/**
- * Phase State Machine - Enforces valid phase transitions
- *
- * Prevents invalid workflow jumps and ensures sequential phase progression.
- * Based on the MORPH 5-phase workflow.
- */
-
-/**
- * Valid phase transitions map
- * Each phase can only transition to specific next phases
- */
-const VALID_TRANSITIONS = {
-  'proposal': ['uiux', 'plan'],
-  'uiux': ['plan'],
-  'plan': ['implement'],
-  'implement': ['review'],
-  'review': []
-};
-
-/**
- * Phase display names for error messages
- */
-const PHASE_NAMES = {
-  'proposal': 'Proposal (Phase 0)',
-  'uiux': 'UI/UX Design (Phase 1)',
-  'plan': 'Plan (Phase 2)',
-  'implement': 'Implement (Phase 3)',
-  'review': 'Quality Review (Phase 4)'
-};
-
-/**
- * Optional phases that can be skipped
- */
-const OPTIONAL_PHASES = ['uiux'];
-
-/**
- * Validate if a phase transition is allowed
- * @param {string} fromPhase - Current phase
- * @param {string} toPhase - Target phase
- * @returns {boolean} True if transition is valid
- */
-export function isValidTransition(fromPhase, toPhase) {
-  if (!fromPhase || !toPhase) {
-    return false;
-  }
-
-  const validNextPhases = VALID_TRANSITIONS[fromPhase];
-  return validNextPhases ? validNextPhases.includes(toPhase) : false;
-}
-
-/**
- * Get list of valid next phases for a given phase
- * @param {string} currentPhase - Current phase
- * @returns {string[]} Array of valid next phase names
- */
-export function getValidNextPhases(currentPhase) {
-  return VALID_TRANSITIONS[currentPhase] || [];
-}
-
-/**
- * Get display name for a phase
- * @param {string} phase - Phase identifier
- * @returns {string} Human-readable phase name
- */
-export function getPhaseDisplayName(phase) {
-  return PHASE_NAMES[phase] || phase;
-}
-
-/**
- * Check if a phase is optional
- * @param {string} phase - Phase identifier
- * @returns {boolean} True if phase is optional
- */
-export function isOptionalPhase(phase) {
-  return OPTIONAL_PHASES.includes(phase);
-}
-
-/**
- * Validate transition and throw error if invalid
- * @param {string} fromPhase - Current phase
- * @param {string} toPhase - Target phase
- * @throws {Error} If transition is invalid
- */
-export function validateTransition(fromPhase, toPhase) {
-  if (!fromPhase) {
-    throw new Error('Current phase is undefined. Cannot validate transition.');
-  }
-
-  if (!toPhase) {
-    throw new Error('Target phase is undefined. Cannot validate transition.');
-  }
-
-  if (!isValidTransition(fromPhase, toPhase)) {
-    const validPhases = getValidNextPhases(fromPhase);
-    const fromDisplay = getPhaseDisplayName(fromPhase);
-    const toDisplay = getPhaseDisplayName(toPhase);
-
-    throw new Error(
-      `Invalid phase transition: ${fromDisplay} → ${toDisplay}\n\n` +
-      `Valid next phases from ${fromDisplay}:\n` +
-      validPhases.map(p => `  • ${getPhaseDisplayName(p)}`).join('\n') +
-      '\n\n' +
-      'You cannot skip phases in the MORPH workflow.\n' +
-      'To override this check, use the --force flag (not recommended).'
-    );
-  }
-}
-
-/**
- * Get the sequential order of phases
- * @returns {string[]} Ordered list of phases
- */
-export function getPhaseSequence() {
-  return ['proposal', 'uiux', 'plan', 'implement', 'review'];
-}
-
-/**
- * Get phase order index (for comparison)
- * @param {string} phase - Phase identifier
- * @returns {number} Index in sequence (-1 if not found)
- */
-export function getPhaseOrder(phase) {
-  return getPhaseSequence().indexOf(phase);
-}
-
-/**
- * Check if target phase is ahead of current phase
- * @param {string} currentPhase - Current phase
- * @param {string} targetPhase - Target phase
- * @returns {boolean} True if target is ahead
- */
-export function isPhaseAhead(currentPhase, targetPhase) {
-  return getPhaseOrder(targetPhase) > getPhaseOrder(currentPhase);
-}
-
-/**
- * Check if target phase is behind current phase (rollback scenario)
- * @param {string} currentPhase - Current phase
- * @param {string} targetPhase - Target phase
- * @returns {boolean} True if target is behind
- */
-export function isPhaseRollback(currentPhase, targetPhase) {
-  return getPhaseOrder(targetPhase) < getPhaseOrder(currentPhase);
-}
-
-/**
- * Get all skipped phases between two phases
- * @param {string} fromPhase - Starting phase
- * @param {string} toPhase - Ending phase
- * @returns {string[]} Array of skipped phases
- */
-export function getSkippedPhases(fromPhase, toPhase) {
-  const sequence = getPhaseSequence();
-  const fromIndex = sequence.indexOf(fromPhase);
-  const toIndex = sequence.indexOf(toPhase);
-
-  if (fromIndex === -1 || toIndex === -1 || toIndex <= fromIndex) {
-    return [];
-  }
-
-  return sequence.slice(fromIndex + 1, toIndex);
-}
-
-/**
- * Validate that no required phases were skipped
- * @param {string} fromPhase - Starting phase
- * @param {string} toPhase - Ending phase
- * @throws {Error} If required phases were skipped
- */
-export function validateNoRequiredPhasesSkipped(fromPhase, toPhase) {
-  const skipped = getSkippedPhases(fromPhase, toPhase);
-  const requiredSkipped = skipped.filter(p => !isOptionalPhase(p));
-
-  if (requiredSkipped.length > 0) {
-    throw new Error(
-      `Cannot skip required phases:\n` +
-      requiredSkipped.map(p => `  • ${getPhaseDisplayName(p)}`).join('\n') +
-      '\n\nYou must complete each required phase in sequence.'
-    );
-  }
-}
-
-/**
- * Get comprehensive phase information
- * @param {string} phase - Phase identifier
- * @returns {Object} Phase metadata
- */
-export function getPhaseInfo(phase) {
-  return {
-    id: phase,
-    displayName: getPhaseDisplayName(phase),
-    order: getPhaseOrder(phase),
-    isOptional: isOptionalPhase(phase),
-    validNextPhases: getValidNextPhases(phase),
-    canTransitionTo: (targetPhase) => isValidTransition(phase, targetPhase)
-  };
-}
+/**
+ * Phase State Machine - Enforces valid phase transitions
+ *
+ * Prevents invalid workflow jumps and ensures sequential phase progression.
+ * Based on the MORPH 5-phase workflow.
+ */
+
+/**
+ * Valid phase transitions map
+ * Each phase can only transition to specific next phases
+ */
+const VALID_TRANSITIONS = {
+  'proposal': ['uiux', 'plan'],
+  'uiux': ['plan'],
+  'plan': ['implement'],
+  'implement': ['review'],
+  'review': []
+};
+
+/**
+ * Phase display names for error messages
+ */
+const PHASE_NAMES = {
+  'proposal': 'Proposal (Phase 0)',
+  'uiux': 'UI/UX Design (Phase 1)',
+  'plan': 'Plan (Phase 2)',
+  'implement': 'Implement (Phase 3)',
+  'review': 'Quality Review (Phase 4)'
+};
+
+/**
+ * Optional phases that can be skipped
+ */
+const OPTIONAL_PHASES = ['uiux'];
+
+/**
+ * Validate if a phase transition is allowed
+ * @param {string} fromPhase - Current phase
+ * @param {string} toPhase - Target phase
+ * @returns {boolean} True if transition is valid
+ */
+export function isValidTransition(fromPhase, toPhase) {
+  if (!fromPhase || !toPhase) {
+    return false;
+  }
+
+  const validNextPhases = VALID_TRANSITIONS[fromPhase];
+  return validNextPhases ? validNextPhases.includes(toPhase) : false;
+}
+
+/**
+ * Get list of valid next phases for a given phase
+ * @param {string} currentPhase - Current phase
+ * @returns {string[]} Array of valid next phase names
+ */
+export function getValidNextPhases(currentPhase) {
+  return VALID_TRANSITIONS[currentPhase] || [];
+}
+
+/**
+ * Get display name for a phase
+ * @param {string} phase - Phase identifier
+ * @returns {string} Human-readable phase name
+ */
+export function getPhaseDisplayName(phase) {
+  return PHASE_NAMES[phase] || phase;
+}
+
+/**
+ * Check if a phase is optional
+ * @param {string} phase - Phase identifier
+ * @returns {boolean} True if phase is optional
+ */
+export function isOptionalPhase(phase) {
+  return OPTIONAL_PHASES.includes(phase);
+}
+
+/**
+ * Validate transition and throw error if invalid
+ * @param {string} fromPhase - Current phase
+ * @param {string} toPhase - Target phase
+ * @throws {Error} If transition is invalid
+ */
+export function validateTransition(fromPhase, toPhase) {
+  if (!fromPhase) {
+    throw new Error('Current phase is undefined. Cannot validate transition.');
+  }
+
+  if (!toPhase) {
+    throw new Error('Target phase is undefined. Cannot validate transition.');
+  }
+
+  if (!isValidTransition(fromPhase, toPhase)) {
+    const validPhases = getValidNextPhases(fromPhase);
+    const fromDisplay = getPhaseDisplayName(fromPhase);
+    const toDisplay = getPhaseDisplayName(toPhase);
+
+    throw new Error(
+      `Invalid phase transition: ${fromDisplay} → ${toDisplay}\n\n` +
+      `Valid next phases from ${fromDisplay}:\n` +
+      validPhases.map(p => `  • ${getPhaseDisplayName(p)}`).join('\n') +
+      '\n\n' +
+      'You cannot skip phases in the MORPH workflow.\n' +
+      'To override this check, use the --force flag (not recommended).'
+    );
+  }
+}
+
+/**
+ * Get the sequential order of phases
+ * @returns {string[]} Ordered list of phases
+ */
+export function getPhaseSequence() {
+  return ['proposal', 'uiux', 'plan', 'implement', 'review'];
+}
+
+/**
+ * Get phase order index (for comparison)
+ * @param {string} phase - Phase identifier
+ * @returns {number} Index in sequence (-1 if not found)
+ */
+export function getPhaseOrder(phase) {
+  return getPhaseSequence().indexOf(phase);
+}
+
+/**
+ * Check if target phase is ahead of current phase
+ * @param {string} currentPhase - Current phase
+ * @param {string} targetPhase - Target phase
+ * @returns {boolean} True if target is ahead
+ */
+export function isPhaseAhead(currentPhase, targetPhase) {
+  return getPhaseOrder(targetPhase) > getPhaseOrder(currentPhase);
+}
+
+/**
+ * Check if target phase is behind current phase (rollback scenario)
+ * @param {string} currentPhase - Current phase
+ * @param {string} targetPhase - Target phase
+ * @returns {boolean} True if target is behind
+ */
+export function isPhaseRollback(currentPhase, targetPhase) {
+  return getPhaseOrder(targetPhase) < getPhaseOrder(currentPhase);
+}
+
+/**
+ * Get all skipped phases between two phases
+ * @param {string} fromPhase - Starting phase
+ * @param {string} toPhase - Ending phase
+ * @returns {string[]} Array of skipped phases
+ */
+export function getSkippedPhases(fromPhase, toPhase) {
+  const sequence = getPhaseSequence();
+  const fromIndex = sequence.indexOf(fromPhase);
+  const toIndex = sequence.indexOf(toPhase);
+
+  if (fromIndex === -1 || toIndex === -1 || toIndex <= fromIndex) {
+    return [];
+  }
+
+  return sequence.slice(fromIndex + 1, toIndex);
+}
+
+/**
+ * Validate that no required phases were skipped
+ * @param {string} fromPhase - Starting phase
+ * @param {string} toPhase - Ending phase
+ * @throws {Error} If required phases were skipped
+ */
+export function validateNoRequiredPhasesSkipped(fromPhase, toPhase) {
+  const skipped = getSkippedPhases(fromPhase, toPhase);
+  const requiredSkipped = skipped.filter(p => !isOptionalPhase(p));
+
+  if (requiredSkipped.length > 0) {
+    throw new Error(
+      `Cannot skip required phases:\n` +
+      requiredSkipped.map(p => `  • ${getPhaseDisplayName(p)}`).join('\n') +
+      '\n\nYou must complete each required phase in sequence.'
+    );
+  }
+}
+
+/**
+ * Get comprehensive phase information
+ * @param {string} phase - Phase identifier
+ * @returns {Object} Phase metadata
+ */
+export function getPhaseInfo(phase) {
+  return {
+    id: phase,
+    displayName: getPhaseDisplayName(phase),
+    order: getPhaseOrder(phase),
+    isOptional: isOptionalPhase(phase),
+    validNextPhases: getValidNextPhases(phase),
+    canTransitionTo: (targetPhase) => isValidTransition(phase, targetPhase)
+  };
+}

package/src/core/state/state-manager.js

@@ -87,7 +87,7 @@ function readProjectFromConfig() {
  * Atomic JSON write: per-process temp file then rename, with an EPERM retry loop
  * for the brief Windows lock race. Creates the parent directory if needed.
  */
-function atomicWriteJson(targetPath, data) {
+export function atomicWriteJson(targetPath, data) {
   const dir = dirname(targetPath);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 
@@ -118,8 +118,14 @@ function atomicWriteJson(targetPath, data) {
  * mutation on feature A would otherwise rewrite sibling B's file from A's loaded
  * copy. Skipping unchanged siblings means A never touches B's authoritative file
  * in the common case — shrinking the cross-feature clobber window to nothing
- * unless B genuinely changed under A. A formatting mismatch only costs a
- * redundant (idempotent) write, never correctness.
+ * unless B genuinely changed under A.
+ *
+ * A formatting mismatch is NOT free, though: the guard compares bytes, so a
+ * sibling committed with a trailing newline fails it and gets rewritten. The
+ * content is equivalent, but git sees ` M` on a file this caller never meant to
+ * touch — enough to fail a whole-tree clean check (see worktreeFinishCommand).
+ * And the guard only skips IDENTICAL content: a concurrent instance's CHANGED
+ * write to a sibling would still be clobbered by the sweep.
  */
 function writeFeatureJson(featureName, feature) {
   const path = getFeatureJsonPath(featureName);
@@ -327,8 +333,17 @@ export function saveState(state) {
   state.metadata.completedFeatures = Object.values(features)
     .filter((f) => f && f.status === 'completed').length;
 
-  // 1) Persist each feature to its authoritative, committed feature.json. This
-  //    is what travels with the feature's own commit — no cross-feature sweep.
+  // 1) Persist each feature to its authoritative, committed feature.json — what
+  //    travels with the feature's own commit.
+  //
+  //    NOTE: this IS a cross-feature sweep. Mutating one feature re-persists
+  //    every sibling; writeFeatureJson's byte-identical guard makes that a no-op
+  //    only while a sibling's committed file matches our formatting exactly. A
+  //    sibling saved with a trailing newline (any editor, prettier) is rewritten
+  //    and shows up as ` M` — dirtying the tree on behalf of a feature the
+  //    caller never touched. Callers that need to change ONE feature's field
+  //    should write that feature.json directly instead of round-tripping state
+  //    through here (see worktreeFinishCommand's registration cleanup).
   const thinFeatures = {};
   for (const [name, feature] of Object.entries(features)) {
     writeFeatureJson(name, feature);
@@ -487,19 +502,24 @@ async function ensureFeature(featureName) {
 /**
  * Explicitly create a feature with the canonical shape (documented in
  * framework/schemas/feature.schema.json). Idempotent: an existing feature is
- * returned untouched. This is the server-side birth path behind
- * `morph-spec create` — replacing the implicit registration on the first
- * Write into .morph/features/ (the state-sync hook remains as fallback).
+ * returned untouched (including its `workType` — a later `--type` on a
+ * repeat call never overwrites it; see `morph-spec retype` for that). This
+ * is the server-side birth path behind `morph-spec create` — replacing the
+ * implicit registration on the first Write into .morph/features/ (the
+ * state-sync hook remains as fallback).
  *
  * Works even before any state exists (scaffolds the root index), so a
  * feature can be born as the very first morph action in a project.
  *
  * @param {string} featureName - Feature name (kebab-case)
- * @param {{ status?: string }} [options]
+ * @param {{ status?: string, workType?: string, workTypeDetection?: object }} [options]
+ *   `workType` defaults to 'feature' (v8 routing — see src/core/work-types.js).
+ *   `workTypeDetection` is only written when provided (source/confidence/matched
+ *   audit trail from the `--type`/`--request` resolution in `create.js`).
  * @returns {Promise<{ feature: Object, created: boolean }>}
  */
 export async function createFeature(featureName, options = {}) {
-  const { status = 'in_progress' } = options;
+  const { status = 'in_progress', workType, workTypeDetection } = options;
   const state = loadState(false) || scaffoldState();
 
   const existing = state.features[featureName];
@@ -510,6 +530,7 @@ export async function createFeature(featureName, options = {}) {
   const now = new Date().toISOString();
   state.features[featureName] = {
     status,
+    workType: workType || 'feature',
     createdAt: now,
     updatedAt: now,
     activeAgents: [],
@@ -534,6 +555,10 @@ export async function createFeature(featureName, options = {}) {
     fileChanges: []
   };
 
+  if (workTypeDetection) {
+    state.features[featureName].workTypeDetection = workTypeDetection;
+  }
+
   state.metadata.totalFeatures = Object.keys(state.features).length;
   saveState(state);
   return { feature: state.features[featureName], created: true };