karajan-code 4.70.3 → 5.0.0

package/src/utils/display/formatters.js

@@ -1,132 +0,0 @@
-export const ANSI = {
-  reset: "\x1b[0m",
-  bold: "\x1b[1m",
-  dim: "\x1b[2m",
-  cyan: "\x1b[36m",
-  green: "\x1b[32m",
-  yellow: "\x1b[33m",
-  red: "\x1b[31m",
-  gray: "\x1b[90m",
-  white: "\x1b[37m",
-  magenta: "\x1b[35m"
-};
-
-export const ICONS = {
-  "session:start": "\u25b6",
-  "planner:start": "\ud83e\udde0",
-  "planner:end": "\ud83e\udde0",
-  "researcher:start": "\ud83d\udd2c",
-  "researcher:end": "\ud83d\udd2c",
-  "iteration:start": "\u25b6",
-  "coder:start": "\ud83d\udd28",
-  "coder:end": "\ud83d\udd28",
-  "refactorer:start": "\u267b\ufe0f",
-  "refactorer:end": "\u267b\ufe0f",
-  "tdd:result": "\ud83d\udccb",
-  "sonar:start": "\ud83d\udd0d",
-  "sonar:end": "\ud83d\udd0d",
-  "reviewer:start": "\ud83d\udc41\ufe0f",
-  "reviewer:end": "\ud83d\udc41\ufe0f",
-  "tester:start": "\ud83e\uddea",
-  "tester:end": "\ud83e\uddea",
-  "security:start": "\ud83d\udd12",
-  "security:end": "\ud83d\udd12",
-  "solomon:start": "\u2696\ufe0f",
-  "solomon:end": "\u2696\ufe0f",
-  "solomon:escalate": "\u26a0\ufe0f",
-  "agent:heartbeat": "\u23f3",
-  "coder:standby": "\u23f3",
-  "coder:standby_heartbeat": "\u23f3",
-  "coder:standby_resume": "\u25b6\ufe0f",
-  "budget:update": "\ud83d\udcb8",
-  "iteration:end": "\u23f1\ufe0f",
-  "session:end": "\ud83c\udfc1",
-  "discover:start": "\ud83d\udd0e",
-  "discover:end": "\ud83d\udd0e",
-  "architect:start": "\ud83c\udfdb\ufe0f",
-  "architect:end": "\ud83c\udfdb\ufe0f",
-  "hu-reviewer:start": "\ud83d\udcdd",
-  "hu-reviewer:end": "\ud83d\udcdd",
-  "impeccable:start": "\ud83c\udfa8",
-  "impeccable:end": "\ud83c\udfa8",
-  "audit:start": "\ud83d\udccb",
-  "audit:end": "\ud83d\udccb",
-  "sonarcloud:start": "\u2601\ufe0f",
-  "sonarcloud:end": "\u2601\ufe0f",
-  "preflight:start": "\ud83d\udee1\ufe0f",
-  "preflight:end": "\ud83d\udee1\ufe0f",
-  question: "\u2753"
-};
-
-export const STATUS_ICON = {
-  ok: `${ANSI.green}\u2705${ANSI.reset}`,
-  fail: `${ANSI.red}\u274c${ANSI.reset}`,
-  paused: `${ANSI.yellow}\u23f8\ufe0f${ANSI.reset}`,
-  running: `${ANSI.cyan}\u25b6${ANSI.reset}`
-};
-
-export const TRACKER_STATUS = {
-  done:    { icon: "\u2713", color: ANSI.green },
-  running: { icon: "\u25b6", color: ANSI.cyan },
-  failed:  { icon: "\u2717", color: ANSI.red }
-};
-
-export const TRACKER_DEFAULT = { icon: "\u00b7", color: ANSI.dim };
-
-/**
- * Format milliseconds into MM:SS string
- * @param {number} ms 
- * @returns {string}
- */
-export function formatElapsed(ms) {
-  const totalSec = Math.floor((ms || 0) / 1000);
-  const min = String(Math.floor(totalSec / 60)).padStart(2, "0");
-  const sec = String(totalSec % 60).padStart(2, "0");
-  return `${min}:${sec}`;
-}
-
-/**
- * Format executor details into a display string
- * @param {Object} detail 
- * @returns {string}
- */
-export function formatExecutor(detail) {
-  if (!detail) return '';
-  const provider = detail.provider || '';
-  const type = detail.executorType || '';
-  if (provider) return `  ${ANSI.dim}${provider}${ANSI.reset}`;
-  if (type === 'local') return `  ${ANSI.dim}local${ANSI.reset}`;
-  if (type === 'system') return `  ${ANSI.dim}system${ANSI.reset}`;
-  return '';
-}
-
-/**
- * Calculate budget ANSI color based on usage
- * @param {number} max 
- * @param {number} pct 
- * @param {number} warn 
- * @returns {string}
- */
-export function budgetColor(max, pct, warn) {
-  if (max > 0 && pct >= 100) return ANSI.red;
-  if (max > 0 && pct >= warn) return ANSI.yellow;
-  return ANSI.green;
-}
-
-export function roleStart(icon, label, provider) {
-  console.log(`  \u251c\u2500 ${icon} ${label} (${provider || "?"}) running...`);
-}
-
-export function roleEnd(status, label, elapsed, executor) {
-  console.log(`  \u251c\u2500 ${status} ${label} completed${executor || ''}  ${elapsed}`);
-}
-
-export function passFailStage(detail, label, failDefault, elapsed) {
-  const executor = formatExecutor(detail);
-  if (detail?.ok === false) {
-    const summary = detail?.summary || failDefault;
-    console.log(`  \u251c\u2500 ${ANSI.red}\u274c ${label}: ${summary}${ANSI.reset}${executor}  ${elapsed}`);
-  } else {
-    console.log(`  \u251c\u2500 ${ANSI.green}\u2705 ${label}: passed${ANSI.reset}${executor}  ${elapsed}`);
-  }
-}

