@jaimevalasek/aioson 1.3.0 → 1.5.1

package/src/commands/squad-daemon.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { SquadDaemon } = require('../squad-daemon');
+const { openRuntimeDb } = require('../runtime-store');
+
+async function handleStart(projectDir, squadSlug, options, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_daemon.squad_required'));
+    return { ok: false };
+  }
+
+  let squadConfig = {};
+  try {
+    const squadJsonPath = path.join(projectDir, '.aioson', 'squads', squadSlug, 'squad.json');
+    squadConfig = JSON.parse(await fs.readFile(squadJsonPath, 'utf8'));
+  } catch { /* squad.json is optional */ }
+
+  const daemon = new SquadDaemon(projectDir, squadSlug, {
+    port: options.port ? Number(options.port) : 0,
+    poll: options.poll ? Number(options.poll) : 10000,
+    config: squadConfig
+  });
+
+  try {
+    const info = await daemon.start();
+    logger.log(t('squad_daemon.started', {
+      squad: squadSlug,
+      port: info.port,
+      workers: info.workers,
+      cron: info.cronJobs
+    }));
+    logger.log(t('squad_daemon.webhook_hint', { port: info.port }));
+    logger.log(t('squad_daemon.stop_hint'));
+
+    // Keep alive until signal
+    await new Promise((resolve) => {
+      process.on('SIGINT', resolve);
+      process.on('SIGTERM', resolve);
+    });
+
+    logger.log(t('squad_daemon.stopping'));
+    await daemon.stop();
+    return { ok: true, ...info };
+  } catch (err) {
+    logger.error(t('squad_daemon.start_failed', { error: err.message }));
+    return { ok: false, error: err.message };
+  }
+}
+
+async function handleStatus(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    // List all daemons
+    const handle = await openRuntimeDb(projectDir, { mustExist: true });
+    if (!handle) {
+      logger.error(t('squad_daemon.no_runtime'));
+      return { ok: false };
+    }
+    const { db } = handle;
+    try {
+      const daemons = db.prepare('SELECT * FROM squad_daemons ORDER BY squad_slug').all();
+      if (daemons.length === 0) {
+        logger.log(t('squad_daemon.no_daemons'));
+        return { ok: true, daemons: [] };
+      }
+      logger.log(`Daemons (${daemons.length}):`);
+      for (const d of daemons) {
+        const icon = d.status === 'running' ? '[*]' : '[ ]';
+        logger.log(`  ${icon} ${d.squad_slug} (${d.status}) port:${d.port || '-'} pid:${d.pid || '-'} heartbeat:${d.last_heartbeat || '-'}`);
+      }
+      return { ok: true, daemons };
+    } finally {
+      db.close();
+    }
+  }
+
+  // Specific squad daemon status
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_daemon.no_runtime'));
+    return { ok: false };
+  }
+  const { db } = handle;
+  try {
+    const record = db.prepare('SELECT * FROM squad_daemons WHERE squad_slug = ?').get(squadSlug);
+    if (!record) {
+      logger.log(t('squad_daemon.not_found', { squad: squadSlug }));
+      return { ok: true, daemon: null };
+    }
+    logger.log(`Daemon: ${record.squad_slug}`);
+    logger.log(`  Status: ${record.status}`);
+    logger.log(`  PID: ${record.pid || '-'}`);
+    logger.log(`  Port: ${record.port || '-'}`);
+    logger.log(`  Started: ${record.started_at || '-'}`);
+    logger.log(`  Heartbeat: ${record.last_heartbeat || '-'}`);
+    if (record.error_message) logger.log(`  Error: ${record.error_message}`);
+    if (record.config_json) {
+      try {
+        const config = JSON.parse(record.config_json);
+        if (config.cronJobs && config.cronJobs.length > 0) {
+          logger.log(`  Cron Jobs:`);
+          for (const job of config.cronJobs) {
+            logger.log(`    - ${job.worker} (${job.cron})`);
+          }
+        }
+      } catch { /* ignore */ }
+    }
+    return { ok: true, daemon: record };
+  } finally {
+    db.close();
+  }
+}
+
+async function handleStop(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_daemon.squad_required'));
+    return { ok: false };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_daemon.no_runtime'));
+    return { ok: false };
+  }
+  const { db } = handle;
+  try {
+    const record = db.prepare('SELECT * FROM squad_daemons WHERE squad_slug = ?').get(squadSlug);
+    if (!record || record.status !== 'running') {
+      logger.log(t('squad_daemon.not_running', { squad: squadSlug }));
+      return { ok: true };
+    }
+
+    // Try to kill the process
+    if (record.pid) {
+      try {
+        process.kill(record.pid, 'SIGTERM');
+        logger.log(t('squad_daemon.signal_sent', { squad: squadSlug, pid: record.pid }));
+      } catch {
+        logger.log(t('squad_daemon.process_gone', { squad: squadSlug }));
+      }
+    }
+
+    // Update record
+    db.prepare(
+      "UPDATE squad_daemons SET status = 'stopped' WHERE squad_slug = ?"
+    ).run(squadSlug);
+
+    return { ok: true };
+  } finally {
+    db.close();
+  }
+}
+
+async function handleLogs(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_daemon.squad_required'));
+    return { ok: false };
+  }
+
+  // Show recent worker runs as daemon logs
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_daemon.no_runtime'));
+    return { ok: false };
+  }
+  const { db } = handle;
+  try {
+    const runs = db.prepare(
+      'SELECT * FROM worker_runs WHERE squad_slug = ? ORDER BY created_at DESC LIMIT 30'
+    ).all(squadSlug);
+    if (runs.length === 0) {
+      logger.log(t('squad_daemon.no_logs'));
+      return { ok: true, runs: [] };
+    }
+    logger.log(`Recent daemon activity for "${squadSlug}" (${runs.length}):`);
+    for (const r of runs) {
+      const icon = r.status === 'completed' ? '[ok]' : r.status === 'failed' ? '[!!]' : '[..]';
+      const ms = r.duration_ms ? `${r.duration_ms}ms` : '-';
+      logger.log(`  ${icon} ${r.created_at} ${r.worker_slug} (${r.trigger_type}) ${ms}`);
+      if (r.error_message) logger.log(`       ${r.error_message}`);
+    }
+    return { ok: true, runs };
+  } finally {
+    db.close();
+  }
+}
+
+async function runSquadDaemon({ args, options, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const sub = options.sub || 'status';
+  const squadSlug = options.squad;
+
+  switch (sub) {
+    case 'start':
+      return handleStart(targetDir, squadSlug, options, { logger, t });
+    case 'status':
+      return handleStatus(targetDir, squadSlug, { logger, t });
+    case 'stop':
+      return handleStop(targetDir, squadSlug, { logger, t });
+    case 'logs':
+      return handleLogs(targetDir, squadSlug, { logger, t });
+    default:
+      logger.error(t('squad_daemon.unknown_sub', { sub }));
+      return { ok: false };
+  }
+}
+
+module.exports = { runSquadDaemon };

package/src/commands/squad-dashboard.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const path = require('node:path');
+const { createDashboardServer } = require('../squad-dashboard/server');
+
+async function runSquadDashboard({ args, options, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const port = Number(options.port) || 4180;
+  const filterSquad = options.squad || null;
+
+  const dashboard = createDashboardServer(targetDir, { port, squad: filterSquad });
+
+  try {
+    const info = await dashboard.start();
+    logger.log(t('squad_dashboard.started', { url: info.url, port: info.port }));
+    if (filterSquad) {
+      logger.log(t('squad_dashboard.filtered', { squad: filterSquad }));
+    }
+    logger.log(t('squad_dashboard.stop_hint'));
+
+    // Keep the process alive until SIGINT/SIGTERM
+    await new Promise((resolve) => {
+      process.on('SIGINT', resolve);
+      process.on('SIGTERM', resolve);
+    });
+
+    logger.log(t('squad_dashboard.stopping'));
+    await dashboard.stop();
+    return { ok: true, port: info.port, url: info.url };
+  } catch (err) {
+    if (err.code === 'EADDRINUSE') {
+      logger.error(t('squad_dashboard.port_in_use', { port }));
+      return { ok: false, error: `Port ${port} already in use` };
+    }
+    throw err;
+  }
+}
+
+module.exports = { runSquadDashboard };

package/src/commands/squad-deploy.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+async function runSquadDeploy({ args, options, logger }) {
+  const squadSlug = args[0] || options.squad;
+  const projectDir = path.resolve(args[1] || options.path || '.');
+  const provider = options.provider || 'cloudpanel';
+
+  if (!squadSlug) {
+    logger.log('Uso: aioson squad:deploy <squad> [dir] --provider=cloudpanel');
+    return { ok: false };
+  }
+
+  const squadJsonPath = path.join(projectDir, '.aioson', 'squads', squadSlug, 'squad.json');
+  let squadConfig;
+  try {
+    squadConfig = JSON.parse(await fs.readFile(squadJsonPath, 'utf8'));
+  } catch {
+    logger.log(`Squad "${squadSlug}" não encontrado em ${squadJsonPath}`);
+    return { ok: false, error: 'squad_not_found' };
+  }
+
+  const port = squadConfig.port || 3001;
+  const deployDir = path.join(projectDir, '.aioson', 'squads', squadSlug, 'deploy');
+  await fs.mkdir(deployDir, { recursive: true });
+
+  const nginxConf = generateNginxConf(squadSlug, port, provider);
+  const outPath = path.join(deployDir, 'nginx.conf');
+  await fs.writeFile(outPath, nginxConf);
+
+  logger.log(`✓ Configuração nginx gerada: ${outPath}`);
+  logger.log('');
+  logger.log('Instruções CloudPanel:');
+  logger.log('  1. Acesse CloudPanel → Websites → [seu site] → Nginx');
+  logger.log('  2. Cole o conteúdo do arquivo nginx.conf em "Custom Nginx Directives"');
+  logger.log('  3. Salve e aguarde o reload automático do nginx');
+  logger.log(`  4. Certifique-se que o daemon está rodando: aioson squad:daemon ${squadSlug} start`);
+
+  return { ok: true, path: outPath };
+}
+
+function generateNginxConf(slug, port, provider) {
+  return [
+    `# Squad: ${slug} — gerado por aioson squad:deploy`,
+    `# Provider: ${provider}`,
+    `# Cole em: CloudPanel → Website → Nginx → Custom Nginx Directives`,
+    `#`,
+    `# Pré-requisito: aioson squad:daemon ${slug} start`,
+    ``,
+    `location /${slug}/webhook/ {`,
+    `    proxy_pass http://127.0.0.1:${port}/webhook/;`,
+    `    proxy_http_version 1.1;`,
+    `    proxy_set_header Host $host;`,
+    `    proxy_set_header X-Real-IP $remote_addr;`,
+    `    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;`,
+    `    proxy_read_timeout 30s;`,
+    `    proxy_connect_timeout 5s;`,
+    `}`,
+  ].join('\n');
+}
+
+module.exports = { runSquadDeploy, generateNginxConf };

package/src/commands/squad-doctor.js

@@ -5,6 +5,7 @@ const path = require('node:path');
 const { openRuntimeDb } = require('../runtime-store');
 const { exists } = require('../utils');
 const { runSquadValidate } = require('./squad-validate');
+const { scoreCompletude, scoreProfundidade, scoreQualidadeEstrutural, scorePotencial, gradeFromScore } = require('./squad-score');
 
 function normalizeRel(value) {
   return String(value || '')
@@ -120,7 +121,7 @@ async function parseSquadPaths(targetDir, slug) {
       ? path.join(targetDir, normalizeRel(packageInfo.agentsDir || `.aioson/squads/${slug}/agents`))
       : path.join(targetDir, 'agents', slug),
     outputDir: path.join(targetDir, normalizeRel(rules.outputsDir || `output/${slug}`)),
-    logsDir: path.join(targetDir, normalizeRel(rules.logsDir || `aios-logs/${slug}`)),
+    logsDir: path.join(targetDir, normalizeRel(rules.logsDir || `aioson-logs/${slug}`)),
     mediaDir: path.join(targetDir, normalizeRel(rules.mediaDir || `media/${slug}`))
   };
 }
@@ -209,6 +210,86 @@ async function runSquadDoctor({ args, options = {}, logger, t }) {
   checks.push(makeCheck('output_dir', outputExists, outputExists ? 'info' : 'warn', t('squad_doctor.check_output_dir', { path: paths.outputDir })));
   checks.push(makeCheck('media_dir', mediaExists, mediaExists ? 'info' : 'warn', t('squad_doctor.check_media_dir', { path: paths.mediaDir })));
 
+  // Output strategy checks
+  const outputStrategy = manifest.outputStrategy && typeof manifest.outputStrategy === 'object'
+    ? manifest.outputStrategy
+    : null;
+
+  if (outputStrategy) {
+    const delivery = outputStrategy.delivery && typeof outputStrategy.delivery === 'object'
+      ? outputStrategy.delivery
+      : {};
+    const webhooks = Array.isArray(delivery.webhooks) ? delivery.webhooks : [];
+    const hasDelivery = webhooks.length > 0 || delivery.cloudPublish;
+
+    checks.push(makeCheck(
+      'output_strategy',
+      true,
+      'info',
+      `Output strategy: mode=${outputStrategy.mode || 'unknown'}, webhooks=${webhooks.length}, cloudPublish=${Boolean(delivery.cloudPublish)}, autoPublish=${Boolean(delivery.autoPublish)}`
+    ));
+
+    if (delivery.autoPublish && !hasDelivery) {
+      checks.push(makeCheck(
+        'output_auto_publish',
+        false,
+        'warn',
+        'autoPublish is enabled but no delivery targets configured (no webhooks, no cloudPublish)'
+      ));
+    }
+
+    for (const wh of webhooks) {
+      if (wh.url && wh.url.includes('{{ENV:')) {
+        const envMatch = wh.url.match(/\{\{ENV:(\w+)\}\}/);
+        if (envMatch && !process.env[envMatch[1]]) {
+          checks.push(makeCheck(
+            `webhook_env_${wh.slug}`,
+            false,
+            'warn',
+            `Webhook "${wh.slug}" references unset env var: ${envMatch[1]}`
+          ));
+        }
+      }
+    }
+  } else {
+    checks.push(makeCheck(
+      'output_strategy',
+      true,
+      'info',
+      'No output strategy configured (default file output will be used)'
+    ));
+  }
+
+  // Webhook production checks (from squad.json, optional file)
+  const squadJsonPath = path.join(paths.packageDir, 'squad.json');
+  let squadConfig = null;
+  try {
+    const raw = await fs.readFile(squadJsonPath, 'utf8');
+    squadConfig = JSON.parse(raw);
+  } catch { /* squad.json is optional */ }
+
+  if (squadConfig && squadConfig.webhook?.validate_signature) {
+    const envKey = squadConfig.webhook.signature_env || 'WEBHOOK_SECRET';
+    const defined = Boolean(process.env[envKey]);
+    checks.push(makeCheck(
+      `webhook_env_${envKey}`,
+      defined,
+      defined ? 'info' : 'error',
+      defined
+        ? `Env ${envKey} definida (HMAC validation enabled)`
+        : `Env ${envKey} não definida — webhook HMAC validation está ativo mas a variável está ausente`
+    ));
+  }
+
+  if (squadConfig && squadConfig.webhook?.public) {
+    checks.push(makeCheck(
+      'webhook_public_deploy',
+      null,
+      'warn',
+      'Config nginx: execute aioson squad:deploy para gerar nginx.conf'
+    ));
+  }
+
   const runtimeHandle = await openRuntimeDb(targetDir, { mustExist: true });
   if (!runtimeHandle) {
     checks.push(makeCheck('runtime_store', false, 'warn', t('squad_doctor.check_runtime_missing')));
@@ -297,6 +378,27 @@ async function runSquadDoctor({ args, options = {}, logger, t }) {
     checks.push(makeCheck('formal_validation', true, 'info', 'Manifest formally valid'));
   }
 
+  // Quality score
+  try {
+    const d1 = scoreCompletude(manifest);
+    const d2 = scoreProfundidade(manifest);
+    const d3 = scoreQualidadeEstrutural(manifest);
+    const d4 = scorePotencial(manifest);
+    const total = d1.score + d2.score + d3.score + d4.score;
+    const maxTotal = d1.max + d2.max + d3.max + d4.max;
+    const grade = gradeFromScore(total);
+    const isLow = total < 50;
+    checks.push(
+      makeCheck(
+        'quality_score',
+        !isLow,
+        'info',
+        `Quality score: ${total}/${maxTotal} — ${grade}`,
+        { qualityScore: { total, max: maxTotal, grade } }
+      )
+    );
+  } catch { /* scoring not critical */ }
+
   const summary = {
     failed: checks.filter((check) => check.severity === 'error' && !check.ok).length,
     warned: checks.filter((check) => check.severity === 'warn' && !check.ok).length,

package/src/commands/squad-investigate.js

@@ -0,0 +1,261 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const {
+  openRuntimeDb,
+  insertInvestigation,
+  listInvestigations,
+  getInvestigation,
+  linkInvestigation
+} = require('../runtime-store');
+
+const SEARCHES_DIR = 'squad-searches';
+const DIMENSION_HEADERS = ['D1', 'D2', 'D3', 'D4', 'D5', 'D6', 'D7'];
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Count how many of the 7 investigation dimensions are present in a report.
+ * Looks for headers like "## D1:", "## D2:", ..., "## D7:" in the markdown.
+ */
+function countDimensions(content) {
+  const text = String(content || '');
+  let count = 0;
+  for (const dim of DIMENSION_HEADERS) {
+    const pattern = new RegExp(`^##\\s+${dim}[:\\s]`, 'm');
+    if (pattern.test(text)) count++;
+  }
+  return count;
+}
+
+/**
+ * Calculate an investigation completeness score (0-1).
+ */
+function scoreCompleteness(content) {
+  const covered = countDimensions(content);
+  const total = DIMENSION_HEADERS.length;
+  return { covered, total, score: Math.round((covered / total) * 100) / 100 };
+}
+
+/**
+ * Subcommand: list
+ * Lists all investigations registered in the runtime SQLite.
+ */
+async function handleList(projectDir, { logger, t }) {
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_investigate.no_runtime'));
+    return { investigations: [], count: 0 };
+  }
+  const { db } = handle;
+  try {
+    const rows = listInvestigations(db);
+    if (rows.length === 0) {
+      logger.log(t('squad_investigate.no_investigations'));
+      return { investigations: [], count: 0 };
+    }
+    for (const row of rows) {
+      const linked = row.linked_squad_slug ? ` → ${row.linked_squad_slug}` : '';
+      const dims = `${row.dimensions_covered}/${row.total_dimensions}`;
+      logger.log(`  ${row.investigation_slug}  [${row.mode}]  ${row.domain}  ${dims}  conf=${row.confidence}${linked}`);
+    }
+    return { investigations: rows, count: rows.length };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: show <slug>
+ * Shows the investigation report content.
+ */
+async function handleShow(projectDir, slug, { logger, t }) {
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_investigate.no_runtime'));
+    return { found: false };
+  }
+  const { db } = handle;
+  try {
+    const row = getInvestigation(db, slug);
+    if (!row) {
+      logger.error(t('squad_investigate.not_found', { slug }));
+      return { found: false };
+    }
+    logger.log(`Investigation: ${row.investigation_slug}`);
+    logger.log(`Domain: ${row.domain}`);
+    logger.log(`Mode: ${row.mode}`);
+    logger.log(`Dimensions: ${row.dimensions_covered}/${row.total_dimensions}`);
+    logger.log(`Confidence: ${row.confidence}`);
+    logger.log(`Report: ${row.report_path || '(none)'}`);
+    logger.log(`Linked squad: ${row.linked_squad_slug || '(standalone)'}`);
+    logger.log(`Created: ${row.created_at}`);
+
+    if (row.report_path) {
+      const reportFile = path.resolve(projectDir, row.report_path);
+      if (await pathExists(reportFile)) {
+        const content = await fs.readFile(reportFile, 'utf8');
+        logger.log('');
+        logger.log(content);
+      }
+    }
+    return { found: true, investigation: row };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: score <slug>
+ * Calculates the completeness score for an investigation report.
+ */
+async function handleScore(projectDir, slug, { logger, t }) {
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_investigate.no_runtime'));
+    return { found: false, score: 0 };
+  }
+  const { db } = handle;
+  try {
+    const row = getInvestigation(db, slug);
+    if (!row) {
+      logger.error(t('squad_investigate.not_found', { slug }));
+      return { found: false, score: 0 };
+    }
+    if (!row.report_path) {
+      logger.error(t('squad_investigate.no_report', { slug }));
+      return { found: true, score: 0 };
+    }
+    const reportFile = path.resolve(projectDir, row.report_path);
+    if (!(await pathExists(reportFile))) {
+      logger.error(t('squad_investigate.report_missing', { path: row.report_path }));
+      return { found: true, score: 0 };
+    }
+    const content = await fs.readFile(reportFile, 'utf8');
+    const result = scoreCompleteness(content);
+    logger.log(`Completeness: ${result.covered}/${result.total} dimensions (${result.score})`);
+    return { found: true, ...result };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: link <investigation-slug> <squad-slug>
+ * Associates an investigation with a squad.
+ */
+async function handleLink(projectDir, invSlug, squadSlug, { logger, t }) {
+  if (!invSlug || !squadSlug) {
+    logger.error(t('squad_investigate.link_usage'));
+    return { linked: false };
+  }
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_investigate.no_runtime'));
+    return { linked: false };
+  }
+  const { db } = handle;
+  try {
+    const success = linkInvestigation(db, invSlug, squadSlug);
+    if (success) {
+      logger.log(t('squad_investigate.linked', { investigation: invSlug, squad: squadSlug }));
+    } else {
+      logger.error(t('squad_investigate.not_found', { slug: invSlug }));
+    }
+    return { linked: success };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: register
+ * Registers an existing investigation report file into the runtime SQLite.
+ */
+async function handleRegister(projectDir, reportPath, options, { logger, t }) {
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_investigate.no_runtime'));
+    return { registered: false };
+  }
+  const { db } = handle;
+  try {
+    const absPath = path.resolve(projectDir, reportPath);
+    if (!(await pathExists(absPath))) {
+      logger.error(t('squad_investigate.report_missing', { path: reportPath }));
+      return { registered: false };
+    }
+    const content = await fs.readFile(absPath, 'utf8');
+    const { covered, total, score } = scoreCompleteness(content);
+    const relPath = path.relative(projectDir, absPath);
+    const slug = insertInvestigation(db, {
+      investigationSlug: options.slug || undefined,
+      domain: options.domain || path.basename(reportPath, '.md'),
+      mode: options.mode || 'full',
+      dimensionsCovered: covered,
+      totalDimensions: total,
+      confidence: options.confidence ? Number(options.confidence) : score,
+      reportPath: relPath,
+      linkedSquadSlug: options.squad || null
+    });
+    logger.log(t('squad_investigate.registered', { slug, path: relPath }));
+    return { registered: true, slug };
+  } finally {
+    db.close();
+  }
+}
+
+async function runSquadInvestigate({ args = [], options = {}, logger = console, t = (k) => k } = {}) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const sub = options.sub || args[1] || 'list';
+
+  if (sub === 'list') {
+    return handleList(projectDir, { logger, t });
+  }
+
+  if (sub === 'show') {
+    const slug = options.investigation || args[2];
+    if (!slug) {
+      logger.error(t('squad_investigate.show_usage'));
+      return { found: false };
+    }
+    return handleShow(projectDir, slug, { logger, t });
+  }
+
+  if (sub === 'score') {
+    const slug = options.investigation || args[2];
+    if (!slug) {
+      logger.error(t('squad_investigate.score_usage'));
+      return { found: false, score: 0 };
+    }
+    return handleScore(projectDir, slug, { logger, t });
+  }
+
+  if (sub === 'link') {
+    const invSlug = options.investigation || args[2];
+    const squadSlug = options.squad || args[3];
+    return handleLink(projectDir, invSlug, squadSlug, { logger, t });
+  }
+
+  if (sub === 'register') {
+    const reportPath = options.report || args[2];
+    if (!reportPath) {
+      logger.error(t('squad_investigate.register_usage'));
+      return { registered: false };
+    }
+    return handleRegister(projectDir, reportPath, options, { logger, t });
+  }
+
+  logger.error(t('squad_investigate.unknown_sub', { sub }));
+  return { error: `Unknown subcommand: ${sub}` };
+}
+
+module.exports = { runSquadInvestigate, scoreCompleteness, countDimensions };