optimal-cli 1.0.0 → 1.1.0

package/bin/optimal.ts

@@ -2,15 +2,20 @@
 import { Command } from 'commander'
 import 'dotenv/config'
 import {
-  createProject, getProjectBySlug, listProjects, updateProject,
-  createMilestone, listMilestones,
-  createLabel, listLabels,
-  createTask, updateTask, getTask, listTasks, claimTask, completeTask,
-  addComment, listComments,
-  logActivity, listActivity,
-  formatBoardTable, getNextClaimable,
-  type Task, type TaskStatus,
-} from '../lib/board/index.js'
+  getBoard,
+  createTask,
+  updateTask,
+  logActivity,
+  type Task,
+} from '../lib/kanban.js'
+import {
+  getBoardByProject,
+  createTask as createObsidianTask,
+  updateTaskStatus as updateObsidianTaskStatus,
+  loadAllTasks,
+  type BoardColumn,
+  type ObsidianTask,
+} from '../lib/kanban-obsidian.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'
@@ -38,8 +43,6 @@ 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, createBlogPost, listBlogDrafts } from '../lib/cms/publish-blog.js'
-import { publishIgPhoto, getMetaConfigForBrand } from '../lib/social/meta.js'
-import { strapiGet, strapiPut, type StrapiPage } from '../lib/cms/strapi-client.js'
 import { migrateDb, listPendingMigrations, createMigration } from '../lib/infra/migrate.js'
 import { saveScenario, loadScenario, listScenarios, compareScenarios, deleteScenario } from '../lib/budget/scenarios.js'
 import { deleteBatch, previewBatch } from '../lib/transactions/delete-batch.js'
@@ -54,271 +57,318 @@ import {
   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, table as fmtTable, 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,
-  type AssetType, type AssetStatus,
-} 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')
-  .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 commands (supabase-backed)
+const board = program.command('board').description('Kanban board operations (supabase)')
 
 board
   .command('view')
   .description('Display the kanban board')
-  .option('-p, --project <slug>', 'Project slug')
+  .option('-p, --project <slug>', 'Project slug', 'optimal-cli')
   .option('-s, --status <status>', 'Filter by status')
-  .option('--mine <agent>', 'Show only tasks claimed by agent')
   .action(async (opts) => {
-    const filters: { project_id?: string; status?: TaskStatus; claimed_by?: string } = {}
-    if (opts.project) {
-      const proj = await getProjectBySlug(opts.project)
-      filters.project_id = proj.id
-    }
-    if (opts.status) filters.status = opts.status as TaskStatus
-    if (opts.mine) filters.claimed_by = opts.mine
-    const tasks = await listTasks(filters)
-    console.log(formatBoardTable(tasks))
+    let tasks = await getBoard(opts.project)
+    if (opts.status) tasks = tasks.filter(t => t.status === opts.status)
+
+    const grouped = new Map<string, Task[]>()
+    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 | Claimed By |')
+    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.claimed_by ?? '—'} |`
+        )
+      }
+    }
+    console.log(`\nTotal: ${tasks.length} 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')
-  .requiredOption('-p, --project <slug>', 'Project slug')
+  .option('-p, --project <slug>', 'Project slug', 'optimal-cli')
   .option('-d, --description <desc>', 'Task description')
   .option('--priority <n>', 'Priority 1-4', '3')
-  .option('--skill <ref>', 'Skill reference')
+  .option('--skill <ref>', 'Skill required')
   .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_id: project.id,
+      project_slug: opts.project,
       title: opts.title,
       description: opts.description,
-      priority: parseInt(opts.priority) as 1 | 2 | 3 | 4,
+      priority: parseInt(opts.priority),
       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(',') ?? [],
     })
-    success(`Created task: ${colorize(task.id, 'dim')}\n  ${task.title} [${statusBadge(task.status)}] ${priorityBadge(task.priority)}`)
+    console.log(`Created task: ${task.id} — "${task.title}" (priority ${task.priority}, status ${task.status})`)
   })
 
 board
   .command('update')
   .description('Update a task')
