@timmeck/marketing-brain 0.2.0

package/src/cli/commands/doctor.ts

@@ -0,0 +1,110 @@
+import { Command } from 'commander';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { getDataDir, getPipeName } from '../../utils/paths.js';
+import { IpcClient } from '../../ipc/client.js';
+import { c, icons, header, divider } from '../colors.js';
+
+function pass(label: string, detail?: string): void {
+  const extra = detail ? ` ${c.dim(detail)}` : '';
+  console.log(`  ${c.green(icons.check)}  ${label}${extra}`);
+}
+
+function fail(label: string, detail?: string): void {
+  const extra = detail ? ` ${c.dim(detail)}` : '';
+  console.log(`  ${c.red(icons.cross)}  ${label}${extra}`);
+}
+
+export function doctorCommand(): Command {
+  return new Command('doctor')
+    .description('Check Marketing Brain health')
+    .action(async () => {
+      console.log(header('Marketing Brain Doctor', icons.megaphone));
+      console.log();
+
+      let allGood = true;
+
+      // 1. Daemon running?
+      const pidPath = path.join(getDataDir(), 'marketing-brain.pid');
+      let daemonRunning = false;
+      if (fs.existsSync(pidPath)) {
+        const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim(), 10);
+        try {
+          process.kill(pid, 0);
+          daemonRunning = true;
+          pass('Daemon running', `PID ${pid}`);
+        } catch {
+          fail('Daemon not running', 'stale PID file');
+          allGood = false;
+        }
+      } else {
+        fail('Daemon not running', 'no PID file');
+        allGood = false;
+      }
+
+      // 2. DB reachable?
+      if (daemonRunning) {
+        const client = new IpcClient(getPipeName(), 3000);
+        try {
+          await client.connect();
+          await client.request('analytics.summary', {});
+          pass('Database reachable');
+        } catch {
+          fail('Database not reachable');
+          allGood = false;
+        } finally {
+          client.disconnect();
+        }
+      } else {
+        fail('Database not reachable', 'daemon not running');
+        allGood = false;
+      }
+
+      // 3. MCP configured?
+      const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+      try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        if (settings.mcpServers?.['marketing-brain']) {
+          pass('MCP server configured');
+        } else {
+          fail('MCP server not configured', `add "marketing-brain" to ${settingsPath}`);
+          allGood = false;
+        }
+      } catch {
+        fail('MCP server not configured', 'settings.json not found');
+        allGood = false;
+      }
+
+      // 4. DB file exists?
+      const dbPath = path.join(getDataDir(), 'marketing-brain.db');
+      try {
+        const stat = fs.statSync(dbPath);
+        pass('Database file', `${(stat.size / 1024 / 1024).toFixed(1)} MB at ${dbPath}`);
+      } catch {
+        fail('Database file not found');
+        allGood = false;
+      }
+
+      // 5. Data dir writable?
+      const dataDir = getDataDir();
+      try {
+        fs.mkdirSync(dataDir, { recursive: true });
+        const testFile = path.join(dataDir, '.write-test');
+        fs.writeFileSync(testFile, 'ok');
+        fs.unlinkSync(testFile);
+        pass('Data directory writable', dataDir);
+      } catch {
+        fail('Data directory not writable', dataDir);
+        allGood = false;
+      }
+
+      console.log();
+      if (allGood) {
+        console.log(`  ${icons.ok}  ${c.success('All checks passed!')}`);
+      } else {
+        console.log(`  ${icons.warn}  ${c.warn('Some checks failed.')} Run ${c.cyan('marketing start')} first.`);
+      }
+      console.log(`\n${divider()}`);
+    });
+}

package/src/cli/commands/export.ts

