@karajan-family/code 4.21.0

package/src/agents/host-agent.js

@@ -0,0 +1,38 @@
+/**
+ * Host Agent — delegates task execution to the MCP host AI via elicitation.
+ *
+ * Instead of spawning a subprocess, returns the prompt to the host AI
+ * (Claude, Codex, etc.) for direct execution. The host has full access
+ * to the codebase and tools — no subprocess overhead.
+ *
+ * Used when: the MCP host IS the same agent configured for a role.
+ */
+
+import { BaseAgent } from "./base-agent.js";
+
+export class HostAgent extends BaseAgent {
+  constructor(config, logger, { askHost }) {
+    super("host", config, logger);
+    this._askHost = askHost;
+  }
+
+  async runTask(task) {
+    const { prompt, onOutput } = task;
+
+    if (!this._askHost) {
+      return { ok: false, output: "", error: "Host agent has no askHost callback" };
+    }
+
+    if (onOutput) onOutput({ stream: "info", line: "[host-agent] Delegating to host AI..." });
+
+    const answer = await this._askHost(prompt);
+
+    if (!answer) {
+      return { ok: false, output: "", error: "Host AI declined or returned no response" };
+    }
+
+    if (onOutput) onOutput({ stream: "info", line: "[host-agent] Host AI completed task" });
+
+    return { ok: true, output: answer, exitCode: 0 };
+  }
+}

package/src/agents/index.js

@@ -0,0 +1,59 @@
+import { ClaudeAgent } from "./claude-agent.js";
+import { CodexAgent } from "./codex-agent.js";
+import { GeminiAgent } from "./gemini-agent.js";
+import { AiderAgent } from "./aider-agent.js";
+import { OpenCodeAgent } from "./opencode-agent.js";
+import { QwenAgent } from "./qwen-agent.js";
+import { CopilotAgent } from "./copilot-agent.js";
+import { KimiAgent } from "./kimi-agent.js";
+import { AgyAgent } from "./agy-agent.js";
+
+const agentRegistry = new Map();
+
+export function registerAgent(name, AgentClass, meta = {}) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Agent name must be a non-empty string");
+  }
+  agentRegistry.set(name, { AgentClass, meta });
+}
+
+export function getAvailableAgents() {
+  return [...agentRegistry.entries()].map(([name, { AgentClass, meta }]) => ({
+    name,
+    AgentClass,
+    ...meta,
+  }));
+}
+
+export function getAgentMeta(name) {
+  const entry = agentRegistry.get(name);
+  return entry ? { ...entry.meta } : null;
+}
+
+/**
+ * @param {string} agentName
+ * @param {import("../types/config.js").KarajanConfig} config
+ * @param {import("../types/stage.js").Logger} logger
+ * @param {import("../infrastructure/environment.js").Environment} [environment]
+ *   Optional DI environment. Defaults to native fs + execa. Tests pass a mock
+ *   environment built via `buildMockEnvironment()` to exercise agent paths
+ *   without spawning real processes.
+ */
+export function createAgent(agentName, config, logger, environment) {
+  const entry = agentRegistry.get(agentName);
+  if (!entry) {
+    throw new Error(`Unsupported agent: ${agentName}`);
+  }
+  return new entry.AgentClass(agentName, config, logger, environment);
+}
+
+// Auto-register built-in agents with CLI metadata
+registerAgent("claude", ClaudeAgent, { bin: "claude", installUrl: "https://docs.anthropic.com/en/docs/claude-code" });
+registerAgent("codex", CodexAgent, { bin: "codex", installUrl: "https://developers.openai.com/codex/cli" });
+registerAgent("gemini", GeminiAgent, { bin: "gemini", installUrl: "https://github.com/google-gemini/gemini-cli" });
+registerAgent("aider", AiderAgent, { bin: "aider", installUrl: "https://aider.chat/docs/install.html" });
+registerAgent("opencode", OpenCodeAgent, { bin: "opencode", installUrl: "https://opencode.ai" });
+registerAgent("qwen", QwenAgent, { bin: "qwen", installUrl: "https://github.com/QwenLM/qwen-code" });
+registerAgent("copilot", CopilotAgent, { bin: "copilot", installUrl: "https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli" });
+registerAgent("kimi", KimiAgent, { bin: "kimi", installUrl: "https://github.com/MoonshotAI/kimi-code" });
+registerAgent("agy", AgyAgent, { bin: "agy", installUrl: "https://antigravity.google" });

