karajan-code 1.59.0 → 2.0.0

package/src/roles/security-role.js

@@ -1,5 +1,4 @@
-import { BaseRole } from "./base-role.js";
-import { createAgent as defaultCreateAgent } from "../agents/index.js";
+import { AgentRole } from "./agent-role.js";
 import { extractFirstJson } from "../utils/json-extract.js";
 
 const SUBAGENT_PREAMBLE = [
@@ -8,118 +7,55 @@ const SUBAGENT_PREAMBLE = [
   "Do NOT use any MCP tools. Focus only on auditing code for security vulnerabilities."
 ].join(" ");
 
-function resolveProvider(config) {
-  return (
-    config?.roles?.security?.provider ||
-    config?.roles?.coder?.provider ||
-    "claude"
-  );
-}
-
-function buildPrompt({ task, diff, instructions }) {
-  const sections = [SUBAGENT_PREAMBLE];
-
-  if (instructions) {
-    sections.push(instructions);
+export class SecurityRole extends AgentRole {
+  constructor(opts) {
+    super({ ...opts, name: "security" });
   }
 
-  sections.push(
-    "You are a security auditor. Analyze the code changes for vulnerabilities.",
-    "Check for: OWASP top 10, exposed secrets/API keys, hardcoded credentials, command injection, XSS, SQL injection, path traversal, prototype pollution, insecure dependencies.",
-    "Return a single valid JSON object with your findings and nothing else.",
-    'JSON schema: {"vulnerabilities":[{"severity":"critical|high|medium|low","category":string,"file":string,"line":number,"description":string,"fix_suggestion":string}],"verdict":"pass"|"fail"}',
-    `## Task\n${task}`
-  );
-
-  if (diff) {
-    sections.push(`## Git diff to audit\n${diff}`);
+  async buildPrompt({ task, diff }) {
+    const sections = [SUBAGENT_PREAMBLE];
+    if (this.instructions) sections.push(this.instructions);
+    sections.push(
+      "You are a security auditor. Analyze the code changes for vulnerabilities.",
+      "Check for: OWASP top 10, exposed secrets/API keys, hardcoded credentials, command injection, XSS, SQL injection, path traversal, prototype pollution, insecure dependencies.",
+      "Return a single valid JSON object with your findings and nothing else.",
+      '{"vulnerabilities":[{"severity":"critical|high|medium|low","category":string,"file":string,"line":number,"description":string,"fix_suggestion":string}],"verdict":"pass"|"fail"}',
+      `## Task\n${task}`
+    );
+    if (diff) sections.push(`## Git diff to audit\n${diff}`);
+    return { prompt: sections.join("\n\n") };
   }
 
-  return sections.join("\n\n");
-}
-
-function parseSecurityOutput(raw) {
-  return extractFirstJson(raw);
-}
-
-function buildSummary(parsed) {
-  const vulns = parsed.vulnerabilities || [];
-  if (vulns.length === 0) {
-    return `Verdict: ${parsed.verdict || "pass"}; No vulnerabilities found`;
+  extractInput(input) {
+    if (typeof input === "string") return { task: input, diff: null };
+    return { task: input?.task || this.context?.task || "", diff: input?.diff || null, onOutput: input?.onOutput || null };
   }
 
-  const bySeverity = {};
-  for (const v of vulns) {
-    const sev = v.severity || "unknown";
-    bySeverity[sev] = (bySeverity[sev] || 0) + 1;
-  }
-
-  const parts = Object.entries(bySeverity)
-    .sort(([a], [b]) => {
-      const order = { critical: 0, high: 1, medium: 2, low: 3 };
-      return (order[a] ?? 4) - (order[b] ?? 4);
-    })
-    .map(([sev, count]) => `${count} ${sev}`);
-
-  return `Verdict: ${parsed.verdict || "fail"}; ${parts.join(", ")}`;
-}
+  parseOutput(raw) { return extractFirstJson(raw); }
 
-export class SecurityRole extends BaseRole {
-  constructor({ config, logger, emitter = null, createAgentFn = null }) {
-    super({ name: "security", config, logger, emitter });
-    this._createAgent = createAgentFn || defaultCreateAgent;
+  isSuccessful(parsed) {
+    const verdict = parsed.verdict || (parsed.vulnerabilities?.length ? "fail" : "pass");
+    return verdict === "pass";
   }
 
-  async execute(input) {
-    const { task, diff } = typeof input === "string"
-      ? { task: input, diff: null }
-      : { task: input?.task || this.context?.task || "", diff: input?.diff || null };
-
-    const provider = resolveProvider(this.config);
-    const agent = this._createAgent(provider, this.config, this.logger);
-
-    const prompt = buildPrompt({ task, diff, instructions: this.instructions });
-    const result = await agent.runTask({ prompt, role: "security" });
+  buildSuccessResult(parsed, provider) {
+    const verdict = parsed.verdict || (parsed.vulnerabilities?.length ? "fail" : "pass");
+    return { vulnerabilities: parsed.vulnerabilities || [], verdict, provider };
+  }
 
-    if (!result.ok) {
-      return {
-        ok: false,
-        result: {
-          error: result.error || result.output || "Security audit failed",
-          provider
-        },
-        summary: `Security audit failed: ${result.error || "unknown error"}`
-      };
-    }
+  buildSummary(parsed) {
+    const verdict = parsed.verdict || (parsed.vulnerabilities?.length ? "fail" : "pass");
+    const vulns = parsed.vulnerabilities || [];
+    if (!vulns.length) return `Verdict: ${verdict}; No vulnerabilities found`;
 
-    try {
-      const parsed = parseSecurityOutput(result.output);
-      if (!parsed) {
-        return {
-          ok: false,
-          result: { error: "Failed to parse security output: no JSON found", provider },
-          summary: "Security output parse error: no JSON found"
-        };
-      }
+    const bySeverity = {};
+    for (const v of vulns) bySeverity[v.severity || "unknown"] = (bySeverity[v.severity || "unknown"] || 0) + 1;
 
-      const verdict = parsed.verdict || (parsed.vulnerabilities?.length ? "fail" : "pass");
-      const ok = verdict === "pass";
+    const order = { critical: 0, high: 1, medium: 2, low: 3 };
+    const parts = Object.entries(bySeverity)
+      .sort(([a], [b]) => (order[a] ?? 4) - (order[b] ?? 4))
+      .map(([sev, count]) => `${count} ${sev}`);
 
-      return {
-        ok,
-        result: {
-          vulnerabilities: parsed.vulnerabilities || [],
-          verdict,
-          provider
-        },
-        summary: buildSummary({ ...parsed, verdict })
-      };
-    } catch (err) {
-      return {
-        ok: false,
-        result: { error: `Failed to parse security output: ${err.message}`, provider },
-        summary: `Security output parse error: ${err.message}`
-      };
-    }
+    return `Verdict: ${verdict}; ${parts.join(", ")}`;
   }
 }

package/src/roles/solomon-role.js

@@ -1,5 +1,6 @@
 import { BaseRole } from "./base-role.js";
 import { createAgent as defaultCreateAgent } from "../agents/index.js";
+import { extractFirstJson } from "../utils/json-extract.js";
 
 const SUBAGENT_PREAMBLE = [
   "IMPORTANT: You are running as a Karajan sub-agent.",
@@ -35,27 +36,51 @@ function buildPrompt({ conflict, task, instructions }) {
   }
 
   sections.push(
-    "You are Solomon, the conflict resolver in a multi-role AI pipeline.",
-    "You are activated when agents cannot reach agreement after their iteration limit.",
-    "## Decision hierarchy",
+    "You are Solomon, the autonomous pipeline boss in a multi-agent AI coding orchestrator.",
+    "You are activated whenever ANYTHING deviates from normal flow: rate limits, agent failures, conflicts, max iterations, quality gate issues.",
+    "",
+    "## Core principle",
+    "The pipeline NEVER skips a quality stage (review, tests, sonar, security) without exhausting alternatives first.",
+    "NEVER approve skipping a stage as your first option. Follow the recovery hierarchy below.",
+    "",
+    "## ABSOLUTE RULE: Security issues from reviewer are NEVER overridable",
+    "If the reviewer's blocking_issues contain security-related issues (categories: authentication, authorization, injection, XSS, CSRF, exposed secrets/credentials, cryptography, session management, input validation), you MUST:",
+    "- Set ruling to \"continue\" (NOT \"approve\")",
+    "- Return the reviewer feedback to the coder for fixing",
+    "- NEVER approve or skip security issues regardless of task complexity or deadline",
+    "This rule overrides all other rules including the recovery hierarchy.",
+    "",
+    "## Recovery hierarchy (STRICT ORDER — follow top to bottom)",
+    "When a stage fails or an agent is unavailable:",
+    "1. **wait** — If there is a known cooldown (cooldownUntil), and it is less than 10 minutes, WAIT. Set ruling to 'approve_with_conditions' with condition 'wait for cooldown' and set waitUntil.",
+    "2. **retry_with_alternative** — Try the same stage with a DIFFERENT agent. The pipeline has multiple agents (claude, codex, gemini). Set ruling to 'approve_with_conditions' with condition specifying the alternative agent.",
+    "3. **evaluate_risk** — Only if no alternatives are available, evaluate the risk of skipping. Consider: task complexity, what the stage would catch, security implications.",
+    "   - If risk is LOW (trivial task, no security impact, style-only review): approve with a clear justification.",
+    "   - If risk is HIGH (complex task, security changes, new dependencies): escalate_human.",
+    "4. **escalate_human** — When you cannot resolve it safely. Always prefer this over blindly approving.",
+    "",
+    "## Quality hierarchy",
     "Security > Correctness > Tests > Architecture > Maintainability > Style",
     "- Green tests are sacred. Never dismiss a failing test.",
     "- Style preferences NEVER block approval.",
-    "- Hardcoded values that will come from DB later are acceptable (contextual false positive).",
     "- Sonar INFO/MINOR issues are always dismissable.",
     "- Sonar BLOCKER/CRITICAL must be fixed unless they are proven false positives.",
+    "",
     "## Classification rules",
     "For each issue, classify as:",
     "1. **critical** (security, correctness, tests broken) — action: must_fix",
     "2. **important** (architecture, maintainability) — action: should_fix",
     "3. **style** (naming, formatting, preferences, false positives) — action: dismiss",
-    "## Your decision options",
-    '1. **approve** — All pending issues are style/false positives. Pipeline continues.',
-    '2. **approve_with_conditions** — Important issues exist but are fixable. Give exact instructions to Coder for one more attempt.',
-    '3. **escalate_human** — Critical issues that cannot be resolved, ambiguous requirements, architecture decisions, or business logic decisions.',
-    '4. **create_subtask** — A prerequisite task must be completed first to resolve the conflict. The current task will pause, the subtask runs, then the current task resumes.',
+    "",
+    "## Ruling options",
+    '1. **approve** — FORBIDDEN when a quality stage (review, tests, sonar, security) was skipped or failed. You MUST try alternatives first (wait for cooldown, use different agent). Only allowed when all stages completed successfully and remaining issues are style/false positives.',
+    '2. **approve_with_conditions** — Fixable issues or recovery actions needed. Include exact conditions (wait, retry with alternative agent, specific fix instructions). Set extraIterations and/or alternativeAgent.',
+    '3. **escalate_human** — Cannot resolve safely. Critical issues, ambiguous requirements, architecture decisions, high-risk skip.',
+    '4. **create_subtask** — A prerequisite task must be completed first.',
+    "",
     "Return a single valid JSON object with your ruling and nothing else.",
-    'JSON schema: {"ruling":"approve"|"approve_with_conditions"|"escalate_human"|"create_subtask","classification":[{"issue":string,"category":"critical"|"important"|"style","action":"must_fix"|"should_fix"|"dismiss"}],"conditions":[string],"dismissed":[string],"escalate":boolean,"escalate_reason":string|null,"subtask":{"title":string,"description":string,"reason":string}|null}'
+    'JSON schema: {"ruling":"approve"|"approve_with_conditions"|"escalate_human"|"create_subtask","classification":[{"issue":string,"category":"critical"|"important"|"style","action":"must_fix"|"should_fix"|"dismiss"}],"conditions":[string],"dismissed":[string],"escalate":boolean,"escalate_reason":string|null,"extraIterations":number|null,"alternativeAgent":string|null,"waitUntil":string|null,"subtask":{"title":string,"description":string,"reason":string}|null}',
+    "When ruling is approve_with_conditions, set extraIterations (1-5) and/or alternativeAgent (claude|codex|gemini) as appropriate."
   );
 
   const stage = conflict?.stage || "unknown";
@@ -65,14 +90,48 @@ function buildPrompt({ conflict, task, instructions }) {
   const isFirstRejection = conflict?.isFirstRejection ?? false;
   const isRepeat = conflict?.isRepeat ?? false;
 
+  const budgetUsd = conflict?.budget_usd;
+  const budgetLine = typeof budgetUsd === "number" ? `Budget spent so far: $${budgetUsd.toFixed(2)}` : "";
+
   sections.push(
     `## Conflict context`,
     `Stage: ${stage}`,
     `Iterations exhausted: ${iterationCount}/${maxIterations}`,
     `isFirstRejection: ${isFirstRejection}`,
-    `isRepeat: ${isRepeat}`
+    `isRepeat: ${isRepeat}`,
+    budgetLine,
+    "",
+    "## Budget awareness",
+    "Consider the cost-benefit ratio when deciding. If significant budget has been spent with little progress,",
+    "prefer approving the current work or escalating to human. If progress is good and budget is low,",
+    "prefer continuing with conditions. Never waste budget on style-only iterations."
   );
 
+  if (conflict?.previousSolomonRulings?.length > 0) {
+    const rulingLines = conflict.previousSolomonRulings.map((r, idx) =>
+      `${idx + 1}. Stage: ${r.conflictStage}, Ruling: ${r.ruling}${r.alternativeAgent ? `, agent: ${r.alternativeAgent}` : ""}${r.error ? ` (FAILED: ${r.error})` : ""}`
+    ).join("\n");
+    sections.push(
+      "## Your previous rulings in this session (DO NOT repeat failed strategies)",
+      rulingLines,
+      "If a previous ruling failed (e.g., alternative agent also rate-limited), do NOT suggest the same strategy again. Escalate or try a different approach."
+    );
+  }
+
+  // Rate limit specific instruction
+  if (stage?.includes("rate_limit")) {
+    const rateLimitedAgent = conflict?.history?.[0]?.feedback?.match(/Agent "(\w+)"/)?.[1] || "unknown";
+    sections.push(
+      "## CRITICAL: Agent rate-limited",
+      `Agent "${rateLimitedAgent}" is rate-limited. You MUST NOT approve skipping this stage.`,
+      "Your ONLY valid options are:",
+      `1. approve_with_conditions + alternativeAgent: pick a different agent (available: claude, codex, gemini — NOT "${rateLimitedAgent}")`,
+      "2. approve_with_conditions + waitUntil: if cooldown is known and <10min",
+      "3. escalate_human: if no alternatives work",
+      `DO NOT set ruling to "approve". The stage MUST be completed by some agent.`
+    );
+  }
+
   if (conflict?.issueCategories) {
     sections.push(`## Issue categories\n${JSON.stringify(conflict.issueCategories, null, 2)}`);
   }
@@ -98,10 +157,7 @@ function buildPrompt({ conflict, task, instructions }) {
 }
 
 function parseSolomonOutput(raw) {
-  const text = raw?.trim() || "";
-  const jsonMatch = /\{[\s\S]*\}/.exec(text);
-  if (!jsonMatch) return null;
-  return JSON.parse(jsonMatch[0]);
+  return extractFirstJson(raw);
 }
 
 function buildSummary(parsed) {

package/src/roles/tester-role.js

@@ -1,6 +1,6 @@
-import { BaseRole } from "./base-role.js";
-import { createAgent as defaultCreateAgent } from "../agents/index.js";
+import { AgentRole } from "./agent-role.js";
 import { extractFirstJson } from "../utils/json-extract.js";
+import { detectTestFramework } from "../utils/project-detect.js";
 
 const SUBAGENT_PREAMBLE = [
   "IMPORTANT: You are running as a Karajan sub-agent.",
@@ -8,108 +8,134 @@ const SUBAGENT_PREAMBLE = [
   "Do NOT use any MCP tools. Focus only on evaluating test quality."
 ].join(" ");
 
-function resolveProvider(config) {
-  return (
-    config?.roles?.tester?.provider ||
-    config?.roles?.coder?.provider ||
-    "claude"
-  );
-}
-
-function buildPrompt({ task, diff, sonarIssues, instructions }) {
-  const sections = [SUBAGENT_PREAMBLE];
-
-  if (instructions) {
-    sections.push(instructions);
+/**
+ * Map test framework to the command that runs tests with coverage.
+ */
+const COVERAGE_COMMANDS = {
+  vitest: "npx vitest run --coverage --reporter=verbose 2>&1",
+  jest: "npx jest --coverage --verbose 2>&1",
+  mocha: "npx c8 mocha 2>&1",
+  playwright: "npx playwright test 2>&1",
+  pytest: "pytest --cov --tb=short 2>&1",
+  "go-test": "go test -cover -v ./... 2>&1",
+  "cargo-test": "cargo test --verbose 2>&1",
+  junit: "mvn test 2>&1",
+  rspec: "bundle exec rspec 2>&1",
+  phpunit: "vendor/bin/phpunit --coverage-text 2>&1",
+  "dotnet-test": "dotnet test --collect:\"XPlat Code Coverage\" 2>&1",
+  "dart-test": "dart test 2>&1"
+};
+
+const TEST_COMMANDS = {
+  vitest: "npx vitest run --reporter=verbose 2>&1",
+  jest: "npx jest --verbose 2>&1",
+  mocha: "npx mocha 2>&1",
+  playwright: "npx playwright test 2>&1",
+  pytest: "pytest --tb=short 2>&1",
+  "go-test": "go test -v ./... 2>&1",
+  "cargo-test": "cargo test --verbose 2>&1",
+  junit: "mvn test 2>&1",
+  rspec: "bundle exec rspec 2>&1",
+  phpunit: "vendor/bin/phpunit 2>&1",
+  "dotnet-test": "dotnet test 2>&1",
+  "dart-test": "dart test 2>&1"
+};
+
+export class TesterRole extends AgentRole {
+  constructor(opts) {
+    super({ ...opts, name: "tester" });
   }
 
-  sections.push(
-    "You are a test quality gate. You do NOT write tests — you evaluate them.",
-    "Run the test suite, check coverage, identify missing scenarios, and evaluate assertion quality.",
-    "Return a single valid JSON object with your findings and nothing else.",
-    'JSON schema: {"tests_pass":boolean,"coverage":{"overall":number,"services":number,"utilities":number},"missing_scenarios":[string],"quality_issues":[string],"verdict":"pass"|"fail"}',
-    `## Task\n${task}`
-  );
-
-  if (diff) {
-    sections.push(`## Git diff\n${diff}`);
+  extractInput(input) {
+    if (typeof input === "string") return { task: input, diff: null, sonarIssues: null };
+    return {
+      task: input?.task || this.context?.task || "",
+      diff: input?.diff || null,
+      sonarIssues: input?.sonarIssues || null,
+      onOutput: input?.onOutput || null
+    };
   }
 
-  if (sonarIssues) {
-    sections.push(`## Sonar test issues\n${sonarIssues}`);
-  }
-
-  return sections.join("\n\n");
-}
-
-function parseTesterOutput(raw) {
-  return extractFirstJson(raw);
-}
+  async buildPrompt({ task, diff, sonarIssues }) {
+    const projectDir = this.config?.projectDir || process.cwd();
+    const detection = await detectTestFramework(projectDir);
+
+    const sections = [SUBAGENT_PREAMBLE];
+    if (this.instructions) sections.push(this.instructions);
+
+    sections.push(
+      "You are a test quality gate. Your job is to EXECUTE the test suite, measure REAL coverage, and evaluate quality.",
+      "You MUST run the actual test command — do NOT guess or estimate results."
+    );
+
+    if (detection.hasTests && detection.framework) {
+      const coverageCmd = COVERAGE_COMMANDS[detection.framework];
+      const testCmd = TEST_COMMANDS[detection.framework];
+      sections.push(
+        `## Detected test framework: ${detection.framework} (${detection.language})`,
+        "**Step 0**: If node_modules/ does not exist, run `npm install` (or `pnpm install`) first.",
+        `**Step 1**: Run the test suite with coverage:`,
+        "```bash",
+        coverageCmd || testCmd,
+        "```",
+        "If the coverage command fails (missing dependency), fall back to:",
+        "```bash",
+        testCmd,
+        "```",
+        "**Step 2**: Parse the output to extract: pass/fail count, coverage percentages, any failures.",
+        "**Step 3**: Return a single JSON object with REAL numbers from the test output."
+      );
+    } else {
+      sections.push(
+        "## No test framework detected",
+        "**Step 0**: If package.json exists but node_modules/ does not, run `npm install` first.",
+        "**Step 1**: Look at package.json or project files to find test scripts.",
+        "**Step 2**: Try running `npm test` or detect the framework from config files.",
+        "**Step 3**: If tests exist, run them. If no tests exist, report tests_pass: false with verdict: 'fail'.",
+        "**Step 4**: Return a JSON object with your findings."
+      );
+    }
 
-export class TesterRole extends BaseRole {
-  constructor({ config, logger, emitter = null, createAgentFn = null }) {
-    super({ name: "tester", config, logger, emitter });
-    this._createAgent = createAgentFn || defaultCreateAgent;
+    sections.push(
+      "",
+      "Return ONLY a single valid JSON object:",
+      '{"tests_pass":boolean,"coverage":{"overall":number,"services":number,"utilities":number},"missing_scenarios":[string],"quality_issues":[string],"verdict":"pass"|"fail"}',
+      "",
+      "- coverage.overall MUST be a real number from the test runner output, NOT an estimate",
+      "- If coverage tool is not available, set coverage.overall to null (not 0, not a guess)",
+      "- tests_pass must reflect whether the actual test run succeeded",
+      `## Task\n${task}`
+    );
+    if (diff) sections.push(`## Git diff\n${diff}`);
+    if (sonarIssues) sections.push(`## Sonar test issues\n${sonarIssues}`);
+    return { prompt: sections.join("\n\n") };
   }
 
-  async execute(input) {
-    const { task, diff, sonarIssues } = typeof input === "string"
-      ? { task: input, diff: null, sonarIssues: null }
-      : { task: input?.task || this.context?.task || "", diff: input?.diff || null, sonarIssues: input?.sonarIssues || null };
-
-    const provider = resolveProvider(this.config);
-    const agent = this._createAgent(provider, this.config, this.logger);
-
-    const prompt = buildPrompt({ task, diff, sonarIssues, instructions: this.instructions });
-    const result = await agent.runTask({ prompt, role: "tester" });
-
-    if (!result.ok) {
-      return {
-        ok: false,
-        result: {
-          error: result.error || result.output || "Tester failed",
-          provider
-        },
-        summary: `Tester failed: ${result.error || "unknown error"}`
-      };
-    }
+  parseOutput(raw) { return extractFirstJson(raw); }
 
-    try {
-      const parsed = parseTesterOutput(result.output);
-      if (!parsed) {
-        return {
-          ok: false,
-          result: { error: "Failed to parse tester output: no JSON found", provider },
-          summary: "Tester output parse error: no JSON found"
-        };
-      }
+  isSuccessful(parsed) {
+    const verdict = parsed.verdict || (parsed.tests_pass ? "pass" : "fail");
+    return verdict === "pass";
+  }
 
-      const verdict = parsed.verdict || (parsed.tests_pass ? "pass" : "fail");
-      const ok = verdict === "pass";
-      const coverage = parsed.coverage || {};
+  buildSuccessResult(parsed, provider) {
+    const verdict = parsed.verdict || (parsed.tests_pass ? "pass" : "fail");
+    return {
+      tests_pass: Boolean(parsed.tests_pass),
+      coverage: parsed.coverage || {},
+      missing_scenarios: parsed.missing_scenarios || [],
+      quality_issues: parsed.quality_issues || [],
+      verdict,
+      provider
+    };
+  }
 
-      return {
-        ok,
-        result: {
-          tests_pass: Boolean(parsed.tests_pass),
-          coverage,
-          missing_scenarios: parsed.missing_scenarios || [],
-          quality_issues: parsed.quality_issues || [],
-          verdict,
-          provider
-        },
-        summary: (() => {
-          const missingPart = parsed.missing_scenarios?.length ? `; ${parsed.missing_scenarios.length} missing scenario(s)` : "";
-          const qualityPart = parsed.quality_issues?.length ? `; ${parsed.quality_issues.length} quality issue(s)` : "";
-          return `Verdict: ${verdict}; Coverage: ${coverage.overall ?? "?"}%${missingPart}${qualityPart}`;
-        })()
-      };
-    } catch (err) {
-      return {
-        ok: false,
-        result: { error: `Failed to parse tester output: ${err.message}`, provider },
-        summary: `Tester output parse error: ${err.message}`
-      };
-    }
+  buildSummary(parsed) {
+    const verdict = parsed.verdict || (parsed.tests_pass ? "pass" : "fail");
+    const coverage = parsed.coverage || {};
+    const coverageStr = coverage.overall != null ? `${coverage.overall}%` : "not measured";
+    const missingPart = parsed.missing_scenarios?.length ? `; ${parsed.missing_scenarios.length} missing scenario(s)` : "";
+    const qualityPart = parsed.quality_issues?.length ? `; ${parsed.quality_issues.length} quality issue(s)` : "";
+    return `Verdict: ${verdict}; Coverage: ${coverageStr}${missingPart}${qualityPart}`;
   }
 }