zouroboros-cli 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 marlandoj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# zouroboros-cli
+
+> Unified command-line interface for Zouroboros
+
+## Installation
+
+```bash
+npm install -g zouroboros-cli
+```
+
+Or use locally:
+
+```bash
+npx zouroboros
+```
+
+## Quick Start
+
+```bash
+# Initialize Zouroboros
+zouroboros init
+
+# Check health
+zouroboros doctor
+
+# Launch dashboard
+zouroboros tui
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `init` | Initialize configuration |
+| `doctor` | Health check |
+| `config` | Manage configuration |
+| `memory` | Memory system commands |
+| `swarm` | Swarm orchestration |
+| `persona` | Persona management |
+| `workflow` | Interview, evaluate, autoloop |
+| `heal` | Self-healing system |
+| `tui` | Launch dashboard |
+
+## Examples
+
+```bash
+# Initialize
+zouroboros init
+
+# Search memory
+zouroboros memory search "project requirements"
+
+# Run swarm campaign
+zouroboros swarm run tasks.json --strategy reliable
+
+# Create persona
+zouroboros persona create "Health Coach" --domain healthcare --interactive
+
+# Run introspection
+zouroboros heal introspect --store
+
+# Launch TUI dashboard
+zouroboros tui
+```

package/dist/commands/agents.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const agentsCommand: Command;

package/dist/commands/agents.js

@@ -0,0 +1,44 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+const MARKER_PATH = join(homedir(), '.zouroboros', 'agents-registered.json');
+export const agentsCommand = new Command('agents')
+    .description('Manage Zouroboros scheduled agents')
+    .addCommand(new Command('sync')
+    .description('Mark agents as registered after creating them in Zo Chat')
+    .action(() => {
+    const monorepoRoot = join(__dirname, '..', '..', '..');
+    const manifestPath = join(monorepoRoot, 'agents', 'manifest.json');
+    if (!existsSync(manifestPath)) {
+        console.error(chalk.red('agents/manifest.json not found'));
+        process.exit(1);
+    }
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    const agentEntries = Object.entries(manifest.agents || {});
+    const marker = {
+        registeredAt: new Date().toISOString(),
+        agents: agentEntries.map(([slug, spec]) => ({
+            slug,
+            title: spec.title,
+        })),
+    };
+    mkdirSync(dirname(MARKER_PATH), { recursive: true });
+    writeFileSync(MARKER_PATH, JSON.stringify(marker, null, 2));
+    console.log(chalk.green(`✓ Marked ${agentEntries.length} agents as registered`));
+    console.log(chalk.gray(`  Written to ${MARKER_PATH}`));
+}))
+    .addCommand(new Command('status')
+    .description('Show agent registration status')
+    .action(() => {
+    if (!existsSync(MARKER_PATH)) {
+        console.log(chalk.yellow('No agents registered. Run: zouroboros agents sync'));
+        return;
+    }
+    const marker = JSON.parse(readFileSync(MARKER_PATH, 'utf-8'));
+    console.log(chalk.green(`${marker.agents.length} agents registered at ${marker.registeredAt}`));
+    for (const agent of marker.agents) {
+        console.log(chalk.gray(`  • ${agent.title}`));
+    }
+}));

package/dist/commands/backup.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const backupCommand: Command;

package/dist/commands/backup.js

@@ -0,0 +1,122 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { loadConfig, createBackup, restoreBackup, listBackups, pruneBackups, formatBytes, } from 'zouroboros-core';
+export const backupCommand = new Command('backup')
+    .description('Backup and restore Zouroboros data')
+    .addCommand(new Command('create')
+    .description('Create a new backup of memory DB, config, and registry')
+    .option('-l, --label <label>', 'Optional label for the backup')
+    .action((opts) => {
+    try {
+        const config = loadConfig();
+        const result = createBackup({ config, label: opts.label });
+        console.log(chalk.green('\n✅ Backup created successfully\n'));
+        console.log(`  Location: ${chalk.cyan(result.backupDir)}`);
+        console.log(`  Files:    ${result.manifest.files.length}`);
+        console.log(`  Size:     ${formatBytes(result.totalSizeBytes)}`);
+        console.log();
+        for (const file of result.manifest.files) {
+            console.log(`  ${chalk.gray('•')} ${file.name} (${formatBytes(file.sizeBytes)})`);
+        }
+        // Auto-prune old backups
+        const pruned = pruneBackups(config);
+        if (pruned > 0) {
+            console.log(chalk.gray(`\n  Pruned ${pruned} old backup(s)`));
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red(`\n❌ Backup failed: ${err instanceof Error ? err.message : String(err)}\n`));
+        process.exit(1);
+    }
+}))
+    .addCommand(new Command('restore')
+    .description('Restore from a backup')
+    .argument('<name>', 'Backup name or path (use "backup list" to see available)')
+    .option('--dry-run', 'Show what would be restored without making changes')
+    .option('--skip-config', 'Skip restoring the config file')
+    .action((name, opts) => {
+    try {
+        const config = loadConfig();
+        const backups = listBackups(config);
+        // Resolve backup path: check if it's a name or full path
+        let backupDir = name;
+        const match = backups.find((b) => b.name === name);
+        if (match) {
+            backupDir = match.path;
+        }
+        if (opts.dryRun) {
+            console.log(chalk.yellow('\n🔍 Dry run — no changes will be made\n'));
+        }
+        const result = restoreBackup(backupDir, {
+            dryRun: opts.dryRun,
+            skipConfig: opts.skipConfig,
+        });
+        const verb = opts.dryRun ? 'Would restore' : 'Restored';
+        console.log(chalk.green(`\n✅ ${verb} from backup (${result.manifest.createdAt})\n`));
+        if (result.restoredFiles.length > 0) {
+            console.log(`  ${chalk.cyan(verb)}:`);
+            for (const f of result.restoredFiles) {
+                console.log(`    ${chalk.gray('•')} ${f}`);
+            }
+        }
+        if (result.skippedFiles.length > 0) {
+            console.log(`\n  ${chalk.yellow('Skipped')}:`);
+            for (const f of result.skippedFiles) {
+                console.log(`    ${chalk.gray('•')} ${f}`);
+            }
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red(`\n❌ Restore failed: ${err instanceof Error ? err.message : String(err)}\n`));
+        process.exit(1);
+    }
+}))
+    .addCommand(new Command('list')
+    .description('List available backups')
+    .alias('ls')
+    .action(() => {
+    try {
+        const config = loadConfig();
+        const backups = listBackups(config);
+        if (backups.length === 0) {
+            console.log(chalk.yellow('\nNo backups found. Run "zouroboros backup create" to create one.\n'));
+            return;
+        }
+        console.log(chalk.cyan(`\nAvailable backups (${backups.length}):\n`));
+        for (const backup of backups) {
+            const date = new Date(backup.createdAt).toLocaleString();
+            console.log(`  ${chalk.white(backup.name)}  ${chalk.gray(date)}  ${chalk.gray(formatBytes(backup.sizeBytes))}  ${chalk.gray(`${backup.fileCount} files`)}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red(`\n❌ ${err instanceof Error ? err.message : String(err)}\n`));
+        process.exit(1);
+    }
+}))
+    .addCommand(new Command('prune')
+    .description('Remove old backups, keeping the most recent N')
+    .option('-k, --keep <count>', 'Number of backups to keep', '10')
+    .action((opts) => {
+    try {
+        const config = loadConfig();
+        const keep = parseInt(opts.keep, 10);
+        if (isNaN(keep) || keep < 1) {
+            console.error(chalk.red('--keep must be a positive number'));
+            process.exit(1);
+        }
+        const pruned = pruneBackups(config, keep);
+        if (pruned === 0) {
+            console.log(chalk.gray(`\nNo backups to prune (${listBackups(config).length} ≤ ${keep})\n`));
+        }
+        else {
+            console.log(chalk.green(`\n✅ Pruned ${pruned} old backup(s), kept ${keep}\n`));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`\n❌ ${err instanceof Error ? err.message : String(err)}\n`));
+        process.exit(1);
+    }
+}));

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const configCommand: Command;

