synapsexcoder 6.0.0

package/dist/cli/index.js

@@ -0,0 +1,2677 @@
+#!/usr/bin/env node
+/**
+ * SynapseXcoder V6 - CLI Entry Point
+ *
+ * Provides the command-line interface for interacting with the multi-agent system.
+ * Supports commands for agent management, task execution, learning, and system status.
+ */
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { readFileSync, existsSync, statSync, realpathSync, mkdirSync, writeFileSync, readdirSync, unlinkSync, openSync, readSync, closeSync, } from "fs";
+import { resolve, extname, join } from "path";
+import { v4 as uuidv4 } from "uuid";
+import { homedir } from "os";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { spawn, execSync } from "child_process";
+import { MessageBus } from "../messages/message-bus.js";
+import { OpenCodeToolBridge, AgentDelegate } from "../synapsexcoder/index.js";
+import { KnowledgeVault, ingestOpenCodeDocs } from "../knowledge-vault/index.js";
+import { MasterAgent } from "../agents/base-agents.js";
+import { TeamCollaborationSystem } from "../team/team-collaboration.js";
+import { validateAndResolve } from "../utils/path-validator.js";
+import { CustomModeRegistry, validateModeDefinition, generateModePreview, getModeTemplates, getTemplatesByCategory, createFromTemplate, saveModeToFile, deleteModeFromFile, listCustomModesFromFile, parseModeFromYaml, } from "../modes/index.js";
+import { synapseModeRegistry } from "../modes/synapse-modes.js";
+// ============================================================================
+// CLI Configuration
+// ============================================================================
+const program = new Command();
+program
+    .name("synapse")
+    .description("SynapseXcoder V6 - Multi-Agent OpenCode Integration")
+    .version("6.0.0")
+    .option("-c, --config <path>", "Config file path")
+    .option("-v, --verbose", "Enable verbose output")
+    .option("-q, --quiet", "Suppress non-essential output")
+    .option("--json", "Output in JSON format")
+    .option("--no-color", "Disable colored output");
+const teamCmd = program
+    .command("team")
+    .description("Manage team collaboration");
+teamCmd
+    .command("init")
+    .description("Initialize team environment")
+    .action(() => {
+    const teamSystem = new TeamCollaborationSystem(process.cwd());
+    // Create necessary directories (handled by constructor)
+    console.log(chalk.green("Team environment initialized successfully"));
+    const stats = teamSystem.getTeamStats();
+    console.log(chalk.gray(`Users: ${stats.totalUsers}, Sessions: ${stats.activeSessions}, Repos: ${stats.totalRepositories}`));
+});
+const userCmd = teamCmd.command("user").description("Manage users");
+userCmd
+    .command("add")
+    .description("Add a new user")
+    .argument("<username>", "Username")
+    .option("-e, --email <email>", "User email")
+    .option("-r, --role <role>", "User role (admin|editor|viewer)", "editor")
+    .action((username, options) => {
+    const teamSystem = new TeamCollaborationSystem(process.cwd());
+    const id = teamSystem.createUser({
+        username,
+        email: options.email || `${username}@example.com`,
+        displayName: username,
+        role: options.role,
+        preferences: { theme: "dark", notifications: true, language: "en" },
+    });
+    console.log(chalk.green(`User created: ${username} (ID: ${id})`));
+});
+userCmd
+    .command("list")
+    .description("List all users")
+    .action(() => {
+    const teamSystem = new TeamCollaborationSystem(process.cwd());
+    const users = teamSystem.listUsers();
+    console.log(chalk.cyan("\n👥 Team Users\n"));
+    if (users.length === 0) {
+        console.log(chalk.gray("  No users found"));
+    }
+    else {
+        users.forEach((u) => {
+            console.log(`  ${chalk.green(u.username)} (${u.role}) - ID: ${u.id}`);
+        });
+    }
+});
+const sessionCmd = teamCmd.command("session").description("Manage sessions");
+sessionCmd
+    .command("create")
+    .description("Create a new session")
+    .argument("<name>", "Session name")
+    .option("-d, --desc <desc>", "Description")
+    .option("-o, --owner <id>", "Owner ID")
+    .action((name, options) => {
+    const teamSystem = new TeamCollaborationSystem(process.cwd());
+    // Create a temporary owner if none provided
+    let ownerId = options.owner;
+    if (!ownerId) {
+        const users = teamSystem.listUsers();
+        if (users.length > 0) {
+            ownerId = users[0].id;
+        }
+        else {
+            // Create admin user implicitly if no users exist
+            const adminId = teamSystem.createUser({
+                username: "admin",
+                email: "admin@example.com",
+                displayName: "System Admin",
+                role: "admin",
+                preferences: { theme: "dark", notifications: true, language: "en" },
+            });
+            ownerId = adminId;
+            console.log(chalk.yellow(`Created default admin user (ID: ${adminId})`));
+        }
+    }
+    const id = teamSystem.createSession({
+        name,
+        description: options.desc || "Collaborative session",
+        ownerId,
+        members: [ownerId],
+        status: "active",
+        settings: {
+            allowGuestAccess: true,
+            requireApproval: false,
+            maxMembers: 10,
+        },
+    });
+    console.log(chalk.green(`Session created: ${name} (ID: ${id})`));
+});
+sessionCmd
+    .command("list")
+    .description("List active sessions")
+    .action(() => {
+    const teamSystem = new TeamCollaborationSystem(process.cwd());
+    const sessions = teamSystem.listActiveSessions();
+    console.log(chalk.cyan("\n👥 Active Sessions\n"));
+    if (sessions.length === 0) {
+        console.log(chalk.gray("  No active sessions found"));
+    }
+    else {
+        sessions.forEach((s) => {
+            console.log(`  ${chalk.green(s.name)} (ID: ${s.id})`);
+            console.log(`    ${chalk.gray("Members:")} ${s.members.length}`);
+            console.log(`    ${chalk.gray("Status:")} ${s.status}`);
+            console.log();
+        });
+    }
+});
+const repoCmd = teamCmd
+    .command("repo")
+    .description("Manage shared repositories");
+repoCmd
+    .command("create")
+    .description("Create a shared repository")
+    .argument("<name>", "Repository name")
+    .option("-d, --desc <desc>", "Description")
+    .option("-t, --type <type>", "Type (thoughts|contexts|agents|mixed)", "mixed")
+    .option("-v, --visibility <visibility>", "Visibility (public|private|team)", "team")
+    .option("-o, --owner <id>", "Owner ID")
+    .action((name, options) => {
+    const teamSystem = new TeamCollaborationSystem(process.cwd());
+    // Create a temporary owner if none provided
+    let ownerId = options.owner;
+    if (!ownerId) {
+        const users = teamSystem.listUsers();
+        if (users.length > 0) {
+            ownerId = users[0].id;
+        }
+        else {
+            // Create admin user implicitly if no users exist
+            const adminId = teamSystem.createUser({
+                username: "admin",
+                email: "admin@example.com",
+                displayName: "System Admin",
+                role: "admin",
+                preferences: { theme: "dark", notifications: true, language: "en" },
+            });
+            ownerId = adminId;
+            console.log(chalk.yellow(`Created default admin user (ID: ${adminId})`));
+        }
+    }
+    const id = teamSystem.createRepository({
+        name,
+        description: options.desc || "Shared repository",
+        ownerId,
+        type: options.type,
+        visibility: options.visibility,
+        items: [],
+        collaborators: [{ userId: ownerId, role: "owner", joinedAt: Date.now() }],
+    });
+    console.log(chalk.green(`Repository created: ${name} (ID: ${id})`));
+});
+repoCmd
+    .command("list")
+    .description("List shared repositories")
+    .action(() => {
+    const teamSystem = new TeamCollaborationSystem(process.cwd());
+    const repos = teamSystem.listRepositories();
+    console.log(chalk.cyan("\n📦 Shared Repositories\n"));
+    if (repos.length === 0) {
+        console.log(chalk.gray("  No repositories found"));
+    }
+    else {
+        repos.forEach((r) => {
+            console.log(`  ${chalk.green(r.name)} (ID: ${r.id})`);
+            console.log(`    ${chalk.gray("Type:")} ${r.type}`);
+            console.log(`    ${chalk.gray("Items:")} ${r.items.length}`);
+            console.log();
+        });
+    }
+});
+// ============================================================================
+// Process Command
+// ============================================================================
+program
+    .command("process")
+    .description("Process input files with the full pipeline")
+    .argument("<input...>", "Input files, directories, or URLs")
+    .option("-m, --mode <mode>", "Processing mode", "full_pipeline")
+    .option("--model <model>", "Model for all agents (single or comma-separated)")
+    .option("-e, --export <formats>", "Export formats (comma-separated)", "markdown")
+    .option("--ui-mockups", "Generate UI mockups")
+    .option("--security", "Enable security scanning")
+    .option("--performance", "Enable performance profiling")
+    .option("--dry-run", "Show plan without executing")
+    .option("--agents <kv>", "Agent overrides (key=value pairs)")
+    .option("-o, --output-dir <dir>", "Output directory", "./synapsexcoder_output")
+    .option("--session <id>", "Attach to team session")
+    .option("--no-parallel", "Disable parallel execution")
+    .option("--research", "Enable web research phase")
+    .option("--docs", "Generate documentation")
+    // Gatekeeper options
+    .option("--gatekeeper", "Enable gatekeeper review (default: enabled)", true)
+    .option("--no-gatekeeper", "Disable gatekeeper review")
+    .option("--gatekeeper-level <level>", "Gatekeeper review level (quick|standard|thorough)", "standard")
+    .option("--gatekeeper-revisions <num>", "Max gatekeeper revisions per phase", "3")
+    .option("--gatekeeper-strict", "Enable strict gatekeeper mode")
+    .action(async (inputs, options) => {
+    const spinner = ora("Initializing SynapseXcoder V1...").start();
+    try {
+        // Load configuration
+        const runtimeConfig = await loadConfig(options.config);
+        // Validate inputs
+        const validInputs = await validateInputs(inputs);
+        spinner.succeed(`Validated ${validInputs.length} input(s)`);
+        // Show execution plan if dry-run
+        if (options.dryRun) {
+            spinner.info(chalk.cyan("DRY RUN - Execution Plan:"));
+            console.log(chalk.gray(`
+          1. Read input files
+          ${options.research ? "2. Execute research phase (Researcher Agent)" : ""}
+          ${options.research ? "3. Execute planning phase (Planner Agent)" : "2. Execute planning phase (Planner Agent)"}
+          ${options.research ? "4. Execute analysis phase (Analyzer Agent)" : "3. Execute analysis phase (Analyzer Agent)"}
+          ${options.research ? "5. Gatekeeper review (Analyzer phase)" : "4. Gatekeeper review (Analyzer phase)"}
+          ${options.research ? "6. Review findings (Reviewer Agent)" : "5. Review findings (Reviewer Agent)"}
+          ${options.research ? "7. Gatekeeper review (Reviewer phase)" : "6. Gatekeeper review (Reviewer phase)"}
+          ${options.research ? "8. Apply fixes (Rewriter Agent)" : "7. Apply fixes (Rewriter Agent)"}
+          ${options.research ? "9. Gatekeeper review (Rewriter phase)" : "8. Gatekeeper review (Rewriter phase)"}
+          ${options.docs ? (options.research ? "10. Generate documentation" : "9. Generate documentation") : ""}
+          ${options.research ? (options.docs ? "11. Final gatekeeper review" : "10. Final gatekeeper review") : options.docs ? "10. Final gatekeeper review" : "9. Final gatekeeper review"}
+          ${options.research ? (options.docs ? "12. Generate output" : "11. Generate output") : options.docs ? "11. Generate output" : "10. Generate output"}
+        `));
+            return;
+        }
+        // Execute pipeline with gatekeeper options
+        const gatekeeperConfig = {
+            enabled: options.gatekeeper !== false,
+            reviewLevel: options.gatekeeperLevel || "standard",
+            maxRevisions: parseInt(options.gatekeeperRevisions || "3", 10),
+            strictMode: options.gatekeeperStrict || false,
+        };
+        spinner.start(chalk.blue("Processing..."));
+        const result = await executePipeline(validInputs, options, runtimeConfig, gatekeeperConfig);
+        spinner.succeed(chalk.green("Processing complete!"));
+        displayResults(result, options, gatekeeperConfig);
+    }
+    catch (error) {
+        spinner.fail(chalk.red(`Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+});
+// ============================================================================
+// Analyze Command
+// ============================================================================
+program
+    .command("analyze")
+    .description("Analyze input without modifications")
+    .argument("<input>", "Input file or directory")
+    .option("-f, --focus <types>", "Analysis focus areas (comma-separated)")
+    .option("-o, --output <file>", "Output report file")
+    .option("--suggest-fixes", "Include fix suggestions")
+    .action(async (input, options) => {
+    const spinner = ora("Analyzing...").start();
+    try {
+        const result = await analyzeInput(input, options);
+        spinner.succeed(chalk.green("Analysis complete!"));
+        if (options.output) {
+            // Write to file
+            console.log(chalk.gray(`Results written to: ${options.output}`));
+        }
+        else {
+            displayAnalysisResults(result, options);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red(`Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+});
+// ============================================================================
+// Agent Commands
+// ============================================================================
+const agentCmd = program.command("agent").description("Manage agents");
+agentCmd
+    .command("list")
+    .description("List available agents")
+    .option("-r, --running", "Show only running agents")
+    .action((options) => {
+    const agents = getAgentList();
+    const running = options.running
+        ? agents.filter((a) => a.status !== "idle")
+        : agents;
+    console.log(chalk.cyan("\nSynapseXcoder V6 Agents\n"));
+    running.forEach((agent) => {
+        const statusColor = agent.status === "running"
+            ? chalk.green
+            : agent.status === "idle"
+                ? chalk.gray
+                : chalk.yellow;
+        console.log(`  ${statusColor("●")} ${chalk.bold(agent.name)} - ${agent.type}`);
+        console.log(`    ${chalk.gray("Model:")} ${agent.model}`);
+        console.log(`    ${chalk.gray("Status:")} ${statusColor(agent.status)}`);
+        console.log();
+    });
+});
+agentCmd
+    .command("spawn")
+    .description("Spawn a new agent")
+    .argument("<type>", "Agent type (planner|analyzer|reviewer|rewriter|ui_designer|researcher)")
+    .option("-t, --task <prompt>", "Task for the agent")
+    .option("-m, --model <model>", "Model override")
+    .action(async (type, options) => {
+    console.log(chalk.cyan(`Spawning ${type} agent...`));
+    const task = options.task || "No task specified";
+    console.log(chalk.gray(`Task: ${task}`));
+    try {
+        const delegate = new AgentDelegate(process.cwd());
+        // For now, we delegate the task. In a real scenario, this might start a long-running process.
+        // We'll treat "spawn" as "delegate task" for this iteration.
+        const result = await delegate.delegate(type, task);
+        if (result.success) {
+            console.log(chalk.green("Agent execution successful!"));
+            if (result.thoughtID) {
+                console.log(chalk.gray(`Recorded thought ID: ${result.thoughtID}`));
+            }
+            console.log("\nOutput:");
+            console.log(result.output);
+        }
+        else {
+            console.log(chalk.red("Agent execution failed."));
+            console.log(chalk.gray(result.output));
+        }
+    }
+    catch (error) {
+        console.log(chalk.red(`Failed to spawn agent: ${error instanceof Error ? error.message : error}`));
+    }
+});
+agentCmd
+    .command("learn")
+    .description("Execute a task and learn from the result")
+    .argument("<agent>", "Agent to use")
+    .argument("<task>", "Task description")
+    .option("--verify <cmd>", "Command to verify success")
+    .action(async (agent, task, options) => {
+    console.log(chalk.cyan(`Starting learning session with ${agent}...`));
+    try {
+        const delegate = new AgentDelegate(process.cwd());
+        const result = await delegate.learnFromExecution(agent, task, options.verify);
+        if (result.success) {
+            console.log(chalk.green("Task completed and learned!"));
+            console.log(result.output);
+        }
+        else {
+            console.log(chalk.red("Task failed."));
+            console.log(result.output);
+        }
+    }
+    catch (error) {
+        console.log(chalk.red(`Learning failed: ${error instanceof Error ? error.message : error}`));
+    }
+});
+agentCmd
+    .command("status")
+    .description("Show agent status")
+    .argument("[agent-id]", "Agent ID (optional, shows all if not specified)")
+    .option("-j, --json", "Output as JSON")
+    .action(async (agentId, options) => {
+    // Query real agent status from the MessageBus
+    const messageBus = new MessageBus({ enableLogging: false });
+    const busStats = messageBus.getStats();
+    const agentTypes = [
+        "master",
+        "planner",
+        "analyzer",
+        "reviewer",
+        "rewriter",
+        "ui_designer",
+        "researcher",
+        "gatekeeper",
+    ];
+    // Build real status info from MessageBus queues
+    const agentStatuses = agentTypes.map((agentType) => {
+        const queueSize = messageBus.getQueueSize(agentType);
+        // Determine state: if the queue has messages, it's "active"; otherwise "idle"
+        // In a persistent daemon scenario the message bus would track agent registrations;
+        // for CLI invocation we infer from queue state.
+        let state = "idle";
+        if (queueSize > 0)
+            state = "active";
+        return {
+            type: agentType,
+            id: `${agentType}-agent`,
+            state,
+            pendingMessages: queueSize,
+            role: agentType === "master" ? "primary" : "subagent",
+        };
+    });
+    const statusInfo = {
+        timestamp: new Date().toISOString(),
+        uptime: `${Math.floor(process.uptime())}s`,
+        memoryMB: Math.round((process.memoryUsage().heapUsed / 1024 / 1024) * 100) / 100,
+        messageBus: {
+            totalMessages: busStats.totalMessages,
+            pendingTasks: busStats.pendingTasks,
+            queues: busStats.queues,
+        },
+        agents: agentStatuses,
+    };
+    if (options.json) {
+        console.log(JSON.stringify(statusInfo, null, 2));
+        return;
+    }
+    if (agentId) {
+        // Show status for a specific agent
+        const agent = agentStatuses.find((a) => a.type === agentId || a.id === agentId);
+        if (!agent) {
+            console.log(chalk.red(`  Agent not found: ${agentId}`));
+            console.log(chalk.gray(`  Available: ${agentTypes.join(", ")}`));
+            return;
+        }
+        const stateColor = agent.state === "active"
+            ? chalk.green
+            : chalk.gray;
+        console.log(chalk.cyan(`\n📊 Agent Status: ${agent.type}\n`));
+        console.log(`  ID:               ${chalk.bold(agent.id)}`);
+        console.log(`  Role:             ${chalk.gray(agent.role)}`);
+        console.log(`  State:            ${stateColor(agent.state)}`);
+        console.log(`  Pending Messages: ${chalk.yellow(String(agent.pendingMessages))}`);
+        console.log(`  Uptime:           ${chalk.gray(statusInfo.uptime)}`);
+        console.log();
+    }
+    else {
+        // Show all agents
+        const activeCount = agentStatuses.filter((a) => a.state === "active").length;
+        console.log(chalk.cyan("\n📊 Agent Status Overview\n"));
+        console.log(`  Uptime:           ${chalk.gray(statusInfo.uptime)}`);
+        console.log(`  Memory:           ${chalk.gray(`${statusInfo.memoryMB} MB`)}`);
+        console.log(`  Total Messages:   ${chalk.gray(String(statusInfo.messageBus.totalMessages))}`);
+        console.log(`  Pending Tasks:    ${chalk.yellow(String(statusInfo.messageBus.pendingTasks))}`);
+        console.log();
+        if (activeCount === 0) {
+            console.log(chalk.gray("  No active agents — all agents are idle."));
+            console.log();
+        }
+        console.log(chalk.bold("  Agents:"));
+        for (const agent of agentStatuses) {
+            const stateColor = agent.state === "active"
+                ? chalk.green
+                : chalk.gray;
+            const stateIcon = agent.state === "active"
+                ? "●"
+                : "○";
+            const queueInfo = agent.pendingMessages > 0
+                ? chalk.yellow(` [${agent.pendingMessages} msg]`)
+                : "";
+            console.log(`    ${stateColor(stateIcon)} ${chalk.bold(agent.type.padEnd(14))} ${stateColor(agent.state.padEnd(12))} ${chalk.gray(agent.role)}${queueInfo}`);
+        }
+        console.log();
+    }
+});
+agentCmd
+    .command("kill")
+    .description("Terminate an agent")
+    .argument("<agent-id>", "Agent ID to terminate")
+    .option("-f, --force", "Force kill")
+    .action(async (agentId, options) => {
+    console.log(chalk.yellow(`Terminating agent: ${agentId}`));
+    try {
+        const messageBus = new MessageBus({ enableLogging: false });
+        const agentTypes = [
+            "master",
+            "planner",
+            "analyzer",
+            "reviewer",
+            "rewriter",
+            "ui_designer",
+            "researcher",
+            "gatekeeper",
+        ];
+        // Check if the agentId matches a known agent type
+        const matchedType = agentTypes.find((t) => t === agentId || `${t}-agent` === agentId);
+        if (!matchedType) {
+            console.log(chalk.red(`  ✗ Agent not found: ${agentId}`));
+            console.log(chalk.gray(`  Available agent types: ${agentTypes.join(", ")}`));
+            return;
+        }
+        // Send termination/abort signal via message bus
+        if (options.force) {
+            console.log(chalk.red("  Force killing — sending abort signal..."));
+        }
+        await messageBus.sendAbortSignal("master", `Termination requested for agent ${matchedType}${options.force ? " (forced)" : ""}`);
+        // Clear the agent's message queue
+        messageBus.clearQueue(matchedType);
+        // Cancel any pending tasks associated with this agent
+        const stats = messageBus.getStats();
+        const pendingCount = stats.pendingTasks;
+        console.log(chalk.green(`  ✓ Agent "${matchedType}" terminated`));
+        console.log(chalk.gray(`    Queue cleared`));
+        if (pendingCount > 0) {
+            console.log(chalk.gray(`    ${pendingCount} pending task(s) in bus`));
+        }
+    }
+    catch (error) {
+        console.log(chalk.red(`  ✗ Failed to terminate agent: ${error instanceof Error ? error.message : String(error)}`));
+    }
+});
+agentCmd
+    .command("kill-all")
+    .description("Terminate all running agents")
+    .action(async () => {
+    console.log(chalk.yellow("Terminating all agents..."));
+    try {
+        const messageBus = new MessageBus({ enableLogging: false });
+        const agentTypes = [
+            "master",
+            "planner",
+            "analyzer",
+            "reviewer",
+            "rewriter",
+            "ui_designer",
+            "researcher",
+            "gatekeeper",
+        ];
+        // Broadcast abort signal to all agents
+        await messageBus.sendAbortSignal("master", "Kill-all: terminating all agents");
+        // Clear every agent queue
+        let clearedCount = 0;
+        for (const agentType of agentTypes) {
+            const queueSize = messageBus.getQueueSize(agentType);
+            messageBus.clearQueue(agentType);
+            if (queueSize > 0)
+                clearedCount += queueSize;
+        }
+        // Reset the entire message bus (clears pending tasks, message history, etc.)
+        const stats = messageBus.getStats();
+        const pendingTasks = stats.pendingTasks;
+        messageBus.reset();
+        console.log(chalk.green(`  ✓ ${agentTypes.length} agent(s) terminated`));
+        if (clearedCount > 0) {
+            console.log(chalk.gray(`    ${clearedCount} queued message(s) cleared`));
+        }
+        if (pendingTasks > 0) {
+            console.log(chalk.gray(`    ${pendingTasks} pending task(s) cancelled`));
+        }
+        console.log(chalk.gray("    Message bus reset"));
+    }
+    catch (error) {
+        console.log(chalk.red(`  ✗ Failed to terminate agents: ${error instanceof Error ? error.message : String(error)}`));
+    }
+});
+// ============================================================================
+// OpenCode Commands
+// ============================================================================
+const opencodeCmd = program
+    .command("opencode")
+    .description("OpenCode CLI integration");
+opencodeCmd
+    .command("run")
+    .description("Run OpenCode command")
+    .argument("<command...>", "Command to run")
+    .action(async (commandArgs) => {
+    const spinner = ora("Running OpenCode...").start();
+    try {
+        const result = await runOpenCodeCommand(commandArgs);
+        if (result.success) {
+            spinner.succeed(chalk.green("OpenCode command executed successfully"));
+            if (result.output) {
+                console.log(result.output);
+            }
+        }
+        else {
+            spinner.fail(chalk.red(`OpenCode command failed: ${result.error}`));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red(`Error: ${error instanceof Error ? error.message : error}`));
+    }
+});
+opencodeCmd
+    .command("serve")
+    .description("Start OpenCode in server mode")
+    .option("-p, --port <n>", "Port number", "4096")
+    .action(async (options) => {
+    if (!checkOpenCodeAvailable()) {
+        console.log(chalk.red("OpenCode CLI not found. Please install OpenCode first."));
+        console.log(chalk.gray("Run: npm install -g @opencode/cli"));
+        return;
+    }
+    console.log(chalk.cyan(`Starting OpenCode server on port ${options.port}...`));
+    try {
+        const result = await runOpenCodeCommand([
+            "serve",
+            "--port",
+            options.port,
+        ]);
+        if (result.success) {
+            console.log(chalk.green("OpenCode server started successfully"));
+        }
+        else {
+            console.log(chalk.red(`Failed to start OpenCode server: ${result.error}`));
+        }
+    }
+    catch (error) {
+        console.log(chalk.red(`Error starting server: ${error instanceof Error ? error.message : error}`));
+    }
+});
+opencodeCmd
+    .command("tools")
+    .description("List available OpenCode tools")
+    .action(async () => {
+    if (!checkOpenCodeAvailable()) {
+        console.log(chalk.yellow("⚠️  OpenCode CLI not found on system"));
+        console.log(chalk.gray("Showing built-in tool expectations...\n"));
+    }
+    else {
+        console.log(chalk.green("✓ OpenCode CLI detected"));
+        console.log(chalk.gray("Querying available tools...\n"));
+    }
+    const tools = [
+        {
+            name: "read_file",
+            category: "filesystem",
+            description: "Read file contents",
+        },
+        {
+            name: "write_file",
+            category: "filesystem",
+            description: "Write to file",
+        },
+        {
+            name: "edit_file",
+            category: "filesystem",
+            description: "Edit file contents",
+        },
+        {
+            name: "list_dir",
+            category: "filesystem",
+            description: "List directory",
+        },
+        {
+            name: "search_files",
+            category: "filesystem",
+            description: "Search file patterns",
+        },
+        {
+            name: "run_bash",
+            category: "execution",
+            description: "Execute bash commands",
+        },
+        { name: "web_search", category: "web", description: "Search the web" },
+        { name: "fetch_url", category: "web", description: "Fetch URL content" },
+        { name: "call_mcp", category: "mcp", description: "Call MCP server" },
+    ];
+    console.log(chalk.cyan("\n🔧 Available OpenCode Tools\n"));
+    const categories = [...new Set(tools.map((t) => t.category))];
+    categories.forEach((category) => {
+        console.log(chalk.bold(`\n${category.toUpperCase()}`));
+        tools
+            .filter((t) => t.category === category)
+            .forEach((tool) => {
+            console.log(`  ${chalk.green(tool.name)} - ${tool.description}`);
+        });
+    });
+    console.log();
+});
+opencodeCmd
+    .command("config")
+    .description("Configure OpenCode settings")
+    .command("edit")
+    .description("Edit OpenCode configuration")
+    .action(() => {
+    if (!checkOpenCodeAvailable()) {
+        console.log(chalk.red("OpenCode CLI not found. Please install OpenCode first."));
+        return;
+    }
+    console.log(chalk.cyan("Opening OpenCode configuration..."));
+    console.log(chalk.gray("Note: This would open the OpenCode config editor"));
+    console.log(chalk.gray("For now, you can manually edit: ~/.config/opencode/config.json"));
+});
+// ============================================================================
+// Context Commands
+// ============================================================================
+const contextCmd = program
+    .command("context")
+    .description("Manage execution context");
+contextCmd
+    .command("save")
+    .description("Save current context")
+    .argument("<name>", "Context name")
+    .action((name) => {
+    try {
+        const context = getCurrentContext();
+        saveContext(name, context);
+        console.log(chalk.green(`Context '${name}' saved successfully`));
+    }
+    catch (error) {
+        console.log(chalk.red(`Failed to save context: ${error instanceof Error ? error.message : error}`));
+    }
+});
+contextCmd
+    .command("load")
+    .description("Load saved context")
+    .argument("<name>", "Context name")
+    .action((name) => {
+    try {
+        const context = loadContext(name);
+        if (context) {
+            console.log(chalk.green(`Context '${name}' loaded successfully`));
+            console.log(chalk.gray("Note: Context loading is conceptual - full implementation requires state management"));
+        }
+        else {
+            console.log(chalk.red(`Context '${name}' not found`));
+        }
+    }
+    catch (error) {
+        console.log(chalk.red(`Failed to load context: ${error instanceof Error ? error.message : error}`));
+    }
+});
+contextCmd
+    .command("list")
+    .description("List saved contexts")
+    .action(() => {
+    const contexts = listContexts();
+    console.log(chalk.cyan("\n📦 Saved Contexts\n"));
+    if (contexts.length === 0) {
+        console.log(chalk.gray("  No saved contexts found"));
+    }
+    else {
+        contexts.forEach((ctx) => {
+            console.log(`  ${chalk.green(ctx.name)}`);
+            console.log(`    ${chalk.gray("Saved:")} ${ctx.savedAt}`);
+            console.log(`    ${chalk.gray("Size:")} ${ctx.size} bytes`);
+            console.log();
+        });
+    }
+    console.log();
+});
+contextCmd
+    .command("show")
+    .description("Show current context")
+    .action(() => {
+    const context = getCurrentContext();
+    console.log(chalk.cyan("\n📋 Current Context\n"));
+    console.log(chalk.gray(`  Mode: ${context.mode}`));
+    console.log(chalk.gray(`  Timestamp: ${context.timestamp}`));
+    console.log(chalk.gray(`  Version: ${context.version}`));
+    const agents = context.agents;
+    console.log(chalk.gray(`  Agents: ${agents.length} total`));
+    agents.forEach((agent) => {
+        const statusColor = agent.status === "running" ? chalk.green : chalk.gray;
+        console.log(`    - ${agent.name}: ${statusColor(agent.status)}`);
+    });
+    console.log();
+});
+contextCmd
+    .command("delete")
+    .description("Delete saved context")
+    .argument("<name>", "Context name")
+    .action((name) => {
+    if (deleteContext(name)) {
+        console.log(chalk.green(`Context '${name}' deleted successfully`));
+    }
+    else {
+        console.log(chalk.red(`Context '${name}' not found`));
+    }
+});
+contextCmd
+    .command("export")
+    .description("Export context to file")
+    .argument("[file]", "Output file (stdout if not specified)")
+    .action((file) => {
+    const context = getCurrentContext();
+    const data = JSON.stringify(context, null, 2);
+    if (file) {
+        try {
+            // Validate path to prevent traversal attacks
+            const validatedPath = validateAndResolve(file, process.cwd());
+            writeFileSync(validatedPath, data);
+            console.log(chalk.green(`Context exported to: ${validatedPath}`));
+        }
+        catch (error) {
+            console.log(chalk.red(`Failed to export context: ${error instanceof Error ? error.message : error}`));
+        }
+    }
+    else {
+        console.log(data);
+    }
+});
+contextCmd
+    .command("import")
+    .description("Import context from file")
+    .argument("[file]", "Input file (stdin if not specified)")
+    .action(async (file) => {
+    try {
+        let data;
+        if (file) {
+            if (!existsSync(file)) {
+                console.log(chalk.red(`File not found: ${file}`));
+                return;
+            }
+            data = readFileSync(file, "utf-8");
+        }
+        else {
+            // Read from stdin
+            const chunks = [];
+            for await (const chunk of process.stdin)
+                chunks.push(chunk);
+            data = Buffer.concat(chunks).toString("utf-8");
+        }
+        const context = JSON.parse(data);
+        console.log(chalk.green("Context imported successfully"));
+        console.log(chalk.gray("Note: Context import is conceptual - full implementation requires state management"));
+        console.log(chalk.gray(`Imported context mode: ${context.mode || "unknown"}`));
+    }
+    catch (error) {
+        console.log(chalk.red(`Failed to import context: ${error instanceof Error ? error.message : error}`));
+    }
+});
+// ============================================================================
+// Merge Command
+// ============================================================================
+program
+    .command("merge")
+    .description("Merge multiple inputs")
+    .argument("<inputs...>", "Input files to merge")
+    .option("-s, --strategy <strategy>", "Merge strategy", "semantic")
+    .option("-o, --output <file>", "Output file")
+    .option("-i, --interactive", "Interactive conflict resolution")
+    .action(async (inputs, options) => {
+    const spinner = ora("Merging...").start();
+    try {
+        // Validate inputs
+        await validateInputs(inputs);
+        // Perform merge
+        const mergedContent = await mergeInputs(inputs, options);
+        spinner.succeed(chalk.green("Merge complete!"));
+        if (options.output) {
+            writeFileSync(options.output, mergedContent);
+            console.log(chalk.gray(`Merged content written to: ${options.output}`));
+        }
+        else {
+            console.log(mergedContent);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red(`Merge failed: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+});
+// ============================================================================
+// Config Command
+// ============================================================================
+const configCmd = program
+    .command("config")
+    .description("Configuration management");
+configCmd
+    .command("init")
+    .description("Initialize default configuration")
+    .action(() => {
+    try {
+        const defaultConfig = getDefaultConfig();
+        saveConfigFile(defaultConfig);
+        console.log(chalk.green("Configuration initialized successfully"));
+        console.log(chalk.gray(`Config file created at: ${CONFIG_FILE}`));
+    }
+    catch (error) {
+        console.log(chalk.red(`Failed to initialize config: ${error instanceof Error ? error.message : error}`));
+    }
+});
+configCmd
+    .command("validate")
+    .description("Validate configuration")
+    .action(() => {
+    console.log(chalk.cyan("Validating configuration..."));
+    console.log(chalk.green("✓ Configuration is valid"));
+});
+configCmd
+    .command("show")
+    .description("Show current configuration")
+    .action(() => {
+    const config = loadConfigFile();
+    console.log(chalk.cyan("\n⚙️  Current Configuration\n"));
+    console.log(stringifyYaml(config));
+});
+configCmd
+    .command("set")
+    .description("Set configuration value")
+    .argument("<key>", "Configuration key")
+    .argument("<value>", "Configuration value")
+    .action((key, value) => {
+    try {
+        setConfigValue(key, value);
+        console.log(chalk.green(`Configuration updated: ${key} = ${value}`));
+    }
+    catch (error) {
+        console.log(chalk.red(`Failed to set config: ${error instanceof Error ? error.message : error}`));
+    }
+});
+configCmd
+    .command("get")
+    .description("Get configuration value")
+    .argument("<key>", "Configuration key")
+    .action((key) => {
+    const value = getConfigValue(key);
+    if (value === undefined) {
+        console.log(chalk.red(`${key}: (not found)`));
+    }
+    else {
+        console.log(chalk.cyan(`${key}:`));
+        console.log(typeof value === "object"
+            ? JSON.stringify(value, null, 2)
+            : String(value));
+    }
+});
+// ============================================================================
+// Knowledge Vault Command (/vault search, /vault prune via CLI)
+// ============================================================================
+const vaultCmd = program
+    .command("vault")
+    .description("Synapse Knowledge Vault — search and manage stored docs");
+vaultCmd
+    .command("search")
+    .description("Search vault entries by keyword")
+    .argument("<query>", "Search query")
+    .option("-l, --limit <n>", "Max results", "20")
+    .action((query, options) => {
+    const vault = new KnowledgeVault();
+    vault.rebuildManifest();
+    const results = vault.search(query, parseInt(String(options.limit), 10) || 20);
+    if (results.length === 0) {
+        console.log(chalk.yellow(`No vault matches for: ${query}`));
+        return;
+    }
+    console.log(chalk.cyan(`\n📚 Vault search: "${query}" (${results.length} results)\n`));
+    for (const r of results) {
+        console.log(chalk.green(`  [${r.score}] ${r.entry.title}`));
+        if (r.entry.sourceUrl)
+            console.log(chalk.gray(`      ${r.entry.sourceUrl}`));
+        if (r.snippet)
+            console.log(chalk.gray(`      …${r.snippet}…`));
+    }
+});
+vaultCmd
+    .command("prune")
+    .description("Apply retention policy and remove stale entries")
+    .option("--dry-run", "Preview removals without deleting")
+    .action((options) => {
+    const vault = new KnowledgeVault();
+    vault.rebuildManifest();
+    const result = vault.prune(Boolean(options.dryRun));
+    const label = options.dryRun ? "Would remove" : "Removed";
+    console.log(chalk.cyan(`\n🗄️  Vault prune: ${label} ${result.removed.length} entries, retained ${result.retained}, freed ${result.freedBytes} bytes\n`));
+});
+vaultCmd
+    .command("stats")
+    .description("Show vault statistics")
+    .action(() => {
+    const vault = new KnowledgeVault();
+    const stats = vault.getStats();
+    console.log(chalk.cyan("\n🗄️  Synapse Knowledge Vault\n"));
+    console.log(`  Path:    ${stats.path}`);
+    console.log(`  Entries: ${stats.entries}`);
+    console.log(`  Size:    ${stats.totalBytes} bytes`);
+    console.log(`  Topics:  ${JSON.stringify(stats.topics)}`);
+});
+vaultCmd
+    .command("rebuild")
+    .description("Rebuild manifest from disk contents")
+    .action(() => {
+    const vault = new KnowledgeVault();
+    const manifest = vault.rebuildManifest();
+    console.log(chalk.green(`Manifest rebuilt: ${manifest.entries.length} entries`));
+});
+vaultCmd
+    .command("ingest")
+    .description("Ingest OpenCode docs from .firecrawl/opencode-docs cache")
+    .action(() => {
+    const result = ingestOpenCodeDocs();
+    for (const warning of result.warnings) {
+        console.log(chalk.yellow(`  ⚠ ${warning}`));
+    }
+    console.log(chalk.green(`Ingested ${result.ingested}/${result.total} documents → ${result.vaultPath}/index.json`));
+});
+// ============================================================================
+// OpenCode Integration Functions
+// ============================================================================
+function checkOpenCodeAvailable() {
+    try {
+        // Check if opencode command is available
+        execSync("which opencode", { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function runOpenCodeCommand(args) {
+    return new Promise((resolve) => {
+        if (!checkOpenCodeAvailable()) {
+            resolve({
+                success: false,
+                output: "",
+                error: "OpenCode CLI not found. Please install OpenCode first.",
+            });
+            return;
+        }
+        const child = spawn("opencode", args, { stdio: "pipe" });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on("data", (data) => {
+            stderr += data.toString();
+        });
+        child.on("close", (code) => {
+            resolve({
+                success: code === 0,
+                output: stdout,
+                error: stderr,
+            });
+        });
+        child.on("error", (error) => {
+            resolve({
+                success: false,
+                output: "",
+                error: error.message,
+            });
+        });
+    });
+}
+const CONFIG_DIR = join(homedir(), ".synapsexcoder");
+const CONFIG_FILE = join(CONFIG_DIR, "config.yaml");
+function ensureConfigDir() {
+    try {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    catch (error) {
+        // Directory already exists or can't create - ignore
+    }
+}
+function loadConfigFile() {
+    if (!existsSync(CONFIG_FILE)) {
+        return getDefaultConfig();
+    }
+    try {
+        const content = readFileSync(CONFIG_FILE, "utf-8");
+        return parseYaml(content);
+    }
+    catch {
+        console.warn(chalk.yellow("Warning: Could not load config file, using defaults"));
+        return getDefaultConfig();
+    }
+}
+function saveConfigFile(config) {
+    ensureConfigDir();
+    try {
+        const yamlContent = stringifyYaml(config);
+        writeFileSync(CONFIG_FILE, yamlContent);
+    }
+    catch (error) {
+        throw new Error(`Failed to save config: ${error instanceof Error ? error.message : error}`);
+    }
+}
+function setConfigValue(key, value) {
+    const config = loadConfigFile();
+    const keys = key.split(".");
+    // Validate keys to prevent prototype pollution
+    const dangerousKeys = ["__proto__", "constructor", "prototype"];
+    for (const k of keys) {
+        if (dangerousKeys.includes(k)) {
+            throw new Error(`Dangerous key detected: ${k}. Cannot modify prototype chain.`);
+        }
+        if (k === "" || k.includes("\\") || k.includes("/")) {
+            throw new Error(`Invalid key: ${k}`);
+        }
+    }
+    let current = config;
+    // Navigate to the nested property safely
+    for (let i = 0; i < keys.length - 1; i++) {
+        const k = keys[i];
+        if (!(k in current) ||
+            typeof current[k] !== "object" ||
+            current[k] === null) {
+            // Use Object.create(null) to prevent prototype pollution
+            current[k] = Object.create(null);
+        }
+        current = current[k];
+    }
+    // Set the value (try to parse as JSON, otherwise keep as string)
+    const finalKey = keys[keys.length - 1];
+    try {
+        const parsedValue = JSON.parse(value);
+        Object.defineProperty(current, finalKey, {
+            value: parsedValue,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    catch {
+        Object.defineProperty(current, finalKey, {
+            value: value,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    saveConfigFile(config);
+}
+function getConfigValue(key) {
+    const config = loadConfigFile();
+    const keys = key.split(".");
+    let current = config;
+    for (const k of keys) {
+        if (typeof current !== "object" || current === null || !(k in current)) {
+            return undefined;
+        }
+        current = current[k];
+    }
+    return current;
+}
+const CONTEXT_DIR = join(homedir(), ".synapsexcoder", "contexts");
+function ensureContextDir() {
+    try {
+        mkdirSync(CONTEXT_DIR, { recursive: true });
+    }
+    catch (error) {
+        // Directory already exists or can't create - ignore
+    }
+}
+function getContextPath(name) {
+    return join(CONTEXT_DIR, `${name}.json`);
+}
+function saveContext(name, context) {
+    ensureContextDir();
+    const contextData = {
+        name,
+        savedAt: new Date().toISOString(),
+        version: "5.0.0",
+        data: context,
+    };
+    writeFileSync(getContextPath(name), JSON.stringify(contextData, null, 2));
+}
+function loadContext(name) {
+    const path = getContextPath(name);
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(path, "utf-8");
+        const contextData = JSON.parse(content);
+        return contextData.data || {};
+    }
+    catch {
+        return null;
+    }
+}
+function listContexts() {
+    ensureContextDir();
+    try {
+        const files = readdirSync(CONTEXT_DIR);
+        return files
+            .filter((file) => file.endsWith(".json"))
+            .map((file) => {
+            const name = file.replace(".json", "");
+            const path = join(CONTEXT_DIR, file);
+            const stat = statSync(path);
+            let savedAt = "unknown";
+            try {
+                const content = readFileSync(path, "utf-8");
+                const data = JSON.parse(content);
+                savedAt = data.savedAt || "unknown";
+            }
+            catch {
+                // Ignore parse errors
+            }
+            return { name, savedAt, size: stat.size };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function deleteContext(name) {
+    const path = getContextPath(name);
+    if (!existsSync(path)) {
+        return false;
+    }
+    try {
+        unlinkSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getCurrentContext() {
+    return {
+        mode: "full_pipeline",
+        timestamp: new Date().toISOString(),
+        version: "5.0.0",
+        agents: getAgentList().map((a) => ({ name: a.name, status: a.status })),
+        config: getDefaultConfig(),
+    };
+}
+async function loadConfig(configPath) {
+    const defaults = getDefaultConfig();
+    if (!configPath) {
+        return loadConfigFile();
+    }
+    try {
+        const content = readFileSync(resolve(configPath), "utf-8");
+        const loaded = parseYaml(content);
+        return {
+            ...defaults,
+            ...loaded,
+        };
+    }
+    catch {
+        console.warn(chalk.yellow(`Warning: Could not load config at ${configPath}, using defaults`));
+        return defaults;
+    }
+}
+function getDefaultConfig() {
+    return {
+        version: "5.0.0",
+        opencode: {
+            mode: "embedded",
+            serverUrl: "http://localhost:4096",
+        },
+        agents: {
+            master: { model: "anthropic/claude-opus-4-6", temperature: 0.2 },
+            planner: { model: "anthropic/claude-haiku-4-20250514", temperature: 0.1 },
+            analyzer: {
+                model: "anthropic/claude-sonnet-4-20250514",
+                temperature: 0.1,
+            },
+            reviewer: {
+                model: "anthropic/claude-sonnet-4-20250514",
+                temperature: 0.2,
+            },
+            rewriter: { model: "anthropic/claude-opus-4-5", temperature: 0.3 },
+            ui_designer: {
+                model: "anthropic/claude-sonnet-4-20250514",
+                temperature: 0.4,
+            },
+            researcher: {
+                model: "anthropic/claude-haiku-4-20250514",
+                temperature: 0.2,
+            },
+        },
+        processing: {
+            defaultMode: "full_pipeline",
+            autoUIDetection: true,
+            modelFallbacks: [
+                "anthropic/claude-opus-4-6",
+                "anthropic/claude-sonnet-4-20250514",
+                "anthropic/claude-haiku-4-20250514",
+            ],
+        },
+    };
+}
+function normalizeModelAliases(model) {
+    const trimmed = model.trim();
+    if (!trimmed)
+        return [];
+    const aliases = [trimmed];
+    // If provider prefix is missing, try common provider-qualified variants.
+    if (!trimmed.includes("/")) {
+        aliases.push(`github-copilot/${trimmed}`);
+        aliases.push(`openai/${trimmed}`);
+        aliases.push(`anthropic/${trimmed}`);
+        aliases.push(`groq/${trimmed}`);
+        aliases.push(`together/${trimmed}`);
+    }
+    // Add specific model mappings for common names
+    const modelMappings = {
+        "claude-opus": ["anthropic/claude-opus-4-6", "anthropic/claude-opus-4-5"],
+        "claude-sonnet": ["anthropic/claude-sonnet-4-20250514"],
+        "claude-haiku": ["anthropic/claude-haiku-4-20250514"],
+        "gpt-4": ["openai/gpt-4", "openai/gpt-4-turbo"],
+        "gpt-3.5": ["openai/gpt-3.5-turbo"],
+        grok: ["github-copilot/grok-code-fast-1"],
+    };
+    if (modelMappings[trimmed]) {
+        aliases.push(...modelMappings[trimmed]);
+    }
+    return aliases;
+}
+function parseCsvList(raw) {
+    if (!raw)
+        return [];
+    return raw
+        .split(",")
+        .map((v) => v.trim())
+        .filter(Boolean);
+}
+function isProviderModelNotFoundError(error) {
+    const text = String(error || "");
+    return (text.includes("ProviderModelNotFoundError") ||
+        text.includes("ModelNotFound") ||
+        text.includes("model not found") ||
+        text.includes("provider/model"));
+}
+function hasProviderModelNotFoundInResult(result) {
+    if (!result || typeof result !== "object")
+        return false;
+    const asRecord = result;
+    if (isProviderModelNotFoundError(asRecord.error)) {
+        return true;
+    }
+    const output = asRecord.output;
+    if (!output || typeof output !== "object") {
+        return false;
+    }
+    const phases = output["phases"];
+    if (!Array.isArray(phases)) {
+        return false;
+    }
+    return phases.some((phase) => {
+        if (!phase || typeof phase !== "object")
+            return false;
+        const phaseRecord = phase;
+        if (isProviderModelNotFoundError(phaseRecord.error)) {
+            return true;
+        }
+        const phaseOutput = phaseRecord.output;
+        if (phaseOutput && typeof phaseOutput === "object") {
+            return isProviderModelNotFoundError(phaseOutput.error);
+        }
+        return false;
+    });
+}
+function getByPath(obj, path) {
+    const keys = path.split(".");
+    let current = obj;
+    for (const key of keys) {
+        if (typeof current !== "object" || current === null || !(key in current)) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+function resolveModelCandidates(options, config) {
+    const candidates = [];
+    // Highest priority: explicit user-selected model(s).
+    // Always try the user selection first, then configured fallbacks.
+    // This keeps user intent while still preventing hard failures when a
+    // provider cannot resolve the selected model.
+    const cliModels = parseCsvList(options["model"]);
+    if (cliModels.length > 0) {
+        candidates.push(...cliModels);
+        // If user supplied bare model IDs (without provider prefix), expand aliases
+        // after the exact choice so provider-qualified variants can still work.
+        for (const model of cliModels) {
+            candidates.push(...normalizeModelAliases(model));
+        }
+    }
+    // Next: saved config master model
+    const configuredMasterModel = getByPath(config, "agents.master.model");
+    if (typeof configuredMasterModel === "string") {
+        candidates.push(...normalizeModelAliases(configuredMasterModel));
+    }
+    // Optional fallback list from config
+    const configuredFallbacks = getByPath(config, "processing.modelFallbacks");
+    if (Array.isArray(configuredFallbacks)) {
+        for (const model of configuredFallbacks) {
+            if (typeof model === "string") {
+                candidates.push(...normalizeModelAliases(model));
+            }
+        }
+    }
+    // Optional fallback list from env (comma-separated)
+    const envFallbacks = parseCsvList(process.env.DUCKY_MODEL_FALLBACKS);
+    for (const model of envFallbacks) {
+        candidates.push(...normalizeModelAliases(model));
+    }
+    // Hard fallback
+    candidates.push(...normalizeModelAliases("anthropic/claude-opus-4-6"), ...normalizeModelAliases("anthropic/claude-sonnet-4-20250514"), ...normalizeModelAliases("anthropic/claude-haiku-4-20250514"), ...normalizeModelAliases("github-copilot/grok-code-fast-1"), ...normalizeModelAliases("openai/gpt-4-turbo"));
+    // De-duplicate while preserving order
+    return [...new Set(candidates)];
+}
+/** Supported code file extensions for validation */
+const SUPPORTED_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".py",
+    ".rs",
+    ".go",
+    ".java",
+    ".c",
+    ".cpp",
+    ".h",
+    ".css",
+    ".scss",
+    ".html",
+    ".json",
+    ".yaml",
+    ".yml",
+    ".md",
+    ".sh",
+    ".bash",
+    ".sql",
+    ".graphql",
+    ".xml",
+    ".toml",
+]);
+/** Size thresholds in bytes */
+const WARN_SIZE_THRESHOLD = 100 * 1024; // 100KB
+const REJECT_SIZE_THRESHOLD = 1024 * 1024; // 1MB
+/**
+ * Check if a file appears to be binary by reading its first chunk.
+ * Returns true if the file contains null bytes (a strong binary indicator).
+ */
+function isBinaryFile(filePath) {
+    try {
+        // Read first 8KB to check for binary content
+        const fd = openSync(filePath, "r");
+        const buf = Buffer.alloc(8192);
+        const bytesRead = readSync(fd, buf, 0, 8192, 0);
+        closeSync(fd);
+        for (let i = 0; i < bytesRead; i++) {
+            if (buf[i] === 0)
+                return true; // Null byte → binary
+        }
+        return false;
+    }
+    catch {
+        return false; // If we can't read, let downstream handle it
+    }
+}
+async function validateInputs(inputs) {
+    const valid = [];
+    const cwd = process.cwd();
+    for (const input of inputs) {
+        // Resolve to absolute path safely
+        let abs;
+        try {
+            abs = validateAndResolve(input, cwd);
+        }
+        catch (error) {
+            console.warn(chalk.red(`  ✗ Rejected: ${input} — ${error instanceof Error ? error.message : String(error)}`));
+            continue;
+        }
+        // Check existence
+        if (!existsSync(abs)) {
+            console.warn(chalk.red(`  ✗ Rejected: ${input} — file not found`));
+            continue;
+        }
+        const stat = statSync(abs);
+        // Handle directories: skip with note (pipeline expects files)
+        if (stat.isDirectory()) {
+            console.warn(chalk.yellow(`  ⚠ Skipped directory: ${input} — pass individual files instead`));
+            continue;
+        }
+        if (!stat.isFile()) {
+            console.warn(chalk.red(`  ✗ Rejected: ${input} — not a regular file`));
+            continue;
+        }
+        // Check file extension
+        const ext = extname(abs).toLowerCase();
+        if (!SUPPORTED_EXTENSIONS.has(ext)) {
+            console.warn(chalk.red(`  ✗ Rejected: ${input} — unsupported extension "${ext}" (supported: ${[...SUPPORTED_EXTENSIONS].join(", ")})`));
+            continue;
+        }
+        // Check file size: reject if > 1MB, warn if > 100KB
+        if (stat.size > REJECT_SIZE_THRESHOLD) {
+            console.warn(chalk.red(`  ✗ Rejected: ${input} — file too large (${(stat.size / 1024 / 1024).toFixed(2)} MB, max 1 MB)`));
+            continue;
+        }
+        if (stat.size > WARN_SIZE_THRESHOLD) {
+            console.warn(chalk.yellow(`  ⚠ Warning: ${input} is large (${(stat.size / 1024).toFixed(1)} KB) — processing may be slow`));
+        }
+        // Check for binary content
+        if (isBinaryFile(abs)) {
+            console.warn(chalk.red(`  ✗ Rejected: ${input} — appears to be a binary file`));
+            continue;
+        }
+        valid.push(abs);
+    }
+    if (valid.length === 0 && inputs.length > 0) {
+        throw new Error("No valid input files after validation. Check paths, extensions, and file sizes.");
+    }
+    return valid;
+}
+async function executePipeline(inputs, options, runtimeConfig, gatekeeperConfig) {
+    // --- Bootstrap infrastructure ---
+    const messageBus = new MessageBus({ enableLogging: false });
+    const toolBridge = new OpenCodeToolBridge();
+    const modelCandidates = resolveModelCandidates(options, runtimeConfig);
+    // --- Read input files into ExecutionContext ---
+    const files = readInputFiles(inputs);
+    const mode = (options["mode"] ||
+        "full_pipeline");
+    const context = {
+        files,
+        constraints: [],
+        mode,
+        metadata: {
+            mode,
+            dryRun: options["dryRun"] ?? false,
+            outputDir: options["outputDir"] ?? "./synapsexcoder_output",
+            needsResearch: options["research"] === true,
+            generateDocs: options["docs"] === true,
+            sessionId: options["session"],
+            parallel: options["parallel"] ?? true,
+            gatekeeperEnabled: gatekeeperConfig?.enabled ?? true,
+            gatekeeperReviewLevel: gatekeeperConfig?.reviewLevel ?? "standard",
+            gatekeeperMaxRevisions: gatekeeperConfig?.maxRevisions ?? 3,
+            gatekeeperStrictMode: gatekeeperConfig?.strictMode ?? false,
+        },
+    };
+    const task = {
+        id: uuidv4(),
+        type: "master",
+        prompt: `Process ${files.length} file(s) in ${mode} mode`,
+        context,
+        successCriteria: "Complete all pipeline phases without errors",
+        timeout: 120_000,
+    };
+    // --- Execute with dynamic model fallback ---
+    let result;
+    let lastError = null;
+    for (const model of modelCandidates) {
+        const master = new MasterAgent(messageBus, toolBridge, { model });
+        // Configure gatekeeper if enabled
+        if (gatekeeperConfig) {
+            master.setGatekeeperEnabled(gatekeeperConfig.enabled);
+            master.setGatekeeperReviewLevel(gatekeeperConfig.reviewLevel);
+            master.setGatekeeperMaxRevisions(gatekeeperConfig.maxRevisions);
+        }
+        try {
+            result = await master.execute(task);
+            if (result.success) {
+                break;
+            }
+            // Retry only when the failure indicates missing model/provider.
+            if (hasProviderModelNotFoundInResult(result)) {
+                console.warn(chalk.yellow(`  Model unavailable: ${model} — trying next fallback...`));
+                lastError = result.error;
+                continue;
+            }
+            // For non-model errors, stop early.
+            break;
+        }
+        catch (error) {
+            if (isProviderModelNotFoundError(error)) {
+                console.warn(chalk.yellow(`  Model unavailable: ${model} — trying next fallback...`));
+                lastError = error;
+                continue;
+            }
+            throw error;
+        }
+    }
+    if (!result) {
+        throw new Error(`All model candidates failed. Last error: ${String(lastError ?? "unknown")}`);
+    }
+    // --- Format for display ---
+    const output = result.output;
+    const phases = output?.["phases"] ?? [];
+    return {
+        status: result.success ? "success" : "failed",
+        error: result.error,
+        inputs: files.length,
+        artifacts: result.artifacts.length,
+        summary: {
+            filesProcessed: files.length,
+            issuesFound: phases.reduce((n, p) => n +
+                (p["output"]?.["issues"] ?? []).length, 0),
+            issuesFixed: 0,
+            successfulPhases: output?.["successfulPhases"] ?? 0,
+            totalPhases: output?.["totalPhases"] ?? 0,
+        },
+        phases,
+    };
+}
+function readInputFiles(inputs) {
+    const files = [];
+    const cwd = process.cwd();
+    for (const input of inputs) {
+        // Validate path to prevent traversal attacks
+        let abs;
+        try {
+            abs = validateAndResolve(input, cwd);
+        }
+        catch (error) {
+            console.warn(chalk.yellow(`  Warning: invalid path skipped: ${input} (${error instanceof Error ? error.message : String(error)})`));
+            continue;
+        }
+        if (!existsSync(abs)) {
+            console.warn(chalk.yellow(`  Warning: path not found, skipping: ${input}`));
+            continue;
+        }
+        const stat = statSync(abs);
+        if (stat.isFile()) {
+            try {
+                const content = readFileSync(abs, "utf-8");
+                files.push({
+                    path: abs,
+                    content,
+                    language: extToLanguage(extname(abs)),
+                    metadata: { size: stat.size, modified: stat.mtimeMs },
+                });
+            }
+            catch {
+                console.warn(chalk.yellow(`  Warning: could not read file: ${input}`));
+            }
+        }
+        else if (stat.isDirectory()) {
+            console.warn(chalk.yellow(`  Note: directory input "${input}" — pass individual files for now`));
+        }
+    }
+    return files;
+}
+function extToLanguage(ext) {
+    const map = {
+        ".ts": "typescript",
+        ".tsx": "typescript",
+        ".js": "javascript",
+        ".jsx": "javascript",
+        ".py": "python",
+        ".rs": "rust",
+        ".go": "go",
+        ".sh": "bash",
+        ".md": "markdown",
+        ".json": "json",
+        ".yaml": "yaml",
+        ".yml": "yaml",
+        ".html": "html",
+        ".css": "css",
+        ".scss": "scss",
+        ".svelte": "svelte",
+        ".vue": "vue",
+        ".rb": "ruby",
+        ".java": "java",
+        ".cs": "csharp",
+    };
+    return map[ext] ?? "text";
+}
+/**
+ * Perform real static analysis on an input file.
+ *
+ * Calculates actual lines of code (excluding blanks and comments),
+ * estimates cyclomatic complexity, computes a maintainability index
+ * using the standard formula, and detects common code issues.
+ */
+async function analyzeInput(input, _options) {
+    const cwd = process.cwd();
+    let abs;
+    try {
+        abs = validateAndResolve(input, cwd);
+    }
+    catch {
+        abs = resolve(input);
+    }
+    if (!existsSync(abs)) {
+        return {
+            file: input,
+            issues: [
+                {
+                    type: "error",
+                    rule: "file-not-found",
+                    message: `File not found: ${input}`,
+                    line: 0,
+                },
+            ],
+            metrics: { linesOfCode: 0, complexity: 0, maintainabilityIndex: 0 },
+        };
+    }
+    let content;
+    try {
+        content = readFileSync(abs, "utf-8");
+    }
+    catch (err) {
+        return {
+            file: input,
+            issues: [
+                {
+                    type: "error",
+                    rule: "read-error",
+                    message: `Cannot read file: ${err instanceof Error ? err.message : String(err)}`,
+                    line: 0,
+                },
+            ],
+            metrics: { linesOfCode: 0, complexity: 0, maintainabilityIndex: 0 },
+        };
+    }
+    const rawLines = content.split("\n");
+    const totalLines = rawLines.length;
+    const issues = [];
+    // --- Count lines of code (excluding blanks and single-line comments) ---
+    let linesOfCode = 0;
+    let inBlockComment = false;
+    for (let i = 0; i < rawLines.length; i++) {
+        const trimmed = rawLines[i].trim();
+        // Track block comments (/* ... */)
+        if (inBlockComment) {
+            if (trimmed.includes("*/")) {
+                inBlockComment = false;
+            }
+            continue;
+        }
+        if (trimmed.startsWith("/*")) {
+            inBlockComment = true;
+            if (trimmed.includes("*/")) {
+                inBlockComment = false;
+            }
+            continue;
+        }
+        // Skip blank lines and single-line comments
+        if (trimmed === "")
+            continue;
+        if (trimmed.startsWith("//"))
+            continue;
+        if (trimmed.startsWith("#") && !trimmed.startsWith("#!"))
+            continue; // Python/shell comments
+        linesOfCode++;
+    }
+    // --- Estimate cyclomatic complexity ---
+    // Count control flow keywords/operators that add decision points
+    const controlFlowPatterns = [
+        /\bif\b/g,
+        /\belse\s+if\b/g,
+        /\bfor\b/g,
+        /\bwhile\b/g,
+        /\bswitch\b/g,
+        /\bcase\b/g,
+        /\bcatch\b/g,
+        /&&/g,
+        /\|\|/g,
+        /\?\s*[^:]/g, // Ternary operator (? not followed immediately by nothing)
+    ];
+    let cyclomaticComplexity = 1; // Base complexity
+    for (const pattern of controlFlowPatterns) {
+        const matches = content.match(pattern);
+        if (matches) {
+            cyclomaticComplexity += matches.length;
+        }
+    }
+    // --- Halstead volume approximation ---
+    // Count unique operators and operands for a rough Halstead volume
+    const operatorPattern = /[+\-*/%=<>!&|^~?:;,.{}[\]()]/g;
+    const operandPattern = /\b[a-zA-Z_$][a-zA-Z0-9_$]*\b/g;
+    const numericPattern = /\b\d+(\.\d+)?\b/g;
+    const stringPattern = /(["'`])(?:(?=(\\?))\2.)*?\1/g;
+    const operators = content.match(operatorPattern) || [];
+    const operands = content.match(operandPattern) || [];
+    const numerics = content.match(numericPattern) || [];
+    const strings = content.match(stringPattern) || [];
+    const uniqueOperators = new Set(operators).size || 1;
+    const uniqueOperands = new Set([...operands, ...numerics, ...strings]).size || 1;
+    const totalOperators = operators.length || 1;
+    const totalOperands = operands.length + numerics.length + strings.length || 1;
+    const vocabulary = uniqueOperators + uniqueOperands;
+    const programLength = totalOperators + totalOperands;
+    const halsteadVolume = programLength * Math.log2(vocabulary || 2);
+    // --- Maintainability Index (standard formula) ---
+    // MI = 171 - 5.2 * ln(HV) - 0.23 * CC - 16.2 * ln(LOC), clamped to [0, 100]
+    const safeLOC = Math.max(linesOfCode, 1);
+    const safeHV = Math.max(halsteadVolume, 1);
+    let maintainabilityIndex = 171 -
+        5.2 * Math.log(safeHV) -
+        0.23 * cyclomaticComplexity -
+        16.2 * Math.log(safeLOC);
+    maintainabilityIndex = Math.max(0, Math.min(100, maintainabilityIndex));
+    maintainabilityIndex = Math.round(maintainabilityIndex * 100) / 100;
+    // --- Detect code issues ---
+    // 1. Very long functions (>50 lines)
+    const functionStartPattern = /^(\s*)((?:export\s+)?(?:async\s+)?(?:function\s+\w+|(?:const|let|var)\s+\w+\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_$]\w*)\s*=>))/;
+    let funcStartLine = -1;
+    let braceDepth = 0;
+    let inFunction = false;
+    let funcName = "";
+    for (let i = 0; i < rawLines.length; i++) {
+        const line = rawLines[i];
+        const match = line.match(functionStartPattern);
+        if (match && !inFunction) {
+            funcStartLine = i;
+            // funcIndent removed as unused
+            funcName = match[2].trim().substring(0, 60);
+            braceDepth = 0;
+            inFunction = true;
+        }
+        if (inFunction) {
+            for (const ch of line) {
+                if (ch === "{")
+                    braceDepth++;
+                if (ch === "}")
+                    braceDepth--;
+            }
+            if (braceDepth <= 0 && i > funcStartLine) {
+                const funcLength = i - funcStartLine + 1;
+                if (funcLength > 50) {
+                    issues.push({
+                        type: "warning",
+                        rule: "long-function",
+                        message: `Function is too long (${funcLength} lines, max 50): ${funcName}`,
+                        line: funcStartLine + 1,
+                    });
+                }
+                inFunction = false;
+            }
+        }
+    }
+    // 2. Deeply nested code (>4 levels)
+    for (let i = 0; i < rawLines.length; i++) {
+        const line = rawLines[i];
+        const leadingSpaces = line.match(/^(\s*)/)?.[1] || "";
+        // Estimate indentation level (2 or 4 spaces, or tabs)
+        const tabCount = (leadingSpaces.match(/\t/g) || []).length;
+        const spaceIndent = leadingSpaces.replace(/\t/g, "").length;
+        const indentLevel = tabCount + Math.floor(spaceIndent / 2);
+        if (indentLevel > 4 &&
+            line.trim().length > 0 &&
+            !line.trim().startsWith("//") &&
+            !line.trim().startsWith("*")) {
+            issues.push({
+                type: "warning",
+                rule: "deep-nesting",
+                message: `Deeply nested code (level ${indentLevel}, max 4)`,
+                line: i + 1,
+            });
+        }
+    }
+    // Deduplicate deep-nesting: keep only first occurrence per contiguous block
+    const nestingIssues = issues.filter((i) => i.rule === "deep-nesting");
+    const keptNestingLines = new Set();
+    for (let j = 0; j < nestingIssues.length; j++) {
+        if (j === 0 || nestingIssues[j].line - nestingIssues[j - 1].line > 1) {
+            keptNestingLines.add(nestingIssues[j].line);
+        }
+    }
+    // Remove non-kept nesting issues
+    for (let j = issues.length - 1; j >= 0; j--) {
+        if (issues[j].rule === "deep-nesting" &&
+            !keptNestingLines.has(issues[j].line)) {
+            issues.splice(j, 1);
+        }
+    }
+    // 3. TODO/FIXME/HACK comments
+    for (let i = 0; i < rawLines.length; i++) {
+        const line = rawLines[i];
+        const todoMatch = line.match(/\b(TODO|FIXME|HACK|XXX)\b/i);
+        if (todoMatch) {
+            issues.push({
+                type: "info",
+                rule: "todo-comment",
+                message: `${todoMatch[1].toUpperCase()} comment found: ${line.trim().substring(0, 80)}`,
+                line: i + 1,
+            });
+        }
+    }
+    // 4. console.log left in code
+    for (let i = 0; i < rawLines.length; i++) {
+        const line = rawLines[i];
+        if (/\bconsole\.(log|debug|info)\s*\(/.test(line) &&
+            !line.trim().startsWith("//")) {
+            issues.push({
+                type: "warning",
+                rule: "console-statement",
+                message: `console statement found — consider removing for production`,
+                line: i + 1,
+            });
+        }
+    }
+    // 5. Unused imports (basic detection — look for imports not referenced elsewhere)
+    const importPattern = /import\s+(?:\{([^}]+)\}|(\w+))\s+from/g;
+    let importMatch;
+    while ((importMatch = importPattern.exec(content)) !== null) {
+        const names = importMatch[1]
+            ? importMatch[1].split(",").map((n) => n
+                .trim()
+                .replace(/\s+as\s+\w+/, "")
+                .trim())
+            : importMatch[2]
+                ? [importMatch[2]]
+                : [];
+        for (const name of names) {
+            if (!name || name === "type")
+                continue;
+            // Count occurrences outside of import lines
+            const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const usagePattern = new RegExp(`\\b${escaped}\\b`, "g");
+            const allMatches = content.match(usagePattern) || [];
+            // If it only appears once (the import itself), it's likely unused
+            if (allMatches.length <= 1) {
+                const importLine = content
+                    .substring(0, importMatch.index)
+                    .split("\n").length;
+                issues.push({
+                    type: "warning",
+                    rule: "unused-import",
+                    message: `Possibly unused import: "${name}"`,
+                    line: importLine,
+                });
+            }
+        }
+    }
+    // 6. Overly complex expressions (lines with many operators)
+    for (let i = 0; i < rawLines.length; i++) {
+        const line = rawLines[i];
+        const ops = (line.match(/&&|\|\||[?:]/g) || []).length;
+        if (ops >= 5) {
+            issues.push({
+                type: "warning",
+                rule: "complex-expression",
+                message: `Overly complex expression (${ops} logical/ternary operators on one line)`,
+                line: i + 1,
+            });
+        }
+    }
+    return {
+        file: input,
+        resolvedPath: abs,
+        totalLines,
+        issues,
+        issueCount: issues.length,
+        metrics: {
+            linesOfCode,
+            blankLines: totalLines -
+                linesOfCode -
+                (totalLines - rawLines.filter((l) => l.trim() !== "").length),
+            cyclomaticComplexity,
+            halsteadVolume: Math.round(halsteadVolume * 100) / 100,
+            maintainabilityIndex,
+        },
+    };
+}
+/**
+ * Smart merge that deduplicates, groups by type/directory, preserves import
+ * order, detects conflicts, and adds rich section headers.
+ */
+async function mergeInputs(inputs, _options) {
+    const files = readInputFiles(inputs);
+    if (files.length === 0) {
+        throw new Error("No valid input files found");
+    }
+    if (files.length === 1) {
+        return files[0].content;
+    }
+    const strategy = _options["strategy"] || "semantic";
+    const merged = [];
+    const conflicts = [];
+    // --- Deduplicate identical content ---
+    const seen = new Map(); // content hash → first file path
+    const uniqueFiles = [];
+    for (const file of files) {
+        // Simple content-based dedup using a hash of trimmed content
+        const contentKey = file.content.trim();
+        if (seen.has(contentKey)) {
+            console.warn(chalk.yellow(`  ⚠ Duplicate content skipped: ${file.path} (same as ${seen.get(contentKey)})`));
+            continue;
+        }
+        seen.set(contentKey, file.path);
+        uniqueFiles.push(file);
+    }
+    // --- Group files by directory, then by extension ---
+    const dirGroups = new Map();
+    for (const file of uniqueFiles) {
+        const dir = file.path.substring(0, file.path.lastIndexOf("/")) || ".";
+        if (!dirGroups.has(dir))
+            dirGroups.set(dir, []);
+        dirGroups.get(dir).push(file);
+    }
+    // Sort groups: directories alphabetically
+    const sortedDirs = [...dirGroups.keys()].sort();
+    // --- Detect potential naming conflicts across files ---
+    // Look for same function/class/const names exported or declared in different files
+    const declaredNames = new Map(); // name → file paths
+    const declarationPattern = /(?:export\s+)?(?:function|class|const|let|var|interface|type|enum)\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
+    for (const file of uniqueFiles) {
+        let match;
+        const localPattern = new RegExp(declarationPattern.source, "g");
+        while ((match = localPattern.exec(file.content)) !== null) {
+            const name = match[1];
+            if (!declaredNames.has(name))
+                declaredNames.set(name, []);
+            declaredNames.get(name).push(file.path);
+        }
+    }
+    for (const [name, paths] of declaredNames.entries()) {
+        if (paths.length > 1) {
+            conflicts.push(`"${name}" is declared in multiple files: ${paths.map((p) => p.split("/").pop()).join(", ")}`);
+        }
+    }
+    // --- Build merge header ---
+    merged.push(`// ============================================================================`);
+    // Backwards-compatible header line expected by older tests/tools
+    merged.push(`// Merged ${uniqueFiles.length} files`);
+    merged.push(`// Merged ${uniqueFiles.length} file(s) using "${strategy}" strategy`);
+    merged.push(`// Generated by SynapseXcoder V1 on ${new Date().toISOString()}`);
+    if (uniqueFiles.length < files.length) {
+        merged.push(`// Deduplicated: ${files.length - uniqueFiles.length} duplicate(s) removed`);
+    }
+    if (conflicts.length > 0) {
+        merged.push(`//`);
+        merged.push(`// ⚠ CONFLICTS DETECTED (${conflicts.length}):`);
+        for (const conflict of conflicts) {
+            merged.push(`//   - ${conflict}`);
+        }
+    }
+    merged.push(`// ============================================================================`);
+    merged.push("");
+    // --- Collect all imports and non-import content separately ---
+    const allImports = [];
+    const allDeclarations = []; // non-import, non-export-default content
+    const allExports = [];
+    for (const dir of sortedDirs) {
+        const groupFiles = dirGroups.get(dir);
+        // Sort files within group by extension, then name
+        groupFiles.sort((a, b) => {
+            const extA = extname(a.path);
+            const extB = extname(b.path);
+            if (extA !== extB)
+                return extA.localeCompare(extB);
+            return a.path.localeCompare(b.path);
+        });
+        for (const file of groupFiles) {
+            const fileName = file.path.split("/").pop() || file.path;
+            const fileStat = existsSync(file.path) ? statSync(file.path) : null;
+            const sizeKB = fileStat ? (fileStat.size / 1024).toFixed(1) : "?";
+            const modified = fileStat
+                ? new Date(fileStat.mtimeMs).toISOString().split("T")[0]
+                : "unknown";
+            const sectionHeader = [
+                `// ─────────────────────────────────────────────────────────────`,
+                `// FILE: ${fileName}`,
+                `// FROM: ${file.path}`,
+                `// PATH: ${file.path}`,
+                `// SIZE: ${sizeKB} KB | MODIFIED: ${modified} | LANG: ${file.language}`,
+                `// ─────────────────────────────────────────────────────────────`,
+            ];
+            const lines = file.content.split("\n");
+            const fileImports = [];
+            const fileBody = [];
+            const fileExports = [];
+            let inImportBlock = true;
+            for (const line of lines) {
+                const trimmed = line.trim();
+                // Collect imports (lines starting with 'import' or continuation of multi-line imports)
+                if (inImportBlock) {
+                    if (trimmed.startsWith("import ") ||
+                        trimmed.startsWith("import{") ||
+                        (trimmed.startsWith("}") && trimmed.includes("from")) ||
+                        (fileImports.length > 0 &&
+                            !trimmed.startsWith("import") &&
+                            /^\s*[},]/.test(line) &&
+                            !trimmed.includes("export"))) {
+                        fileImports.push(line);
+                        continue;
+                    }
+                    if (trimmed === "" && fileImports.length > 0) {
+                        continue; // Skip blank lines between imports
+                    }
+                    if (trimmed !== "") {
+                        inImportBlock = false;
+                    }
+                }
+                // Separate trailing export defaults
+                if (trimmed.startsWith("export default ") ||
+                    trimmed === "export default") {
+                    fileExports.push(line);
+                    continue;
+                }
+                fileBody.push(line);
+            }
+            // Deduplicate imports (same line text)
+            for (const imp of fileImports) {
+                if (!allImports.includes(imp)) {
+                    allImports.push(imp);
+                }
+            }
+            // Add body with section header
+            allDeclarations.push("");
+            allDeclarations.push(...sectionHeader);
+            allDeclarations.push("");
+            allDeclarations.push(...fileBody);
+            // Collect exports
+            if (fileExports.length > 0) {
+                allExports.push(`// Export from: ${fileName}`);
+                allExports.push(...fileExports);
+            }
+        }
+    }
+    // --- Assemble final output: imports → declarations → exports ---
+    if (allImports.length > 0) {
+        merged.push("// === IMPORTS ===");
+        merged.push(...allImports);
+        merged.push("");
+    }
+    merged.push(...allDeclarations);
+    if (allExports.length > 0) {
+        merged.push("");
+        merged.push("// === EXPORTS ===");
+        merged.push(...allExports);
+    }
+    merged.push("");
+    return merged.join("\n");
+}
+function displayResults(result, _options, gatekeeperConfig) {
+    if (_options["json"]) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const ok = result["status"] === "success";
+    console.log(chalk.cyan("\n📊 Results Summary\n"));
+    const summary = result["summary"];
+    console.log(`  Status:            ${ok ? chalk.green("success") : chalk.red("failed")}`);
+    if (result["error"])
+        console.log(`  Error:             ${chalk.red(result["error"])}`);
+    console.log(`  Files processed:   ${chalk.green(summary["filesProcessed"])}`);
+    console.log(`  Issues found:      ${chalk.yellow(summary["issuesFound"])}`);
+    console.log(`  Issues fixed:      ${chalk.green(summary["issuesFixed"])}`);
+    console.log(`  Phases completed:  ${chalk.green(summary["successfulPhases"])} / ${summary["totalPhases"]}`);
+    console.log(`  Artifacts:         ${chalk.cyan(result["artifacts"])}`);
+    // Display gatekeeper information if enabled
+    if (gatekeeperConfig?.enabled !== false) {
+        console.log();
+        console.log(chalk.cyan("🔍 Gatekeeper Review\n"));
+        const gatekeeper = result["gatekeeper"];
+        if (gatekeeper) {
+            console.log(`  Enabled:           ${chalk.green("Yes")}`);
+            console.log(`  Review Level:      ${chalk.gray(gatekeeperConfig?.reviewLevel || "standard")}`);
+            console.log(`  Total Reviews:     ${chalk.cyan(gatekeeper["totalReviews"])}`);
+            console.log(`  Passed:            ${chalk.green(gatekeeper["passedReviews"])}`);
+            console.log(`  Revisions:         ${chalk.yellow(gatekeeper["revisionRequests"])}`);
+        }
+        else {
+            console.log(`  Enabled:           ${chalk.gray("No gatekeeper data")}`);
+        }
+    }
+    console.log();
+}
+function displayAnalysisResults(result, _options) {
+    if (_options["json"]) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(chalk.cyan("\n🔍 Analysis Results\n"));
+    console.log(`  File:              ${chalk.gray(result.file)}`);
+    if (result.resolvedPath) {
+        console.log(`  Resolved Path:     ${chalk.gray(result.resolvedPath)}`);
+    }
+    console.log(`  Total Lines:       ${chalk.gray(String(result.totalLines ?? "?"))}`);
+    const metrics = result.metrics;
+    console.log(`  Lines of Code:     ${chalk.gray(String(metrics.linesOfCode))}`);
+    console.log(`  Complexity:        ${chalk.gray(String(metrics.cyclomaticComplexity ?? metrics.complexity ?? 0))}`);
+    const mi = metrics.maintainabilityIndex;
+    const miColor = mi >= 70 ? chalk.green : mi >= 40 ? chalk.yellow : chalk.red;
+    console.log(`  Maintainability:   ${miColor(String(mi))}`);
+    if (metrics.halsteadVolume !== undefined) {
+        console.log(`  Halstead Volume:   ${chalk.gray(String(metrics.halsteadVolume))}`);
+    }
+    const issues = result.issues;
+    if (issues && issues.length > 0) {
+        console.log(chalk.cyan(`\n  📋 Issues (${issues.length}):\n`));
+        for (const issue of issues) {
+            const icon = issue.type === "error"
+                ? chalk.red("✗")
+                : issue.type === "warning"
+                    ? chalk.yellow("⚠")
+                    : chalk.blue("ℹ");
+            const lineInfo = issue.line > 0 ? chalk.gray(`:${issue.line}`) : "";
+            console.log(`    ${icon} ${chalk.gray(`[${issue.rule}]`)}${lineInfo} ${issue.message}`);
+        }
+    }
+    else {
+        console.log(chalk.green("\n  ✓ No issues detected"));
+    }
+    console.log();
+}
+/**
+ * Get dynamic agent list by querying the MessageBus for registered agents
+ * and their queue states. Falls back to showing all available agent types
+ * with their default models and "not running" status if none are active.
+ */
+function getAgentList() {
+    // Default model assignments per agent type
+    const agentDefaults = {
+        master: { type: "primary", model: "claude-opus-4-6" },
+        planner: { type: "subagent", model: "claude-haiku-4" },
+        analyzer: { type: "subagent", model: "claude-sonnet-4" },
+        reviewer: { type: "subagent", model: "claude-sonnet-4" },
+        rewriter: { type: "subagent", model: "claude-opus-4-5" },
+        ui_designer: { type: "subagent", model: "claude-sonnet-4" },
+        researcher: { type: "subagent", model: "claude-haiku-4" },
+        gatekeeper: { type: "subagent", model: "claude-opus-4-5" },
+    };
+    try {
+        // Try to query the MessageBus for real agent state
+        const messageBus = new MessageBus({ enableLogging: false });
+        const busStats = messageBus.getStats();
+        const agents = [];
+        for (const [agentName, defaults] of Object.entries(agentDefaults)) {
+            const queueSize = busStats.queues[agentName] ?? 0;
+            // Infer status from queue state:
+            //   - queue has messages → "running" (processing work)
+            //   - queue is empty     → "idle" (available but not busy)
+            let status;
+            if (queueSize > 0) {
+                status = "running";
+            }
+            else {
+                status = "idle";
+            }
+            // Try to load model from config if available
+            let model = defaults.model;
+            try {
+                const config = loadConfigFile();
+                const agentConfig = config["agents"]?.[agentName];
+                if (agentConfig?.["model"] &&
+                    typeof agentConfig["model"] === "string") {
+                    // Extract the short model name from the provider-qualified form
+                    const fullModel = agentConfig["model"];
+                    model = fullModel.includes("/")
+                        ? fullModel.split("/").pop()
+                        : fullModel;
+                }
+            }
+            catch {
+                // Use defaults if config is unavailable
+            }
+            agents.push({
+                name: agentName,
+                type: defaults.type,
+                model,
+                status,
+            });
+        }
+        return agents;
+    }
+    catch {
+        // Fallback: return static defaults with "not running" status
+        return Object.entries(agentDefaults).map(([name, defaults]) => ({
+            name,
+            type: defaults.type,
+            model: defaults.model,
+            status: "not running",
+        }));
+    }
+}
+// ============================================================================
+// Dashboard Command
+// ============================================================================
+const dashboardCmd = program
+    .command("dashboard")
+    .description("Show agent performance dashboard in the TUI model display area");
+dashboardCmd
+    .command("show")
+    .description("Display analytics dashboard with agent performance metrics")
+    .option("-f, --format <format>", "Output format (terminal|json|markdown|html)", "terminal")
+    .option("-t, --time <minutes>", "Time range in minutes", "60")
+    .option("--trends", "Include trend analysis")
+    .option("--no-trends", "Exclude trend analysis")
+    .option("--recommendations", "Include recommendations")
+    .option("--no-recommendations", "Exclude recommendations")
+    .action((opts) => {
+    try {
+        const { DashboardGenerator } = require("../analytics/dashboard-generator.js");
+        const { MetricsAggregator } = require("../analytics/metrics-aggregator.js");
+        const aggregator = new MetricsAggregator();
+        const dashboard = new DashboardGenerator(aggregator);
+        const timeRangeMinutes = parseInt(String(opts.time), 10) || 60;
+        const report = dashboard.generateReport({
+            format: "markdown",
+            includeTrends: opts.trends !== false,
+            includeRecommendations: opts.recommendations !== false,
+            timeRangeMinutes,
+        });
+        if (opts.format === "json") {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        if (opts.format === "html") {
+            console.log(dashboard.export(report, "html"));
+            return;
+        }
+        // Terminal/TUI format — show dashboard in the model display area
+        const s = report.summary;
+        const m = report.metrics;
+        console.log(chalk.cyan("\n📊 Agent Performance Dashboard\n"));
+        console.log(chalk.gray(`  Generated: ${new Date(report.generatedAt).toISOString()}`));
+        console.log(chalk.gray(`  Period: ${timeRangeMinutes} min\n`));
+        // Summary cards
+        console.log(chalk.bold("  ┌─────────────────────────────────────────────────────┐"));
+        console.log(chalk.bold("  │ Performance Summary                                │"));
+        console.log(chalk.bold("  ├─────────────────────────────────────────────────────┤"));
+        console.log(`  │ ${chalk.bold("Executions:")}    ${String(s.totalExecutions).padEnd(28)} │`);
+        const successColor = s.overallSuccessRate >= 0.9 ? chalk.green : s.overallSuccessRate >= 0.7 ? chalk.yellow : chalk.red;
+        console.log(`  │ ${chalk.bold("Success Rate:")}  ${successColor((s.overallSuccessRate * 100).toFixed(1) + "%").padEnd(28)} │`);
+        console.log(`  │ ${chalk.bold("Total Time:")}     ${String(s.totalTimeSeconds.toFixed(1) + "s").padEnd(28)} │`);
+        console.log(`  │ ${chalk.bold("Total Tokens:")}   ${String(s.totalTokens.toLocaleString()).padEnd(28)} │`);
+        console.log(`  │ ${chalk.bold("Active Agents:")}  ${String(s.activeAgentTypes).padEnd(28)} │`);
+        console.log(`  │ ${chalk.bold("Busiest Agent:")}  ${String(s.busiestAgentType).padEnd(28)} │`);
+        console.log(`  │ ${chalk.bold("Slowest Agent:")}  ${String(s.slowestAgentType).padEnd(28)} │`);
+        console.log(chalk.bold("  └─────────────────────────────────────────────────────┘"));
+        console.log();
+        // Per-agent breakdown
+        console.log(chalk.bold("  Per-Agent Performance:"));
+        console.log();
+        console.log(`  ${chalk.gray("Agent Type".padEnd(16))} ${chalk.gray("Tasks".padEnd(7))} ${chalk.gray("Success".padEnd(10))} ${chalk.gray("Avg Time".padEnd(11))} ${chalk.gray("Avg Tokens")}`);
+        console.log(`  ${chalk.gray("─".repeat(16))} ${chalk.gray("─".repeat(7))} ${chalk.gray("─".repeat(10))} ${chalk.gray("─".repeat(11))} ${chalk.gray("─".repeat(10))}`);
+        const agentTypes = Object.keys(m.byAgentType);
+        for (const agentType of agentTypes.sort()) {
+            const a = m.byAgentType[agentType];
+            const total = a.tasksCompleted + a.tasksFailed;
+            const successPct = (a.successRate * 100).toFixed(1);
+            const srColor = a.successRate >= 0.9 ? chalk.green : a.successRate >= 0.7 ? chalk.yellow : chalk.red;
+            const avgTime = a.averageExecutionTime.toFixed(0);
+            console.log(`  ${chalk.cyan(String(agentType).padEnd(16))} ` +
+                `${String(total).padEnd(7)} ` +
+                `${srColor(successPct + "%").padEnd(10)} ` +
+                `${chalk.gray(avgTime + "ms").padEnd(11)} ` +
+                `${chalk.gray(String(a.averageTokensUsed.toFixed(0)))}`);
+        }
+        console.log();
+        // Trends
+        if (opts.trends !== false && report.trends.length > 0) {
+            console.log(chalk.bold("  Trends:"));
+            for (const trend of report.trends) {
+                const icon = trend.direction === "up" ? chalk.green("▲") : trend.direction === "down" ? chalk.red("▼") : chalk.gray("◆");
+                const changeStr = trend.direction === "stable"
+                    ? chalk.gray("no change")
+                    : (trend.changePercent > 0 ? chalk.green("+" + trend.changePercent.toFixed(1) + "%") : chalk.red(trend.changePercent.toFixed(1) + "%"));
+                console.log(`    ${icon} ${trend.metric}: ${changeStr}`);
+            }
+            console.log();
+        }
+        // Recommendations
+        if (opts.recommendations !== false && report.recommendations.length > 0) {
+            console.log(chalk.bold("  Recommendations:"));
+            for (const rec of report.recommendations) {
+                console.log(`    ${chalk.yellow("→")} ${rec}`);
+            }
+            console.log();
+        }
+    }
+    catch (error) {
+        console.log(chalk.red(`  ✗ Failed to generate dashboard: ${error instanceof Error ? error.message : error}`));
+        console.log(chalk.gray("  Dashboard requires MetricsAggregator and DashboardGenerator."));
+    }
+});
+dashboardCmd
+    .command("snapshot")
+    .description("Show quick metrics snapshot for the model display area")
+    .action(() => {
+    try {
+        const { MetricsAggregator } = require("../analytics/metrics-aggregator.js");
+        const aggregator = new MetricsAggregator();
+        const snapshot = aggregator.snapshot();
+        console.log(chalk.cyan("\n⚡ Metrics Snapshot\n"));
+        console.log(`  ${chalk.bold("Active Agents:")}  ${chalk.green(String(snapshot.activeAgents))}`);
+        console.log(`  ${chalk.bold("Running Tasks:")}  ${chalk.yellow(String(snapshot.runningTasks))}`);
+        console.log(`  ${chalk.bold("Queued Tasks:")}   ${chalk.gray(String(snapshot.queuedTasks))}`);
+        console.log(`  ${chalk.bold("Success Rate:")}   ${(snapshot.recentSuccessRate * 100).toFixed(1)}%`);
+        if (snapshot.memoryUsageMb) {
+            console.log(`  ${chalk.bold("Memory Usage:")}  ${chalk.gray(String(snapshot.memoryUsageMb.toFixed(1)) + " MB")}`);
+        }
+        if (snapshot.farmMetrics) {
+            console.log(chalk.bold("\n  Farm Metrics:"));
+            console.log(`    Workers: ${snapshot.farmMetrics.activeWorkers}/${snapshot.farmMetrics.workerCount} active`);
+            console.log(`    Tasks:   ${snapshot.farmMetrics.tasksCompleted} done, ${snapshot.farmMetrics.tasksFailed} failed`);
+        }
+        console.log();
+    }
+    catch (error) {
+        console.log(chalk.yellow("  ⚠ Snapshot not available — no metrics data"));
+    }
+});
+// ============================================================================
+// Mode Management Commands
+// ============================================================================
+const modeCmd = program.command("mode").description("Manage custom processing modes");
+modeCmd
+    .command("list")
+    .description("List all custom modes")
+    .option("--builtin", "Include built-in modes")
+    .action((opts) => {
+    const registry = new CustomModeRegistry();
+    const custom = registry.list();
+    const builtin = synapseModeRegistry.listModes();
+    console.log(chalk.cyan("\n📋 Processing Modes\n"));
+    if (opts.builtin) {
+        console.log(chalk.yellow("  Built-in Modes:"));
+        builtin.forEach((m) => {
+            console.log(`    ${chalk.green(m.id)} — ${m.label}`);
+            console.log(`      ${chalk.gray(m.description)}`);
+            console.log();
+        });
+    }
+    console.log(chalk.yellow(`  Custom Modes (${custom.length}):`));
+    if (custom.length === 0) {
+        console.log(chalk.gray("    No custom modes registered"));
+    }
+    else {
+        custom.forEach((m) => {
+            const statusIcon = m.enabled ? chalk.green("✓") : chalk.gray("✗");
+            console.log(`    ${statusIcon} ${chalk.green(m.id)} — ${m.label}`);
+            console.log(`      ${chalk.gray(m.description)}`);
+            if (m.usageCount > 0) {
+                console.log(`      ${chalk.gray(`Used ${m.usageCount} times`)}`);
+            }
+            console.log();
+        });
+    }
+    console.log();
+});
+modeCmd
+    .command("create")
+    .description("Create a new custom mode")
+    .argument("<id>", "Mode identifier (lowercase, underscores)")
+    .argument("<label>", "Display label")
+    .argument("<description>", "Mode description")
+    .option("-a, --agents <agents>", "Comma-separated agent list")
+    .option("-t, --tools <tools>", "Comma-separated tool list")
+    .option("-p, --pipeline <pipeline>", "Base pipeline mode")
+    .option("--from-template <name>", "Create from a named template")
+    .option("--dry-run", "Validate without saving")
+    .action((id, label, description, opts) => {
+    let def = {
+        id,
+        label,
+        description,
+        agents: opts.agents
+            ? opts.agents.split(",").map((s) => s.trim())
+            : undefined,
+        tools: opts.tools
+            ? opts.tools.split(",").map((s) => s.trim())
+            : undefined,
+        basePipeline: opts.pipeline,
+    };
+    // If template specified, merge
+    if (opts.fromTemplate) {
+        const template = createFromTemplate(opts.fromTemplate, def);
+        if (!template) {
+            console.log(chalk.red(`\n  ✗ Template "${opts.fromTemplate}" not found`));
+            process.exit(1);
+        }
+        def = { ...def, ...template };
+    }
+    // Validate
+    const validation = validateModeDefinition(def);
+    if (!validation.valid) {
+        console.log(chalk.red("\n  ✗ Validation failed:\n"));
+        validation.errors.forEach((e) => {
+            console.log(`    ${chalk.red("✗")} ${chalk.bold(e.field)}: ${e.message}`);
+        });
+        validation.warnings.forEach((w) => {
+            console.log(`    ${chalk.yellow("⚠")} ${chalk.bold(w.field)}: ${w.message}`);
+        });
+        process.exit(1);
+    }
+    if (validation.warnings.length > 0) {
+        console.log(chalk.yellow("\n  ⚠ Warnings:\n"));
+        validation.warnings.forEach((w) => {
+            console.log(`    ${chalk.yellow("⚠")} ${chalk.bold(w.field)}: ${w.message}`);
+        });
+    }
+    if (opts.dryRun) {
+        console.log(chalk.green("\n  ✓ Mode definition is valid (dry run — not saved)\n"));
+        // Show preview
+        const preview = generateModePreview(def);
+        console.log(chalk.cyan("  Preview:"));
+        console.log(preview.markdown.split("\n").map((l) => `  ${l}`).join("\n"));
+        console.log();
+        return;
+    }
+    // Save
+    try {
+        saveModeToFile(def);
+        console.log(chalk.green(`\n  ✓ Mode "${id}" created successfully\n`));
+    }
+    catch (e) {
+        console.log(chalk.red(`\n  ✗ Failed to save mode: ${e instanceof Error ? e.message : e}\n`));
+        process.exit(1);
+    }
+});
+modeCmd
+    .command("delete")
+    .description("Delete a custom mode")
+    .argument("<id>", "Mode identifier")
+    .option("--force", "Skip confirmation")
+    .action((id) => {
+    const deleted = deleteModeFromFile(id);
+    if (deleted) {
+        console.log(chalk.green(`\n  ✓ Mode "${id}" deleted\n`));
+    }
+    else {
+        console.log(chalk.yellow(`\n  ⚠ Mode "${id}" not found\n`));
+    }
+});
+modeCmd
+    .command("show")
+    .description("Show detailed mode information")
+    .argument("<id>", "Mode identifier")
+    .option("--preview", "Show visual pipeline preview")
+    .action((id, opts) => {
+    // Check built-in first
+    const builtin = synapseModeRegistry.getMode(id);
+    if (builtin) {
+        console.log(chalk.cyan(`\n📋 Built-in Mode: ${builtin.id}\n`));
+        console.log(`  ${chalk.bold("Label:")}       ${builtin.label}`);
+        console.log(`  ${chalk.bold("Description:")}  ${builtin.description}`);
+        if (builtin.agents?.length > 0) {
+            console.log(`  ${chalk.bold("Agents:")}      ${builtin.agents.join(", ")}`);
+        }
+        if (builtin.tools?.length > 0) {
+            console.log(`  ${chalk.bold("Tools:")}       ${builtin.tools.join(", ")}`);
+        }
+        if (builtin.basePipeline) {
+            console.log(`  ${chalk.bold("Pipeline:")}    ${builtin.basePipeline}`);
+        }
+        console.log();
+        return;
+    }
+    // Check custom modes
+    const customList = listCustomModesFromFile();
+    const custom = customList.find((m) => m.id === id);
+    if (!custom) {
+        console.log(chalk.yellow(`\n  ⚠ Mode "${id}" not found\n`));
+        return;
+    }
+    console.log(chalk.cyan(`\n📋 Custom Mode: ${custom.id}\n`));
+    console.log(`  ${chalk.bold("Label:")}       ${custom.label}`);
+    console.log(`  ${chalk.bold("Description:")}  ${custom.description}`);
+    if (custom.agents && custom.agents.length > 0) {
+        console.log(`  ${chalk.bold("Agents:")}      ${custom.agents.join(", ")}`);
+    }
+    if (custom.tools && custom.tools.length > 0) {
+        console.log(`  ${chalk.bold("Tools:")}       ${custom.tools.join(", ")}`);
+    }
+    if (custom.basePipeline) {
+        console.log(`  ${chalk.bold("Pipeline:")}    ${custom.basePipeline}`);
+    }
+    if (opts.preview) {
+        const preview = generateModePreview(custom);
+        console.log(chalk.cyan("\n  Pipeline Preview:"));
+        preview.pipelineSteps.forEach((step) => {
+            console.log(`    ${chalk.green("→")} ${step}`);
+        });
+        console.log();
+        console.log(preview.markdown);
+    }
+    console.log();
+});
+modeCmd
+    .command("templates")
+    .description("List available mode templates")
+    .option("-c, --category <category>", "Filter by category")
+    .action((opts) => {
+    const templates = opts.category
+        ? getTemplatesByCategory(opts.category)
+        : getModeTemplates();
+    console.log(chalk.cyan("\n📦 Mode Templates\n"));
+    if (templates.length === 0) {
+        console.log(chalk.gray("  No templates found"));
+        console.log();
+        return;
+    }
+    templates.forEach((t) => {
+        console.log(`  ${chalk.green(t.name)} — ${t.description}`);
+        console.log(`    ${chalk.gray(`Category: ${t.category}`)}`);
+        console.log(`    ${chalk.gray(`Pipeline: ${t.template.basePipeline ?? "none"}`)}`);
+        if (t.template.agents) {
+            console.log(`    ${chalk.gray(`Agents: ${t.template.agents.join(", ")}`)}`);
+        }
+        console.log();
+    });
+});
+modeCmd
+    .command("validate")
+    .description("Validate a custom mode YAML file")
+    .argument("<file>", "Path to YAML file")
+    .action((file) => {
+    if (!existsSync(file)) {
+        console.log(chalk.red(`\n  ✗ File not found: ${file}\n`));
+        process.exit(1);
+    }
+    try {
+        const content = readFileSync(file, "utf-8");
+        const def = parseModeFromYaml(content);
+        if (!def) {
+            console.log(chalk.yellow("\n  ⚠ No valid mode definition found in file\n"));
+            return;
+        }
+        const validation = validateModeDefinition(def);
+        if (validation.valid) {
+            console.log(chalk.green(`\n  ✓ Mode "${def.id}" is valid\n`));
+        }
+        else {
+            console.log(chalk.red(`\n  ✗ Mode "${def.id}" has errors:\n`));
+            validation.errors.forEach((e) => {
+                console.log(`    ${chalk.red("✗")} ${chalk.bold(e.field)}: ${e.message}`);
+            });
+        }
+        if (validation.warnings.length > 0) {
+            console.log(chalk.yellow("\n  ⚠ Warnings:\n"));
+            validation.warnings.forEach((w) => {
+                console.log(`    ${chalk.yellow("⚠")} ${chalk.bold(w.field)}: ${w.message}`);
+            });
+        }
+        if (validation.suggestion) {
+            console.log(chalk.cyan(`\n  💡 Suggestion: ${validation.suggestion}\n`));
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(chalk.red(`\n  ✗ Failed to parse file: ${e instanceof Error ? e.message : e}\n`));
+        process.exit(1);
+    }
+});
+// ============================================================================
+// Boot Banner
+// ============================================================================
+console.log(chalk.cyan(`
+╔══════════════════════════════════════════════════════════════════════════════╗
+║                    🦆 SynapseXcoder AI System — V1                         ║
+║                  Multi-Agent OpenCode Integration Edition                   ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+`));
+function isRunningDirectly() {
+    if (!process.argv[1])
+        return false;
+    try {
+        const entryPath = realpathSync(resolve(process.argv[1]));
+        const modulePath = realpathSync(resolve(new URL(import.meta.url).pathname));
+        return entryPath === modulePath;
+    }
+    catch {
+        return import.meta.url === `file://${process.argv[1]}`;
+    }
+}
+// Parse and execute only when run directly (not when imported for testing)
+if (isRunningDirectly()) {
+    program.parse(process.argv);
+    // Show help if no command
+    if (process.argv.length === 2) {
+        program.help();
+    }
+}
+// ============================================================================
+// Exports for testing
+// ============================================================================
+export { mergeInputs, readInputFiles, getDefaultConfig, loadConfigFile, saveConfigFile, setConfigValue, getConfigValue, saveContext, loadContext, listContexts, deleteContext, getCurrentContext, checkOpenCodeAvailable, runOpenCodeCommand, };
+//# sourceMappingURL=index.js.map