package/src/utils/display/header.js

@@ -1,47 +0,0 @@
-import path from "node:path";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { printBanner } from "../banner.js";
-import { ANSI } from "./formatters.js";
-
-const DISPLAY_PKG_PATH = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../package.json");
-const DISPLAY_VERSION = JSON.parse(readFileSync(DISPLAY_PKG_PATH, "utf8")).version;
-
-const BAR = `${ANSI.dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${ANSI.reset}`;
-
-/**
- * Print task, configuration and pipeline header
- * @param {Object} params
- * @param {string} params.task
- * @param {Object} params.config
- */
-export function printHeader({ task, config }) {
-  const version = DISPLAY_VERSION;
-  // Force banner: caller already gates on !jsonMode, so if we're here it's a human-readable run
-  printBanner(version, { force: true });
-  console.log(`${ANSI.bold}Task:${ANSI.reset} ${task}`);
-  console.log(
-    `${ANSI.bold}Coder:${ANSI.reset} ${config.roles?.coder?.provider || config.coder} ${ANSI.dim}|${ANSI.reset} ${ANSI.bold}Reviewer:${ANSI.reset} ${config.roles?.reviewer?.provider || config.reviewer}`
-  );
-  console.log(
-    `${ANSI.bold}Max iterations:${ANSI.reset} ${config.max_iterations} ${ANSI.dim}|${ANSI.reset} ${ANSI.bold}Timeout:${ANSI.reset} ${config.session.max_total_minutes}min`
-  );
-
-  const pipeline = config.pipeline || {};
-  const activeRoles = [];
-  if (pipeline.planner?.enabled) activeRoles.push(`Planner (${config.roles?.planner?.provider || "?"})`);
-  if (pipeline.researcher?.enabled) activeRoles.push(`Researcher (${config.roles?.researcher?.provider || "?"})`);
-  if (pipeline.tester?.enabled) activeRoles.push("Tester");
-  if (pipeline.security?.enabled) activeRoles.push("Security");
-  if (pipeline.solomon?.enabled) {
-    const solomonProvider = config.roles?.solomon?.provider;
-    activeRoles.push(solomonProvider ? `Solomon (${solomonProvider})` : "Solomon");
-  }
-  if (activeRoles.length > 0) {
-    const separator = ` ${ANSI.dim}|${ANSI.reset} `;
-    console.log(`${ANSI.bold}Pipeline:${ANSI.reset} ${activeRoles.join(separator)}`);
-  }
-
-  console.log(BAR);
-  console.log();
-}