-  .requiredOption('--id <uuid>', 'Task ID')
+  .requiredOption('--id <taskId>', 'Task UUID')
   .option('-s, --status <status>', 'New status')
   .option('-a, --agent <name>', 'Assign to agent')
   .option('--priority <n>', 'New priority')
-  .option('-m, --message <msg>', 'Log message (adds comment)')
+  .option('-m, --message <msg>', 'Log message')
   .action(async (opts) => {
     const updates: Record<string, unknown> = {}
     if (opts.status) updates.status = opts.status
     if (opts.agent) updates.assigned_to = opts.agent
     if (opts.priority) updates.priority = parseInt(opts.priority)
-    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)}`)
+
+    const task = await updateTask(opts.id, updates)
+    if (opts.message) {
+      await logActivity(opts.id, {
+        agent: opts.agent ?? 'cli',
+        action: 'status_change',
+        details: opts.message,
+      })
+    }
+    console.log(`Updated task ${task.id}: status → ${task.status}, assigned_to → ${task.assigned_to ?? '—'}`)
   })
 
 board
   .command('claim')
-  .description('Claim a task (bot pull model)')
-  .requiredOption('--id <uuid>', 'Task ID')
-  .requiredOption('--agent <name>', 'Agent name')
+  .description('Claim a task for an agent')
+  .requiredOption('--id <taskId>', 'Task UUID')
+  .option('-a, --agent <name>', 'Agent name', 'oracle')
   .action(async (opts) => {
+    const { claimTask } = await import('../lib/kanban.js')
     const task = await claimTask(opts.id, opts.agent)
-    success(`Claimed: ${colorize(task.title, 'cyan')} by ${colorize(opts.agent, 'bold')}`)
+    console.log(`Claimed task: ${task.title} by ${task.claimed_by} (status: ${task.status})`)
   })
 
 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')
+  .command('my-tasks')
+  .description('Show tasks claimed by an agent')
+  .option('-a, --agent <name>', 'Agent name', 'oracle')
+  .option('-p, --project <slug>', 'Project slug', 'optimal-cli')
   .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')}`)
+    const { getBoard } = await import('../lib/kanban.js')
+    const tasks = await getBoard(opts.project)
+    const myTasks = tasks.filter(t => t.claimed_by === opts.agent)
+    
+    console.log(`\n📋 Tasks claimed by ${opts.agent}:\n`)
+    for (const t of myTasks) {
+      console.log(`  [${t.status}] ${t.title} (priority ${t.priority})`)
+    }
+    console.log(`\nTotal: ${myTasks.length} tasks`)
   })
 
-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')
+// Sync commands for 3-way sync
+const syncCmd = program.command('sync').description('Sync tasks between obsidian and supabase')
+
+syncCmd
+  .command('push')
+  .description('Push obsidian tasks to supabase')
+  .option('--project <slug>', 'Target project slug', 'optimal-tasks')
+  .option('--dry-run', 'Show what would be synced without writing', false)
   .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`)
+    const { syncObsidianToSupabase } = await import('../lib/kanban-sync.js')
+    await syncObsidianToSupabase(opts.project, opts.dryRun)
   })
 
-// --- 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} |`)
-    }
+syncCmd
+  .command('pull')
+  .description('Pull supabase tasks to obsidian')
+  .option('--project <slug>', 'Source project slug', 'optimal-tasks')
+  .option('--dry-run', 'Show what would be synced without writing', false)
+  .action(async (opts) => {
+    const { syncSupabaseToObsidian } = await import('../lib/kanban-sync.js')
+    await syncSupabaseToObsidian(opts.project, opts.dryRun)
   })
 
-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')
+syncCmd
+  .command('status')
+  .description('Show sync status between obsidian and supabase')
+  .option('--project <slug>', 'Project slug', 'optimal-tasks')
   .action(async (opts) => {
-    const p = await createProject({
-      slug: opts.slug,
-      name: opts.name,
-      owner: opts.owner,
-      priority: parseInt(opts.priority) as 1 | 2 | 3 | 4,
-    })
-    success(`Created project: ${colorize(p.slug, 'cyan')} (${colorize(p.id, 'dim')})`)
+    const { getSyncStatus } = await import('../lib/kanban-sync.js')
+    await getSyncStatus(opts.project)
   })
 
