karajan-code 4.70.4 → 5.0.1

package/src/roles/karajan-brain-role.js

@@ -1,134 +0,0 @@
-import { AgentRole } from "./agent-role.js";
-import { extractFirstJson } from "../utils/json-extract.js";
-
-const BRAIN_PREAMBLE = [
-  "You are Karajan Brain, the central orchestrator of a multi-agent AI coding pipeline.",
-  "You receive the output of a role that just completed and decide what happens next.",
-  "Your decisions MUST be intelligent, context-aware, and token-efficient.",
-  "Do NOT execute the task yourself — you route, enrich, and control the flow."
-].join(" ");
-
-/**
- * KarajanBrainRole — AI-powered central orchestrator.
- * Receives role outputs and decides: next role, enriched prompt, direct actions.
- * Only consults Solomon when facing a genuine dilemma.
- */
-export class KarajanBrainRole extends AgentRole {
-  constructor(opts) {
-    super({ ...opts, name: "karajan-brain" });
-  }
-
-  resolveProvider() {
-    return (
-      this.config?.roles?.["karajan-brain"]?.provider ||
-      this.config?.brain?.provider ||
-      this.config?.roles?.coder?.provider ||
-      "claude"
-    );
-  }
-
-  extractInput(input) {
-    return {
-      currentRole: input?.currentRole || null,
-      roleOutput: input?.roleOutput || null,
-      pipelineState: input?.pipelineState || {},
-      availableRoles: input?.availableRoles || [],
-      task: input?.task || this.context?.task || "",
-      onOutput: input?.onOutput || null
-    };
-  }
-
-  async buildPrompt({ currentRole, roleOutput, pipelineState, availableRoles, task }) {
-    const sections = [BRAIN_PREAMBLE];
-    if (this.instructions) sections.push(this.instructions);
-
-    sections.push(
-      "## Current pipeline state",
-      `Task: ${task}`,
-      `Last role executed: ${currentRole || "none"}`,
-      `Available roles: ${availableRoles.join(", ") || "coder, reviewer, tester, security"}`,
-      `Iteration: ${pipelineState.iteration || 0}/${pipelineState.maxIterations || 5}`
-    );
-
-    if (pipelineState.filesChanged != null) {
-      sections.push(`Files changed so far: ${pipelineState.filesChanged}`);
-    }
-    if (pipelineState.budget) {
-      sections.push(`Budget used: $${pipelineState.budget.cost_usd?.toFixed(2) || 0}`);
-    }
-
-    if (roleOutput) {
-      const outputStr = typeof roleOutput === "string" ? roleOutput : JSON.stringify(roleOutput, null, 2);
-      const truncated = outputStr.length > 3000 ? outputStr.slice(0, 3000) + "...[truncated]" : outputStr;
-      sections.push(`## Output from ${currentRole}`, truncated);
-    }
-
-    sections.push(
-      "## Your decision",
-      "Return a single JSON object with your routing decision:",
-      "```json",
-      "{",
-      '  "nextRole": "coder|reviewer|tester|security|solomon|done",',
-      '  "enrichedPrompt": "string with specific instructions for the next role, or null to use default",',
-      '  "directActions": [{"type": "run_command|create_file|update_gitignore", "params": {}}],',
-      '  "reasoning": "why this decision",',
-      '  "consultSolomon": false,',
-      '  "dilemma": null',
-      "}",
-      "```",
-      "",
-      "Guidelines:",
-      "- If coder produced 0 file changes and there's reviewer feedback: enrich the prompt with concrete file paths and resend to coder",
-      "- If tests are failing but node_modules missing: directAction to run npm install",
-      '- If you cannot decide or face a genuine dilemma (security vs deadline, conflicting gates): set consultSolomon=true and describe the dilemma',
-      "- If the pipeline should end (approved, max iterations, unrecoverable): set nextRole=done"
-    );
-
-    return { prompt: sections.join("\n\n") };
-  }
-
-  parseOutput(raw) {
-    return extractFirstJson(raw);
-  }
-
-  buildSuccessResult(parsed, provider) {
-    return {
-      nextRole: parsed.nextRole || "coder",
-      enrichedPrompt: parsed.enrichedPrompt || null,
-      directActions: Array.isArray(parsed.directActions) ? parsed.directActions : [],
-      reasoning: parsed.reasoning || "",
-      consultSolomon: Boolean(parsed.consultSolomon),
-      dilemma: parsed.dilemma || null,
-      provider
-    };
-  }
-
-  buildSummary(parsed) {
-    const next = parsed.nextRole || "unknown";
-    const actions = Array.isArray(parsed.directActions) ? parsed.directActions.length : 0;
-    const solomon = parsed.consultSolomon ? " (consulting Solomon)" : "";
-    return `Brain: next=${next}, ${actions} direct action(s)${solomon}`;
-  }
-
-  handleParseNull(agentResult, provider) {
-    // Fallback: continue with default flow
-    return {
-      ok: true,
-      result: {
-        nextRole: "coder",
-        enrichedPrompt: null,
-        directActions: [],
-        reasoning: "Unstructured output — falling back to default flow",
-        consultSolomon: false,
-        dilemma: null,
-        provider
-      },
-      summary: "Brain: fallback to default flow (unstructured output)",
-      usage: agentResult.usage
-    };
-  }
-
-  handleParseError(_err, agentResult, provider) {
-    return this.handleParseNull(agentResult, provider);
-  }
-}

