wogiflow 2.4.2 → 2.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "2.4.2",
+  "version": "2.4.4",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {
@@ -61,12 +61,12 @@
     "sql.js": "^1.14.1"
   },
   "optionalDependencies": {
-    "@babel/parser": "^7.29.0",
+    "@babel/parser": "^7.29.2",
     "@babel/traverse": "^7.29.0",
-    "@xenova/transformers": "^2.15.0"
+    "@huggingface/transformers": "^3.0.0"
   },
   "devDependencies": {
-    "eslint": "^9.0.0"
+    "eslint": "^10.0.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/scripts/MEMORY-ARCHITECTURE.md

@@ -88,7 +88,7 @@ flow knowledge-sync regenerate  # Regenerate stale files
 
 **Features**:
 - SQLite database using sql.js (pure JS)
-- Embedding generation via @xenova/transformers
+- Embedding generation via @huggingface/transformers
 - Semantic similarity search
 - Facts, proposals, and PRD chunk storage
 

package/scripts/base-workflow-step.js

@@ -0,0 +1,136 @@
+/**
+ * Wogi Flow - BaseWorkflowStep
+ *
+ * Base class for all flow-step-*.js workflow steps.
+ * Provides shared infrastructure: file filtering, context loading,
+ * validation, and result formatting.
+ *
+ * Subclasses override execute() with step-specific logic.
+ *
+ * Usage:
+ *   const { BaseWorkflowStep } = require('./base-workflow-step');
+ *
+ *   class MyStep extends BaseWorkflowStep {
+ *     constructor() {
+ *       super('myStep', {
+ *         extensions: ['.js', '.ts'],
+ *         excludeTests: true,
+ *         excludeDts: true,
+ *       });
+ *     }
+ *     async execute(files, options) {
+ *       // ... step-specific logic
+ *       return this.pass('All checks passed');
+ *     }
+ *   }
+ *
+ *   module.exports = { run: (options) => new MyStep().run(options) };
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { PATHS } = require('./flow-utils');
+
+class BaseWorkflowStep {
+  /**
+   * @param {string} name - Step identifier
+   * @param {object} [filterOpts] - File filtering options
+   * @param {string[]} [filterOpts.extensions] - File extensions to include (e.g., ['.js', '.ts'])
+   * @param {boolean} [filterOpts.excludeTests=true] - Exclude .test./.spec. files
+   * @param {boolean} [filterOpts.excludeDts=true] - Exclude .d.ts files
+   */
+  constructor(name, filterOpts = {}) {
+    this.name = name;
+    this.extensions = filterOpts.extensions ?? ['.js', '.ts', '.jsx', '.tsx'];
+    this.excludeTests = filterOpts.excludeTests ?? true;
+    this.excludeDts = filterOpts.excludeDts ?? true;
+  }
+
+  /**
+   * Main entry point — matches the `run(options)` interface expected by flow-workflow-steps.js
+   * @param {object} options
+   * @param {string[]} [options.files] - Files modified
+   * @param {object} [options.stepConfig] - Step configuration
+   * @param {string} [options.mode] - Step mode (block/warn/prompt/auto)
+   * @param {string} [options.taskType] - Task type
+   * @param {string} [options.taskId] - Task ID
+   * @param {string} [options.taskTitle] - Task title
+   * @returns {Promise<{passed: boolean, message: string, details?: any}>}
+   */
+  async run(options = {}) {
+    const { files = [], stepConfig = {}, ...rest } = options;
+
+    // Filter files to those this step cares about
+    const filteredFiles = this.filterFiles(files);
+
+    if (filteredFiles.length === 0) {
+      return this.pass(`No ${this.name}-eligible files modified`);
+    }
+
+    // Delegate to subclass
+    return await this.execute(filteredFiles, { stepConfig, ...rest });
+  }
+
+  /**
+   * Override in subclass — contains the step-specific logic.
+   * @param {string[]} files - Filtered files
+   * @param {object} options - Remaining options (stepConfig, mode, taskType, etc.)
+   * @returns {Promise<{passed: boolean, message: string, details?: any}>}
+   */
+  async execute(files, options) {
+    throw new Error(`${this.name}: execute() must be overridden`);
+  }
+
+  /**
+   * Filter files based on step's extension and exclusion rules.
+   * @param {string[]} files - Raw file list
+   * @returns {string[]} Filtered files
+   */
+  filterFiles(files) {
+    return files.filter(f => {
+      const hasExt = this.extensions.some(ext => f.endsWith(ext));
+      if (!hasExt) return false;
+      if (this.excludeTests && (f.includes('.test.') || f.includes('.spec.'))) return false;
+      if (this.excludeDts && f.endsWith('.d.ts')) return false;
+      return true;
+    });
+  }
+
+  /**
+   * Read a file safely, returning null on error.
+   * @param {string} relativePath - Path relative to project root
+   * @returns {string|null} File content or null
+   */
+  readFile(relativePath) {
+    const fullPath = path.join(PATHS.root, relativePath);
+    try {
+      if (!fs.existsSync(fullPath)) return null;
+      return fs.readFileSync(fullPath, 'utf8');
+    } catch (_err) {
+      return null;
+    }
+  }
+
+  /**
+   * Create a passing result.
+   * @param {string} message
+   * @returns {{passed: true, message: string}}
+   */
+  pass(message) {
+    return { passed: true, message };
+  }
+
+  /**
+   * Create a failing result.
+   * @param {string} message
+   * @param {any} [details]
+   * @returns {{passed: false, message: string, details?: any}}
+   */
+  fail(message, details) {
+    const result = { passed: false, message };
+    if (details !== undefined) result.details = details;
+    return result;
+  }
+}
+
+module.exports = { BaseWorkflowStep };

