crewx 0.8.1 → 0.8.2-rc.2

package/scripts/analyze-task-logs.mjs

@@ -0,0 +1,569 @@
+#!/usr/bin/env node
+// PM 조사 도구 — tasks.logs 컬럼 통계 분석기 (임시/재활용 가능)
+// 제품 코드 아님. scripts/ 하위 조사용.
+//
+// 사용 예:
+//   node scripts/analyze-task-logs.mjs
+//   node scripts/analyze-task-logs.mjs --preset failure-analysis
+//   node scripts/analyze-task-logs.mjs --since 2026-04-01 --until 2026-04-24
+//   node scripts/analyze-task-logs.mjs --filter status=failed --group-by event.type
+//   node scripts/analyze-task-logs.mjs --preset failure-analysis --sample 20 --output md,json,console
+
+import Database from 'better-sqlite3';
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..');
+
+// ─── CLI 파싱 ───────────────────────────────────────────────────────────────
+function parseArgs(argv) {
+  const args = {
+    db: join(homedir(), '.crewx/crewx.db'),
+    since: null,   // ISO date or YYYY-MM-DD; default: 14d ago
+    until: null,   // default: now
+    filter: [],    // array of "col=val" or raw SQL WHERE fragment
+    groupBy: [],
+    sample: 10,
+    preset: null,
+    output: ['console'],
+    outputDir: join(REPO_ROOT, 'docs/qa-reports'),
+  };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => argv[++i];
+    switch (a) {
+      case '--db': args.db = next(); break;
+      case '--since': args.since = next(); break;
+      case '--until': args.until = next(); break;
+      case '--filter': args.filter.push(next()); break;
+      case '--group-by': args.groupBy.push(next()); break;
+      case '--sample': args.sample = parseInt(next(), 10); break;
+      case '--preset': args.preset = next(); break;
+      case '--output': args.output = next().split(',').map(s => s.trim()); break;
+      case '--output-dir': args.outputDir = next(); break;
+      case '-h':
+      case '--help': printHelp(); process.exit(0);
+      default: console.error(`Unknown arg: ${a}`); process.exit(1);
+    }
+  }
+  // defaults
+  if (!args.since) {
+    const d = new Date(); d.setDate(d.getDate() - 14);
+    args.since = d.toISOString();
+  }
+  if (!args.until) args.until = new Date().toISOString();
+  return args;
+}
+
+function printHelp() {
+  console.log(`
+PM Task Logs Analyzer
+
+Usage:
+  node scripts/analyze-task-logs.mjs [options]
+
+Options:
+  --db <path>              SQLite DB path (default: ~/.crewx/crewx.db)
+  --since <date>           Include tasks started at/after date (default: 14 days ago)
+  --until <date>           Include tasks started at/before date (default: now)
+  --filter <expr>          WHERE fragment (repeatable). e.g. status=failed, agent_id=core_sqa
+  --group-by <key>         Grouping key (repeatable). Supported: event.type, event.level, provider, agent_id
+  --sample <n>             Drill-down sample count per bucket (default: 10)
+  --preset <name>          Preset bundle: failure-analysis | event-catalog
+  --output <csv>           Comma list of: console, json, md (default: console)
+  --output-dir <path>      Output directory for md/json (default: docs/qa-reports)
+  -h, --help               Print this help
+
+Presets:
+  failure-analysis  — 실패 태스크 이벤트 패턴 + 카탈로그 v2 매칭률 + drill-down
+  event-catalog     — provider별 관찰된 이벤트 타입 전수 목록 (중립 분석)
+`);
+}
+
+// ─── Provider 감지 (stdout 이벤트 구조 기반 — ground truth) ────────────────────
+// 외부 파일 의존성 없음. DB 자체만 보고 판단.
+function detectProvider(stdoutLines) {
+  const types = new Set();
+  for (const line of stdoutLines) {
+    try {
+      const p = JSON.parse(line);
+      if (p.type) types.add(p.type);
+    } catch {}
+  }
+  // Codex: turn.*/thread.*/item.* 전용
+  if (types.has('turn.started') || types.has('turn.failed') || types.has('thread.started')) return 'codex';
+  // Copilot: assistant.* 델타 + tool.execution_*
+  if (types.has('assistant.message_delta') || types.has('tool.execution_complete') || types.has('tool.execution_start')) return 'copilot';
+  // OpenCode: step_start + step_finish (part 객체 포함)
+  if (types.has('step_start') && types.has('step_finish')) return 'opencode';
+  // Claude Code: system + result (둘 다 있는 경우)
+  if (types.has('system') && types.has('result')) return 'claude';
+  // Gemini native: init + message (type 필드만 보고)
+  if (types.has('init') && types.has('message')) return 'gemini';
+  // Claude 단독 (짧게 실패) — assistant + result 조합
+  if (types.has('result') && types.has('assistant')) return 'claude';
+  return null;  // 감지 불가 (로그 없거나 너무 짧음)
+}
+
+// ─── 카탈로그 v2 기반 extractFailure (설계서 참조) ─────────────────────────────
+// tier: primary(확정) / secondary(noise 허용) / tertiary(rate limit 등 약한 신호)
+function extractClaudeLikeFailure(p) {
+  if (p.type === 'result' && p.is_error === true) {
+    return { message: String(p.result || p.error || 'Task failed'), tier: 'primary' };
+  }
+  if (p.type === 'rate_limit_event') {
+    const info = p.rate_limit_info;
+    if (info?.status === 'rejected') return { message: 'Rate limit rejected', tier: 'tertiary' };
+  }
+  return null;
+}
+const FAILURE_EXTRACTORS = {
+  codex(p) {
+    if (p.type === 'turn.failed' && p.error?.message) {
+      return { message: String(p.error.message), tier: 'primary' };
+    }
+    if (p.type === 'error' && p.message) {
+      return { message: String(p.message), tier: 'secondary' };
+    }
+    return null;
+  },
+  claude: extractClaudeLikeFailure,
+  copilot: extractClaudeLikeFailure,
+  gemini(p) {
+    if (p.type === 'error' && p.message) return { message: String(p.message), tier: 'primary' };
+    return null;
+  },
+  opencode(p) {
+    if (p.type === 'step_finish' && p.part?.reason && p.part.reason !== 'stop') {
+      return { message: `OpenCode step stopped: ${p.part.reason}`, tier: 'primary' };
+    }
+    return null;
+  },
+};
+
+function pickFailureMessage(stdoutLines, provider) {
+  const extractor = FAILURE_EXTRACTORS[provider];
+  if (!extractor) return { message: null, tier: null };
+  let primary = null, lastSecondary = null, lastTertiary = null;
+  for (const line of stdoutLines) {
+    let p;
+    try { p = JSON.parse(line); } catch { continue; }
+    const sig = extractor(p);
+    if (!sig) continue;
+    if (sig.tier === 'primary' && primary == null) primary = sig.message;
+    else if (sig.tier === 'secondary') lastSecondary = sig.message;
+    else if (sig.tier === 'tertiary') lastTertiary = sig.message;
+  }
+  if (primary != null) return { message: primary, tier: 'primary' };
+  if (lastSecondary != null) return { message: lastSecondary, tier: 'secondary' };
+  if (lastTertiary != null) return { message: lastTertiary, tier: 'tertiary' };
+  return { message: null, tier: null };
+}
+
+// ─── 기본 통계 집계 ──────────────────────────────────────────────────────────
+function analyze({ rows, sampleCount, groupBy }) {
+  const stats = {
+    totalTasks: rows.length,
+    statusDist: {},
+    providerDist: {},
+    eventLevelTotals: { stdout: 0, stderr: 0, info: 0, other: 0 },
+    eventTypesByProvider: {},     // provider → type → count
+    eventCardinality: {},          // provider → Set<type>
+    tasksPerProvider: {},          // provider → count
+    tasksWithStdoutJson: {},       // provider → count
+    tasksWithStderr: {},           // provider → count
+    jsonParseStats: { ok: 0, fail: 0 },
+    eventsPerTaskDist: [],         // numeric array → mean/median/max
+    stderrFirstLineDist: {},       // provider → first-stderr-line → count
+    durationsByStatus: {},          // status → duration_ms[]
+    // failure-specific
+    failureMatch: {                // provider → {primary, secondary, tertiary, none, total}
+    },
+    unmatchedFailureSamples: {},   // provider → sample[]
+    extractedMessages: {},          // provider → {message: count}
+    groupBy: {},                   // custom group-by
+  };
+
+  for (const row of rows) {
+    // status dist
+    stats.statusDist[row.status] = (stats.statusDist[row.status] || 0) + 1;
+
+    // duration
+    if (row.duration_ms != null) {
+      (stats.durationsByStatus[row.status] ||= []).push(row.duration_ms);
+    }
+
+    // logs
+    let logs = [];
+    if (row.logs) {
+      try { logs = JSON.parse(row.logs); if (!Array.isArray(logs)) logs = []; } catch {}
+    }
+
+    const stdoutLines = [];
+    let hasStderr = false;
+    let firstStderr = null;
+    for (const entry of logs) {
+      const level = entry.level || 'other';
+      stats.eventLevelTotals[level] = (stats.eventLevelTotals[level] || 0) + 1;
+      if (level === 'stdout') {
+        stdoutLines.push(entry.message);
+      } else if (level === 'stderr') {
+        hasStderr = true;
+        if (firstStderr == null) firstStderr = (entry.message || '').slice(0, 120);
+      }
+    }
+    // provider 감지 — stdout 이벤트 구조로만 (DB ground truth)
+    const provider = detectProvider(stdoutLines) || 'unknown';
+    stats.providerDist[provider] = (stats.providerDist[provider] || 0) + 1;
+    stats.tasksPerProvider[provider] = (stats.tasksPerProvider[provider] || 0) + 1;
+
+    if (stdoutLines.length > 0) {
+      stats.tasksWithStdoutJson[provider] = (stats.tasksWithStdoutJson[provider] || 0) + 1;
+    }
+    if (hasStderr) {
+      stats.tasksWithStderr[provider] = (stats.tasksWithStderr[provider] || 0) + 1;
+      if (firstStderr) {
+        (stats.stderrFirstLineDist[provider] ||= {});
+        stats.stderrFirstLineDist[provider][firstStderr] = (stats.stderrFirstLineDist[provider][firstStderr] || 0) + 1;
+      }
+    }
+    stats.eventsPerTaskDist.push(logs.length);
+
+    // event type集계
+    (stats.eventTypesByProvider[provider] ||= {});
+    (stats.eventCardinality[provider] ||= new Set());
+    for (const line of stdoutLines) {
+      let parsed;
+      try { parsed = JSON.parse(line); stats.jsonParseStats.ok++; } catch { stats.jsonParseStats.fail++; continue; }
+      const t = parsed.type || '_no_type';
+      stats.eventTypesByProvider[provider][t] = (stats.eventTypesByProvider[provider][t] || 0) + 1;
+      stats.eventCardinality[provider].add(t);
+    }
+
+    // failure-specific (status=failed)
+    if (row.status === 'failed') {
+      const errMsg = normalizeError(row.error);
+      const isUserCancelled = errMsg && /중지|cancel|abort/i.test(errMsg);
+      (stats.failureMatch[provider] ||= { primary: 0, secondary: 0, tertiary: 0, none: 0, userCancelled: 0, total: 0 });
+      const m = stats.failureMatch[provider];
+      m.total++;
+      if (isUserCancelled) { m.userCancelled++; continue; }
+
+      const { message, tier } = pickFailureMessage(stdoutLines, provider);
+      if (tier) {
+        m[tier]++;
+        // record unique extracted messages
+        (stats.extractedMessages[provider] ||= {});
+        const keyMsg = (message || '').slice(0, 200);
+        stats.extractedMessages[provider][keyMsg] = (stats.extractedMessages[provider][keyMsg] || 0) + 1;
+      } else {
+        m.none++;
+        // drill-down: capture sample
+        (stats.unmatchedFailureSamples[provider] ||= []);
+        if (stats.unmatchedFailureSamples[provider].length < sampleCount) {
+          const lastEvents = stdoutLines.slice(-5);
+          stats.unmatchedFailureSamples[provider].push({
+            id: row.id,
+            agent: row.agent_id,
+            model: row.model,
+            errorField: errMsg ? errMsg.slice(0, 200) : null,
+            lastStdoutEvents: lastEvents.map(l => l.slice(0, 300)),
+            stdoutEventCount: stdoutLines.length,
+            firstStderrLine: firstStderr,
+          });
+        }
+      }
+    }
+
+    // custom group-by
+    for (const key of groupBy) {
+      const bucket = resolveGroupKey(key, { row, provider, logs, stdoutLines });
+      if (bucket == null) continue;
+      (stats.groupBy[key] ||= {});
+      stats.groupBy[key][bucket] = (stats.groupBy[key][bucket] || 0) + 1;
+    }
+  }
+
+  // Convert Set to count
+  for (const p of Object.keys(stats.eventCardinality)) {
+    stats.eventCardinality[p] = stats.eventCardinality[p].size;
+  }
+
+  // Summaries
+  stats.eventsPerTaskStats = numericSummary(stats.eventsPerTaskDist);
+  delete stats.eventsPerTaskDist;
+  for (const [status, arr] of Object.entries(stats.durationsByStatus)) {
+    stats.durationsByStatus[status] = numericSummary(arr);
+  }
+
+  return stats;
+}
+
+function normalizeError(errField) {
+  if (!errField) return null;
+  try { const p = JSON.parse(errField); return p.message || errField; } catch { return errField; }
+}
+
+function resolveGroupKey(key, ctx) {
+  if (key === 'agent_id') return ctx.row.agent_id;
+  if (key === 'provider') return ctx.provider;
+  if (key === 'status') return ctx.row.status;
+  if (key === 'model') return ctx.row.model;
+  if (key === 'event.type') {
+    // counts per unique event type — returns array... flatten: return null, handled elsewhere
+    // For simplicity here, pick first event type
+    for (const line of ctx.stdoutLines) {
+      try { const p = JSON.parse(line); if (p.type) return p.type; } catch {}
+    }
+    return null;
+  }
+  if (key === 'event.level') {
+    const levels = new Set(ctx.logs.map(l => l.level || 'other'));
+    return [...levels].sort().join('+');
+  }
+  return null;
+}
+
+function numericSummary(arr) {
+  if (!arr.length) return { count: 0, mean: 0, median: 0, max: 0, min: 0 };
+  const sorted = [...arr].sort((a, b) => a - b);
+  const sum = sorted.reduce((s, v) => s + v, 0);
+  return {
+    count: sorted.length,
+    mean: Math.round(sum / sorted.length),
+    median: sorted[Math.floor(sorted.length / 2)],
+    max: sorted[sorted.length - 1],
+    min: sorted[0],
+  };
+}
+
+// ─── WHERE 절 조립 ────────────────────────────────────────────────────────────
+function buildWhere(filters, since, until) {
+  const clauses = [];
+  const params = {};
+  // time filter
+  if (since) { clauses.push('started_at >= @since'); params.since = since; }
+  if (until) { clauses.push('started_at <= @until'); params.until = until; }
+  // filters
+  for (let i = 0; i < filters.length; i++) {
+    const f = filters[i];
+    const m = f.match(/^(\w+)\s*=\s*(.+)$/);
+    if (m) {
+      const col = m[1]; const val = m[2].replace(/^['"]|['"]$/g, '');
+      clauses.push(`${col} = @f${i}`); params[`f${i}`] = val;
+    } else {
+      clauses.push(`(${f})`);
+    }
+  }
+  return { where: clauses.length ? 'WHERE ' + clauses.join(' AND ') : '', params };
+}
+
+// ─── 출력 포맷터 ─────────────────────────────────────────────────────────────
+function renderConsole(stats, args) {
+  const out = [];
+  out.push(`\n━━━ Task Logs Analysis ━━━`);
+  out.push(`기간: ${args.since}  ~  ${args.until}`);
+  out.push(`필터: ${args.filter.length ? args.filter.join(' | ') : '(없음)'}`);
+  out.push(`총 태스크: ${stats.totalTasks}`);
+  out.push('');
+  out.push(`[상태 분포]`);
+  for (const [k, v] of Object.entries(stats.statusDist).sort((a,b) => b[1]-a[1])) {
+    out.push(`  ${k.padEnd(12)} ${v}`);
+  }
+  out.push('');
+  out.push(`[Provider 분포]`);
+  for (const [k, v] of Object.entries(stats.providerDist).sort((a,b) => b[1]-a[1])) {
+    out.push(`  ${k.padEnd(12)} ${v}`);
+  }
+  out.push('');
+  out.push(`[이벤트 level 총량]`);
+  for (const [k, v] of Object.entries(stats.eventLevelTotals)) out.push(`  ${k.padEnd(8)} ${v}`);
+  out.push('');
+  out.push(`[태스크당 이벤트 수] mean=${stats.eventsPerTaskStats.mean} median=${stats.eventsPerTaskStats.median} max=${stats.eventsPerTaskStats.max}`);
+  out.push(`[stdout JSON 파싱] ok=${stats.jsonParseStats.ok} fail=${stats.jsonParseStats.fail}`);
+
+  out.push(`\n[Provider × 이벤트 타입 카디널리티]`);
+  for (const [p, n] of Object.entries(stats.eventCardinality)) {
+    out.push(`  ${p.padEnd(12)} ${n} unique types`);
+  }
+
+  if (Object.keys(stats.failureMatch).length) {
+    out.push(`\n[실패 태스크 — 카탈로그 v2 매칭률]`);
+    out.push(`  Provider     total  primary  secondary  tertiary  none  userCancelled  improve%`);
+    for (const [p, m] of Object.entries(stats.failureMatch).sort((a,b) => b[1].total-a[1].total)) {
+      const improvable = m.total - m.userCancelled;
+      const matched = m.primary + m.secondary + m.tertiary;
+      const pct = improvable > 0 ? ((matched / improvable) * 100).toFixed(0) : 0;
+      out.push(`  ${p.padEnd(12)} ${String(m.total).padStart(5)}  ${String(m.primary).padStart(7)}  ${String(m.secondary).padStart(9)}  ${String(m.tertiary).padStart(8)}  ${String(m.none).padStart(4)}  ${String(m.userCancelled).padStart(13)}   ${pct}%`);
+    }
+  }
+
+  if (args.preset === 'failure-analysis' || args.preset === 'event-catalog') {
+    out.push(`\n[Provider × Event Type 빈도 (Top 15)]`);
+    for (const [p, types] of Object.entries(stats.eventTypesByProvider)) {
+      out.push(`  --- ${p} ---`);
+      const sorted = Object.entries(types).sort((a,b) => b[1]-a[1]).slice(0, 15);
+      for (const [t, c] of sorted) out.push(`    ${t.padEnd(35)} ${c}`);
+    }
+  }
+
+  if (args.preset === 'failure-analysis' && Object.keys(stats.extractedMessages).length) {
+    out.push(`\n[추출된 메시지 unique 빈도 (Top 10 per provider)]`);
+    for (const [p, msgs] of Object.entries(stats.extractedMessages)) {
+      out.push(`  --- ${p} ---`);
+      const sorted = Object.entries(msgs).sort((a,b) => b[1]-a[1]).slice(0, 10);
+      for (const [m, c] of sorted) out.push(`    [${String(c).padStart(3)}] ${m.slice(0, 140)}`);
+    }
+  }
+
+  if (args.preset === 'failure-analysis' && Object.keys(stats.unmatchedFailureSamples).length) {
+    out.push(`\n[비매칭 실패 샘플 drill-down (max ${args.sample} per provider)]`);
+    for (const [p, samples] of Object.entries(stats.unmatchedFailureSamples)) {
+      out.push(`  --- ${p} (${samples.length} samples) ---`);
+      for (const s of samples.slice(0, 5)) {
+        out.push(`    [${s.id}] agent=${s.agent} model=${s.model || '-'} events=${s.stdoutEventCount}`);
+        out.push(`      errorField: ${s.errorField || '-'}`);
+        out.push(`      firstStderr: ${s.firstStderrLine || '-'}`);
+        const last = s.lastStdoutEvents[s.lastStdoutEvents.length - 1];
+        if (last) out.push(`      lastEvent:  ${last.slice(0, 160)}`);
+      }
+    }
+  }
+
+  return out.join('\n');
+}
+
+function renderMarkdown(stats, args) {
+  const lines = [];
+  lines.push(`# Task Logs Analysis — ${args.preset || 'custom'}`);
+  lines.push('');
+  lines.push(`- **기간**: ${args.since} ~ ${args.until}`);
+  lines.push(`- **필터**: ${args.filter.length ? args.filter.join(', ') : '(없음)'}`);
+  lines.push(`- **총 태스크**: ${stats.totalTasks}`);
+  lines.push(`- **생성**: ${new Date().toISOString()}`);
+  lines.push('');
+  lines.push(`## 상태 분포`);
+  lines.push('| status | count |');
+  lines.push('|---|---|');
+  for (const [k, v] of Object.entries(stats.statusDist).sort((a,b) => b[1]-a[1])) {
+    lines.push(`| ${k} | ${v} |`);
+  }
+  lines.push('');
+  lines.push(`## Provider 분포`);
+  lines.push('| provider | count |');
+  lines.push('|---|---|');
+  for (const [k, v] of Object.entries(stats.providerDist).sort((a,b) => b[1]-a[1])) {
+    lines.push(`| ${k} | ${v} |`);
+  }
+  lines.push('');
+  if (Object.keys(stats.failureMatch).length) {
+    lines.push(`## 실패 매칭률 (카탈로그 v2 기준)`);
+    lines.push('| provider | total | primary | secondary | tertiary | none | userCancelled | improve% |');
+    lines.push('|---|---|---|---|---|---|---|---|');
+    for (const [p, m] of Object.entries(stats.failureMatch).sort((a,b) => b[1].total-a[1].total)) {
+      const improvable = m.total - m.userCancelled;
+      const matched = m.primary + m.secondary + m.tertiary;
+      const pct = improvable > 0 ? ((matched / improvable) * 100).toFixed(0) : 0;
+      lines.push(`| ${p} | ${m.total} | ${m.primary} | ${m.secondary} | ${m.tertiary} | ${m.none} | ${m.userCancelled} | ${pct}% |`);
+    }
+    lines.push('');
+  }
+  lines.push(`## Provider × Event Type 빈도 (Top 15)`);
+  for (const [p, types] of Object.entries(stats.eventTypesByProvider)) {
+    lines.push(`### ${p}`);
+    lines.push('| event.type | count |');
+    lines.push('|---|---|');
+    const sorted = Object.entries(types).sort((a,b) => b[1]-a[1]).slice(0, 15);
+    for (const [t, c] of sorted) lines.push(`| \`${t}\` | ${c} |`);
+    lines.push('');
+  }
+
+  if (Object.keys(stats.extractedMessages).length) {
+    lines.push(`## 추출된 메시지 unique 빈도`);
+    for (const [p, msgs] of Object.entries(stats.extractedMessages)) {
+      lines.push(`### ${p}`);
+      lines.push('| count | message |');
+      lines.push('|---|---|');
+      const sorted = Object.entries(msgs).sort((a,b) => b[1]-a[1]).slice(0, 15);
+      for (const [m, c] of sorted) lines.push(`| ${c} | \`${m.replace(/\|/g, '\\|').slice(0, 180)}\` |`);
+      lines.push('');
+    }
+  }
+
+  if (Object.keys(stats.unmatchedFailureSamples).length) {
+    lines.push(`## 비매칭 실패 샘플 drill-down (${args.sample}개 per provider)`);
+    for (const [p, samples] of Object.entries(stats.unmatchedFailureSamples)) {
+      lines.push(`### ${p} (${samples.length} samples)`);
+      for (const s of samples) {
+        lines.push(`- **${s.id}** agent=\`${s.agent}\` model=\`${s.model || '-'}\` events=${s.stdoutEventCount}`);
+        lines.push(`  - errorField: \`${(s.errorField || '-').replace(/`/g, "'")}\``);
+        lines.push(`  - firstStderr: \`${(s.firstStderrLine || '-').replace(/`/g, "'")}\``);
+        if (s.lastStdoutEvents.length) {
+          lines.push(`  - lastEvent: \`${s.lastStdoutEvents[s.lastStdoutEvents.length-1].slice(0, 200).replace(/`/g, "'")}\``);
+        }
+      }
+      lines.push('');
+    }
+  }
+
+  if (Object.keys(stats.stderrFirstLineDist).length) {
+    lines.push(`## stderr 첫 줄 분포 (provider별 Top 8)`);
+    for (const [p, dist] of Object.entries(stats.stderrFirstLineDist)) {
+      lines.push(`### ${p}`);
+      lines.push('| count | stderr first line |');
+      lines.push('|---|---|');
+      const sorted = Object.entries(dist).sort((a,b) => b[1]-a[1]).slice(0, 8);
+      for (const [l, c] of sorted) lines.push(`| ${c} | \`${l.replace(/\|/g, '\\|').replace(/`/g, "'").slice(0, 160)}\` |`);
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}
+
+// ─── 메인 ────────────────────────────────────────────────────────────────────
+function main() {
+  const args = parseArgs(process.argv);
+
+  // 프리셋 자동 필터/그룹 세팅
+  if (args.preset === 'failure-analysis' && !args.filter.some(f => f.startsWith('status='))) {
+    args.filter.push('status=failed');
+  }
+
+  const db = new Database(args.db, { readonly: true });
+  const { where, params } = buildWhere(args.filter, args.since, args.until);
+  const sql = `
+    SELECT id, agent_id, status, error, logs, started_at, completed_at, duration_ms, model
+    FROM tasks
+    ${where}
+  `;
+  const rows = db.prepare(sql).all(params);
+
+  const stats = analyze({ rows, sampleCount: args.sample, groupBy: args.groupBy });
+  stats._meta = { since: args.since, until: args.until, preset: args.preset, filter: args.filter };
+
+  // 출력
+  if (args.output.includes('console')) {
+    console.log(renderConsole(stats, args));
+  }
+  if (args.output.includes('md') || args.output.includes('json')) {
+    if (!existsSync(args.outputDir)) mkdirSync(args.outputDir, { recursive: true });
+    const date = new Date().toISOString().slice(0, 10);
+    const base = args.preset ? `task-logs-${args.preset}-${date}` : `task-logs-${date}`;
+    if (args.output.includes('md')) {
+      const p = join(args.outputDir, `${base}.md`);
+      writeFileSync(p, renderMarkdown(stats, args), 'utf8');
+      console.log(`\n📝 MD 리포트: ${p}`);
+    }
+    if (args.output.includes('json')) {
+      const p = join(args.outputDir, `${base}.json`);
+      writeFileSync(p, JSON.stringify(stats, null, 2), 'utf8');
+      console.log(`📊 JSON dump: ${p}`);
+    }
+  }
+}
+
+main();