package/src/roles/perf-role.js

@@ -1,122 +0,0 @@
-/**
- * PerfRole — webperf quality gate (KJC-TSK-0150).
- *
- * Same shape as SonarRole / AuditRole: extends BaseRole, exposes an
- * `execute()` that returns `{ok, result, summary}`. Internally drives
- * `runWebperfScan` from src/webperf/scanner.js (the Lighthouse wrapper
- * added in KJC-TSK-0149) and persists the result so subsequent
- * `kj audit` runs surface it via `cwv-result` mode (KJC-TSK-0360).
- *
- * Configuration (kj.config.yml):
- *   webperf:
- *     url: http://localhost:3000   # required for the role to run
- *     preset: desktop              # or "mobile"
- *     thresholds: { lcp: { good: 2500, poor: 4000 }, ... }
- *     persist: true                # writes to ~/.karajan/webperf/<slug>/last.json
- *
- * Pipeline activation (KJC-TSK-0151) wires this role behind a triage-
- * driven flag so it only runs for frontend / fullstack tasks.
- */
-
-import fs from "node:fs/promises";
-import path from "node:path";
-import { BaseRole } from "./base-role.js";
-import { runWebperfScan } from "../webperf/scanner.js";
-
-function projectSlug(projectDir) {
-  return path.basename(projectDir || process.cwd()).replaceAll(/[^a-zA-Z0-9_-]/g, "_");
-}
-
-// Delegated to src/utils/paths.js (KJC-TSK-0420) — respects
-// KARAJAN_HOME / KJ_HOME / VITEST tmp / default.
-import { getWebperfDir } from "../utils/paths.js";
-function defaultPersistDir() { return getWebperfDir(); }
-
-async function persistResult(result, projectDir) {
-  if (!result?.ok) return null;
-  const dir = path.join(defaultPersistDir(), projectSlug(projectDir));
-  await fs.mkdir(dir, { recursive: true });
-  const filePath = path.join(dir, "last.json");
-  await fs.writeFile(filePath, JSON.stringify(result, null, 2), "utf8");
-  return filePath;
-}
-
-export class PerfRole extends BaseRole {
-  constructor({ config, logger, emitter = null, scanFn = null }) {
-    super({ name: "perf", config, logger, emitter });
-    // scanFn is injectable for tests so we don't need to mock execFile here.
-    this._scan = scanFn || runWebperfScan;
-  }
-
-  /**
-   * Run a webperf scan against the configured URL.
-   *
-   * @param {object} [_input] - unused; PerfRole reads its target from config
-   * @returns {Promise<{ok: boolean, result: object, summary: string}>}
-   */
-  async execute(_input) {
-    const webperfConfig = this.config?.webperf || {};
-    const url = webperfConfig.url;
-    const preset = webperfConfig.preset === "mobile" ? "mobile" : "desktop";
-    const thresholds = webperfConfig.thresholds || null;
-    const persist = webperfConfig.persist !== false;
-
-    if (!url) {
-      return {
-        ok: false,
-        result: { error: "config.webperf.url is required for PerfRole" },
-        summary: "PerfRole skipped: no config.webperf.url configured",
-      };
-    }
-
-    const scan = await this._scan(url, { preset, thresholds, logger: this.logger });
-
-    if (!scan.ok) {
-      return {
-        ok: false,
-        result: {
-          url,
-          error: scan.reason || "webperf scan failed",
-        },
-        summary: `Webperf scan failed: ${scan.reason || "unknown"}`,
-      };
-    }
-
-    let savedPath = null;
-    if (persist) {
-      try {
-        savedPath = await persistResult(scan, this.config?.projectDir);
-      } catch (err) {
-        if (this.logger?.warn) {
-          this.logger.warn(`PerfRole: failed to persist result (non-blocking): ${err.message}`);
-        }
-      }
-    }
-
-    const verdict = scan.cwv?.pass ? "PASS" : "FAIL";
-    const score = typeof scan.performanceScore === "number" ? scan.performanceScore : null;
-    const blockingMetrics = (scan.cwv?.blocking || []).map(b => `${b.metric.toUpperCase()}=${Math.round(b.value)}`).join(", ");
-    const summaryParts = [
-      `Webperf ${verdict}`,
-      score !== null ? `score ${score}/100` : null,
-      blockingMetrics ? `blocking: ${blockingMetrics}` : null,
-      `top opportunities: ${scan.issues?.length ?? 0}`,
-    ].filter(Boolean);
-
-    return {
-      ok: scan.cwv?.pass === true,
-      result: {
-        url: scan.url,
-        preset: scan.preset,
-        capturedAt: scan.capturedAt,
-        performanceScore: scan.performanceScore,
-        metrics: scan.metrics,
-        cwv: scan.cwv,
-        issues: scan.issues,
-        thresholds: scan.thresholds,
-        savedPath,
-      },
-      summary: summaryParts.join(" — "),
-    };
-  }
-}

