optimal-cli 0.1.0 → 1.0.1

package/dist/bin/optimal.js

@@ -1,12 +1,12 @@
-#!/usr/bin/env tsx
+#!/usr/bin/env node
 import { Command } from 'commander';
 import 'dotenv/config';
-import { getBoard, createTask, updateTask, logActivity, } from '../lib/kanban.js';
+import { createProject, getProjectBySlug, listProjects, updateProject, createMilestone, listMilestones, createLabel, listLabels, createTask, updateTask, listTasks, claimTask, addComment, listActivity, formatBoardTable, } from '../lib/board/index.js';
 import { runAuditComparison } from '../lib/returnpro/audit.js';
 import { exportKpis, formatKpiTable, formatKpiCsv } from '../lib/returnpro/kpis.js';
 import { deploy, healthCheck, listApps } from '../lib/infra/deploy.js';
 import { fetchWesImports, parseSummaryFromJson, initializeProjections, applyUniformAdjustment, calculateTotals, exportToCSV, formatProjectionTable, } from '../lib/budget/projections.js';
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync, writeFileSync } from 'node:fs';
 import { generateNewsletter } from '../lib/newsletter/generate.js';
 import { scrapeCompanies, formatCsv } from '../lib/social/scraper.js';
 import { ingestTransactions } from '../lib/transactions/ingest.js';
@@ -21,87 +21,258 @@ import { distributeNewsletter, checkDistributionStatus } from '../lib/newsletter
 import { generateSocialPosts } from '../lib/social/post-generator.js';
 import { publishSocialPosts, getPublishQueue, retryFailed } from '../lib/social/publish.js';
 import { publishBlog, listBlogDrafts } from '../lib/cms/publish-blog.js';
+import { publishIgPhoto, getMetaConfigForBrand } from '../lib/social/meta.js';
+import { strapiGet, strapiPut } from '../lib/cms/strapi-client.js';
 import { migrateDb, listPendingMigrations, createMigration } from '../lib/infra/migrate.js';
 import { saveScenario, listScenarios, compareScenarios, deleteScenario } from '../lib/budget/scenarios.js';
 import { deleteBatch, previewBatch } from '../lib/transactions/delete-batch.js';
-import { pushConfig, pullConfig, listConfigs, diffConfig, syncConfig } from '../lib/config.js';
+import { assertOptimalConfigV1 } from '../lib/config/schema.js';
+import { appendHistory, getHistoryPath, getLocalConfigPath, hashConfig, pullRegistryProfile, pushRegistryProfile, readLocalConfig, writeLocalConfig, } from '../lib/config/registry.js';
+import { sendHeartbeat, getActiveAgents, claimNextTask, releaseTask, reportProgress, reportCompletion, reportBlocked, runCoordinatorLoop, getCoordinatorStatus, assignTask, rebalance, } from '../lib/bot/index.js';
+import { colorize, statusBadge, priorityBadge, success, error as fmtError, warn as fmtWarn, info as fmtInfo, } from '../lib/format.js';
+import { listAssets, createAsset, updateAsset, getAsset, deleteAsset, trackAssetUsage, listAssetUsage, formatAssetTable, } from '../lib/assets/index.js';
 const program = new Command()
     .name('optimal')
     .description('Optimal CLI — unified skills for financial analytics, content, and infra')
-    .version('0.1.0');
-// Board commands
-const board = program.command('board').description('Kanban board operations');
+    .version('0.1.0')
+    .addHelpText('after', `
+Examples:
+  $ optimal board view                              View the kanban board
+  $ optimal board view -s in_progress               Filter board by status
+  $ optimal board claim --id <uuid> --agent bot1     Claim a task
+  $ optimal project list                            List all projects
+  $ optimal publish-instagram --brand CRE-11TRUST   Publish to Instagram
+  $ optimal social-queue --brand CRE-11TRUST        View social post queue
+  $ optimal generate-newsletter --brand CRE-11TRUST Generate a newsletter
+  $ optimal audit-financials --months 2025-01        Audit a single month
+  $ optimal export-kpis --format csv > kpis.csv      Export KPIs as CSV
+  $ optimal deploy dashboard --prod                  Deploy to production
+  $ optimal bot agents                              List active bot agents
+  $ optimal config doctor                           Validate local config
+`);
+// --- Board commands ---
+const board = program.command('board').description('Kanban board operations')
+    .addHelpText('after', `
+Examples:
+  $ optimal board view                        Show full board
+  $ optimal board view -p cli-consolidation   Filter by project
+  $ optimal board view -s ready --mine bot1   Show bot1's ready tasks
+  $ optimal board create -t "Fix bug" -p cli-consolidation
+  $ optimal board claim --id <uuid> --agent bot1
+  $ optimal board log --actor bot1 --limit 5
+`);
 board
     .command('view')
     .description('Display the kanban board')
-    .option('-p, --project <slug>', 'Project slug', 'optimal-cli-refactor')
+    .option('-p, --project <slug>', 'Project slug')
     .option('-s, --status <status>', 'Filter by status')