package/dist/commands/config.js

@@ -0,0 +1,52 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { loadConfig, saveConfig } from 'zouroboros-core';
+import { join } from 'path';
+import { homedir } from 'os';
+export const configCommand = new Command('config')
+    .description('Manage Zouroboros configuration')
+    .addCommand(new Command('get')
+    .description('Get a configuration value')
+    .argument('<key>', 'Configuration key (dot notation)')
+    .action((key) => {
+    const config = loadConfig();
+    const value = key.split('.').reduce((obj, k) => obj?.[k], config);
+    if (value === undefined) {
+        console.log(chalk.yellow(`Key '${key}' not found`));
+        process.exit(1);
+    }
+    console.log(typeof value === 'object' ? JSON.stringify(value, null, 2) : value);
+}))
+    .addCommand(new Command('set')
+    .description('Set a configuration value')
+    .argument('<key>', 'Configuration key (dot notation)')
+    .argument('<value>', 'Value to set')
+    .action((key, value) => {
+    const configPath = join(homedir(), '.zouroboros', 'config.json');
+    const config = loadConfig(configPath);
+    const keys = key.split('.');
+    let target = config;
+    for (let i = 0; i < keys.length - 1; i++) {
+        if (!target[keys[i]])
+            target[keys[i]] = {};
+        target = target[keys[i]];
+    }
+    // Try to parse as JSON, fallback to string
+    try {
+        target[keys[keys.length - 1]] = JSON.parse(value);
+    }
+    catch {
+        target[keys[keys.length - 1]] = value;
+    }
+    saveConfig(config, configPath);
+    console.log(chalk.green(`✅ Set ${key} = ${value}`));
+}))
+    .addCommand(new Command('list')
+    .description('List all configuration values')
+    .alias('ls')
+    .action(() => {
+    const config = loadConfig();
+    console.log(chalk.cyan('\nZouroboros Configuration:\n'));
+    console.log(JSON.stringify(config, null, 2));
+    console.log();
+}));