package/src/roles/planner-role.js

@@ -1,151 +0,0 @@
-import { AgentRole } from "./agent-role.js";
-import { withBrainRecovery } from "../brain/with-brain-recovery.js";
-
-const RESEARCH_FIELDS = [
-  { key: "affected_files", label: "Affected files" },
-  { key: "patterns", label: "Patterns" },
-  { key: "constraints", label: "Constraints" },
-  { key: "risks", label: "Risks" },
-  { key: "prior_decisions", label: "Prior decisions" }
-];
-
-function appendDecompositionSection(sections, triageDecomposition) {
-  if (!triageDecomposition?.length) return;
-  sections.push("## Triage decomposition recommendation", "The triage stage determined this task should be decomposed. Suggested subtasks:");
-  for (let i = 0; i < triageDecomposition.length; i++) sections.push(`${i + 1}. ${triageDecomposition[i]}`);
-  sections.push("", "Focus your plan on the FIRST subtask only. List the remaining subtasks as 'pending_subtasks' in your output for documentation.", "");
-}
-
-function appendResearchSection(sections, research) {
-  if (!research) return;
-  sections.push("## Research findings");
-  for (const { key, label } of RESEARCH_FIELDS) {
-    if (research[key]?.length) sections.push(`${label}: ${research[key].join(", ")}`);
-  }
-  sections.push("");
-}
-
-function appendArchitectSection(sections, architectContext) {
-  if (!architectContext) return;
-  const arch = architectContext.architecture || {};
-  sections.push("## Architecture context");
-  if (arch.type) sections.push(`Type: ${arch.type}`);
-  if (arch.layers?.length) sections.push(`Layers: ${arch.layers.join(", ")}`);
-  if (arch.patterns?.length) sections.push(`Patterns: ${arch.patterns.join(", ")}`);
-  if (arch.dataModel?.entities?.length) sections.push(`Data model entities: ${arch.dataModel.entities.join(", ")}`);
-  if (arch.apiContracts?.length) sections.push(`API contracts: ${arch.apiContracts.join(", ")}`);
-  if (arch.tradeoffs?.length) sections.push(`Tradeoffs: ${arch.tradeoffs.join(", ")}`);
-  if (architectContext.summary) sections.push(`Summary: ${architectContext.summary}`);
-  sections.push("");
-}
-
-function resolveSilenceTimeoutMs(config) {
-  const minutes = Number(config?.session?.max_agent_silence_minutes);
-  return Number.isFinite(minutes) && minutes > 0 ? Math.round(minutes * 60 * 1000) : null;
-}
-
-function resolveRuntimeTimeoutMs(config) {
-  const minutes = Number(config?.session?.max_planner_minutes);
-  return Number.isFinite(minutes) && minutes > 0 ? Math.round(minutes * 60 * 1000) : null;
-}
-
-export class PlannerRole extends AgentRole {
-  constructor(opts) {
-    super({ ...opts, name: "planner" });
-  }
-
-  async execute(input) {
-    const { task: rawTask, onOutput } = typeof input === "string"
-      ? { task: input, onOutput: null }
-      : { task: input?.task || input || "", onOutput: input?.onOutput || null };
-
-    const task = rawTask || this.context?.task || "";
-    const research = this.context?.research || null;
-    const triageDecomposition = this.context?.triageDecomposition || null;
-    const architectContext = this.context?.architecture || null;
-
-    const sections = [];
-    if (this.instructions) sections.push(this.instructions, "");
-    // Tests-first planning (v2.7.5):
-    // The planner MUST emit structured acceptance tests for every step.
-    // These are the contract the coder is handed (phase 2 of the
-    // tests-first flow); the tester role later runs them as the
-    // pass/fail gate. Without them the coder has no executable spec.
-    sections.push(
-      "Create an implementation plan for this task as structured JSON.",
-      "",
-      "Output MUST be a JSON object with this exact shape:",
-      "",
-      "```json",
-      "{",
-      '  "approach": "<2-3 sentence high-level plan>",',
-      '  "risks": ["<risk 1>", "<risk 2>"],',
-      '  "outOfScope": ["<excluded item>"],',
-      '  "steps": [',
-      "    {",
-      '      "description": "<what this step achieves, one sentence>",',
-      '      "spec_section": "<short reference to the SPEC section this implements, e.g. \\"5.3\\" or \\"§5 Initial Scope\\". Optional but strongly preferred.>",',
-      '      "acceptance_tests": [',
-      '        { "type": "gherkin", "content": "Given <ctx>\\nWhen <action>\\nThen <outcome>" },',
-      '        { "type": "shell", "content": "<bash command that must exit 0>" }',
-      "      ]",
-      "    }",
-      "  ]",
-      "}",
-      "```",
-      "",
-      "Rules for acceptance_tests (CRITICAL — this is the contract the coder must satisfy):",
-      '- EVERY step MUST have at least one acceptance_test. No empty arrays.',
-      '- "gherkin" tests describe observable behaviour in natural language. Use them for end-to-end or user-facing assertions.',
-      '- "shell" tests are bash commands that exit 0 on success. Use them for concrete verifications (file exists, lint passes, specific exit code, HTTP status).',
-      '- Write tests BEFORE the step is implemented — they should fail until the step is done, pass afterwards.',
-      '- Prefer 2-4 tests per step: one happy-path, at least one edge case / failure path.',
-      '- Do NOT use the generic fallback "npx vitest run" (pre-v2.7.5 placeholder). Each test must assert something specific to the step.',
-      "",
-      "spec_section: when the task includes a structured SPEC (numbered headings like '## 5. Initial Scope'), every step MUST cite the section it implements. Becomes traceability metadata for the coder and reviewer.",
-      "",
-      "Steps must be ordered so that each depends only on previous steps (the first step has no prerequisites).",
-      "Return ONLY the JSON — no prose, no markdown fences around it.",
-      ""
-    );
-    if (this.config?.productContext) sections.push("## Product Context", this.config.productContext, "");
-    if (this.config?.domainContext) sections.push("## Domain Context", this.config.domainContext, "");
-    appendDecompositionSection(sections, triageDecomposition);
-    appendArchitectSection(sections, architectContext);
-    appendResearchSection(sections, research);
-    sections.push("## Task", task);
-
-    const provider = this.resolveProvider();
-    const agent = this.createAgentInstance(provider);
-    const runArgs = { prompt: sections.join("\n"), role: "planner" };
-    if (onOutput) runArgs.onOutput = onOutput;
-
-    const silenceMs = resolveSilenceTimeoutMs(this.config);
-    if (silenceMs) runArgs.silenceTimeoutMs = silenceMs;
-    const timeoutMs = resolveRuntimeTimeoutMs(this.config);
-    if (timeoutMs) runArgs.timeoutMs = timeoutMs;
-
-    // KJC-TSK-0413 step C: PlannerRole tiene execute() custom (no usa el de
-    // AgentRole). Wrap aquí también.
-    const result = await withBrainRecovery({
-      agent, taskArgs: runArgs, role: "planner", provider,
-      emitter: this.emitter, logger: this.logger,
-    });
-
-    if (!result.ok) {
-      const recoveryNote = result.recovery?.class ? ` [${result.recovery.class}]` : "";
-      return {
-        ok: false,
-        result: { ...result, error: result.error || result.output || `Planner agent failed${recoveryNote}`, plan: null, recovery: result.recovery, action: result.action },
-        summary: `Planner failed${recoveryNote}: ${result.recovery?.message || result.error || "unknown error"}`
-      };
-    }
-
-    const plan = result.output?.trim() || "";
-    return {
-      ok: true,
-      result: { ...result, plan, provider },
-      summary: plan ? `Plan generated (${plan.split("\n").length} lines)` : "Empty plan generated"
-    };
-  }
-}