package/src/agents/kimi-agent.js

@@ -0,0 +1,45 @@
+import { BaseAgent } from "./base-agent.js";
+import { resolveBin } from "./resolve-bin.js";
+
+/**
+ * Kimi Code (Moonshot, binary `kimi`) — KJC-TSK-0729 fase 2: the eighth
+ * built-in agent and the free-tier reserve of the reviewer/solomon panel.
+ *
+ * Verified live against kimi-code 0.27.0:
+ *  - `-p <prompt>` runs one prompt non-interactively and prints the
+ *    response (text output by default) — the prompt travels as an argument,
+ *    same E2BIG caveat as claude/copilot (KJC-BUG-0121) for huge diffs.
+ *  - `-m <model>` picks a model alias; `-y` auto-approves actions.
+ *  - Auth is the device-code login (`kimi login`), no env keys involved;
+ *    "No model configured" on a logged machine means the login did not
+ *    populate the managed provider (re-run `kimi login`).
+ */
+export class KimiAgent extends BaseAgent {
+  async runTask(task) {
+    // Coder mode IS an agentic run: file edits and shell need approval.
+    return this._exec(task, this.getRoleModel(task.role || "coder"), ["-y"]);
+  }
+
+  async reviewTask(task) {
+    // Review/arbitration answers from the prompt alone — no auto-approval,
+    // and an explicit no-tools instruction so a headless run never stalls
+    // waiting for a permission prompt nobody can answer.
+    return this._exec(
+      { ...task, prompt: `Do NOT use any tools. Answer directly from this prompt only.\n\n${task.prompt}` },
+      this.getRoleModel(task.role || "reviewer"),
+      [],
+    );
+  }
+
+  async _exec(task, model, extraArgs) {
+    const args = ["-p", task.prompt, ...extraArgs];
+    if (model) args.push("-m", model);
+    const res = await this.runCommand(resolveBin("kimi"), args, {
+      onOutput: task.onOutput,
+      silenceTimeoutMs: task.silenceTimeoutMs,
+      timeout: task.timeoutMs,
+      cwd: task.cwd,
+    });
+    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+  }
+}

package/src/agents/model-registry.js