+    .option('--mine <agent>', 'Show only tasks claimed by agent')
     .action(async (opts) => {
-    let tasks = await getBoard(opts.project);
-    if (opts.status)
-        tasks = tasks.filter(t => t.status === opts.status);
-    const grouped = new Map();
-    for (const t of tasks) {
-        const list = grouped.get(t.status) ?? [];
-        list.push(t);
-        grouped.set(t.status, list);
-    }
-    const order = ['in_progress', 'blocked', 'ready', 'backlog', 'review', 'done'];
-    console.log('| Status | P | Title | Agent | Skill |');
-    console.log('|--------|---|-------|-------|-------|');
-    for (const status of order) {
-        const list = grouped.get(status) ?? [];
-        for (const t of list) {
-            console.log(`| ${t.status} | ${t.priority} | ${t.title} | ${t.assigned_agent ?? '—'} | ${t.skill_ref ?? '—'} |`);
-        }
+    const filters = {};
+    if (opts.project) {
+        const proj = await getProjectBySlug(opts.project);
+        filters.project_id = proj.id;
     }
-    console.log(`\nTotal: ${tasks.length} tasks`);
+    if (opts.status)
+        filters.status = opts.status;
+    if (opts.mine)
+        filters.claimed_by = opts.mine;
+    const tasks = await listTasks(filters);
+    console.log(formatBoardTable(tasks));
 });
 board
     .command('create')
     .description('Create a new task')
+    .addHelpText('after', `
+Example:
+  $ optimal board create -t "Migrate auth" -p cli-consolidation --priority 1 --labels infra,migration
+`)
     .requiredOption('-t, --title <title>', 'Task title')
-    .option('-p, --project <slug>', 'Project slug', 'optimal-cli-refactor')
+    .requiredOption('-p, --project <slug>', 'Project slug')
     .option('-d, --description <desc>', 'Task description')
     .option('--priority <n>', 'Priority 1-4', '3')
     .option('--skill <ref>', 'Skill reference')
+    .option('--source <repo>', 'Source repo')
+    .option('--target <module>', 'Target module')
+    .option('--effort <size>', 'Effort: xs, s, m, l, xl')
+    .option('--blocked-by <ids>', 'Comma-separated blocking task IDs')
     .option('--labels <labels>', 'Comma-separated labels')
     .action(async (opts) => {
+    const project = await getProjectBySlug(opts.project);
     const task = await createTask({
-        project_slug: opts.project,
+        project_id: project.id,
         title: opts.title,
         description: opts.description,
         priority: parseInt(opts.priority),
-        skill_ref: opts.skill,
-        labels: opts.labels?.split(',').map((l) => l.trim()),
+        skill_required: opts.skill,
+        source_repo: opts.source,
+        target_module: opts.target,
+        estimated_effort: opts.effort,
+        blocked_by: opts.blockedBy?.split(',') ?? [],
+        labels: opts.labels?.split(',') ?? [],
     });
-    console.log(`Created task: ${task.id} — "${task.title}" (priority ${task.priority}, status ${task.status})`);
+    success(`Created task: ${colorize(task.id, 'dim')}\n  ${task.title} [${statusBadge(task.status)}] ${priorityBadge(task.priority)}`);
 });
 board
     .command('update')
     .description('Update a task')
-    .requiredOption('--id <taskId>', 'Task UUID')
+    .requiredOption('--id <uuid>', 'Task ID')
     .option('-s, --status <status>', 'New status')
     .option('-a, --agent <name>', 'Assign to agent')
     .option('--priority <n>', 'New priority')
-    .option('-m, --message <msg>', 'Log message')
+    .option('-m, --message <msg>', 'Log message (adds comment)')
     .action(async (opts) => {
     const updates = {};
     if (opts.status)
         updates.status = opts.status;
     if (opts.agent)
-        updates.assigned_agent = opts.agent;
+        updates.assigned_to = opts.agent;
     if (opts.priority)
         updates.priority = parseInt(opts.priority);
-    const task = await updateTask(opts.id, updates);
-    if (opts.message) {
-        await logActivity(opts.id, {
-            agent: opts.agent ?? 'cli',
-            action: 'status_change',
-            message: opts.message,
-        });
+    if (opts.status === 'done')
+        updates.completed_at = new Date().toISOString();
+    const task = await updateTask(opts.id, updates, opts.agent ?? 'cli');
+    if (opts.message)
+        await addComment({ task_id: task.id, author: opts.agent ?? 'cli', body: opts.message });
+    success(`Updated: ${task.title} -> ${statusBadge(task.status)}`);
+});
+board
+    .command('claim')
+    .description('Claim a task (bot pull model)')
+    .requiredOption('--id <uuid>', 'Task ID')
+    .requiredOption('--agent <name>', 'Agent name')
+    .action(async (opts) => {
+    const task = await claimTask(opts.id, opts.agent);
+    success(`Claimed: ${colorize(task.title, 'cyan')} by ${colorize(opts.agent, 'bold')}`);
+});
+board
+    .command('comment')
+    .description('Add a comment to a task')
+    .requiredOption('--id <uuid>', 'Task ID')
+    .requiredOption('--author <name>', 'Author name')
+    .requiredOption('--body <text>', 'Comment body')
+    .action(async (opts) => {
+    const comment = await addComment({ task_id: opts.id, author: opts.author, body: opts.body });
+    success(`Comment added by ${colorize(comment.author, 'bold')} at ${colorize(comment.created_at, 'dim')}`);
+});
+board
+    .command('log')
+    .description('View activity log')
+    .option('--task <uuid>', 'Filter by task ID')
+    .option('--actor <name>', 'Filter by actor')
+    .option('--limit <n>', 'Max entries', '20')
+    .action(async (opts) => {
+    const entries = await listActivity({
+        task_id: opts.task,
+        actor: opts.actor,
+        limit: parseInt(opts.limit),
+    });
+    for (const e of entries) {
+        console.log(`${e.created_at} | ${e.actor.padEnd(8)} | ${e.action.padEnd(15)} | ${JSON.stringify(e.new_value ?? {})}`);
+    }
+    console.log(`\n${entries.length} entries`);
+});
+// --- Project commands ---
+const proj = program.command('project').description('Project management')
+    .addHelpText('after', `
+Examples:
+  $ optimal project list
+  $ optimal project create --slug my-proj --name "My Project" --priority 1
+  $ optimal project update --slug my-proj -s active
+`);
+proj
+    .command('list')
+    .description('List all projects')
+    .action(async () => {
+    const projects = await listProjects();
+    console.log('| Status   | P | Slug                    | Owner   | Name |');
+    console.log('|----------|---|-------------------------|---------|------|');
+    for (const p of projects) {
+        console.log(`| ${p.status.padEnd(8)} | ${p.priority} | ${p.slug.padEnd(23)} | ${(p.owner ?? '—').padEnd(7)} | ${p.name} |`);
+    }
+});
+proj
+    .command('create')
+    .description('Create a project')
+    .requiredOption('--slug <slug>', 'Project slug')
+    .requiredOption('--name <name>', 'Project name')
+    .option('--owner <name>', 'Owner')
+    .option('--priority <n>', 'Priority 1-4', '3')
+    .action(async (opts) => {
+    const p = await createProject({
+        slug: opts.slug,
+        name: opts.name,
+        owner: opts.owner,
+        priority: parseInt(opts.priority),
+    });
+    success(`Created project: ${colorize(p.slug, 'cyan')} (${colorize(p.id, 'dim')})`);
+});
+proj
+    .command('update')
+    .description('Update a project')
+    .requiredOption('--slug <slug>', 'Project slug')
+    .option('-s, --status <status>', 'New status')
+    .option('--owner <name>', 'New owner')
+    .action(async (opts) => {
+    const updates = {};
+    if (opts.status)
+        updates.status = opts.status;
+    if (opts.owner)
+        updates.owner = opts.owner;
+    const p = await updateProject(opts.slug, updates);
+    success(`Updated project: ${colorize(p.slug, 'cyan')} -> ${statusBadge(p.status)}`);
+});
+// --- Milestone commands ---
+const ms = program.command('milestone').description('Milestone management')
+    .addHelpText('after', `
+Examples:
+  $ optimal milestone list --project cli-consolidation
+  $ optimal milestone create --project cli-consolidation --name "v1.0" --due 2026-04-01
+`);
+ms
+    .command('create')
+    .description('Create a milestone')
+    .requiredOption('--project <slug>', 'Project slug')
+    .requiredOption('--name <name>', 'Milestone name')
+    .option('--due <date>', 'Due date (YYYY-MM-DD)')
+    .action(async (opts) => {
+    const project = await getProjectBySlug(opts.project);
+    const m = await createMilestone({ project_id: project.id, name: opts.name, due_date: opts.due });
+    success(`Created milestone: ${colorize(m.name, 'cyan')} (${colorize(m.id, 'dim')})`);
+});
+ms
+    .command('list')
+    .description('List milestones')
+    .option('--project <slug>', 'Filter by project')
+    .action(async (opts) => {
+    let projectId;
+    if (opts.project) {
+        const p = await getProjectBySlug(opts.project);
+        projectId = p.id;
+    }
+    const milestones = await listMilestones(projectId);
+    for (const m of milestones) {
+        console.log(`${m.status.padEnd(10)} | ${m.due_date ?? 'no date'} | ${m.name}`);
     }
-    console.log(`Updated task ${task.id}: status → ${task.status}, agent → ${task.assigned_agent ?? '—'}`);
+});
+// --- Label commands ---
+const lbl = program.command('label').description('Label management');
+lbl
+    .command('create')
+    .description('Create a label')
+    .requiredOption('--name <name>', 'Label name')
+    .option('--color <hex>', 'Color hex code')
+    .action(async (opts) => {
+    const l = await createLabel(opts.name, opts.color);
+    success(`Created label: ${colorize(l.name, 'cyan')} (${colorize(l.id, 'dim')})`);
+});
+lbl
+    .command('list')
+    .description('List all labels')
+    .action(async () => {
+    const labels = await listLabels();
+    for (const l of labels)
+        console.log(`${l.name}${l.color ? ` (${l.color})` : ''}`);
 });
 // Audit financials command
 program
@@ -186,14 +357,14 @@ program
     .argument('<app>', `App to deploy (${listApps().join(', ')})`)
     .option('--prod', 'Deploy to production', false)
     .action(async (app, opts) => {
-    console.log(`Deploying ${app}${opts.prod ? ' (production)' : ' (preview)'}...`);
+    fmtInfo(`Deploying ${colorize(app, 'cyan')}${opts.prod ? colorize(' (production)', 'yellow') : ' (preview)'}...`);
     try {
         const url = await deploy(app, opts.prod);
-        console.log(`Deployed: ${url}`);
+        success(`Deployed: ${colorize(url, 'green')}`);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        console.error(`Deploy failed: ${msg}`);
+        fmtError(`Deploy failed: ${msg}`);
         process.exit(1);
     }
 });
@@ -298,12 +469,12 @@ program
             dryRun: opts.dryRun,
         });
         if (result.strapiDocumentId) {
-            console.log(`\nStrapi documentId: ${result.strapiDocumentId}`);
+            success(`Strapi documentId: ${colorize(result.strapiDocumentId, 'cyan')}`);
         }
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        console.error(`Newsletter generation failed: ${msg}`);
+        fmtError(`Newsletter generation failed: ${msg}`);
         process.exit(1);
     }
 });
