karajan-code 4.70.4 → 5.0.1

package/src/roles/researcher-role.js

@@ -1,70 +0,0 @@
-import { AgentRole } from "./agent-role.js";
-import { extractFirstJson } from "../utils/json-extract.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 researching the codebase."
-].join(" ");
-
-const EMPTY_RESEARCH = {
-  affected_files: [], patterns: [], constraints: [],
-  prior_decisions: [], risks: [], test_coverage: ""
-};
-
-export class ResearcherRole extends AgentRole {
-  constructor(opts) {
-    super({ ...opts, name: "researcher" });
-  }
-
-  async buildPrompt({ task }) {
-    const sections = [SUBAGENT_PREAMBLE];
-    if (this.instructions) sections.push(this.instructions);
-    sections.push(
-      "Investigate the codebase for the following task.",
-      "Identify affected files, patterns, constraints, prior decisions, risks, and test coverage.",
-      "Return a single valid JSON object with your findings and nothing else.",
-      '{"affected_files":[string],"patterns":[string],"constraints":[string],"prior_decisions":[string],"risks":[string],"test_coverage":string}',
-      `## Task\n${task}`
-    );
-    return { prompt: sections.join("\n\n") };
-  }
-
-  parseOutput(raw) { return extractFirstJson(raw); }
-
-  buildSuccessResult(parsed, provider) {
-    return {
-      affected_files: parsed.affected_files || [],
-      patterns: parsed.patterns || [],
-      constraints: parsed.constraints || [],
-      prior_decisions: parsed.prior_decisions || [],
-      risks: parsed.risks || [],
-      test_coverage: parsed.test_coverage || "",
-      provider
-    };
-  }
-
-  buildSummary(parsed) {
-    const files = parsed.affected_files?.length || 0;
-    const risks = parsed.risks?.length || 0;
-    const patterns = parsed.patterns?.length || 0;
-    const parts = [];
-    if (files) parts.push(`${files} file${files === 1 ? "" : "s"}`);
-    if (risks) parts.push(`${risks} risk${risks === 1 ? "" : "s"}`);
-    if (patterns) parts.push(`${patterns} pattern${patterns === 1 ? "" : "s"}`);
-    return parts.length ? `Research complete: ${parts.join(", ")} identified` : "Research complete";
-  }
-
-  handleParseNull(agentResult, provider) {
-    return {
-      ok: true,
-      result: { ...EMPTY_RESEARCH, raw: agentResult.output, provider },
-      summary: "Research complete (unstructured output)",
-      usage: agentResult.usage
-    };
-  }
-
-  handleParseError(_err, agentResult, provider) {
-    return this.handleParseNull(agentResult, provider);
-  }
-}

package/src/roles/reviewer-role.js