@@ -0,0 +1,137 @@
+const modelRegistry = new Map();
+
+export function registerModel(name, { provider, pricing, deprecated } = {}) {
+	if (!name || typeof name !== "string") {
+		throw new Error("Model name must be a non-empty string");
+	}
+	if (!pricing || typeof pricing.input_per_million !== "number" || typeof pricing.output_per_million !== "number") {
+		throw new Error(`Model "${name}" requires pricing with input_per_million and output_per_million`);
+	}
+	modelRegistry.set(name, {
+		name,
+		provider: provider || name.split("/")[0],
+		pricing: { input_per_million: pricing.input_per_million, output_per_million: pricing.output_per_million },
+		deprecated: deprecated || null,
+	});
+}
+
+export function registerModelAlias(alias, target, { provider } = {}) {
+	const entry = modelRegistry.get(target);
+	if (!entry) {
+		throw new Error(`Target model "${target}" for alias "${alias}" not found`);
+	}
+	modelRegistry.set(alias, {
+		...entry,
+		name: alias,
+		provider: provider || entry.provider
+	});
+}
+
+export function getModelPricing(name) {
+	const entry = modelRegistry.get(name);
+	return entry ? { ...entry.pricing } : null;
+}
+
+export function isModelDeprecated(name) {
+	const entry = modelRegistry.get(name);
+	if (!entry?.deprecated) return false;
+	return new Date(entry.deprecated) <= new Date();
+}
+
+export function getModelInfo(name) {
+	const entry = modelRegistry.get(name);
+	if (!entry) return null;
+	return { name: entry.name, provider: entry.provider, pricing: { ...entry.pricing }, deprecated: entry.deprecated };
+}
+
+export function getRegisteredModels() {
+	return [...modelRegistry.entries()].map(([_name, entry]) => ({
+		name: entry.name,
+		provider: entry.provider,
+		pricing: { ...entry.pricing },
+		deprecated: entry.deprecated,
+	}));
+}
+
+export function buildDefaultPricingTable() {
+	const table = {};
+	for (const [name, entry] of modelRegistry) {
+		table[name] = { ...entry.pricing };
+	}
+	return table;
+}
+
+/**
+ * Anthropic Claude Family
+ * Pricing & Info: https://platform.claude.com/docs/en/about-claude/pricing
+ */
+registerModel("claude-opus-4.6", { provider: "anthropic", pricing: { input_per_million: 5.0, output_per_million: 25.0 } });
+registerModel("claude-sonnet-4.6", { provider: "anthropic", pricing: { input_per_million: 3.0, output_per_million: 15.0 } });
+registerModel("claude-haiku-4.5", { provider: "anthropic", pricing: { input_per_million: 1.0, output_per_million: 5.0 } });
+
+// Default models & General aliases
+registerModel("claude", { provider: "anthropic", pricing: { input_per_million: 3, output_per_million: 15 } });
+registerModel("sonnet", { provider: "anthropic", pricing: { input_per_million: 3, output_per_million: 15 } });
+registerModel("opus", { provider: "anthropic", pricing: { input_per_million: 15, output_per_million: 75 } });
+registerModel("haiku", { provider: "anthropic", pricing: { input_per_million: 0.25, output_per_million: 1.25 } });
+
+/**
+ * OpenAI GPT Family
+ * Pricing: https://developers.openai.com/api/docs/pricing
+ */
+registerModel("gpt-5.4-standard", { provider: "openai", pricing: { input_per_million: 2.5, output_per_million: 15.0 } });
+registerModel("gpt-5.4-thinking", { provider: "openai", pricing: { input_per_million: 2.5, output_per_million: 15.0 } });
+registerModel("gpt-5.4-pro", { provider: "openai", pricing: { input_per_million: 30.0, output_per_million: 180.0 } });
+registerModel("gpt-5.4-mini", { provider: "openai", pricing: { input_per_million: 0.75, output_per_million: 4.5 } });
+
+// Default models & General aliases
+registerModel("codex", { provider: "openai", pricing: { input_per_million: 1.5, output_per_million: 4 } });
+registerModel("o4-mini", { provider: "openai", pricing: { input_per_million: 1.5, output_per_million: 4 } });
+registerModel("o3", { provider: "openai", pricing: { input_per_million: 10, output_per_million: 40 } });
+
+/**
+ * Google Gemini Family
+ * Pricing: https://ai.google.dev/gemini-api/docs/pricing
+ */
+registerModel("gemini-3.1-pro-preview", { provider: "google", pricing: { input_per_million: 2.0, output_per_million: 12.0 } });
+registerModel("gemini-3.1-flash-lite", { provider: "google", pricing: { input_per_million: 0.25, output_per_million: 1.5 } });
+registerModel("gemini-3-flash-preview", { provider: "google", pricing: { input_per_million: 0.5, output_per_million: 3.0 } });
+registerModel("gemini-2.5-pro", { provider: "google", pricing: { input_per_million: 1.25, output_per_million: 5 } });
+registerModel("gemini-2.0-flash", { provider: "google", pricing: { input_per_million: 0.075, output_per_million: 0.3 } });
+
+// Default models & General aliases
+registerModelAlias("gemini", "gemini-2.5-pro");
+
+/**
+ * Other Providers & CLI Aliases
+ */
+registerModel("aider", { provider: "aider", pricing: { input_per_million: 3, output_per_million: 15 } });
+registerModel("opencode", { provider: "opencode", pricing: { input_per_million: 0, output_per_million: 0 } });
+
+/**
+ * Moonshot Kimi Family (KJC-TSK-0633) — consumed through OpenCode as an
+ * OpenAI-compatible provider (docs/providers-via-opencode.md).
+ * Pricing: https://platform.moonshot.ai/docs/pricing — verify before
+ * trusting for billing decisions; ids/prices move fast.
+ */
+registerModel("kimi-k2", { provider: "moonshot", pricing: { input_per_million: 0.6, output_per_million: 2.5 } });
+registerModel("kimi-k2-thinking", { provider: "moonshot", pricing: { input_per_million: 0.6, output_per_million: 2.5 } });
+registerModelAlias("kimi", "kimi-k2");
+// Prefixed ids as the documented opencode.json snippet produces them.
+registerModelAlias("kimi/kimi-k2", "kimi-k2");
+registerModelAlias("kimi/kimi-k2-thinking", "kimi-k2-thinking");
+
+/**
+ * DeepSeek Family (KJC-TSK-0633) — same OpenCode route.
+ * Pricing: https://api-docs.deepseek.com/quick_start/pricing
+ */
+registerModel("deepseek-chat", { provider: "deepseek", pricing: { input_per_million: 0.28, output_per_million: 0.42 } });
+registerModel("deepseek-reasoner", { provider: "deepseek", pricing: { input_per_million: 0.28, output_per_million: 0.42 } });
+registerModelAlias("deepseek", "deepseek-chat");
+registerModelAlias("deepseek/deepseek-chat", "deepseek-chat");
+registerModelAlias("deepseek/deepseek-reasoner", "deepseek-reasoner");
+
+// Common CLI Aliases (with provider overrides)
+registerModelAlias("aider/claude-3-7-sonnet", "claude-sonnet-4.6", { provider: "aider" });
+registerModelAlias("aider/gpt-4o", "gpt-5.4-standard", { provider: "aider" });
+registerModelAlias("opencode/minimax-m2.5", "opencode", { provider: "opencode" });