package/src/roles/refactorer-role.js

@@ -1,30 +0,0 @@
-import { AgentRole } from "./agent-role.js";
-
-export class RefactorerRole extends AgentRole {
-  constructor(opts) {
-    super({ ...opts, name: "refactorer" });
-  }
-
-  resolveProvider() {
-    return this.config?.roles?.refactorer?.provider || this.config?.roles?.coder?.provider || "claude";
-  }
-
-  async buildPrompt({ task }) {
-    const sections = [];
-    if (this.instructions) sections.push(this.instructions, "");
-    sections.push(
-      "Refactor the current changes for clarity and maintainability without changing behavior.",
-      "Do not expand scope and keep tests green.",
-      "",
-      "## Task context",
-      task
-    );
-    return { prompt: sections.join("\n") };
-  }
-
-  buildSuccessResult(parsed, provider, agentResult) {
-    return { ...agentResult, output: (agentResult.output || "").trim(), provider };
-  }
-
-  buildSummary() { return "Refactoring applied"; }
-}

package/src/roles/repairer-role.js

@@ -1,181 +0,0 @@
-/**
- * RepairerRole — repairs broken acceptance tests at runtime.
- *
- * The Brain calls this when an HU's acceptance test has failed N
- * consecutive iterations with the same error signature, signalling
- * that the test ITSELF may be the bug (not the implementation).
- * Originated from the 2026-04-29 incident where the planner emitted
- * a syntactically-broken jq query in HU 002's acceptance_tests; the
- * coder iterated 3× trying to make an irreparable test pass; HU 002
- * → failed → 7 dependents blocked.
- *
- * The role takes the failing test + its error output + HU intent and
- * returns either a corrected test (`verdict: "fixable"` with
- * `fixed_test`) or an escalation (`verdict: "unfixable"` with reason).
- *
- * Behaviour notes:
- *  - The role MUST NOT soften assertions to make them pass — the test
- *    defines the contract; this role's job is to make the test ASK
- *    its question correctly, not weakly.
- *  - The role MUST NOT rewrite a test to pass against the current
- *    code. Code is measured against the test, not the other way.
- *  - One bug per repair. If the test is layered with problems, return
- *    the most blocking fix first; subsequent invocations handle the
- *    rest.
- */
-
-import { AgentRole } from "./agent-role.js";
-import { extractFirstJson } from "../utils/json-extract.js";
-import { loadAvailableSkills, buildSkillSection } from "../skills/skill-loader.js";
-
-const SUBAGENT_PREAMBLE = [
-  "IMPORTANT: You are running as a Karajan sub-agent.",
-  "Do NOT ask about using Karajan, do NOT mention Karajan, do NOT suggest orchestration.",
-  "Do NOT use any MCP tools. Focus only on diagnosing and (if possible) repairing a single broken acceptance test.",
-].join(" ");
-
-export class RepairerRole extends AgentRole {
-  constructor(opts) {
-    super({ ...opts, name: "repairer" });
-  }
-
-  resolveProvider() {
-    // Default to the same provider family the coder uses — keeps
-    // the repair attempt cheap and consistent. Per-role override
-    // works as for every other role.
-    return this.config?.roles?.repairer?.provider
-      || this.config?.roles?.coder?.provider
-      || this.config?.coder
-      || "claude";
-  }
-
-  /**
-   * Inputs:
-   *   - failingTest: the test object (`{ type, content }` or string).
-   *   - errorOutput: stdout+stderr from the last test run (truncated to
-   *     ~2KB to keep the prompt small).
-   *   - huTitle, huScope: intent context.
-   *   - siblingTests: the HU's other acceptance_tests (for consistency).
-   *   - iteration: how many coder iterations have already failed on this.
-   */
-  extractInput(input) {
-    if (typeof input === "string") {
-      return {
-        failingTest: input, errorOutput: "", huTitle: "", huScope: "",
-        siblingTests: [], iteration: 0, onOutput: null,
-      };
-    }
-    return {
-      failingTest: input?.failingTest ?? null,
-      errorOutput: input?.errorOutput ?? "",
-      huTitle: input?.huTitle ?? "",
-      huScope: input?.huScope ?? "",
-      siblingTests: Array.isArray(input?.siblingTests) ? input.siblingTests : [],
-      iteration: Number.isFinite(input?.iteration) ? input.iteration : 0,
-      onOutput: input?.onOutput ?? null,
-    };
-  }
-
-  async buildPrompt({ failingTest, errorOutput, huTitle, huScope, siblingTests, iteration }) {
-    const sections = [SUBAGENT_PREAMBLE];
-    if (this.instructions) sections.push(this.instructions);
-
-    const testContent = (failingTest && typeof failingTest === "object")
-      ? failingTest.content
-      : String(failingTest || "");
-    const testType = (failingTest && typeof failingTest === "object" && failingTest.type)
-      ? failingTest.type
-      : "shell";
-
-    sections.push(
-      "You are repairing a broken acceptance test. The coder has failed to satisfy it across multiple iterations,",
-      "and the Brain suspects the test ITSELF is the bug — not the implementation.",
-      "",
-      "## HU intent",
-      `Title: ${huTitle || "(unknown)"}`,
-      `Scope: ${huScope || "(unknown)"}`,
-      "",
-      `## Failing test (type: ${testType}, after ${iteration} iteration(s))`,
-      "```",
-      testContent,
-      "```",
-      "",
-      "## Last error output",
-      "```",
-      String(errorOutput || "").slice(0, 2048),
-      "```",
-    );
-
-    if (siblingTests.length > 0) {
-      sections.push("## HU's other acceptance tests (for consistency — do NOT modify these)", "```");
-      for (const t of siblingTests) {
-        const c = typeof t === "object" ? t.content : t;
-        sections.push(`- ${c}`);
-      }
-      sections.push("```");
-    }
-
-    sections.push(
-      "",
-      "## Your job",
-      "Decide whether the failing test is **fixable** (you can correct a syntactic / structural bug)",
-      "or **unfixable** (test is fundamentally impossible, or the test is correct and the code must change).",
-      "",
-      "Return ONLY a single valid JSON object:",
-      '{"verdict":"fixable"|"unfixable","fixed_test":{"type":"shell"|"gherkin","content":string}|null,"reason":string,"diagnostics":[string]}',
-      "",
-      "- When verdict=fixable, fixed_test is REQUIRED and reason describes the bug class.",
-      "- When verdict=unfixable, fixed_test is null and reason explains why.",
-      "- NEVER soften an assertion. NEVER rewrite to pass against current code.",
-    );
-
-    const projectDir = this.config?.projectDir || process.cwd();
-    const skills = await loadAvailableSkills(projectDir);
-    const skillSection = buildSkillSection(skills, {
-      provider: this._resolvedProvider || (typeof this.resolveProvider === "function" ? this.resolveProvider() : null),
-      role: "repairer",
-    });
-    if (skillSection) sections.push(skillSection);
-
-    return { prompt: sections.join("\n\n") };
-  }
-
-  parseOutput(raw) { return extractFirstJson(raw); }
-
-  isSuccessful(parsed) {
-    if (!parsed || typeof parsed !== "object") return false;
-    if (parsed.verdict === "fixable") {
-      // Must produce a complete fixed_test object.
-      const ft = parsed.fixed_test;
-      return Boolean(ft && typeof ft === "object" && typeof ft.content === "string" && ft.content.trim());
-    }
-    if (parsed.verdict === "unfixable") {
-      // Unfixable is a valid OUTCOME (escalation), not a role failure.
-      return Boolean(parsed.reason && String(parsed.reason).trim());
-    }
-    return false;
-  }
-
-  buildSuccessResult(parsed, provider) {
-    return {
-      verdict: parsed.verdict,
-      fixed_test: parsed.fixed_test || null,
-      reason: parsed.reason || "",
-      diagnostics: Array.isArray(parsed.diagnostics) ? parsed.diagnostics : [],
-      provider,
-    };
-  }
-
-  buildSummary(parsed) {
-    if (!parsed) return "Repairer: no parseable output";
-    if (parsed.verdict === "fixable") {
-      const reason = (parsed.reason || "").slice(0, 120);
-      return `Repairer: fixable — ${reason}`;
-    }
-    if (parsed.verdict === "unfixable") {
-      const reason = (parsed.reason || "").slice(0, 120);
-      return `Repairer: unfixable — ${reason}`;
-    }
-    return `Repairer: unexpected verdict "${parsed.verdict}"`;
-  }
-}