@@ -0,0 +1,40 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons } from '../colors.js';
+
+export function exportCommand(): Command {
+  return new Command('export')
+    .description('Export Marketing Brain data')
+    .option('--format <fmt>', 'Output format: json (default)', 'json')
+    .action(async () => {
+      await withIpc(async (client) => {
+        process.stderr.write(`${icons.chart}  ${c.info('Exporting Marketing Brain data...')}\n`);
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const summary: any = await client.request('analytics.summary', {});
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const top: any = await client.request('analytics.top', { limit: 50 });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const insights: any = await client.request('insight.list', { limit: 100 });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const rules: any = await client.request('rule.list', {});
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const strategies: any = await client.request('strategy.list', { limit: 100 });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const network: any = await client.request('synapse.stats', {});
+
+        const data = {
+          exportedAt: new Date().toISOString(),
+          summary,
+          topPerformers: top,
+          insights,
+          rules,
+          strategies,
+          network,
+        };
+
+        console.log(JSON.stringify(data, null, 2));
+        process.stderr.write(`${icons.ok}  ${c.success('Export complete.')}\n`);
+      });
+    });
+}

package/src/cli/commands/import.ts

@@ -0,0 +1,84 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons } from '../colors.js';
+
+export function importCommand(): Command {
+  return new Command('import')
+    .description('Import posts from a JSON file')
+    .argument('<file>', 'JSON file with posts array')
+    .action(async (file) => {
+      const fs = await import('node:fs');
+      const path = await import('node:path');
+
+      const filePath = path.default.resolve(file);
+      if (!fs.default.existsSync(filePath)) {
+        console.error(`${icons.error}  ${c.error(`File not found: ${filePath}`)}`);
+        process.exit(1);
+      }
+
+      const data = JSON.parse(fs.default.readFileSync(filePath, 'utf-8'));
+      const posts = Array.isArray(data) ? data : data.posts;
+
+      if (!Array.isArray(posts)) {
+        console.error(`${icons.error}  ${c.error('Expected JSON array or { posts: [...] }')}`);
+        process.exit(1);
+      }
+
+      await withIpc(async (client) => {
+        let imported = 0;
+        let skipped = 0;
+
+        for (const post of posts) {
+          try {
+            // Create campaign if specified
+            let campaignId: number | null = null;
+            if (post.campaign) {
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              const camp: any = await client.request('campaign.create', { name: post.campaign, brand: post.brand });
+              campaignId = camp.id;
+            }
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result: any = await client.request('post.report', {
+              platform: post.platform,
+              content: post.content,
+              format: post.format ?? 'text',
+              url: post.url ?? null,
+              hashtags: post.hashtags ?? null,
+              campaign_id: campaignId,
+              status: post.status ?? 'published',
+              published_at: post.published_at ?? null,
+            });
+
+            if (result.isNew) {
+              imported++;
+
+              // Import engagement if provided
+              if (post.engagement) {
+                await client.request('post.engagement', {
+                  post_id: result.post.id,
+                  ...post.engagement,
+                });
+              }
+
+              // Import strategy if provided
+              if (post.strategy) {
+                await client.request('strategy.report', {
+                  post_id: result.post.id,
+                  description: post.strategy.description,
+                  approach: post.strategy.approach,
+                  outcome: post.strategy.outcome,
+                });
+              }
+            } else {
+              skipped++;
+            }
+          } catch (err) {
+            console.error(`${icons.error}  ${c.error(`Failed: ${err instanceof Error ? err.message : err}`)}`);
+          }
+        }
+
+        console.log(`${icons.ok}  ${c.success(`Import complete: ${imported} imported, ${skipped} skipped (duplicates)`)}`);
+      });
+    });
+}

package/src/cli/commands/insights.ts