-proj
-  .command('update')
-  .description('Update a project')
-  .requiredOption('--slug <slug>', 'Project slug')
-  .option('-s, --status <status>', 'New status')
-  .option('--owner <name>', 'New owner')
+// Obsidian-backed board commands (primary)
+const oboard = program.command('oboard').description('Obsidian Kanban board (primary)')
+
+oboard
+  .command('view')
+  .description('Display the obsidian task board')
+  .option('-p, --project <slug>', 'Project filter')
+  .option('-s, --status <status>', 'Filter by status (pending|in-progress|done)')
   .action(async (opts) => {
-    const updates: Record<string, unknown> = {}
-    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)}`)
+    const columns = await getBoardByProject(opts.project)
+    
+    if (opts.status) {
+      const col = columns.find(c => c.status === opts.status)
+      if (col) {
+        console.log(`\n## ${col.name}\n`)
+        for (const task of col.tasks) {
+          console.log(`- [${task.priority}] ${task.title} (${task.assignee || 'unassigned'})`)
+        }
+        console.log(`\nTotal: ${col.tasks.length} tasks`)
+      }
+      return
+    }
+    
+    for (const col of columns) {
+      console.log(`\n## ${col.name} (${col.tasks.length})\n`)
+      for (const task of col.tasks) {
+        const tags = task.tags.length ? ` [${task.tags.join(', ')}]` : ''
+        console.log(`- [${task.priority}] ${task.title}${tags}`)
+      }
+    }
+    console.log(`\nTotal: ${columns.reduce((sum, c) => sum + c.tasks.length, 0)} tasks`)
   })
 
-// --- 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
-`)
+oboard
+  .command('list')
+  .description('List all tasks with details')
+  .option('-p, --project <slug>', 'Project filter')
+  .option('-s, --status <status>', 'Status filter')
+  .option('--assignee <name>', 'Filter by assignee')
+  .option('--owner <name>', 'Filter by owner')
+  .option('--json', 'Output as JSON (for agent consumption)', false)
+  .action(async (opts: { project?: string; status?: string; assignee?: string; owner?: string; json?: boolean }) => {
+    let tasks = await loadAllTasks()
+    
+    if (opts.project) tasks = tasks.filter(t => t.project === opts.project)
+    if (opts.status) tasks = tasks.filter(t => t.status === opts.status)
+    if (opts.assignee) tasks = tasks.filter(t => t.assignee === opts.assignee)
+    if (opts.owner) tasks = tasks.filter(t => t.owner === opts.owner)
+    
+    if (opts.json) {
+      // Agent-friendly JSON output
+      console.log(JSON.stringify(tasks.map(t => ({
+        id: t.id,
+        title: t.title,
+        status: t.status,
+        priority: t.priority,
+        owner: t.owner,
+        assignee: t.assignee,
+        project: t.project,
+        tags: t.tags,
+        updatedAt: t.updatedAt,
+        createdAt: t.createdAt
+      })), null, 2))
+      return
+    }
+    
+    console.log(`\nFound ${tasks.length} tasks:\n`)
+    for (const task of tasks) {
+      console.log(`ID: ${task.id}`)
+      console.log(`  Title: ${task.title}`)
+      console.log(`  Status: ${task.status} | Priority: ${task.priority}`)
+      console.log(`  Owner: ${task.owner || '—'} | Assignee: ${task.assignee || '—'}`)
+      console.log(`  Project: ${task.project || '—'}`)
+      console.log(`  Tags: ${task.tags.join(', ') || 'none'}`)
+      console.log(`  Updated: ${task.updatedAt || 'never'}`)
+      console.log('')
+    }
+  })
 
-ms
+oboard
   .command('create')
-  .description('Create a milestone')
-  .requiredOption('--project <slug>', 'Project slug')
-  .requiredOption('--name <name>', 'Milestone name')
-  .option('--due <date>', 'Due date (YYYY-MM-DD)')
+  .description('Create a new obsidian task')
+  .requiredOption('-t, --title <title>', 'Task title')
+  .option('-d, --description <desc>', 'Task description')
+  .option('-p, --project <slug>', 'Project slug')
+  .option('--priority <n>', 'Priority 1-4', '3')
+  .option('--owner <name>', 'Owner', 'oracle')
+  .option('--assignee <name>', 'Assignee')
+  .option('--tags <labels>', 'Comma-separated tags')
   .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')})`)
