karajan-code 4.70.3 → 5.0.0

package/src/orchestrator/solomon-escalation.js

@@ -1,331 +0,0 @@
-import { SolomonRole } from "../roles/solomon-role.js";
-import { addCheckpoint, pauseSession, saveSession } from "../session/store.js";
-import { setSuggestions } from "../session/mutators.js";
-import { emitProgress, makeEvent } from "../utils/events.js";
-import { msg, getLang } from "../utils/messages.js";
-import { listPendingPaths } from "../utils/git.js";
-import { keepSymlinkTargets, symlinkTargets } from "../git/symlink-targets.js";
-
-/**
- * @typedef {import("../types/solomon.js").Conflict} Conflict
- * @typedef {import("../types/solomon.js").SolomonResult} SolomonResult
- */
-
-// KJC-BUG-0414 (#2606): the symlinks among the pending paths, so Solomon never advises taking a
-// link's target out of the commit. Unlistable is said, and Solomon goes on without the fact.
-async function changeSymlinks(config, logger) {
-  const projectDir = config.projectDir || process.cwd();
-  try {
-    return symlinkTargets(projectDir, await listPendingPaths(projectDir));
-  } catch (err) {
-    logger.warn(`Solomon: the change's symlinks could not be listed (${err.message})`);
-    return [];
-  }
-}
-
-function dropSymlinkTargetConditions(ruling, symlinks, logger) {
-  const conditions = ruling?.result?.conditions;
-  if (!Array.isArray(conditions) || symlinks.length === 0) return;
-  const { kept, dropped } = keepSymlinkTargets(conditions, symlinks);
-  if (dropped.length === 0) return;
-  ruling.result.conditions = kept;
-  logger.warn(`Solomon: dropped ${dropped.length} condition(s) that took a symlink's target out of the commit: ${dropped.join(" | ")}`);
-}
-
-/**
- * Architectural invariant (DO NOT BREAK):
- * `invokeSolomon` MUST NOT be called directly from stages, rules or agent
- * code. The only callers should be:
- *   - Karajan Brain (via `src/brain/solomon-consult.js`)
- *   - The orchestrator's escalation path (`src/orchestrator/flow-runner.js`)
- *     on behalf of Brain.
- * The v2.3.0 audit fixed 21 violations of this rule. Keeping Solomon behind
- * Brain is what the "Brain-as-gateway, Solomon-as-judge" architecture
- * depends on — see docs/ARCHITECTURE.md §Brain/Solomon.
- */
-
-/**
- * Build a human-readable escalation message from raw Solomon conflict data.
- * Replaces the raw JSON dump with structured, plain-text output.
- *
- * @param {object} solomonResult - The conflict object passed to escalateToHuman
- * @param {object} [session]     - Current session (optional, used for extra context)
- * @returns {string} Formatted message suitable for display to the user
- */
-export function formatEscalationMessage(solomonResult, session) {
-  const stage = solomonResult?.stage || "unknown";
-  const solomonReason = solomonResult?.solomonReason || null;
-  const history = solomonResult?.history || [];
-  const lang = getLang(session?.config_snapshot);
-
-  const lines = [];
-  lines.push(msg("solomon_conflict", lang, { stage }));
-  lines.push("");
-
-  // Extract reviewer/agent feedback from history
-  const feedbackEntries = history.filter(entry => entry && typeof entry === "object");
-  if (feedbackEntries.length > 0) {
-    lines.push(msg("solomon_feedback", lang));
-    for (const entry of feedbackEntries) {
-      const agent = entry.agent || "unknown";
-      const feedback = entry.feedback || "No feedback provided";
-      // Split multi-line feedback (e.g. "R-1: ...\nR-2: ...") into bullet points
-      const feedbackLines = String(feedback).split("\n").filter(l => l.trim());
-      if (feedbackLines.length === 1) {
-        lines.push(`  [${agent}] ${feedbackLines[0]}`);
-      } else {
-        lines.push(`  [${agent}]`);
-        for (const fl of feedbackLines) {
-          lines.push(`    - ${fl}`);
-        }
-      }
-    }
-    lines.push("");
-  }
-
-  // Solomon's reason (if it tried and failed)
-  if (solomonReason) {
-    lines.push(`${msg("solomon_reason", lang)} ${solomonReason}`);
-    lines.push("");
-  }
-
-  // Iteration context
-  const iterationCount = solomonResult?.iterationCount;
-  const maxIterations = solomonResult?.maxIterations;
-  if (iterationCount !== undefined && maxIterations !== undefined) {
-    lines.push(msg("pipeline_iteration", lang, { current: iterationCount, max: maxIterations }));
-    lines.push("");
-  }
-
-  lines.push(msg("solomon_options", lang));
-  lines.push("");
-  lines.push(msg("solomon_proceed", lang));
-
-  return lines.join("\n");
-}
-
-/**
- * Extract Solomon's previous rulings from session checkpoints.
- * Gives Solomon memory of its own decisions to avoid repeating failed strategies.
- */
-function extractSolomonHistory(session) {
-  const checkpoints = session?.checkpoints || [];
-  return checkpoints
-    .filter(cp => cp.stage === "solomon")
-    .map(cp => ({
-      conflictStage: cp.conflictStage,
-      ruling: cp.ruling,
-      alternativeAgent: cp.alternativeAgent,
-      waitUntil: cp.waitUntil,
-      conditions: cp.conditions,
-      error: cp.error || null
-    }));
-}
-
-/**
- * Consult Solomon (or fall back to human escalation) for a given conflict.
- * See the Conflict typedef for the shape of the `conflict` argument and
- * the invariant above for who is allowed to call this.
- *
- * @param {Object}    params
- * @param {Object}    params.config
- * @param {Object}    params.logger
- * @param {Object}    [params.emitter]
- * @param {Object}    [params.eventBase]
- * @param {string}    params.stage
- * @param {Conflict}  params.conflict
- * @param {Function}  [params.askQuestion]
- * @param {Object}    [params.session]
- * @param {number}    [params.iteration]
- * @returns {Promise<SolomonResult>}
- */
-export async function invokeSolomon({ config, logger, emitter, eventBase, stage, conflict, askQuestion, session, iteration }) {
-  const solomonEnabled = Boolean(config.pipeline?.solomon?.enabled);
-
-  if (!solomonEnabled) {
-    return escalateToHuman({ askQuestion, session, emitter, eventBase, stage, conflict, iteration });
-  }
-
-  // KJC-BUG-0113: the fallback used to be "gemini" — Google retired the
-  // Gemini Code Assist CLI for individuals (IneligibleTierError), so an
-  // unconfigured Solomon died on every escalation. Claude matches the
-  // brain.provider default.
-  const solomonProvider = config?.roles?.solomon?.provider || "claude";
-  emitProgress(
-    emitter,
-    makeEvent("solomon:start", { ...eventBase, stage: "solomon" }, {
-      message: `Solomon arbitrating ${stage} conflict`,
-      detail: { conflictStage: stage, provider: solomonProvider, executorType: "agent" }
-    })
-  );
-
-  // Collect pending suggestions from the session for Solomon's context
-  const pendingSuggestions = Array.isArray(session.suggestions) && session.suggestions.length > 0
-    ? session.suggestions.slice()
-    : null;
-
-  const solomon = new SolomonRole({ config, logger, emitter });
-  await solomon.init({ task: conflict.task, iteration });
-  let ruling;
-  try {
-    // Inject Solomon's own history so it doesn't repeat failed strategies
-    const solomonHistory = extractSolomonHistory(session);
-    const symlinks = await changeSymlinks(config, logger);
-    const enrichedConflict = {
-      ...conflict,
-      ...(pendingSuggestions && { hostSuggestions: pendingSuggestions }),
-      ...(solomonHistory.length > 0 && { previousSolomonRulings: solomonHistory }),
-      ...(symlinks.length > 0 && { symlinkTargets: symlinks })
-    };
-    ruling = await solomon.run({ conflict: enrichedConflict });
-    dropSymlinkTargetConditions(ruling, symlinks, logger);
-  } catch (err) {
-    logger.warn(`Solomon threw: ${err.message}`);
-    return escalateToHuman({
-      askQuestion, session, emitter, eventBase, stage, iteration,
-      conflict: { ...conflict, solomonReason: `Solomon error: ${err.message}` }
-    });
-  }
-
-  // Clear processed suggestions from session
-  if (pendingSuggestions) {
-    setSuggestions(session, []);
-    try { await saveSession(session); } catch { /* best-effort */ }
-  }
-
-  const solomonError = ruling.result?.error;
-  if (!ruling.ok && solomonError) {
-    logger.warn(`Solomon execution failed: ${solomonError}`);
-  }
-
-  emitProgress(
-    emitter,
-    makeEvent("solomon:end", { ...eventBase, stage: "solomon" }, {
-      message: ruling.ok
-        ? `Solomon ruling: ${ruling.result?.ruling || "unknown"}`
-        : `Solomon failed: ${(solomonError || ruling.summary || "unknown error").slice(0, 200)}`,
-      detail: { ...ruling.result, provider: solomonProvider, executorType: "agent" }
-    })
-  );
-
-  await addCheckpoint(session, {
-    stage: "solomon",
-    iteration,
-    conflictStage: conflict?.stage || stage,
-    ruling: ruling.result?.ruling,
-    alternativeAgent: ruling.result?.alternativeAgent || null,
-    waitUntil: ruling.result?.waitUntil || null,
-    conditions: ruling.result?.conditions || [],
-    escalate: ruling.result?.escalate,
-    error: solomonError ? solomonError.slice(0, 500) : undefined,
-    subtask: ruling.result?.subtask?.title || null
-  });
-
-  // Record the ruling for the session journal (decisions.md). Lazy-import so
-  // this module stays free of journal-specific deps for callers that don't
-  // need them.
-  try {
-    const { recordSolomonRuling } = await import("../session/journal/decisions-writer.js");
-    recordSolomonRuling(session, {
-      stage: conflict?.stage || stage,
-      trigger: conflict?.reason || conflict?.summary || "solomon invoked",
-      conflict: {
-        task: conflict?.task,
-        reason: conflict?.reason,
-        summary: conflict?.summary,
-        iterationCount: conflict?.iterationCount,
-      },
-      ruling: ruling.result?.ruling || (ruling.ok ? "continue" : "escalate_human"),
-      reasoning: ruling.result?.reasoning || ruling.summary || "",
-      conditions: ruling.result?.conditions || [],
-      alternativeAgent: ruling.result?.alternativeAgent || null,
-    });
-  } catch { /* best-effort, don't break the pipeline on a journal hiccup */ }
-
-  if (!ruling.ok) {
-    const reason = ruling.result?.escalate_reason || solomonError || ruling.summary;
-    return escalateToHuman({
-      askQuestion, session, emitter, eventBase, stage, iteration,
-      conflict: { ...conflict, solomonReason: reason }
-    });
-  }
-
-  const r = ruling.result?.ruling;
-  if (r === "approve") {
-    return { action: "approve", conditions: [], ruling };
-  }
-  if (r === "approve_with_conditions") {
-    return {
-      action: "continue",
-      conditions: ruling.result?.conditions || [],
-      extraIterations: ruling.result?.extraIterations || null,
-      alternativeAgent: ruling.result?.alternativeAgent || null,
-      waitUntil: ruling.result?.waitUntil || null,
-      ruling
-    };
-  }
-
-  if (r === "escalate_human") {
-    return escalateToHuman({
-      askQuestion, session, emitter, eventBase, stage, iteration,
-      conflict: { ...conflict, solomonReason: ruling.result?.escalate_reason || "Solomon escalated to human" }
-    });
-  }
-
-  if (r === "create_subtask") {
-    return { action: "subtask", subtask: ruling.result?.subtask, ruling };
-  }
-
-  return { action: "continue", conditions: [], ruling };
-}
-
-export function parseEscalationAnswer(answer) {
-  if (!answer) return null;
-  const trimmed = answer.trim().toLowerCase();
-  // Option 1: Accept coder's work as-is
-  if (trimmed === "1" || trimmed === "accept" || trimmed === "yes" || trimmed === "sí" || trimmed === "si") {
-    return { action: "continue", humanGuidance: "Accept coder's work as-is" };
-  }
-  // Option 2: Retry with reviewer's feedback
-  if (trimmed === "2" || trimmed === "retry") {
-    return { action: "continue", humanGuidance: "Retry with reviewer feedback" };
-  }
-  // Option 3: Stop the session
-  if (trimmed === "3" || trimmed.startsWith("stop") || trimmed.startsWith("pause")) {
-    return { action: "stop" };
-  }
-  // Free-text: treat as human guidance (backward compat)
-  return { action: "continue", humanGuidance: answer.trim() };
-}
-
-export async function escalateToHuman({ askQuestion, session, emitter, eventBase, stage, conflict, iteration }) {
-  const question = formatEscalationMessage({ ...conflict, stage }, session);
-
-  if (askQuestion) {
-    const answer = await askQuestion(question, { iteration, stage });
-    const parsed = parseEscalationAnswer(answer);
-    if (parsed && parsed.action === "continue") {
-      return { action: "continue", humanGuidance: parsed.humanGuidance };
-    }
-    if (parsed && parsed.action === "stop") {
-      // Fall through to pause session
-    } else if (answer) {
-      return { action: "continue", humanGuidance: answer };
-    }
-  }
-
-  await pauseSession(session, {
-    question,
-    context: { iteration, stage, conflict }
-  });
-  emitProgress(
-    emitter,
-    makeEvent("question", { ...eventBase, stage }, {
-      status: "paused",
-      message: question,
-      detail: { question, sessionId: session.id }
-    })
-  );
-
-  return { action: "pause", question };
-}

