@cloudpftc/opencode-orchestrator 3.5.15 → 3.6.0

package/v3/@claude-flow/cli/dist/src/init/executor.js

@@ -15,7 +15,7 @@ import { generateSettingsJson, generateSettings } from './settings-generator.js'
 import { generateMCPJson } from './mcp-generator.js';
 import { generateStatuslineScript } from './statusline-generator.js';
 import { generatePreCommitHook, generatePostCommitHook, generateSessionManager, generateAgentRouter, generateMemoryHelper, generateHookHandler, generateIntelligenceStub, generateAutoMemoryHook, } from './helpers-generator.js';
-import { generateClaudeMd } from './claudemd-generator.js';
+import { generateSkillMd } from './skillmd-generator.js';
 /**
  * Skills to copy based on configuration
  */
@@ -109,23 +109,24 @@ const AGENTS_MAP = {
 };
 /**
  * Directory structure to create
+ * OpenCode uses .opencode/ instead of .opencode/
  */
 const DIRECTORIES = {
-    claude: [
-        '.claude',
-        '.claude/skills',
-        '.claude/commands',
-        '.claude/agents',
-        '.claude/helpers',
+    opencode: [
+        '.opencode',
+        '.opencode/skills',
+        '.opencode/commands',
+        '.opencode/agents',
+        '.opencode/helpers',
     ],
     runtime: [
-        '.claude-flow',
-        '.claude-flow/data',
-        '.claude-flow/logs',
-        '.claude-flow/sessions',
-        '.claude-flow/hooks',
-        '.claude-flow/agents',
-        '.claude-flow/workflows',
+        '.opencode-flow',
+        '.opencode-flow/data',
+        '.opencode-flow/logs',
+        '.opencode-flow/sessions',
+        '.opencode-flow/hooks',
+        '.opencode-flow/agents',
+        '.opencode-flow/workflows',
     ],
 };
 /**
@@ -152,6 +153,8 @@ export async function executeInit(options) {
     };
     const targetDir = options.targetDir;
     try {
+        // Clean up old Claude Code files if they exist
+        await cleanupOldClaudeFiles(targetDir, result);
         // Create directory structure
         await createDirectories(targetDir, options, result);
         // Generate and write settings.json
@@ -190,9 +193,9 @@ export async function executeInit(options) {
         if (options.components.statusline) {
             await writeInitialMetrics(targetDir, options, result);
         }
-        // Generate CLAUDE.md
-        if (options.components.claudeMd) {
-            await writeClaudeMd(targetDir, options, result);
+        // Generate SKILL.md
+        if (options.components.opencodeMd) {
+            await writeSkillMd(targetDir, options, result);
         }
         // Count enabled hooks
         result.summary.hooksEnabled = countEnabledHooks(options);
@@ -234,7 +237,7 @@ function mergeSettingsForUpgrade(existing) {
     const gitRootResolver = "var c=require('child_process'),p=require('path'),u=require('url'),r;"
         + "try{r=c.execSync('git rev-parse --show-toplevel',{encoding:'utf8'}).trim()}"
         + 'catch(e){r=process.cwd()}';
-    const autoMemoryScript = '.claude/helpers/auto-memory-hook.mjs';
+    const autoMemoryScript = '.opencode/helpers/auto-memory-hook.mjs';
     const autoMemoryImportCmd = `node -e "${gitRootResolver}var f=p.join(r,'${autoMemoryScript}');import(u.pathToFileURL(f).href)" import`;
     const autoMemorySyncCmd = `node -e "${gitRootResolver}var f=p.join(r,'${autoMemoryScript}');import(u.pathToFileURL(f).href)" sync`;
     // Add auto-memory import to SessionStart (if not already present)
@@ -286,14 +289,14 @@ function mergeSettingsForUpgrade(existing) {
     if (existingStatusLine) {
         merged.statusLine = {
             type: 'command',
-            command: existingStatusLine.command || `node -e "var c=require('child_process'),p=require('path'),r;try{r=c.execSync('git rev-parse --show-toplevel',{encoding:'utf8'}).trim()}catch(e){r=process.cwd()}var s=p.join(r,'.claude/helpers/statusline.cjs');process.argv.splice(1,0,s);require(s)"`,
+            command: existingStatusLine.command || `node -e "var c=require('child_process'),p=require('path'),r;try{r=c.execSync('git rev-parse --show-toplevel',{encoding:'utf8'}).trim()}catch(e){r=process.cwd()}var s=p.join(r,'.opencode/helpers/statusline.cjs');process.argv.splice(1,0,s);require(s)"`,
             // Remove invalid fields: refreshMs, enabled (not supported by Claude Code)
         };
     }
     // 4. Merge claudeFlow settings (preserve existing, add agentTeams + memory)
-    const existingClaudeFlow = existing.claudeFlow || {};
+    const existingClaudeFlow = existing.opencodeFlow || {};
     const existingMemory = existingClaudeFlow.memory || {};
-    merged.claudeFlow = {
+    merged.opencodeFlow = {
         ...existingClaudeFlow,
         version: existingClaudeFlow.version || '3.0.0',
         enabled: existingClaudeFlow.enabled !== false,
@@ -340,10 +343,10 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
     try {
         // Ensure required directories exist
         const dirs = [
-            '.claude/helpers',
-            '.claude-flow/metrics',
-            '.claude-flow/security',
-            '.claude-flow/learning',
+            '.opencode/helpers',
+            '.opencode-flow/metrics',
+            '.opencode-flow/security',
+            '.opencode-flow/learning',
         ];
         for (const dir of dirs) {
             const fullPath = path.join(targetDir, dir);
@@ -356,14 +359,14 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
         if (sourceHelpersForUpgrade) {
             const criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'intelligence.cjs'];
             for (const helperName of criticalHelpers) {
-                const targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
+                const targetPath = path.join(targetDir, '.opencode', 'helpers', helperName);
                 const sourcePath = path.join(sourceHelpersForUpgrade, helperName);
                 if (fs.existsSync(sourcePath)) {
                     if (fs.existsSync(targetPath)) {
-                        result.updated.push(`.claude/helpers/${helperName}`);
+                        result.updated.push(`.opencode/helpers/${helperName}`);
                     }
                     else {
-                        result.created.push(`.claude/helpers/${helperName}`);
+                        result.created.push(`.opencode/helpers/${helperName}`);
                     }
                     fs.copyFileSync(sourcePath, targetPath);
                     try {
@@ -381,12 +384,12 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 'auto-memory-hook.mjs': generateAutoMemoryHook(),
             };
             for (const [helperName, content] of Object.entries(generatedCritical)) {
-                const targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
+                const targetPath = path.join(targetDir, '.opencode', 'helpers', helperName);
                 if (fs.existsSync(targetPath)) {
-                    result.updated.push(`.claude/helpers/${helperName}`);
+                    result.updated.push(`.opencode/helpers/${helperName}`);
                 }
                 else {
-                    result.created.push(`.claude/helpers/${helperName}`);
+                    result.created.push(`.opencode/helpers/${helperName}`);
                 }
                 fs.writeFileSync(targetPath, content, 'utf-8');
                 try {
@@ -396,7 +399,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
             }
         }
         // 1. ALWAYS update statusline helper (force overwrite)
-        const statuslinePath = path.join(targetDir, '.claude', 'helpers', 'statusline.cjs');
+        const statuslinePath = path.join(targetDir, '.opencode', 'helpers', 'statusline.cjs');
         // Use default options with statusline config
         const upgradeOptions = {
             ...DEFAULT_INIT_OPTIONS,
@@ -409,15 +412,15 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
         };
         const statuslineContent = generateStatuslineScript(upgradeOptions);
         if (fs.existsSync(statuslinePath)) {
-            result.updated.push('.claude/helpers/statusline.cjs');
+            result.updated.push('.opencode/helpers/statusline.cjs');
         }
         else {
-            result.created.push('.claude/helpers/statusline.cjs');
+            result.created.push('.opencode/helpers/statusline.cjs');
         }
         fs.writeFileSync(statuslinePath, statuslineContent, 'utf-8');
         // 2. Create MISSING metrics files only (preserve existing data)
-        const metricsDir = path.join(targetDir, '.claude-flow', 'metrics');
-        const securityDir = path.join(targetDir, '.claude-flow', 'security');
+        const metricsDir = path.join(targetDir, '.opencode-flow', 'metrics');
+        const securityDir = path.join(targetDir, '.opencode-flow', 'security');
         // v3-progress.json
         const progressPath = path.join(metricsDir, 'v3-progress.json');
         if (!fs.existsSync(progressPath)) {
@@ -431,10 +434,10 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 _note: 'Metrics will update as you use Claude Flow'
             };
             fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2), 'utf-8');
-            result.created.push('.claude-flow/metrics/v3-progress.json');
+            result.created.push('.opencode-flow/metrics/v3-progress.json');
         }
         else {
-            result.preserved.push('.claude-flow/metrics/v3-progress.json');
+            result.preserved.push('.opencode-flow/metrics/v3-progress.json');
         }
         // swarm-activity.json
         const activityPath = path.join(metricsDir, 'swarm-activity.json');
@@ -447,10 +450,10 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 _initialized: true
             };
             fs.writeFileSync(activityPath, JSON.stringify(activity, null, 2), 'utf-8');
-            result.created.push('.claude-flow/metrics/swarm-activity.json');
+            result.created.push('.opencode-flow/metrics/swarm-activity.json');
         }
         else {
-            result.preserved.push('.claude-flow/metrics/swarm-activity.json');
+            result.preserved.push('.opencode-flow/metrics/swarm-activity.json');
         }
         // learning.json
         const learningPath = path.join(metricsDir, 'learning.json');
@@ -463,10 +466,10 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 _note: 'Intelligence grows as you use Claude Flow'
             };
             fs.writeFileSync(learningPath, JSON.stringify(learning, null, 2), 'utf-8');
-            result.created.push('.claude-flow/metrics/learning.json');
+            result.created.push('.opencode-flow/metrics/learning.json');
         }
         else {
-            result.preserved.push('.claude-flow/metrics/learning.json');
+            result.preserved.push('.opencode-flow/metrics/learning.json');
         }
         // audit-status.json
         const auditPath = path.join(securityDir, 'audit-status.json');
@@ -480,20 +483,20 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 _note: 'Run: npx @claude-flow/cli@latest security scan'
             };
             fs.writeFileSync(auditPath, JSON.stringify(audit, null, 2), 'utf-8');
-            result.created.push('.claude-flow/security/audit-status.json');
+            result.created.push('.opencode-flow/security/audit-status.json');
         }
         else {
-            result.preserved.push('.claude-flow/security/audit-status.json');
+            result.preserved.push('.opencode-flow/security/audit-status.json');
         }
         // 3. Merge settings if requested
         if (upgradeSettings) {
-            const settingsPath = path.join(targetDir, '.claude', 'settings.json');
+            const settingsPath = path.join(targetDir, '.opencode', 'settings.json');
             if (fs.existsSync(settingsPath)) {
                 try {
                     const existingSettings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
                     const mergedSettings = mergeSettingsForUpgrade(existingSettings);
                     fs.writeFileSync(settingsPath, JSON.stringify(mergedSettings, null, 2), 'utf-8');
-                    result.updated.push('.claude/settings.json');
+                    result.updated.push('.opencode/settings.json');
                     result.settingsUpdated = [
                         'env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS',
                         'hooks.SessionStart (auto-memory import)',
@@ -512,7 +515,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 // Create new settings.json with defaults
                 const defaultSettings = generateSettings(DEFAULT_INIT_OPTIONS);
                 fs.writeFileSync(settingsPath, JSON.stringify(defaultSettings, null, 2), 'utf-8');
-                result.created.push('.claude/settings.json');
+                result.created.push('.opencode/settings.json');
                 result.settingsUpdated = ['Created new settings.json with Agent Teams'];
             }
         }
@@ -541,9 +544,9 @@ export async function executeUpgradeWithMissing(targetDir, upgradeSettings = fal
     result.addedCommands = [];
     try {
         // Ensure target directories exist
-        const skillsDir = path.join(targetDir, '.claude', 'skills');
-        const agentsDir = path.join(targetDir, '.claude', 'agents');
-        const commandsDir = path.join(targetDir, '.claude', 'commands');
+        const skillsDir = path.join(targetDir, '.opencode', 'skills');
+        const agentsDir = path.join(targetDir, '.opencode', 'agents');
+        const commandsDir = path.join(targetDir, '.opencode', 'commands');
         for (const dir of [skillsDir, agentsDir, commandsDir]) {
             if (!fs.existsSync(dir)) {
                 fs.mkdirSync(dir, { recursive: true });
@@ -578,7 +581,7 @@ export async function executeUpgradeWithMissing(targetDir, upgradeSettings = fal
                 if (sourceExists && !targetExists) {
                     copyDirRecursive(sourcePath, targetPath);
                     result.addedSkills.push(skillName);
-                    result.created.push(`.claude/skills/${skillName}`);
+                    result.created.push(`.opencode/skills/${skillName}`);
                 }
             }
         }
@@ -591,7 +594,7 @@ export async function executeUpgradeWithMissing(targetDir, upgradeSettings = fal
                 if (fs.existsSync(sourcePath) && !fs.existsSync(targetPath)) {
                     copyDirRecursive(sourcePath, targetPath);
                     result.addedAgents.push(agentCategory);
-                    result.created.push(`.claude/agents/${agentCategory}`);
+                    result.created.push(`.opencode/agents/${agentCategory}`);
                 }
             }
         }
@@ -609,7 +612,7 @@ export async function executeUpgradeWithMissing(targetDir, upgradeSettings = fal
                         fs.copyFileSync(sourcePath, targetPath);
                     }
                     result.addedCommands.push(cmdName);
-                    result.created.push(`.claude/commands/${cmdName}`);
+                    result.created.push(`.opencode/commands/${cmdName}`);
                 }
             }
         }
@@ -619,12 +622,57 @@ export async function executeUpgradeWithMissing(targetDir, upgradeSettings = fal
     }
     return result;
 }
+/**
+ * Clean up old Claude Code files (migration from previous versions)
+ */
+async function cleanupOldClaudeFiles(targetDir, result) {
+    const oldPaths = [
+        '.claude',
+        '.claude/skills',
+        '.claude/commands',
+        '.claude/agents',
+        '.claude/helpers',
+        '.claude/settings.json',
+        'CLAUDE.md',
+        '.mcp.json',
+        '.claude-flow',
+        '.claude-flow/data',
+        '.claude-flow/logs',
+        '.claude-flow/sessions',
+        '.claude-flow/hooks',
+        '.claude-flow/agents',
+        '.claude-flow/workflows',
+        '.claude-flow/config.yaml',
+        '.claude-flow/CAPABILITIES.md',
+        '.claude-flow/memory.db',
+        '.claude-flow/hnsw.index',
+        '.claude-flow/session.json',
+    ];
+    for (const oldPath of oldPaths) {
+        const fullPath = path.join(targetDir, oldPath);
+        if (fs.existsSync(fullPath)) {
+            try {
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    fs.rmSync(fullPath, { recursive: true, force: true });
+                }
+                else {
+                    fs.unlinkSync(fullPath);
+                }
+                result.skipped.push(`Cleaned up old: ${oldPath}`);
+            }
+            catch (error) {
+                // Ignore errors during cleanup - files might be in use
+            }
+        }
+    }
+}
 /**
  * Create directory structure
  */
 async function createDirectories(targetDir, options, result) {
     const dirs = [
-        ...DIRECTORIES.claude,
+        ...DIRECTORIES.opencode,
         ...(options.components.runtime ? DIRECTORIES.runtime : []),
     ];
     for (const dir of dirs) {
@@ -639,14 +687,14 @@ async function createDirectories(targetDir, options, result) {
  * Write settings.json
  */
 async function writeSettings(targetDir, options, result) {
-    const settingsPath = path.join(targetDir, '.claude', 'settings.json');
+    const settingsPath = path.join(targetDir, '.opencode', 'settings.json');
     if (fs.existsSync(settingsPath) && !options.force) {
-        result.skipped.push('.claude/settings.json');
+        result.skipped.push('.opencode/settings.json');
         return;
     }
     const content = generateSettingsJson(options);
     fs.writeFileSync(settingsPath, content, 'utf-8');
-    result.created.files.push('.claude/settings.json');
+    result.created.files.push('.opencode/settings.json');
 }
 /**
  * Write .mcp.json
@@ -666,7 +714,7 @@ async function writeMCPConfig(targetDir, options, result) {
  */
 async function copySkills(targetDir, options, result) {
     const skillsConfig = options.skills;
-    const targetSkillsDir = path.join(targetDir, '.claude', 'skills');
+    const targetSkillsDir = path.join(targetDir, '.opencode', 'skills');
     // Determine which skills to copy
     const skillsToCopy = [];
     if (skillsConfig.all) {
@@ -700,11 +748,11 @@ async function copySkills(targetDir, options, result) {
         if (fs.existsSync(sourcePath)) {
             if (!fs.existsSync(targetPath) || options.force) {
                 copyDirRecursive(sourcePath, targetPath);
-                result.created.files.push(`.claude/skills/${skillName}`);
+                result.created.files.push(`.opencode/skills/${skillName}`);
                 result.summary.skillsCount++;
             }
             else {
-                result.skipped.push(`.claude/skills/${skillName}`);
+                result.skipped.push(`.opencode/skills/${skillName}`);
             }
         }
     }
@@ -714,7 +762,7 @@ async function copySkills(targetDir, options, result) {
  */
 async function copyCommands(targetDir, options, result) {
     const commandsConfig = options.commands;
-    const targetCommandsDir = path.join(targetDir, '.claude', 'commands');
+    const targetCommandsDir = path.join(targetDir, '.opencode', 'commands');
     // Determine which commands to copy
     const commandsToCopy = [];
     if (commandsConfig.all) {
@@ -756,11 +804,11 @@ async function copyCommands(targetDir, options, result) {
                 else {
                     fs.copyFileSync(sourcePath, targetPath);
                 }
-                result.created.files.push(`.claude/commands/${cmdName}`);
+                result.created.files.push(`.opencode/commands/${cmdName}`);
                 result.summary.commandsCount++;
             }
             else {
-                result.skipped.push(`.claude/commands/${cmdName}`);
+                result.skipped.push(`.opencode/commands/${cmdName}`);
             }
         }
     }
@@ -770,7 +818,7 @@ async function copyCommands(targetDir, options, result) {
  */
 async function copyAgents(targetDir, options, result) {
     const agentsConfig = options.agents;
-    const targetAgentsDir = path.join(targetDir, '.claude', 'agents');
+    const targetAgentsDir = path.join(targetDir, '.opencode', 'agents');
     // Determine which agents to copy
     const agentsToCopy = [];
     if (agentsConfig.all) {
@@ -816,10 +864,10 @@ async function copyAgents(targetDir, options, result) {
                 const yamlFiles = countFiles(sourcePath, '.yaml');
                 const mdFiles = countFiles(sourcePath, '.md');
                 result.summary.agentsCount += yamlFiles + mdFiles;
-                result.created.files.push(`.claude/agents/${agentCategory}`);
+                result.created.files.push(`.opencode/agents/${agentCategory}`);
             }
             else {
-                result.skipped.push(`.claude/agents/${agentCategory}`);
+                result.skipped.push(`.opencode/agents/${agentCategory}`);
             }
         }
     }
@@ -834,21 +882,21 @@ function findSourceHelpersDir(sourceBaseDir) {
     const SENTINEL_FILE = 'hook-handler.cjs'; // Must exist in valid source
     // If explicit source base directory is provided, check it first
     if (sourceBaseDir) {
-        possiblePaths.push(path.join(sourceBaseDir, '.claude', 'helpers'));
+        possiblePaths.push(path.join(sourceBaseDir, '.opencode', 'helpers'));
     }
     // Strategy 1: require.resolve to find package root (most reliable for npx)
     try {
         const esmRequire = createRequire(import.meta.url);
         const pkgJsonPath = esmRequire.resolve('@claude-flow/cli/package.json');
         const pkgRoot = path.dirname(pkgJsonPath);
-        possiblePaths.push(path.join(pkgRoot, '.claude', 'helpers'));
+        possiblePaths.push(path.join(pkgRoot, '.opencode', 'helpers'));
     }
     catch {
         // Not installed as a package — skip
     }
     // Strategy 2: __dirname-based (dist/src/init -> package root)
     const packageRoot = path.resolve(__dirname, '..', '..', '..');
-    const packageHelpers = path.join(packageRoot, '.claude', 'helpers');
+    const packageHelpers = path.join(packageRoot, '.opencode', 'helpers');
     possiblePaths.push(packageHelpers);
     // Strategy 3: Walk up from __dirname looking for package root
     let currentDir = __dirname;
@@ -856,15 +904,15 @@ function findSourceHelpersDir(sourceBaseDir) {
         const parentDir = path.dirname(currentDir);
         if (parentDir === currentDir)
             break; // hit filesystem root
-        const helpersPath = path.join(parentDir, '.claude', 'helpers');
+        const helpersPath = path.join(parentDir, '.opencode', 'helpers');
         possiblePaths.push(helpersPath);
         currentDir = parentDir;
     }
     // Strategy 4: Check cwd-relative paths (for local dev)
     const cwdBased = [
-        path.join(process.cwd(), '.claude', 'helpers'),
-        path.join(process.cwd(), '..', '.claude', 'helpers'),
-        path.join(process.cwd(), '..', '..', '.claude', 'helpers'),
+        path.join(process.cwd(), '.opencode', 'helpers'),
+        path.join(process.cwd(), '..', '.opencode', 'helpers'),
+        path.join(process.cwd(), '..', '..', '.opencode', 'helpers'),
     ];
     possiblePaths.push(...cwdBased);
     // Return first path that exists AND contains the sentinel file
@@ -879,7 +927,7 @@ function findSourceHelpersDir(sourceBaseDir) {
  * Write helper scripts
  */
 async function writeHelpers(targetDir, options, result) {
-    const helpersDir = path.join(targetDir, '.claude', 'helpers');
+    const helpersDir = path.join(targetDir, '.opencode', 'helpers');
     // Find source helpers directory (works for npm package and local dev)
     const sourceHelpersDir = findSourceHelpersDir(options.sourceBaseDir);
     // Try to copy existing helpers from source first
@@ -898,11 +946,11 @@ async function writeHelpers(targetDir, options, result) {
                 if (file.endsWith('.sh') || file.endsWith('.mjs')) {
                     fs.chmodSync(destPath, '755');
                 }
-                result.created.files.push(`.claude/helpers/${file}`);
+                result.created.files.push(`.opencode/helpers/${file}`);
                 copiedCount++;
             }
             else {
-                result.skipped.push(`.claude/helpers/${file}`);
+                result.skipped.push(`.opencode/helpers/${file}`);
             }
         }
         if (copiedCount > 0) {
@@ -928,26 +976,26 @@ async function writeHelpers(targetDir, options, result) {
             if (!name.endsWith('.js')) {
                 fs.chmodSync(filePath, '755');
             }
-            result.created.files.push(`.claude/helpers/${name}`);
+            result.created.files.push(`.opencode/helpers/${name}`);
         }
         else {
-            result.skipped.push(`.claude/helpers/${name}`);
+            result.skipped.push(`.opencode/helpers/${name}`);
         }
     }
 }
 /**
- * Find source .claude directory for statusline files
+ * Find source .opencode directory for statusline files
  */
 function findSourceClaudeDir(sourceBaseDir) {
     const possiblePaths = [];
     // If explicit source base directory is provided, check it first
     if (sourceBaseDir) {
-        possiblePaths.push(path.join(sourceBaseDir, '.claude'));
+        possiblePaths.push(path.join(sourceBaseDir, '.opencode'));
     }
-    // IMPORTANT: Check the package's own .claude directory
+    // IMPORTANT: Check the package's own .opencode directory
     // Go up 3 levels: dist/src/init -> dist/src -> dist -> root
     const packageRoot = path.resolve(__dirname, '..', '..', '..');
-    const packageClaude = path.join(packageRoot, '.claude');
+    const packageClaude = path.join(packageRoot, '.opencode');
     if (fs.existsSync(packageClaude)) {
         possiblePaths.unshift(packageClaude); // Add to beginning (highest priority)
     }
@@ -955,7 +1003,7 @@ function findSourceClaudeDir(sourceBaseDir) {
     let currentDir = __dirname;
     for (let i = 0; i < 10; i++) {
         const parentDir = path.dirname(currentDir);
-        const claudePath = path.join(parentDir, '.claude');
+        const claudePath = path.join(parentDir, '.opencode');
         if (fs.existsSync(claudePath)) {
             possiblePaths.push(claudePath);
         }
@@ -972,9 +1020,9 @@ function findSourceClaudeDir(sourceBaseDir) {
  * Write statusline configuration
  */
 async function writeStatusline(targetDir, options, result) {
-    const claudeDir = path.join(targetDir, '.claude');
-    const helpersDir = path.join(targetDir, '.claude', 'helpers');
-    // Find source .claude directory (works for npm package and local dev)
+    const claudeDir = path.join(targetDir, '.opencode');
+    const helpersDir = path.join(targetDir, '.opencode', 'helpers');
+    // Find source .opencode directory (works for npm package and local dev)
     const sourceClaudeDir = findSourceClaudeDir(options.sourceBaseDir);
     // Try to copy existing advanced statusline files from source
     const advancedStatuslineFiles = [
@@ -992,10 +1040,10 @@ async function writeStatusline(targetDir, options, result) {
                     if (file.src.endsWith('.sh') || file.src.endsWith('.mjs')) {
                         fs.chmodSync(destPath, '755');
                     }
-                    result.created.files.push(`.claude/${file.dest}`);
+                    result.created.files.push(`.opencode/${file.dest}`);
                 }
                 else {
-                    result.skipped.push(`.claude/${file.dest}`);
+                    result.skipped.push(`.opencode/${file.dest}`);
                 }
             }
         }
@@ -1006,22 +1054,22 @@ async function writeStatusline(targetDir, options, result) {
     const statuslinePath = path.join(helpersDir, 'statusline.cjs');
     if (!fs.existsSync(statuslinePath) || options.force) {
         fs.writeFileSync(statuslinePath, statuslineScript, 'utf-8');
-        result.created.files.push('.claude/helpers/statusline.cjs');
+        result.created.files.push('.opencode/helpers/statusline.cjs');
     }
     else {
-        result.skipped.push('.claude/helpers/statusline.cjs');
+        result.skipped.push('.opencode/helpers/statusline.cjs');
     }
 }
 /**
- * Write runtime configuration (.claude-flow/)
+ * Write runtime configuration (.opencode-flow/)
  */
 async function writeRuntimeConfig(targetDir, options, result) {
-    const configPath = path.join(targetDir, '.claude-flow', 'config.yaml');
+    const configPath = path.join(targetDir, '.opencode-flow', 'config.yaml');
     if (fs.existsSync(configPath) && !options.force) {
-        result.skipped.push('.claude-flow/config.yaml');
+        result.skipped.push('.opencode-flow/config.yaml');
         return;
     }
-    const config = `# RuFlo V3 Runtime Configuration
+    const config = `# OpenCode Orchestrator Runtime Configuration
 # Generated: ${new Date().toISOString()}
 
 version: "3.0.0"
@@ -1035,7 +1083,7 @@ swarm:
 memory:
   backend: ${options.runtime.memoryBackend}
   enableHNSW: ${options.runtime.enableHNSW}
-  persistPath: .claude-flow/data
+  persistPath: .opencode-flow/data
   cacheSize: 100
   # ADR-049: Self-Learning Memory
   learningBridge:
@@ -1055,7 +1103,7 @@ memory:
 
 neural:
   enabled: ${options.runtime.enableNeural}
-  modelPath: .claude-flow/neural
+  modelPath: .opencode-flow/neural
 
 hooks:
   enabled: true
@@ -1066,9 +1114,9 @@ mcp:
   port: ${options.mcp.port}
 `;
     fs.writeFileSync(configPath, config, 'utf-8');
-    result.created.files.push('.claude-flow/config.yaml');
+    result.created.files.push('.opencode-flow/config.yaml');
     // Write .gitignore
-    const gitignorePath = path.join(targetDir, '.claude-flow', '.gitignore');
+    const gitignorePath = path.join(targetDir, '.opencode-flow', '.gitignore');
     const gitignore = `# Claude Flow runtime files
 data/
 logs/
@@ -1079,7 +1127,7 @@ neural/
 `;
     if (!fs.existsSync(gitignorePath) || options.force) {
         fs.writeFileSync(gitignorePath, gitignore, 'utf-8');
-        result.created.files.push('.claude-flow/.gitignore');
+        result.created.files.push('.opencode-flow/.gitignore');
     }
     // Write CAPABILITIES.md with full system overview
     await writeCapabilitiesDoc(targetDir, options, result);
@@ -1089,9 +1137,9 @@ neural/
  * Creates baseline data so statusline shows meaningful state instead of all zeros
  */
 async function writeInitialMetrics(targetDir, options, result) {
-    const metricsDir = path.join(targetDir, '.claude-flow', 'metrics');
-    const learningDir = path.join(targetDir, '.claude-flow', 'learning');
-    const securityDir = path.join(targetDir, '.claude-flow', 'security');
+    const metricsDir = path.join(targetDir, '.opencode-flow', 'metrics');
+    const learningDir = path.join(targetDir, '.opencode-flow', 'learning');
+    const securityDir = path.join(targetDir, '.opencode-flow', 'security');
     // Ensure directories exist
     for (const dir of [metricsDir, learningDir, securityDir]) {
         if (!fs.existsSync(dir)) {
@@ -1128,7 +1176,7 @@ async function writeInitialMetrics(targetDir, options, result) {
             _note: 'Metrics will update as you use Claude Flow. Run: npx @claude-flow/cli@latest daemon start'
         };
         fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2), 'utf-8');
-        result.created.files.push('.claude-flow/metrics/v3-progress.json');
+        result.created.files.push('.opencode-flow/metrics/v3-progress.json');
     }
     // Create initial swarm-activity.json
     const activityPath = path.join(metricsDir, 'swarm-activity.json');
@@ -1152,7 +1200,7 @@ async function writeInitialMetrics(targetDir, options, result) {
             _initialized: true
         };
         fs.writeFileSync(activityPath, JSON.stringify(activity, null, 2), 'utf-8');
-        result.created.files.push('.claude-flow/metrics/swarm-activity.json');
+        result.created.files.push('.opencode-flow/metrics/swarm-activity.json');
     }
     // Create initial learning.json
     const learningPath = path.join(metricsDir, 'learning.json');
@@ -1175,7 +1223,7 @@ async function writeInitialMetrics(targetDir, options, result) {
             _note: 'Intelligence grows as you use Claude Flow'
         };
         fs.writeFileSync(learningPath, JSON.stringify(learning, null, 2), 'utf-8');
-        result.created.files.push('.claude-flow/metrics/learning.json');
+        result.created.files.push('.opencode-flow/metrics/learning.json');
     }
     // Create initial audit-status.json
     const auditPath = path.join(securityDir, 'audit-status.json');
@@ -1189,21 +1237,21 @@ async function writeInitialMetrics(targetDir, options, result) {
             _note: 'Run: npx @claude-flow/cli@latest security scan'
         };
         fs.writeFileSync(auditPath, JSON.stringify(audit, null, 2), 'utf-8');
-        result.created.files.push('.claude-flow/security/audit-status.json');
+        result.created.files.push('.opencode-flow/security/audit-status.json');
     }
 }
 /**
  * Write CAPABILITIES.md - comprehensive overview of all Claude Flow features
  */
 async function writeCapabilitiesDoc(targetDir, options, result) {
-    const capabilitiesPath = path.join(targetDir, '.claude-flow', 'CAPABILITIES.md');
+    const capabilitiesPath = path.join(targetDir, '.opencode-flow', 'CAPABILITIES.md');
     if (fs.existsSync(capabilitiesPath) && !options.force) {
-        result.skipped.push('.claude-flow/CAPABILITIES.md');
+        result.skipped.push('.opencode-flow/CAPABILITIES.md');
         return;
     }
-    const capabilities = `# RuFlo V3 - Complete Capabilities Reference
+    const capabilities = `# OpenCode Orchestrator - Complete Capabilities Reference
 > Generated: ${new Date().toISOString()}
-> Full documentation: https://github.com/ruvnet/claude-flow
+> Full documentation: https://github.com/pedrocosta95/opencode-orchestrator
 
 ## 📋 Table of Contents
 
@@ -1221,7 +1269,7 @@ async function writeCapabilitiesDoc(targetDir, options, result) {
 
 ## Overview
 
-RuFlo V3 is a domain-driven design architecture for multi-agent AI coordination with:
+OpenCode Orchestrator is a domain-driven design architecture for multi-agent AI coordination with:
 
 - **15-Agent Swarm Coordination** with hierarchical and mesh topologies
 - **HNSW Vector Search** - 150x-12,500x faster pattern retrieval
@@ -1453,9 +1501,9 @@ npx @claude-flow/cli@latest doctor --fix
 **MemoryGraph** - Builds a knowledge graph from entry references. PageRank identifies influential insights. Communities group related knowledge. Graph-aware ranking blends vector + structural scores.
 
 **AgentMemoryScope** - Maps Claude Code 3-scope directories:
-- \`project\`: \`<gitRoot>/.claude/agent-memory/<agent>/\`
-- \`local\`: \`<gitRoot>/.claude/agent-memory-local/<agent>/\`
-- \`user\`: \`~/.claude/agent-memory/<agent>/\`
+- \`project\`: \`<gitRoot>/.opencode/agent-memory/<agent>/\`
+- \`local\`: \`<gitRoot>/.opencode/agent-memory-local/<agent>/\`
+- \`user\`: \`~/.opencode/agent-memory/<agent>/\`
 
 High-confidence insights (>0.8) can transfer between agents.
 
@@ -1589,7 +1637,7 @@ npx @claude-flow/cli@latest hooks worker dispatch --trigger optimize
 
 ### File Structure
 \`\`\`
-.claude-flow/
+.opencode-flow/
 ├── config.yaml      # Runtime configuration
 ├── CAPABILITIES.md  # This file
 ├── data/            # Memory storage
@@ -1606,22 +1654,22 @@ npx @claude-flow/cli@latest hooks worker dispatch --trigger optimize
 **Issues**: https://github.com/ruvnet/claude-flow/issues
 `;
     fs.writeFileSync(capabilitiesPath, capabilities, 'utf-8');
-    result.created.files.push('.claude-flow/CAPABILITIES.md');
+    result.created.files.push('.opencode-flow/CAPABILITIES.md');
 }
 /**
- * Write CLAUDE.md with swarm guidance
+ * Write SKILL.md with swarm guidance
  */
-async function writeClaudeMd(targetDir, options, result) {
-    const claudeMdPath = path.join(targetDir, 'CLAUDE.md');
-    if (fs.existsSync(claudeMdPath) && !options.force) {
-        result.skipped.push('CLAUDE.md');
+async function writeSkillMd(targetDir, options, result) {
+    const skillMdPath = path.join(targetDir, 'SKILL.md');
+    if (fs.existsSync(skillMdPath) && !options.force) {
+        result.skipped.push('SKILL.md');
         return;
     }
     // Determine template: explicit option > infer from components > 'standard'
     const inferredTemplate = (!options.components.commands && !options.components.agents) ? 'minimal' : undefined;
-    const content = generateClaudeMd(options, inferredTemplate);
-    fs.writeFileSync(claudeMdPath, content, 'utf-8');
-    result.created.files.push('CLAUDE.md');
+    const content = generateSkillMd(options, inferredTemplate);
+    fs.writeFileSync(skillMdPath, content, 'utf-8');
+    result.created.files.push('SKILL.md');
 }
 /**
  * Find source directory for skills/commands/agents
@@ -1631,24 +1679,24 @@ function findSourceDir(type, sourceBaseDir) {
     const possiblePaths = [];
     // If explicit source base directory is provided, use it first
     if (sourceBaseDir) {
-        possiblePaths.push(path.join(sourceBaseDir, '.claude', type));
+        possiblePaths.push(path.join(sourceBaseDir, '.opencode', type));
     }
-    // IMPORTANT: Check the package's own .claude directory first
+    // IMPORTANT: Check the package's own .opencode directory first
     // This is the primary path when running as an npm package
     // __dirname is typically /path/to/node_modules/@claude-flow/cli/dist/src/init
     // We need to go up 3 levels to reach the package root (dist/src/init -> dist/src -> dist -> root)
     const packageRoot = path.resolve(__dirname, '..', '..', '..');
-    const packageDotClaude = path.join(packageRoot, '.claude', type);
+    const packageDotClaude = path.join(packageRoot, '.opencode', type);
     if (fs.existsSync(packageDotClaude)) {
         possiblePaths.unshift(packageDotClaude); // Add to beginning (highest priority)
     }
     // From dist/src/init -> go up to project root
     const distPath = __dirname;
-    // Try to find the project root by looking for .claude directory
+    // Try to find the project root by looking for .opencode directory
     let currentDir = distPath;
     for (let i = 0; i < 10; i++) {
         const parentDir = path.dirname(currentDir);
-        const dotClaudePath = path.join(parentDir, '.claude', type);
+        const dotClaudePath = path.join(parentDir, '.opencode', type);
         if (fs.existsSync(dotClaudePath)) {
             possiblePaths.push(dotClaudePath);
         }
@@ -1656,14 +1704,14 @@ function findSourceDir(type, sourceBaseDir) {
     }
     // Also check relative to process.cwd() for development
     const cwdBased = [
-        path.join(process.cwd(), '.claude', type),
-        path.join(process.cwd(), '..', '.claude', type),
-        path.join(process.cwd(), '..', '..', '.claude', type),
+        path.join(process.cwd(), '.opencode', type),
+        path.join(process.cwd(), '..', '.opencode', type),
+        path.join(process.cwd(), '..', '..', '.opencode', type),
     ];
     possiblePaths.push(...cwdBased);
     // Check v2 directory for agents
     if (type === 'agents') {
-        possiblePaths.push(path.join(process.cwd(), 'v2', '.claude', type), path.join(process.cwd(), '..', 'v2', '.claude', type));
+        possiblePaths.push(path.join(process.cwd(), 'v2', '.opencode', type), path.join(process.cwd(), '..', 'v2', '.opencode', type));
     }
     // Plugin directory
     possiblePaths.push(path.join(process.cwd(), 'plugin', type), path.join(process.cwd(), '..', 'plugin', type));