@@ -1,115 +0,0 @@
-import { createHash } from "node:crypto";
-
-import { AgentRole } from "./agent-role.js";
-import { buildRtkInstructions } from "../prompts/rtk-snippet.js";
-import { extractFirstJson } from "../utils/json-extract.js";
-import { reportUnparseableVerdict } from "../review/unparseable-verdict.js";
-import { section, buildPromptLayout, joinLayout, STABLE, VOLATILE } from "../prompts/prompt-layout.js";
-import { clipDiff } from "../prompts/diff-clip.js";
-import { buildSplitSignal } from "../prompts/split-signal.js";
-import { isMutationReviewEnabled, buildReviewerMutationSignal } from "../mutate/reviewer-signal.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 reviewing the code."
-].join(" ");
-
-export class ReviewerRole extends AgentRole {
-  constructor(opts) {
-    super({ ...opts, name: "reviewer" });
-  }
-
-  get agentMethod() { return "reviewTask"; }
-
-  extractInput(input) {
-    if (typeof input === "string") return { task: input, diff: "", reviewRules: null, onOutput: null };
-    return {
-      task: input?.task || this.context?.task || "",
-      diff: input?.diff || "",
-      reviewRules: input?.reviewRules || null,
-      onOutput: input?.onOutput || null
-    };
-  }
-
-  // Φ1-E (KJC-PCS-0057): stable block (preamble, instructions, mode,
-  // schema, contexts, rtk, review rules) first; task + diff — different
-  // on every review — last. The buckets ride along so ClaudeAgent can
-  // ship the stable block via --append-system-prompt (Φ1-D).
-  async buildPrompt({ task, diff, reviewRules }) {
-    // Opt-in (KJ_REVIEW_MUTATION): null when off/clean → prompt stays identical.
-    const mutationSignal = await buildReviewerMutationSignal({
-      enabled: isMutationReviewEnabled(),
-      projectDir: this.config?.projectDir,
-    });
-    // KJC-BUG-0134: a clip is declared as kj's own, outside the diff body.
-    const { body: clippedDiff, note: clipNote } = clipDiff(diff || "");
-    // KJC-BUG-0138: moved-lines correlation, computed on the FULL diff.
-    const splitSignal = buildSplitSignal(diff || "");
-    const layout = buildPromptLayout([
-      section(SUBAGENT_PREAMBLE, STABLE),
-      section(this.instructions, STABLE),
-      section(`You are a code reviewer in ${this.config?.review_mode || "standard"} mode.`, STABLE),
-      section("Return only one valid JSON object and nothing else.", STABLE),
-      section("JSON schema:", STABLE),
-      section('{"approved":boolean,"blocking_issues":[{"id":string,"severity":"critical|high|medium|low","file":string,"line":number,"description":string,"suggested_fix":string}],"non_blocking_suggestions":[string],"summary":string,"confidence":number}', STABLE),
-      section(this.config?.productContext ? `## Product Context\n${this.config.productContext}` : null, STABLE),
-      section(this.config?.domainContext ? `## Domain Context\n${this.config.domainContext}` : null, STABLE),
-      section(buildRtkInstructions({ rtkAvailable: Boolean(this.config?.rtk?.available) }), STABLE),
-      section(reviewRules ? `Review rules:\n${reviewRules}` : null, STABLE),
-      section(`Task context:\n${task}`, VOLATILE),
-      section(`Git diff:\n${clippedDiff}`, VOLATILE),
-      section(clipNote, VOLATILE),
-      section(splitSignal, VOLATILE),
-      section(mutationSignal, VOLATILE),
-    ]);
-    return { prompt: joinLayout(layout), stablePrompt: layout.stable, volatilePrompt: layout.volatile };
-  }
-
-  parseOutput(raw) {
-    const parsed = extractFirstJson(raw);
-    if (!parsed) throw new Error("Failed to parse reviewer output: no JSON found");
-    // KJC-BUG-0284 (#1982): a reviewer wrapped its verdict in the role envelope
-    // {ok, result: {approved…}, summary}; the envelope is not the verdict.
-    const verdict = typeof parsed.approved !== "boolean" && typeof parsed.result?.approved === "boolean"
-      ? { ...parsed.result, summary: parsed.result.summary ?? parsed.summary }
-      : parsed;
-    if (typeof verdict.approved !== "boolean") throw new Error("Failed to parse reviewer output: no boolean approved");
-    return verdict;
-  }
-
-  buildSuccessResult(parsed, provider, agentResult) {
-    return {
-      ...agentResult,
-      approved: parsed.approved,
-      blocking_issues: parsed.blocking_issues || [],
-      non_blocking_suggestions: parsed.non_blocking_suggestions || [],
-      confidence: parsed.confidence ?? null,
-      raw_summary: parsed.summary || ""
-    };
-  }
-
-  buildSummary(parsed) {
-    const blockingIssues = parsed.blocking_issues || [];
-    return parsed.approved
-      ? `Approved: ${parsed.summary || "no issues found"}`
-      : `Rejected: ${blockingIssues.length} blocking issue(s) — ${parsed.summary || ""}`;
-  }
-
-  // KJC-BUG-0284 (#1982): an unreadable answer is the reviewer's failure, not
-  // the coder's. Returned as ok=false so the retry and the fallback reviewer
-  // engage (reviewer-fallback.js); the raw answer is saved for inspection.
-  // Before, it came back as a PARSE_ERROR rejection: the coder read it as a
-  // defect of its code and one run went in circles for twenty minutes.
-  async handleParseError(err, agentResult, provider) {
-    const output = agentResult?.output;
-    const hash = createHash("sha256").update(String(output ?? "")).digest("hex").slice(0, 12);
-    const error = await reportUnparseableVerdict({ projectDir: this.config?.projectDir ?? process.cwd(), reviewer: provider, output, hash });
-    return {
-      ok: false,
-      result: { ...agentResult, error: `${err.message}\n${error}`, provider },
-      summary: `Reviewer output parse error: ${err.message}`,
-      usage: agentResult?.usage
-    };
-  }
-}

