profclaw 2.0.0 → 2.3.0

package/dist/cli/commands/plan.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Plan Mode CLI Commands
+ *
+ * View and manage agent plans created during plan-mode sessions.
+ *
+ * Usage:
+ *   profclaw plan list
+ *   profclaw plan show <id>
+ *   profclaw plan approve <id>
+ */
+import { Command } from 'commander';
+export declare function planCommands(): Command;
+//# sourceMappingURL=plan.d.ts.map

package/dist/cli/commands/plan.js

@@ -0,0 +1,184 @@
+/**
+ * Plan Mode CLI Commands
+ *
+ * View and manage agent plans created during plan-mode sessions.
+ *
+ * Usage:
+ *   profclaw plan list
+ *   profclaw plan show <id>
+ *   profclaw plan approve <id>
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { planManager } from '../../agents/plan-mode.js';
+import { createTable, formatRelativeTime, success, error, warn, truncate, } from '../utils/output.js';
+// ─── Status formatting ───────────────────────────────────────────────────────
+const PLAN_STATUS_COLORS = {
+    draft: chalk.yellow,
+    approved: chalk.blue,
+    in_progress: chalk.cyan,
+    completed: chalk.green,
+    rejected: chalk.red,
+};
+const STEP_STATUS_SYMBOLS = {
+    pending: chalk.dim('○'),
+    in_progress: chalk.cyan('◑'),
+    completed: chalk.green('●'),
+    skipped: chalk.gray('–'),
+};
+function formatPlanStatus(status) {
+    const colorFn = PLAN_STATUS_COLORS[status] ?? chalk.white;
+    return colorFn(status.toUpperCase().replace('_', ' '));
+}
+// ─── Command builder ─────────────────────────────────────────────────────────
+export function planCommands() {
+    const plan = new Command('plan').description('Manage agent implementation plans');
+    // ── list ──────────────────────────────────────────────────────────────────
+    plan
+        .command('list')
+        .alias('ls')
+        .description('List all plans')
+        .option('-s, --status <status>', 'Filter by status (draft|approved|in_progress|completed|rejected)')
+        .option('--json', 'Output as JSON')
+        .action((options) => {
+        let plans = planManager.list();
+        if (options.status) {
+            plans = plans.filter((p) => p.status === options.status);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(plans, null, 2));
+            return;
+        }
+        if (plans.length === 0) {
+            console.log(chalk.dim('No plans found.'));
+            return;
+        }
+        const table = createTable(['ID', 'Title', 'Status', 'Steps', 'Created']);
+        for (const p of plans) {
+            const doneSteps = p.steps.filter((s) => s.status === 'completed' || s.status === 'skipped').length;
+            table.push([
+                p.id.slice(0, 8),
+                truncate(p.title, 40),
+                formatPlanStatus(p.status),
+                `${doneSteps}/${p.steps.length}`,
+                formatRelativeTime(new Date(p.createdAt)),
+            ]);
+        }
+        console.log(table.toString());
+        console.log(chalk.dim(`\n${plans.length} plan(s) total`));
+    });
+    // ── show ──────────────────────────────────────────────────────────────────
+    plan
+        .command('show <id>')
+        .alias('get')
+        .description('Show plan details and step list')
+        .option('--json', 'Output as JSON')
+        .action((id, options) => {
+        // Support partial ID prefix matching
+        const allPlans = planManager.list();
+        const found = allPlans.find((p) => p.id === id || p.id.startsWith(id));
+        if (!found) {
+            error(`Plan not found: ${id}`);
+            process.exit(1);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(found, null, 2));
+            return;
+        }
+        console.log('');
+        console.log(chalk.bold(`Plan: ${found.id}`));
+        console.log(`Title:   ${found.title}`);
+        console.log(`Status:  ${formatPlanStatus(found.status)}`);
+        console.log(`Created: ${formatRelativeTime(new Date(found.createdAt))}`);
+        if (found.approvedAt) {
+            console.log(`Approved: ${formatRelativeTime(new Date(found.approvedAt))}`);
+        }
+        if (found.completedAt) {
+            console.log(`Completed: ${formatRelativeTime(new Date(found.completedAt))}`);
+        }
+        if (found.rejectionReason) {
+            console.log(`Rejection reason: ${chalk.red(found.rejectionReason)}`);
+        }
+        if (found.taskId) {
+            console.log(`Task ID: ${found.taskId}`);
+        }
+        console.log('');
+        console.log(chalk.bold('Steps:'));
+        for (const step of found.steps) {
+            const symbol = STEP_STATUS_SYMBOLS[step.status];
+            const effort = step.estimatedEffort ? chalk.dim(` [${step.estimatedEffort}]`) : '';
+            console.log(`  ${symbol} ${step.index}. ${step.description}${effort}`);
+            if (step.files && step.files.length > 0) {
+                for (const f of step.files) {
+                    console.log(`       ${chalk.dim(f)}`);
+                }
+            }
+        }
+        console.log('');
+    });
+    // ── approve ───────────────────────────────────────────────────────────────
+    plan
+        .command('approve <id>')
+        .description('Approve a pending plan so the agent can begin implementation')
+        .option('--json', 'Output as JSON')
+        .action((id, options) => {
+        const allPlans = planManager.list();
+        const found = allPlans.find((p) => p.id === id || p.id.startsWith(id));
+        if (!found) {
+            error(`Plan not found: ${id}`);
+            process.exit(1);
+        }
+        if (found.status !== 'draft') {
+            warn(`Plan ${found.id.slice(0, 8)} is already ${found.status}, cannot approve.`);
+            process.exit(1);
+        }
+        try {
+            const approved = planManager.approve(found.id);
+            if (options.json) {
+                console.log(JSON.stringify(approved, null, 2));
+                return;
+            }
+            success(`Plan approved: ${approved.id.slice(0, 8)} — "${approved.title}"`);
+            console.log(chalk.dim('The agent will now begin implementation.'));
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : 'Failed to approve plan');
+            process.exit(1);
+        }
+    });
+    // ── reject ────────────────────────────────────────────────────────────────
+    plan
+        .command('reject <id>')
+        .description('Reject a pending plan')
+        .option('-r, --reason <reason>', 'Reason for rejection')
+        .option('--json', 'Output as JSON')
+        .action((id, options) => {
+        const allPlans = planManager.list();
+        const found = allPlans.find((p) => p.id === id || p.id.startsWith(id));
+        if (!found) {
+            error(`Plan not found: ${id}`);
+            process.exit(1);
+        }
+        if (found.status !== 'draft') {
+            warn(`Plan ${found.id.slice(0, 8)} is already ${found.status}, cannot reject.`);
+            process.exit(1);
+        }
+        try {
+            const rejected = planManager.reject(found.id, options.reason);
+            if (options.json) {
+                console.log(JSON.stringify(rejected, null, 2));
+                return;
+            }
+            console.log(chalk.red('✗') + ` Plan rejected: ${rejected.id.slice(0, 8)}`);
+            if (options.reason) {
+                console.log(chalk.dim(`Reason: ${options.reason}`));
+            }
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : 'Failed to reject plan');
+            process.exit(1);
+        }
+    });
+    return plan;
+}
+//# sourceMappingURL=plan.js.map

package/dist/cli/commands/serve.d.ts

@@ -1,3 +1,10 @@
 import { Command } from 'commander';
+export declare function checkPortAvailable(port: number): Promise<boolean>;
+/**
+ * Try to find an available port starting at `startPort`.
+ * Attempts up to MAX_PORT_ATTEMPTS consecutive ports.
+ * Returns the available port, or null if all attempts fail.
+ */
+export declare function resolvePort(startPort: number): Promise<number | null>;
 export declare function serveCommand(): Command;
 //# sourceMappingURL=serve.d.ts.map