package/scripts/flow-adaptive-learning.js

@@ -15,7 +15,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
-const { getProjectRoot, colors } = require('./flow-utils');
+const { getProjectRoot, colors, PATHS } = require('./flow-utils');
 const { error: errorMsg } = require('./flow-output');
 const { readJson } = require('./flow-io');
 const { storeSingleLearning, getAdapterPath } = require('./flow-model-adapter');
@@ -26,9 +26,8 @@ const {
 } = require('./flow-failure-categories');
 const { validateRepoFormat, safeGitCommand, sanitizeCommitMessage } = require('./flow-security');
 
-const PROJECT_ROOT = getProjectRoot();
-const LEARNING_LOG_PATH = path.join(PROJECT_ROOT, '.workflow', 'state', 'adaptive-learning.json');
-const STRATEGY_STATS_PATH = path.join(PROJECT_ROOT, '.workflow', 'state', 'strategy-effectiveness.json');
+const LEARNING_LOG_PATH = path.join(PATHS.state, 'adaptive-learning.json');
+const STRATEGY_STATS_PATH = path.join(PATHS.state, 'strategy-effectiveness.json');
 
 // ============================================================
 // Failure Analysis
@@ -690,7 +689,7 @@ function exportLearningsForSharing() {
   }
 
   // Load model adapter files and extract learnings sections