package/dist/commands/doctor.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const doctorCommand: Command;

package/dist/commands/doctor.js

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { runDoctor } from '../utils/doctor.js';
+export const doctorCommand = new Command('doctor')
+    .description('Run health check on all Zouroboros components')
+    .option('--fix', 'Attempt to fix issues automatically')
+    .action(async (options) => {
+    console.log(chalk.cyan('\n🔍 Zouroboros Health Check\n'));
+    const healthy = await runDoctor({ fix: options.fix });
+    process.exit(healthy ? 0 : 1);
+});

package/dist/commands/heal.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const healCommand: Command;

package/dist/commands/heal.js

@@ -0,0 +1,51 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+export const healCommand = new Command('heal')
+    .description('Self-healing system commands')
+    .addCommand(new Command('introspect')
+    .description('Run health introspection')
+    .option('--json', 'Output as JSON')
+    .option('--store', 'Store as memory episode')
+    .action(async (options) => {
+    const { introspect } = await import('zouroboros-selfheal');
+    const scorecard = await introspect({
+        json: options.json,
+        store: options.store,
+    });
+    if (options.json) {
+        console.log(JSON.stringify(scorecard, null, 2));
+    }
+}))
+    .addCommand(new Command('prescribe')
+    .description('Generate improvement prescription')
+    .option('--live', 'Run introspect live')
+    .option('--target <metric>', 'Target specific metric')
+    .action(async (options) => {
+    console.log(chalk.cyan('\n🔬 Generating prescription...\n'));
+    const { prescribe } = await import('zouroboros-selfheal');
+    const prescription = await prescribe({
+        live: options.live,
+        target: options.target,
+    });
+    console.log(chalk.green('✅ Prescription generated'));
+    console.log(chalk.gray(`   Metric: ${prescription.metric.name}`));
+    console.log(chalk.gray(`   Playbook: ${prescription.playbook.id}\n`));
+}))
+    .addCommand(new Command('evolve')
+    .description('Execute prescribed improvement')
+    .requiredOption('--prescription <path>', 'Prescription file')
+    .action(async (options) => {
+    console.log(chalk.cyan('\n🧬 Executing evolution...\n'));
+    const { evolve } = await import('zouroboros-selfheal');
+    const result = await evolve({
+        prescription: options.prescription,
+    });
+    if (result.success) {
+        console.log(chalk.green('✅ Evolution complete'));
+        console.log(chalk.gray(`   Delta: ${result.delta}\n`));
+    }
+    else {
+        console.log(chalk.red('❌ Evolution failed'));
+        console.log(chalk.gray(`   Detail: ${result.detail}\n`));
+    }
+}));

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const initCommand: Command;