package/src/utils/display/session-summary.js

@@ -1,118 +0,0 @@
-import { ANSI } from "./formatters.js";
-
-export function printSessionStages(stages) {
-  if (!stages) return;
-  if (stages.researcher?.summary) {
-    console.log(`  ${ANSI.dim}\ud83d\udd2c Research: ${stages.researcher.summary}${ANSI.reset}`);
-  }
-  printSessionPlanner(stages.planner);
-  if (stages.tester?.summary) {
-    console.log(`  ${ANSI.dim}\ud83e\uddea Tester: ${stages.tester.summary}${ANSI.reset}`);
-  }
-  if (stages.security?.summary) {
-    console.log(`  ${ANSI.dim}\ud83d\udd12 Security: ${stages.security.summary}${ANSI.reset}`);
-  }
-  printSessionSonar(stages.sonar);
-}
-
-function printSessionPlanner(planner) {
-  if (!planner?.title && !planner?.approach && !planner?.completedSteps?.length) return;
-  const planParts = [];
-  if (planner.title) planParts.push(planner.title);
-  if (planner.approach) planParts.push(`approach: ${planner.approach}`);
-  console.log(`  ${ANSI.dim}\ud83d\uddfa Plan: ${planParts.join(" | ")}${ANSI.reset}`);
-  for (const step of planner.completedSteps || []) {
-    console.log(`  ${ANSI.dim}   \u2713 ${step}${ANSI.reset}`);
-  }
-}
-
-export function printSessionSonar(sonar) {
-  if (!sonar) return;
-  // Three buckets so the banner reads correctly:
-  //   - OK                                 \u2192 green (real pass).
-  //   - SKIPPED / PENDING                  \u2192 gray (informational; sonar
-  //     wasn't gated against, this is NOT a fail). Pre-2026-05-07 N4
-  //     dogfooding these were rendered red, which made a clean run
-  //     look like a sonar failure during the live demo.
-  //   - everything else (ERROR, WARN, ...) \u2192 red (real fail).
-  let gateLabel;
-  if (sonar.gateStatus === "OK") gateLabel = ANSI.green;
-  else if (sonar.gateStatus === "SKIPPED" || sonar.gateStatus === "PENDING") gateLabel = ANSI.gray;
-  else gateLabel = ANSI.red;
-  console.log(`  ${ANSI.dim}\ud83d\udd0d Sonar: ${gateLabel}${sonar.gateStatus}${ANSI.reset}${ANSI.dim} (${sonar.openIssues ?? 0} issues)${ANSI.reset}`);
-  if (typeof sonar.issuesInitial === "number" || typeof sonar.issuesResolved === "number") {
-    const issuesInitial = sonar.issuesInitial ?? sonar.openIssues ?? 0;
-    const issuesFinal = sonar.issuesFinal ?? sonar.openIssues ?? 0;
-    const issuesResolved = sonar.issuesResolved ?? Math.max(issuesInitial - issuesFinal, 0);
-    console.log(`  ${ANSI.dim}\ud83d\udee0 Issues: ${issuesInitial} detected, ${issuesFinal} open, ${issuesResolved} resolved${ANSI.reset}`);
-  }
-}
-
-export function printSessionGit(git) {
-  if (!git?.branch) return;
-  const parts = [`branch: ${git.branch}`];
-  if (git.committed) parts.push("committed");
-  if (git.pushed) parts.push("pushed");
-  if (git.pr || git.prUrl) parts.push(`PR: ${git.pr || git.prUrl}`);
-  console.log(`  ${ANSI.dim}\ud83d\udcce Git: ${parts.join(", ")}${ANSI.reset}`);
-  if (Array.isArray(git.commits) && git.commits.length > 0) {
-    console.log(`  ${ANSI.dim}\ud83e\uddfe Commits:${ANSI.reset}`);
-    for (const commit of git.commits) {
-      const shortHash = (commit.hash || "").slice(0, 7) || "unknown";
-      const message = commit.message || "";
-      console.log(`  ${ANSI.dim}   - ${shortHash} ${message}${ANSI.reset}`);
-    }
-  }
-}
-
-function isBudgetUnavailable(budget) {
-  return budget.usage_available === false ||
-    (budget.total_tokens === 0 && budget.total_cost_usd === 0 && Object.keys(budget.breakdown_by_role || {}).length > 0);
-}
-
-export function printSessionRtkSavings(rtkSavings) {
-  if (!rtkSavings || !rtkSavings.callCount) return;
-  const tokens = rtkSavings.estimatedTokensSaved ?? 0;
-  const ratio = rtkSavings.savedPct ?? 0;
-  const commands = rtkSavings.callCount ?? 0;
-  const original = rtkSavings.originalBytes ?? 0;
-  const compressed = rtkSavings.rtkBytes ?? 0;
-
-  if (tokens === 0 || ratio === 0) {
-    console.log(`  ${ANSI.dim}⚡ RTK: ${commands} commands wrapped, 0% savings — output was already minimal (${original} bytes in, ${compressed} bytes out)${ANSI.reset}`);
-  } else {
-    console.log(`  ${ANSI.dim}⚡ RTK: saved ~${tokens.toLocaleString()} tokens (${ratio}% compression, ${commands} commands, ${original.toLocaleString()} → ${compressed.toLocaleString()} bytes)${ANSI.reset}`);
-  }
-}
-
-export function printSessionBudget(budget) {
-  if (!budget) return;
-  if (isBudgetUnavailable(budget)) {
-    console.log(`  ${ANSI.dim}\ud83d\udcb0 Budget: N/A (provider does not report usage)${ANSI.reset}`);
-    return;
-  }
-  const estPrefix = budget.includes_estimates ? "~" : "";
-  const estNote = budget.includes_estimates ? " (includes estimates)" : "";
-  const fmtTokens = (n) => Number(n || 0).toLocaleString("en-US");
-  console.log(`  ${ANSI.dim}\ud83d\udcb0 Total tokens: ${estPrefix}${fmtTokens(budget.total_tokens)}${estNote}${ANSI.reset}`);
-  console.log(`  ${ANSI.dim}\ud83d\udcb0 Total cost: ${estPrefix}$${Number(budget.total_cost_usd || 0).toFixed(2)}${ANSI.reset}`);
-  // KJC-TSK-0274: KJ-vs-non-KJ comparison line when compression data exists.
-  const cmp = budget.kj_comparison;
-  if (cmp?.hasCompression) {
-    const wkCost = `$${Number(cmp.withKj?.cost || 0).toFixed(2)}`;
-    const wkTok = fmtTokens(Number(cmp.withKj?.tokens || 0));
-    const wnCost = `$${Number(cmp.withoutKj?.cost || 0).toFixed(2)}`;
-    const wnTok = fmtTokens(Number(cmp.withoutKj?.tokens || 0));
-    const pct = Math.round(Number(cmp.savedPct || 0));
-    console.log(`  ${ANSI.dim}   \u2937 With KJ: ${wkCost} / ${wkTok} tokens${ANSI.reset}`);
-    console.log(`  ${ANSI.dim}   \u2937 Without KJ: ~${wnCost} / ~${wnTok} tokens (-${pct}%)${ANSI.reset}`);
-  }
-  for (const [role, metrics] of Object.entries(budget.breakdown_by_role || {})) {
-    const tokens = Number(metrics.total_tokens || 0);
-    const cost = Number(metrics.total_cost_usd || 0);
-    if (tokens === 0 && cost === 0) continue; // skip roles with no usage
-    console.log(
-      `  ${ANSI.dim}   - ${role}: ${estPrefix}${fmtTokens(tokens)} tokens, ${estPrefix}$${cost.toFixed(2)}${ANSI.reset}`
-    );
-  }
-}