+    const result = await createObsidianTask({
+      title: opts.title,
+      description: opts.description,
+      project: opts.project,
+      priority: parseInt(opts.priority) || 3,
+      owner: opts.owner,
+      assignee: opts.assignee,
+      tags: opts.tags?.split(',').map((t: string) => t.trim()),
+    })
+    
+    if (result.ok) {
+      console.log(`✓ ${result.message}`)
+      console.log(`  ID: ${result.task?.id}`)
+    } else {
+      console.error(`✗ ${result.message}`)
+      process.exit(1)
+    }
   })
 
-ms
-  .command('list')
-  .description('List milestones')
-  .option('--project <slug>', 'Filter by project')
+oboard
+  .command('update')
+  .description('Update an obsidian task')
+  .requiredOption('--id <taskId>', 'Task ID (or partial match)')
+  .option('-s, --status <status>', 'New status (pending|in-progress|done)')
+  .option('-a, --assignee <name>', 'Assign to agent')
+  .option('--owner <name>', 'Set owner')
+  .option('--priority <n>', 'Set priority 1-4')
+  .option('-m, --message <msg>', 'Log progress message')
   .action(async (opts) => {
-    let projectId: string | undefined
-    if (opts.project) {
-      const p = await getProjectBySlug(opts.project)
-      projectId = p.id
+    if (!opts.status && !opts.assignee && !opts.owner && !opts.priority && !opts.message) {
+      console.error('No updates specified. Use --status, --assignee, --owner, --priority, or --message')
+      process.exit(1)
     }
-    const milestones = await listMilestones(projectId)
-    for (const m of milestones) {
-      console.log(`${m.status.padEnd(10)} | ${m.due_date ?? 'no date'} | ${m.name}`)
+    
+    if (opts.status) {
+      const result = await updateObsidianTaskStatus(opts.id, opts.status, opts.message)
+      if (result.ok) {
+        console.log(`✓ ${result.message}`)
+      } else {
+        console.error(`✗ ${result.message}`)
+        process.exit(1)
+      }
+    }
+    
+    // TODO: Add other update fields
+    if (opts.assignee || opts.owner || opts.priority) {
+      console.log('Note: Full field updates not yet implemented, use status for now')
     }
   })
 
-// --- 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')
+oboard
+  .command('done')
+  .description('Mark a task as done')
+  .requiredOption('--id <taskId>', 'Task ID (or partial match)')
+  .option('-m, --message <msg>', 'Completion message')
   .action(async (opts) => {
-    const l = await createLabel(opts.name, opts.color)
-    success(`Created label: ${colorize(l.name, 'cyan')} (${colorize(l.id, 'dim')})`)
+    const result = await updateObsidianTaskStatus(opts.id, 'done', opts.message)
+    if (result.ok) {
+      console.log(`✓ Completed: ${result.message}`)
+    } else {
+      console.error(`✗ ${result.message}`)
+      process.exit(1)
+    }
   })
 
-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})` : ''}`)
+oboard
+  .command('start')
+  .description('Mark a task as in-progress')
+  .requiredOption('--id <taskId>', 'Task ID (or partial match)')
+  .action(async (opts) => {
+    const result = await updateObsidianTaskStatus(opts.id, 'in-progress')
+    if (result.ok) {
+      console.log(`✓ Started: ${result.message}`)
+    } else {
+      console.error(`✗ ${result.message}`)
+      process.exit(1)
+    }
   })
 
 // Audit financials command
