wogiflow 1.1.0 → 1.1.2

package/.claude/docs/knowledge-base/01-setup-onboarding/README.md

@@ -48,7 +48,6 @@ This analyzes your codebase and populates:
 | [Onboarding](./onboarding-existing.md) | Analyze and configure existing projects |
 | [Component Indexing](./component-indexing.md) | Auto-scan and register components |
 | [Framework Detection](./framework-detection.md) | Auto-detect tech stack and suggest skills |
-| [Team Setup](./team-setup.md) | Configure team sync and shared knowledge |
 
 ---
 

package/.claude/docs/knowledge-base/README.md

@@ -42,7 +42,7 @@ npx flow onboard
 Unlike feature-by-feature documentation, this knowledge base is organized by **purpose** - what you're trying to accomplish:
 
 ### 1. Setting Up (Once per project)
-Everything in [01-setup-onboarding](./01-setup-onboarding/) helps you get WogiFlow configured for your project. This includes analyzing your codebase, populating decisions and component registries, and setting up team sync.
+Everything in [01-setup-onboarding](./01-setup-onboarding/) helps you get WogiFlow configured for your project. This includes analyzing your codebase and populating decisions and component registries.
 
 ### 2. Executing Tasks (Daily workflow)
 The [02-task-execution](./02-task-execution/) category is the heart of WogiFlow. It explains the entire execution pipeline from task selection through completion, including:

package/.claude/docs/knowledge-base/configuration/README.md

@@ -133,25 +133,6 @@ cat .workflow/config.json
 }
 ```
 
-### Team-Optimized
-
-```json
-{
-  "team": {
-    "enabled": true,
-    "sync": {
-      "decisions": true,
-      "skills": true,
-      "componentIndex": true
-    }
-  },
-  "knowledgeRouting": {
-    "autoDetect": true,
-    "modelSpecificLearning": true
-  }
-}
-```
-
 ### Cost-Optimized (Hybrid Mode)
 
 ```json
@@ -225,4 +206,3 @@ See [all-options.md](./all-options.md) for complete configuration reference with
 
 - [All Options](./all-options.md) - Complete reference
 - [Task Execution](../02-task-execution/) - Execution config details
-- [Team Setup](../01-setup-onboarding/team-setup.md) - Team 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "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);