package/src/roles/security-role.js

@@ -1,73 +0,0 @@
-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 auditing code for security vulnerabilities."
-].join(" ");
-
-export class SecurityRole extends AgentRole {
-  constructor(opts) {
-    super({ ...opts, name: "security" });
-  }
-
-  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}`);
-
-    // Inject security-relevant skills (owasp-*, security-*, sast-*) filtered
-    // by role=security.
-    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: "security",
-    });
-    if (skillSection) sections.push(skillSection);
-
-    return { prompt: sections.join("\n\n") };
-  }
-
-  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 };
-  }
-
-  parseOutput(raw) { return extractFirstJson(raw); }
-
-  isSuccessful(parsed) {
-    const verdict = parsed.verdict || (parsed.vulnerabilities?.length ? "fail" : "pass");
-    return verdict === "pass";
-  }
-
-  buildSuccessResult(parsed, provider) {
-    const verdict = parsed.verdict || (parsed.vulnerabilities?.length ? "fail" : "pass");
-    return { vulnerabilities: parsed.vulnerabilities || [], verdict, provider };
-  }
-
-  buildSummary(parsed) {
-    const verdict = parsed.verdict || (parsed.vulnerabilities?.length ? "fail" : "pass");
-    const vulns = parsed.vulnerabilities || [];
-    if (!vulns.length) return `Verdict: ${verdict}; No vulnerabilities found`;
-
-    const bySeverity = {};
-    for (const v of vulns) bySeverity[v.severity || "unknown"] = (bySeverity[v.severity || "unknown"] || 0) + 1;
-
-    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 `Verdict: ${verdict}; ${parts.join(", ")}`;
-  }
-}

package/src/roles/solomon-role.js

@@ -1,271 +0,0 @@
-import { BaseRole } from "./base-role.js";
-import { createAgent as defaultCreateAgent } from "../agents/index.js";
-import { extractFirstJson } from "../utils/json-extract.js";
-import { withBrainRecovery } from "../brain/with-brain-recovery.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 resolving the conflict between agents."
-].join(" ");
-
-function resolveProvider(config) {
-  return (
-    config?.roles?.solomon?.provider ||
-    config?.roles?.coder?.provider ||
-    "claude"
-  );
-}
-
-function formatHistory(history) {
-  if (!history || history.length === 0) return "No previous interactions recorded.";
-
-  return history
-    .map((entry, i) => {
-      const agent = entry.agent || "unknown";
-      const feedback = entry.feedback || entry.message || "(no feedback)";
-      return `### Interaction ${i + 1} [${agent}]\n${feedback}`;
-    })
-    .join("\n\n");
-}
-
-function buildPrompt({ conflict, task, instructions }) {
-  const sections = [SUBAGENT_PREAMBLE];
-
-  if (instructions) {
-    sections.push(instructions);
-  }
-
-  sections.push(
-    "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.",
-    "- 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",
-    "",
-    "## 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,"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";
-  const iterationCount = conflict?.iterationCount ?? "?";
-  const maxIterations = conflict?.maxIterations ?? "?";
-
-  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}`,
-    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)}`);
-  }
-
-  if (conflict?.blockingIssues?.length) {
-    const issueList = conflict.blockingIssues
-      .map((issue, i) => `${i + 1}. [${issue.severity || "unknown"}] ${issue.description || issue}`)
-      .join("\n");
-    sections.push(`## Blocking issues\n${issueList}`);
-  }
-
-  // KJC-BUG-0414 (#2606): taking a symlink's target out of the commit leaves the link dangling.
-  if (conflict?.symlinkTargets?.length) {
-    const links = conflict.symlinkTargets.map(({ link, target }) => `- ${link} -> ${target}`).join("\n");
-    sections.push(`## Symlinks in this change\n${links}\nEach target stays in the commit: never propose unstaging, removing or restoring it, or the link is committed dangling.`);
-  }
-
-  if (task) {
-    sections.push(`## Original task\n${task}`);
-  }
-
-  if (conflict?.diff) {
-    sections.push(`## Current diff\n${conflict.diff}`);
-  }
-
-  sections.push(`## Agent interaction history\n${formatHistory(conflict?.history)}`);
-
-  return sections.join("\n\n");
-}
-
-function parseSolomonOutput(raw) {
-  return extractFirstJson(raw);
-}
-
-function buildSummary(parsed) {
-  const ruling = parsed.ruling || "unknown";
-  const conditions = parsed.conditions || [];
-  const dismissed = parsed.dismissed || [];
-  const subtask = parsed.subtask || null;
-
-  if (ruling === "approve") {
-    const parts = ["Approved"];
-    if (dismissed.length > 0) parts.push(`${dismissed.length} dismissed`);
-    return parts.join("; ");
-  }
-
-  if (ruling === "approve_with_conditions") {
-    const parts = [`Approved with ${conditions.length} condition${conditions.length === 1 ? "" : "s"}`];
-    if (dismissed.length > 0) parts.push(`${dismissed.length} dismissed`);
-    return parts.join("; ");
-  }
-
-  if (ruling === "escalate_human") {
-    return `Escalated to human: ${parsed.escalate_reason || "ambiguous conflict"}`;
-  }
-
-  if (ruling === "create_subtask") {
-    return `Subtask created: ${subtask?.title || "unnamed subtask"}`;
-  }
-
-  return `Solomon ruling: ${ruling}`;
-}
-
-export class SolomonRole extends BaseRole {
-  constructor({ config, logger, emitter = null, createAgentFn = null }) {
-    super({ name: "solomon", config, logger, emitter });
-    this._createAgent = createAgentFn || defaultCreateAgent;
-  }
-
-  async execute(input) {
-    const conflict = input?.conflict || {};
-
-    const provider = resolveProvider(this.config);
-    const agent = this._createAgent(provider, this.config, this.logger);
-
-    const prompt = buildPrompt({
-      conflict,
-      task: this.context?.task || "",
-      instructions: this.instructions
-    });
-
-    // KJC-TSK-0413 step C: Solomon es BaseRole (no AgentRole) — wrap explícito.
-    const result = await withBrainRecovery({
-      agent, taskArgs: { prompt, role: "solomon" }, role: "solomon", provider,
-      emitter: this.emitter, logger: this.logger,
-    });
-
-    if (!result.ok) {
-      const recoveryNote = result.recovery?.class ? ` [${result.recovery.class}]` : "";
-      return {
-        ok: false,
-        result: {
-          error: result.error || result.output || `Solomon arbitration failed${recoveryNote}`,
-          provider, recovery: result.recovery, action: result.action,
-        },
-        summary: `Solomon failed${recoveryNote}: ${result.recovery?.message || result.error || "unknown error"}`
-      };
-    }
-
-    try {
-      const parsed = parseSolomonOutput(result.output);
-      if (!parsed) {
-        return {
-          ok: false,
-          result: { error: "Failed to parse Solomon output: no JSON found", provider },
-          summary: "Solomon output parse error: no JSON found"
-        };
-      }
-
-      const ruling = parsed.ruling || "approve";
-      const escalate = Boolean(parsed.escalate);
-      const ok = ruling !== "escalate_human";
-
-      return {
-        ok,
-        result: {
-          ruling,
-          classification: parsed.classification || [],
-          conditions: parsed.conditions || [],
-          dismissed: parsed.dismissed || [],
-          escalate,
-          escalate_reason: parsed.escalate_reason || null,
-          subtask: parsed.subtask || null,
-          provider
-        },
-        summary: buildSummary(parsed)
-      };
-    } catch (err) {
-      return {
-        ok: false,
-        result: { error: `Failed to parse Solomon output: ${err.message}`, provider },
-        summary: `Solomon output parse error: ${err.message}`
-      };
-    }
-  }
-}

