opencroc 1.5.1 → 1.6.1

package/dist/cli/index.js

@@ -1729,6 +1729,7 @@ var init_ollama = __esm({
 });
 
 // src/llm/index.ts
+var SYSTEM_PROMPTS;
 var init_llm = __esm({
   "src/llm/index.ts"() {
     "use strict";
@@ -1737,36 +1738,336 @@ var init_llm = __esm({
     init_ollama();
     init_openai();
     init_ollama();
+    SYSTEM_PROMPTS = {
+      failureAnalysis: `You are an expert test failure analyst for an E2E testing framework.
+Given a test failure error message and its context, analyze the root cause and suggest a fix.
+Respond in JSON format: { "rootCause": string, "category": string, "suggestedFix": string, "confidence": number }
+Categories: backend-5xx, timeout, endpoint-not-found, data-constraint, network, frontend-render, test-script, unknown.`,
+      chainPlanning: `You are an API test chain planner.
+Given a list of API endpoints and their dependencies, generate an optimal test execution order.
+Consider data dependencies, authentication requirements, and cleanup steps.
+Respond in JSON format: { "chains": [{ "name": string, "steps": [{ "endpoint": string, "method": string, "description": string }] }] }`
+    };
   }
 });
 
 // src/self-healing/dialog-loop-runner.ts
+function createJsonResultParser() {
+  return {
+    parse(stdout2) {
+      const failures = [];
+      const lines = stdout2.split("\n");
+      for (const line of lines) {
+        const failMatch = line.match(/[✘✗×]\s+.*?›\s+(.+)/);
+        if (failMatch) {
+          failures.push({
+            title: failMatch[1].trim(),
+            error: failMatch[1].trim()
+          });
+        }
+      }
+      return failures;
+    },
+    countTotal(stdout2) {
+      let total = 0;
+      const passMatch = stdout2.match(/(\d+)\s+passed/);
+      const failMatch = stdout2.match(/(\d+)\s+failed/);
+      if (passMatch) total += parseInt(passMatch[1], 10);
+      if (failMatch) total += parseInt(failMatch[1], 10);
+      return total || 1;
+    }
+  };
+}
+async function runDialogLoop(options) {
+  const cfg = { ...DEFAULTS2, ...options.config };
+  const { runner, parser, fixer } = options;
+  const history = [];
+  const errorTracker = /* @__PURE__ */ new Map();
+  for (let iteration = 1; iteration <= cfg.maxIterations + 1; iteration++) {
+    const iterStart = Date.now();
+    const { stdout: stdout2 } = await runner.run();
+    const failures = parser.parse(stdout2);
+    const totalTests = parser.countTotal(stdout2);
+    const passed = totalTests - failures.length;
+    const iterResult = {
+      iteration,
+      totalTests,
+      passed,
+      failed: failures.length,
+      failedTests: failures.map((f) => f.title),
+      fixesApplied: [],
+      durationMs: 0
+    };
+    if (failures.length === 0) {
+      iterResult.durationMs = Date.now() - iterStart;
+      history.push(iterResult);
+      options.onIteration?.(iterResult);
+      break;
+    }
+    if (iteration > cfg.maxIterations) {
+      iterResult.durationMs = Date.now() - iterStart;
+      history.push(iterResult);
+      options.onIteration?.(iterResult);
+      break;
+    }
+    const newFailures = failures.filter((f) => {
+      const key = `${f.title}::${f.error}`;
+      const count = (errorTracker.get(key) ?? 0) + 1;
+      errorTracker.set(key, count);
+      return count <= cfg.sameErrorThreshold;
+    });
+    if (newFailures.length === 0) {
+      iterResult.durationMs = Date.now() - iterStart;
+      history.push(iterResult);
+      options.onIteration?.(iterResult);
+      break;
+    }
+    for (const failure of newFailures) {
+      const outcome = await fixer.apply(failure);
+      if (outcome.success) {
+        iterResult.fixesApplied.push(failure.title);
+      }
+    }
+    iterResult.durationMs = Date.now() - iterStart;
+    history.push(iterResult);
+    options.onIteration?.(iterResult);
+    if (iterResult.fixesApplied.length === 0 || !cfg.autoRerunOnFix) {
+      break;
+    }
+  }
+  const final = history[history.length - 1];
+  const totalFixesApplied = history.reduce((sum, h) => sum + h.fixesApplied.length, 0);
+  return {
+    iterations: history,
+    finalPassed: final?.passed ?? 0,
+    finalFailed: final?.failed ?? 0,
+    totalFixesApplied,
+    success: (final?.failed ?? 1) === 0
+  };
+}
+var DEFAULTS2;
 var init_dialog_loop_runner = __esm({
   "src/self-healing/dialog-loop-runner.ts"() {
     "use strict";
     init_esm_shims();
+    DEFAULTS2 = {
+      maxIterations: 3,
+      pollIntervalMs: 1e4,
+      sameErrorThreshold: 2,
+      autoRerunOnFix: true
+    };
   }
 });
 
 // src/self-healing/controlled-fixer.ts
 import { existsSync as existsSync8, copyFileSync, readFileSync as readFileSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync } from "fs";
 import { dirname as dirname2 } from "path";
+async function applyControlledFix(opts) {
+  const fs8 = opts.fs ?? defaultFs;
+  const scope = opts.options?.scope ?? "config-only";
+  const dryRun = opts.options?.dryRun ?? true;
+  const verify = opts.options?.verify ?? true;
+  const configPath = opts.configPath;
+  const backupPath = configPath + ".backup";
+  if (!fs8.exists(configPath)) {
+    return { success: false, scope, fixedItems: [], rolledBack: false, error: `Config file not found: ${configPath}` };
+  }
+  const originalContent = fs8.read(configPath);
+  fs8.write(backupPath, originalContent);
+  const validation = opts.validator.validate(originalContent);
+  if (validation.passed) {
+    cleanup(fs8, backupPath);
+    return { success: true, scope, fixedItems: [], rolledBack: false };
+  }
+  let fixResult;
+  try {
+    fixResult = opts.fixer.fix(originalContent, validation.errors);
+  } catch (err) {
+    rollback(fs8, backupPath, configPath);
+    return { success: false, scope, fixedItems: [], rolledBack: true, error: `Fix threw: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  if (!fixResult.success) {
+    rollback(fs8, backupPath, configPath);
+    return { success: false, scope, fixedItems: fixResult.fixedItems, rolledBack: true, error: `Remaining errors: ${fixResult.remainingErrors.join("; ")}` };
+  }
+  if (dryRun) {
+    const dryValidation = opts.validator.validate(fixResult.fixedContent);
+    if (!dryValidation.passed) {
+      rollback(fs8, backupPath, configPath);
+      return { success: false, scope, fixedItems: fixResult.fixedItems, rolledBack: true, error: `Dry-run validation failed: ${dryValidation.errors.join("; ")}` };
+    }
+  }
+  fs8.write(configPath, fixResult.fixedContent);
+  if (verify) {
+    const reloaded = fs8.read(configPath);
+    const postValidation = opts.validator.validate(reloaded);
+    if (!postValidation.passed) {
+      rollback(fs8, backupPath, configPath);
+      return { success: false, scope, fixedItems: fixResult.fixedItems, rolledBack: true, error: `Post-write verification failed: ${postValidation.errors.join("; ")}` };
+    }
+  }
+  cleanup(fs8, backupPath);
+  let prUrl;
+  if (scope === "config-and-source" && opts.attribution && opts.prGenerator) {
+    try {
+      prUrl = await opts.prGenerator.generate(opts.attribution);
+    } catch {
+    }
+  }
+  return { success: true, scope, fixedItems: fixResult.fixedItems, rolledBack: false, prUrl };
+}
+function rollback(fs8, backupPath, configPath) {
+  if (fs8.exists(backupPath)) {
+    const backup = fs8.read(backupPath);
+    fs8.write(configPath, backup);
+    fs8.remove(backupPath);
+  }
+}
+function cleanup(fs8, backupPath) {
+  if (fs8.exists(backupPath)) {
+    fs8.remove(backupPath);
+  }
+}
+var defaultFs;
 var init_controlled_fixer = __esm({
   "src/self-healing/controlled-fixer.ts"() {
     "use strict";
     init_esm_shims();
+    defaultFs = {
+      exists: existsSync8,
+      read: (p) => readFileSync2(p, "utf-8"),
+      write: (p, c) => {
+        mkdirSync3(dirname2(p), { recursive: true });
+        writeFileSync3(p, c, "utf-8");
+      },
+      copy: copyFileSync,
+      remove: unlinkSync,
+      mkdirp: (d) => mkdirSync3(d, { recursive: true })
+    };
   }
 });
 
 // src/self-healing/auto-fix-generator.ts
+async function generateFixPR(attribution, git, patchWriter, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const branch = `${opts.branchPrefix}${ts}`;
+  const patchFile = `report/patch-${ts}.patch`;
+  await git.exec("git", ["checkout", "-b", branch]);
+  await patchWriter.mkdir("report");
+  await patchWriter.write(patchFile, attribution.fixSuggestion.codePatch);
+  try {
+    await git.exec("git", ["apply", patchFile]);
+  } catch {
+  }
+  await git.exec("git", ["add", "."]);
+  await git.exec("git", ["commit", "-m", `fix: AI auto-patch for "${attribution.testName}"`]);
+  await git.exec("git", ["push", "origin", branch]);
+  const prArgs = [
+    "pr",
+    "create",
+    "--draft",
+    "--title",
+    `[AI Fix] ${attribution.testName}`,
+    "--body",
+    buildPRBody(attribution)
+  ];
+  const { stdout: prUrl } = await git.exec("gh", prArgs);
+  await git.exec("git", ["checkout", opts.baseBranch]);
+  return { prUrl: prUrl.trim(), branch, patchFile };
+}
+function buildPRBody(a) {
+  return [
+    "## AI Auto-Fix PR",
+    "",
+    `**Test:** ${a.testName}`,
+    `**Category:** ${a.category} | **Severity:** ${a.severity} | **Confidence:** ${(a.confidence * 100).toFixed(0)}%`,
+    "",
+    "### Root Cause",
+    a.rootCause,
+    "",
+    "### Fix",
+    a.fixSuggestion.description,
+    "",
+    "---",
+    "> This PR was auto-generated by AI and **must be reviewed before merging**."
+  ].join("\n");
+}
+var DEFAULT_OPTIONS;
 var init_auto_fix_generator = __esm({
   "src/self-healing/auto-fix-generator.ts"() {
     "use strict";
     init_esm_shims();
+    DEFAULT_OPTIONS = {
+      branchPrefix: "autofix/",
+      baseBranch: "main",
+      draftOnly: true
+    };
   }
 });
 
 // src/self-healing/index.ts
+var self_healing_exports = {};
+__export(self_healing_exports, {
+  analyzeFailureWithLLM: () => analyzeFailureWithLLM,
+  applyControlledFix: () => applyControlledFix,
+  categorizeFailure: () => categorizeFailure,
+  createJsonResultParser: () => createJsonResultParser,
+  createSelfHealingLoop: () => createSelfHealingLoop,
+  generateFixPR: () => generateFixPR,
+  runDialogLoop: () => runDialogLoop
+});
+function categorizeFailure(errorMessage) {
+  const msg = errorMessage.toLowerCase();
+  if (/5\d{2}|internal server error/.test(msg))
+    return { category: "backend-5xx", confidence: 0.9 };
+  if (/timeout|timed?\s*out/.test(msg))
+    return { category: "timeout", confidence: 0.8 };
+  if (/404|not found/.test(msg))
+    return { category: "endpoint-not-found", confidence: 0.85 };
+  if (/4[0-2]\d|validation|constraint/.test(msg))
+    return { category: "data-constraint", confidence: 0.75 };
+  if (/econnrefused|enotfound|network/.test(msg))
+    return { category: "network", confidence: 0.9 };
+  if (/selector|locator|element/.test(msg))
+    return { category: "frontend-render", confidence: 0.7 };
+  if (/storage\s*state|auth|login/.test(msg))
+    return { category: "test-script", confidence: 0.8 };
+  return { category: "unknown", confidence: 0.5 };
+}
+async function analyzeFailureWithLLM(errorMessage, llm) {
+  const heuristic = categorizeFailure(errorMessage);
+  if (!llm) {
+    return {
+      rootCause: errorMessage,
+      category: heuristic.category,
+      suggestedFix: "",
+      confidence: heuristic.confidence
+    };
+  }
+  try {
+    const response = await llm.chat([
+      { role: "system", content: SYSTEM_PROMPTS.failureAnalysis },
+      { role: "user", content: `Analyze this test failure:
+
+${errorMessage}` }
+    ]);
+    const parsed = JSON.parse(response);
+    return {
+      rootCause: parsed.rootCause || errorMessage,
+      category: parsed.category || heuristic.category,
+      suggestedFix: parsed.suggestedFix || "",
+      confidence: parsed.confidence || heuristic.confidence
+    };
+  } catch {
+    return {
+      rootCause: errorMessage,
+      category: heuristic.category,
+      suggestedFix: "",
+      confidence: heuristic.confidence
+    };
+  }
+}
 async function attemptConfigFix(_testResultsDir, _mode, _llm) {
   return {
     success: false,
@@ -1868,6 +2169,13 @@ var init_heal = __esm({
 });
 
 // src/ci/index.ts
+var ci_exports = {};
+__export(ci_exports, {
+  generateCiTemplate: () => generateCiTemplate,
+  generateGitHubActionsTemplate: () => generateGitHubActionsTemplate,
+  generateGitLabCITemplate: () => generateGitLabCITemplate,
+  listCiPlatforms: () => listCiPlatforms
+});
 function generateGitHubActionsTemplate(opts = {}) {
   const nodeVersions = opts.nodeVersions ?? ["20.x"];
   const install = opts.installCommand ?? "npm ci";
@@ -1997,8 +2305,8 @@ var init_ci = __esm({
 });
 
 // src/cli/commands/ci.ts
-var ci_exports = {};
-__export(ci_exports, {
+var ci_exports2 = {};
+__export(ci_exports2, {
   ci: () => ci
 });
 import * as fs5 from "fs";
@@ -2044,6 +2352,143 @@ var init_ci2 = __esm({
 });
 
 // src/reporters/checklist-reporter.ts
+function classifyFailure(error) {
+  if (!error) return "other";
+  if (error.includes("[BACKEND_5XX]")) return "backend-5xx";
+  if (error.includes("[MIXED_5XX]")) return "mixed-5xx";
+  if (error.includes("[SLOW_API_FATAL]")) return "slow-api";
+  if (error.includes("[LOG_COMPLETION_FAIL]")) return "log-fail";
+  if (error.includes("[LOG_COMPLETION_TIMEOUT]")) return "log-timeout";
+  if (/waitForSelector|toHaveURL|Timeout/i.test(error)) return "frontend-load";
+  return "other";
+}
+function buildFailureSummary(records) {
+  const failed = records.filter((r) => r.status === "failed");
+  const cats = failed.map((r) => classifyFailure(r.error));
+  return {
+    totalFailed: failed.length,
+    backend5xx: cats.filter((c) => c === "backend-5xx").length,
+    mixed5xx: cats.filter((c) => c === "mixed-5xx").length,
+    slowApi: cats.filter((c) => c === "slow-api").length,
+    logFail: cats.filter((c) => c === "log-fail").length,
+    logTimeout: cats.filter((c) => c === "log-timeout").length,
+    frontendLoad: cats.filter((c) => c === "frontend-load").length,
+    other: cats.filter((c) => c === "other").length
+  };
+}
+function aggregateLogCompletion(records) {
+  let totalCandidates = 0;
+  let succeeded = 0;
+  let failed = 0;
+  let timedOut = 0;
+  const timedOutFreq = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const lc = r.logCompletion;
+    if (!lc || lc.candidateCount === 0) continue;
+    totalCandidates += lc.candidateCount;
+    succeeded += lc.succeeded.length;
+    failed += lc.failed.length;
+    timedOut += lc.timedOut.length;
+    for (const item of lc.timedOut) {
+      const key = `${item.method}:${item.path}`;
+      const existing = timedOutFreq.get(key);
+      if (existing) existing.count += 1;
+      else timedOutFreq.set(key, { method: item.method, path: item.path, count: 1 });
+    }
+  }
+  const timedOutTop5 = Array.from(timedOutFreq.values()).sort((a, b) => b.count - a.count).slice(0, 5).map((t) => ({ method: t.method, path: t.path, occurrences: t.count }));
+  const matchRate = totalCandidates > 0 ? (succeeded + failed) / totalCandidates * 100 : 0;
+  const effectiveRate = totalCandidates > 0 ? succeeded / totalCandidates * 100 : 0;
+  return { totalCandidates, succeeded, failed, timedOut, matchRate, effectiveRate, timedOutTop5 };
+}
+function extractUrls(error) {
+  if (!error) return [];
+  const matched = error.match(/https?:\/\/[^\s\n]+/g);
+  return matched ? Array.from(new Set(matched)) : [];
+}
+function parseApiDomain(urlStr) {
+  try {
+    const u = new URL(urlStr);
+    const segments = u.pathname.split("/").filter(Boolean);
+    const v1Index = segments.findIndex((s) => s === "v1");
+    if (v1Index === -1 || v1Index + 1 >= segments.length) return segments[0] || null;
+    const afterV1 = segments.slice(v1Index + 1);
+    if (afterV1.length === 0) return null;
+    const first = afterV1[0];
+    if (/^\d+$/.test(first) && afterV1.length > 1) return afterV1[1];
+    return first;
+  } catch {
+    return null;
+  }
+}
+function buildBackendChecklist(records) {
+  const domainMap = /* @__PURE__ */ new Map();
+  const failed = records.filter((r) => r.status === "failed");
+  for (const item of failed) {
+    const cat = classifyFailure(item.error);
+    if (cat !== "backend-5xx" && cat !== "mixed-5xx") continue;
+    const urls = extractUrls(item.error);
+    for (const url of urls) {
+      const domain = parseApiDomain(url);
+      if (!domain) continue;
+      const current = domainMap.get(domain) ?? { tests: /* @__PURE__ */ new Set(), endpoints: /* @__PURE__ */ new Set() };
+      current.tests.add(item.title);
+      current.endpoints.add(url);
+      domainMap.set(domain, current);
+    }
+  }
+  return Array.from(domainMap.entries()).map(([domain, v]) => ({
+    domain,
+    tests: Array.from(v.tests).sort(),
+    endpoints: Array.from(v.endpoints).sort()
+  })).sort((a, b) => b.tests.length - a.tests.length || a.domain.localeCompare(b.domain));
+}
+function renderChecklistMarkdown(items, summary, logSummary) {
+  const lines = [
+    "# Backend Fix Checklist",
+    ""
+  ];
+  if (logSummary) {
+    lines.push(
+      `- Log match rate: ${logSummary.matchRate.toFixed(2)}% (candidates=${logSummary.totalCandidates}, succeeded=${logSummary.succeeded}, failed=${logSummary.failed}, timedOut=${logSummary.timedOut})`,
+      `- Effective success rate: ${logSummary.effectiveRate.toFixed(2)}%`
+    );
+  }
+  lines.push(
+    `- Backend 5xx: ${summary.backend5xx}`,
+    `- Mixed 5xx: ${summary.mixed5xx}`,
+    `- Slow API: ${summary.slowApi}`,
+    `- Log fail: ${summary.logFail}`,
+    `- Log timeout: ${summary.logTimeout}`,
+    `- Frontend load: ${summary.frontendLoad}`,
+    `- Other: ${summary.other}`,
+    ""
+  );
+  if (logSummary && logSummary.timedOutTop5.length > 0) {
+    lines.push("### Timed-out APIs Top 5", "", "| # | Method | Path | Occurrences |", "|---|--------|------|-------------|");
+    logSummary.timedOutTop5.forEach((t, i) => {
+      lines.push(`| ${i + 1} | ${t.method} | ${t.path} | ${t.occurrences} |`);
+    });
+    lines.push("");
+  }
+  if (items.length === 0) {
+    lines.push("No backend 5xx failures this run.");
+    return lines.join("\n") + "\n";
+  }
+  for (const item of items) {
+    lines.push(
+      `## ${item.domain}`,
+      "",
+      `- Failed tests: ${item.tests.length}`,
+      "- Affected tests:"
+    );
+    for (const t of item.tests) lines.push(`  - ${t}`);
+    lines.push("- Failed endpoints:");
+    for (const e of item.endpoints) lines.push(`  - ${e}`);
+    lines.push("");
+  }
+  return lines.join("\n") + "\n";
+}
 var init_checklist_reporter = __esm({
   "src/reporters/checklist-reporter.ts"() {
     "use strict";
@@ -2052,6 +2497,99 @@ var init_checklist_reporter = __esm({
 });
 
 // src/reporters/workorder-reporter.ts
+function assignPriority(item, isLogRate) {
+  if (isLogRate) return "P0";
+  if (item.tests.length >= 3) return "P0";
+  if (item.tests.length === 2) return "P1";
+  return "P2";
+}
+function buildWorkorders(opts) {
+  const { checklist, logSummary, logRateThreshold = 90 } = opts;
+  const result = [];
+  let idx = 1;
+  if (logSummary && logSummary.totalCandidates > 0 && logSummary.matchRate < logRateThreshold) {
+    const logItem = {
+      domain: "Log Completion Standards",
+      tests: logSummary.timedOutTop5.map((t) => `${t.method} ${t.path} (\xD7${t.occurrences})`),
+      endpoints: logSummary.timedOutTop5.map((t) => t.path)
+    };
+    result.push({
+      index: idx++,
+      domain: logItem.domain,
+      priority: "P0",
+      tests: logItem.tests,
+      endpoints: logItem.endpoints,
+      objective: "Add missing end-phase structured logs for timed-out APIs",
+      acceptanceCriteria: [
+        `Log completion match rate \u2265 ${logRateThreshold}%`,
+        "TimedOut API count drops to 0 or only SSE/long-polling endpoints remain"
+      ]
+    });
+  }
+  for (const item of checklist) {
+    const priority = assignPriority(item, false);
+    result.push({
+      index: idx++,
+      domain: item.domain,
+      priority,
+      tests: item.tests,
+      endpoints: item.endpoints,
+      objective: "Fix 500 errors and return a valid business response",
+      acceptanceCriteria: [
+        "HTTP status returns 2xx for affected endpoints",
+        "No [BACKEND_5XX] errors in corresponding page traversal",
+        "All covered tests pass"
+      ]
+    });
+  }
+  return result;
+}
+function renderWorkordersMarkdown(workorders, summary, logSummary) {
+  const lines = [
+    "# Backend Work Orders",
+    ""
+  ];
+  if (logSummary) {
+    lines.push(
+      `- Log match rate: ${logSummary.matchRate.toFixed(2)}%`,
+      `- Effective success rate: ${logSummary.effectiveRate.toFixed(2)}%`
+    );
+  }
+  lines.push(
+    `- Total failed: ${summary.totalFailed}`,
+    `- Backend 5xx: ${summary.backend5xx}`,
+    `- Mixed 5xx: ${summary.mixed5xx}`,
+    `- Slow API: ${summary.slowApi}`,
+    `- Log fail: ${summary.logFail}`,
+    `- Log timeout: ${summary.logTimeout}`,
+    `- Frontend load: ${summary.frontendLoad}`,
+    `- Other: ${summary.other}`,
+    ""
+  );
+  if (workorders.length === 0) {
+    lines.push("No backend work orders this run.");
+    return lines.join("\n") + "\n";
+  }
+  for (const wo of workorders) {
+    lines.push(
+      `## Workorder ${wo.index} - ${wo.domain}`,
+      "",
+      `- Priority: ${wo.priority}`,
+      `- Affected tests: ${wo.tests.length}`,
+      "- Scope:"
+    );
+    for (const t of wo.tests) lines.push(`  - ${t}`);
+    if (wo.endpoints.length > 0) {
+      lines.push("- Endpoints:");
+      for (const e of wo.endpoints) lines.push(`  - ${e}`);
+    }
+    lines.push(`- Objective: ${wo.objective}`);
+    lines.push("- Acceptance criteria:");
+    for (const c of wo.acceptanceCriteria) lines.push(`  - ${c}`);
+    lines.push("");
+  }
+  return lines.join("\n") + "\n";
+}
 var init_workorder_reporter = __esm({
   "src/reporters/workorder-reporter.ts"() {
     "use strict";
@@ -2060,14 +2598,133 @@ var init_workorder_reporter = __esm({
 });
 
 // src/reporters/token-reporter.ts
+function renderTokenReportMarkdown(summary) {
+  const lines = [
+    "# AI Token Usage Report",
+    "",
+    `- Total requests: ${summary.totalRequests}`,
+    `- Total tokens: ${summary.totalTokens.toLocaleString()}`,
+    `- Prompt tokens: ${summary.totalPromptTokens.toLocaleString()}`,
+    `- Completion tokens: ${summary.totalCompletionTokens.toLocaleString()}`,
+    `- Estimated cost: \xA5${summary.totalEstimatedCost.toFixed(4)}`,
+    `- Average latency: ${summary.avgLatencyMs}ms`
+  ];
+  if (summary.budgetUsedPercent !== null) {
+    lines.push(`- Budget used: ${summary.budgetUsedPercent}%${summary.budgetExceeded ? " **EXCEEDED**" : ""}`);
+  }
+  lines.push("");
+  const cats = Object.entries(summary.byCategory).sort((a, b) => b[1].totalTokens - a[1].totalTokens);
+  if (cats.length > 0) {
+    lines.push(
+      "## By Category",
+      "",
+      "| Category | Requests | Prompt | Completion | Total | Cost |",
+      "|----------|----------|--------|------------|-------|------|"
+    );
+    for (const [cat, d] of cats) {
+      lines.push(`| ${cat} | ${d.requests} | ${d.promptTokens.toLocaleString()} | ${d.completionTokens.toLocaleString()} | ${d.totalTokens.toLocaleString()} | \xA5${d.estimatedCost.toFixed(4)} |`);
+    }
+    lines.push("");
+  }
+  const models = Object.entries(summary.byModel);
+  if (models.length > 0) {
+    lines.push(
+      "## By Model",
+      "",
+      "| Model | Requests | Total Tokens | Cost |",
+      "|-------|----------|-------------|------|"
+    );
+    for (const [model, d] of models) {
+      lines.push(`| ${model} | ${d.requests} | ${d.totalTokens.toLocaleString()} | \xA5${d.estimatedCost.toFixed(4)} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n") + "\n";
+}
+var TokenTracker;
 var init_token_reporter = __esm({
   "src/reporters/token-reporter.ts"() {
     "use strict";
     init_esm_shims();
+    TokenTracker = class {
+      entries = [];
+      budget = null;
+      setBudget(maxTokens) {
+        this.budget = maxTokens;
+      }
+      record(entry) {
+        this.entries.push(entry);
+      }
+      reset() {
+        this.entries = [];
+      }
+      getSummary() {
+        const totalRequests = this.entries.length;
+        let totalPromptTokens = 0;
+        let totalCompletionTokens = 0;
+        let totalEstimatedCost = 0;
+        let totalLatency = 0;
+        const byCategory = {};
+        const byModel = {};
+        for (const e of this.entries) {
+          totalPromptTokens += e.promptTokens;
+          totalCompletionTokens += e.completionTokens;
+          totalEstimatedCost += e.estimatedCost;
+          totalLatency += e.latencyMs;
+          if (!byCategory[e.category]) {
+            byCategory[e.category] = { requests: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0, estimatedCost: 0 };
+          }
+          const cat = byCategory[e.category];
+          cat.requests++;
+          cat.promptTokens += e.promptTokens;
+          cat.completionTokens += e.completionTokens;
+          cat.totalTokens += e.promptTokens + e.completionTokens;
+          cat.estimatedCost += e.estimatedCost;
+          if (!byModel[e.model]) {
+            byModel[e.model] = { requests: 0, totalTokens: 0, estimatedCost: 0 };
+          }
+          const mod = byModel[e.model];
+          mod.requests++;
+          mod.totalTokens += e.promptTokens + e.completionTokens;
+          mod.estimatedCost += e.estimatedCost;
+        }
+        const totalTokens = totalPromptTokens + totalCompletionTokens;
+        const budgetUsedPercent = this.budget && this.budget > 0 ? Math.round(totalTokens / this.budget * 1e4) / 100 : null;
+        return {
+          totalRequests,
+          totalTokens,
+          totalPromptTokens,
+          totalCompletionTokens,
+          totalEstimatedCost,
+          avgLatencyMs: totalRequests > 0 ? Math.round(totalLatency / totalRequests) : 0,
+          byCategory,
+          byModel,
+          budgetUsedPercent,
+          budgetExceeded: budgetUsedPercent !== null && budgetUsedPercent > 100
+        };
+      }
+    };
   }
 });
 
 // src/reporters/index.ts
+var reporters_exports = {};
+__export(reporters_exports, {
+  TokenTracker: () => TokenTracker,
+  aggregateLogCompletion: () => aggregateLogCompletion,
+  buildBackendChecklist: () => buildBackendChecklist,
+  buildFailureSummary: () => buildFailureSummary,
+  buildWorkorders: () => buildWorkorders,
+  classifyFailure: () => classifyFailure,
+  generateHtmlReport: () => generateHtmlReport,
+  generateJsonReport: () => generateJsonReport,
+  generateMarkdownReport: () => generateMarkdownReport,
+  generateReports: () => generateReports,
+  parseApiDomain: () => parseApiDomain,
+  renderChecklistMarkdown: () => renderChecklistMarkdown,
+  renderTokenReportMarkdown: () => renderTokenReportMarkdown,
+  renderWorkordersMarkdown: () => renderWorkordersMarkdown
+});
 function generateJsonReport(result) {
   const serializable = {
     modules: result.modules,
@@ -3549,6 +4206,65 @@ function registerAgentRoutes(app, office) {
       duration: result.duration
     };
   });
+  app.post("/api/run-tests", async (req, reply) => {
+    if (office.isRunning()) {
+      reply.code(409).send({ error: "A task is already running" });
+      return;
+    }
+    const mode = req.body?.mode;
+    if (mode && !["auto", "reuse", "managed"].includes(mode)) {
+      reply.code(400).send({ error: "Invalid mode. Valid values: auto, reuse, managed" });
+      return;
+    }
+    office.runTests({ mode }).catch(() => {
+    });
+    return { ok: true, message: "Test execution started" };
+  });
+  app.get("/api/test-results", async () => {
+    const metrics = office.getLastExecutionMetrics();
+    if (!metrics) return { ok: false, message: "No tests have been run yet" };
+    const total = metrics.passed + metrics.failed + metrics.skipped + metrics.timedOut;
+    return { ok: true, metrics, total };
+  });
+  app.post("/api/reports/generate", async (_req, reply) => {
+    if (office.isRunning()) {
+      reply.code(409).send({ error: "A task is already running" });
+      return;
+    }
+    office.generateReport().catch(() => {
+    });
+    return { ok: true, message: "Report generation started" };
+  });
+  app.get("/api/reports", async () => {
+    const reports = office.getLastReports();
+    if (reports.length === 0) return { ok: false, message: "No reports generated yet" };
+    return {
+      ok: true,
+      reports: reports.map((r) => ({
+        format: r.format,
+        filename: r.filename,
+        size: r.content.length
+      }))
+    };
+  });
+  app.get("/api/reports/:format", async (req, reply) => {
+    const reports = office.getLastReports();
+    const report2 = reports.find((r) => r.format === req.params.format);
+    if (!report2) {
+      reply.code(404).send({ error: `No ${req.params.format} report found` });
+      return;
+    }
+    const contentType = req.params.format === "html" ? "text/html" : req.params.format === "json" ? "application/json" : "text/markdown";
+    reply.type(contentType).send(report2.content);
+  });
+  app.get("/api/ci/template", async (req) => {
+    const provider = req.query.provider || "github";
+    const { generateGitHubActionsTemplate: generateGitHubActionsTemplate2, generateGitLabCITemplate: generateGitLabCITemplate2 } = await Promise.resolve().then(() => (init_ci(), ci_exports));
+    if (provider === "gitlab") {
+      return { ok: true, provider: "gitlab", template: generateGitLabCITemplate2() };
+    }
+    return { ok: true, provider: "github", template: generateGitHubActionsTemplate2() };
+  });
 }
 var init_agents = __esm({
   "src/server/routes/agents.ts"() {
@@ -3557,6 +4273,264 @@ var init_agents = __esm({
   }
 });
 
+// src/execution/coordinator.ts
+var coordinator_exports = {};
+__export(coordinator_exports, {
+  createExecutionCoordinator: () => createExecutionCoordinator
+});
+import { execSync as nodeExecSync } from "child_process";
+function parseMetrics(output) {
+  const metrics = { passed: 0, failed: 0, skipped: 0, timedOut: 0 };
+  const passedMatch = output.match(/(\d+)\s+passed/);
+  const failedMatch = output.match(/(\d+)\s+failed/);
+  const skippedMatch = output.match(/(\d+)\s+skipped/);
+  const timedOutMatch = output.match(/(\d+)\s+timed?\s*out/i);
+  if (passedMatch) metrics.passed = parseInt(passedMatch[1], 10);
+  if (failedMatch) metrics.failed = parseInt(failedMatch[1], 10);
+  if (skippedMatch) metrics.skipped = parseInt(skippedMatch[1], 10);
+  if (timedOutMatch) metrics.timedOut = parseInt(timedOutMatch[1], 10);
+  return metrics;
+}
+function getFailureLines(output) {
+  return output.split(/\r?\n/).filter((line) => /fail|error|timeout/i.test(line)).slice(0, 5);
+}
+function createExecutionCoordinator(deps = {}) {
+  const execSync = deps.execSync ?? nodeExecSync;
+  const categorizeFailure2 = deps.categorizeFailure;
+  return {
+    async run(request) {
+      const mode = request.mode ?? "auto";
+      const timeoutMs = request.timeoutMs ?? 3e5;
+      const command = `npx playwright test ${request.testFiles.map((file) => `"${file}"`).join(" ")} --reporter=line 2>&1`;
+      let output;
+      try {
+        output = String(execSync(command, {
+          cwd: request.cwd,
+          encoding: "utf-8",
+          timeout: timeoutMs,
+          stdio: "pipe"
+        }));
+      } catch (err) {
+        const execErr = err;
+        output = `${execErr.stdout || ""}
+${execErr.stderr || ""}`;
+      }
+      output = output.trim();
+      const metrics = parseMetrics(output);
+      if (metrics.passed === 0 && metrics.failed === 0 && metrics.skipped === 0 && metrics.timedOut === 0) {
+        metrics.failed = request.testFiles.length;
+      }
+      const failureHints = getFailureLines(output).map((line) => {
+        const analyzed = categorizeFailure2 ? categorizeFailure2(line) : { category: "unknown", confidence: 0.5 };
+        return {
+          line,
+          category: analyzed.category,
+          confidence: analyzed.confidence
+        };
+      });
+      return {
+        mode,
+        metrics,
+        output,
+        failureHints
+      };
+    }
+  };
+}
+var init_coordinator = __esm({
+  "src/execution/coordinator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/runtime/resilient-fetch.ts
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function waitForBackend(baseUrl, options = {}) {
+  const { timeoutMs = 3e4, intervalMs = 1e3, healthPath = "/health" } = options;
+  const healthUrl = new URL(healthPath, baseUrl).href;
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const resp = await fetch(healthUrl, { method: "GET", signal: AbortSignal.timeout(3e3) });
+      if (resp.ok) return;
+    } catch {
+    }
+    await sleep(intervalMs);
+  }
+  throw new Error(`Backend not ready: ${healthUrl} timed out after ${timeoutMs}ms`);
+}
+var init_resilient_fetch = __esm({
+  "src/runtime/resilient-fetch.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/execution/backend-manager.ts
+var backend_manager_exports = {};
+__export(backend_manager_exports, {
+  createBackendManager: () => createBackendManager
+});
+import { resolve as resolve8 } from "path";
+import { spawn as nodeSpawn } from "child_process";
+function normalizeHealthUrl(server, baseURL) {
+  if (server?.healthUrl) return server.healthUrl;
+  if (baseURL) return new URL("/health", baseURL).href;
+  return "http://localhost:3000/health";
+}
+function splitHealthUrl(healthUrl) {
+  const parsed = new URL(healthUrl);
+  const baseUrl = `${parsed.protocol}//${parsed.host}`;
+  const healthPath = `${parsed.pathname}${parsed.search}`;
+  return { baseUrl, healthPath };
+}
+async function waitReady(waitForBackend2, healthUrl, timeoutMs, intervalMs) {
+  const { baseUrl, healthPath } = splitHealthUrl(healthUrl);
+  await waitForBackend2(baseUrl, {
+    timeoutMs,
+    intervalMs,
+    healthPath
+  });
+}
+function createBackendManager(deps = {}) {
+  const waitForBackend2 = deps.waitForBackend ?? waitForBackend;
+  const spawn = deps.spawn ?? nodeSpawn;
+  return {
+    async ensureReady(request) {
+      const server = request.server ?? {};
+      const healthUrl = normalizeHealthUrl(server, request.baseURL);
+      const quickTimeoutMs = 1500;
+      const startTimeoutMs = server.startTimeoutMs ?? 3e4;
+      const pollIntervalMs = server.pollIntervalMs ?? 800;
+      const tryReuse = request.mode !== "managed" || server.reuseExisting !== false;
+      if (tryReuse) {
+        try {
+          await waitReady(waitForBackend2, healthUrl, quickTimeoutMs, 300);
+          return {
+            mode: request.mode,
+            status: "reused",
+            healthUrl,
+            cleanup: async () => {
+            }
+          };
+        } catch (err) {
+          void err;
+        }
+      }
+      if (request.mode === "reuse") {
+        throw new Error(`HEALTH_FAIL: backend is not reachable at ${healthUrl} in reuse mode`);
+      }
+      if (!server.command) {
+        if (request.mode === "auto") {
+          return {
+            mode: request.mode,
+            status: "skipped",
+            healthUrl,
+            cleanup: async () => {
+            }
+          };
+        }
+        throw new Error("BOOT_CONFIG_MISSING: runtime.server.command is required for managed mode");
+      }
+      const child = spawn(server.command, server.args ?? [], {
+        cwd: resolve8(request.cwd, server.cwd ?? "."),
+        shell: true,
+        stdio: "pipe",
+        env: process.env
+      });
+      try {
+        await waitReady(waitForBackend2, healthUrl, startTimeoutMs, pollIntervalMs);
+      } catch {
+        if (child.exitCode === null) child.kill();
+        throw new Error(`BOOT_TIMEOUT: backend did not become healthy at ${healthUrl}`);
+      }
+      return {
+        mode: request.mode,
+        status: "started",
+        healthUrl,
+        cleanup: async () => {
+          if (child.exitCode === null) child.kill();
+        }
+      };
+    }
+  };
+}
+var init_backend_manager = __esm({
+  "src/execution/backend-manager.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_resilient_fetch();
+  }
+});
+
+// src/execution/runtime-bootstrap.ts
+var runtime_bootstrap_exports = {};
+__export(runtime_bootstrap_exports, {
+  createRuntimeBootstrap: () => createRuntimeBootstrap
+});
+import { existsSync as existsSync15, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname5, join as join13 } from "path";
+function ensureFile(filePath, content, force) {
+  if (existsSync15(filePath) && !force) {
+    return false;
+  }
+  mkdirSync10(dirname5(filePath), { recursive: true });
+  writeFileSync10(filePath, content, "utf-8");
+  return true;
+}
+function createRuntimeBootstrap(config) {
+  return {
+    async ensure(request) {
+      const force = request.force ?? false;
+      const files = [
+        {
+          name: "playwright.config.ts",
+          content: generatePlaywrightConfig(config)
+        },
+        {
+          name: "global-setup.ts",
+          content: generateGlobalSetup(config)
+        },
+        {
+          name: "global-teardown.ts",
+          content: generateGlobalTeardown(config)
+        }
+      ];
+      if (request.hasAuth) {
+        files.push({
+          name: "auth.setup.ts",
+          content: generateAuthSetup(config)
+        });
+      }
+      const writtenFiles = [];
+      const skippedFiles = [];
+      for (const file of files) {
+        const filePath = join13(request.cwd, file.name);
+        const written = ensureFile(filePath, file.content, force);
+        if (written) writtenFiles.push(file.name);
+        else skippedFiles.push(file.name);
+      }
+      return {
+        writtenFiles,
+        skippedFiles
+      };
+    }
+  };
+}
+var init_runtime_bootstrap = __esm({
+  "src/execution/runtime-bootstrap.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_playwright_config_generator();
+    init_global_setup_generator();
+    init_global_teardown_generator();
+    init_auth_setup_generator();
+  }
+});
+
 // src/server/croc-office.ts
 var DEFAULT_AGENTS, CrocOffice;
 var init_croc_office = __esm({
@@ -3580,6 +4554,8 @@ var init_croc_office = __esm({
       running = false;
       lastPipelineResult = null;
       lastGeneratedFiles = [];
+      lastExecutionMetrics = null;
+      lastReports = [];
       constructor(config, cwd) {
         this.config = config;
         this.cwd = cwd;
@@ -3695,13 +4671,13 @@ var init_croc_office = __esm({
           const fullResult = await pipeline.run(["scan", "er-diagram", "api-chain", "plan", "codegen"]);
           this.lastPipelineResult = fullResult;
           this.lastGeneratedFiles = fullResult.generatedFiles;
-          const { writeFileSync: writeFileSync10, mkdirSync: mkdirSync10 } = await import("fs");
-          const { dirname: dirname6 } = await import("path");
+          const { writeFileSync: writeFileSync11, mkdirSync: mkdirSync11 } = await import("fs");
+          const { dirname: dirname7 } = await import("path");
           let filesWritten = 0;
           for (const file of fullResult.generatedFiles) {
             const fullPath = resolvePath(this.cwd, file.filePath);
-            mkdirSync10(dirname6(fullPath), { recursive: true });
-            writeFileSync10(fullPath, file.content, "utf-8");
+            mkdirSync11(dirname7(fullPath), { recursive: true });
+            writeFileSync11(fullPath, file.content, "utf-8");
             filesWritten++;
           }
           this.updateNodeStatus("controller", "passed");
@@ -3761,6 +4737,144 @@ var init_croc_office = __esm({
       getGeneratedFiles() {
         return this.lastGeneratedFiles;
       }
+      /** Get last execution metrics */
+      getLastExecutionMetrics() {
+        return this.lastExecutionMetrics;
+      }
+      /** Get last generated reports */
+      getLastReports() {
+        return this.lastReports;
+      }
+      /** Run generated tests with Playwright */
+      async runTests(options = {}) {
+        if (this.running) return { ok: false, task: "execute", duration: 0, error: "Another task is running" };
+        if (this.lastGeneratedFiles.length === 0) {
+          return { ok: false, task: "execute", duration: 0, error: "No test files \u2014 run Pipeline first" };
+        }
+        this.running = true;
+        const start = Date.now();
+        let cleanupBackend = null;
+        try {
+          const { resolve: resolvePath } = await import("path");
+          const { existsSync: existsSync17 } = await import("fs");
+          const { createExecutionCoordinator: createExecutionCoordinator2 } = await Promise.resolve().then(() => (init_coordinator(), coordinator_exports));
+          const { createBackendManager: createBackendManager2 } = await Promise.resolve().then(() => (init_backend_manager(), backend_manager_exports));
+          const { createRuntimeBootstrap: createRuntimeBootstrap2 } = await Promise.resolve().then(() => (init_runtime_bootstrap(), runtime_bootstrap_exports));
+          const { categorizeFailure: categorizeFailure2 } = await Promise.resolve().then(() => (init_self_healing(), self_healing_exports));
+          const testFiles = this.lastGeneratedFiles.map((f) => resolvePath(this.cwd, f.filePath)).filter((f) => existsSync17(f));
+          if (testFiles.length === 0) {
+            this.log("\u26A0\uFE0F No test files found on disk", "warn");
+            return { ok: false, task: "execute", duration: Date.now() - start, error: "No test files found on disk" };
+          }
+          const mode = options.mode ?? "auto";
+          this.updateAgent("tester-croc", { status: "working", currentTask: `Running ${testFiles.length} test files (${mode})...`, progress: 0 });
+          this.log(`\u{1F9EA} \u6D4B\u8BD5\u9CC4 is running ${testFiles.length} Playwright tests (${mode})...`);
+          const runtimeBootstrap = createRuntimeBootstrap2(this.config);
+          const runtimeResult = await runtimeBootstrap.ensure({
+            cwd: this.cwd,
+            hasAuth: !!this.config.runtime?.auth?.loginUrl
+          });
+          if (runtimeResult.writtenFiles.length > 0) {
+            this.log(`\u{1F9E9} Runtime assets prepared: ${runtimeResult.writtenFiles.join(", ")}`);
+          }
+          const backendManager = createBackendManager2();
+          const backendReady = await backendManager.ensureReady({
+            mode,
+            cwd: this.cwd,
+            server: this.config.runtime?.server,
+            baseURL: this.config.playwright?.baseURL
+          });
+          cleanupBackend = backendReady.cleanup;
+          if (backendReady.status === "started") {
+            this.log(`\u{1F680} Managed backend started (${backendReady.healthUrl})`);
+          } else if (backendReady.status === "reused") {
+            this.log(`\u{1F501} Reusing backend (${backendReady.healthUrl})`);
+          }
+          this.updateAgent("healer-croc", { status: "thinking", currentTask: "Monitoring test run...", progress: 0 });
+          const coordinator = createExecutionCoordinator2({ categorizeFailure: categorizeFailure2 });
+          const execResult = await coordinator.run({
+            cwd: this.cwd,
+            testFiles,
+            mode
+          });
+          const metrics = execResult.metrics;
+          this.lastExecutionMetrics = metrics;
+          const total = metrics.passed + metrics.failed + metrics.skipped + metrics.timedOut;
+          if (metrics.failed > 0) {
+            this.updateAgent("tester-croc", { status: "error", currentTask: `${metrics.failed} tests failed`, progress: 100 });
+            this.updateAgent("healer-croc", { status: "working", currentTask: `Analyzing ${metrics.failed} failures...`, progress: 50 });
+            this.log(`\u274C Tests: ${metrics.passed} passed, ${metrics.failed} failed, ${metrics.skipped} skipped`, "warn");
+            for (const hint of execResult.failureHints) {
+              this.log(`  \u{1F50D} ${hint.category} (${Math.round(hint.confidence * 100)}%): ${hint.line.substring(0, 100)}`, "warn");
+            }
+            this.updateAgent("healer-croc", { status: "done", currentTask: "Failure analysis done", progress: 100 });
+          } else {
+            this.updateAgent("tester-croc", { status: "done", currentTask: `All ${metrics.passed} tests passed!`, progress: 100 });
+            this.updateAgent("healer-croc", { status: "done", currentTask: "No failures", progress: 100 });
+            this.log(`\u2705 All ${metrics.passed} tests passed!`);
+          }
+          this.updateNodeStatus("controller", metrics.failed > 0 ? "failed" : "passed");
+          this.broadcast("test:complete", { metrics, total });
+          const duration = Date.now() - start;
+          this.log(`\u{1F9EA} Test execution complete in ${duration}ms`);
+          return { ok: metrics.failed === 0, task: "execute", duration, details: metrics };
+        } catch (err) {
+          this.updateAgent("tester-croc", { status: "error", currentTask: String(err) });
+          this.log(`\u274C Test execution failed: ${err}`, "error");
+          return { ok: false, task: "execute", duration: Date.now() - start, error: String(err) };
+        } finally {
+          if (cleanupBackend) {
+            try {
+              await cleanupBackend();
+              this.log("\u{1F9F9} Managed backend stopped");
+            } catch (err) {
+              this.log(`\u26A0\uFE0F Backend cleanup failed: ${err}`, "warn");
+            }
+          }
+          this.running = false;
+        }
+      }
+      /** Generate reports (HTML/JSON/Markdown) */
+      async generateReport() {
+        if (this.running) return { ok: false, task: "report", duration: 0, error: "Another task is running" };
+        if (!this.lastPipelineResult) {
+          return { ok: false, task: "report", duration: 0, error: "No pipeline result \u2014 run Pipeline first" };
+        }
+        this.running = true;
+        const start = Date.now();
+        try {
+          this.updateAgent("reporter-croc", { status: "working", currentTask: "Generating reports...", progress: 0 });
+          this.log("\u{1F4CA} \u6C47\u62A5\u9CC4 is generating reports...");
+          const { generateReports: generateReports2 } = await Promise.resolve().then(() => (init_reporters(), reporters_exports));
+          const formats = ["html", "json", "markdown"];
+          const reports = generateReports2(this.lastPipelineResult, formats);
+          this.lastReports = reports;
+          const { resolve: resolvePath } = await import("path");
+          const { writeFileSync: writeFileSync11, mkdirSync: mkdirSync11 } = await import("fs");
+          const outDir = resolvePath(this.cwd, this.config.outDir || "./opencroc-output");
+          mkdirSync11(outDir, { recursive: true });
+          for (const report2 of reports) {
+            const fullPath = resolvePath(outDir, report2.filename);
+            writeFileSync11(fullPath, report2.content, "utf-8");
+            this.log(`\u{1F4C4} Generated ${report2.format} report: ${report2.filename}`);
+          }
+          this.updateAgent("reporter-croc", { status: "done", currentTask: `${reports.length} reports generated`, progress: 100 });
+          this.broadcast("reports:generated", reports.map((r) => ({
+            format: r.format,
+            filename: r.filename,
+            size: r.content.length
+          })));
+          const duration = Date.now() - start;
+          this.log(`\u2705 Reports generated in ${duration}ms`);
+          return { ok: true, task: "report", duration, details: { count: reports.length } };
+        } catch (err) {
+          this.updateAgent("reporter-croc", { status: "error", currentTask: String(err) });
+          this.log(`\u274C Report generation failed: ${err}`, "error");
+          return { ok: false, task: "report", duration: Date.now() - start, error: String(err) };
+        } finally {
+          this.running = false;
+        }
+      }
       // ============ Graph Helpers ============
       updateNodeStatus(type, status) {
         if (!this.cachedGraph) return;
@@ -3986,13 +5100,13 @@ import Fastify from "fastify";
 import fastifyStatic from "@fastify/static";
 import fastifyWebsocket from "@fastify/websocket";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname5, join as join13, resolve as resolve8 } from "path";
-import { existsSync as existsSync15 } from "fs";
+import { dirname as dirname6, join as join14, resolve as resolve9 } from "path";
+import { existsSync as existsSync16 } from "fs";
 async function startServer(opts) {
   const app = Fastify({ logger: false });
   await app.register(fastifyWebsocket);
-  const webDir = resolve8(__dirname2, "../web");
-  if (existsSync15(webDir)) {
+  const webDir = resolve9(__dirname2, "../web");
+  if (existsSync16(webDir)) {
     await app.register(fastifyStatic, {
       root: webDir,
       prefix: "/",
@@ -4013,8 +5127,8 @@ async function startServer(opts) {
       reply.code(404).send({ error: "Not found" });
       return;
     }
-    const indexPath = join13(webDir, "index.html");
-    if (existsSync15(indexPath)) {
+    const indexPath = join14(webDir, "index.html");
+    if (existsSync16(indexPath)) {
       reply.sendFile("index.html");
     } else {
       reply.code(200).header("content-type", "text/html").send(getEmbeddedHtml());
@@ -4165,7 +5279,7 @@ var init_server = __esm({
     init_agents();
     init_croc_office();
     __filename2 = fileURLToPath2(import.meta.url);
-    __dirname2 = dirname5(__filename2);
+    __dirname2 = dirname6(__filename2);
   }
 });
 
@@ -4236,7 +5350,7 @@ program.command("heal").description("Run self-healing loop on failed tests").opt
   await heal2(opts);
 });
 program.command("ci").description("Generate CI/CD pipeline template").option("-p, --platform <name>", "CI platform (github, gitlab)", "github").option("--self-heal", "Include self-healing step").option("--node <versions>", "Node.js versions (comma-separated)", "20.x").action(async (opts) => {
-  const { ci: ci2 } = await Promise.resolve().then(() => (init_ci2(), ci_exports));
+  const { ci: ci2 } = await Promise.resolve().then(() => (init_ci2(), ci_exports2));
   await ci2(opts);
 });
 program.command("report").description("Generate pipeline report (HTML/JSON/Markdown)").option("-f, --format <formats>", "Report formats (comma-separated)", "html").option("-o, --output <dir>", "Output directory").action(async (opts) => {