package/dist/commands/init.js

@@ -0,0 +1,234 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { existsSync, mkdirSync } from 'fs';
+import { execSync } from 'child_process';
+import { join } from 'path';
+import { homedir } from 'os';
+import { saveConfig, DEFAULT_CONFIG } from 'zouroboros-core';
+import { runDoctor } from '../utils/doctor.js';
+export const initCommand = new Command('init')
+    .description('Initialize Zouroboros configuration')
+    .option('-f, --force', 'Overwrite existing configuration')
+    .option('--skip-doctor', 'Skip health check after initialization')
+    .option('--skip-ollama', 'Skip Ollama installation')
+    .action(async (options) => {
+    console.log(chalk.cyan('\n🐍⭕ Initializing Zouroboros...\n'));
+    const configDir = join(homedir(), '.zouroboros');
+    const configPath = join(configDir, 'config.json');
+    // Check if already initialized
+    if (existsSync(configPath) && !options.force) {
+        console.log(chalk.yellow('⚠️  Zouroboros is already initialized.'));
+        console.log(chalk.gray(`   Config: ${configPath}`));
+        console.log(chalk.gray('\n   Use --force to reinitialize.\n'));
+        return;
+    }
+    // Create config directory
+    mkdirSync(configDir, { recursive: true });
+    // Create default configuration
+    const config = {
+        ...DEFAULT_CONFIG,
+        initializedAt: new Date().toISOString(),
+    };
+    saveConfig(config, configPath);
+    console.log(chalk.green('✅ Configuration created'));
+    console.log(chalk.gray(`   ${configPath}\n`));
+    // Create workspace directories
+    const workspaceDirs = [
+        join(configDir, 'logs'),
+        join(configDir, 'seeds'),
+        join(configDir, 'results'),
+    ];
+    for (const dir of workspaceDirs) {
+        mkdirSync(dir, { recursive: true });
+    }
+    console.log(chalk.green('✅ Workspace directories created'));
+    console.log(chalk.gray(`   ${configDir}/{logs,seeds,results}\n`));
+    // Initialize memory database
+    console.log(chalk.cyan('💾 Initializing memory database...'));
+    try {
+        const dbPath = config.memory.dbPath;
+        const dbDir = join(dbPath, '..');
+        mkdirSync(dbDir, { recursive: true });
+        // Use sqlite3 CLI to create the schema (avoids needing bun:sqlite at install time)
+        const schemaSql = `
+PRAGMA journal_mode = WAL;
+
+CREATE TABLE IF NOT EXISTS facts (
+  id TEXT PRIMARY KEY,
+  persona TEXT,
+  entity TEXT NOT NULL,
+  key TEXT,
+  value TEXT NOT NULL,
+  text TEXT NOT NULL,
+  category TEXT DEFAULT 'fact' CHECK(category IN ('preference', 'fact', 'decision', 'convention', 'other', 'reference', 'project')),
+  decay_class TEXT DEFAULT 'medium' CHECK(decay_class IN ('permanent', 'long', 'medium', 'short')),
+  importance REAL DEFAULT 1.0,
+  source TEXT,
+  created_at INTEGER DEFAULT (strftime('%s', 'now')),
+  expires_at INTEGER,
+  last_accessed INTEGER DEFAULT (strftime('%s', 'now')),
+  confidence REAL DEFAULT 1.0,
+  metadata TEXT
+);
+
+CREATE TABLE IF NOT EXISTS fact_embeddings (
+  fact_id TEXT PRIMARY KEY REFERENCES facts(id) ON DELETE CASCADE,
+  embedding BLOB NOT NULL,
+  model TEXT DEFAULT 'nomic-embed-text',
+  created_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS episodes (
+  id TEXT PRIMARY KEY,
+  summary TEXT NOT NULL,
+  outcome TEXT NOT NULL CHECK(outcome IN ('success', 'failure', 'resolved', 'ongoing')),
+  happened_at INTEGER NOT NULL,
+  duration_ms INTEGER,
+  procedure_id TEXT,
+  metadata TEXT,
+  created_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS episode_entities (
+  episode_id TEXT NOT NULL REFERENCES episodes(id) ON DELETE CASCADE,
+  entity TEXT NOT NULL,
+  PRIMARY KEY (episode_id, entity)
+);
+
+CREATE TABLE IF NOT EXISTS procedures (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  version INTEGER DEFAULT 1,
+  steps TEXT NOT NULL,
+  success_count INTEGER DEFAULT 0,
+  failure_count INTEGER DEFAULT 0,
+  evolved_from TEXT,
+  created_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS open_loops (
+  id TEXT PRIMARY KEY,
+  summary TEXT NOT NULL,
+  entity TEXT NOT NULL,
+  status TEXT DEFAULT 'open' CHECK(status IN ('open', 'resolved')),
+  priority INTEGER DEFAULT 1,
+  created_at INTEGER DEFAULT (strftime('%s', 'now')),
+  resolved_at INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS continuation_context (
+  id TEXT PRIMARY KEY,
+  conversation_id TEXT NOT NULL,
+  last_summary TEXT NOT NULL,
+  open_loop_ids TEXT,
+  entity_stack TEXT,
+  last_agent TEXT,
+  updated_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS cognitive_profiles (
+  entity TEXT PRIMARY KEY,
+  traits TEXT,
+  preferences TEXT,
+  interaction_count INTEGER DEFAULT 0,
+  last_interaction INTEGER,
+  created_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS _migrations (
+  id INTEGER PRIMARY KEY,
+  name TEXT NOT NULL,
+  applied_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_facts_entity_key ON facts(entity, key);
+CREATE INDEX IF NOT EXISTS idx_facts_decay ON facts(decay_class, expires_at);
+CREATE INDEX IF NOT EXISTS idx_facts_category ON facts(category);
+CREATE INDEX IF NOT EXISTS idx_episodes_happened ON episodes(happened_at);
+CREATE INDEX IF NOT EXISTS idx_episodes_outcome ON episodes(outcome);
+CREATE INDEX IF NOT EXISTS idx_episode_entities ON episode_entities(entity);
+CREATE INDEX IF NOT EXISTS idx_open_loops_entity ON open_loops(entity, status);
+`;
+        execSync(`sqlite3 "${dbPath}" <<'SCHEMA'\n${schemaSql}\nSCHEMA`, {
+            shell: '/bin/bash',
+            stdio: 'pipe',
+        });
+        console.log(chalk.green('✅ Memory database initialized'));
+        console.log(chalk.gray(`   ${dbPath}\n`));
+    }
+    catch (error) {
+        console.log(chalk.yellow('⚠️  Memory database initialization failed — will be created on first use'));
+        console.log(chalk.gray(`   ${error instanceof Error ? error.message : String(error)}\n`));
+    }
+    // Install Ollama if not present
+    if (!options.skipOllama) {
+        console.log(chalk.cyan('🦙 Checking Ollama...'));
+        let ollamaAvailable = false;
+        try {
+            execSync('command -v ollama', { stdio: 'pipe' });
+            ollamaAvailable = true;
+            console.log(chalk.green('✅ Ollama already installed'));
+        }
+        catch {
+            console.log(chalk.gray('   Ollama not found — installing...'));
+            try {
+                execSync('curl -fsSL https://ollama.com/install.sh | sh', {
+                    stdio: 'inherit',
+                    timeout: 120000,
+                });
+                ollamaAvailable = true;
+                console.log(chalk.green('✅ Ollama installed'));
+            }
+            catch (error) {
+                console.log(chalk.yellow('⚠️  Ollama installation failed — vector search will be limited'));
+                console.log(chalk.gray('   Install manually: https://ollama.com/download\n'));
+            }
+        }
+        // Pull the embedding model if Ollama is available
+        if (ollamaAvailable) {
+            console.log(chalk.gray('   Pulling embedding model (nomic-embed-text)...'));
+            try {
+                // Ensure ollama is serving
+                try {
+                    execSync('curl -sf http://localhost:11434/api/tags > /dev/null', { timeout: 3000 });
+                }
+                catch {
+                    // Start ollama serve in background
+                    execSync('nohup ollama serve > /dev/null 2>&1 &', { shell: '/bin/bash' });
+                    // Wait briefly for it to start
+                    execSync('sleep 3');
+                }
+                execSync('ollama pull nomic-embed-text', {
+                    stdio: 'inherit',
+                    timeout: 300000, // 5 min for model download
+                });
+                console.log(chalk.green('✅ Embedding model ready\n'));
+            }
+            catch (error) {
+                console.log(chalk.yellow('⚠️  Could not pull embedding model — run manually: ollama pull nomic-embed-text\n'));
+            }
+        }
+    }
+    else {
+        console.log(chalk.gray('⏭️  Skipping Ollama installation (--skip-ollama)\n'));
+    }
+    // Run doctor unless skipped
+    if (!options.skipDoctor) {
+        console.log(chalk.cyan('🔍 Running health check...\n'));
+        const healthy = await runDoctor();
+        if (healthy) {
+            console.log(chalk.green('\n✅ Zouroboros is ready to use!\n'));
+            console.log('Next steps:');
+            console.log(chalk.yellow('  zouroboros doctor') + chalk.gray('     - Check system health'));
+            console.log(chalk.yellow('  zouroboros --help') + chalk.gray('     - See all commands'));
+            console.log(chalk.yellow('  zouroboros tui') + chalk.gray('        - Launch dashboard\n'));
+        }
+        else {
+            console.log(chalk.yellow('\n⚠️  Some components need attention.\n'));
+            console.log('Run ' + chalk.yellow('zouroboros doctor') + ' for details.\n');
+        }
+    }
+    else {
+        console.log(chalk.green('\n✅ Initialization complete!\n'));
+    }
+});