@@ -676,6 +847,71 @@ program
     }
     console.log(`\n${queue.length} posts queued`);
 });
+// ── Publish to Instagram via Meta Graph API ─────────────────────────
+program
+    .command('publish-instagram')
+    .description('Publish pending social posts to Instagram via Meta Graph API')
+    .requiredOption('--brand <brand>', 'Brand: CRE-11TRUST or LIFEINSUR')
+    .option('--limit <n>', 'Max posts to publish')
+    .option('--dry-run', 'Preview without publishing', false)
+    .action(async (opts) => {
+    try {
+        const config = getMetaConfigForBrand(opts.brand);
+        // Fetch pending instagram posts from Strapi
+        const result = await strapiGet('/api/social-posts', {
+            'filters[brand][$eq]': opts.brand,
+            'filters[delivery_status][$eq]': 'pending',
+            'filters[platform][$eq]': 'instagram',
+            'sort': 'scheduled_date:asc',
+            'pagination[pageSize]': opts.limit ?? '50',
+        });
+        const posts = result.data;
+        if (posts.length === 0) {
+            console.log('No pending Instagram posts found');
+            return;
+        }
+        console.log(`Found ${posts.length} pending Instagram post(s) for ${opts.brand}`);
+        let published = 0;
+        let failed = 0;
+        for (const post of posts) {
+            const headline = post.headline ?? '(no headline)';
+            const imageUrl = post.image_url;
+            const caption = (post.body ?? post.headline ?? '').trim();
+            if (!imageUrl) {
+                console.log(`  SKIP | ${headline} — no image_url`);
+                failed++;
+                continue;
+            }
+            if (opts.dryRun) {
+                console.log(`  DRY  | ${headline}`);
+                continue;
+            }
+            try {
+                const igResult = await publishIgPhoto(config, { imageUrl, caption });
+                await strapiPut('/api/social-posts', post.documentId, {
+                    delivery_status: 'delivered',
+                    platform_post_id: igResult.mediaId,
+                });
+                console.log(`  OK   | ${headline} → ${igResult.mediaId}`);
+                published++;
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                await strapiPut('/api/social-posts', post.documentId, {
+                    delivery_status: 'failed',
+                    delivery_errors: [{ timestamp: new Date().toISOString(), error: errMsg }],
+                }).catch(() => { });
+                console.log(`  FAIL | ${headline} — ${errMsg}`);
+                failed++;
+            }
+        }
+        console.log(`\nPublished: ${published} | Failed: ${failed}${opts.dryRun ? ' | (dry run)' : ''}`);
+    }
+    catch (err) {
+        console.error(`Instagram publish failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+});
 // ── Publish blog ────────────────────────────────────────────────────
 program
     .command('publish-blog')
@@ -712,7 +948,13 @@ program
     }
 });
 // ── Database migration ──────────────────────────────────────────────
-const migrate = program.command('migrate').description('Supabase database migration operations');
+const migrate = program.command('migrate').description('Supabase database migration operations')
+    .addHelpText('after', `
+Examples:
+  $ optimal migrate pending --target optimalos
+  $ optimal migrate push --target returnpro --dry-run
+  $ optimal migrate create --target optimalos --name "add-index"
+`);
 migrate
     .command('push')
     .description('Run supabase db push --linked on a target project')
@@ -758,7 +1000,14 @@ migrate
     console.log(`Created: ${path}`);
 });
 // ── Budget scenarios ────────────────────────────────────────────────
-const scenario = program.command('scenario').description('Budget scenario management');
+const scenario = program.command('scenario').description('Budget scenario management')
+    .addHelpText('after', `
+Examples:
+  $ optimal scenario list
+  $ optimal scenario save --name "4pct-growth" --adjustment-type percentage --adjustment-value 4
+  $ optimal scenario compare --names "baseline,4pct-growth"
+  $ optimal scenario delete --name "old-scenario"
+`);
 scenario
     .command('save')
     .description('Save current projections as a named scenario')
@@ -893,103 +1142,449 @@ program
         console.log(`Deleted ${result.deletedCount} rows from ${table}`);
     }
 });
-// ── Config commands ─────────────────────────────────────────────────
-const config = program.command('config').description('OpenClaw config sync operations');
+// ── Config registry (v1 scaffold) ─────────────────────────────────
+const config = program.command('config').description('Manage optimal-cli local/shared config profile')
+    .addHelpText('after', `
+Examples:
+  $ optimal config init --owner oracle --brand CRE-11TRUST
+  $ optimal config doctor
+  $ optimal config export --out ./backup.json
+  $ optimal config import --in ./backup.json
+  $ optimal config sync pull
+  $ optimal config sync push --agent bot1
+`);
 config
-    .command('push')
-    .description('Push local openclaw.json to cloud storage')
-    .requiredOption('--agent <name>', 'Agent name (e.g., oracle, opal, kimklaw)')
+    .command('init')
+    .description('Create a local config scaffold (overwrites with --force)')
+    .option('--owner <owner>', 'Config owner (default: $OPTIMAL_CONFIG_OWNER or $USER)')
+    .option('--profile <name>', 'Profile name', 'default')
+    .option('--brand <brand>', 'Default brand', 'CRE-11TRUST')
+    .option('--timezone <tz>', 'Default timezone', 'America/New_York')
+    .option('--force', 'Overwrite existing config', false)
     .action(async (opts) => {
     try {
-        const result = await pushConfig(opts.agent);
-        console.log(`✓ Config pushed for ${opts.agent}`);
-        console.log(`  ID: ${result.id}`);
-        console.log(`  Version: ${result.version}`);
+        const existing = await readLocalConfig();
+        if (existing && !opts.force) {
+            console.error(`Config already exists at ${getLocalConfigPath()} (use --force to overwrite)`);
+            process.exit(1);
+        }
+        const owner = opts.owner || process.env.OPTIMAL_CONFIG_OWNER || process.env.USER || 'oracle';
+        const payload = {
+            version: '1.0.0',
+            profile: {
+                name: opts.profile,
+                owner,
+                updated_at: new Date().toISOString(),
+            },
+            providers: {
+                supabase: {
+                    project_ref: process.env.OPTIMAL_SUPABASE_PROJECT_REF || 'unset',
+                    url: process.env.OPTIMAL_SUPABASE_URL || 'unset',
+                    anon_key_present: Boolean(process.env.OPTIMAL_SUPABASE_ANON_KEY),
+                },
+                strapi: {
+                    base_url: process.env.STRAPI_BASE_URL || 'unset',
+                    token_present: Boolean(process.env.STRAPI_TOKEN),
+                },
+            },
+            defaults: {
+                brand: opts.brand,
+                timezone: opts.timezone,
+            },
+            features: {
+                cms: true,
+                tasks: true,
+                deploy: true,
+            },
+        };
+        await writeLocalConfig(payload);
+        await appendHistory(`${new Date().toISOString()} init profile=${opts.profile} owner=${owner} hash=${hashConfig(payload)}`);
+        console.log(`Initialized config at ${getLocalConfigPath()}`);
     }
     catch (err) {
-        console.error(`Push failed: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`Config init failed: ${err instanceof Error ? err.message : String(err)}`);
         process.exit(1);
     }
 });
 config