-  const adaptersDir = path.join(PROJECT_ROOT, '.workflow', 'model-adapters');
+  const adaptersDir = PATHS.modelAdapters;
   if (fs.existsSync(adaptersDir)) {
     const adapterFiles = fs.readdirSync(adaptersDir).filter(f => f.endsWith('.md') && !f.startsWith('_'));
 
@@ -845,7 +844,7 @@ async function contributeLearnings(upstreamRepo = 'your-org/wogi-flow', options
 
   try {
     // Create contribution file
-    const contributionDir = path.join(PROJECT_ROOT, '.workflow', 'contributions');
+    const contributionDir = path.join(PATHS.workflow, 'contributions');
     if (!fs.existsSync(contributionDir)) {
       fs.mkdirSync(contributionDir, { recursive: true });
     }
@@ -935,7 +934,7 @@ async function createAutoPR(upstreamRepo, options = {}) {
 
   try {
     // Clone fork, create branch, add files, push, create PR
-    const tempDir = path.join(PROJECT_ROOT, '.workflow', 'temp-pr');
+    const tempDir = path.join(PATHS.workflow, 'temp-pr');
 
     console.log(`${colors.cyan}Creating PR automatically...${colors.reset}`);
 
@@ -1136,12 +1135,12 @@ if (require.main === module) {
       }
 
       // Save export file
-      const exportPath = path.join(PROJECT_ROOT, '.workflow', 'learnings-export.json');
+      const exportPath = path.join(PATHS.workflow, 'learnings-export.json');
       fs.writeFileSync(exportPath, JSON.stringify(data, null, 2));
       console.log(`\n${colors.green}✅ Exported to: ${exportPath}${colors.reset}`);
 
       // Also create PR-ready markdown
-      const prPath = path.join(PROJECT_ROOT, '.workflow', 'learnings-contribution.md');
+      const prPath = path.join(PATHS.workflow, 'learnings-contribution.md');
       fs.writeFileSync(prPath, formatExportForPR(data));
       console.log(`${colors.green}✅ PR-ready format: ${prPath}${colors.reset}`);
 

package/scripts/flow-aggregate.js

@@ -16,7 +16,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const readline = require('node:readline');
+const readline = require('node:readline/promises');
 const {
   PATHS,
   PROJECT_ROOT,
@@ -36,7 +36,7 @@ const { syncDecisionsToRules } = require('./flow-rules-sync');
 // ============================================================
 
 const SKILLS_DIR = PATHS.skills;
-const CORRECTIONS_DIR = path.join(PROJECT_ROOT, '.workflow', 'corrections');
+const CORRECTIONS_DIR = PATHS.corrections;
 
 // ============================================================
 // Data Collection
@@ -386,7 +386,7 @@ async function runPromotionWizard(data) {
     output: process.stdout
   });
 
-  const prompt = (q) => new Promise(r => rl.question(q, r));
+  const prompt = (q) => rl.question(q);
 
   console.log(color('cyan', 'Pattern Promotion Wizard'));
   console.log('');
@@ -435,10 +435,15 @@ function appendToDecisions(pattern) {
   const entry = `\n## ${date} - Promoted Pattern\n\n**Rule**: ${pattern}\n**Source**: Aggregated from learnings (3+ occurrences)\n\n`;
 
   content += entry;
-  writeFile(decisionsPath, content);
 
-  // Sync to .claude/rules/ for Claude Code integration
-  syncDecisionsToRules();
+  // Route through orchestrator for locking and dedup
+  try {
+    const { writeToDecisions } = require('./flow-learning-orchestrator');
+    writeToDecisions({ content, entryText: pattern, caller: 'flow-aggregate/appendToDecisions', syncRules: true }).catch(() => {});
+  } catch (_err) {
+    writeFile(decisionsPath, content);
+    syncDecisionsToRules();
+  }
 }
 
 /**

package/scripts/flow-api-index.js

@@ -15,7 +15,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { getProjectRoot, getConfig, color, success, warn, error, safeJsonParse } = require('./flow-utils');
+const { getProjectRoot, getConfig, color, success, warn, error, safeJsonParse, PATHS } = require('./flow-utils');
 const {
   findSimilarItems,
   generateAIDecisionPrompt,
@@ -24,10 +24,8 @@ const {
 } = require('./flow-semantic-match');
 const { BaseScanner, PROJECT_ROOT } = require('./flow-scanner-base');
 
-const WORKFLOW_DIR = path.join(PROJECT_ROOT, '.workflow');
-const STATE_DIR = path.join(WORKFLOW_DIR, 'state');
-const INDEX_PATH = path.join(STATE_DIR, 'api-index.json');
-const MAP_PATH = path.join(STATE_DIR, 'api-map.md');
+const INDEX_PATH = path.join(PATHS.state, 'api-index.json');
+const MAP_PATH = path.join(PATHS.state, 'api-map.md');
 
 // ============================================================
 // Configuration
@@ -568,7 +566,7 @@ class APIScanner extends BaseScanner {
    */
   save() {
     this.prune();
-    fs.mkdirSync(STATE_DIR, { recursive: true });
+    fs.mkdirSync(PATHS.state, { recursive: true });
     fs.writeFileSync(INDEX_PATH, JSON.stringify(this.registry, null, 2));
     success(`Saved to ${path.relative(PROJECT_ROOT, INDEX_PATH)}`);
   }

package/scripts/flow-assumption-detector.js

@@ -1,5 +1,3 @@
-'use strict';
-
 /**
  * Assumption Detector Library
  *

package/scripts/flow-audit.js

@@ -95,11 +95,24 @@ function findTodos() {
           if (!line) continue;
           const match = line.match(/^(.+):(\d+):(.+)$/);
           if (match) {
+            const file = match[1];
+            const text = match[3].trim();
+
+            // Exclude self-references: the TODO scanner's own code mentions
+            // TODO/FIXME/HACK as search patterns, not as actual action items.
+            // Also exclude lines that are clearly about scanning for TODOs
+            // (e.g., pattern arrays, grep invocations, variable names).
+            if (file === 'scripts/flow-audit.js') continue;
+
+            // Skip lines where the pattern appears only inside a string literal
+            // used as a search term (e.g., patterns = ['TODO', 'FIXME', ...])
+            if (/\[\s*['"](?:TODO|FIXME|HACK|WORKAROUND|TEMPORARY)['"]/.test(text)) continue;
+
             results.push({
               type: pattern,
-              file: match[1],
+              file,
               line: parseInt(match[2], 10),
-              text: match[3].trim()
+              text
             });
           }
         }

package/scripts/flow-auto-context.js

@@ -55,8 +55,6 @@ try {
   // Smart context gatherer not available - that's ok
 }
 
-const PROJECT_ROOT = getProjectRoot();
-
 // ============================================================
 // Index Freshness Check
 // ============================================================
@@ -241,7 +239,7 @@ function inferTaskType(keywords) {
  */
 function searchTraces(keywords) {
   const results = [];
-  const tracesDir = path.join(PATHS.traces || path.join(PATHS.workflow, 'traces'));
+  const tracesDir = path.join(PATHS.traces || PATHS.traces);
 
   if (!fs.existsSync(tracesDir)) return results;
 
@@ -278,7 +276,7 @@ function searchTraces(keywords) {
 
           results.push({
             source: 'trace',
-            path: path.relative(PROJECT_ROOT, tracePath),
+            path: path.relative(PATHS.root, tracePath),
             name: traceName,
             query: queryMatch ? queryMatch[1] : traceName,
             status: statusMatch ? statusMatch[1] : 'unknown',
@@ -415,7 +413,7 @@ function searchComponentIndex(keywords, config = null) {
  */
 function grepCodebase(keywords, maxResults = 10, config = null) {
   const results = [];
-  const srcDir = path.join(PROJECT_ROOT, 'src');
+  const srcDir = path.join(PATHS.root, 'src');
 
   if (!fs.existsSync(srcDir)) return results;
 
@@ -453,7 +451,7 @@ function grepCodebase(keywords, maxResults = 10, config = null) {
       for (const file of files) {
         if (results.length >= effectiveMaxResults) break;
 
-        const relPath = path.relative(PROJECT_ROOT, file);
+        const relPath = path.relative(PATHS.root, file);
         if (!results.some(r => r.path === relPath)) {
           // Optionally read file content with truncation
           let content = null;
@@ -637,11 +635,9 @@ async function enrichWithLSP(fileResults, config) {
   if (filesToEnrich.length === 0) return fileResults;
 
   try {
-    // Create timeout with cleanup to prevent resource leak
-    let timeoutId;
-    const timeoutPromise = new Promise(resolve => {
-      timeoutId = setTimeout(() => resolve(filesToEnrich), timeout);
-    });
+    // Create timeout with cleanup using AbortController
+    const ac = new AbortController();
+    const timeoutPromise = require('node:timers/promises').setTimeout(timeout, filesToEnrich, { signal: ac.signal }).catch(() => filesToEnrich);
 
     const enriched = await Promise.race([
       Promise.all(filesToEnrich.map(async (result) => {
@@ -670,7 +666,7 @@ async function enrichWithLSP(fileResults, config) {
     ]);
 
     // Clean up timeout to prevent resource leak
-    clearTimeout(timeoutId);
+    ac.abort();
 
     // Merge enriched results back into full list
     const enrichedMap = new Map(enriched.map(r => [r.path, r]));

package/scripts/flow-auto-learn.js

@@ -202,6 +202,7 @@ function loadAutoPatterns() {
 
 /**
  * Save auto-captured patterns back to feedback-patterns.md
+ * Routes through the learning orchestrator for locking and dedup.
  * @param {Array} patterns - Array of pattern objects
  */
 function saveAutoPatterns(patterns) {
@@ -211,31 +212,35 @@ function saveAutoPatterns(patterns) {
   }
 
   try {
-    let content = fs.readFileSync(FEEDBACK_PATTERNS_PATH, 'utf-8');
+    const { modifyFeedbackPatterns } = require('./flow-learning-orchestrator');
 
-    // Build new table (using DRY constants)
-    const rows = patterns.map(p =>
-      `| ${p.date} | ${p.pattern} | ${p.source} | ${p.count} | ${p.confidence}% | ${p.status} |`
-    );
+    modifyFeedbackPatterns((currentContent) => {
+      let content = currentContent;
 
-    const newSection = `${TABLE_FORMAT.sectionHeader}\n\n${TABLE_FORMAT.header}\n${TABLE_FORMAT.separator}\n${rows.join('\n')}`;
-
-    // Replace or add section
-    if (content.includes('## Auto-Captured Patterns')) {
-      content = content.replace(
-        /## Auto-Captured Patterns[\s\S]*?(?=\n## |\n---\n\n## |$)/,
-        newSection + '\n\n'
+      // Build new table (using DRY constants)
+      const rows = patterns.map(p =>
+        `| ${p.date} | ${p.pattern} | ${p.source} | ${p.count} | ${p.confidence}% | ${p.status} |`
       );
-    } else {
-      // Add before "## Promotion History" or at the end
-      if (content.includes('## Promotion History')) {
-        content = content.replace('## Promotion History', newSection + '\n\n---\n\n## Promotion History');
+
+      const newSection = `${TABLE_FORMAT.sectionHeader}\n\n${TABLE_FORMAT.header}\n${TABLE_FORMAT.separator}\n${rows.join('\n')}`;
+
+      // Replace or add section
+      if (content.includes('## Auto-Captured Patterns')) {
+        content = content.replace(
+          /## Auto-Captured Patterns[\s\S]*?(?=\n## |\n---\n\n## |$)/,
+          newSection + '\n\n'
+        );
       } else {
-        content = content.trimEnd() + '\n\n---\n\n' + newSection + '\n';
+        // Add before "## Promotion History" or at the end
+        if (content.includes('## Promotion History')) {
+          content = content.replace('## Promotion History', newSection + '\n\n---\n\n## Promotion History');
+        } else {
+          content = content.trimEnd() + '\n\n---\n\n' + newSection + '\n';
+        }
       }
-    }
 
-    fs.writeFileSync(FEEDBACK_PATTERNS_PATH, content, 'utf-8');
+      return { content, entryText: null }; // Bulk rewrite, no single entry dedup
+    }, { caller: 'flow-auto-learn/saveAutoPatterns', skipDedup: true });
   } catch (err) {
     warn(`Could not save feedback-patterns.md: ${err.message}`);
   }
@@ -449,6 +454,7 @@ function handlePromotion(pattern, config) {
 
 /**
  * Promote pattern to decisions.md
+ * Routes through the learning orchestrator for locking and dedup.
  * @param {Object} pattern - Pattern to promote
  */
 function promoteToDecisions(pattern) {
@@ -458,37 +464,39 @@ function promoteToDecisions(pattern) {
   }
 
   try {
-    let content = fs.readFileSync(DECISIONS_PATH, 'utf-8');
+    const { modifyDecisions } = require('./flow-learning-orchestrator');
+    const today = getTodayDate();
+    const escapedPattern = pattern.pattern.replace(/[#*_\[\]()\\]/g, '\\$&');
 
-    // Find Coding Standards section
-    const sectionHeader = '## Coding Standards';
+    modifyDecisions((currentContent) => {
+      let content = currentContent;
 
-    if (!content.includes(sectionHeader)) {
-      warn(`Could not promote pattern: Coding Standards section not found in decisions.md`);
-      return;
-    }
+      // Find Coding Standards section
+      const sectionHeader = '## Coding Standards';
 
-    // Generate rule entry (escape markdown special characters in pattern name)
-    const today = getTodayDate();
-    const escapedPattern = pattern.pattern.replace(/[#*_\[\]()\\]/g, '\\$&');
-    const ruleEntry = `\n### ${escapedPattern} (${today})
+      if (!content.includes(sectionHeader)) {
+        warn(`Could not promote pattern: Coding Standards section not found in decisions.md`);
+        return null;
+      }
+
+      // Generate rule entry
+      const ruleEntry = `\n### ${escapedPattern} (${today})
 **Source**: Auto-learned from ${pattern.count} occurrences (${pattern.source})
 **Rule**: [Describe the pattern rule here]
 `;
 
-    // Insert after Coding Standards header
-    const insertPoint = content.indexOf(sectionHeader) + sectionHeader.length;
-    const nextSection = content.indexOf('\n## ', insertPoint);
+      // Insert after Coding Standards header
+      const insertPoint = content.indexOf(sectionHeader) + sectionHeader.length;
+      const nextSection = content.indexOf('\n## ', insertPoint);
 
-    if (nextSection > insertPoint) {
-      // Insert before next section
-      content = content.slice(0, nextSection) + ruleEntry + content.slice(nextSection);
-    } else {
-      // Append to section
-      content = content.slice(0, insertPoint) + ruleEntry + content.slice(insertPoint);
-    }
+      if (nextSection > insertPoint) {
+        content = content.slice(0, nextSection) + ruleEntry + content.slice(nextSection);
+      } else {
+        content = content.slice(0, insertPoint) + ruleEntry + content.slice(insertPoint);
+      }
 
-    fs.writeFileSync(DECISIONS_PATH, content, 'utf-8');
+      return { content, entryText: pattern.pattern };
+    }, { caller: 'flow-auto-learn/promoteToDecisions', syncRules: true });
 
     // Update pattern status
     const patterns = loadAutoPatterns();
@@ -497,14 +505,6 @@ function promoteToDecisions(pattern) {
       updated.status = 'Promoted';
       saveAutoPatterns(patterns);
     }
-
-    // Sync rules
-    try {
-      require('./flow-rules-sync');
-    } catch (syncErr) {
-      // Log the failure for debugging
-      info(`Note: Rules sync skipped - ${syncErr.code === 'MODULE_NOT_FOUND' ? 'module not found' : syncErr.message}`);
-    }
   } catch (err) {
     warn(`Could not promote to decisions.md: ${err.message}`);
   }

package/scripts/flow-background.js

@@ -23,15 +23,14 @@ const {
   fileExists,
   color,
   printHeader,
-  printSection, success } = require('./flow-utils');
+  printSection, success, PATHS } = require('./flow-utils');
 
 // ============================================================
 // Configuration
 // ============================================================
 
-const PROJECT_ROOT = getProjectRoot();
-const BACKGROUND_STATE_PATH = path.join(PROJECT_ROOT, '.workflow', 'state', 'background-tasks.json');
-const LOGS_DIR = path.join(PROJECT_ROOT, '.workflow', 'logs');
+const BACKGROUND_STATE_PATH = path.join(PATHS.state, 'background-tasks.json');
+const LOGS_DIR = PATHS.logs;
 
 // Available background tasks with their configurations
 const AVAILABLE_TASKS = {
@@ -141,7 +140,7 @@ function runBackgroundTask(taskName, options = {}) {
     throw new Error(`Unknown task: ${taskName}. Use 'flow background list' to see available tasks.`);
   }
 
-  const scriptPath = path.join(PROJECT_ROOT, 'scripts', taskConfig.script);
+  const scriptPath = path.join(PATHS.root, 'scripts', taskConfig.script);
 
   if (!fileExists(scriptPath)) {
     throw new Error(`Script not found: ${taskConfig.script}`);
@@ -163,7 +162,7 @@ function runBackgroundTask(taskName, options = {}) {
 
   // Spawn the process
   const child = spawn('node', [scriptPath, ...args], {
-    cwd: PROJECT_ROOT,
+    cwd: PATHS.root,
     detached: true,
     stdio: ['ignore', 'pipe', 'pipe'],
     env: { ...process.env, BACKGROUND_TASK: 'true', TASK_ID: taskId }

package/scripts/flow-bridge-state.js

@@ -18,14 +18,12 @@ const path = require('node:path');
 const crypto = require('node:crypto');
 
 // Import canonical safeJsonParse from flow-utils (consolidated per code review)
-const { safeJsonParse } = require('./flow-utils');
+const { safeJsonParse, PATHS } = require('./flow-utils');
 
 // Project paths
 const PROJECT_ROOT = path.resolve(__dirname, '..');
-const WORKFLOW_DIR = path.join(PROJECT_ROOT, '.workflow');
-const STATE_DIR = path.join(WORKFLOW_DIR, 'state');
-const CONFIG_PATH = path.join(WORKFLOW_DIR, 'config.json');
-const SYNC_STATE_PATH = path.join(STATE_DIR, 'bridge-sync.json');
+const CONFIG_PATH = path.join(PATHS.workflow, 'config.json');
+const SYNC_STATE_PATH = path.join(PATHS.state, 'bridge-sync.json');
 
 // CLI type to output file mapping (Claude Code only)
 const CLI_OUTPUT_FILES = {
@@ -60,7 +58,7 @@ function getTemplateChecksum(cliType) {
     const templateName = CLI_TEMPLATES[cliType];
     if (!templateName) return '';
 
-    const templatePath = path.join(WORKFLOW_DIR, 'templates', templateName);
+    const templatePath = path.join(PATHS.workflow, 'templates', templateName);
     const content = fs.readFileSync(templatePath, 'utf-8');
     return crypto.createHash('md5').update(content).digest('hex');
   } catch (_err) {
@@ -94,8 +92,8 @@ function readSyncState() {
 function writeSyncState(state) {
   try {
     // Ensure state directory exists
-    if (!fs.existsSync(STATE_DIR)) {
-      fs.mkdirSync(STATE_DIR, { recursive: true });
+    if (!fs.existsSync(PATHS.state)) {
+      fs.mkdirSync(PATHS.state, { recursive: true });
     }
     fs.writeFileSync(SYNC_STATE_PATH, JSON.stringify(state, null, 2));
   } catch (err) {
@@ -220,7 +218,7 @@ async function autoSyncBridge(cliType = 'claude-code', options = {}) {
   // Load bridges module
   let bridges;
   try {
-    bridges = require(path.join(PROJECT_ROOT, '.workflow', 'bridges'));
+    bridges = require(PATHS.bridges);
   } catch (err) {
     if (process.env.DEBUG) {
       console.error(`[bridge-state] Failed to load bridges: ${err.message}`);
@@ -294,7 +292,7 @@ function getSyncStatus() {
   const check = needsSync(cliType);
   const outputPath = getOutputFilePath(cliType);
   const templateName = CLI_TEMPLATES[cliType];
-  const templatePath = templateName ? path.join(WORKFLOW_DIR, 'templates', templateName) : null;
+  const templatePath = templateName ? path.join(PATHS.workflow, 'templates', templateName) : null;
 
   return {
     'claude-code': {

package/scripts/flow-bulk-loop.js

@@ -339,9 +339,7 @@ async function runCompact() {
  * Sleep for specified milliseconds
  * @param {number} ms - Milliseconds to sleep
  */
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
+const { setTimeout: sleep } = require('node:timers/promises');
 
 /**
  * Format duration in human-readable form