@polymorphism-tech/morph-spec 4.8.19 → 4.10.0

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

@@ -5,7 +5,7 @@
  * Used both by CLI commands and internal automation.
  */
 
-import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from 'fs';
+import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { detectWorkflow } from '../workflows/workflow-detector.js';
 import { getAllOutputPaths, getOutputPath } from '../paths/output-schema.js';
@@ -27,12 +27,13 @@ export function getStatePath() {
  * Returns the phase corresponding to the highest-numbered folder present.
  *
  * @param {string} featurePath - Absolute path to .morph/features/{feature}/
- * @returns {string} Phase name: 'implement' | 'tasks' | 'uiux' | 'design' | 'proposal' | 'setup'
+ * @returns {string} Phase name: 'implement' | 'tasks' | 'plan' | 'uiux' | 'design' | 'proposal' | 'setup'
  */
 export function derivePhase(featurePath) {
   const phaseMap = [
-    ['4-implement', 'implement'],
-    ['3-tasks', 'tasks'],
+    ['5-implement', 'implement'],
+    ['4-tasks', 'tasks'],
+    ['3-plan', 'plan'],
     ['2-ui', 'uiux'],
     ['1-design', 'design'],
     ['0-proposal', 'proposal'],
@@ -137,10 +138,29 @@ export function saveState(state) {
     mkdirSync(stateDir, { recursive: true });
   }
 
-  // Atomic write: write to temp then rename to avoid partial-write corruption
-  const tmpPath = statePath + '.tmp';
+  // Atomic write: write to a per-process temp file then rename.
+  // Per-process name prevents two concurrent CLI invocations (e.g. `task done && task start`)
+  // from clobbering each other's temp file on Windows.
+  const tmpPath = `${statePath}.tmp.${process.pid}`;
   writeFileSync(tmpPath, JSON.stringify(state, null, 2), 'utf8');
-  renameSync(tmpPath, statePath);
+
+  // Retry rename on EPERM — Windows holds a brief exclusive lock on the target
+  // when another process is reading it; a short backoff resolves the contention.
+  const MAX_RETRIES = 5;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      renameSync(tmpPath, statePath);
+      return;
+    } catch (err) {
+      if (err.code === 'EPERM' && attempt < MAX_RETRIES) {
+        // Synchronous sleep: CPU-friendly, works on Node.js main thread (v9.4+)
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50 * (attempt + 1));
+      } else {
+        try { unlinkSync(tmpPath); } catch { /* ignore cleanup errors */ }
+        throw err;
+      }
+    }
+  }
 }
 
 /**
@@ -241,7 +261,7 @@ async function ensureFeature(featureName, options = {}) {
 
     state.features[featureName] = {
       status: "draft",
-      workflow: workflowId, // auto | fast-track | standard | full-morph | design-impl | ui-refresh
+      workflow: workflowId, // auto | standard | nodejs-cli
       workflowDetection,
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
@@ -259,20 +279,7 @@ async function ensureFeature(featureName, options = {}) {
         pending: 0
       },
       checkpoints: [],
-      threadMetrics: {
-        totalThreads: 0,
-        parallelPeak: 0,
-        avgDuration: 0,
-        checkpointPassRate: 100
-      },
-      trustConfig: {
-        level: 'low',
-        history: [],
-        autoApprove: {
-          design: false,
-          tasks: false
-        }
-      },
+      trustConfig: {},
       contextBundles: [],
       fileChanges: []
     };
@@ -515,20 +522,11 @@ export async function markOutput(featureName, outputType) {
 
   const normalized = normalizeOutputType(outputType);
 
-  // Initialize outputs on demand (not pre-stored since v5.0.0)
+  // Initialize outputs on demand (not pre-stored)
   if (!state.features[featureName].outputs) {
     state.features[featureName].outputs = getAllOutputPaths(featureName);
   }
 
-  // Define all valid output types (both camelCase and kebab-case alternatives)
-  const validTypes = [
-    'proposal', 'spec', 'contracts', 'tasks', 'decisions', 'recap',
-    'uiDesignSystem', 'ui-design-system',
-    'uiMockups', 'ui-mockups',
-    'uiComponents', 'ui-components',
-    'uiFlows', 'ui-flows'
-  ];
-
   if (!state.features[featureName].outputs[normalized]) {
     // Try to find closest match for better error message
     const validCamelCaseTypes = Object.keys(state.features[featureName].outputs);
@@ -551,9 +549,8 @@ export async function markOutput(featureName, outputType) {
     }
 
     errorMsg += `\n\nValid types:\n`;
-    errorMsg += `  - Standard: proposal, spec, contracts, tasks, decisions, recap\n`;
-    errorMsg += `  - UI/UX: uiDesignSystem, uiMockups, uiComponents, uiFlows\n`;
-    errorMsg += `\nNote: UI types also accept kebab-case (e.g., 'ui-design-system')`;
+    errorMsg += `  ${validCamelCaseTypes.join(', ')}\n`;
+    errorMsg += `\nNote: UI types also accept kebab-case (e.g., 'ui-design-system', 'schema-analysis')`;
 
     throw new Error(errorMsg);
   }
@@ -575,31 +572,9 @@ export async function markOutput(featureName, outputType) {
     });
   }
 
-  // If marking tasks output, try to sync task count from state tasks array
-  if (normalized === 'tasks') {
-    syncTasksCount(state.features[featureName]);
-  }
-
   saveState(state);
 }
 
-/**
- * Sync progress counters from taskList array into feature.progress
- * @param {Object} feature - Feature object
- */
-function syncTasksCount(feature) {
-  const list = feature.taskList;
-  if (!Array.isArray(list) || list.length === 0) return;
-  const completed = list.filter(t => t.status === 'completed').length;
-  feature.progress = {
-    total: list.length,
-    completed,
-    inProgress: list.filter(t => t.status === 'in_progress').length,
-    pending: list.filter(t => t.status === 'pending').length,
-    percentage: Math.round((completed / list.length) * 100)
-  };
-}
-
 /**
  * Track a file change for a feature
  * @param {string} featureName - Feature name

package/src/core/workflows/workflow-detector.js

@@ -242,11 +242,11 @@ export async function detectWorkflow(options) {
   if (workflows.length === 0) {
     // Fallback if no configs found
     return {
-      workflowId: 'full-morph',
+      workflowId: 'standard',
       confidence: 0.5,
       matchedKeywords: [],
       estimatedComplexity: { files: 0, lines: 0, components: 0, hasInfra: false },
-      reasoning: 'No workflow configs found - using full-morph as fallback',
+      reasoning: 'No workflow configs found - using standard as fallback',
       alternativeWorkflows: []
     };
   }
@@ -286,8 +286,8 @@ export async function detectWorkflow(options) {
       (priorityScore * priorityWeight) +
       (contextScore * contextWeight);
 
-    // Penalty for workflows with no keyword matches (unless it's full-morph fallback)
-    if (keywordMatch.matched.length === 0 && workflow.id !== 'full-morph') {
+    // Penalty for workflows with no keyword matches
+    if (keywordMatch.matched.length === 0) {
       totalScore *= 0.5; // 50% penalty for no keyword match
     }
 
@@ -382,84 +382,6 @@ export function listWorkflows(projectPath = '.') {
   }));
 }
 
-// ============================================================================
-// Parallel, Fusion, Long-Running, Zero-Touch Detection
-// ============================================================================
-
-/**
- * Detect if parallel execution mode should be used for a feature.
- * Based on dependency graph analysis: if feature has independent task squads,
- * recommend parallel mode.
- *
- * @param {string} feature - Feature name
- * @param {string} [projectPath='.'] - Project path
- * @returns {Object} { useParallel: boolean, reason: string, squads: Array }
- */
-export async function detectParallelMode(feature, projectPath = '.') {
-  try {
-    const { getExecutionPlan } = await import('../../lib/threads/thread-coordinator.js').catch(() => {
-      // thread-coordinator may not exist yet — graceful fallback
-      return { getExecutionPlan: null };
-    });
-
-    if (!getExecutionPlan) {
-      return { useParallel: false, reason: 'thread-coordinator not available', squads: [] };
-    }
-
-    const plan = getExecutionPlan(feature);
-
-    if (!plan.valid) {
-      return { useParallel: false, reason: plan.error, squads: [] };
-    }
-
-    const parallelPhases = plan.phases.filter(p => p.canRunParallel);
-    const useParallel = parallelPhases.length > 0 && plan.stats.parallelizationRatio > 30;
-
-    return {
-      useParallel,
-      reason: useParallel
-        ? `${plan.stats.parallelizationRatio}% of tasks are parallelizable across ${parallelPhases.length} phases`
-        : 'Tasks are mostly sequential — parallel mode would not improve throughput',
-      parallelizationRatio: plan.stats.parallelizationRatio,
-      parallelPhases: parallelPhases.length,
-      squads: parallelPhases.map(p => p.tasks)
-    };
-  } catch {
-    return { useParallel: false, reason: 'Dependency analysis failed', squads: [] };
-  }
-}
-
-/**
- * Detect if a request needs fusion workflow (uncertainty → run N agents → best-of-N)
- * @param {string} userRequest
- * @returns {boolean}
- */
-export function detectFusionNeed(userRequest) {
-  const fusionKeywords = [
-    'uncertain', 'uncertainty', 'critical decision', 'compare approaches',
-    'best approach', 'prototype', 'explore options', 'which is better',
-    'not sure how', 'multiple solutions', 'benchmark'
-  ];
-  const req = userRequest.toLowerCase();
-  return fusionKeywords.some(kw => req.includes(kw));
-}
-
-/**
- * Detect if a request needs long-running workflow (L-Thread with stop hooks)
- * @param {string} userRequest
- * @returns {boolean}
- */
-export function detectLongRunningNeed(userRequest) {
-  const longRunningKeywords = [
-    'autonomous', 'large scope', 'full system', 'end to end', 'e2e',
-    'complete implementation', 'no interruption', 'long running', 'unattended'
-  ];
-  const req = userRequest.toLowerCase();
-  const fileCountMatch = req.match(/(\d+)\+?\s+files?/);
-  const fileCount = fileCountMatch ? parseInt(fileCountMatch[1]) : 0;
-  return longRunningKeywords.some(kw => req.includes(kw)) || fileCount > 10;
-}
-
 /**
  * Check zero-touch eligibility for a feature (requires trust-manager)
  * @param {string} feature
@@ -467,14 +389,14 @@ export function detectLongRunningNeed(userRequest) {
  */
 export async function checkZeroTouchEligibility(feature) {
   try {
-    const { getTrustLevel } = await import('../../lib/trust/trust-manager.js').catch(() => ({
-      getTrustLevel: null
+    const { getTrust } = await import('../../lib/trust/trust-manager.js').catch(() => ({
+      getTrust: null
     }));
 
-    if (!getTrustLevel) return false;
+    if (!getTrust) return false;
 
-    const level = getTrustLevel(feature);
-    return level === 'maximum';
+    const trust = getTrust(feature);
+    return trust.level === 'auto';
   } catch {
     return false;
   }