claude-flow 3.27.4 → 3.29.0

package/v3/@claude-flow/cli/dist/src/commands/hive-mind.js

@@ -51,103 +51,103 @@ function generateHiveMindPrompt(swarmId, swarmName, objective, workers, workerGr
     const queenType = flags.queenType || 'strategic';
     const consensusAlgorithm = flags.consensus || 'byzantine';
     const topology = flags.topology || 'hierarchical-mesh';
-    return `🧠 HIVE MIND COLLECTIVE INTELLIGENCE SYSTEM
-═══════════════════════════════════════════════
-
-You are the Queen coordinator of a Hive Mind swarm with collective intelligence capabilities.
-
-HIVE MIND CONFIGURATION:
-📌 Swarm ID: ${swarmId}
-📌 Swarm Name: ${swarmName}
-🎯 Objective: ${objective}
-👑 Queen Type: ${queenType}
-🐝 Worker Count: ${workers.length}
-🔗 Topology: ${topology}
-🤝 Consensus Algorithm: ${consensusAlgorithm}
-⏰ Initialized: ${currentTime}
-
-WORKER DISTRIBUTION:
-${workerTypes.map(type => `• ${type}: ${workerGroups[type].length} agents`).join('\n')}
-
-🔧 AVAILABLE MCP TOOLS FOR HIVE MIND COORDINATION:
-
-1️⃣ **COLLECTIVE INTELLIGENCE**
-   mcp__ruflo__hive-mind_consensus    - Democratic decision making
-   mcp__ruflo__hive-mind_memory       - Share knowledge across the hive
-   mcp__ruflo__hive-mind_broadcast    - Broadcast to all workers
-   mcp__ruflo__neural_patterns        - Neural pattern recognition
-
-2️⃣ **QUEEN COORDINATION**
-   mcp__ruflo__hive-mind_status       - Monitor swarm health
-   mcp__ruflo__task_create            - Create and delegate tasks
-   mcp__ruflo__coordination_orchestrate - Orchestrate task distribution
-   mcp__ruflo__agent_spawn            - Spawn additional workers
-
-3️⃣ **WORKER MANAGEMENT**
-   mcp__ruflo__agent_list             - List all active agents
-   mcp__ruflo__agent_status           - Check agent status
-   mcp__ruflo__agent_health           - Check worker health
-   mcp__ruflo__hive-mind_join         - Add agent to hive
-   mcp__ruflo__hive-mind_leave        - Remove agent from hive
-
-4️⃣ **TASK ORCHESTRATION**
-   mcp__ruflo__task_assign            - Assign tasks to workers
-   mcp__ruflo__task_status            - Track task progress
-   mcp__ruflo__task_complete          - Mark tasks complete
-   mcp__ruflo__workflow_create        - Create workflows
-
-5️⃣ **MEMORY & LEARNING**
-   mcp__ruflo__memory_store           - Store collective knowledge
-   mcp__ruflo__memory_retrieve        - Access shared memory
-   mcp__ruflo__memory_search          - Search memory patterns
-   mcp__ruflo__neural_train           - Learn from experiences
-   mcp__ruflo__hooks_intelligence_pattern-store - Store patterns
-
-📋 HIVE MIND EXECUTION PROTOCOL:
-
-1. **INITIALIZATION PHASE**
-   - Verify all workers are online and responsive
-   - Establish communication channels
-   - Load previous session state if available
-   - Initialize shared memory space
-
-2. **TASK DISTRIBUTION PHASE**
-   - Analyze the objective and decompose into subtasks
-   - Assign tasks based on worker specializations
-   - Set up task dependencies and ordering
-   - Monitor parallel execution
-
-3. **COORDINATION PHASE**
-   - Use consensus for critical decisions
-   - Aggregate results from workers
-   - Resolve conflicts using ${consensusAlgorithm} consensus
-   - Share learnings across the hive
-
-4. **COMPLETION PHASE**
-   - Verify all subtasks are complete
-   - Consolidate results
-   - Store learnings in collective memory
-   - Report final status
-
-🎯 YOUR OBJECTIVE:
-${objective}
-
-⚠️ CRITICAL — TOOL PREFERENCE RULES (#1422):
-• You MUST use Ruflo MCP tools (mcp__ruflo__*) for ALL orchestration tasks
-• Do NOT use Claude native Task/Agent tools for swarm coordination — use mcp__ruflo__agent_spawn, mcp__ruflo__task_assign, etc.
-• Native Claude tools (Read, Write, Edit, Bash, Grep, Glob) should ONLY be used for file operations and shell commands
-• All agent spawning, task assignment, memory, and coordination MUST go through mcp__ruflo__* tools
-• If a Ruflo MCP tool exists for an operation, always prefer it over any native equivalent
-
-💡 COORDINATION TIPS:
-• Use mcp__ruflo__hive-mind_broadcast for swarm-wide announcements
-• Check worker status regularly with mcp__ruflo__hive-mind_status
-• Store important decisions in shared memory for persistence
-• Use consensus for any decisions affecting multiple workers
-• Use mcp__ruflo__task_assign to assign tasks to workers, then mcp__ruflo__task_complete when done
-
-🚀 BEGIN HIVE MIND COORDINATION NOW!
-Start by checking the current hive status and then proceed with the objective.
+    return `🧠 HIVE MIND COLLECTIVE INTELLIGENCE SYSTEM
+═══════════════════════════════════════════════
+
+You are the Queen coordinator of a Hive Mind swarm with collective intelligence capabilities.
+
+HIVE MIND CONFIGURATION:
+📌 Swarm ID: ${swarmId}
+📌 Swarm Name: ${swarmName}
+🎯 Objective: ${objective}
+👑 Queen Type: ${queenType}
+🐝 Worker Count: ${workers.length}
+🔗 Topology: ${topology}
+🤝 Consensus Algorithm: ${consensusAlgorithm}
+⏰ Initialized: ${currentTime}
+
+WORKER DISTRIBUTION:
+${workerTypes.map(type => `• ${type}: ${workerGroups[type].length} agents`).join('\n')}
+
+🔧 AVAILABLE MCP TOOLS FOR HIVE MIND COORDINATION:
+
+1️⃣ **COLLECTIVE INTELLIGENCE**
+   mcp__ruflo__hive-mind_consensus    - Democratic decision making
+   mcp__ruflo__hive-mind_memory       - Share knowledge across the hive
+   mcp__ruflo__hive-mind_broadcast    - Broadcast to all workers
+   mcp__ruflo__neural_patterns        - Neural pattern recognition
+
+2️⃣ **QUEEN COORDINATION**
+   mcp__ruflo__hive-mind_status       - Monitor swarm health
+   mcp__ruflo__task_create            - Create and delegate tasks
+   mcp__ruflo__coordination_orchestrate - Orchestrate task distribution
+   mcp__ruflo__agent_spawn            - Spawn additional workers
+
+3️⃣ **WORKER MANAGEMENT**
+   mcp__ruflo__agent_list             - List all active agents
+   mcp__ruflo__agent_status           - Check agent status
+   mcp__ruflo__agent_health           - Check worker health
+   mcp__ruflo__hive-mind_join         - Add agent to hive
+   mcp__ruflo__hive-mind_leave        - Remove agent from hive
+
+4️⃣ **TASK ORCHESTRATION**
+   mcp__ruflo__task_assign            - Assign tasks to workers
+   mcp__ruflo__task_status            - Track task progress
+   mcp__ruflo__task_complete          - Mark tasks complete
+   mcp__ruflo__workflow_create        - Create workflows
+
+5️⃣ **MEMORY & LEARNING**
+   mcp__ruflo__memory_store           - Store collective knowledge
+   mcp__ruflo__memory_retrieve        - Access shared memory
+   mcp__ruflo__memory_search          - Search memory patterns
+   mcp__ruflo__neural_train           - Learn from experiences
+   mcp__ruflo__hooks_intelligence_pattern-store - Store patterns
+
+📋 HIVE MIND EXECUTION PROTOCOL:
+
+1. **INITIALIZATION PHASE**
+   - Verify all workers are online and responsive
+   - Establish communication channels
+   - Load previous session state if available
+   - Initialize shared memory space
+
+2. **TASK DISTRIBUTION PHASE**
+   - Analyze the objective and decompose into subtasks
+   - Assign tasks based on worker specializations
+   - Set up task dependencies and ordering
+   - Monitor parallel execution
+
+3. **COORDINATION PHASE**
+   - Use consensus for critical decisions
+   - Aggregate results from workers
+   - Resolve conflicts using ${consensusAlgorithm} consensus
+   - Share learnings across the hive
+
+4. **COMPLETION PHASE**
+   - Verify all subtasks are complete
+   - Consolidate results
+   - Store learnings in collective memory
+   - Report final status
+
+🎯 YOUR OBJECTIVE:
+${objective}
+
+⚠️ CRITICAL — TOOL PREFERENCE RULES (#1422):
+• You MUST use Ruflo MCP tools (mcp__ruflo__*) for ALL orchestration tasks
+• Do NOT use Claude native Task/Agent tools for swarm coordination — use mcp__ruflo__agent_spawn, mcp__ruflo__task_assign, etc.
+• Native Claude tools (Read, Write, Edit, Bash, Grep, Glob) should ONLY be used for file operations and shell commands
+• All agent spawning, task assignment, memory, and coordination MUST go through mcp__ruflo__* tools
+• If a Ruflo MCP tool exists for an operation, always prefer it over any native equivalent
+
+💡 COORDINATION TIPS:
+• Use mcp__ruflo__hive-mind_broadcast for swarm-wide announcements
+• Check worker status regularly with mcp__ruflo__hive-mind_status
+• Store important decisions in shared memory for persistence
+• Use consensus for any decisions affecting multiple workers
+• Use mcp__ruflo__task_assign to assign tasks to workers, then mcp__ruflo__task_complete when done
+
+🚀 BEGIN HIVE MIND COORDINATION NOW!
+Start by checking the current hive status and then proceed with the objective.
 `;
 }
 /**

package/v3/@claude-flow/cli/dist/src/commands/hooks.js

@@ -3942,15 +3942,15 @@ const tokenOptimizeCommand = {
                 const total = stats.cacheHits + stats.cacheMisses;
                 const hitRate = total > 0 ? (stats.cacheHits / total * 100).toFixed(1) : '0';
                 const savings = (stats.totalTokensSaved / 1000 * 0.01).toFixed(2);
-                output.writeln(`## Token Optimization Report
-
-| Metric | Value |
-|--------|-------|
-| Tokens Saved | ${stats.totalTokensSaved.toLocaleString()} |
-| Edits Optimized | ${stats.editsOptimized} |
-| Cache Hit Rate | ${hitRate}% |
-| Memories Retrieved | ${stats.memoriesRetrieved} |
-| Est. Monthly Savings | $${savings} |
+                output.writeln(`## Token Optimization Report
+
+| Metric | Value |
+|--------|-------|
+| Tokens Saved | ${stats.totalTokensSaved.toLocaleString()} |
+| Edits Optimized | ${stats.editsOptimized} |
+| Cache Hit Rate | ${hitRate}% |
+| Memories Retrieved | ${stats.memoriesRetrieved} |
+| Est. Monthly Savings | $${savings} |
 | Agentic-Flow Active | ${agenticFlowAvailable ? '✓' : '✗'} |`);
             }
             return { success: true, data: { config, stats: { ...stats, agenticFlowAvailable } } };

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

@@ -8,6 +8,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { executeInit, executeUpgrade, executeUpgradeWithMissing, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, } from '../init/index.js';
 import { ENROLLMENT_SCREEN, recordEnrollmentOutcome, shouldOfferEnrollment, } from '../funnel/enrollment.js';
+import { commandExists } from '../services/harness-hosts.js';
 /**
  * ADR-302 post-init capability enrollment. One-time, interactive-TTY-only,
  * skippable with --no-signup, auto-skipped in CI/automation. Never throws
@@ -42,6 +43,87 @@ async function offerCapabilityEnrollment(ctx) {
         // Enrollment is optional; init success is never affected.
     }
 }
+async function resolveCodexInitializer(cwd) {
+    // Use a variable to prevent TypeScript from statically resolving the optional module
+    const codexModuleId = '@claude-flow/codex';
+    const resolutionStrategies = [
+        // Strategy 1: Direct import (works if installed as CLI dependency)
+        async () => (await import(codexModuleId)).CodexInitializer,
+        // Strategy 2: Project node_modules (works if installed in user's project)
+        async () => {
+            const projectPath = path.join(cwd, 'node_modules', '@claude-flow', 'codex', 'dist', 'index.js');
+            if (fs.existsSync(projectPath)) {
+                const mod = await import(`file://${projectPath}`);
+                return mod.CodexInitializer;
+            }
+            throw new Error('Not found in project');
+        },
+        // Strategy 3: Global node_modules
+        async () => {
+            const { execSync } = await import('child_process');
+            const globalPath = execSync('npm root -g', { encoding: 'utf-8' }).trim();
+            const codexPath = path.join(globalPath, '@claude-flow', 'codex', 'dist', 'index.js');
+            if (fs.existsSync(codexPath)) {
+                const mod = await import(`file://${codexPath}`);
+                return mod.CodexInitializer;
+            }
+            throw new Error('Not found globally');
+        },
+    ];
+    for (const strategy of resolutionStrategies) {
+        try {
+            const ctor = await strategy();
+            if (ctor)
+                return ctor;
+        }
+        catch {
+            // Try next strategy
+        }
+    }
+    return undefined;
+}
+// #2666-adjacent — quietly wire up Codex too when a plain `ruflo init` (no
+// --codex/--dual) runs on a machine that also has the OpenAI Codex CLI on
+// PATH: registers its MCP server and installs skills alongside the Claude
+// Code setup that just happened. Best-effort and silent-by-default — must
+// never fail or noisily interrupt a normal init. Opt out with
+// --no-codex-detect. Skipped entirely under --skip-claude (runtime-only
+// init) and scripted `--format json` output.
+async function maybeAutoDetectCodex(ctx, options) {
+    try {
+        if (ctx.flags['no-codex-detect'] === true)
+            return;
+        if (ctx.flags.format === 'json')
+            return; // scripted output stays pure
+        if (!commandExists('codex'))
+            return;
+        const CodexInitializer = await resolveCodexInitializer(ctx.cwd);
+        if (!CodexInitializer) {
+            output.writeln();
+            output.printInfo('Detected the OpenAI Codex CLI — install @claude-flow/codex to auto-configure its MCP server and skills:');
+            output.writeln(output.dim('  npm install @claude-flow/codex && ruflo init --codex'));
+            return;
+        }
+        const initializer = new CodexInitializer();
+        const result = await initializer.initialize({
+            projectPath: ctx.cwd,
+            template: (options.minimal ? 'minimal' : options.full ? 'full' : 'default'),
+            force: options.force,
+            dual: false, // Claude Code files were already written by the main init flow above
+        });
+        if (!result.success)
+            return; // best-effort — never fail the primary init over this
+        output.writeln();
+        output.printBox([
+            `AGENTS.md:            Codex project instructions`,
+            `.agents/config.toml:  MCP server + skills config`,
+            `.agents/skills/:      ${result.skillsGenerated.length} skills`,
+        ].join('\n'), 'OpenAI Codex detected — configured');
+    }
+    catch {
+        // Codex auto-detect is a bonus, never a requirement — swallow everything.
+    }
+}
 // Codex initialization action
 async function initCodexAction(ctx, options) {
     const { force, minimal, full, dualMode } = options;
@@ -53,44 +135,7 @@ async function initCodexAction(ctx, options) {
     const spinner = output.createSpinner({ text: 'Initializing Codex project...' });
     spinner.start();
     try {
-        let CodexInitializer;
-        // Try multiple resolution strategies for the @claude-flow/codex package
-        // Use a variable to prevent TypeScript from statically resolving the optional module
-        const codexModuleId = '@claude-flow/codex';
-        const resolutionStrategies = [
-            // Strategy 1: Direct import (works if installed as CLI dependency)
-            async () => (await import(codexModuleId)).CodexInitializer,
-            // Strategy 2: Project node_modules (works if installed in user's project)
-            async () => {
-                const projectPath = path.join(ctx.cwd, 'node_modules', '@claude-flow', 'codex', 'dist', 'index.js');
-                if (fs.existsSync(projectPath)) {
-                    const mod = await import(`file://${projectPath}`);
-                    return mod.CodexInitializer;
-                }
-                throw new Error('Not found in project');
-            },
-            // Strategy 3: Global node_modules
-            async () => {
-                const { execSync } = await import('child_process');
-                const globalPath = execSync('npm root -g', { encoding: 'utf-8' }).trim();
-                const codexPath = path.join(globalPath, '@claude-flow', 'codex', 'dist', 'index.js');
-                if (fs.existsSync(codexPath)) {
-                    const mod = await import(`file://${codexPath}`);
-                    return mod.CodexInitializer;
-                }
-                throw new Error('Not found globally');
-            },
-        ];
-        for (const strategy of resolutionStrategies) {
-            try {
-                CodexInitializer = await strategy();
-                if (CodexInitializer)
-                    break;
-            }
-            catch {
-                // Try next strategy
-            }
-        }
+        const CodexInitializer = await resolveCodexInitializer(ctx.cwd);
         if (!CodexInitializer) {
             throw new Error('Cannot find module @claude-flow/codex');
         }
@@ -357,6 +402,10 @@ const initAction = async (ctx) => {
             output.printInfo(`Hooks: ${result.summary.hooksEnabled} hook types enabled in settings.json`);
             output.writeln();
         }
+        // #2666-adjacent — auto-detect + configure OpenAI Codex CLI if present
+        if (!skipClaude) {
+            await maybeAutoDetectCodex(ctx, { force, minimal, full });
+        }
         // Handle --start-all or --start-daemon
         const startAll = ctx.flags['start-all'] || ctx.flags.startAll;
         const startDaemon = ctx.flags['start-daemon'] || ctx.flags.startDaemon || startAll;
@@ -1112,6 +1161,12 @@ export const initCommand = {
             type: 'boolean',
             default: false,
         },
+        {
+            name: 'no-codex-detect',
+            description: 'Skip auto-detecting the OpenAI Codex CLI and configuring its MCP server + skills',
+            type: 'boolean',
+            default: false,
+        },
         {
             name: 'all-agents',
             description: 'Install all agent categories (ADR-128: default is ~24 substrate agents; this restores the full set of ~89)',
@@ -1139,6 +1194,7 @@ export const initCommand = {
         { command: 'claude-flow init --codex', description: 'Initialize for OpenAI Codex (AGENTS.md)' },
         { command: 'claude-flow init --codex --full', description: 'Codex init with all 137+ skills' },
         { command: 'claude-flow init --dual', description: 'Initialize for both Claude Code and Codex' },
+        { command: 'claude-flow init --no-codex-detect', description: 'Skip auto-configuring OpenAI Codex even if it is installed' },
         { command: 'claude-flow init --all-agents', description: 'Install all agent categories (~89 agents; ADR-128 opt-in)' },
     ],
     action: initAction,

package/v3/@claude-flow/cli/dist/src/commands/memory.js

@@ -646,6 +646,90 @@ const deleteCommand = {
         }
     }
 };
+// #2666 — Hard, namespace-scoped purge. `delete` above only ever
+// soft-deletes a single key (status='deleted', row stays and still occupies
+// the UNIQUE(namespace, key) slot — #2652). Reconciling an entire namespace
+// after its source-of-truth changed (e.g. a plugin's index after a source
+// file was removed) needs the row to actually be gone, not tombstoned.
+// Irreversible — always requires --namespace explicitly (no default) and
+// either interactive confirmation or --force.
+const purgeCommand = {
+    name: 'purge',
+    description: 'Permanently delete every entry in a namespace (hard delete — not the soft delete/tombstone that `memory delete` uses)',
+    options: [
+        {
+            name: 'namespace',
+            short: 'n',
+            description: 'Namespace to purge (required — no default, to avoid an accidental whole-namespace wipe)',
+            type: 'string'
+        },
+        {
+            name: 'dry-run',
+            short: 'd',
+            description: 'Report how many entries would be deleted, without deleting them',
+            type: 'boolean',
+            default: false
+        },
+        {
+            name: 'force',
+            short: 'f',
+            description: 'Skip confirmation',
+            type: 'boolean',
+            default: false
+        },
+        DB_PATH_OPTION
+    ],
+    examples: [
+        { command: 'claude-flow memory purge --namespace stale-cache --dry-run', description: 'Preview a purge' },
+        { command: 'claude-flow memory purge --namespace stale-cache --force', description: 'Purge without confirmation (e.g. in a script)' }
+    ],
+    action: async (ctx) => {
+        const namespace = ctx.flags.namespace;
+        const dryRun = ctx.flags.dryRun;
+        const force = ctx.flags.force;
+        const dbPath = ctx.flags.path;
+        if (!namespace) {
+            output.printError('Namespace is required. Use: memory purge -n "namespace" [--dry-run | --force]');
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            const { listEntries, purgeNamespace, resolveDbPath: _rdbPurge } = await import('../memory/memory-initializer.js');
+            const resolvedDbPath = _rdbPurge(dbPath);
+            const preview = await listEntries({ namespace, limit: 1, dbPath: resolvedDbPath });
+            const previewCount = preview.total ?? preview.entries?.length ?? 0;
+            if (dryRun) {
+                output.printInfo(`Would permanently delete ${previewCount} entr${previewCount === 1 ? 'y' : 'ies'} from namespace "${namespace}" (dry run — nothing deleted)`);
+                return { success: true, data: { namespace, wouldDelete: previewCount } };
+            }
+            if (!force && ctx.interactive) {
+                const confirmed = await confirm({
+                    message: `Permanently delete ${previewCount} entr${previewCount === 1 ? 'y' : 'ies'} from namespace "${namespace}"? This is a hard delete — not reversible with \`memory delete\`'s soft-undo.`,
+                    default: false
+                });
+                if (!confirmed) {
+                    output.printInfo('Operation cancelled');
+                    return { success: true };
+                }
+            }
+            else if (!force) {
+                output.printError(`Refusing to purge namespace "${namespace}" without --force in non-interactive mode`);
+                return { success: false, exitCode: 1 };
+            }
+            const result = await purgeNamespace({ namespace, dbPath: resolvedDbPath });
+            if (!result.success) {
+                output.printError(result.error || 'Failed to purge');
+                return { success: false, exitCode: 1 };
+            }
+            output.printSuccess(`Purged ${result.deletedCount} entr${result.deletedCount === 1 ? 'y' : 'ies'} from namespace "${namespace}"`);
+            output.printInfo(`Remaining entries (all namespaces): ${result.remainingEntries}`);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            output.printError(`Failed to purge: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
+};
 // Stats command
 const statsCommand = {
     name: 'stats',
@@ -1476,7 +1560,7 @@ const initMemoryCommand = {
 export const memoryCommand = {
     name: 'memory',
     description: 'Memory management commands',
-    subcommands: [initMemoryCommand, storeCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand, distillCommand, backupCommand],
+    subcommands: [initMemoryCommand, storeCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, purgeCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand, distillCommand, backupCommand],
     options: [],
     examples: [
         { command: 'claude-flow memory store -k "key" -v "value"', description: 'Store data' },

package/v3/@claude-flow/cli/dist/src/commands/ruvector/backup.js

@@ -182,10 +182,10 @@ const backupSubcommand = {
                 tables = tablesFilter.split(',').map(t => t.trim());
             }
             else {
-                const tablesResult = await client.query(`
-          SELECT table_name FROM information_schema.tables
-          WHERE table_schema = $1 AND table_type = 'BASE TABLE'
-          ORDER BY table_name
+                const tablesResult = await client.query(`
+          SELECT table_name FROM information_schema.tables
+          WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+          ORDER BY table_name
         `, [config.schema]);
                 tables = tablesResult.rows.map(r => r.table_name);
             }
@@ -209,16 +209,16 @@ const backupSubcommand = {
                 spinner.setText(`Exporting ${tableName}...`);
                 spinner.start();
                 // Get columns
-                const columnsResult = await client.query(`
-          SELECT column_name, data_type
-          FROM information_schema.columns
-          WHERE table_schema = $1 AND table_name = $2
-          ORDER BY ordinal_position
+                const columnsResult = await client.query(`
+          SELECT column_name, data_type
+          FROM information_schema.columns
+          WHERE table_schema = $1 AND table_name = $2
+          ORDER BY ordinal_position
         `, [config.schema, tableName]);
                 const columns = columnsResult.rows.map(r => r.column_name);
                 // Get data
-                const dataResult = await client.query(`
-          SELECT * FROM ${config.schema}.${tableName}
+                const dataResult = await client.query(`
+          SELECT * FROM ${config.schema}.${tableName}
         `);
                 backupData.tables.push({
                     name: tableName,
@@ -233,14 +233,14 @@ const backupSubcommand = {
             if (includeIndexes) {
                 spinner.setText('Exporting index definitions...');
                 spinner.start();
-                const indexResult = await client.query(`
-          SELECT pg_get_indexdef(i.oid) as indexdef
-          FROM pg_index idx
-          JOIN pg_class i ON i.oid = idx.indexrelid
-          JOIN pg_class t ON t.oid = idx.indrelid
-          JOIN pg_namespace n ON n.oid = t.relnamespace
-          WHERE n.nspname = $1
-            AND NOT idx.indisprimary
+                const indexResult = await client.query(`
+          SELECT pg_get_indexdef(i.oid) as indexdef
+          FROM pg_index idx
+          JOIN pg_class i ON i.oid = idx.indexrelid
+          JOIN pg_class t ON t.oid = idx.indrelid
+          JOIN pg_namespace n ON n.oid = t.relnamespace
+          WHERE n.nspname = $1
+            AND NOT idx.indisprimary
         `, [config.schema]);
                 backupData.indexes = indexResult.rows.map(r => r.indexdef);
                 spinner.succeed(`Exported ${backupData.indexes.length} index definitions`);
@@ -566,10 +566,10 @@ const restoreSubcommand = {
                             return typeof val === 'object' ? JSON.stringify(val) : val;
                         });
                         try {
-                            await client.query(`
-                INSERT INTO ${config.schema}.${table.name} (${columns.join(', ')})
-                VALUES (${values.join(', ')})
-                ON CONFLICT DO NOTHING
+                            await client.query(`
+                INSERT INTO ${config.schema}.${table.name} (${columns.join(', ')})
+                VALUES (${values.join(', ')})
+                ON CONFLICT DO NOTHING
               `, params);
                             restoredRows++;
                         }