package/src/utils/display/solomon.js

@@ -1,42 +0,0 @@
-import { ANSI } from "./formatters.js";
-
-const SOLOMON_RULING_HANDLERS = {
-  approve(detail, elapsed) {
-    const dismissedCount = detail?.dismissed?.length || 0;
-    const dismissedSuffix = dismissedCount > 0 ? ` (${dismissedCount} dismissed)` : "";
-    console.log(`  \u251c\u2500 ${ANSI.green}\u2696\ufe0f Solomon: APPROVE${dismissedSuffix}${ANSI.reset}  ${elapsed}`);
-  },
-  approve_with_conditions(detail, elapsed) {
-    const condCount = detail?.conditions?.length || 0;
-    console.log(`  \u251c\u2500 ${ANSI.yellow}\u2696\ufe0f Solomon: ${condCount} condition${condCount === 1 ? "" : "s"}${ANSI.reset}  ${elapsed}`);
-    if (detail?.conditions) {
-      for (const cond of detail.conditions) {
-        console.log(`  \u2502   ${ANSI.dim}${cond}${ANSI.reset}`);
-      }
-    }
-  },
-  escalate_human(detail, elapsed) {
-    const reason = detail?.escalate_reason || "unknown reason";
-    console.log(`  \u251c\u2500 ${ANSI.red}\u2696\ufe0f Solomon: ESCALATE \u2014 ${reason}${ANSI.reset}  ${elapsed}`);
-  },
-  create_subtask(detail, elapsed) {
-    const subtaskTitle = detail?.subtask?.title || "untitled";
-    console.log(`  \u251c\u2500 ${ANSI.magenta}\u2696\ufe0f Solomon: SUBTASK \u2014 ${subtaskTitle}${ANSI.reset}  ${elapsed}`);
-  }
-};
-
-/**
- * Print Solomon ruling details
- * @param {Object} detail 
- * @param {string} elapsed 
- */
-export function printSolomonRuling(detail, elapsed) {
-  const ruling = detail?.ruling || "unknown";
-  const handler = SOLOMON_RULING_HANDLERS[ruling];
-  if (handler) {
-    handler(detail, elapsed);
-  } else {
-    const rulingUpper = ruling.toUpperCase().replaceAll("_", " ");
-    console.log(`  \u251c\u2500 \u2696\ufe0f Solomon: ${rulingUpper}  ${elapsed}`);
-  }
-}

