mixdog 0.7.18 → 0.8.0

package/scripts/live-worker-smoke.mjs

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { BRIDGE_TOOL, createStandaloneBridge } from '../src/standalone/bridge-tool.mjs';
+import { executePatchTool } from '../src/runtime/agent/orchestrator/tools/patch.mjs';
+import { executeBuiltinTool } from '../src/runtime/agent/orchestrator/tools/builtin.mjs';
+import { initProviders } from '../src/runtime/agent/orchestrator/providers/registry.mjs';
+import {
+  closeSession,
+  enqueuePendingMessage,
+  getSession,
+  getSessionLastProgressAt,
+  getSessionRuntime,
+  listSessions,
+} from '../src/runtime/agent/orchestrator/session/manager.mjs';
+
+const root = mkdtempSync(join(tmpdir(), 'mixdog-live-worker-'));
+const dataDir = join(root, '.mixdog-data');
+let activeAsks = 0;
+let maxActiveAsks = 0;
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function jobId(text) {
+  return String(text).match(/bridge job: (\S+)/)?.[1] || null;
+}
+
+async function main() {
+  const leadToolRules = readFileSync('src/rules/lead/00-tool-lead.md', 'utf8');
+  const workflowRules = readFileSync('src/defaults/user-workflow.md', 'utf8');
+  assert(/Use `bridge` to delegate actual scoped work/i.test(leadToolRules), 'lead rules must direct scoped work to bridge');
+  assert(/parallelize independent files\/concerns/i.test(leadToolRules), 'lead rules must keep independent work parallel');
+  assert(/Use bridge workers/i.test(workflowRules) && /parallelizes useful work/i.test(workflowRules), 'workflow rules must recommend bridge parallelism');
+  assert(/Prefer async by default/i.test(BRIDGE_TOOL.description || '') && /distinct tags/i.test(BRIDGE_TOOL.description || '') && /completion notification/i.test(BRIDGE_TOOL.description || ''), 'bridge tool description must expose async parallel tags');
+
+  mkdirSync(dataDir, { recursive: true });
+  await initProviders({ 'openai-oauth': { enabled: true } });
+  writeFileSync(join(dataDir, 'user-workflow.json'), JSON.stringify({
+    roles: [
+      { name: 'worker', preset: 'fake-worker', permission: 'full', maxLoopIterations: 3, idleTimeoutMs: 5000 },
+      { name: 'reviewer', preset: 'fake-reviewer', permission: 'read' },
+      { name: 'debugger', preset: 'fake-debugger', permission: 'read' },
+    ],
+  }));
+  writeFileSync(join(root, 'feature.txt'), 'alpha\nbeta\n', 'utf8');
+  writeFileSync(join(root, 'notes.txt'), 'TODO investigate timeout\n', 'utf8');
+
+  const cfgMod = {
+    loadConfig() {
+      return {
+        providers: { 'openai-oauth': { enabled: true } },
+        presets: [
+          { id: 'fake-worker', name: 'Fake Worker', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'full', effort: 'medium', fast: true },
+          { id: 'fake-reviewer', name: 'Fake Reviewer', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'readonly', effort: 'low' },
+          { id: 'fake-debugger', name: 'Fake Debugger', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'readonly', effort: 'low' },
+        ],
+      };
+    },
+    resolveRuntimeSpec(preset, ctx) {
+      return { lane: 'bridge', scopeKey: `smoke:${ctx.agentId}`, provider: preset.provider, model: preset.model };
+    },
+  };
+  const reg = { initProviders };
+
+  async function fakeAskSession(sessionId, prompt, _context, _onToolCall, cwdOverride) {
+    const session = getSession(sessionId);
+    if (session) {
+      session.status = 'running';
+      session.lastStreamDeltaAt = Date.now();
+    }
+    activeAsks += 1;
+    maxActiveAsks = Math.max(maxActiveAsks, activeAsks);
+    try {
+      if (/parallel slow/i.test(prompt)) await sleep(600);
+      if (/long busy/i.test(prompt)) await sleep(350);
+      if (/write implementation/i.test(prompt)) {
+        const out = await executePatchTool('apply_patch', {
+          base_path: cwdOverride,
+          patch: `*** Begin Patch
+*** Update File: feature.txt
+@@
+ alpha
+-beta
++beta from worker
+*** End Patch
+`,
+        }, cwdOverride);
+        return { content: `worker wrote feature\n${String(out).split(/\r?\n/)[0]}` };
+      }
+      if (/run verification/i.test(prompt)) {
+        const out = await executeBuiltinTool('shell', {
+          command: 'Get-Content feature.txt',
+          cwd: cwdOverride,
+          shell: 'powershell',
+          timeout: 30_000,
+        }, cwdOverride);
+        return { content: `verification\n${out}` };
+      }
+      if (/review/i.test(prompt)) {
+        const body = readFileSync(join(cwdOverride, 'feature.txt'), 'utf8');
+        return { content: body.includes('worker') ? 'reviewer ok' : 'reviewer missing worker change' };
+      }
+      if (/debug/i.test(prompt)) {
+        return { content: `debugger ${readFileSync(join(cwdOverride, 'notes.txt'), 'utf8').trim()}` };
+      }
+      return { content: `ack ${session?.role || 'worker'}` };
+    } finally {
+      activeAsks -= 1;
+      if (session) {
+        session.status = 'idle';
+        session.lastUsedAt = new Date().toISOString();
+        session.lastStreamDeltaAt = Date.now();
+      }
+    }
+  }
+
+  const mgr = {
+    getSession,
+    listSessions,
+    closeSession,
+    getSessionRuntime,
+    enqueuePendingMessage,
+    getSessionLastProgressAt,
+    askSession: fakeAskSession,
+  };
+  const bridge = createStandaloneBridge({ cfgMod, reg, mgr, dataDir, cwd: root, defaultMode: 'async' });
+
+  async function waitJob(out, pattern, label) {
+    const id = jobId(out);
+    assert(id, `missing job id for ${label}: ${out}`);
+    let last = '';
+    for (let i = 0; i < 40; i += 1) {
+      last = await bridge.execute({ type: 'read', jobId: id }, { invocationSource: 'model-tool', cwd: root });
+      if (pattern.test(last)) return last;
+      if (/^Error[\s:[]/.test(last) || /status: error/.test(last)) break;
+      await sleep(100);
+    }
+    throw new Error(`${label} did not finish with ${pattern}: ${last}`);
+  }
+
+  const spawnOut = await bridge.execute({
+    type: 'spawn',
+    role: 'worker',
+    tag: 'impl1',
+    cwd: root,
+    prompt: 'write implementation: update feature.txt with apply_patch',
+  }, { invocationSource: 'model-tool', cwd: root });
+  await waitJob(spawnOut, /worker wrote feature/, 'worker write');
+
+  const sendOut = await bridge.execute({
+    type: 'send',
+    tag: 'impl1',
+    message: 'run verification: inspect feature.txt using bash',
+  }, { invocationSource: 'model-tool', cwd: root });
+  assert(/bridge job:/.test(sendOut), `completed worker send should be async job, got ${sendOut}`);
+  await waitJob(sendOut, /beta from worker/, 'worker verify');
+
+  const reviewOut = await bridge.execute({
+    type: 'spawn',
+    role: 'reviewer',
+    tag: 'rev1',
+    cwd: root,
+    prompt: 'review feature.txt for the worker change',
+  }, { invocationSource: 'model-tool', cwd: root });
+  const debugOut = await bridge.execute({
+    type: 'spawn',
+    role: 'debugger',
+    tag: 'dbg1',
+    cwd: root,
+    prompt: 'debug notes.txt timeout clue',
+  }, { invocationSource: 'model-tool', cwd: root });
+  await waitJob(reviewOut, /reviewer ok/, 'reviewer');
+  await waitJob(debugOut, /debugger TODO/, 'debugger');
+
+  const parallelSpawns = await Promise.all([
+    bridge.execute({
+      type: 'spawn',
+      role: 'worker',
+      tag: 'parWorker',
+      cwd: root,
+      prompt: 'parallel slow worker task',
+    }, { invocationSource: 'model-tool', cwd: root }),
+    bridge.execute({
+      type: 'spawn',
+      role: 'reviewer',
+      tag: 'parReviewer',
+      cwd: root,
+      prompt: 'parallel slow review task',
+    }, { invocationSource: 'model-tool', cwd: root }),
+    bridge.execute({
+      type: 'spawn',
+      role: 'debugger',
+      tag: 'parDebugger',
+      cwd: root,
+      prompt: 'parallel slow debug task',
+    }, { invocationSource: 'model-tool', cwd: root }),
+  ]);
+  assert(parallelSpawns.every((out) => /bridge job:/.test(out)), `parallel spawns must return jobs: ${parallelSpawns.join('\n---\n')}`);
+  await Promise.all([
+    waitJob(parallelSpawns[0], /ack worker/, 'parallel worker'),
+    waitJob(parallelSpawns[1], /reviewer ok/, 'parallel reviewer'),
+    waitJob(parallelSpawns[2], /debugger TODO/, 'parallel debugger'),
+  ]);
+  assert(maxActiveAsks >= 2, `bridge workers did not overlap; maxActiveAsks=${maxActiveAsks}`);
+
+  const busyOut = await bridge.execute({
+    type: 'spawn',
+    role: 'worker',
+    tag: 'busy1',
+    cwd: root,
+    prompt: 'long busy worker task',
+  }, { invocationSource: 'model-tool', cwd: root });
+  const queued = await bridge.execute({
+    type: 'send',
+    tag: 'busy1',
+    message: 'follow-up while still busy',
+  }, { invocationSource: 'model-tool', cwd: root });
+  assert(/bridge message queued/.test(queued), `busy send should queue, got ${queued}`);
+  await waitJob(busyOut, /ack worker/, 'busy worker');
+
+  const missing = await bridge.execute({ type: 'read', jobId: 'job_missing_live_smoke' }, { invocationSource: 'model-tool', cwd: root });
+  assert(/^Error[\s:[]/.test(missing), 'missing bridge job should be Error result');
+  assert(readFileSync(join(root, 'feature.txt'), 'utf8').includes('beta from worker'), 'final file missing worker edit');
+  bridge.closeAll('live-worker-smoke-end');
+  process.stdout.write('live worker smoke passed\n');
+}
+
+try {
+  await main();
+} finally {
+  rmSync(root, { recursive: true, force: true });
+}

package/scripts/output-style-smoke.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const require = createRequire(import.meta.url);
+const rulesBuilder = require('../src/lib/rules-builder.cjs');
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function assertCleanOutput(name, value, { maxLines = 2, maxBullets = 3 } = {}) {
+  const text = String(value || '').trim();
+  assert(text, `${name}: empty output`);
+  assert(!/\n\s*\n/.test(text), `${name}: multiple paragraphs are not compact`);
+  assert(!/^\s*#{1,6}\s/m.test(text), `${name}: heading found`);
+  assert(!/^\s*\d+[.)]\s/m.test(text), `${name}: numbered list found`);
+  assert(!/^\s{2,}[-*]\s/m.test(text), `${name}: nested bullet found`);
+  assert(!/^\s*[\p{L}\p{N}][\p{L}\p{N} _-]{0,30}:\s/um.test(text), `${name}: report label found`);
+  assert(!/\b(?:tool trace|session metadata|model metadata|searched-path list)\b/i.test(text), `${name}: tool/meta trace found`);
+  assert(!/\b(?:Mapped|Searched|Read|Called) for \d/i.test(text), `${name}: timing/tool status found`);
+  assert(!/^(?:네|예|맞아요|좋아요|알겠습니다|Sure|Okay|Understood)[,.\s]/i.test(text), `${name}: acknowledgment preface found`);
+  assert(!/(.+)(?:\n|\s{2,})\1/.test(text), `${name}: repeated conclusion found`);
+
+  const lines = text.split(/\r?\n/).filter((line) => line.trim());
+  const bulletLines = lines.filter((line) => /^\s*[-*]\s+/.test(line));
+  if (bulletLines.length > 0) {
+    assert(bulletLines.length === lines.length, `${name}: mixed prose and bullets`);
+    assert(bulletLines.length <= maxBullets, `${name}: too many bullets`);
+    return;
+  }
+  assert(lines.length <= maxLines, `${name}: too many lines`);
+
+  const withoutCode = text.replace(/`[^`]*`/g, '');
+  const sentenceMarks = withoutCode.match(/[.!?。！？]|다\.|요\./g) || [];
+  assert(sentenceMarks.length <= 2, `${name}: too many sentences`);
+}
+
+const defaultStyle = readFileSync(join(root, 'src', 'output-styles', 'default.md'), 'utf8');
+for (const required of [
+  'name: default',
+  'Uniformity beats local cleverness.',
+  'One answer only.',
+  'Hard cap user-visible replies at 2 short sentences',
+  'Explore/retrieval results are evidence only',
+  'Do not use label prefixes',
+]) {
+  assert(defaultStyle.includes(required), `default.md missing: ${required}`);
+}
+assert(!defaultStyle.includes('Claude Code-compact'), 'default.md must not reference the old compact style name');
+
+const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-output-style-smoke-'));
+try {
+  writeFileSync(join(dataDir, 'user-workflow.md'), 'workflow context should not override output style\n');
+  const leadRules = rulesBuilder.buildInjectionContent({ PLUGIN_ROOT: join(root, 'src'), DATA_DIR: dataDir });
+  const outputStyleIndex = leadRules.lastIndexOf('# Output Style');
+  assert(outputStyleIndex >= 0, 'Lead output style missing');
+  assert(outputStyleIndex > leadRules.lastIndexOf('# User Workflow'), 'Lead output style must be injected after workflow/user context');
+
+  mkdirSync(join(dataDir, 'output-styles'), { recursive: true });
+  writeFileSync(join(dataDir, 'mixdog-config.json'), JSON.stringify({ outputStyle: 'custom-smoke' }));
+  writeFileSync(join(dataDir, 'output-styles', 'custom-smoke.md'), '---\nname: custom-smoke\n---\n\n# Custom Output Style\n\ncustom smoke style\n');
+  const customRules = rulesBuilder.buildInjectionContent({ PLUGIN_ROOT: join(root, 'src'), DATA_DIR: dataDir });
+  assert(customRules.includes('# Custom Output Style'), 'configured outputStyle must select custom style');
+  assert(!customRules.includes('Default concise engineering replies'), 'custom outputStyle should not append default style');
+} finally {
+  rmSync(dataDir, { recursive: true, force: true });
+}
+
+const goodOutputs = {
+  explanation: '기본 출력은 한 문장으로 결론만 말하고, 추가 설명은 사용자가 요청할 때만 붙입니다.',
+  implementation: 'default 출력 스타일을 한 문장 우선으로 조였고 `npm run smoke:output`으로 확인했습니다.',
+  crowded: '- default 스타일은 한 문장 우선입니다.\n- 상세/후보 요청이 있을 때만 목록을 펼칩니다.',
+  blocker: '`src/output-styles/default.md`를 찾을 수 없어 변경이 막혔습니다.',
+  semicolon: '`default.md`를 다듬었고; 출력 스모크가 예시 응답 모양을 검증합니다.',
+};
+for (const [name, output] of Object.entries(goodOutputs)) assertCleanOutput(name, output);
+
+const badOutputs = {
+  heading: '## Summary\nDone.',
+  label: 'Changed: updated default style.',
+  koreanLabel: '변경: default 스타일을 수정했습니다.\n검증: 스모크를 통과했습니다.',
+  numbered: '1. Updated style\n2. Ran smoke',
+  paragraphs: 'Done.\n\nDone again.',
+  nested: '- Updated\n  - Nested detail',
+  ack: '네, default 스타일을 수정했습니다.',
+  timing: 'Mapped for 2m 32s\n\ndefault 스타일을 수정했습니다.',
+  tooManySentences: '수정했습니다. 검증했습니다. 보고했습니다.',
+  mixed: '수정했습니다.\n- 검증했습니다.',
+};
+for (const [name, output] of Object.entries(badOutputs)) {
+  let failed = false;
+  try { assertCleanOutput(`bad:${name}`, output); } catch { failed = true; }
+  assert(failed, `bad sample unexpectedly passed: ${name}`);
+}
+
+process.stdout.write(`output style smoke passed samples=${Object.keys(goodOutputs).length}\n`);

package/scripts/smoke-loop-report.mjs

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+function argValue(name, fallback = null) {
+  const idx = process.argv.indexOf(name);
+  if (idx >= 0 && idx + 1 < process.argv.length) return process.argv[idx + 1];
+  const prefix = `${name}=`;
+  const hit = process.argv.find((arg) => arg.startsWith(prefix));
+  return hit ? hit.slice(prefix.length) : fallback;
+}
+
+function parseNumber(value, fallback = null) {
+  if (value == null || value === '') return fallback;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+function parseDuration(value, fallback = null) {
+  const raw = String(value || '').trim();
+  if (!raw) return fallback;
+  if (/^\d+$/.test(raw)) return Number(raw);
+  const match = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/i);
+  if (!match) throw new Error(`invalid duration: ${raw}`);
+  const n = Number(match[1]);
+  const unit = match[2].toLowerCase();
+  const mult = unit === 'ms' ? 1 : unit === 's' ? 1000 : unit === 'm' ? 60_000 : 3_600_000;
+  return Math.max(1, Math.floor(n * mult));
+}
+
+function argValues(name) {
+  const values = [];
+  const prefix = `${name}=`;
+  for (let i = 0; i < process.argv.length; i += 1) {
+    const arg = process.argv[i];
+    if (arg === name && i + 1 < process.argv.length) values.push(process.argv[i + 1]);
+    else if (arg.startsWith(prefix)) values.push(arg.slice(prefix.length));
+  }
+  return values;
+}
+
+function parseStepCaps(values) {
+  const caps = new Map();
+  for (const value of values) {
+    const raw = String(value || '').trim();
+    if (!raw) continue;
+    const idx = raw.lastIndexOf('=');
+    if (idx <= 0) throw new Error(`invalid --max-step-ms value: ${raw}`);
+    const name = raw.slice(0, idx).trim().replace(/^scripts\//, '');
+    const cap = Number(raw.slice(idx + 1).trim());
+    if (!name || !Number.isFinite(cap) || cap < 0) throw new Error(`invalid --max-step-ms value: ${raw}`);
+    caps.set(name, cap);
+  }
+  return caps;
+}
+
+function summarize(values) {
+  if (!values.length) return { min: 0, max: 0, avg: 0 };
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const avg = values.reduce((sum, value) => sum + value, 0) / values.length;
+  return {
+    min: Math.round(min * 10) / 10,
+    max: Math.round(max * 10) / 10,
+    avg: Math.round(avg * 10) / 10,
+  };
+}
+
+function readRows(path) {
+  if (!existsSync(path)) throw new Error(`smoke loop log not found: ${path}`);
+  return readFileSync(path, 'utf8')
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line, index) => {
+      try {
+        return JSON.parse(line);
+      } catch (error) {
+        return { type: 'parse_error', line: index + 1, error: error?.message || String(error), raw: line };
+      }
+    });
+}
+
+function formatDuration(ms) {
+  const total = Math.max(0, Math.round(Number(ms) || 0));
+  const h = Math.floor(total / 3_600_000);
+  const m = Math.floor((total % 3_600_000) / 60_000);
+  const s = Math.floor((total % 60_000) / 1000);
+  if (h > 0) return `${h}h ${m}m ${s}s`;
+  if (m > 0) return `${m}m ${s}s`;
+  return `${s}s`;
+}
+
+function summarizeSteps(iterations) {
+  const byScript = new Map();
+  for (const row of iterations) {
+    if (!Array.isArray(row.steps)) continue;
+    for (const step of row.steps) {
+      const script = String(step?.script || '').replace(/^scripts\//, '');
+      const ms = Number(step?.ms);
+      if (!script || !Number.isFinite(ms)) continue;
+      const values = byScript.get(script) || [];
+      values.push(ms);
+      byScript.set(script, values);
+    }
+  }
+  return Object.fromEntries([...byScript.entries()].map(([script, values]) => [script, summarize(values)]));
+}
+
+const logPath = resolve(argValue('--log', '.mixdog/data/history/smoke-loop.jsonl'));
+const pidArg = parseNumber(argValue('--pid', null), null);
+const minIterations = parseNumber(argValue('--min-iterations', null), null);
+const minElapsedMs = parseDuration(argValue('--min-elapsed', null), null);
+const maxGapMs = parseDuration(argValue('--max-gap', null), null);
+const maxStaleMs = parseDuration(argValue('--max-stale', null), null);
+const maxSmokeMs = parseNumber(argValue('--max-smoke-ms', null), null);
+const maxAvgSmokeMs = parseNumber(argValue('--max-avg-smoke-ms', null), null);
+const maxStepMs = parseStepCaps(argValues('--max-step-ms'));
+const maxRssMb = parseNumber(argValue('--max-rss-mb', null), null);
+const maxRssGrowthMb = parseNumber(argValue('--max-rss-growth-mb', null), null);
+const jsonMode = process.argv.includes('--json');
+const requireComplete = process.argv.includes('--require-complete');
+
+const rows = readRows(logPath);
+const startRows = rows.filter((row) => row?.type === 'start' && (pidArg == null || Number(row.pid) === pidArg));
+const start = startRows.at(-1);
+if (!start) throw new Error(pidArg == null ? 'no smoke loop start row found' : `no smoke loop start row found for pid ${pidArg}`);
+
+const startIndex = rows.lastIndexOf(start);
+const runRows = rows.slice(startIndex).filter((row) => Number(row.pid) === Number(start.pid));
+const iterations = runRows.filter((row) => row?.type === 'iteration');
+const errors = runRows.filter((row) => row?.type === 'error' || row?.type === 'parse_error');
+const summaryRows = runRows.filter((row) => row?.type === 'summary');
+const last = iterations.at(-1) || null;
+const smoke = summarize(iterations.map((row) => Number(row.smoke_ms)).filter(Number.isFinite));
+const stepMs = summarizeSteps(iterations);
+const rss = summarize(iterations.map((row) => Number(row.rss_mb)).filter(Number.isFinite));
+const startRss = Number(start.rss_mb);
+const lastRss = Number(last?.rss_mb);
+const rssGrowth = Number.isFinite(startRss) && Number.isFinite(lastRss)
+  ? Math.round((lastRss - startRss) * 10) / 10
+  : 0;
+const elapsedMs = Number(last?.elapsed_ms || summaryRows.at(-1)?.elapsed_ms || 0);
+const durationMs = Number(start.duration_ms || 0);
+const remainingMs = durationMs > 0 ? Math.max(0, durationMs - elapsedMs) : null;
+const startTs = Date.parse(start.ts);
+const finishAt = durationMs > 0 && Number.isFinite(startTs)
+  ? new Date(startTs + durationMs).toISOString()
+  : null;
+const iterationsPerHour = elapsedMs > 0
+  ? Math.round((iterations.length / (elapsedMs / 3_600_000)) * 10) / 10
+  : 0;
+const gaps = [];
+for (let i = 1; i < iterations.length; i += 1) {
+  const prev = Date.parse(iterations[i - 1].ts);
+  const cur = Date.parse(iterations[i].ts);
+  if (Number.isFinite(prev) && Number.isFinite(cur)) gaps.push(cur - prev);
+}
+const gapSummary = summarize(gaps);
+const lastTs = Date.parse(last?.ts || '');
+const staleMs = Number.isFinite(lastTs) ? Date.now() - lastTs : null;
+
+const failures = [];
+if (errors.length > 0) failures.push(`errors=${errors.length}`);
+if (requireComplete && summaryRows.length === 0) failures.push('loop has no completed summary row');
+if (minIterations != null && iterations.length < minIterations) failures.push(`iterations ${iterations.length} < ${minIterations}`);
+if (minElapsedMs != null && elapsedMs < minElapsedMs) failures.push(`elapsed ${formatDuration(elapsedMs)} < ${formatDuration(minElapsedMs)}`);
+if (maxGapMs != null && gapSummary.max > maxGapMs) failures.push(`max gap ${formatDuration(gapSummary.max)} > ${formatDuration(maxGapMs)}`);
+if (maxStaleMs != null && staleMs != null && staleMs > maxStaleMs) failures.push(`latest iteration stale ${formatDuration(staleMs)} > ${formatDuration(maxStaleMs)}`);
+if (maxSmokeMs != null && smoke.max > maxSmokeMs) failures.push(`smoke max ${smoke.max}ms > ${maxSmokeMs}ms`);
+if (maxAvgSmokeMs != null && smoke.avg > maxAvgSmokeMs) failures.push(`smoke avg ${smoke.avg}ms > ${maxAvgSmokeMs}ms`);
+for (const [script, cap] of maxStepMs.entries()) {
+  const stats = stepMs[script];
+  if (stats && stats.max > cap) failures.push(`${script} max ${stats.max}ms > ${cap}ms`);
+}
+if (maxRssMb != null && rss.max > maxRssMb) failures.push(`rss max ${rss.max}MB > ${maxRssMb}MB`);
+if (maxRssGrowthMb != null && rssGrowth > maxRssGrowthMb) failures.push(`rss growth ${rssGrowth}MB > ${maxRssGrowthMb}MB`);
+
+const report = {
+  ok: failures.length === 0,
+  pid: start.pid,
+  started_at: start.ts,
+  finish_at: finishAt,
+  elapsed_ms: elapsedMs,
+  elapsed: formatDuration(elapsedMs),
+  remaining_ms: remainingMs,
+  remaining: remainingMs == null ? null : formatDuration(remainingMs),
+  min_elapsed_ms: minElapsedMs,
+  iterations: iterations.length,
+  iterations_per_hour: iterationsPerHour,
+  duration_ms: start.duration_ms,
+  interval_ms: start.interval_ms,
+  smoke_ms: smoke,
+  step_ms: stepMs,
+  max_step_ms: Object.fromEntries(maxStepMs.entries()),
+  rss_mb: rss,
+  rss_growth_mb: rssGrowth,
+  gap_ms: gapSummary,
+  stale_ms: staleMs,
+  errors: errors.length,
+  completed: summaryRows.length > 0,
+  require_complete: requireComplete,
+  latest_iteration: last?.iteration || 0,
+  failures,
+};
+
+if (jsonMode) {
+  console.log(JSON.stringify(report, null, 2));
+} else {
+  console.log(`smoke loop report pid=${report.pid} ok=${report.ok}`);
+  console.log(`started=${report.started_at} finish=${report.finish_at || '-'} elapsed=${report.elapsed} remaining=${report.remaining || '-'} iterations=${report.iterations} rate=${iterationsPerHour}/h completed=${report.completed}`);
+  console.log(`smoke_ms min=${smoke.min} avg=${smoke.avg} max=${smoke.max}`);
+  for (const [script, stats] of Object.entries(stepMs)) {
+    console.log(`${script} min=${stats.min} avg=${stats.avg} max=${stats.max}`);
+  }
+  console.log(`rss_mb min=${rss.min} avg=${rss.avg} max=${rss.max} growth=${rssGrowth}`);
+  console.log(`gap_ms min=${gapSummary.min} avg=${gapSummary.avg} max=${gapSummary.max} stale=${staleMs == null ? '-' : staleMs}`);
+  console.log(`errors=${errors.length}`);
+  if (failures.length) console.log(`failures: ${failures.join('; ')}`);
+}
+
+if (failures.length) process.exit(1);