package/src/agents/opencode-agent.js

@@ -0,0 +1,72 @@
+import { BaseAgent } from "./base-agent.js";
+import { resolveBin } from "./resolve-bin.js";
+
+/**
+ * Extract OpenAI-style `usage` from OpenCode stdout. With `--format json`
+ * (used in reviewTask) the CLI emits a JSON document; with LiteLLM-backed
+ * runs that document carries `usage.prompt_tokens_details.cached_tokens`.
+ *
+ * Accepts the whole payload, individual lines, or array elements with a
+ * nested `usage` object. Returns `{tokens_in, tokens_out, cached_tokens}`
+ * or null (= unmeasured).
+ */
+function extractOpenCodeUsage(text) {
+  if (!text) return null;
+  const candidates = [text.trim()];
+  for (const line of text.split("\n")) {
+    const t = line.trim();
+    if (t.startsWith("{") || t.startsWith("[")) candidates.push(t);
+  }
+  for (const candidate of candidates) {
+    let obj;
+    try { obj = JSON.parse(candidate); } catch { continue; }
+    const usage = obj?.usage
+      ?? obj?.result?.usage
+      ?? (Array.isArray(obj) ? obj.find((e) => e?.usage)?.usage : null);
+    if (!usage || typeof usage.prompt_tokens !== "number") continue;
+    return {
+      tokens_in: usage.prompt_tokens,
+      tokens_out: usage.completion_tokens ?? 0,
+      cached_tokens: usage.prompt_tokens_details?.cached_tokens ?? 0
+    };
+  }
+  return null;
+}
+
+export class OpenCodeAgent extends BaseAgent {
+  async runTask(task) {
+    const role = task.role || "coder";
+    const model = this.getRoleModel(role);
+    const result = await this._exec(task, model, false);
+    if (!result.ok && model && this.isModelNotSupportedError(result)) {
+      this.logger?.warn(`OpenCode model "${model}" not supported — retrying with agent default`);
+      return this._exec(task, null, false);
+    }
+    return result;
+  }
+
+  async reviewTask(task) {
+    const role = task.role || "reviewer";
+    const model = this.getRoleModel(role);
+    const result = await this._exec(task, model, true);
+    if (!result.ok && model && this.isModelNotSupportedError(result)) {
+      this.logger?.warn(`OpenCode model "${model}" not supported — retrying with agent default`);
+      return this._exec(task, null, true);
+    }
+    return result;
+  }
+
+  async _exec(task, model, jsonFormat) {
+    const args = ["run"];
+    if (jsonFormat) args.push("--format", "json");
+    if (model) args.push("--model", model);
+    args.push(task.prompt);
+    const res = await this.runCommand(resolveBin("opencode"), args, {
+      onOutput: task.onOutput,
+      silenceTimeoutMs: task.silenceTimeoutMs,
+      timeout: task.timeoutMs
+    });
+    const usage = extractOpenCodeUsage(res.stdout) ?? extractOpenCodeUsage(res.stderr);
+    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode, ...usage };
+  }
+}