package/src/utils/pricing.js

@@ -1,29 +0,0 @@
-import { buildDefaultPricingTable } from "../agents/model-registry.js";
-
-export const DEFAULT_MODEL_PRICING = buildDefaultPricingTable();
-
-export function calculateUsageCostUsd({ provider, model, tokens_in, tokens_out, pricing }) {
-  const table = pricing || DEFAULT_MODEL_PRICING;
-  
-  let entry = table[model];
-
-  if (!entry && provider && model) {
-    entry = table[`${provider}/${model}`];
-  }
-
-  if (!entry && model && model.includes("/")) {
-    const [, actualModel] = model.split("/");
-    entry = table[actualModel];
-  }
-
-  if (!entry) return 0;
-
-  const inputCost = (tokens_in * entry.input_per_million) / 1_000_000;
-  const outputCost = (tokens_out * entry.output_per_million) / 1_000_000;
-  return inputCost + outputCost;
-}
-
-export function mergePricing(defaults, overrides) {
-  if (!overrides || typeof overrides !== "object") return { ...defaults };
-  return { ...defaults, ...overrides };
-}

package/src/utils/quota-simulator.js

@@ -1,56 +0,0 @@
-// KJ_SIMULATE_QUOTA — testing hook for the standby flow. See
-// docs/quota-simulation.md. KJC-TSK-0493.
-
-let _warned = false;
-
-export function parseQuotaSimulationConfig(env = process.env) {
-  const trigger = env.KJ_SIMULATE_QUOTA;
-  if (!trigger) return null;
-  const m = /^after-iter-(\d+)$/i.exec(String(trigger).trim());
-  if (!m) {
-    if (!_warned) {
-      // eslint-disable-next-line no-console
-      console.warn(`[KJ_SIMULATE_QUOTA] Ignoring malformed value "${trigger}". Expected "after-iter-<N>".`);
-      _warned = true;
-    }
-    return null;
-  }
-  return {
-    afterIter: Number.parseInt(m[1], 10),
-    resetIso: env.KJ_SIMULATE_QUOTA_RESET || new Date(Date.now() + 3600_000).toISOString(),
-    agent: String(env.KJ_SIMULATE_QUOTA_AGENT || "claude").toLowerCase(),
-  };
-}
-
-const SYNTHETIC_MSG = {
-  claude: (iso) => `[KJ_SIMULATE_QUOTA] Claude Pro usage limit reached. weekly limit. resets at ${iso}`,
-  codex: () => `[KJ_SIMULATE_QUOTA] You have exceeded your current quota. retry after 60 seconds`,
-  gemini: () => `[KJ_SIMULATE_QUOTA] Resource exhausted: quota exceeded. retry after 60 seconds`,
-};
-
-export function buildSyntheticQuotaMessage(agent, resetIso) {
-  return (SYNTHETIC_MSG[agent] || SYNTHETIC_MSG.claude)(resetIso);
-}
-
-export function shouldSimulateQuota({ iteration, agent }, env = process.env) {
-  const cfg = parseQuotaSimulationConfig(env);
-  if (!cfg) return null;
-  if (Number(iteration) < cfg.afterIter) return null;
-  const a = String(agent || "").toLowerCase();
-  if (cfg.agent !== "any" && cfg.agent !== a) return null;
-  return { resetIso: cfg.resetIso, agent: a || cfg.agent };
-}
-
-// Mutates execResult: forces ok=false and prepends the synthetic quota
-// line to result.error so the existing detectRateLimit branch fires.
-export function applyQuotaSimulation(execResult, { iteration, agent }, env = process.env) {
-  const fire = shouldSimulateQuota({ iteration, agent }, env);
-  if (!fire || !execResult || typeof execResult !== "object") return false;
-  if (!execResult.result || typeof execResult.result !== "object") execResult.result = {};
-  execResult.result.error = `${buildSyntheticQuotaMessage(fire.agent, fire.resetIso)}\n${execResult.result.error || ""}`;
-  execResult.ok = false;
-  return true;
-}
-
-// Test seam — reset the one-shot warning between unit tests.
-export function _resetSimulatorWarning() { _warned = false; }