package/src/roles/sonar-role.js

@@ -1,72 +0,0 @@
-import { BaseRole } from "./base-role.js";
-import { indexedFilesFrom, runSonarScan } from "../sonar/scanner.js";
-import { getQualityGateStatus, getOpenIssues } from "../sonar/api.js";
-import { shouldBlockByProfile, summarizeIssues } from "../sonar/enforcer.js";
-
-function normalizeIssues(rawIssues) {
-  return rawIssues.map((issue) => ({
-    severity: issue.severity || "UNKNOWN",
-    type: issue.type || "UNKNOWN",
-    file: issue.component || "",
-    line: issue.line || 0,
-    rule: issue.rule || "",
-    message: issue.message || ""
-  }));
-}
-
-export class SonarRole extends BaseRole {
-  constructor({ config, logger, emitter = null }) {
-    super({ name: "sonar", config, logger, emitter });
-  }
-
-  async execute(_input) {
-    // KJC-TSK-0839: verbose, so the scanner names every file it indexed.
-    const scan = await runSonarScan(this.config, null, { verbose: true });
-
-    if (!scan.ok) {
-      return {
-        ok: false,
-        result: {
-          projectKey: scan.projectKey || null,
-          gateStatus: null,
-          issues: [],
-          openIssuesTotal: 0,
-          issuesSummary: "",
-          blocking: false,
-          error: scan.stderr || scan.stdout || "Scan failed"
-        },
-        summary: `Sonar scan failed: ${scan.stderr || scan.stdout || "unknown error"}`
-      };
-    }
-
-    const gate = await getQualityGateStatus(this.config, scan.projectKey);
-    const openIssues = await getOpenIssues(this.config, scan.projectKey);
-    const issues = normalizeIssues(openIssues.issues || []);
-    const issuesSummary = summarizeIssues(openIssues.issues || []);
-
-    const profile = this.config.sonarqube?.enforcement_profile || "pragmatic";
-    const blocking = shouldBlockByProfile({
-      gateStatus: gate.status,
-      profile
-    });
-
-    return {
-      ok: !blocking,
-      result: {
-        projectKey: scan.projectKey,
-        indexedFiles: [...indexedFilesFrom(scan.stdout)],
-        gateStatus: gate.status,
-        conditions: gate.conditions || [],
-        issues,
-        openIssuesTotal: openIssues.total || 0,
-        issuesSummary,
-        blocking
-      },
-      summary: (() => {
-        const issuesPart = issuesSummary ? ` (${issuesSummary})` : "";
-        const blockingPart = blocking ? " [BLOCKING]" : "";
-        return `Quality gate: ${gate.status}; Issues: ${openIssues.total || 0}${issuesPart}${blockingPart}`;
-      })()
-    };
-  }
-}