karajan-code 1.59.0 → 2.0.0

package/src/commands/review.js

@@ -7,24 +7,24 @@ import { resolveReviewProfile } from "../review/profiles.js";
 
 export async function reviewCommand({ task, config, logger, baseRef }) {
   const reviewerRole = resolveRole(config, "reviewer");
-  await assertAgentsAvailable([reviewerRole.provider, config.reviewer_options?.fallback_reviewer]);
+  await assertAgentsAvailable([reviewerRole.provider]);
   logger.info(`Reviewer (${reviewerRole.provider}) starting...`);
   const reviewer = createAgent(reviewerRole.provider, config, logger);
 
   let diff;
-  if (config.becaria?.enabled) {
-    // BecarIA mode: read diff from open PR
-    const { detectRepo, detectPrNumber } = await import("../becaria/repo.js");
-    const { getPrDiff } = await import("../becaria/pr-diff.js");
+  if (config.ci?.enabled) {
+    // CI mode: read diff from open PR
+    const { detectRepo, detectPrNumber } = await import("../ci/repo.js");
+    const { getPrDiff } = await import("../ci/pr-diff.js");
     const repo = await detectRepo();
     const prNumber = await detectPrNumber();
     if (!prNumber) {
-      throw new Error("BecarIA enabled but no open PR found for current branch. Create a PR first or disable BecarIA.");
+      throw new Error("CI enabled but no open PR found for current branch. Create a PR first or disable CI.");
     }
-    logger.info(`BecarIA: reading PR diff #${prNumber}`);
+    logger.info(`CI: reading PR diff #${prNumber}`);
     diff = await getPrDiff(prNumber);
     // Store for dispatch later
-    config._becaria_pr = { repo, prNumber };
+    config._ci_pr = { repo, prNumber };
   } else {
     const resolvedBase = await computeBaseRef({ baseBranch: config.base_branch, baseRef });
     diff = await generateDiff({ baseRef: resolvedBase });
@@ -42,12 +42,12 @@ export async function reviewCommand({ task, config, logger, baseRef }) {
   console.log(result.output);
   logger.info(`Reviewer completed (exit ${result.exitCode})`);
 
-  // BecarIA: dispatch review result
-  if (config.becaria?.enabled && config._becaria_pr) {
+  // CI: dispatch review result
+  if (config.ci?.enabled && config._ci_pr) {
     try {
-      const { dispatchReview, dispatchComment } = await import("../becaria/dispatch.js");
-      const { repo, prNumber } = config._becaria_pr;
-      const bc = config.becaria;
+      const { dispatchReview, dispatchComment } = await import("../ci/dispatch.js");
+      const { repo, prNumber } = config._ci_pr;
+      const bc = config.ci;
 
       // Try to parse structured review from output
       let review;
@@ -61,18 +61,18 @@ export async function reviewCommand({ task, config, logger, baseRef }) {
       await dispatchReview({
         repo, prNumber, event,
         body: review.summary || result.output.slice(0, 500),
-        agent: "Reviewer", becariaConfig: bc
+        agent: "Reviewer", ciConfig: bc
       });
 
       await dispatchComment({
         repo, prNumber, agent: "Reviewer",
         body: `Standalone review: ${event}\n\n${review.summary || result.output.slice(0, 1000)}`,
-        becariaConfig: bc
+        ciConfig: bc
       });
 
-      logger.info(`BecarIA: dispatched review for PR #${prNumber}`);
+      logger.info(`CI: dispatched review for PR #${prNumber}`);
     } catch (err) {
-      logger.warn(`BecarIA dispatch failed (non-blocking): ${err.message}`);
+      logger.warn(`CI dispatch failed (non-blocking): ${err.message}`);
     }
   }
 }

package/src/commands/run.js

@@ -35,8 +35,7 @@ export async function runCommandHandler({ task, config, logger, flags }) {
   } catch { /* non-blocking */ }
 
   const requiredProviders = [
-    resolveRole(config, "coder").provider,
-    config.reviewer_options?.fallback_reviewer
+    resolveRole(config, "coder").provider
   ];
   if (config.pipeline?.reviewer?.enabled !== false) {
     requiredProviders.push(resolveRole(config, "reviewer").provider);

package/src/commands/status.js

@@ -5,7 +5,7 @@
 import { readRunLog } from "../utils/run-log.js";
 import { loadMostRecentSession } from "../session-store.js";
 import { buildDashboard } from "../utils/status-dashboard.js";
-import { getProxyStats } from "../proxy/proxy-lifecycle.js";
+
 
 /**
  * Run the `kj status` command: print a human-readable dashboard to stdout.
@@ -33,10 +33,4 @@ export async function statusCommand({ lines = 50, projectDir } = {}) {
 
   const dashboard = buildDashboard(session, logResult.lines || [], { stories });
   console.log(dashboard);
-
-  const proxyStats = getProxyStats();
-  if (proxyStats) {
-    console.log("");
-    console.log(`Proxy: port ${proxyStats.port}, ${proxyStats.requests} requests, ${proxyStats.bytes_in} bytes in, ${proxyStats.bytes_out} bytes out`);
-  }
 }

package/src/config.js

@@ -49,7 +49,7 @@ const DEFAULTS = {
     model: null,
     deterministic: true,
     retries: 1,
-    fallback_reviewer: "codex"
+    fallback_reviewer: null
   },
   development: {
     methodology: "tdd",
@@ -128,7 +128,7 @@ const DEFAULTS = {
   policies: {},
   serena: { enabled: false },
   planning_game: { enabled: false, project_id: null, codeveloper: null },
-  becaria: { enabled: false, review_event: "becaria-review", comment_event: "becaria-comment", comment_prefix: true },
+  ci: { enabled: false, review_event: "kj-review", comment_event: "kj-comment", comment_prefix: true },
   git: { auto_commit: false, auto_push: false, auto_pr: false, auto_rebase: true, branch_prefix: "feat/" },
   output: { report_dir: "./.reviews", log_level: "info", quiet: true },
   budget: {
@@ -159,50 +159,12 @@ const DEFAULTS = {
   failFast: {
     repeatThreshold: 2
   },
-  retry: {
-    max_attempts: 3,
-    initial_backoff_ms: 1000,
-    max_backoff_ms: 30000,
-    backoff_multiplier: 2,
-    jitter_factor: 0.1
-  },
   webperf: {
     enabled: true,
     devtools_mcp: false,
     thresholds: { lcp: 2500, cls: 0.1, inp: 200 }
   },
   telemetry: true,
-  proxy: {
-    enabled: true,
-    port: "auto",
-    compression: {
-      enabled: true,
-      ai_compression: false,
-      ai_model: "haiku",
-      ai_provider: "anthropic",
-      layers: {
-        git: true,
-        tests: true,
-        build: true,
-        infra: true,
-        packages: true,
-        read_dedup: true,
-        glob_truncate: true,
-        grep_collapse: true,
-      },
-      pressure_thresholds: {
-        low: 0.5,
-        medium: 0.8,
-        high: 0.9,
-      },
-    },
-    cache: {
-      persist_to_disk: true,
-      flush_interval_ms: 5000,
-    },
-    inject_prompts: true,
-    monitor: true,
-  },
   guards: {
     output: {
       enabled: true,
@@ -398,12 +360,12 @@ function applyMethodologyOverride(out, flags) {
   out.development.require_test_changes = methodology === "tdd";
 }
 
-function applyBecariaOverride(out, flags) {
-  out.becaria = out.becaria || { enabled: false };
-  if (flags.enableBecaria === undefined) return;
-  out.becaria.enabled = Boolean(flags.enableBecaria);
-  // BecarIA requires git automation (commit + push + PR)
-  if (out.becaria.enabled) {
+function applyCiOverride(out, flags) {
+  out.ci = out.ci || { enabled: false };
+  if (flags.enableCi === undefined) return;
+  out.ci.enabled = Boolean(flags.enableCi);
+  // CI requires git automation (commit + push + PR)
+  if (out.ci.enabled) {
     out.git.auto_commit = true;
     out.git.auto_push = true;
     out.git.auto_pr = true;
@@ -432,10 +394,6 @@ function applyMiscOverrides(out, flags) {
   if (flags.pgTask) out.planning_game.enabled = true;
   if (flags.pgProject) out.planning_game.project_id = flags.pgProject;
 
-  out.proxy = out.proxy || {};
-  if (flags.noProxy) out.proxy.enabled = false;
-  if (flags.proxyPort) out.proxy.port = flags.proxyPort;
-
   out.model_selection = out.model_selection || { enabled: true, tiers: {}, role_overrides: {} };
   if (flags.smartModels === true) out.model_selection.enabled = true;
   if (flags.smartModels === false || flags.noSmartModels === true) out.model_selection.enabled = false;
@@ -461,7 +419,7 @@ export function applyRunOverrides(config, flags) {
   applyPipelineOverrides(out, flags);
   applyScalarAndBooleanOverrides(out, flags);
   applyMethodologyOverride(out, flags);
-  applyBecariaOverride(out, flags);
+  applyCiOverride(out, flags);
   applyMiscOverrides(out, flags);
   applyOutputModeOverrides(out, flags);
 
@@ -479,7 +437,7 @@ const AGENT_MODEL_SIGNATURES = {
   gemini: ["gemini", "flash-"]
 };
 
-export function isModelCompatible(agent, model) {
+function isModelCompatible(agent, model) {
   if (!model || !agent) return true;
   const lower = model.toLowerCase();
 

package/src/domains/domain-loader.js

@@ -5,8 +5,8 @@
  * Project-local domains override user-global domains by directory name.
  */
 
-import { readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { readdir, readFile, mkdir, writeFile, stat } from "node:fs/promises";
+import { join, isAbsolute } from "node:path";
 import yaml from "js-yaml";
 import { getKarajanHome } from "../utils/paths.js";
 
@@ -103,8 +103,52 @@ function parseSections(content) {
   return sections;
 }
 
+/**
+ * Auto-detect project context files (README.md, CLAUDE.md) as lightweight domains.
+ * Used as fallback when no explicit .karajan/domains/ are configured.
+ *
+ * @param {string} projectDir — absolute path to project root
+ * @returns {Promise<DomainFile[]>}
+ */
+export async function autoDetectDomains(projectDir) {
+  if (!projectDir) return [];
+
+  const candidates = ["README.md", "CLAUDE.md", "docs/README.md"];
+  const detected = [];
+
+  for (const rel of candidates) {
+    const filePath = join(projectDir, rel);
+    let content;
+    try {
+      content = await readFile(filePath, "utf-8");
+    } catch { continue; }
+
+    if (!content || content.trim().length < 20) continue;
+
+    // Truncate to first 4000 chars to avoid bloating context
+    const trimmed = content.length > 4000 ? content.slice(0, 4000) + "\n\n[...truncated]" : content;
+
+    detected.push({
+      name: `auto:${rel}`,
+      description: `Auto-detected from ${rel}`,
+      tags: [],
+      version: "0.0.0",
+      author: "",
+      visibility: "private",
+      sources: [{ type: "auto-detect", note: rel }],
+      content: trimmed,
+      sections: parseSections(trimmed),
+      filePath,
+      origin: "auto-detect"
+    });
+  }
+
+  return detected;
+}
+
 /**
  * Load all domains from project-local and user-global directories.
+ * Falls back to auto-detecting README.md/CLAUDE.md when no explicit domains found.
  * Project-local domains override user-global domains when directory names match.
  *
  * @param {string|null} projectDir — absolute path to project root (null = user-global only)
@@ -119,7 +163,6 @@ export async function loadDomains(projectDir) {
   const projectDomains = projectDomainDir ? await scanDomainDir(projectDomainDir, "project") : [];
 
   // Build a map keyed by directory name for merge.
-  // We track by directory name (not domain name) because the override is by directory.
   const merged = new Map();
 
   for (const { dirName, domain } of userDomains) {
@@ -129,7 +172,14 @@ export async function loadDomains(projectDir) {
     merged.set(dirName, domain); // project overrides user
   }
 
-  return Array.from(merged.values());
+  const explicit = Array.from(merged.values());
+
+  // Fallback: auto-detect README.md, CLAUDE.md when no explicit domains found
+  if (explicit.length === 0 && projectDir) {
+    return autoDetectDomains(projectDir);
+  }
+
+  return explicit;
 }
 
 /**
@@ -162,3 +212,34 @@ async function scanDomainDir(dir, origin) {
 
   return results;
 }
+
+/**
+ * Persist an inline domain (text or file path) to .karajan/domains/inline/DOMAIN.md.
+ * If domainInput is a path to an existing .md file, reads its content.
+ * Otherwise treats it as inline text.
+ *
+ * @param {string} domainInput — inline text or absolute path to a .md file
+ * @param {string} projectDir — project root
+ */
+export async function persistInlineDomain(domainInput, projectDir) {
+  if (!domainInput || !projectDir) return;
+
+  let content = domainInput;
+
+  // If it looks like a file path, try to read it
+  if (isAbsolute(domainInput) && domainInput.endsWith(".md")) {
+    try {
+      const s = await stat(domainInput);
+      if (s.isFile()) {
+        content = await readFile(domainInput, "utf-8");
+      }
+    } catch { /* treat as inline text */ }
+  }
+
+  const domainDir = join(projectDir, ".karajan", "domains", "inline");
+  await mkdir(domainDir, { recursive: true });
+
+  const domainFile = join(domainDir, DOMAIN_FILE);
+  const wrapped = `---\nname: inline-domain\ndescription: Domain knowledge provided via --domain parameter\ntags: []\nversion: "0.0.0"\n---\n\n${content}\n`;
+  await writeFile(domainFile, wrapped, "utf-8");
+}

package/src/git/automation.js

@@ -110,7 +110,7 @@ export function buildPrBody({ task, stageResults }) {
 }
 
 /**
- * Create an early PR after the first coder iteration (BecarIA Gateway flow).
+ * Create an early PR after the first coder iteration (Karajan CI flow).
  * Commits, pushes, and creates a PR before the reviewer runs.
  * Returns { prNumber, prUrl, commits } or null if nothing to commit.
  */
@@ -125,10 +125,10 @@ export async function earlyPrCreation({ gitCtx, task, logger, session, stageResu
   }
 
   const commits = commitResult.commit ? [commitResult.commit] : [];
-  await addCheckpoint(session, { stage: "becaria-commit", committed: true });
+  await addCheckpoint(session, { stage: "ci-commit", committed: true });
 
   await pushBranch(gitCtx.branch);
-  await addCheckpoint(session, { stage: "becaria-push", branch: gitCtx.branch });
+  await addCheckpoint(session, { stage: "ci-push", branch: gitCtx.branch });
   logger.info(`Pushed branch for early PR: ${gitCtx.branch}`);
 
   const body = buildPrBody({ task, stageResults });
@@ -138,7 +138,7 @@ export async function earlyPrCreation({ gitCtx, task, logger, session, stageResu
     title: commitMessageFromTask(task),
     body
   });
-  await addCheckpoint(session, { stage: "becaria-pr", branch: gitCtx.branch, pr: prUrl });
+  await addCheckpoint(session, { stage: "ci-pr", branch: gitCtx.branch, pr: prUrl });
   logger.info(`Early PR created: ${prUrl}`);
 
   // Extract PR number from URL (e.g. https://github.com/owner/repo/pull/42)
@@ -147,7 +147,7 @@ export async function earlyPrCreation({ gitCtx, task, logger, session, stageResu
 }
 
 /**
- * Incremental push after each coder iteration (BecarIA Gateway flow).
+ * Incremental push after each coder iteration (Karajan CI flow).
  * Commits and pushes without creating a new PR.
  */
 export async function incrementalPush({ gitCtx, task, logger, session }) {
@@ -161,10 +161,10 @@ export async function incrementalPush({ gitCtx, task, logger, session }) {
   }
 
   const commits = commitResult.commit ? [commitResult.commit] : [];
-  await addCheckpoint(session, { stage: "becaria-incremental-commit", committed: true });
+  await addCheckpoint(session, { stage: "ci-incremental-commit", committed: true });
 
   await pushBranch(gitCtx.branch);
-  await addCheckpoint(session, { stage: "becaria-incremental-push", branch: gitCtx.branch });
+  await addCheckpoint(session, { stage: "ci-incremental-push", branch: gitCtx.branch });
   logger.info(`Incremental push: ${gitCtx.branch}`);
 
   return { commits };
@@ -202,7 +202,7 @@ export async function finalizeGitAutomation({ config, gitCtx, task, logger, sess
     logger.info(`Pushed branch: ${gitCtx.branch}`);
   }
 
-  let prUrl = session.becaria_pr_url || null;
+  let prUrl = session.ci_pr_url || null;
   if (config.git.auto_pr && !prUrl) {
     const body = buildPrBody({ task, stageResults });
     prUrl = await createPullRequest({
@@ -214,7 +214,7 @@ export async function finalizeGitAutomation({ config, gitCtx, task, logger, sess
     await addCheckpoint(session, { stage: "git-pr", branch: gitCtx.branch, pr: prUrl });
     logger.info("Pull request created");
   } else if (prUrl) {
-    logger.info(`PR already exists (BecarIA flow): ${prUrl}`);
+    logger.info(`PR already exists (CI flow): ${prUrl}`);
   }
 
   return { committed, branch: gitCtx.branch, prUrl, pr: prUrl, commits };

package/src/guards/output-guard.js

@@ -148,21 +148,4 @@ export function scanDiff(diff, config = {}) {
   return { pass: !hasCritical, violations };
 }
 
-/**
- * Run output guard on the current git diff.
- * This is the main entry point for the pipeline integration.
- */
-export async function runOutputGuard(config = {}, baseBranch = "main") {
-  const diffResult = await runCommand("git", ["diff", `origin/${baseBranch}...HEAD`]);
-  if (diffResult.exitCode !== 0) {
-    // Fallback: diff against HEAD~1
-    const fallback = await runCommand("git", ["diff", "HEAD~1"]);
-    if (fallback.exitCode !== 0) {
-      return { pass: true, violations: [], error: "Could not generate diff" };
-    }
-    return scanDiff(fallback.stdout, config);
-  }
-  return scanDiff(diffResult.stdout, config);
-}
-
 export { DESTRUCTIVE_PATTERNS, CREDENTIAL_PATTERNS, DEFAULT_PROTECTED_FILES };

package/src/mcp/handlers/direct-handlers.js

@@ -258,7 +258,7 @@ export async function handleReviewDirect(a, server, extra) {
   const logger = createLogger(config.output.log_level, "mcp");
 
   const reviewerRole = resolveRole(config, "reviewer");
-  await assertAgentsAvailable([reviewerRole.provider, config.reviewer_options?.fallback_reviewer]);
+  await assertAgentsAvailable([reviewerRole.provider]);
 
   const projectDir = await resolveProjectDir(server, a.projectDir);
   const runLog = createRunLog(projectDir);

package/src/mcp/handlers/run-handler.js

@@ -98,8 +98,7 @@ const PIPELINE_PROVIDER_ROLES = [
 
 function collectRequiredProviders(config) {
   const providers = [
-    resolveRole(config, "coder").provider,
-    config.reviewer_options?.fallback_reviewer
+    resolveRole(config, "coder").provider
   ];
   if (config.pipeline?.reviewer?.enabled !== false) {
     providers.push(resolveRole(config, "reviewer").provider);

package/src/mcp/sovereignty-guard.js

@@ -17,14 +17,14 @@ const ALLOWED_PARAMS = new Set([
   "enableTester", "enableSecurity", "enableImpeccable",
   "enableDiscover", "enableArchitect",
   "architectModel", "huFile",
-  "enableSerena", "enableBecaria",
+  "enableSerena", "enableCi",
   "reviewerFallback", "reviewerRetries",
   "mode", "maxIterations", "maxIterationMinutes", "maxTotalMinutes",
   "baseBranch", "baseRef", "methodology",
   "autoCommit", "autoPush", "autoPr", "autoRebase", "branchPrefix",
   "autoSimplify", "smartModels", "checkpointInterval",
   "taskType", "quiet", "noSonar", "enableSonarcloud",
-  "kjHome", "sonarToken", "timeoutMs",
+  "kjHome", "sonarToken", "timeoutMs", "domain",
   // Sovereign flags — validated below but still "known"
   "enableTriage", "enableHuReviewer",
 ]);

package/src/mcp/tools.js

@@ -79,7 +79,7 @@ export const tools = [
         architectModel: { type: "string" },
         huFile: { type: "string", description: "Path to YAML file with HU stories to certify before coding" },
         enableSerena: { type: "boolean" },
-        enableBecaria: { type: "boolean", description: "Enable BecarIA Gateway (early PR + dispatch comments/reviews)" },
+        enableCi: { type: "boolean", description: "Enable Karajan CI (early PR + dispatch comments/reviews)" },
         reviewerFallback: { type: "string" },
         reviewerRetries: { type: "number" },
         mode: { type: "string" },
@@ -104,7 +104,8 @@ export const tools = [
         enableSonarcloud: { type: "boolean", description: "Enable SonarCloud scan (complementary to SonarQube)" },
         kjHome: { type: "string" },
         sonarToken: { type: "string" },
-        timeoutMs: { type: "number" }
+        timeoutMs: { type: "number" },
+        domain: { type: "string", description: "Domain knowledge: inline text describing the project domain, or absolute path to a .md file. Auto-saved to .karajan/domains/ for the curator." }
       }
     }
   },

package/src/orchestrator/brain-coordinator.js

@@ -0,0 +1,165 @@
+// Brain Coordinator: integrates Karajan Brain + 5 support modules into the pipeline.
+// Replaces ad-hoc role-to-role communication with a central intelligence.
+
+import * as queue from "./feedback-queue.js";
+import * as enrich from "./feedback-enrichment.js";
+import { verifyCoderOutput, VerificationTracker } from "./verification-gate.js";
+import { executeActions } from "./direct-actions.js";
+import { compressRoleOutput, measureCompression } from "./role-output-compressor.js";
+
+/**
+ * @typedef {Object} BrainContext
+ * @property {Object} feedbackQueue - structured feedback queue
+ * @property {VerificationTracker} verificationTracker - tracks coder changes
+ * @property {Object} compressionStats - token savings per role
+ * @property {boolean} enabled - whether brain coordination is active
+ */
+
+/**
+ * Create a new brain context for a pipeline session.
+ */
+export function createBrainContext({ enabled = false } = {}) {
+  return {
+    feedbackQueue: queue.createQueue(),
+    verificationTracker: new VerificationTracker(),
+    compressionStats: { totalSaved: 0, perRole: {} },
+    enabled
+  };
+}
+
+/**
+ * Check if brain coordination is enabled for this config.
+ */
+export function isBrainEnabled(config) {
+  return Boolean(config?.brain?.enabled) || Boolean(config?.pipeline?.brain?.enabled);
+}
+
+/**
+ * After a role completes, push its feedback to the queue and compress.
+ * Returns the compressed output for passing to next role.
+ */
+export function processRoleOutput(ctx, { roleName, output, iteration }) {
+  if (!ctx.enabled) return output;
+
+  // Compress for next-role context
+  const compressed = compressRoleOutput(roleName, output);
+  const stats = measureCompression(output, compressed);
+  ctx.compressionStats.totalSaved += stats.savedTokens;
+  ctx.compressionStats.perRole[roleName] = stats;
+
+  // Extract feedback entries from specific role outputs
+  const entries = extractFeedbackEntries(roleName, output, iteration);
+  if (entries.length > 0) {
+    queue.addEntries(ctx.feedbackQueue, entries);
+    enrich.enrichQueue(ctx.feedbackQueue);
+    queue.deduplicate(ctx.feedbackQueue);
+    queue.prioritize(ctx.feedbackQueue);
+  }
+
+  return compressed;
+}
+
+/**
+ * Extract structured feedback entries from a role's output.
+ */
+function extractFeedbackEntries(roleName, output, iteration) {
+  if (!output || typeof output !== "object") return [];
+
+  const entries = [];
+  if (roleName === "reviewer" && output.blocking_issues) {
+    for (const issue of output.blocking_issues) {
+      entries.push({
+        source: "reviewer",
+        severity: issue.severity || "medium",
+        description: issue.description || "",
+        file: issue.file || null,
+        line: issue.line || null,
+        suggestedFix: issue.suggested_fix || null,
+        id: issue.id || null,
+        iteration
+      });
+    }
+  } else if (roleName === "tester" && output.verdict === "fail") {
+    const missing = output.missing_scenarios || [];
+    for (const scenario of missing) {
+      entries.push({
+        source: "tester",
+        severity: "high",
+        category: "tests",
+        description: `Missing scenario: ${scenario}`,
+        iteration
+      });
+    }
+    if (output.coverage?.overall != null && output.coverage.overall < 80) {
+      entries.push({
+        source: "tester",
+        severity: "high",
+        category: "tests",
+        description: `Coverage below 80% (${output.coverage.overall}%)`,
+        iteration
+      });
+    }
+  } else if (roleName === "security" && output.verdict === "fail") {
+    for (const vuln of output.vulnerabilities || []) {
+      entries.push({
+        source: "security",
+        severity: vuln.severity || "high",
+        category: "security",
+        description: vuln.description || "",
+        file: vuln.file || null,
+        line: vuln.line || null,
+        suggestedFix: vuln.fix_suggestion || null,
+        iteration
+      });
+    }
+  }
+  return entries;
+}
+
+/**
+ * Before coder runs, format the feedback queue as an actionable prompt.
+ */
+export function buildCoderFeedbackPrompt(ctx) {
+  if (!ctx.enabled || ctx.feedbackQueue.entries.length === 0) return null;
+  return enrich.formatEnrichedForCoder(ctx.feedbackQueue.entries);
+}
+
+/**
+ * After coder runs, verify changes were made. Returns verification result.
+ */
+export function verifyCoderRan(ctx, { baseRef, projectDir }) {
+  if (!ctx.enabled) return { passed: true, filesChanged: 0, reason: "brain disabled" };
+  const result = verifyCoderOutput({ baseRef, projectDir });
+  ctx.verificationTracker.record(result);
+  return result;
+}
+
+/**
+ * Execute direct actions (npm install, gitignore updates, etc.).
+ */
+export async function runDirectActions(ctx, actions, { cwd } = {}) {
+  if (!ctx.enabled || !actions?.length) return [];
+  return executeActions(actions, { cwd });
+}
+
+/**
+ * Clear feedback queue after coder addresses it.
+ */
+export function clearFeedback(ctx) {
+  if (!ctx.enabled) return;
+  queue.clear(ctx.feedbackQueue);
+}
+
+/**
+ * Get a summary of brain activity for the session.
+ */
+export function summarize(ctx) {
+  if (!ctx.enabled) return null;
+  return {
+    feedbackQueueSize: ctx.feedbackQueue.entries.length,
+    queueCategories: queue.countByCategory(ctx.feedbackQueue),
+    consecutiveVerificationFailures: ctx.verificationTracker.consecutiveFailures,
+    compressionSaved: ctx.compressionStats.totalSaved,
+    compressionPerRole: ctx.compressionStats.perRole
+  };
+}