package/src/utils/role-assigner.js

@@ -1,137 +0,0 @@
-// Smart role assignment based on available AI agents.
-// Used by both kj init (interactive) and auto-init (non-interactive).
-
-import { detectAvailableAgents } from "./agent-detect.js";
-
-// Agent capability tiers (higher = more capable for complex reasoning)
-const CAPABILITY_TIERS = {
-  claude: 5, // Best for reasoning, orchestration, complex tasks
-  codex: 4,  // Strong coder, good reviewer
-  gemini: 3, // Good general purpose
-  aider: 2,  // Good coder, limited reasoning
-  opencode: 2 // Similar to aider
-};
-
-// Role requirements: what capability level is ideal for each role
-const ROLE_PREFERENCES = {
-  brain: { minTier: 4, prefer: "claude", description: "Karajan Brain (orchestrator)" },
-  // KJC-BUG-0113: Solomon preferred gemini, but Google retired the Gemini
-  // Code Assist CLI for individuals — a binary that answers --version yet
-  // dies with IneligibleTierError on every real call. Any machine with the
-  // stale CLI on PATH got a judge that could never rule. Claude matches
-  // the brain default; diversifyReviewer still picks a different agent
-  // when more than one healthy option exists.
-  solomon: { minTier: 3, prefer: "claude", description: "Solomon (judge/arbiter)" },
-  coder: { minTier: 2, prefer: "claude", description: "Coder" },
-  reviewer: { minTier: 3, prefer: "codex", description: "Reviewer" },
-  planner: { minTier: 4, prefer: "claude", description: "Planner" },
-  researcher: { minTier: 3, prefer: "claude", description: "Researcher" },
-  architect: { minTier: 4, prefer: "claude", description: "Architect" },
-  tester: { minTier: 3, prefer: "claude", description: "Tester" },
-  security: { minTier: 3, prefer: "claude", description: "Security" },
-  triage: { minTier: 3, prefer: "claude", description: "Triage" }
-};
-
-/**
- * Assign the best available agent to a role.
- * Prefers the role's preferred agent if available, then falls back by capability tier.
- */
-function assignRole(roleName, availableAgents) {
-  const pref = ROLE_PREFERENCES[roleName];
-  if (!pref) return availableAgents[0]?.name || "claude";
-
-  // Preferred agent available?
-  if (availableAgents.find(a => a.name === pref.prefer)) {
-    return pref.prefer;
-  }
-
-  // Sort by capability tier (descending) and pick the best available
-  const sorted = [...availableAgents].sort(
-    (a, b) => (CAPABILITY_TIERS[b.name] || 1) - (CAPABILITY_TIERS[a.name] || 1)
-  );
-
-  return sorted[0]?.name || "claude";
-}
-
-/**
- * Try to diversify: if possible, use a different agent for reviewer than coder.
- */
-function diversifyReviewer(coderAgent, availableAgents) {
-  const alternatives = availableAgents.filter(a => a.name !== coderAgent);
-  if (alternatives.length === 0) return coderAgent;
-
-  const sorted = [...alternatives].sort(
-    (a, b) => (CAPABILITY_TIERS[b.name] || 1) - (CAPABILITY_TIERS[a.name] || 1)
-  );
-  return sorted[0].name;
-}
-
-/**
- * Auto-assign all roles based on detected agents. Non-interactive.
- * Returns a config-ready object with role assignments.
- */
-export async function autoAssignRoles(logger) {
-  const agents = await detectAvailableAgents();
-  const available = agents.filter(a => a.available);
-
-  if (available.length === 0) {
-    logger?.warn?.("No AI agents detected. Using claude as default for all roles.");
-    return { assignments: getDefaultAssignments("claude"), agents, available: [] };
-  }
-
-  logger?.info?.(`Detected ${available.length} AI agent(s): ${available.map(a => `${a.name} (${a.version})`).join(", ")}`);
-
-  const coder = assignRole("coder", available);
-  const reviewer = available.length > 1 ? diversifyReviewer(coder, available) : coder;
-  const brain = assignRole("brain", available);
-  const solomon = available.length > 1 ? diversifyReviewer(brain, available) : brain;
-
-  const assignments = {
-    brain,
-    solomon,
-    coder,
-    reviewer,
-    planner: assignRole("planner", available),
-    researcher: assignRole("researcher", available),
-    architect: assignRole("architect", available),
-    tester: assignRole("tester", available),
-    security: assignRole("security", available),
-    triage: assignRole("triage", available)
-  };
-
-  logger?.info?.(`Role assignments: Brain=${brain}, Solomon=${solomon}, Coder=${coder}, Reviewer=${reviewer}`);
-
-  return { assignments, agents, available };
-}
-
-function getDefaultAssignments(agent) {
-  return {
-    brain: agent, solomon: agent, coder: agent, reviewer: agent,
-    planner: agent, researcher: agent, architect: agent,
-    tester: agent, security: agent, triage: agent
-  };
-}
-
-/**
- * Apply role assignments to a Karajan config object.
- */
-export function applyRoleAssignments(config, assignments) {
-  config.coder = assignments.coder;
-  config.reviewer = assignments.reviewer;
-
-  const roleNames = ["coder", "reviewer", "planner", "researcher", "architect",
-    "tester", "security", "triage", "solomon"];
-
-  for (const role of roleNames) {
-    config.roles = config.roles || {};
-    config.roles[role] = config.roles[role] || {};
-    config.roles[role].provider = assignments[role] || assignments.coder;
-  }
-
-  // Brain is a new top-level config (not in roles yet — will be when KarajanBrainRole is implemented)
-  config.brain = { provider: assignments.brain };
-
-  return config;
-}
-
-export { CAPABILITY_TIERS };