package/dist/cli/commands/serve.js

@@ -5,23 +5,21 @@ import { spawn } from 'child_process';
 import { resolve } from 'path';
 import { existsSync } from 'fs';
 import { createServer } from 'net';
+import * as readline from 'readline';
 import { success, error, info, warn } from '../utils/output.js';
+import { isServerRunning, killExistingServer } from '../../utils/pid-file.js';
 const MAX_RESTART_ATTEMPTS = 5;
+const MAX_PORT_ATTEMPTS = 3;
 const BASE_BACKOFF_MS = 1000;
 const MAX_BACKOFF_MS = 30000;
 const CRASH_WINDOW_MS = 10000;
 const HEALTH_CHECK_DELAY_MS = 3000;
 const HEALTH_CHECK_TIMEOUT_MS = 5000;
-function checkPortAvailable(port) {
+export function checkPortAvailable(port) {
     return new Promise((resolve) => {
         const server = createServer();
         server.once('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                resolve(false);
-            }
-            else {
-                resolve(true);
-            }
+            resolve(err.code !== 'EADDRINUSE');
         });
         server.once('listening', () => {
             server.close();
@@ -30,6 +28,21 @@ function checkPortAvailable(port) {
         server.listen(port, '127.0.0.1');
     });
 }
+/**
+ * Try to find an available port starting at `startPort`.
+ * Attempts up to MAX_PORT_ATTEMPTS consecutive ports.
+ * Returns the available port, or null if all attempts fail.
+ */
+export async function resolvePort(startPort) {
+    for (let offset = 0; offset < MAX_PORT_ATTEMPTS; offset++) {
+        const candidate = startPort + offset;
+        const available = await checkPortAvailable(candidate);
+        if (available) {
+            return candidate;
+        }
+    }
+    return null;
+}
 async function healthCheck(port) {
     try {
         const res = await fetch(`http://localhost:${port}/health`, {
@@ -58,19 +71,46 @@ export function serveCommand() {
         console.log(chalk.cyan(banner));
         console.log(chalk.dim('  AI Agent Task Orchestrator\n'));
         const port = parseInt(options.port, 10);
-        // Pre-flight: check port availability
-        const portAvailable = await checkPortAvailable(port);
-        if (!portAvailable) {
-            error(`Port ${port} is already in use.`);
-            info('Options:');
-            console.log(`  1. Stop the existing process: ${chalk.cyan(`lsof -ti:${port} | xargs kill`)}`);
-            console.log(`  2. Use a different port: ${chalk.cyan(`profclaw serve -p ${port + 1}`)}`);
+        // Pre-flight: check for an existing server instance via PID file
+        const running = isServerRunning();
+        if (running.running && running.pid !== undefined) {
+            warn(`A profClaw server is already running (PID ${running.pid}, port ${running.port}).`);
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const answer = await new Promise((resolve) => {
+                rl.question('  Kill the existing server and start a new one? [y/N] ', (ans) => {
+                    rl.close();
+                    resolve(ans.trim().toLowerCase());
+                });
+            });
+            if (answer === 'y' || answer === 'yes') {
+                const killed = killExistingServer();
+                if (killed) {
+                    success('Existing server stopped.');
+                }
+                else {
+                    error('Could not stop the existing server within 5 seconds. Aborting.');
+                    process.exit(1);
+                }
+            }
+            else {
+                info('Aborted. The existing server is still running.');
+                process.exit(0);
+            }
+        }
+        // Pre-flight: find an available port (retry up to MAX_PORT_ATTEMPTS)
+        const actualPort = await resolvePort(port);
+        if (actualPort === null) {
+            error(`Ports ${port}–${port + MAX_PORT_ATTEMPTS - 1} are all in use.`);
+            info(`Free a port or specify a different one: ${chalk.cyan(`profclaw serve -p <port>`)}`);
             process.exit(1);
         }
+        if (actualPort !== port) {
+            warn(`Port ${port} in use, started on port ${actualPort}`);
+        }
         // Set environment variables
         const env = {
             ...process.env,
-            PORT: options.port,
+            PORT: String(actualPort),
             ENABLE_CRON: options.cron === false ? 'false' : 'true',
         };
         // Determine the project root
@@ -92,7 +132,7 @@ export function serveCommand() {
                 command = 'npx';
                 args = ['tsx', 'src/server.ts'];
             }
-            console.log(chalk.blue(`Starting server on port ${options.port}...\n`));
+            console.log(chalk.blue(`Starting server on port ${actualPort}...\n`));
         }
         const autoRestart = options.restart !== false && !options.dev;
         const state = {
@@ -154,9 +194,28 @@ export function serveCommand() {
                 setTimeout(async () => {
                     if (state.shuttingDown)
                         return;
-                    const healthy = await healthCheck(port);
+                    const healthy = await healthCheck(actualPort);
                     if (healthy) {
-                        success(`Server healthy on port ${port}`);
+                        success(`Server healthy on port ${actualPort}`);
+                        // WS-1.3: detect first-run (no admin users) and print setup prompt
+                        try {
+                            const res = await fetch(`http://localhost:${actualPort}/`, {
+                                redirect: 'manual',
+                                signal: AbortSignal.timeout(HEALTH_CHECK_TIMEOUT_MS),
+                            });
+                            if (res.status === 302) {
+                                const location = res.headers.get('location') || '';
+                                if (location.includes('/setup')) {
+                                    console.log('');
+                                    console.log(chalk.yellow('  First run detected.'));
+                                    console.log(chalk.yellow(`  Visit ${chalk.cyan(`http://localhost:${port}/setup`)} to configure profClaw`));
+                                    console.log('');
+                                }
+                            }
+                        }
+                        catch {
+                            // Non-critical — ignore
+                        }
                     }
                     else {
                         warn('Server may not be fully ready yet. Check logs above.');

package/dist/cli/commands/setup.js

@@ -14,11 +14,13 @@ import figlet from 'figlet';
 import { select, search, input, password as passwordPrompt, confirm, Separator } from '@inquirer/prompts';
 import { randomUUID } from 'crypto';
 import { eq } from 'drizzle-orm';
-import { spawn } from 'child_process';
+import { spawn, execFile } from 'child_process';
 import { existsSync, mkdirSync, openSync } from 'node:fs';
 import { join } from 'node:path';
+import { promisify } from 'node:util';
+import * as os from 'os';
 import { createServer } from 'net';
-import { initStorage, getDb, saveProviderConfig, loadAllProviderConfigs } from '../../storage/index.js';
+import { initStorage, getDb, closeStorage, saveProviderConfig, loadAllProviderConfigs } from '../../storage/index.js';
 import { users, inviteCodes } from '../../storage/schema.js';
 import { PROVIDER_CATALOG } from '../providers.js';
 import { hashPassword, validatePasswordStrength, generateRecoveryCodes, hashRecoveryCodes, generateInviteCode, hashInviteCode, } from '../../auth/password.js';
@@ -586,6 +588,80 @@ async function stepGitHubOAuth() {
     return true;
 }
 // Step 6: Summary
+const execFileAsync = promisify(execFile);
+async function runQuickHealthCheck() {
+    const results = [];
+    // 1. Node.js version
+    const nodeVersion = process.version;
+    const nodeMajor = parseInt(nodeVersion.slice(1).split('.')[0], 10);
+    results.push({
+        label: 'Node.js',
+        status: nodeMajor >= 20 ? 'pass' : 'warn',
+        detail: nodeMajor >= 20 ? nodeVersion : `${nodeVersion} (v20+ recommended)`,
+    });
+    // 2. Config files
+    const cwd = process.cwd();
+    const settingsExists = existsSync(join(cwd, 'config', 'settings.yml'));
+    const envExists = existsSync(join(cwd, '.env'));
+    const configStatus = settingsExists && envExists ? 'pass' : settingsExists || envExists ? 'warn' : 'fail';
+    const configDetail = settingsExists && envExists
+        ? 'settings.yml + .env found'
+        : settingsExists
+            ? 'settings.yml found, .env missing'
+            : envExists
+                ? '.env found, settings.yml missing'
+                : 'settings.yml and .env not found';
+    results.push({ label: 'Config', status: configStatus, detail: configDetail });
+    // 3. Database — initStorage() already ran, so if we get here the DB is initialized
+    results.push({ label: 'Database', status: 'pass', detail: 'Initialized' });
+    // 4. Memory
+    const freeBytes = os.freemem();
+    const freeMb = freeBytes / 1024 / 1024;
+    const freeGb = freeBytes / 1024 / 1024 / 1024;
+    const memDetail = freeGb >= 1 ? `${freeGb.toFixed(1)} GB free` : `${Math.round(freeMb)} MB free`;
+    results.push({
+        label: 'Memory',
+        status: freeMb >= 256 ? 'pass' : 'warn',
+        detail: freeMb >= 256 ? memDetail : `${memDetail} (low)`,
+    });
+    // 5. Disk — df on cwd
+    let diskDetail = 'unavailable';
+    let diskStatus = 'warn';
+    try {
+        const { stdout } = await execFileAsync('df', ['-k', cwd]);
+        const lines = stdout.trim().split('\n');
+        if (lines.length >= 2) {
+            const parts = lines[1].trim().split(/\s+/);
+            // df -k columns: Filesystem 1K-blocks Used Available Use% Mounted (macOS/Linux may vary)
+            const availIdx = parts.length >= 4 ? (parts.length === 6 ? 3 : parts.length - 3) : -1;
+            const useIdx = parts.length >= 5 ? parts.length - 2 : -1;
+            if (availIdx !== -1 && useIdx !== -1) {
+                const availKb = parseInt(parts[availIdx], 10);
+                const usePercent = parts[useIdx];
+                const availGb = availKb / 1024 / 1024;
+                diskDetail = `${availGb.toFixed(0)} GB free (${usePercent} used)`;
+                diskStatus = availGb >= 1 ? 'pass' : 'warn';
+            }
+        }
+    }
+    catch { /* df not available */ }
+    results.push({ label: 'Disk', status: diskStatus, detail: diskDetail });
+    // Render
+    const icon = (s) => s === 'pass' ? chalk.green('\u2713') : s === 'warn' ? chalk.yellow('\u26a0') : chalk.red('\u2717');
+    const labelWidth = 12;
+    console.log('');
+    console.log(chalk.bold.white('  Quick Health Check'));
+    console.log('  ' + '\u2500'.repeat(44));
+    for (const r of results) {
+        const label = r.label.padEnd(labelWidth);
+        console.log(`  ${icon(r.status)} ${chalk.dim(label)} ${r.detail}`);
+    }
+    console.log('  ' + '\u2500'.repeat(44));
+    const passed = results.filter(r => r.status === 'pass').length;
+    const total = results.length;
+    const summary = passed === total ? chalk.green(`${passed}/${total} checks passed`) : chalk.yellow(`${passed}/${total} checks passed`);
+    console.log(`  ${summary}`);
+}
 function checkPortAvailable(port) {
     return new Promise((resolve) => {
         const server = createServer();
@@ -605,6 +681,7 @@ async function showSummaryAndOffer(results) {
     console.log(`  ${mark(true)} Registration: ${results.registrationMode}${results.inviteCodes.length ? ` (${results.inviteCodes.length} codes)` : ''}`);
     console.log(`  ${mark(results.githubOAuth)} GitHub OAuth: ${results.githubOAuth ? 'configured' : 'skipped'}`);
     console.log('  ' + '\u2500'.repeat(44));
+    await runQuickHealthCheck();
     // Check if server is already running
     const portFree = await checkPortAvailable(port);
     const serverRunning = !portFree;
@@ -828,7 +905,8 @@ export function setupCommand() {
                     aiProvider: options.aiProvider,
                     registrationMode: options.registrationMode,
                 });
-                return;
+                await closeStorage();
+                process.exit(0);
             }
             const fromOnboard = !!options.fromOnboard;
             // Interactive mode
@@ -904,9 +982,12 @@ export function setupCommand() {
                 githubOAuth,
                 fromOnboard,
             });
+            await closeStorage();
+            process.exit(0);
         }
         catch (err) {
             error(err instanceof Error ? err.message : 'Setup failed');
+            await closeStorage();
             process.exit(1);
         }
     });

package/dist/cli/commands/status.js

@@ -2,6 +2,25 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import { api } from '../utils/api.js';
 import { spinner } from '../utils/output.js';
+import { isServerRunning } from '../../utils/pid-file.js';
+function formatUptime(seconds) {
+    if (seconds < 60) {
+        return `${seconds}s`;
+    }
+    if (seconds < 3600) {
+        const m = Math.floor(seconds / 60);
+        const s = seconds % 60;
+        return `${m}m ${s}s`;
+    }
+    if (seconds < 86400) {
+        const h = Math.floor(seconds / 3600);
+        const m = Math.floor((seconds % 3600) / 60);
+        return `${h}h ${m}m`;
+    }
+    const d = Math.floor(seconds / 86400);
+    const h = Math.floor((seconds % 86400) / 3600);
+    return `${d}d ${h}h`;
+}
 export function statusCommand() {
     const cmd = new Command('status')
         .description('System status overview')
@@ -35,6 +54,41 @@ export function statusCommand() {
             ? chalk.green('healthy')
             : chalk.red('unhealthy');
         console.log(`\nprofClaw v${version} | Mode: ${mode} | Status: ${statusText}\n`);
+        // PID / port from PID file (fast local read) or health endpoint
+        const pidInfo = isServerRunning();
+        const pid = health.data?.process?.pid ?? pidInfo.pid;
+        const port = health.data?.process?.port ?? pidInfo.port;
+        if (pid !== undefined) {
+            console.log(`${chalk.bold('Process')}      PID ${pid}${port ? `, port ${port}` : ''}`);
+        }
+        // Uptime
+        if (health.data?.uptime !== undefined) {
+            console.log(`${chalk.bold('Uptime')}       ${formatUptime(health.data.uptime)}`);
+        }
+        // SSE clients
+        if (health.data?.sseClients !== undefined) {
+            console.log(`${chalk.bold('SSE Clients')}  ${health.data.sseClients}`);
+        }
+        // Active agent sessions
+        if (health.data?.activeSessions !== undefined) {
+            console.log(`${chalk.bold('Sessions')}     ${health.data.activeSessions} active`);
+        }
+        // Queue depth
+        if (health.data?.queueDepth !== undefined) {
+            const q = health.data.queueDepth;
+            console.log(`${chalk.bold('Queue')}        ${q.pending} pending, ${q.running} running`);
+        }
+        // Memory and CPU
+        if (health.data?.process !== undefined) {
+            const p = health.data.process;
+            const load = p.cpuLoadAvg.length > 0 ? p.cpuLoadAvg[0].toFixed(2) : '?';
+            console.log(`${chalk.bold('Resources')}    ${p.memoryMb} MB RSS | CPU load ${load}`);
+        }
+        // Last error
+        if (health.data?.lastError) {
+            console.log(`${chalk.bold('Last error')}   ${chalk.red(health.data.lastError)}`);
+        }
+        console.log('');
         if (providers.ok && providers.data) {
             const active = providers.data.providers.filter((p) => p.enabled || p.configured);
             const healthySummary = active

package/dist/cli/commands/tools.js

@@ -11,9 +11,9 @@ import { registerBuiltinTools } from '../../chat/execution/tools/index.js';
 import { getToolRegistry } from '../../chat/execution/registry.js';
 // Lazy initialization - only register tools when a tools command actually runs
 let toolsInitialized = false;
-function getRegistry() {
+async function getRegistry() {
     if (!toolsInitialized) {
-        registerBuiltinTools();
+        await registerBuiltinTools();
         toolsInitialized = true;
     }
     return getToolRegistry();
@@ -93,7 +93,7 @@ export function toolsCommands() {
         .option('--json', 'Output as JSON')
         .option('-c, --category <cat>', 'Filter by category')
         .action(async (options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         let toolList = registry.list();
         if (options.category) {
             toolList = toolList.filter((t) => t.category === options.category);
@@ -145,7 +145,7 @@ export function toolsCommands() {
         .description('Show detailed information about a tool')
         .option('--json', 'Output as JSON')
         .action(async (name, options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get(name);
         if (!tool) {
             error(`Tool '${name}' not found`);
@@ -192,7 +192,7 @@ export function toolsCommands() {
         .option('--json', 'Output result as JSON')
         .option('-y, --yes', 'Skip approval for moderate tools')
         .action(async (name, options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get(name);
         if (!tool) {
             error(`Tool '${name}' not found`);
@@ -270,7 +270,7 @@ export function toolsCommands() {
         .option('--json', 'Output as JSON')
         .action(async (commandParts, options) => {
         const command = commandParts.join(' ');
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('exec');
         if (!tool) {
             error('exec tool not found');
@@ -308,7 +308,7 @@ export function toolsCommands() {
         .option('-s, --short', 'Short format')
         .option('-w, --workdir <path>', 'Repository path')
         .action(async (options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('git_status');
         if (!tool) {
             error('git_status tool not found');
@@ -332,7 +332,7 @@ export function toolsCommands() {
         .option('-t, --type <type>', 'Info type: all, cpu, memory, os, network', 'all')
         .option('--json', 'Output as JSON')
         .action(async (options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('system_info');
         if (!tool) {
             error('system_info tool not found');
@@ -359,7 +359,7 @@ export function toolsCommands() {
         .description('Shortcut: Show environment variables')
         .option('-f, --filter <pattern>', 'Filter by pattern')
         .action(async (name, options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('env');
         if (!tool) {
             error('env tool not found');
@@ -381,7 +381,7 @@ export function toolsCommands() {
         .command('which <command>')
         .description('Shortcut: Find command location')
         .action(async (command) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('which');
         if (!tool) {
             error('which tool not found');
@@ -403,7 +403,7 @@ export function toolsCommands() {
         .description('Shortcut: Read a file')
         .option('-l, --lines <n>', 'Max lines to read', '100')
         .action(async (filePath, options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('read_file');
         if (!tool) {
             error('read_file tool not found');
@@ -431,7 +431,7 @@ export function toolsCommands() {
         .option('-p, --path <dir>', 'Search directory', '.')
         .option('-t, --type <type>', 'File type: file, directory, both', 'file')
         .action(async (pattern, options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('search_files');
         if (!tool) {
             error('search_files tool not found');
@@ -469,7 +469,7 @@ export function toolsCommands() {
         .option('-i, --ignore-case', 'Case insensitive')
         .option('-c, --context <n>', 'Context lines', '0')
         .action(async (pattern, searchPath, options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('grep');
         if (!tool) {
             error('grep tool not found');