@@ -0,0 +1,44 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons } from '../colors.js';
+
+export function insightsCommand(): Command {
+  return new Command('insights')
+    .description('Show current marketing insights')
+    .option('-t, --type <type>', 'Filter by type (trend, gap, synergy, template, optimization)')
+    .option('-l, --limit <n>', 'Max results', '10')
+    .action(async (opts) => {
+      await withIpc(async (client) => {
+        let insights: unknown[];
+        if (opts.type) {
+          insights = await client.request('insight.byType', { type: opts.type, limit: Number(opts.limit) }) as unknown[];
+        } else {
+          insights = await client.request('insight.list', { limit: Number(opts.limit) }) as unknown[];
+        }
+
+        if ((insights as unknown[]).length === 0) {
+          console.log(`${c.dim('No active insights. Start tracking posts to generate insights!')}`);
+          return;
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        for (const insight of insights as any[]) {
+          const typeIcon = insight.type === 'trend' ? '📈'
+            : insight.type === 'gap' ? '🕳️'
+            : insight.type === 'synergy' ? '🔄'
+            : insight.type === 'template' ? icons.template
+            : insight.type === 'optimization' ? '⚡'
+            : icons.insight;
+
+          const priority = insight.priority >= 7 ? c.red(`[P${insight.priority}]`)
+            : insight.priority >= 4 ? c.orange(`[P${insight.priority}]`)
+            : c.dim(`[P${insight.priority}]`);
+
+          console.log(`  ${typeIcon}  ${priority} ${c.value(insight.title)}`);
+          console.log(`     ${c.dim(insight.description)}`);
+          console.log(`     ${c.dim(`confidence: ${(insight.confidence * 100).toFixed(0)}%`)}`);
+          console.log();
+        }
+      });
+    });
+}

package/src/cli/commands/learn.ts

@@ -0,0 +1,24 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons, header, keyValue, divider } from '../colors.js';
+
+export function learnCommand(): Command {
+  return new Command('learn')
+    .description('Trigger a learning cycle manually (pattern extraction + rule generation)')
+    .action(async () => {
+      await withIpc(async (client) => {
+        console.log(`${icons.bolt}  ${c.info('Running learning cycle...')}`);
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const result: any = await client.request('learning.run', {});
+
+        console.log(header('Learning Cycle Complete', icons.bolt));
+        console.log(keyValue('Rules created', result.rulesCreated ?? 0));
+        console.log(keyValue('Rules updated', result.rulesUpdated ?? 0));
+        console.log(keyValue('Strategies updated', result.strategiesUpdated ?? 0));
+        console.log(keyValue('Synapses decayed', result.synapsesDecayed ?? 0));
+        console.log(keyValue('Synapses pruned', result.synapsesPruned ?? 0));
+        console.log(`\n${divider()}`);
+      });
+    });
+}

package/src/cli/commands/network.ts

@@ -0,0 +1,71 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons, header, keyValue, divider } from '../colors.js';
+
+export function networkCommand(): Command {
+  return new Command('network')
+    .description('Explore the synapse network')
+    .option('--node <type:id>', 'Node to explore (e.g., post:42)')
+    .option('-l, --limit <n>', 'Max synapses to show', '20')
+    .action(async (opts) => {
+      await withIpc(async (client) => {
+        if (opts.node) {
+          const [nodeType, nodeIdStr] = opts.node.split(':');
+          const nodeId = parseInt(nodeIdStr, 10);
+
+          if (!nodeType || isNaN(nodeId)) {
+            console.error(c.error('Invalid node format. Use: --node post:42'));
+            return;
+          }
+
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const related: any = await client.request('synapse.related', {
+            nodeType,
+            nodeId,
+            maxDepth: 2,
+          });
+
+          if (!related?.length) {
+            console.log(`${c.dim('No connections found for')} ${c.cyan(`${nodeType}:${nodeId}`)}`);
+            return;
+          }
+
+          console.log(header(`Connections from ${nodeType}:${nodeId}`, icons.synapse));
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          for (const r of related as any[]) {
+            const weight = (r.activation ?? r.weight ?? 0);
+            const weightColor = weight >= 0.7 ? c.green : weight >= 0.3 ? c.orange : c.dim;
+            const nodeType = r.node?.type ?? r.nodeType ?? '?';
+            const nodeId = r.node?.id ?? r.nodeId ?? '?';
+            console.log(`  ${c.cyan(icons.arrow)} ${c.value(`${nodeType}:${nodeId}`)} ${c.label('weight:')} ${weightColor(weight.toFixed(3))}`);
+          }
+        } else {
+          // Show general network stats
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const stats: any = await client.request('synapse.stats', {});
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const strongest: any = await client.request('synapse.strongest', {
+            limit: parseInt(opts.limit, 10),
+          });
+
+          console.log(header('Synapse Network', icons.synapse));
+          console.log(keyValue('Total synapses', stats.totalSynapses ?? 0));
+          console.log(keyValue('Average weight', (stats.avgWeight ?? 0).toFixed(3)));
+          console.log();
+
+          if (strongest?.length) {
+            console.log(`  ${c.purple.bold('Strongest connections:')}`);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            for (const s of strongest as any[]) {
+              const weight = (s.weight ?? 0);
+              const weightColor = weight >= 0.7 ? c.green : weight >= 0.3 ? c.orange : c.dim;
+              const src = `${s.source_type}:${s.source_id}`;
+              const tgt = `${s.target_type}:${s.target_id}`;
+              console.log(`  ${c.dim(src)} ${c.cyan(icons.arrow)} ${c.dim(tgt)} ${c.label(`[${s.synapse_type}]`)} ${weightColor(weight.toFixed(3))}`);
+            }
+          }
+        }
+        console.log(`\n${divider()}`);
+      });
+    });
+}