package/src/orchestrator/solomon-rules.js

@@ -1,212 +0,0 @@
-/**
- * Solomon rules engine — detects anomalies during session execution.
- * Each rule returns { triggered: boolean, severity: "warn"|"critical", message, detail }
- */
-
-const DEFAULT_RULES = {
-  max_stale_iterations: 3,
-  no_new_dependencies_without_task: true,
-  scope_guard: true,
-  reviewer_overreach: true,
-  reviewer_style_block: true
-};
-
-export function evaluateRules(context, rulesConfig = {}) {
-  const rules = { ...DEFAULT_RULES, ...rulesConfig };
-  const alerts = [];
-
-  // Rule 1: Stale iterations (no progress)
-  if (rules.max_stale_iterations && context.staleIterations >= rules.max_stale_iterations) {
-    alerts.push({
-      rule: "max_stale_iterations",
-      severity: "critical",
-      message: `${context.staleIterations} iterations without progress. Same errors repeating.`,
-      detail: { staleIterations: context.staleIterations, limit: rules.max_stale_iterations }
-    });
-  }
-
-  // Rule 3: New dependencies not in task (only flag suspicious runtime deps, not dev/test tooling)
-  if (rules.no_new_dependencies_without_task && context.newDependencies?.length > 0) {
-    const testTooling = /vitest|jest|mocha|coverage|eslint|prettier|typescript|@types\//i;
-    const buildTooling = /webpack|vite|rollup|esbuild|tsup|unbuild/i;
-    const depsNotInTask = context.newDependencies.filter(dep => {
-      if (testTooling.test(dep) || buildTooling.test(dep)) return false;
-      if (dep.startsWith("dev:") || dep.startsWith("@vitest/") || dep.startsWith("@types/")) return false;
-      return !context.task?.toLowerCase().includes(dep.toLowerCase());
-    });
-    if (depsNotInTask.length > 0) {
-      alerts.push({
-        rule: "no_new_dependencies_without_task",
-        severity: "warn",
-        message: `New dependencies added not mentioned in task: ${depsNotInTask.join(", ")}`,
-        detail: { dependencies: depsNotInTask }
-      });
-    }
-  }
-
-  // Rule 4: Scope guard — files outside expected scope
-  if (rules.scope_guard && context.outOfScopeFiles?.length > 0) {
-    alerts.push({
-      rule: "scope_guard",
-      severity: "warn",
-      message: `Files modified outside expected scope: ${context.outOfScopeFiles.join(", ")}`,
-      detail: { files: context.outOfScopeFiles }
-    });
-  }
-
-  // Rule 5: Reviewer overreach — reviewer consistently flags out-of-scope issues
-  if (rules.reviewer_overreach && context.reviewerDemotedCount > 0) {
-    const severity = context.reviewerDemotedCount >= 3 ? "critical" : "warn";
-    alerts.push({
-      rule: "reviewer_overreach",
-      severity,
-      message: `Reviewer flagged ${context.reviewerDemotedCount} out-of-scope issue(s) that were auto-demoted by scope filter.`,
-      detail: { demotedCount: context.reviewerDemotedCount, autoApproved: context.reviewerAutoApproved || false }
-    });
-  }
-
-  // Rule 6: Reviewer style-only block — all blocking issues are style/naming/formatting, not security/correctness
-  if (rules.reviewer_style_block && context.blockingIssues?.length > 0) {
-    const styleKeywords = /\b(naming|name|rename|style|format|formatting|indent|spacing|camelCase|snake_case|convention|cosmetic|readability|comment|jsdoc|documentation|whitespace|semicolon|quotes|trailing)\b/i;
-    // Anti-style: if any of these match, the issue is NOT style — it's a real correctness/security concern.
-    // Fixes KJC-BUG-0026 (Solomon approving legitimate security blockers misclassified as "style").
-    // Decomposed by concern (S5843, complexity 71 → 7 named groups).
-    // The union of tokens is byte-identical to the original alternation.
-    const SECURITY_KEYWORD_GROUPS = [
-      /\b(sql\s*injection|xss|csrf|ssrf|rce|injection|vulnerab|exploit)\b/i,
-      /\b(sanitiz|escape\b|encod\b|cors|traversal|prototype[-_\s]*pollution|deserializ)\b/i,
-      /\b(auth|authn|authz|password|secret|credential|token|api[-_\s]*key|private[-_\s]*key)\b/i,
-      /\b(hash|cipher|crypto|encrypt|decrypt|tls|ssl|certificate)\b/i,
-      /\b(leak|sensitive|pii|privacy|insecure|unsafe)\b/i,
-      /\b(race[-_\s]*condition|deadlock|memory[-_\s]*leak|null[-_\s]*deref|uaf|overflow)\b/i,
-      /\b(eval\b|exec\b|spawn|shell|command[-_\s]*injection)\b/i,
-    ];
-    const securityKeywords = { test: (text) => SECURITY_KEYWORD_GROUPS.some((re) => re.test(text)) };
-    const securityCategories = new Set(["security", "correctness", "bug", "vulnerability"]);
-    const styleSeverities = new Set(["low", "minor"]);
-    const blockingSeverities = new Set(["critical", "high", "blocker", "major"]);
-    const isSecurityIssue = issue => {
-      const desc = issue.description || "";
-      const sev = (issue.severity || "").toLowerCase();
-      const cat = (issue.category || issue.type || "").toLowerCase();
-      const tags = Array.isArray(issue.tags) ? issue.tags.map(t => String(t).toLowerCase()) : [];
-      if (blockingSeverities.has(sev)) return true;
-      if (securityCategories.has(cat)) return true;
-      if (tags.some(t => securityCategories.has(t))) return true;
-      return securityKeywords.test(desc);
-    };
-    const allStyle = context.blockingIssues.every(issue => {
-      if (isSecurityIssue(issue)) return false;
-      const desc = issue.description || "";
-      const sev = (issue.severity || "").toLowerCase();
-      return styleSeverities.has(sev) || styleKeywords.test(desc);
-    });
-    if (allStyle) {
-      alerts.push({
-        rule: "reviewer_style_block",
-        severity: "critical",
-        message: `Reviewer blocked on ${context.blockingIssues.length} style-only issue(s). Style preferences should not block approval — escalating to Solomon mediation.`,
-        detail: { issueCount: context.blockingIssues.length, issues: context.blockingIssues.map(i => i.description) }
-      });
-    }
-  }
-
-  return {
-    alerts,
-    hasCritical: alerts.some(a => a.severity === "critical"),
-    hasWarnings: alerts.some(a => a.severity === "warn")
-  };
-}
-
-/**
- * Build context for rules evaluation from git diff and session state.
- */
-export async function buildRulesContext({ session, task, iteration, blockingIssues }) {
-  const context = {
-    task,
-    iteration,
-    filesChanged: 0,
-    staleIterations: 0,
-    newDependencies: [],
-    outOfScopeFiles: [],
-    reviewerDemotedCount: 0,
-    reviewerAutoApproved: false,
-    blockingIssues: blockingIssues || []
-  };
-
-  // Count reviewer scope-filter demotions from session checkpoints
-  const scopeFilterCheckpoints = (session.checkpoints || [])
-    .filter(cp => cp.stage === "reviewer-scope-filter");
-  if (scopeFilterCheckpoints.length > 0) {
-    const latest = scopeFilterCheckpoints.at(-1);
-    context.reviewerDemotedCount = latest.demoted_count || 0;
-    context.reviewerAutoApproved = latest.auto_approved || false;
-  }
-
-  // Count files changed via git
-  try {
-    // Audit follow-up: was using execaCommand with template-string
-    // interpolation of `baseRef`. baseRef comes from session state, not
-    // user input, but the shape is a known shell-injection vector.
-    // Switched to execa with arg arrays so no shell expansion happens.
-    const { execa } = await import("execa");
-    const baseRef = session.session_start_sha || "HEAD~1";
-
-    // Files changed
-    const diffResult = await execa("git", ["diff", "--name-only", String(baseRef)], { reject: false });
-    if (diffResult.stdout) {
-      const files = diffResult.stdout.split("\n").filter(Boolean);
-      context.filesChanged = files.length;
-
-      // Detect scope: config files, CI/CD, etc. that are often out of scope
-      // Exclude .env.example (legitimate for new projects) and files within projectDir
-      const scopePatterns = [".github/", ".gitlab-ci", "docker-compose", "firebase.json", "firestore.rules"];
-      const projectDir = session?.config_snapshot?.projectDir || null;
-      context.outOfScopeFiles = files.filter(f => {
-        // Files inside projectDir are always in scope
-        if (projectDir && f.startsWith(projectDir.replace(/^\.\//, ""))) return false;
-        // .env (but not .env.example) is out of scope
-        if (f.endsWith(".env") && !f.endsWith(".env.example")) return true;
-        return scopePatterns.some(pattern => f.includes(pattern));
-      });
-
-      // Detect new dependencies
-      if (files.includes("package.json")) {
-        try {
-          const pkgDiff = await execa("git", ["diff", String(baseRef), "--", "package.json"], { reject: false });
-          const addedDeps = (pkgDiff.stdout || "").split("\n")
-            .filter(line => line.startsWith("+") && line.includes('"') && !line.startsWith("+++"))
-            .map(line => {
-              const match = /"([^"]+)":\s*"/.exec(line);
-              return match ? match[1] : null;
-            })
-            .filter(Boolean)
-            .filter(name => !new Set(["name", "version", "description", "main", "scripts", "type", "license", "author"]).has(name));
-          context.newDependencies = addedDeps;
-        } catch { /* ignore */ }
-      }
-    }
-  } catch { /* git not available */ }
-
-  // Count stale iterations from session checkpoints
-  // "Stale" means TRULY no progress: same exact feedback AND zero files changed
-  const checkpoints = session.checkpoints || [];
-  const reviewerCps = checkpoints.filter(cp => cp.stage === "reviewer").slice(-3);
-  const coderCps = checkpoints.filter(cp => cp.stage === "coder").slice(-3);
-
-  if (reviewerCps.length >= 3) {
-    const feedbacks = reviewerCps.map(cp => cp.note || "");
-    const uniqueFeedbacks = new Set(feedbacks);
-    const filesChanged = coderCps.some(cp => (cp.filesChanged || 0) > 0);
-
-    // Only stale if feedback is identical AND no files changed
-    if (uniqueFeedbacks.size === 1 && !filesChanged) {
-      context.staleIterations = reviewerCps.length;
-    }
-    // If issues are changing between iterations, there IS progress
-  }
-
-  return context;
-}
-
-export { DEFAULT_RULES };

package/src/orchestrator/stages/acceptance-coverage-stage.js

@@ -1,47 +0,0 @@
-// KJC-TSK-0987 (issue #1894): the acceptance-coverage stage. With a card whose
-// criteria the run was meant to implement, a different AI reads each criterion
-// against the diff before the run is approved. No card or no criteria: the
-// stage does not run and costs nothing. An unreadable verdict is the judge's
-// failure, never an approval.
-import { AcceptanceCoverageRole } from "../../roles/acceptance-coverage-role.js";
-import { emitProgress, makeEvent } from "../../utils/events.js";
-
-const STAGE = "acceptance-coverage";
-
-/** The feedback the coder gets: the criteria with no evidence in the diff. */
-export const uncoveredFeedback = (uncovered) => {
-  const lines = uncovered.map((c) => "- [" + c.index + "] " + c.text + (c.evidence ? " (judge: " + c.evidence + ")" : ""));
-  return "Acceptance criteria NOT covered by the diff (implement them, with tests that exercise them):\n" + lines.join("\n");
-};
-
-/**
- * @returns {Promise<{action: "skip"|"ok"|"retry"|"fail", stageResult?: object, feedback?: string}>}
- */
-export async function runAcceptanceCoverageStage({ config, logger, emitter, eventBase, trackBudget, iteration, task, criteria, diff, RoleClass = AcceptanceCoverageRole }) {
-  if (!Array.isArray(criteria) || criteria.length === 0) return { action: "skip" };
-  logger.setContext?.({ iteration, stage: STAGE });
-  emitProgress(emitter, makeEvent(`${STAGE}:start`, { ...eventBase, stage: STAGE }, {
-    message: `Acceptance coverage: ${criteria.length} criteria against the diff`,
-    detail: { criteria: criteria.length, executorType: "agent" },
-  }));
-  const role = new RoleClass({ config, logger, emitter });
-  await role.init({ task, iteration });
-  const started = Date.now();
-  const output = await role.run({ task, criteria, diff });
-  const provider = output.result?.provider || role.resolveProvider();
-  trackBudget?.({ role: STAGE, provider, model: config?.roles?.[STAGE]?.model || null, result: output, duration_ms: Date.now() - started });
-
-  if (!output.ok) {
-    const stageResult = { ok: false, summary: output.summary || "acceptance-coverage: the judge gave no verdict", provider, error: output.result?.error || null };
-    emitProgress(emitter, makeEvent(`${STAGE}:end`, { ...eventBase, stage: STAGE }, { status: "fail", message: stageResult.summary, detail: stageResult }));
-    return { action: "fail", stageResult };
-  }
-  const { criteria: verdicts, uncovered } = output.result;
-  const stageResult = { ok: uncovered.length === 0, summary: output.summary, provider, criteria: verdicts, uncovered };
-  emitProgress(emitter, makeEvent(`${STAGE}:end`, { ...eventBase, stage: STAGE }, {
-    status: stageResult.ok ? "ok" : "fail", message: output.summary, detail: stageResult,
-  }));
-  if (stageResult.ok) return { action: "ok", stageResult };
-  logger.warn(`${output.summary} — sending them back to the coder`);
-  return { action: "retry", stageResult, feedback: uncoveredFeedback(uncovered) };
-}