wogiflow 2.4.2 → 2.4.3

package/scripts/flow-loop-retry-learning.js

@@ -15,11 +15,10 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { getConfig, getProjectRoot, colors, readJson, info, success } = require('./flow-utils');
+const { getConfig, getProjectRoot, colors, readJson, info, success, PATHS } = require('./flow-utils');
 const { FailureCategory, detectCategory } = require('./flow-failure-categories');
 
-const PROJECT_ROOT = getProjectRoot();
-const LEARNING_LOG_PATH = path.join(PROJECT_ROOT, '.workflow', 'state', 'adaptive-learning.json');
+const LEARNING_LOG_PATH = path.join(PATHS.state, 'adaptive-learning.json');
 
 // ============================================================================
 // Root Cause Categories

package/scripts/flow-lsp.js

@@ -327,7 +327,7 @@ class LSPClient {
     });
 
     // Wait a bit for the server to process
-    await new Promise(r => setTimeout(r, 100));
+    await require('node:timers/promises').setTimeout(100);
 
     return uri;
   }
@@ -419,7 +419,7 @@ class LSPClient {
     const uri = await this.openDocument(filePath);
 
     // Wait for diagnostics to be pushed
-    await new Promise(r => setTimeout(r, 500));
+    await require('node:timers/promises').setTimeout(500);
 
     const diagnostics = this.diagnosticsCache.get(uri) || [];
 
@@ -916,7 +916,7 @@ module.exports = {
 };
 
 if (require.main === module) {
-  main().catch(e => {
+  main().catch(err => {
     error(err.message);
     process.exit(1);
   });

package/scripts/flow-mcp-docs.js

@@ -27,9 +27,8 @@ const { color, printHeader, printSection, success } = require('./flow-output');;
 // Configuration
 // ============================================================
 
-const PROJECT_ROOT = getProjectRoot();
-const MCP_DOCS_PATH = path.join(PROJECT_ROOT, '.workflow', 'state', 'mcp-tools.json');
-const DOCS_OUTPUT_PATH = path.join(PROJECT_ROOT, '.claude', 'docs', 'knowledge-base', '05-development-tools', 'mcp-tools-generated.md');
+const MCP_DOCS_PATH = path.join(PATHS.state, 'mcp-tools.json');
+const DOCS_OUTPUT_PATH = path.join(PATHS.root, '.claude', 'docs', 'knowledge-base', '05-development-tools', 'mcp-tools-generated.md');
 
 // Known MCP server locations in this project
 const MCP_SERVER_PATHS = [
@@ -46,7 +45,7 @@ const MCP_SERVER_PATHS = [
  * @returns {Object[]} Array of tool definitions
  */
 function extractToolsFromFile(filePath) {
-  const fullPath = path.join(PROJECT_ROOT, filePath);
+  const fullPath = path.join(PATHS.root, filePath);
 
   if (!fileExists(fullPath)) {
     return [];

package/scripts/flow-memory-db.js

@@ -10,7 +10,7 @@
  *
  * Features:
  * - SQLite database with sql.js
- * - Embeddings via @xenova/transformers
+ * - Embeddings via @huggingface/transformers
  * - Facts, proposals, and PRD storage
  * - Semantic similarity search
  *
@@ -54,10 +54,8 @@ const DEFAULTS = {
 // Configuration
 // ============================================================
 
-const { getProjectRoot } = require('./flow-paths');
-const PROJECT_ROOT = getProjectRoot();
-const WORKFLOW_DIR = path.join(PROJECT_ROOT, '.workflow');
-const MEMORY_DIR = path.join(WORKFLOW_DIR, 'memory');
+const { getProjectRoot, PATHS } = require('./flow-paths');
+const MEMORY_DIR = path.join(PATHS.workflow, 'memory');
 const DB_PATH = path.join(MEMORY_DIR, 'local.db');
 
 // ============================================================
@@ -424,21 +422,21 @@ let embeddingsAvailable = null; // null = unknown, true/false after first check
 
 /**
  * Get embedder (lazy load)
- * Returns null if @xenova/transformers is not installed
+ * Returns null if @huggingface/transformers is not installed
  */
 async function getEmbedder() {
   if (embeddingsAvailable === false) return null;
 
   if (!embedder) {
     try {
-      const { pipeline } = await import('@xenova/transformers');
+      const { pipeline } = await import('@huggingface/transformers');
       embedder = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
       embeddingsAvailable = true;
     } catch (err) {
       if (err.code === 'ERR_MODULE_NOT_FOUND' || err.code === 'MODULE_NOT_FOUND') {
         embeddingsAvailable = false;
         if (process.env.DEBUG) {
-          console.warn('[DEBUG] @xenova/transformers not installed - semantic search disabled');
+          console.warn('[DEBUG] @huggingface/transformers not installed - semantic search disabled');
         }
         return null;
       }

package/scripts/flow-memory-sync.js

@@ -28,6 +28,7 @@ let _syncDecisionsToRules = null;
 function syncDecisionsToRules() {
   if (!_syncDecisionsToRules) {
     _syncDecisionsToRules = require('./flow-rules-sync').syncDecisionsToRules;
+const { PATHS } = require('./flow-utils');
   }
   return _syncDecisionsToRules();
 }
@@ -36,7 +37,7 @@ function syncDecisionsToRules() {
 // Configuration
 // ============================================================
 
-const DECISIONS_PATH = path.join(PROJECT_ROOT, '.workflow', 'state', 'decisions.md');
+const DECISIONS_PATH = PATHS.decisions;
 
 // loadConfig() removed — getConfig() already handles errors gracefully
 
@@ -249,12 +250,15 @@ async function promoteFact(factId, dryRun = false) {
     return true;
   }
 
-  // Update decisions.md
+  // Update decisions.md through orchestrator
   const newContent = appendToDecisions(formatted, decisionsContent);
-  fs.writeFileSync(DECISIONS_PATH, newContent);
-
-  // Sync to .claude/rules/ for Claude Code integration
-  syncDecisionsToRules();
+  try {
+    const { writeToDecisions } = require('./flow-learning-orchestrator');
+    await writeToDecisions({ content: newContent, entryText: fact.fact, caller: 'flow-memory-sync/promote', syncRules: true });
+  } catch (_err) {
+    fs.writeFileSync(DECISIONS_PATH, newContent);
+    syncDecisionsToRules();
+  }
 
   // Mark fact as promoted
   await memoryDb.markFactPromoted(factId, 'decisions.md');
@@ -324,15 +328,18 @@ async function autoPromote(config) {
   }
 
   if (promoted > 0) {
-    // Write decisions.md FIRST, then mark as promoted in DB
-    // This prevents data loss if process crashes between the two operations
-    fs.writeFileSync(DECISIONS_PATH, currentContent);
+    // Write decisions.md through orchestrator, then mark as promoted in DB
+    try {
+      const { writeToDecisions } = require('./flow-learning-orchestrator');
+      await writeToDecisions({ content: currentContent, caller: 'flow-memory-sync/autoPromote', skipDedup: true, syncRules: true });
+    } catch (_err) {
+      fs.writeFileSync(DECISIONS_PATH, currentContent);
+      syncDecisionsToRules();
+    }
     // Now safe to mark as promoted in DB
     for (const id of promotedIds) {
       await memoryDb.markFactPromoted(id, 'decisions.md');
     }
-    // Sync to .claude/rules/ for Claude Code integration
-    syncDecisionsToRules();
     await memoryDb.recordMemoryMetric('auto_promote');
   }
 

package/scripts/flow-metrics.js

@@ -21,8 +21,7 @@ const path = require('node:path');
 const { getProjectRoot, getConfig, PATHS, colors, showHelp: showHelpGeneric, readJson } = require('./flow-utils');
 const { success, error: errorMsg } = require('./flow-output');
 
-const PROJECT_ROOT = getProjectRoot();
-const METRICS_PATH = path.join(PROJECT_ROOT, '.workflow', 'state', 'command-metrics.json');
+const METRICS_PATH = PATHS.commandMetrics;
 
 // ============================================================
 // Metrics Data Structure

package/scripts/flow-model-adapter.js

@@ -29,9 +29,8 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { getProjectRoot, getConfig, PATHS, colors, readJson } = require('./flow-utils');
 
-const PROJECT_ROOT = getProjectRoot();
-const ADAPTERS_DIR = path.join(PROJECT_ROOT, '.workflow', 'model-adapters');
-const MODEL_STATS_PATH = path.join(PROJECT_ROOT, '.workflow', 'state', 'model-stats.json');
+const ADAPTERS_DIR = PATHS.modelAdapters;
+const MODEL_STATS_PATH = PATHS.modelStatsLegacy;
 
 // ============================================================
 // Model Detection

package/scripts/flow-model-config.js

@@ -31,13 +31,11 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { getProjectRoot, safeJsonParse, colors: c, error, success } = require('./flow-utils');
+const { getProjectRoot, safeJsonParse, safeJsonParseString, colors: c, error, success, PATHS } = require('./flow-utils');
 
-const PROJECT_ROOT = getProjectRoot();
-const WORKFLOW_DIR = path.join(PROJECT_ROOT, '.workflow');
-const CONFIG_PATH = path.join(WORKFLOW_DIR, 'config.json');
-const ENV_PATH = path.join(PROJECT_ROOT, '.env');
-const SESSION_STATE_PATH = path.join(WORKFLOW_DIR, 'state', 'session-state.json');
+const CONFIG_PATH = path.join(PATHS.workflow, 'config.json');
+const ENV_PATH = path.join(PATHS.root, '.env');
+const SESSION_STATE_PATH = path.join(PATHS.workflow, 'state', 'session-state.json');
 
 /**
  * Known provider configurations
@@ -106,7 +104,7 @@ function readConfig() {
  * @param {Object} config - Config to write
  */
 function writeConfig(config) {
-  fs.mkdirSync(WORKFLOW_DIR, { recursive: true });
+  fs.mkdirSync(PATHS.workflow, { recursive: true });
   fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
 }
 
@@ -374,8 +372,12 @@ async function testLocalProvider(endpoint) {
       res.on('data', chunk => data += chunk);
       res.on('end', () => {
         try {
-          const parsed = JSON.parse(data);
-          const models = parsed.models?.map(m => m.name) || [];
+          const parsed = safeJsonParseString(data, null);
+          if (!parsed) {
+            resolve({ success: false, message: 'Invalid JSON response from Ollama' });
+            return;
+          }
+          const models = parsed.models?.map(m => m.name) ?? [];
           resolve({
             success: true,
             message: `Connected to Ollama. Found ${models.length} models.`,
@@ -405,115 +407,81 @@ async function testLocalProvider(endpoint) {
  * Test LM Studio provider
  */
 async function testLMStudio(baseEndpoint) {
-  const http = require('node:http');
-
-  return new Promise((resolve) => {
+  try {
     // LM Studio uses OpenAI-compatible endpoint
     const endpoint = baseEndpoint.replace(':11434', ':1234');
     const url = new URL('/v1/models', endpoint);
 
-    const req = http.request(url, { method: 'GET', timeout: 5000 }, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        try {
-          const parsed = JSON.parse(data);
-          const models = parsed.data?.map(m => m.id) || [];
-          resolve({
-            success: true,
-            message: `Connected to LM Studio. Found ${models.length} models.`,
-            models,
-            provider: 'lmstudio'
-          });
-        } catch (err) {
-          resolve({ success: false, message: 'No local LLM detected' });
-        }
-      });
-    });
-
-    req.on('error', () => {
-      resolve({ success: false, message: 'No local LLM detected at localhost:11434 or :1234' });
-    });
-
-    req.end();
-  });
+    const res = await fetch(url, { method: 'GET', signal: AbortSignal.timeout(5000) });
+    const parsed = await res.json();
+    const models = parsed.data?.map(m => m.id) || [];
+    return {
+      success: true,
+      message: `Connected to LM Studio. Found ${models.length} models.`,
+      models,
+      provider: 'lmstudio'
+    };
+  } catch (_err) {
+    return { success: false, message: 'No local LLM detected at localhost:11434 or :1234' };
+  }
 }
 
 /**
  * Test cloud provider connection
  */
 async function testCloudProvider(providerName, endpoint, apiKey) {
-  const https = require('node:https');
+  let url, headers;
 
-  return new Promise((resolve, reject) => {
-    let url, headers;
-
-    switch (providerName) {
-      case 'openai':
-        url = new URL('/v1/models', endpoint);
-        headers = { 'Authorization': `Bearer ${apiKey}` };
-        break;
-      case 'google':
-        url = new URL('/v1beta/models', endpoint);
-        headers = { 'x-goog-api-key': apiKey };
-        break;
-      case 'anthropic':
-        // Anthropic doesn't have a models list endpoint, just test with a simple check
-        resolve({ success: true, message: 'API key format valid (Anthropic)' });
-        return;
-      default:
-        reject(new Error(`Unknown cloud provider: ${providerName}`));
-        return;
-    }
+  switch (providerName) {
+    case 'openai':
+      url = new URL('/v1/models', endpoint);
+      headers = { 'Authorization': `Bearer ${apiKey}` };
+      break;
+    case 'google':
+      url = new URL('/v1beta/models', endpoint);
+      headers = { 'x-goog-api-key': apiKey };
+      break;
+    case 'anthropic':
+      // Anthropic doesn't have a models list endpoint, just test with a simple check
+      return { success: true, message: 'API key format valid (Anthropic)' };
+    default:
+      throw new Error(`Unknown cloud provider: ${providerName}`);
+  }
 
-    const req = https.request(url, { method: 'GET', headers, timeout: 10000 }, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        if (res.statusCode === 200) {
-          try {
-            const parsed = JSON.parse(data);
-
-            // Check for prototype pollution in API response
-            if (hasDangerousKeys(parsed)) {
-              resolve({ success: false, message: 'Invalid API response (security check failed)' });
-              return;
-            }
-
-            let models = [];
-
-            if (providerName === 'openai') {
-              models = parsed.data?.map(m => m.id).filter(id =>
-                id.startsWith('gpt-4') || id.startsWith('o1')
-              ).slice(0, 10) || [];
-            } else if (providerName === 'google') {
-              models = parsed.models?.map(m => m.name.replace('models/', '')) || [];
-            }
-
-            resolve({
-              success: true,
-              message: `Connected to ${providerName}. Found ${models.length} models.`,
-              models
-            });
-          } catch (err) {
-            resolve({ success: true, message: `Connected to ${providerName}` });
-          }
-        } else if (res.statusCode === 401) {
-          resolve({ success: false, message: 'Invalid API key' });
-        } else {
-          resolve({ success: false, message: `API error: ${res.statusCode}` });
-        }
-      });
-    });
+  const res = await fetch(url, { method: 'GET', headers, signal: AbortSignal.timeout(10000) });
 
-    req.on('error', (err) => reject(err));
-    req.on('timeout', () => {
-      req.destroy();
-      reject(new Error('Connection timeout'));
-    });
+  if (res.status === 200) {
+    try {
+      const parsed = await res.json();
 
-    req.end();
-  });
+      // Check for prototype pollution in API response
+      if (hasDangerousKeys(parsed)) {
+        return { success: false, message: 'Invalid API response (security check failed)' };
+      }
+
+      let models = [];
+
+      if (providerName === 'openai') {
+        models = parsed.data?.map(m => m.id).filter(id =>
+          id.startsWith('gpt-4') || id.startsWith('o1')
+        ).slice(0, 10) || [];
+      } else if (providerName === 'google') {
+        models = parsed.models?.map(m => m.name.replace('models/', '')) || [];
+      }
+
+      return {
+        success: true,
+        message: `Connected to ${providerName}. Found ${models.length} models.`,
+        models
+      };
+    } catch (_err) {
+      return { success: true, message: `Connected to ${providerName}` };
+    }
+  } else if (res.status === 401) {
+    return { success: false, message: 'Invalid API key' };
+  } else {
+    return { success: false, message: `API error: ${res.status}` };
+  }
 }
 
 /**

package/scripts/flow-model-router.js

@@ -29,7 +29,7 @@ const {
   getConfig,
   printHeader,
   printSection,
-  estimateTokens
+  estimateTokens, PATHS
 } = require('./flow-utils');
 
 const { analyzeTask } = require('./flow-task-analyzer');
@@ -61,7 +61,7 @@ try {
 // Constants
 // ============================================================
 
-const CONFIG_PATH = path.join(PROJECT_ROOT, '.workflow', 'config.json');
+const CONFIG_PATH = path.join(PATHS.workflow, 'config.json');
 
 const ROUTING_STRATEGIES = {
   'quality-first': 'Select highest-capability model matching requirements',

package/scripts/flow-model-types.js

@@ -1,5 +1,3 @@
-'use strict';
-
 /**
  * Wogi Flow - Model Types & Shared Registry Access
  *

package/scripts/flow-multi-approach.js

@@ -27,11 +27,10 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { getProjectRoot, getConfig, PATHS, colors, writeJson, ensureDir, readJson } = require('./flow-utils');
+const { getProjectRoot, getConfig, PATHS, colors, writeJson, ensureDir, readJson, safeJsonParse } = require('./flow-utils');
 const { success, error: errorMsg } = require('./flow-output');
 
-const PROJECT_ROOT = getProjectRoot();
-const APPROACHES_DIR = path.join(PROJECT_ROOT, '.workflow', 'state', 'approaches');
+const APPROACHES_DIR = path.join(PATHS.state, 'approaches');
 
 // ============================================================
 // Configuration
@@ -351,9 +350,8 @@ function listSessions(limit = 10) {
   return fs.readdirSync(APPROACHES_DIR)
     .filter(f => f.endsWith('.json'))
     .map(f => {
-      const session = JSON.parse(
-        fs.readFileSync(path.join(APPROACHES_DIR, f), 'utf-8')
-      );
+      const session = safeJsonParse(path.join(APPROACHES_DIR, f), null);
+      if (!session) return null;
       return {
         id: session.id,
         task: session.task?.description?.slice(0, 50) + '...',
@@ -362,6 +360,7 @@ function listSessions(limit = 10) {
         createdAt: session.createdAt
       };
     })
+    .filter(Boolean)
     .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
     .slice(0, limit);
 }

package/scripts/flow-orchestrate-context.js

@@ -1,6 +1,4 @@
 #!/usr/bin/env node
-'use strict';
-
 /**
  * Project Context Generator - Extracted from flow-orchestrate.js
  *
@@ -17,7 +15,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { getProjectRoot, colors, getConfig } = require('./flow-utils');
+const { getProjectRoot, colors, getConfig, PATHS } = require('./flow-utils');
 const {
   buildExportMap,
   loadCachedExportMap,
@@ -26,17 +24,15 @@ const {
   setProjectRoot: setExportScannerRoot
 } = require('./flow-export-scanner');
 
-const PROJECT_ROOT = getProjectRoot();
-
 // Set export scanner project root to match
-setExportScannerRoot(PROJECT_ROOT);
+setExportScannerRoot(PATHS.root);
 
 function log(color, ...args) {
   console.log(colors[color] + args.join(' ') + colors.reset);
 }
 
 class ProjectContextGenerator {
-  constructor(projectRoot = PROJECT_ROOT) {
+  constructor(projectRoot = PATHS.root) {
     this.projectRoot = projectRoot;
     this.contextPath = path.join(projectRoot, '.workflow/state/hybrid-context.md');
     this.cacheMaxAge = 60 * 60 * 1000; // 1 hour

package/scripts/flow-orchestrate-rollback.js

@@ -1,6 +1,4 @@
 #!/usr/bin/env node
-'use strict';
-
 /**
  * Rollback Manager - Extracted from flow-orchestrate.js
  *
@@ -10,12 +8,9 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { getProjectRoot, colors } = require('./flow-utils');
+const { getProjectRoot, colors, PATHS } = require('./flow-utils');
 const { readJson } = require('./flow-io');
 
-const PROJECT_ROOT = getProjectRoot();
-const STATE_DIR = path.join(PROJECT_ROOT, '.workflow', 'state');
-
 function log(color, ...args) {
   console.log(colors[color] + args.join(' ') + colors.reset);
 }
@@ -24,7 +19,7 @@ class RollbackManager {
   constructor() {
     this.createdFiles = [];
     this.modifiedFiles = [];
-    this.checkpointPath = path.join(STATE_DIR, 'rollback-checkpoint.json');
+    this.checkpointPath = path.join(PATHS.state, 'rollback-checkpoint.json');
   }
 
   trackCreation(filePath) {
@@ -68,7 +63,7 @@ class RollbackManager {
         log('dim', `  🗑️  Deleted: ${filePath}`);
 
         let dir = path.dirname(filePath);
-        while (dir !== PROJECT_ROOT && fs.existsSync(dir)) {
+        while (dir !== PATHS.root && fs.existsSync(dir)) {
           const files = fs.readdirSync(dir);
           if (files.length === 0) {
             fs.rmdirSync(dir);

package/scripts/flow-orchestrate-state.js

@@ -1,6 +1,4 @@
 #!/usr/bin/env node
-'use strict';
-
 /**
  * State Manager - Extracted from flow-orchestrate.js
  *
@@ -10,22 +8,18 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { getProjectRoot, colors, getConfig, writeJson } = require('./flow-utils');
+const { getProjectRoot, colors, getConfig, writeJson, PATHS } = require('./flow-utils');
 const { readJson } = require('./flow-io');
 const { loadCachedExportMap } = require('./flow-export-scanner');
 const durableSession = require('./flow-durable-session');
 
-const PROJECT_ROOT = getProjectRoot();
-const WORKFLOW_DIR = path.join(PROJECT_ROOT, '.workflow');
-const STATE_DIR = path.join(WORKFLOW_DIR, 'state');
-
 function log(color, ...args) {
   console.log(colors[color] + args.join(' ') + colors.reset);
 }
 
 class StateManager {
   updateRequestLog(step, status, mode = 'hybrid', executor = '') {
-    const logPath = path.join(STATE_DIR, 'request-log.md');
+    const logPath = PATHS.requestLog;
     const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 16);
 
     const entry = `
@@ -49,7 +43,7 @@ ${step.description || ''}
   updateAppMap(update) {
     if (!update) return;
 
-    const mapPath = path.join(STATE_DIR, 'app-map.md');
+    const mapPath = PATHS.appMap;
     if (!fs.existsSync(mapPath)) return;
 
     let content = fs.readFileSync(mapPath, 'utf-8');
@@ -111,7 +105,7 @@ ${step.description || ''}
     // DEPRECATED: This path is kept for backward compatibility but will be removed
     // Enable durableSteps in config.json to use the modern session management
     console.warn('[DEPRECATED] Using legacy hybrid-session.json - enable durableSteps.enabled in config.json');
-    const sessionPath = path.join(STATE_DIR, 'hybrid-session.json');
+    const sessionPath = path.join(PATHS.state, 'hybrid-session.json');
 
     let session = {
       sessionId: `sess-${Date.now()}`,
@@ -150,7 +144,7 @@ ${step.description || ''}
     }
 
     // Legacy fallback - DEPRECATED
-    const sessionPath = path.join(STATE_DIR, 'hybrid-session.json');
+    const sessionPath = path.join(PATHS.state, 'hybrid-session.json');
     const legacySession = readJson(sessionPath, null);
     if (legacySession) {
       console.warn('[DEPRECATED] Reading legacy hybrid-session.json - enable durableSteps.enabled in config.json');
@@ -160,7 +154,7 @@ ${step.description || ''}
   }
 
   saveResults(results) {
-    const resultsPath = path.join(STATE_DIR, 'hybrid-results.json');
+    const resultsPath = path.join(PATHS.state, 'hybrid-results.json');
     fs.writeFileSync(resultsPath, JSON.stringify(results, null, 2));
   }
 
@@ -192,7 +186,7 @@ ${step.description || ''}
     };
 
     // Try to load from config (primary source)
-    const configPath = path.join(WORKFLOW_DIR, 'config.json');
+    const configPath = path.join(PATHS.workflow, 'config.json');
     const config = readJson(configPath, null);
     if (config) {
       const projectCtx = config.hybrid?.projectContext || {};
@@ -295,7 +289,7 @@ ${step.description || ''}
     }
 
     // Supplement with app-map.md if no exports found
-    const appMapPath = path.join(STATE_DIR, 'app-map.md');
+    const appMapPath = PATHS.appMap;
     if (fs.existsSync(appMapPath) && !context.availableComponents) {
       try {
         const appMap = fs.readFileSync(appMapPath, 'utf-8');