@@ -426,13 +476,13 @@ program
   .argument('<app>', `App to deploy (${listApps().join(', ')})`)
   .option('--prod', 'Deploy to production', false)
   .action(async (app: string, opts: { prod: boolean }) => {
-    fmtInfo(`Deploying ${colorize(app, 'cyan')}${opts.prod ? colorize(' (production)', 'yellow') : ' (preview)'}...`)
+    console.log(`Deploying ${app}${opts.prod ? ' (production)' : ' (preview)'}...`)
     try {
       const url = await deploy(app, opts.prod)
-      success(`Deployed: ${colorize(url, 'green')}`)
+      console.log(`Deployed: ${url}`)
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err)
-      fmtError(`Deploy failed: ${msg}`)
+      console.error(`Deploy failed: ${msg}`)
       process.exit(1)
     }
   })
@@ -562,11 +612,11 @@ program
       })
 
       if (result.strapiDocumentId) {
-        success(`Strapi documentId: ${colorize(result.strapiDocumentId, 'cyan')}`)
+        console.log(`\nStrapi documentId: ${result.strapiDocumentId}`)
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err)
-      fmtError(`Newsletter generation failed: ${msg}`)
+      console.error(`Newsletter generation failed: ${msg}`)
       process.exit(1)
     }
   })
@@ -956,78 +1006,6 @@ 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: { brand: string; limit?: string; dryRun: boolean }) => {
-    try {
-      const config = getMetaConfigForBrand(opts.brand)
-
-      // Fetch pending instagram posts from Strapi
-      const result = await strapiGet<StrapiPage>('/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 as string) ?? '(no headline)'
-        const imageUrl = post.image_url as string | undefined
-        const caption = ((post.body as string) ?? (post.headline as string) ?? '').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')
@@ -1065,12 +1043,6 @@ program
 
 // ── Database migration ──────────────────────────────────────────────
 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')
@@ -1119,13 +1091,6 @@ migrate
 
 // ── Budget scenarios ────────────────────────────────────────────────
 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')
@@ -1265,15 +1230,6 @@ program
 
 // ── 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('init')
@@ -1410,7 +1366,15 @@ configSync
   .command('pull')
   .description('Pull config profile from shared registry into local config')
   .option('--profile <name>', 'Registry profile name', 'default')
-  .action(async (opts: { profile: string }) => {
+  .option('--dry-run', 'Show what would be pulled without writing', false)
+  .action(async (opts: { profile: string; dryRun?: boolean }) => {
+    if (opts.dryRun) {
+      const local = await readLocalConfig()
+      const owner = local?.profile.owner || process.env.OPTIMAL_CONFIG_OWNER || 'unknown'
+      console.log(`[dry-run] Would pull profile '${opts.profile}' for owner '${owner}' from registry`)
+      console.log(`[dry-run] Local config: ${local ? 'exists' : 'none'}`)
+      return
+    }
     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}`)
@@ -1427,7 +1391,20 @@ configSync
   .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: { agent: string; profile: string; force?: boolean }) => {
+  .option('--dry-run', 'Show what would be pushed without writing', false)
+  .action(async (opts: { agent: string; profile: string; force?: boolean; dryRun?: boolean }) => {
+    if (opts.dryRun) {
+      const local = await readLocalConfig()
+      if (!local) {
+        console.error('[dry-run] No local config to push')
+        process.exit(1)
+      }
+      const hash = hashConfig(local)
+      console.log(`[dry-run] Would push profile '${opts.profile}' for agent '${opts.agent}' to registry`)
+      console.log(`[dry-run] Local config hash: ${hash}`)
+      console.log(`[dry-run] Force: ${Boolean(opts.force)}`)
+      return
+    }
     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}`)
@@ -1438,294 +1415,4 @@ configSync
     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 as 'idle' | 'working' | 'error')
-    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 as AssetType | undefined,
-      status: opts.status as AssetStatus | undefined,
-      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 as AssetType,
-      status: opts.status as AssetStatus | undefined,
-      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: Record<string, unknown> = {}
-    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()