package/src/cli/commands/post.ts

@@ -0,0 +1,47 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons } from '../colors.js';
+
+export function postCommand(): Command {
+  return new Command('post')
+    .description('Report a published post')
+    .argument('<platform>', 'Platform (x, reddit, linkedin, bluesky)')
+    .argument('[url]', 'Post URL')
+    .option('-c, --content <text>', 'Post content/text')
+    .option('-f, --format <format>', 'Post format (text, image, video, thread)', 'text')
+    .option('--campaign <name>', 'Campaign name')
+    .option('--hashtags <tags>', 'Hashtags (comma-separated)')
+    .action(async (platform, url, opts) => {
+      if (!opts.content && !url) {
+        console.error(`${icons.error}  ${c.error('Provide either --content or a URL')}`);
+        process.exit(1);
+      }
+
+      await withIpc(async (client) => {
+        let campaignId: number | null = null;
+        if (opts.campaign) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const campaign: any = await client.request('campaign.create', { name: opts.campaign });
+          campaignId = campaign.id;
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const result: any = await client.request('post.report', {
+          platform,
+          content: opts.content ?? `Post at ${url}`,
+          format: opts.format,
+          url: url ?? null,
+          hashtags: opts.hashtags ?? null,
+          campaign_id: campaignId,
+          status: 'published',
+          published_at: new Date().toISOString(),
+        });
+
+        if (result.isNew) {
+          console.log(`${icons.ok}  ${c.success('Post reported!')} ${c.dim(`#${result.post.id} on ${platform}`)}`);
+        } else {
+          console.log(`${icons.post}  ${c.info('Post already tracked')} ${c.dim(`#${result.post.id}`)}`);
+        }
+      });
+    });
+}

package/src/cli/commands/query.ts

@@ -0,0 +1,108 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons, header, divider } from '../colors.js';
+
+export function queryCommand(): Command {
+  return new Command('query')
+    .description('Search posts, strategies, and insights')
+    .argument('<search>', 'Search term')
+    .option('-l, --limit <n>', 'Maximum results per category', '10')
+    .option('--posts-only', 'Only search posts')
+    .option('--strategies-only', 'Only search strategies')
+    .option('--insights-only', 'Only search insights')
+    .option('--page <n>', 'Page number (starting from 1)', '1')
+    .action(async (search: string, opts) => {
+      await withIpc(async (client) => {
+        const limit = parseInt(opts.limit, 10);
+        const page = parseInt(opts.page, 10) || 1;
+        const offset = (page - 1) * limit;
+        const searchAll = !opts.postsOnly && !opts.strategiesOnly && !opts.insightsOnly;
+        let totalResults = 0;
+
+        // --- Posts ---
+        if (searchAll || opts.postsOnly) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const results: any = await client.request('post.search', {
+            query: search,
+            limit: limit + offset,
+          });
+
+          const posts = Array.isArray(results) ? results.slice(offset, offset + limit) : [];
+          if (posts.length > 0) {
+            totalResults += posts.length;
+            console.log(header(`Posts matching "${search}"`, icons.post));
+
+            for (const post of posts) {
+              const platformTag = c.cyan(`[${post.platform}]`);
+              const formatTag = c.purple(post.format ?? 'text');
+              console.log(`  ${c.dim(`#${post.id}`)} ${platformTag} ${formatTag}`);
+              console.log(`     ${c.dim((post.content ?? '').slice(0, 120))}`);
+              if (post.hashtags) {
+                console.log(`     ${c.orange(post.hashtags)}`);
+              }
+              console.log();
+            }
+          }
+        }
+
+        // --- Strategies ---
+        if (searchAll || opts.strategiesOnly) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const strategies: any = await client.request('strategy.suggest', {
+            query: search,
+            limit: limit + offset,
+          });
+
+          const strats = Array.isArray(strategies) ? strategies.slice(offset, offset + limit) : [];
+          if (strats.length > 0) {
+            totalResults += strats.length;
+            console.log(header(`Strategies matching "${search}"`, icons.campaign));
+
+            for (const strat of strats) {
+              const confidence = strat.confidence ?? 0;
+              const confColor = confidence >= 0.7 ? c.green : confidence >= 0.4 ? c.orange : c.dim;
+              console.log(`  ${c.dim(`#${strat.id}`)} ${confColor(`[${(confidence * 100).toFixed(0)}%]`)} ${c.value(strat.description ?? '')}`);
+              if (strat.approach) {
+                console.log(`     ${c.label('Approach:')} ${c.dim(strat.approach.slice(0, 120))}`);
+              }
+              console.log();
+            }
+          }
+        }
+
+        // --- Insights ---
+        if (searchAll || opts.insightsOnly) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const insights: any = await client.request('insight.list', { limit: 100 });
+
+          const allInsights = Array.isArray(insights) ? insights : [];
+          const searchLower = search.toLowerCase();
+          const matched = allInsights.filter((i: { title?: string; description?: string }) =>
+            (i.title ?? '').toLowerCase().includes(searchLower) ||
+            (i.description ?? '').toLowerCase().includes(searchLower)
+          ).slice(offset, offset + limit);
+
+          if (matched.length > 0) {
+            totalResults += matched.length;
+            console.log(header(`Insights matching "${search}"`, icons.insight));
+
+            for (const ins of matched) {
+              const typeTag = c.cyan(`[${ins.type}]`);
+              console.log(`  ${typeTag} ${c.value(ins.title)}`);
+              if (ins.description) {
+                console.log(`     ${c.dim(ins.description.slice(0, 150))}`);
+              }
+              console.log();
+            }
+          }
+        }
+
+        if (totalResults === 0) {
+          console.log(`\n${icons.insight}  ${c.dim(`No results found for "${search}".`)}`);
+        } else {
+          console.log(`  ${c.dim(`Page ${page} — showing ${totalResults} result(s). Use --page ${page + 1} for more.`)}`);
+          console.log(divider());
+        }
+      });
+    });
+}

