wogiflow 1.1.1 → 1.1.3

package/.workflow/bridges/base-bridge.js

@@ -400,13 +400,112 @@ class BaseBridge {
 
   // ==================== Template Utility Methods ====================
 
+  /**
+   * Get the package root directory (where wogiflow is installed)
+   * @returns {string|null} Package root path or null if not found
+   */
+  getPackageRoot() {
+    // Try to find the package by looking up from scripts directory
+    const possibleRoots = [
+      path.resolve(__dirname, '..', '..'),  // From .workflow/bridges/ -> package root
+      path.resolve(__dirname, '..', '..', '..', 'node_modules', 'wogiflow'),  // From project
+    ];
+
+    for (const root of possibleRoots) {
+      const pkgPath = path.join(root, 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+          if (pkg.name === 'wogiflow') {
+            return root;
+          }
+        } catch {
+          // Continue to next option
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Check if a template file is outdated/stub
+   * @param {string} templatePath - Path to template file
+   * @returns {boolean} True if template appears to be outdated
+   */
+  isTemplateOutdated(templatePath) {
+    if (!fs.existsSync(templatePath)) {
+      return true;
+    }
+
+    try {
+      const content = fs.readFileSync(templatePath, 'utf-8');
+
+      // Check for stub/placeholder markers
+      const stubMarkers = [
+        'Full implementation pending',
+        'stub template',
+        'not yet implemented',
+        'TODO: implement',
+        'placeholder template'
+      ];
+
+      for (const marker of stubMarkers) {
+        if (content.toLowerCase().includes(marker.toLowerCase())) {
+          return true;
+        }
+      }
+
+      // Check if template is too short (likely incomplete)
+      if (content.length < 500) {
+        return true;
+      }
+
+      return false;
+    } catch {
+      return true;
+    }
+  }
+
+  /**
+   * Get template path, preferring package template if project template is outdated
+   * @param {string} templateName - Template filename (e.g., 'gemini-md.hbs')
+   * @returns {string|null} Path to best available template
+   */
+  getBestTemplatePath(templateName) {
+    const projectTemplate = path.join(this.projectDir, this.workflowDir, 'templates', templateName);
+
+    // If project template exists and is not outdated, use it
+    if (!this.isTemplateOutdated(projectTemplate)) {
+      return projectTemplate;
+    }
+
+    // Try to use package template instead
+    const packageRoot = this.getPackageRoot();
+    if (packageRoot) {
+      const packageTemplate = path.join(packageRoot, '.workflow', 'templates', templateName);
+      if (fs.existsSync(packageTemplate)) {
+        this.log(`Using package template for ${templateName} (project template outdated)`);
+        return packageTemplate;
+      }
+    }
+
+    // Fall back to project template even if outdated
+    if (fs.existsSync(projectTemplate)) {
+      return projectTemplate;
+    }
+
+    return null;
+  }
+
   /**
    * Load a partial template from .workflow/templates/partials/
+   * Checks both project and package directories
    * @param {string} partialName - Name of the partial (without .hbs extension)
    * @returns {string} Partial content or empty string if not found
    */
   loadPartial(partialName) {
-    const partialPath = path.join(
+    // Try project partials first
+    const projectPartialPath = path.join(
       this.projectDir,
       this.workflowDir,
       'templates',
@@ -415,12 +514,33 @@ class BaseBridge {
     );
 
     try {
-      if (fs.existsSync(partialPath)) {
-        return fs.readFileSync(partialPath, 'utf-8');
+      if (fs.existsSync(projectPartialPath)) {
+        return fs.readFileSync(projectPartialPath, 'utf-8');
       }
     } catch (err) {
-      this.log(`Warning: Could not load partial ${partialName}: ${err.message}`);
+      this.log(`Warning: Could not load project partial ${partialName}: ${err.message}`);
+    }
+
+    // Try package partials as fallback
+    const packageRoot = this.getPackageRoot();
+    if (packageRoot) {
+      const packagePartialPath = path.join(
+        packageRoot,
+        '.workflow',
+        'templates',
+        'partials',
+        `${partialName}.hbs`
+      );
+
+      try {
+        if (fs.existsSync(packagePartialPath)) {
+          return fs.readFileSync(packagePartialPath, 'utf-8');
+        }
+      } catch (err) {
+        this.log(`Warning: Could not load package partial ${partialName}: ${err.message}`);
+      }
     }
+
     return '';
   }
 

package/.workflow/bridges/claude-bridge.js

@@ -45,11 +45,9 @@ class ClaudeBridge extends BaseBridge {
    * @returns {string} Generated CLAUDE.md content
    */
   generateRulesContent(config) {
-    const projectName = config.projectName || 'Project';
-
-    // Check if custom template exists
-    const templatePath = path.join(this.projectDir, this.workflowDir, 'templates', 'claude-md.hbs');
-    if (fs.existsSync(templatePath)) {
+    // Use getBestTemplatePath to find the best template (prefers package over outdated project)
+    const templatePath = this.getBestTemplatePath('claude-md.hbs');
+    if (templatePath) {
       return this.generateFromTemplate(templatePath, config);
     }
 

package/.workflow/bridges/codex-bridge.js

@@ -81,8 +81,8 @@ class CodexBridge extends BaseBridge {
       this.registerPartials();
 
       try {
-        const templatePath = path.join(this.projectDir, this.workflowDir, 'templates', 'agents-md.hbs');
-        if (fs.existsSync(templatePath)) {
+        const templatePath = this.getBestTemplatePath('agents-md.hbs');
+        if (templatePath) {
           const templateSource = fs.readFileSync(templatePath, 'utf-8');
           const template = Handlebars.compile(templateSource);
           return template(context);

package/.workflow/bridges/cursor-bridge.js

@@ -88,8 +88,8 @@ class CursorBridge extends BaseBridge {
       // Register partials before compiling
       this.registerPartials();
 
-      const templatePath = path.join(this.projectDir, this.workflowDir, 'templates', 'cursor-rules.mdc.hbs');
-      if (fs.existsSync(templatePath)) {
+      const templatePath = this.getBestTemplatePath('cursor-rules.mdc.hbs');
+      if (templatePath) {
         try {
           const templateSource = fs.readFileSync(templatePath, 'utf-8');
           const template = Handlebars.compile(templateSource);

package/.workflow/bridges/gemini-bridge.js

@@ -58,9 +58,9 @@ class GeminiBridge extends BaseBridge {
    * @returns {string} Generated GEMINI.md content
    */
   generateRulesContent(config) {
-    // Check if custom template exists
-    const templatePath = path.join(this.projectDir, this.workflowDir, 'templates', 'gemini-md.hbs');
-    if (fs.existsSync(templatePath)) {
+    // Use getBestTemplatePath to find the best template (prefers package over outdated project)
+    const templatePath = this.getBestTemplatePath('gemini-md.hbs');
+    if (templatePath) {
       return this.generateFromTemplate(templatePath, config);
     }
 

package/.workflow/bridges/index.js

@@ -92,23 +92,53 @@ function getCliType(projectDir = process.cwd()) {
   }
 }
 
+/**
+ * Detect which CLI is currently running based on environment
+ * @param {string} projectDir - Project root directory
+ * @returns {string} Detected CLI type
+ */
+function detectRunningCli(projectDir = process.cwd()) {
+  // Priority 1: Environment variables set by CLI tools
+  if (process.env.CLAUDE_CODE_ENTRY_POINT) return 'claude-code';
+  if (process.env.CURSOR_SESSION_ID) return 'cursor';
+  if (process.env.OPENCODE_SESSION) return 'opencode';
+
+  // Priority 2: Check caller stack for hook path hints
+  try {
+    const stack = new Error().stack || '';
+    if (stack.includes('/claude-code/')) return 'claude-code';
+    if (stack.includes('/gemini-cli/')) return 'gemini-cli';
+    if (stack.includes('/cursor/')) return 'cursor';
+    if (stack.includes('/opencode/')) return 'opencode';
+  } catch {
+    // Ignore stack parsing errors
+  }
+
+  // Priority 3: Config file setting
+  return getCliType(projectDir);
+}
+
 /**
  * Get the bridge instance for the current CLI type
  * @param {Object} options - Options to pass to bridge constructor
  * @param {string} options.projectDir - Project root directory
+ * @param {string} options.cliType - Override CLI type (optional)
  * @param {boolean} options.verbose - Enable verbose logging
  * @returns {BaseBridge} Bridge instance
  */
 function getBridge(options = {}) {
   const projectDir = options.projectDir || process.cwd();
-  const cliType = getCliType(projectDir);
+  // Allow explicit CLI type override, otherwise detect from config
+  const cliType = options.cliType || getCliType(projectDir);
 
   loadBridges();
 
   const BridgeLoader = bridges[cliType];
   if (!BridgeLoader) {
     // If no specific bridge exists, return null (manual mode)
-    console.warn(`No bridge available for CLI type: ${cliType}`);
+    if (options.verbose) {
+      console.warn(`No bridge available for CLI type: ${cliType}`);
+    }
     return null;
   }
 
@@ -122,16 +152,18 @@ function getBridge(options = {}) {
 /**
  * Sync the current CLI bridge
  * @param {Object} options - Options
+ * @param {string} options.cliType - Override CLI type (optional)
  * @returns {Object} Sync result
  */
 async function syncBridge(options = {}) {
   const bridge = getBridge(options);
+  const cliType = options.cliType || getCliType(options.projectDir);
 
   if (!bridge) {
     return {
       success: false,
       error: 'No bridge available for current CLI type',
-      cliType: getCliType(options.projectDir)
+      cliType
     };
   }
 
@@ -161,6 +193,7 @@ module.exports = {
   getBridge,
   syncBridge,
   getCliType,
+  detectRunningCli,
   listAvailableBridges,
   isBridgeAvailable,
   BaseBridge: require('./base-bridge')

package/.workflow/bridges/kimi-bridge.js

@@ -88,11 +88,11 @@ class KimiBridge extends BaseBridge {
 
       try {
         // Try kimi-specific template first, fall back to generic agents-md.hbs
-        let templatePath = path.join(this.projectDir, this.workflowDir, 'templates', 'kimi-agents-md.hbs');
-        if (!fs.existsSync(templatePath)) {
-          templatePath = path.join(this.projectDir, this.workflowDir, 'templates', 'agents-md.hbs');
+        let templatePath = this.getBestTemplatePath('kimi-agents-md.hbs');
+        if (!templatePath) {
+          templatePath = this.getBestTemplatePath('agents-md.hbs');
         }
-        if (fs.existsSync(templatePath)) {
+        if (templatePath) {
           let templateSource;
           try {
             templateSource = fs.readFileSync(templatePath, 'utf-8');

package/.workflow/bridges/opencode-bridge.js

@@ -84,8 +84,8 @@ class OpenCodeBridge extends BaseBridge {
       this.registerPartials();
 
       try {
-        const templatePath = path.join(this.projectDir, this.workflowDir, 'templates', 'opencode-agents-md.hbs');
-        if (fs.existsSync(templatePath)) {
+        const templatePath = this.getBestTemplatePath('opencode-agents-md.hbs');
+        if (templatePath) {
           const templateSource = fs.readFileSync(templatePath, 'utf-8');
           const template = Handlebars.compile(templateSource);
           return template(context);

package/lib/installer.js

@@ -322,6 +322,31 @@ function createWorkflowStructure(projectRoot, config) {
   console.log('  Created .workflow/ directory structure');
 }
 
+/**
+ * CLI-specific resource mappings
+ * Maps CLI keys to their package source directories and output file names
+ */
+const CLI_RESOURCES = {
+  claude: {
+    packageDir: '.claude',
+    rulesFile: 'CLAUDE.md',
+    templateName: 'claude-md.hbs',
+    subdirs: ['commands', 'docs', 'rules', 'skills']
+  },
+  gemini: {
+    packageDir: '.claude', // Share Claude's resources as base, bridge customizes output
+    rulesFile: 'GEMINI.md',
+    templateName: 'gemini-md.hbs',
+    subdirs: ['commands', 'docs', 'rules', 'skills']
+  },
+  opencode: {
+    packageDir: '.claude',
+    rulesFile: '.opencode/agents.md',
+    templateName: 'opencode-agents-md.hbs',
+    subdirs: ['docs', 'skills']
+  }
+};
+
 /**
  * Create CLI-specific configuration
  * @param {string} projectRoot - Project root directory
@@ -338,45 +363,48 @@ function createCLIConfig(projectRoot, cliKey, config) {
   const cliDir = path.join(projectRoot, cli.dir);
   fs.mkdirSync(cliDir, { recursive: true });
 
-  // Create CLI-specific config file and copy resources
-  if (cliKey === 'claude') {
-    // Copy commands from package
-    const packageCommands = path.join(PACKAGE_ROOT, '.claude', 'commands');
-    const projectCommands = path.join(cliDir, 'commands');
-    if (fs.existsSync(packageCommands)) {
-      copyDir(packageCommands, projectCommands);
-      console.log('  Copied .claude/commands/ (slash commands)');
-    }
+  // Get CLI-specific resource configuration
+  const resources = CLI_RESOURCES[cliKey];
+  if (!resources) {
+    console.log(`  ${cli.name} will be configured via bridge sync`);
+    console.log(`  Configured ${cli.name}`);
+    return;
+  }
 
-    // Copy docs from package
-    const packageDocs = path.join(PACKAGE_ROOT, '.claude', 'docs');
-    const projectDocs = path.join(cliDir, 'docs');
-    if (fs.existsSync(packageDocs)) {
-      copyDir(packageDocs, projectDocs);
-      console.log('  Copied .claude/docs/ (documentation)');
+  // Copy common subdirectories (commands, docs, rules, skills)
+  const packageCliDir = path.join(PACKAGE_ROOT, resources.packageDir);
+  for (const subdir of resources.subdirs) {
+    const packageSubdir = path.join(packageCliDir, subdir);
+    const projectSubdir = path.join(cliDir, subdir);
+    if (fs.existsSync(packageSubdir)) {
+      copyDir(packageSubdir, projectSubdir);
+      console.log(`  Copied ${cli.dir}/${subdir}/`);
     }
+  }
 
-    // Copy rules from package
-    const packageRules = path.join(PACKAGE_ROOT, '.claude', 'rules');
-    const projectRules = path.join(cliDir, 'rules');
-    if (fs.existsSync(packageRules)) {
-      copyDir(packageRules, projectRules);
-      console.log('  Copied .claude/rules/ (coding rules)');
+  // Generate the rules/instructions file (CLAUDE.md, GEMINI.md, etc.)
+  // First try to use the bridge for proper template rendering
+  try {
+    const bridgesPath = path.join(projectRoot, '.workflow', 'bridges');
+    if (fs.existsSync(bridgesPath)) {
+      const bridges = require(bridgesPath);
+      const bridge = bridges.getBridge({ projectDir: projectRoot, cliType: cliKey === 'claude' ? 'claude-code' : cliKey === 'gemini' ? 'gemini-cli' : cliKey, verbose: false });
+      if (bridge) {
+        bridge.generateRulesFile();
+        console.log(`  Created ${resources.rulesFile} (via bridge)`);
+        console.log(`  Configured ${cli.name}`);
+        return;
+      }
     }
-
-    // Copy skills from package (base skills only)
-    const packageSkills = path.join(PACKAGE_ROOT, '.claude', 'skills');
-    const projectSkills = path.join(cliDir, 'skills');
-    if (fs.existsSync(packageSkills)) {
-      copyDir(packageSkills, projectSkills);
-      console.log('  Copied .claude/skills/ (base skills)');
+  } catch (err) {
+    // Bridge not available yet - fall through to simple generation
+    if (process.env.DEBUG) {
+      console.log(`  Bridge not available: ${err.message}`);
     }
+  }
 
-    // Generate CLAUDE.md from template
-    const claudeMdTemplate = path.join(PACKAGE_ROOT, '.workflow', 'templates', 'claude-md.hbs');
-    if (fs.existsSync(claudeMdTemplate)) {
-      // For now, create a simple CLAUDE.md - the bridge will regenerate with full template
-      const claudeMd = `# Project Instructions
+  // Fallback: Create a simple rules file - the bridge will regenerate with full template
+  const simpleContent = `# Project Instructions
 
 You are an AI development assistant using the WogiFlow methodology v1.0.
 
@@ -394,13 +422,25 @@ cat .workflow/state/ready.json # Check tasks
 - \`/wogi-status\` - Project overview
 - \`/wogi-health\` - Check workflow health
 
+Run \`flow bridge sync\` to regenerate this file with full template.
+
 Generated by Wogi Flow v${config.version}
 `;
-      fs.writeFileSync(path.join(projectRoot, 'CLAUDE.md'), claudeMd);
-      console.log('  Created CLAUDE.md');
-    }
+
+  // Determine output path (handle nested paths like .opencode/agents.md)
+  const rulesFilePath = resources.rulesFile.includes('/')
+    ? path.join(projectRoot, resources.rulesFile)
+    : path.join(projectRoot, resources.rulesFile);
+
+  // Ensure parent directory exists for nested paths
+  const rulesFileDir = path.dirname(rulesFilePath);
+  if (!fs.existsSync(rulesFileDir)) {
+    fs.mkdirSync(rulesFileDir, { recursive: true });
   }
 
+  fs.writeFileSync(rulesFilePath, simpleContent);
+  console.log(`  Created ${resources.rulesFile}`);
+
   console.log(`  Configured ${cli.name}`);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {

package/scripts/flow-bridge-state.js

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Bridge State Tracker
+ *
+ * Tracks CLI bridge sync state and provides auto-sync functionality.
+ * Enables seamless generation of CLI instruction files on session start.
+ *
+ * Usage:
+ *   const { autoSyncBridge, needsSync } = require('./flow-bridge-state');
+ *
+ *   // Auto-sync on session start (non-blocking)
+ *   await autoSyncBridge('claude-code', { silent: true });
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// 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');
+
+// CLI type to output file mapping
+const CLI_OUTPUT_FILES = {
+  'claude-code': 'CLAUDE.md',
+  'gemini-cli': 'GEMINI.md',
+  'cursor': '.cursor/rules/wogi-flow.mdc',
+  'opencode': '.opencode/agents.md',
+  'codex': 'AGENTS.md',
+  'kimi': 'KIMI.md'
+};
+
+/**
+ * Safe JSON parse with prototype pollution protection
+ * @param {string} filePath - Path to JSON file
+ * @param {*} defaultValue - Default value if parsing fails
+ * @returns {*} Parsed object or default value
+ */
+function safeJsonParse(filePath, defaultValue = {}) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const parsed = JSON.parse(content);
+
+    // Check for prototype pollution keys
+    const checkDangerous = (obj, depth = 0) => {
+      if (depth > 10 || !obj || typeof obj !== 'object') return false;
+      const dangerous = ['__proto__', 'constructor', 'prototype'];
+      for (const key of Object.keys(obj)) {
+        if (dangerous.includes(key)) return true;
+        if (obj[key] && typeof obj[key] === 'object') {
+          if (checkDangerous(obj[key], depth + 1)) return true;
+        }
+      }
+      return false;
+    };
+
+    if (checkDangerous(parsed)) {
+      return defaultValue;
+    }
+    return parsed;
+  } catch {
+    return defaultValue;
+  }
+}
+
+/**
+ * Calculate MD5 hash of config.json for staleness detection
+ * @returns {string} Hash of config content
+ */
+function getConfigChecksum() {
+  try {
+    const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
+    return crypto.createHash('md5').update(content).digest('hex');
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Get the output file path for a CLI type
+ * @param {string} cliType - CLI type
+ * @returns {string} Full path to output file
+ */
+function getOutputFilePath(cliType) {
+  const filename = CLI_OUTPUT_FILES[cliType];
+  if (!filename) return null;
+  return path.join(PROJECT_ROOT, filename);
+}
+
+/**
+ * Read current sync state
+ * @returns {Object} Sync state
+ */
+function readSyncState() {
+  return safeJsonParse(SYNC_STATE_PATH, { syncs: {}, version: 1 });
+}
+
+/**
+ * Write sync state
+ * @param {Object} state - State to write
+ */
+function writeSyncState(state) {
+  try {
+    // Ensure state directory exists
+    if (!fs.existsSync(STATE_DIR)) {
+      fs.mkdirSync(STATE_DIR, { recursive: true });
+    }
+    fs.writeFileSync(SYNC_STATE_PATH, JSON.stringify(state, null, 2));
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[bridge-state] Failed to write sync state: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Get last sync time for a CLI type
+ * @param {string} cliType - CLI type
+ * @returns {string|null} ISO timestamp or null
+ */
+function getLastSyncTime(cliType) {
+  const state = readSyncState();
+  return state.syncs?.[cliType]?.lastSync || null;
+}
+
+/**
+ * Update sync time for a CLI type
+ * @param {string} cliType - CLI type
+ * @param {string} configHash - Current config hash
+ */
+function setLastSyncTime(cliType, configHash) {
+  const state = readSyncState();
+  if (!state.syncs) state.syncs = {};
+  state.syncs[cliType] = {
+    lastSync: new Date().toISOString(),
+    configHash
+  };
+  writeSyncState(state);
+}
+
+/**
+ * Check if a CLI bridge needs to be synced
+ * @param {string} cliType - CLI type to check
+ * @returns {Object} { needsSync: boolean, reason: string }
+ */
+function needsSync(cliType) {
+  // Check if output file exists
+  const outputPath = getOutputFilePath(cliType);
+  if (!outputPath) {
+    return { needsSync: false, reason: 'unknown-cli' };
+  }
+
+  if (!fs.existsSync(outputPath)) {
+    return { needsSync: true, reason: 'file-missing' };
+  }
+
+  // Check if config has changed since last sync
+  const state = readSyncState();
+  const cliState = state.syncs?.[cliType];
+
+  if (!cliState) {
+    return { needsSync: true, reason: 'never-synced' };
+  }
+
+  const currentHash = getConfigChecksum();
+  if (cliState.configHash !== currentHash) {
+    return { needsSync: true, reason: 'config-changed' };
+  }
+
+  return { needsSync: false, reason: 'up-to-date' };
+}
+
+/**
+ * Auto-sync a CLI bridge if needed
+ * @param {string} cliType - CLI type to sync
+ * @param {Object} options - Options
+ * @param {boolean} options.silent - Suppress output
+ * @param {boolean} options.force - Force sync even if up-to-date
+ * @returns {Object} { synced: boolean, reason: string }
+ */
+async function autoSyncBridge(cliType, options = {}) {
+  const { silent = false, force = false } = options;
+
+  // Check if sync is needed
+  if (!force) {
+    const check = needsSync(cliType);
+    if (!check.needsSync) {
+      if (!silent && process.env.DEBUG) {
+        console.error(`[bridge-state] ${cliType}: ${check.reason}, skipping sync`);
+      }
+      return { synced: false, reason: check.reason };
+    }
+  }
+
+  // Load bridges module
+  let bridges;
+  try {
+    bridges = require(path.join(PROJECT_ROOT, '.workflow', 'bridges'));
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[bridge-state] Failed to load bridges: ${err.message}`);
+    }
+    return { synced: false, reason: 'bridges-unavailable', error: err.message };
+  }
+
+  // Get bridge for the specified CLI type
+  let bridge;
+  try {
+    // Pass explicit cliType to override config default
+    bridge = bridges.getBridge({
+      projectDir: PROJECT_ROOT,
+      cliType: cliType,
+      verbose: !silent
+    });
+
+    // Fallback: Try loading the specific bridge directly
+    if (!bridge) {
+      const BridgeClass = require(path.join(PROJECT_ROOT, '.workflow', 'bridges', `${cliType}-bridge`));
+      bridge = new BridgeClass({
+        projectDir: PROJECT_ROOT,
+        verbose: !silent
+      });
+    }
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[bridge-state] Failed to get bridge for ${cliType}: ${err.message}`);
+    }
+    return { synced: false, reason: 'bridge-load-failed', error: err.message };
+  }
+
+  // Run sync
+  try {
+    await bridge.sync();
+
+    // Update state
+    const configHash = getConfigChecksum();
+    setLastSyncTime(cliType, configHash);
+
+    if (!silent) {
+      console.error(`[bridge-state] Synced ${cliType} bridge`);
+    }
+
+    return { synced: true, reason: 'success' };
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[bridge-state] Sync failed for ${cliType}: ${err.message}`);
+    }
+    return { synced: false, reason: 'sync-failed', error: err.message };
+  }
+}
+
+/**
+ * Sync all enabled CLIs
+ * @param {Object} options - Options
+ * @returns {Object} Results for each CLI
+ */
+async function syncAllEnabledClis(options = {}) {
+  const config = safeJsonParse(CONFIG_PATH, {});
+  const primaryCli = config.cli?.type || 'claude-code';
+  const enabledClis = config.cli?.enabled || [primaryCli];
+
+  const results = {};
+  for (const cliType of enabledClis) {
+    results[cliType] = await autoSyncBridge(cliType, options);
+  }
+
+  return results;
+}
+
+/**
+ * Detect which CLI is currently running
+ * Based on environment variables and caller context
+ * @returns {string} CLI type
+ */
+function detectRunningCli() {
+  // Priority 1: Environment variables
+  if (process.env.CLAUDE_CODE_ENTRY_POINT) return 'claude-code';
+  if (process.env.GEMINI_API_KEY && !process.env.CLAUDE_CODE_ENTRY_POINT) return 'gemini-cli';
+  if (process.env.CURSOR_SESSION_ID) return 'cursor';
+  if (process.env.OPENCODE_SESSION) return 'opencode';
+
+  // Priority 2: Check caller stack for hook path hints
+  try {
+    const stack = new Error().stack || '';
+    if (stack.includes('/claude-code/')) return 'claude-code';
+    if (stack.includes('/gemini-cli/')) return 'gemini-cli';
+    if (stack.includes('/cursor/')) return 'cursor';
+    if (stack.includes('/opencode/')) return 'opencode';
+  } catch {
+    // Ignore stack parsing errors
+  }
+
+  // Priority 3: Config file setting
+  const config = safeJsonParse(CONFIG_PATH, {});
+  if (config.cli?.type) return config.cli.type;
+
+  // Default
+  return 'claude-code';
+}
+
+// CLI interface
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  const run = async () => {
+    switch (command) {
+      case 'check': {
+        const cliType = args[1] || detectRunningCli();
+        const result = needsSync(cliType);
+        console.log(JSON.stringify({ cliType, ...result }, null, 2));
+        break;
+      }
+
+      case 'sync': {
+        const cliType = args[1] || detectRunningCli();
+        const result = await autoSyncBridge(cliType, { silent: false, force: args.includes('--force') });
+        console.log(JSON.stringify({ cliType, ...result }, null, 2));
+        break;
+      }
+
+      case 'sync-all': {
+        const results = await syncAllEnabledClis({ silent: false, force: args.includes('--force') });
+        console.log(JSON.stringify(results, null, 2));
+        break;
+      }
+
+      case 'detect': {
+        const cliType = detectRunningCli();
+        console.log(cliType);
+        break;
+      }
+
+      default:
+        console.log('Usage: flow-bridge-state <command> [options]');
+        console.log('');
+        console.log('Commands:');
+        console.log('  check [cli-type]    Check if sync is needed');
+        console.log('  sync [cli-type]     Sync a CLI bridge');
+        console.log('  sync-all            Sync all enabled CLIs');
+        console.log('  detect              Detect running CLI type');
+        console.log('');
+        console.log('Options:');
+        console.log('  --force             Force sync even if up-to-date');
+    }
+  };
+
+  run().catch(err => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  needsSync,
+  autoSyncBridge,
+  syncAllEnabledClis,
+  detectRunningCli,
+  getConfigChecksum,
+  getLastSyncTime,
+  setLastSyncTime,
+  CLI_OUTPUT_FILES
+};

package/scripts/flow-bridge.js

@@ -62,30 +62,44 @@ function listBridges() {
     {
       id: 'claude-code',
       name: 'Claude Code',
-      status: 'implemented',
+      status: 'full',
       folder: '.claude',
       rulesFile: 'CLAUDE.md'
     },
     {
       id: 'gemini-cli',
       name: 'Gemini CLI',
-      status: 'planned',
+      status: 'full',
       folder: '.gemini',
       rulesFile: 'GEMINI.md'
     },
+    {
+      id: 'cursor',
+      name: 'Cursor',
+      status: 'full',
+      folder: '.cursor',
+      rulesFile: '.cursor/rules/wogi-flow.mdc'
+    },
     {
       id: 'opencode',
       name: 'OpenCode',
-      status: 'planned',
+      status: 'full',
       folder: '.opencode',
-      rulesFile: 'OPENCODE.md'
+      rulesFile: '.opencode/agents.md'
+    },
+    {
+      id: 'codex',
+      name: 'Codex CLI',
+      status: 'soft',
+      folder: '.codex',
+      rulesFile: 'AGENTS.md'
     },
     {
-      id: 'other',
-      name: 'Other / Manual',
-      status: 'manual',
-      folder: 'N/A',
-      rulesFile: 'N/A'
+      id: 'kimi',
+      name: 'Kimi CLI',
+      status: 'soft',
+      folder: '.kimi',
+      rulesFile: 'KIMI.md'
     }
   ];
 
@@ -93,12 +107,14 @@ function listBridges() {
 
   for (const bridge of availableBridges) {
     const isCurrent = bridge.id === currentCli;
-    const statusColor = bridge.status === 'implemented' ? colors.green :
-                        bridge.status === 'planned' ? colors.yellow : colors.cyan;
+    const statusColor = bridge.status === 'full' ? colors.green :
+                        bridge.status === 'soft' ? colors.yellow : colors.cyan;
+    const statusLabel = bridge.status === 'full' ? 'full parity (hooks)' :
+                        bridge.status === 'soft' ? 'soft parity (rules only)' : bridge.status;
     const indicator = isCurrent ? `${colors.green}→${colors.reset}` : ' ';
 
     console.log(`  ${indicator} ${colors.bold}${bridge.name}${colors.reset} (${bridge.id})`);
-    console.log(`      Status: ${statusColor}${bridge.status}${colors.reset}`);
+    console.log(`      Status: ${statusColor}${statusLabel}${colors.reset}`);
     console.log(`      Folder: ${bridge.folder}`);
     console.log(`      Rules:  ${bridge.rulesFile}`);
     console.log('');
@@ -150,12 +166,43 @@ function showStatus() {
   console.log('');
 }
 
+/**
+ * Normalize CLI type argument to standard format
+ */
+function normalizeCliType(input) {
+  if (!input) return null;
+  const normalized = input.toLowerCase().trim();
+  const aliases = {
+    'gemini': 'gemini-cli',
+    'gemini-cli': 'gemini-cli',
+    'claude': 'claude-code',
+    'claude-code': 'claude-code',
+    'opencode': 'opencode',
+    'cursor': 'cursor',
+    'codex': 'codex',
+    'kimi': 'kimi'
+  };
+  return aliases[normalized] || null;
+}
+
 /**
  * Sync bridge
  */
 async function syncBridge(options = {}) {
   const verbose = options.verbose || process.argv.includes('--verbose') || process.argv.includes('-v');
 
+  // Check for CLI type argument (e.g., "flow bridge sync gemini")
+  const cliTypeArg = process.argv[3];
+  const requestedCliType = normalizeCliType(cliTypeArg);
+
+  if (cliTypeArg && !requestedCliType) {
+    console.error(`${colors.red}Error:${colors.reset} Unknown CLI type: ${cliTypeArg}`);
+    console.error('Available types: claude-code, gemini-cli, cursor, opencode, codex, kimi');
+    process.exit(1);
+  }
+
+  const targetCliType = requestedCliType || getCliType();
+
   console.log(`${colors.cyan}Syncing CLI bridge...${colors.reset}`);
   console.log('');
 
@@ -170,7 +217,11 @@ async function syncBridge(options = {}) {
       process.exit(1);
     }
 
-    const result = await bridges.syncBridge({ verbose, projectDir: PROJECT_ROOT });
+    const result = await bridges.syncBridge({
+      verbose,
+      projectDir: PROJECT_ROOT,
+      cliType: targetCliType
+    });
 
     if (result.success) {
       console.log(`${colors.green}✓ Bridge sync complete${colors.reset}`);
@@ -213,11 +264,18 @@ switch (command) {
     listBridges();
     break;
   default:
-    console.log('Usage: flow bridge [sync|status|list]');
+    console.log('Usage: flow bridge [sync|status|list] [cli-type]');
     console.log('');
     console.log('Commands:');
-    console.log('  sync    Sync .workflow/ config to CLI-specific folder');
-    console.log('  status  Show current bridge configuration');
-    console.log('  list    List available CLI bridges');
+    console.log('  sync [cli-type]  Sync .workflow/ config to CLI-specific folder');
+    console.log('  status           Show current bridge configuration');
+    console.log('  list             List available CLI bridges');
+    console.log('');
+    console.log('CLI Types:');
+    console.log('  claude-code, gemini-cli (or gemini), cursor, opencode, codex, kimi');
+    console.log('');
+    console.log('Examples:');
+    console.log('  flow bridge sync           # Sync default CLI from config');
+    console.log('  flow bridge sync gemini    # Sync Gemini CLI specifically');
     process.exit(1);
 }

package/scripts/hooks/entry/claude-code/session-start.js

@@ -11,8 +11,30 @@ const { gatherSessionContext } = require('../../core/session-context');
 const { claudeCodeAdapter } = require('../../adapters/claude-code');
 const { setCliSessionId, clearStaleCurrentTaskAsync } = require('../../../flow-session-state');
 
+// Lazy-load bridge state to avoid circular dependencies
+let autoSyncBridge = null;
+function getAutoSyncBridge() {
+  if (!autoSyncBridge) {
+    try {
+      autoSyncBridge = require('../../../flow-bridge-state').autoSyncBridge;
+    } catch {
+      autoSyncBridge = async () => ({ synced: false, reason: 'unavailable' });
+    }
+  }
+  return autoSyncBridge;
+}
+
 async function main() {
   try {
+    // Auto-sync bridge if needed (non-blocking, silent)
+    try {
+      const syncFn = getAutoSyncBridge();
+      await syncFn('claude-code', { silent: true });
+    } catch (err) {
+      if (process.env.DEBUG) {
+        console.error(`[session-start] Bridge auto-sync failed: ${err.message}`);
+      }
+    }
     // Read input from stdin
     let inputData = '';
     for await (const chunk of process.stdin) {

package/scripts/hooks/entry/cursor/session-start.js

@@ -31,6 +31,19 @@ function getSessionState() {
   return sessionState;
 }
 
+// Lazy-load bridge state for auto-sync
+let autoSyncBridge = null;
+function getAutoSyncBridge() {
+  if (!autoSyncBridge) {
+    try {
+      autoSyncBridge = require('../../../flow-bridge-state').autoSyncBridge;
+    } catch {
+      autoSyncBridge = async () => ({ synced: false, reason: 'unavailable' });
+    }
+  }
+  return autoSyncBridge;
+}
+
 /**
  * Read stdin with size limit protection
  * @returns {string} Input data, truncated if over limit
@@ -59,6 +72,16 @@ async function readStdinWithLimit() {
  * Handle session start event
  */
 async function handleSessionStart(input) {
+  // Auto-sync bridge if needed (non-blocking, silent)
+  try {
+    const syncFn = getAutoSyncBridge();
+    await syncFn('cursor', { silent: true });
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[cursor/session-start] Bridge auto-sync failed: ${err.message}`);
+    }
+  }
+
   try {
     const parsedInput = cursorAdapter.parseInput(input);
 

package/scripts/hooks/entry/gemini-cli/session-start.js

@@ -22,8 +22,30 @@ try {
   clearStaleCurrentTaskAsync = async () => {};
 }
 
+// Lazy-load bridge state for auto-sync
+let autoSyncBridge = null;
+function getAutoSyncBridge() {
+  if (!autoSyncBridge) {
+    try {
+      autoSyncBridge = require('../../../flow-bridge-state').autoSyncBridge;
+    } catch {
+      autoSyncBridge = async () => ({ synced: false, reason: 'unavailable' });
+    }
+  }
+  return autoSyncBridge;
+}
+
 async function main() {
   try {
+    // Auto-sync bridge if needed (non-blocking, silent)
+    try {
+      const syncFn = getAutoSyncBridge();
+      await syncFn('gemini-cli', { silent: true });
+    } catch (err) {
+      if (process.env.DEBUG) {
+        console.error(`[session-start] Bridge auto-sync failed: ${err.message}`);
+      }
+    }
     // Read input from stdin
     let inputData = '';
     for await (const chunk of process.stdin) {

package/scripts/hooks/entry/opencode/session-start.js

@@ -26,12 +26,35 @@ function getSessionState() {
   return sessionState;
 }
 
+// Lazy-load bridge state for auto-sync
+let autoSyncBridge = null;
+function getAutoSyncBridge() {
+  if (!autoSyncBridge) {
+    try {
+      autoSyncBridge = require('../../../flow-bridge-state').autoSyncBridge;
+    } catch {
+      autoSyncBridge = async () => ({ synced: false, reason: 'unavailable' });
+    }
+  }
+  return autoSyncBridge;
+}
+
 /**
  * Handle session start event
  * @param {Object} ctx - OpenCode plugin context
  * @returns {Object} Plugin result with additionalContext
  */
 async function handleSessionStart(ctx) {
+  // Auto-sync bridge if needed (non-blocking, silent)
+  try {
+    const syncFn = getAutoSyncBridge();
+    await syncFn('opencode', { silent: true });
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[opencode/session-start] Bridge auto-sync failed: ${err.message}`);
+    }
+  }
+
   try {
     const input = ctx || {};
     const parsedInput = opencodeAdapter.parseInput(input);