package/src/utils/rtk-wrapper.js

@@ -1,87 +0,0 @@
-import { runCommand } from "./process.js";
-
-/**
- * Commands that RTK can safely wrap for token-optimized output.
- */
-export const RTK_SUPPORTED_COMMANDS = [
-  "git", "ls", "find", "grep", "cat", "head", "tail",
-  "wc", "diff", "tree", "du", "file"
-];
-
-const supportedSet = new Set(RTK_SUPPORTED_COMMANDS);
-
-/**
- * Wrap a command with RTK if available and the command is in the whitelist.
- * @param {string} command
- * @param {string[]} args
- * @param {boolean} rtkAvailable
- * @returns {{ command: string, args: string[] }}
- */
-export function wrapWithRtk(command, args, rtkAvailable) {
-  if (rtkAvailable && supportedSet.has(command)) {
-    return { command: "rtk", args: [command, ...args] };
-  }
-  return { command, args };
-}
-
-/**
- * Session-level accumulator for RTK byte savings.
- */
-export class RtkSavingsTracker {
-  constructor() {
-    this.originalBytes = 0;
-    this.rtkBytes = 0;
-    this.callCount = 0;
-  }
-
-  record(originalSize, rtkSize) {
-    this.originalBytes += originalSize;
-    this.rtkBytes += rtkSize;
-    this.callCount += 1;
-  }
-
-  summary() {
-    const savedBytes = this.originalBytes - this.rtkBytes;
-    const savedPct = this.originalBytes > 0
-      ? Number(((savedBytes / this.originalBytes) * 100).toFixed(1))
-      : 0;
-    const estimatedTokensSaved = Math.floor(savedBytes / 4);
-    return {
-      originalBytes: this.originalBytes,
-      rtkBytes: this.rtkBytes,
-      savedBytes,
-      savedPct,
-      estimatedTokensSaved,
-      callCount: this.callCount
-    };
-  }
-
-  /** Returns true if any commands were recorded. */
-  hasData() {
-    return this.callCount > 0;
-  }
-}
-
-/**
- * Create a runner function that transparently wraps supported commands with RTK.
- * @param {boolean} rtkAvailable
- * @param {RtkSavingsTracker} [tracker] - Optional savings tracker
- * @returns {(command: string, args?: string[], options?: object) => Promise<object>}
- */
-export function createRtkRunner(rtkAvailable, tracker = null) {
-  return async (command, args = [], options = {}) => {
-    const wrapped = wrapWithRtk(command, args, rtkAvailable);
-    const result = await runCommand(wrapped.command, wrapped.args, options);
-
-    if (tracker && rtkAvailable && supportedSet.has(command)) {
-      const outputSize = Buffer.byteLength(result.stdout || "", "utf8");
-      // For RTK-wrapped calls, the output is already compressed.
-      // We estimate the original size as outputSize (conservative — real savings
-      // would require running the command without RTK, which defeats the purpose).
-      // The tracker is useful when the caller provides real estimates externally.
-      tracker.record(outputSize, outputSize);
-    }
-
-    return result;
-  };
-}

package/src/utils/run-registry.js

@@ -1,9 +0,0 @@
-// Shim: run-registry now lives in karajan-core/run-registry so the
-// hu-board workspace can consume it without a relative dep on the CLI
-// src tree. KJC-TSK-0511 PR3.
-export {
-  runsDir,
-  registerRun,
-  unregisterRun,
-  listActiveRuns,
-} from "karajan-core/run-registry";