package/src/cli/commands/rules.ts

@@ -0,0 +1,27 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons } from '../colors.js';
+
+export function rulesCommand(): Command {
+  return new Command('rules')
+    .description('Show learned marketing rules')
+    .action(async () => {
+      await withIpc(async (client) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const rules: any[] = await client.request('rule.list') as any[];
+
+        if (rules.length === 0) {
+          console.log(`${c.dim('No rules learned yet. Track more posts to generate rules!')}`);
+          return;
+        }
+
+        for (const rule of rules) {
+          const conf = (rule.confidence * 100).toFixed(0);
+          console.log(`  ${icons.rule}  ${c.value(rule.pattern)}`);
+          console.log(`     ${c.dim(rule.recommendation)}`);
+          console.log(`     ${c.dim(`confidence: ${conf}% | triggers: ${rule.trigger_count} | success: ${rule.success_count}`)}`);
+          console.log();
+        }
+      });
+    });
+}

package/src/cli/commands/start.ts

@@ -0,0 +1,100 @@
+import { Command } from 'commander';
+import { spawn, type ChildProcess } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDataDir } from '../../utils/paths.js';
+import { c, icons } from '../colors.js';
+
+const MAX_RESTARTS = 5;
+const RESTART_WINDOW_MS = 5 * 60 * 1000; // 5 minutes
+const BASE_BACKOFF_MS = 1000;
+
+function spawnDaemon(entryPoint: string, args: string[]): ChildProcess {
+  const child = spawn(process.execPath, [entryPoint, ...args], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+  return child;
+}
+
+function startWatchdog(entryPoint: string, args: string[], pidPath: string): void {
+  const restartTimes: number[] = [];
+
+  function launch(): void {
+    const child = spawnDaemon(entryPoint, args);
+    console.log(`${icons.megaphone}  ${c.info('Marketing Brain daemon starting')} ${c.dim(`(PID: ${child.pid})`)}`);
+
+    child.on('exit', (code) => {
+      // Normal shutdown (code 0 or SIGTERM) — don't restart
+      if (code === 0 || code === null) return;
+
+      const now = Date.now();
+      restartTimes.push(now);
+
+      // Only count restarts within the window
+      const recentRestarts = restartTimes.filter((t) => now - t < RESTART_WINDOW_MS);
+      restartTimes.length = 0;
+      restartTimes.push(...recentRestarts);
+
+      if (recentRestarts.length > MAX_RESTARTS) {
+        console.error(`${icons.error}  ${c.error(`Marketing Brain crashed ${MAX_RESTARTS} times in 5 minutes — giving up.`)}`);
+        // Clean up stale PID file
+        try { fs.unlinkSync(pidPath); } catch { /* ignore */ }
+        return;
+      }
+
+      const backoff = BASE_BACKOFF_MS * Math.pow(2, recentRestarts.length - 1);
+      console.log(`${icons.warn}  ${c.warn(`Marketing Brain exited (code ${code}) — restarting in ${backoff / 1000}s...`)}`);
+
+      setTimeout(launch, backoff);
+    });
+  }
+
+  launch();
+
+  // Wait briefly for PID file to appear
+  setTimeout(() => {
+    if (fs.existsSync(pidPath)) {
+      console.log(`${icons.ok}  ${c.success('Marketing Brain daemon started successfully.')} ${c.dim('(watchdog active)')}`);
+    } else {
+      console.log(`${icons.clock}  ${c.warn('Daemon may still be starting.')} Check: ${c.cyan('marketing status')}`);
+    }
+  }, 1000);
+}
+
+export function startCommand(): Command {
+  return new Command('start')
+    .description('Start the Marketing Brain daemon')
+    .option('-f, --foreground', 'Run in foreground (no detach)')
+    .option('-c, --config <path>', 'Config file path')
+    .action((opts) => {
+      const pidPath = path.join(getDataDir(), 'marketing-brain.pid');
+
+      if (fs.existsSync(pidPath)) {
+        const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim(), 10);
+        try {
+          process.kill(pid, 0);
+          console.log(`${icons.megaphone}  Marketing Brain daemon is ${c.green('already running')} ${c.dim(`(PID: ${pid})`)}`);
+          return;
+        } catch {
+          fs.unlinkSync(pidPath);
+        }
+      }
+
+      if (opts.foreground) {
+        import('../../marketing-core.js').then(({ MarketingCore }) => {
+          const core = new MarketingCore();
+          core.start(opts.config);
+        });
+        return;
+      }
+
+      // Spawn detached daemon with watchdog
+      const args = ['daemon'];
+      if (opts.config) args.push('-c', opts.config);
+      const entryPoint = path.resolve(import.meta.dirname, '../../index.js');
+
+      startWatchdog(entryPoint, args, pidPath);
+    });
+}