-    .command('pull')
-    .description('Pull config from cloud and save to local openclaw.json')
-    .requiredOption('--agent <name>', 'Agent name to pull config for')
-    .action(async (opts) => {
+    .command('doctor')
+    .description('Validate local config file and print health details')
+    .action(async () => {
     try {
-        const result = await pullConfig(opts.agent);
-        console.log(`✓ Config pulled for ${result.agent_name}`);
-        console.log(`  Version: ${result.version}`);
-        console.log(`  Updated: ${result.updated_at}`);
-        console.log(`\nSaved to: ~/.openclaw/openclaw.json`);
+        const cfg = await readLocalConfig();
+        if (!cfg) {
+            console.log(`No local config found at ${getLocalConfigPath()}`);
+            process.exit(1);
+        }
+        const digest = hashConfig(cfg);
+        console.log(`config: ok`);
+        console.log(`path: ${getLocalConfigPath()}`);
+        console.log(`profile: ${cfg.profile.name}`);
+        console.log(`owner: ${cfg.profile.owner}`);
+        console.log(`version: ${cfg.version}`);
+        console.log(`hash: ${digest}`);
+        console.log(`history: ${getHistoryPath()}`);
     }
     catch (err) {
-        console.error(`Pull failed: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`Config doctor failed: ${err instanceof Error ? err.message : String(err)}`);
         process.exit(1);
     }
 });
 config
-    .command('list')
-    .description('List all saved agent configs in cloud')
-    .action(async () => {
+    .command('export')
+    .description('Export local config to a JSON path')
+    .requiredOption('--out <path>', 'Output path for JSON export')
+    .action(async (opts) => {
     try {
-        const configs = await listConfigs();
-        if (configs.length === 0) {
-            console.log('No configs found in cloud storage');
-            return;
-        }
-        console.log('| Agent | Version | Updated |');
-        console.log('|-------|---------|---------|');
-        for (const c of configs) {
-            console.log(`| ${c.agent_name} | ${c.version.slice(0, 19)} | ${c.updated_at.slice(0, 19)} |`);
+        const cfg = await readLocalConfig();
+        if (!cfg) {
+            console.error(`No local config found at ${getLocalConfigPath()}`);
+            process.exit(1);
         }
-        console.log(`\nTotal: ${configs.length} configs`);
+        const payload = {
+            ...cfg,
+            profile: {
+                ...cfg.profile,
+                updated_at: new Date().toISOString(),
+            },
+        };
+        const json = `${JSON.stringify(payload, null, 2)}\n`;
+        writeFileSync(opts.out, json, 'utf-8');
+        await appendHistory(`${new Date().toISOString()} export out=${opts.out} hash=${hashConfig(payload)}`);
+        console.log(`Exported config to ${opts.out}`);
     }
     catch (err) {
-        console.error(`List failed: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`Config export failed: ${err instanceof Error ? err.message : String(err)}`);
         process.exit(1);
     }
 });
 config
-    .command('diff')
-    .description('Compare local config with cloud version')
-    .requiredOption('--agent <name>', 'Agent name to compare')
+    .command('import')
+    .description('Import local config from a JSON path')
+    .requiredOption('--in <path>', 'Input path for JSON config')
     .action(async (opts) => {
     try {
-        const { local, cloud, differences } = await diffConfig(opts.agent);
-        if (differences.length === 0) {
-            console.log('✓ Local and cloud configs are in sync');
-            return;
-        }
-        console.log('Differences found:');
-        for (const d of differences) {
-            console.log(`  • ${d}`);
-        }
-        if (local?.meta?.lastTouchedAt) {
-            console.log(`\nLocal updated: ${local.meta.lastTouchedAt}`);
-        }
-        if (cloud?.updated_at) {
-            console.log(`Cloud updated: ${cloud.updated_at}`);
+        if (!existsSync(opts.in)) {
+            console.error(`Input file not found: ${opts.in}`);
+            process.exit(1);
         }
+        const raw = readFileSync(opts.in, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const payload = assertOptimalConfigV1(parsed);
+        await writeLocalConfig(payload);
+        await appendHistory(`${new Date().toISOString()} import in=${opts.in} hash=${hashConfig(payload)}`);
+        console.log(`Imported config from ${opts.in}`);
     }
     catch (err) {
-        console.error(`Diff failed: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`Config import failed: ${err instanceof Error ? err.message : String(err)}`);
         process.exit(1);
     }
 });
-config
-    .command('sync')
-    .description('Two-way sync: push if local is newer, pull if cloud is newer')
-    .requiredOption('--agent <name>', 'Agent name to sync')
+const configSync = config.command('sync').description('Sync local profile with shared registry (scaffold)');
+configSync
+    .command('pull')
+    .description('Pull config profile from shared registry into local config')
+    .option('--profile <name>', 'Registry profile name', 'default')
     .action(async (opts) => {
-    try {
-        const result = await syncConfig(opts.agent);
-        console.log(`✓ ${result.action}`);
-        console.log(`  ${result.message}`);
+    const result = await pullRegistryProfile(opts.profile);
+    const stamp = new Date().toISOString();
+    await appendHistory(`${stamp} sync.pull profile=${opts.profile} ok=${result.ok} msg=${result.message}`);
+    if (!result.ok) {
+        console.error(result.message);
+        process.exit(1);
     }
-    catch (err) {
-        console.error(`Sync failed: ${err instanceof Error ? err.message : String(err)}`);
+    console.log(result.message);
+});
+configSync
+    .command('push')
+    .description('Push local config profile to shared registry')
+    .requiredOption('--agent <name>', 'Agent/owner name for the config profile')
+    .option('--profile <name>', 'Registry profile name', 'default')
+    .option('--force', 'Force write even on conflict', false)
+    .action(async (opts) => {
+    const result = await pushRegistryProfile(opts.profile, Boolean(opts.force), opts.agent);
+    const stamp = new Date().toISOString();
+    await appendHistory(`${stamp} sync.push agent=${opts.agent} profile=${opts.profile} force=${Boolean(opts.force)} ok=${result.ok} msg=${result.message}`);
+    if (!result.ok) {
+        console.error(result.message);
         process.exit(1);
     }
+    console.log(result.message);
+});
+// --- Bot commands ---
+const bot = program.command('bot').description('Bot agent orchestration')
+    .addHelpText('after', `
+Examples:
+  $ optimal bot agents                           List active agents
+  $ optimal bot heartbeat --agent bot1            Send heartbeat
+  $ optimal bot claim --agent bot1                Claim next task
+  $ optimal bot report --task <id> --agent bot1 --message "50% done"
+  $ optimal bot complete --task <id> --agent bot1 --summary "All tests pass"
+`);
+bot
+    .command('heartbeat')
+    .description('Send agent heartbeat')
+    .requiredOption('--agent <id>', 'Agent ID')
+    .option('--status <s>', 'Status: idle, working, error', 'idle')
+    .action(async (opts) => {
+    await sendHeartbeat(opts.agent, opts.status);
+    success(`Heartbeat sent: ${colorize(opts.agent, 'bold')} [${colorize(opts.status, 'cyan')}]`);
+});
+bot
+    .command('agents')
+    .description('List active agents (heartbeat in last 5 min)')
+    .action(async () => {
+    const agents = await getActiveAgents();
+    if (agents.length === 0) {
+        console.log('No active agents.');
+        return;
+    }
+    console.log('| Agent            | Status  | Last Seen           |');
+    console.log('|------------------|---------|---------------------|');
+    for (const a of agents) {
+        console.log(`| ${a.agent.padEnd(16)} | ${a.status.padEnd(7)} | ${a.lastSeen} |`);
+    }
+});
+bot
+    .command('claim')
+    .description('Claim the next available task')
+    .requiredOption('--agent <id>', 'Agent ID')
+    .option('--skill <s>', 'Skill filter (comma-separated)')
+    .action(async (opts) => {
+    const skills = opts.skill ? opts.skill.split(',') : undefined;
+    const task = await claimNextTask(opts.agent, skills);
+    if (!task) {
+        console.log('No claimable tasks found.');
+        return;
+    }
+    success(`Claimed: ${colorize(task.title, 'cyan')} (${colorize(task.id, 'dim')}) by ${colorize(opts.agent, 'bold')}`);
+});
+bot
+    .command('report')
+    .description('Report progress on a task')
+    .requiredOption('--task <id>', 'Task ID')
+    .requiredOption('--agent <id>', 'Agent ID')
+    .requiredOption('--message <msg>', 'Progress message')
+    .action(async (opts) => {
+    await reportProgress(opts.task, opts.agent, opts.message);
+    success(`Progress reported on ${colorize(opts.task, 'dim')}`);
+});
+bot
+    .command('complete')
+    .description('Mark a task as done')
+    .requiredOption('--task <id>', 'Task ID')
+    .requiredOption('--agent <id>', 'Agent ID')
+    .requiredOption('--summary <s>', 'Completion summary')
+    .action(async (opts) => {
+    await reportCompletion(opts.task, opts.agent, opts.summary);
+    success(`Task ${colorize(opts.task, 'dim')} marked ${statusBadge('done')} by ${colorize(opts.agent, 'bold')}`);
+});
+bot
+    .command('release')
+    .description('Release a claimed task back to ready')
+    .requiredOption('--task <id>', 'Task ID')
+    .requiredOption('--agent <id>', 'Agent ID')
+    .option('--reason <r>', 'Release reason')
+    .action(async (opts) => {
+    await releaseTask(opts.task, opts.agent, opts.reason);
+    fmtInfo(`Task ${colorize(opts.task, 'dim')} released by ${colorize(opts.agent, 'bold')}`);
+});
+bot
+    .command('blocked')
+    .description('Mark a task as blocked')
+    .requiredOption('--task <id>', 'Task ID')
+    .requiredOption('--agent <id>', 'Agent ID')
+    .requiredOption('--reason <r>', 'Block reason')
+    .action(async (opts) => {
+    await reportBlocked(opts.task, opts.agent, opts.reason);
+    fmtWarn(`Task ${colorize(opts.task, 'dim')} marked ${statusBadge('blocked')}: ${opts.reason}`);
+});
+// --- Coordinator commands ---
+const coordinator = program.command('coordinator').description('Multi-agent coordination')
+    .addHelpText('after', `
+Examples:
+  $ optimal coordinator start                        Run coordinator loop
+  $ optimal coordinator start --interval 10000       Poll every 10s
+  $ optimal coordinator status                       Show coordinator status
+  $ optimal coordinator assign --task <id> --agent bot1
+  $ optimal coordinator rebalance                    Release stale tasks
+`);
+coordinator
+    .command('start')
+    .description('Run the coordinator loop')
+    .option('--interval <ms>', 'Poll interval in milliseconds', '30000')
+    .option('--max-agents <n>', 'Maximum agents to manage', '10')
+    .action(async (opts) => {
+    await runCoordinatorLoop({
+        pollIntervalMs: parseInt(opts.interval),
+        maxAgents: parseInt(opts.maxAgents),
+    });
+});
+coordinator
+    .command('status')
+    .description('Show coordinator status')
+    .action(async () => {
+    const s = await getCoordinatorStatus();
+    console.log(`Last poll: ${s.lastPollAt ?? 'never'}`);
+    console.log(`Tasks — ready: ${s.tasksReady}, in progress: ${s.tasksInProgress}, blocked: ${s.tasksBlocked}`);
+    console.log(`\nActive agents (${s.activeAgents.length}):`);
+    for (const a of s.activeAgents) {
+        console.log(`  ${a.agent.padEnd(16)} ${a.status.padEnd(8)} last seen ${a.lastSeen}`);
+    }
+    console.log(`\nIdle agents (${s.idleAgents.length}):`);
+    for (const a of s.idleAgents) {
+        console.log(`  ${a.id.padEnd(16)} skills: ${a.skills.join(', ')}`);
+    }
+});
+coordinator
+    .command('assign')
+    .description('Manually assign a task to an agent')
+    .requiredOption('--task <id>', 'Task ID')
+    .requiredOption('--agent <id>', 'Agent ID')
+    .action(async (opts) => {
+    const task = await assignTask(opts.task, opts.agent);
+    success(`Assigned: ${colorize(task.title, 'cyan')} -> ${colorize(opts.agent, 'bold')}`);
+});
+coordinator
+    .command('rebalance')
+    .description('Release stale tasks and rebalance')
+    .action(async () => {
+    const result = await rebalance();
+    if (result.releasedTasks.length === 0) {
+        fmtInfo('No stale tasks found.');
+        return;
+    }
+    console.log(`Released ${result.releasedTasks.length} stale task(s):`);
+    for (const t of result.releasedTasks) {
+        console.log(`  ${colorize(t.id, 'dim')} ${t.title}`);
+    }
+    if (result.reassignedTasks.length > 0) {
+        console.log(`Reassigned ${result.reassignedTasks.length} task(s):`);
+        for (const t of result.reassignedTasks) {
+            console.log(`  ${colorize(t.id, 'dim')} ${t.title} -> ${t.claimed_by}`);
+        }
+    }
+});
+// --- Asset commands ---
+const asset = program.command('asset').description('Digital asset tracking (domains, servers, API keys, services, repos)')
+    .addHelpText('after', `
+Examples:
+  $ optimal asset list                                 List all assets
+  $ optimal asset list --type domain --status active   Filter by type/status
+  $ optimal asset add --name "op-hub.com" --type domain --owner clenisa
+  $ optimal asset update --id <uuid> --status inactive
+  $ optimal asset usage --id <uuid>                    View usage log
+`);
+asset
+    .command('list')
+    .description('List tracked assets')
+    .option('-t, --type <type>', 'Filter by type (domain, server, api_key, service, repo, other)')
+    .option('-s, --status <status>', 'Filter by status (active, inactive, expired, pending)')
+    .option('-o, --owner <owner>', 'Filter by owner')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const assets = await listAssets({
+        type: opts.type,
+        status: opts.status,
+        owner: opts.owner,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(assets, null, 2));
+    }
+    else {
+        console.log(formatAssetTable(assets));
+    }
+});
+asset
+    .command('add')
+    .description('Add a new asset')
+    .requiredOption('-n, --name <name>', 'Asset name')
+    .requiredOption('-t, --type <type>', 'Asset type (domain, server, api_key, service, repo, other)')
+    .option('-s, --status <status>', 'Status (default: active)')
+    .option('-o, --owner <owner>', 'Owner')
+    .option('--expires <date>', 'Expiration date (YYYY-MM-DD or ISO)')
+    .option('--meta <json>', 'Metadata JSON string')
+    .action(async (opts) => {
+    const metadata = opts.meta ? JSON.parse(opts.meta) : undefined;
+    const created = await createAsset({
+        name: opts.name,
+        type: opts.type,
+        status: opts.status,
+        owner: opts.owner,
+        expires_at: opts.expires,
+        metadata,
+    });
+    success(`Created asset: ${colorize(created.name, 'cyan')} [${created.type}] (${colorize(created.id, 'dim')})`);
+});
+asset
+    .command('update')
+    .description('Update an existing asset')
+    .requiredOption('--id <uuid>', 'Asset ID')
+    .option('-n, --name <name>', 'New name')
+    .option('-t, --type <type>', 'New type')
+    .option('-s, --status <status>', 'New status')
+    .option('-o, --owner <owner>', 'New owner')
+    .option('--expires <date>', 'New expiration date')
+    .option('--meta <json>', 'New metadata JSON')
+    .action(async (opts) => {
+    const updates = {};
+    if (opts.name)
+        updates.name = opts.name;
+    if (opts.type)
+        updates.type = opts.type;
+    if (opts.status)
+        updates.status = opts.status;
+    if (opts.owner)
+        updates.owner = opts.owner;
+    if (opts.expires)
+        updates.expires_at = opts.expires;
+    if (opts.meta)
+        updates.metadata = JSON.parse(opts.meta);
+    const updated = await updateAsset(opts.id, updates);
+    success(`Updated: ${colorize(updated.name, 'cyan')} -> status=${colorize(updated.status, 'bold')}`);
+});
+asset
+    .command('get')
+    .description('Get a single asset by ID')
+    .requiredOption('--id <uuid>', 'Asset ID')
+    .action(async (opts) => {
+    const a = await getAsset(opts.id);
+    console.log(JSON.stringify(a, null, 2));
+});
+asset
+    .command('remove')
+    .description('Delete an asset')
+    .requiredOption('--id <uuid>', 'Asset ID')
+    .action(async (opts) => {
+    await deleteAsset(opts.id);
+    success(`Deleted asset ${colorize(opts.id, 'dim')}`);
+});
+asset
+    .command('track')
+    .description('Log a usage event for an asset')
+    .requiredOption('--id <uuid>', 'Asset ID')
+    .requiredOption('-e, --event <event>', 'Event name (e.g. "renewed", "deployed", "rotated")')
+    .option('--actor <name>', 'Who performed the action')
+    .option('--meta <json>', 'Event metadata JSON')
+    .action(async (opts) => {
+    const metadata = opts.meta ? JSON.parse(opts.meta) : undefined;
+    const entry = await trackAssetUsage(opts.id, opts.event, opts.actor, metadata);
+    success(`Tracked: ${colorize(opts.event, 'cyan')} on ${colorize(opts.id, 'dim')} at ${colorize(entry.created_at, 'dim')}`);
+});
+asset
+    .command('usage')
+    .description('View usage log for an asset')
+    .requiredOption('--id <uuid>', 'Asset ID')
+    .option('--limit <n>', 'Max entries', '20')
+    .action(async (opts) => {
+    const events = await listAssetUsage(opts.id, parseInt(opts.limit));
+    if (events.length === 0) {
+        console.log('No usage events found.');
+        return;
+    }
+    for (const e of events) {
+        console.log(`${e.created_at} | ${(e.actor ?? '-').padEnd(10)} | ${e.event} ${Object.keys(e.metadata).length > 0 ? JSON.stringify(e.metadata) : ''}`);
+    }
+    console.log(`\n${events.length} events`);
 });
 program.parseAsync();