package/src/agents/qwen-agent.js

@@ -0,0 +1,20 @@
+import { GeminiAgent } from "./gemini-agent.js";
+
+/**
+ * Qwen Code (@qwen-code/qwen-code, binary `qwen`) — KJC-TSK-0665.
+ *
+ * A gemini-cli fork with the same headless interface (prompt on stdin,
+ * `--output-format json`, `--model`, identical usageMetadata shape), so it
+ * inherits everything from GeminiAgent including the KJC-BUG-0121 stdin
+ * contract. Cloud-backed and free with a Qwen account: the sixth built-in
+ * agent, and the natural third AI for solomon arbitration now that the
+ * gemini individual tier is retired.
+ */
+export class QwenAgent extends GeminiAgent {
+  get cliBin() { return "qwen"; }
+  // qwen has no workspace-trust gate. execa merges this object over
+  // process.env, so the explicit undefined REMOVES gemini's var from the
+  // child even when the parent shell exported it (manual workarounds) —
+  // returning no env at all would let it leak through inheritance.
+  get spawnEnv() { return { GEMINI_CLI_TRUST_WORKSPACE: undefined }; }
+}

package/src/agents/resolve-bin.js

@@ -0,0 +1,73 @@
+import { existsSync, readdirSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { execFileSync } from "node:child_process";
+
+const cache = new Map();
+
+const isWin = process.platform === "win32";
+
+const SEARCH_DIRS = isWin
+  ? [
+    path.join(os.homedir(), "AppData", "Roaming", "npm"),
+    path.join(os.homedir(), "AppData", "Local", "npm"),
+    path.join(os.homedir(), ".opencode", "bin"),
+  ]
+  : [
+    "/opt/node/bin",
+    path.join(os.homedir(), ".npm-global", "bin"),
+    "/usr/local/bin",
+    path.join(os.homedir(), ".local", "bin"),
+    path.join(os.homedir(), ".opencode", "bin"),
+  ];
+
+function getNvmDirs() {
+  const nvmDir = process.env.NVM_DIR || path.join(os.homedir(), ".nvm");
+  const versionsDir = path.join(nvmDir, "versions", "node");
+  try {
+    return readdirSync(versionsDir).map(v => path.join(versionsDir, v, "bin"));
+  } catch { /* nvm versions dir may not exist */
+    return [];
+  }
+}
+
+export function resolveBin(name) {
+  if (cache.has(name)) return cache.get(name);
+
+  // 1. Try system PATH via `which` (Unix) or `where` (Windows)
+  try {
+    const whichCmd = isWin ? "where" : "which";
+    const resolved = execFileSync(whichCmd, [name], {
+      encoding: "utf8",
+      timeout: 3000,
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim().split(/\r?\n/)[0];
+    if (resolved) {
+      cache.set(name, resolved);
+      return resolved;
+    }
+  } catch {
+    /* not in PATH */
+  }
+
+  // 2. Search known directories
+  const dirs = [...SEARCH_DIRS, ...getNvmDirs()];
+  const extensions = isWin ? ["", ".cmd", ".exe", ".bat"] : [""];
+  for (const dir of dirs) {
+    for (const ext of extensions) {
+      const candidate = path.join(dir, name + ext);
+      if (existsSync(candidate)) {
+        cache.set(name, candidate);
+        return candidate;
+      }
+    }
+  }
+
+  // 3. Fallback: return name as-is (let execa try PATH)
+  cache.set(name, name);
+  return name;
+}
+
+export function clearBinCache() {
+  cache.clear();
+}