package/dist/commands/memory.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const memoryCommand: Command;

package/dist/commands/memory.js

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+import { spawn } from 'child_process';
+import { join } from 'path';
+const MEMORY_SCRIPT = join(process.env.ZO_WORKSPACE || '/home/workspace', 'Skills/zo-memory-system/scripts/memory.ts');
+export const memoryCommand = new Command('memory')
+    .description('Memory system commands')
+    .addCommand(new Command('search')
+    .description('Search memory')
+    .argument('<query>', 'Search query')
+    .option('--limit <n>', 'Limit results', '10')
+    .action((query, options) => {
+    spawn('bun', [MEMORY_SCRIPT, 'search', query, '--limit', options.limit], {
+        stdio: 'inherit'
+    });
+}))
+    .addCommand(new Command('store')
+    .description('Store a fact')
+    .requiredOption('--entity <entity>', 'Entity name')
+    .requiredOption('--key <key>', 'Key')
+    .requiredOption('--value <value>', 'Value')
+    .action((options) => {
+    spawn('bun', [MEMORY_SCRIPT, 'store',
+        '--entity', options.entity,
+        '--key', options.key,
+        '--value', options.value
+    ], { stdio: 'inherit' });
+}))
+    .addCommand(new Command('stats')
+    .description('Show memory statistics')
+    .action(() => {
+    spawn('bun', [MEMORY_SCRIPT, 'stats'], { stdio: 'inherit' });
+}));

package/dist/commands/migrate.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const migrateCommand: Command;