karajan-code 1.59.1 → 2.0.0

package/templates/roles/solomon.md

@@ -1,122 +1,83 @@
-# Solomon Role (Pipeline Boss & Arbiter)
+# Solomon — AI Judge (Arbiter of Dilemmas)
 
-You are **Solomon**, the supreme decision-maker in a multi-role AI pipeline. You evaluate **EVERY** reviewer rejection — not just stalls. You decide whether the coder should fix, whether the reviewer's issues should be overridden, or whether to escalate to a human. Your decisions are final within your rules.
+You are **Solomon**, an AI judge consulted by **Karajan Brain** only when it faces a genuine dilemma. You do NOT route the pipeline. You do NOT decide what role runs next. You give **opinions**. Karajan Brain decides what to do with your opinion.
 
-## When activated
+## Your role
 
-- **Every reviewer rejection** (first rejection AND repeats)
-- Coder ↔ Sonar loop exhausted (default: 3 iterations)
-- Coder ↔ Tester loop exhausted (default: 1 iteration)
-- Coder ↔ Security loop exhausted (default: 1 iteration)
-- Any two roles produce contradictory outputs
+Think of the pipeline as a company:
+- **Karajan Brain** is the CEO. It runs everything, knows the project, makes decisions.
+- **You (Solomon)** are the lawyer/advisor. You get called when the CEO faces a tough call.
 
-## Input
+You are NOT consulted for routine decisions. Karajan Brain handles those itself.
 
-You receive the full history of the conflict:
-- All agent feedback across iterations (identifying which agent said what)
-- All coder attempts and changes
-- Original task requirements and acceptance criteria
-- Sonar findings, reviewer comments, tester feedback, security findings (as applicable)
-- Current diff
+## When you are consulted
 
-## Decision hierarchy
+Only for **genuine dilemmas**:
+- Security vs deadline tradeoffs
+- Two quality gates giving contradictory feedback (reviewer approves, tester rejects)
+- Stalled loops where the CEO has tried 3+ approaches with no progress
+- Unclear risk evaluation (is this blocking or cosmetic?)
+- Rate limit with no alternative agents available
 
-```
-Security > Correctness > Tests > Architecture > Maintainability > Style
-```
+You are **NOT consulted** for:
+- Coder produced 0 files (CEO handles with better prompt)
+- Missing npm install (CEO runs it directly)
+- Vague feedback (CEO enriches it)
+- Normal reviewer rejection with clear fix (CEO passes to coder)
+
+## Your skills (arbitration)
+
+### 1. security-vs-deadline
+When a deadline is tight and a security issue is blocking:
+- Security ALWAYS wins. Never approve shipping with known security holes.
+- If the issue is a false positive (contextual), say so with clear reasoning.
+- Suggest a mitigation path if deadline is critical.
+
+### 2. conflicting-quality-gates
+When two gates disagree (e.g., reviewer approves but tester fails):
+- Identify which gate is closer to the user impact.
+- Recommend whose opinion should prevail, with reasoning.
+- Suggest how to satisfy both.
 
-- **Green tests are sacred.** Never dismiss a failing test.
-- **Style preferences NEVER block approval.**
-- **Contextual false positives are valid.** For example: hardcoded values that will come from DB in a future task are acceptable at this stage.
-- **Sonar INFO/MINOR issues** are always dismissable.
-- **Sonar MAJOR** — evaluate in context; dismiss if it's a known pattern or temporary state.
-- **Sonar BLOCKER/CRITICAL** must be fixed unless proven false positive.
-
-## Classification rules
-
-For each blocking issue raised by any agent, classify it as:
-
-1. **critical** (security vulnerability, correctness bug, tests broken) — action: **must_fix**
-2. **important** (architecture, maintainability, missing coverage) — action: **should_fix**
-3. **style** (naming, formatting, preferences, false positives, contextual exceptions) — action: **dismiss**
-
-## Blocking criteria (real-world)
-
-| Criterion | Blocks? | Notes |
-|-----------|---------|-------|
-| Failing test | YES | Always — tests are sacred |
-| Security vulnerability critical/high | YES | Always requires fix |
-| Security vulnerability medium | DEPENDS | Evaluate in context |
-| Security vulnerability low | NO | Document as TODO |
-| Sonar BLOCKER/CRITICAL | YES | Unless proven false positive |
-| Sonar MAJOR | DEPENDS | Evaluate context and project stage |
-| Sonar MINOR/INFO | NO | Dismiss |
-| Hardcoded value (planned for DB later) | NO | Contextual false positive |
-| Coverage < threshold | YES | Per project configuration |
-| Pure style issue | NO | Never blocks |
-| Architecture change not in scope | ESCALATE | Human decision required |
-
-## Decision framework
-
-Use the `isFirstRejection`, `isRepeat`, and `issueCategories` fields from the conflict to decide:
-
-| Scenario | Decision |
-|----------|----------|
-| Issues are security/critical (any count) | **approve_with_conditions** — ALWAYS send back to fix |
-| Issues are ALL style/naming/cosmetic | **approve** — override the reviewer |
-| Issues are correctness but minor (first rejection) | **approve_with_conditions** — give ONE retry with specific instructions |
-| Issues are a repeat of the same thing the coder already failed to fix | **escalate_human** — the coder cannot fix it |
-| Reviewer is clearly wrong or issues are out of scope | **approve** — override the reviewer |
-| Ambiguous requirements or architecture decisions | **escalate_human** — human must decide |
-
-Be **concise and decisive**. Do not hedge. Pick one action and commit.
-
-## Decision options
-
-1. **approve** — All pending issues are style/false positives, or the reviewer is wrong. Code passes to next pipeline stage. Solomon overrides the reviewer.
-2. **approve_with_conditions** — Fixable issues exist. Give the Coder exact, actionable instructions for one more attempt. Not generic feedback — specific changes with file and line references.
-3. **escalate_human** — When you cannot decide:
-   - Critical issues that resist multiple fix attempts
-   - Ambiguous or conflicting requirements
-   - Architecture decisions beyond task scope
-   - Business logic decisions
-   - Scope creep (task is larger than originally estimated)
-   - Same issue repeated across iterations — the coder cannot fix it
-4. **create_subtask** — A prerequisite task must be completed first to unblock the current conflict. The pipeline will:
-   - Pause the current task
-   - Execute the subtask through the full pipeline
-   - Resume the original task with the subtask completed
-
-### When to create a subtask
-
-- A shared utility/module is needed that doesn't exist yet
-- A refactoring is required before the current change can work
-- A dependency needs to be updated or configured
-- A circular dependency needs to be broken
-- Test infrastructure needs to be set up first
+### 3. stalled-loop-analysis
+When the CEO reports 3+ iterations with no progress:
+- Analyze the pattern. Same issue? Different issues?
+- Is the coder capable of fixing this, or is it a design problem?
+- Recommend: retry with different approach, decompose into subtasks, or escalate human.
+
+### 4. risk-evaluation
+When the CEO is unsure if something is truly blocking:
+- Classify: production-risk, user-facing bug, tech debt, cosmetic.
+- Judge impact: data loss, security hole, feature broken, nothing user-facing.
+- Give a clear verdict with confidence.
+
+## Decision priority
+
+Always rank issues in this order:
+1. **Security** — never compromised
+2. **Correctness** — user gets wrong results
+3. **Tests** — failing tests block approval
+4. **Architecture** — maintainability matters but not blocking
+5. **Style** — never blocks approval
 
 ## Output format
 
+Return a single JSON object with your opinion:
+
 ```json
 {
-  "ruling": "approve | approve_with_conditions | escalate_human | create_subtask",
-  "classification": [
-    { "issue": "Description of the issue", "category": "critical | important | style", "action": "must_fix | should_fix | dismiss" }
-  ],
-  "conditions": ["Specific actionable fix instruction with file:line reference"],
-  "dismissed": ["Issue description — reason for dismissal"],
-  "escalate": false,
-  "escalate_reason": null,
-  "subtask": {
-    "title": "Short descriptive title for the subtask",
-    "description": "What needs to be done and why",
-    "reason": "How this resolves the current conflict"
-  }
+  "verdict": "continue_coder|consult_human|retry_different_approach|approve_with_conditions|escalate",
+  "reasoning": "detailed explanation of your opinion",
+  "confidence": 0.0-1.0,
+  "priority": "critical|high|medium|low",
+  "conditions": ["string", ...],
+  "suggestedActions": ["string", ...]
 }
 ```
 
-Notes:
-- `subtask` is `null` unless ruling is `create_subtask`
-- `escalate_reason` is `null` unless ruling is `escalate_human`
-- `conditions` is empty unless ruling is `approve_with_conditions`
-- `dismissed` lists all style/false-positive issues with rationale
+## Remember
+
+- You are an **advisor**, not a commander.
+- Karajan Brain decides what to do with your opinion.
+- Never compromise security.
+- When in doubt, escalate to the human with clear reasoning.

package/templates/workflows/automerge.yml

@@ -1,7 +1,7 @@
-# Auto-merge PRs approved by BecarIA reviewer.
-# Merges when becaria-reviewer[bot] approves and all checks pass.
+# Auto-merge PRs approved by Karajan CI reviewer.
+# Merges when kj-reviewer[bot] approves and all checks pass.
 
-name: Auto-merge (BecarIA)
+name: Auto-merge (Karajan CI)
 
 on:
   pull_request_review:
@@ -15,7 +15,7 @@ jobs:
   automerge:
     if: >
       github.event.review.state == 'approved' &&
-      contains(github.event.review.user.login, 'becaria-reviewer')
+      contains(github.event.review.user.login, 'kj-reviewer')
     runs-on: ubuntu-latest
     steps:
       - name: Enable auto-merge

package/templates/workflows/houston-override.yml

@@ -1,5 +1,5 @@
 # Houston Override — allows a human to force-approve a PR by commenting "/houston approve".
-# Bypasses BecarIA's REQUEST_CHANGES review.
+# Bypasses Karajan CI's REQUEST_CHANGES review.
 
 name: Houston Override
 
@@ -17,20 +17,20 @@ jobs:
       contains(github.event.comment.body, '/houston approve')
     runs-on: ubuntu-latest
     steps:
-      - name: Dismiss BecarIA review and approve
+      - name: Dismiss Karajan CI review and approve
         uses: actions/github-script@v7
         with:
           script: |
             const { owner, repo } = context.repo;
             const pr_number = context.payload.issue.number;
 
-            // Find and dismiss becaria-reviewer reviews
+            // Find and dismiss kj-reviewer reviews
             const reviews = await github.rest.pulls.listReviews({
               owner, repo, pull_number: pr_number
             });
 
             for (const review of reviews.data) {
-              if (review.user.login.includes('becaria-reviewer') && review.state === 'CHANGES_REQUESTED') {
+              if (review.user.login.includes('kj-reviewer') && review.state === 'CHANGES_REQUESTED') {
                 await github.rest.pulls.dismissReview({
                   owner, repo, pull_number: pr_number, review_id: review.id,
                   message: `Dismissed by Houston Override (${context.payload.comment.user.login})`

package/templates/workflows/{becaria-gateway.yml → kj-ci-gateway.yml}

@@ -1,17 +1,17 @@
-# BecarIA Gateway — publishes PR comments and reviews from repository_dispatch events.
+# Karajan CI Gateway — publishes PR comments and reviews from repository_dispatch events.
 # Triggered by Karajan Code pipeline via `gh api repos/{owner}/{repo}/dispatches`.
 #
 # Required secrets:
-#   BECARIA_APP_ID          — GitHub App ID for becaria-reviewer
-#   BECARIA_APP_PRIVATE_KEY — PEM private key for the GitHub App
+#   KJ_CI_APP_ID      — GitHub App ID for kj-reviewer
+#   KJ_CI_PRIVATE_KEY — PEM private key for the GitHub App
 
-name: BecarIA Gateway
+name: Karajan CI Gateway
 
 on:
   repository_dispatch:
     types:
-      - becaria-comment
-      - becaria-review
+      - kj-comment
+      - kj-review
 
 permissions:
   contents: read
@@ -25,11 +25,11 @@ jobs:
         id: app-token
         uses: actions/create-github-app-token@v1
         with:
-          app-id: ${{ secrets.BECARIA_APP_ID }}
-          private-key: ${{ secrets.BECARIA_APP_PRIVATE_KEY }}
+          app-id: ${{ secrets.KJ_CI_APP_ID }}
+          private-key: ${{ secrets.KJ_CI_PRIVATE_KEY }}
 
       - name: Post Comment
-        if: github.event.action == 'becaria-comment'
+        if: github.event.action == 'kj-comment'
         uses: actions/github-script@v7
         with:
           github-token: ${{ steps.app-token.outputs.token }}
@@ -39,11 +39,11 @@ jobs:
               owner: context.repo.owner,
               repo: context.repo.repo,
               issue_number: pr_number,
-              body: `**${agent}** (via BecarIA)\n\n${body}`
+              body: `**${agent}** (via Karajan CI)\n\n${body}`
             });
 
       - name: Submit Review
-        if: github.event.action == 'becaria-review'
+        if: github.event.action == 'kj-review'
         uses: actions/github-script@v7
         with:
           github-token: ${{ steps.app-token.outputs.token }}
@@ -54,5 +54,5 @@ jobs:
               repo: context.repo.repo,
               pull_number: pr_number,
               event: event,
-              body: `**${agent}** (via BecarIA)\n\n${body}`
+              body: `**${agent}** (via Karajan CI)\n\n${body}`
             });

package/src/proxy/adapters/anthropic.js

@@ -1,131 +0,0 @@
-/**
- * Anthropic message format adapter.
- *
- * Anthropic messages API uses an array of messages where each message has a
- * `content` array. Tool results appear as content blocks with
- * `type: "tool_result"`. Each tool_result block contains an `id` (matching
- * the prior tool_use), optional `tool_use_id`, and nested `content` that
- * can be a string or an array of content blocks (text, image, etc.).
- *
- * @module
- */
-
-/**
- * Extract tool results from Anthropic-format messages.
- *
- * @param {Array<object>} messages - Anthropic messages array
- * @returns {Array<{id: string, toolName: string, text: string, turnIndex: number}>}
- */
-export function extractToolResults(messages) {
-  const results = [];
-
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (!msg || !Array.isArray(msg.content)) continue;
-
-    // Collect tool_use names from assistant messages so we can map ids to names
-    const toolNameMap = buildToolNameMap(messages, i);
-
-    for (const block of msg.content) {
-      if (block.type !== "tool_result") continue;
-
-      const id = block.tool_use_id || block.id || "";
-      const text = extractText(block);
-      const toolName = toolNameMap.get(id) || "unknown";
-
-      results.push({ id, toolName, text, turnIndex: i });
-    }
-  }
-
-  return results;
-}
-
-/**
- * Rebuild messages replacing tool_result text with compressed versions.
- *
- * @param {Array<object>} messages - Original Anthropic messages array
- * @param {Map<string, string>|Record<string, string>} compressedMap - id → compressed text
- * @returns {Array<object>} Deep-cloned messages with replacements applied
- */
-export function rebuildMessages(messages, compressedMap) {
-  const map = compressedMap instanceof Map ? compressedMap : new Map(Object.entries(compressedMap));
-  return messages.map((msg) => {
-    if (!msg || !Array.isArray(msg.content)) return msg;
-
-    const newContent = msg.content.map((block) => {
-      if (block.type !== "tool_result") return block;
-
-      const id = block.tool_use_id || block.id || "";
-      if (!map.has(id)) return block;
-
-      const compressed = map.get(id);
-      return replaceText(block, compressed);
-    });
-
-    return { ...msg, content: newContent };
-  });
-}
-
-// ── helpers ──────────────────────────────────────────────────────────
-
-/**
- * Build a map of tool_use id → tool name by scanning assistant messages
- * that precede or are at the given turn index.
- */
-function buildToolNameMap(messages, upToIndex) {
-  const map = new Map();
-  for (let i = 0; i <= upToIndex; i++) {
-    const msg = messages[i];
-    if (!msg || msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
-    for (const block of msg.content) {
-      if (block.type === "tool_use" && block.id) {
-        map.set(block.id, block.name || "unknown");
-      }
-    }
-  }
-  return map;
-}
-
-/**
- * Extract plain text from a tool_result block.
- * Content can be a string, an array of {type:"text", text} blocks, or absent.
- */
-function extractText(block) {
-  if (typeof block.content === "string") return block.content;
-  if (Array.isArray(block.content)) {
-    return block.content
-      .filter((c) => c.type === "text")
-      .map((c) => c.text)
-      .join("\n");
-  }
-  return "";
-}
-
-/**
- * Return a new tool_result block with text replaced.
- * Preserves the content shape (string vs array).
- */
-function replaceText(block, newText) {
-  if (typeof block.content === "string") {
-    return { ...block, content: newText };
-  }
-  if (Array.isArray(block.content)) {
-    // Replace only text blocks, keep images etc.
-    const newContent = block.content.map((c) =>
-      c.type === "text" ? { ...c, text: newText } : c,
-    );
-    // If there were text blocks, replace the first and remove the rest
-    let seenText = false;
-    const filtered = newContent.filter((c) => {
-      if (c.type !== "text") return true;
-      if (!seenText) {
-        seenText = true;
-        return true;
-      }
-      return false;
-    });
-    return { ...block, content: filtered };
-  }
-  // No content field — add it as string
-  return { ...block, content: newText };
-}

package/src/proxy/adapters/gemini.js

@@ -1,106 +0,0 @@
-/**
- * Gemini message format adapter.
- *
- * Gemini API uses `contents[]` where each content has `parts[]`.
- * Function responses appear as parts with a `functionResponse` field:
- * `{ functionResponse: { name: "...", response: { content: "..." } } }`
- *
- * Gemini does not use explicit IDs for function calls/responses. Instead,
- * the function name serves as the correlation key. When multiple calls to
- * the same function exist, we generate synthetic IDs combining turnIndex
- * and part index for disambiguation.
- *
- * @module
- */
-
-/**
- * Extract tool results from Gemini-format messages (contents array).
- *
- * @param {Array<object>} messages - Gemini contents array
- * @returns {Array<{id: string, toolName: string, text: string, turnIndex: number}>}
- */
-export function extractToolResults(messages) {
-  const results = [];
-
-  for (let i = 0; i < messages.length; i++) {
-    const content = messages[i];
-    if (!content || !Array.isArray(content.parts)) continue;
-
-    for (let p = 0; p < content.parts.length; p++) {
-      const part = content.parts[p];
-      if (!part.functionResponse) continue;
-
-      const fr = part.functionResponse;
-      const toolName = fr.name || "unknown";
-      const text = extractResponseText(fr.response);
-      // Synthetic ID: turn index + part index (Gemini has no explicit IDs)
-      const id = `gemini-${i}-${p}`;
-
-      results.push({ id, toolName, text, turnIndex: i });
-    }
-  }
-
-  return results;
-}
-
-/**
- * Rebuild messages replacing functionResponse content with compressed versions.
- *
- * @param {Array<object>} messages - Original Gemini contents array
- * @param {Map<string, string>|Record<string, string>} compressedMap - id → compressed text
- * @returns {Array<object>} Deep-cloned messages with replacements applied
- */
-export function rebuildMessages(messages, compressedMap) {
-  const map = compressedMap instanceof Map ? compressedMap : new Map(Object.entries(compressedMap));
-
-  return messages.map((content, i) => {
-    if (!content || !Array.isArray(content.parts)) return content;
-
-    const newParts = content.parts.map((part, p) => {
-      if (!part.functionResponse) return part;
-
-      const id = `gemini-${i}-${p}`;
-      if (!map.has(id)) return part;
-
-      const compressed = map.get(id);
-      return {
-        ...part,
-        functionResponse: {
-          ...part.functionResponse,
-          response: replaceResponseText(part.functionResponse.response, compressed),
-        },
-      };
-    });
-
-    return { ...content, parts: newParts };
-  });
-}
-
-// ── helpers ──────────────────────────────────────────────────────────
-
-/**
- * Extract text from a Gemini function response object.
- * The response can have `content` (string), `result` (string),
- * or be a nested object that we JSON-serialize.
- */
-function extractResponseText(response) {
-  if (!response) return "";
-  if (typeof response === "string") return response;
-  if (typeof response.content === "string") return response.content;
-  if (typeof response.result === "string") return response.result;
-  // For structured responses, serialize to JSON
-  return JSON.stringify(response);
-}
-
-/**
- * Replace text in a Gemini function response object.
- * Preserves the original shape (content field, result field, etc.).
- */
-function replaceResponseText(response, newText) {
-  if (!response) return { content: newText };
-  if (typeof response === "string") return newText;
-  if (typeof response.content === "string") return { ...response, content: newText };
-  if (typeof response.result === "string") return { ...response, result: newText };
-  // Default: replace with content field
-  return { content: newText };
-}

package/src/proxy/adapters/index.js

@@ -1,51 +0,0 @@
-/**
- * Provider adapter registry.
- *
- * Each adapter implements the contract:
- *   extractToolResults(messages) → [{id, toolName, text, turnIndex}]
- *   rebuildMessages(messages, compressedMap) → messages
- *
- * @module
- */
-
-import * as anthropic from "./anthropic.js";
-import * as openai from "./openai.js";
-import * as gemini from "./gemini.js";
-
-const adapters = {
-  anthropic,
-  openai,
-  gemini,
-};
-
-/**
- * Hostname → provider mapping.
- * @type {Record<string, string>}
- */
-const HOST_MAP = {
-  "api.anthropic.com": "anthropic",
-  "api.openai.com": "openai",
-  "generativelanguage.googleapis.com": "gemini",
-};
-
-/**
- * Get the adapter for a given provider name.
- *
- * @param {string} provider - "anthropic" | "openai" | "gemini"
- * @returns {object|null} Adapter with extractToolResults and rebuildMessages, or null
- */
-export function getAdapter(provider) {
-  return adapters[provider] || null;
-}
-
-/**
- * Detect the provider from a hostname.
- *
- * @param {string} hostname - e.g. "api.anthropic.com", "api.openai.com:443"
- * @returns {string} Provider name or "unknown"
- */
-export function detectProvider(hostname) {
-  // Strip port if present
-  const host = (hostname || "").split(":")[0];
-  return HOST_MAP[host] || "unknown";
-}

package/src/proxy/adapters/openai.js

@@ -1,71 +0,0 @@
-/**
- * OpenAI message format adapter.
- *
- * OpenAI Chat Completions API uses messages with `role: "tool"`.
- * Each tool message has a `tool_call_id` linking back to the assistant's
- * `tool_calls` array, and a `content` string with the tool output.
- *
- * @module
- */
-
-/**
- * Extract tool results from OpenAI-format messages.
- *
- * @param {Array<object>} messages - OpenAI messages array
- * @returns {Array<{id: string, toolName: string, text: string, turnIndex: number}>}
- */
-export function extractToolResults(messages) {
-  const results = [];
-  const toolNameMap = buildToolNameMap(messages);
-
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (!msg || msg.role !== "tool") continue;
-
-    const id = msg.tool_call_id || "";
-    const text = typeof msg.content === "string" ? msg.content : "";
-    const toolName = toolNameMap.get(id) || "unknown";
-
-    results.push({ id, toolName, text, turnIndex: i });
-  }
-
-  return results;
-}
-
-/**
- * Rebuild messages replacing tool message content with compressed versions.
- *
- * @param {Array<object>} messages - Original OpenAI messages array
- * @param {Map<string, string>|Record<string, string>} compressedMap - id → compressed text
- * @returns {Array<object>} Deep-cloned messages with replacements applied
- */
-export function rebuildMessages(messages, compressedMap) {
-  const map = compressedMap instanceof Map ? compressedMap : new Map(Object.entries(compressedMap));
-  return messages.map((msg) => {
-    if (!msg || msg.role !== "tool") return msg;
-
-    const id = msg.tool_call_id || "";
-    if (!map.has(id)) return msg;
-
-    return { ...msg, content: map.get(id) };
-  });
-}
-
-// ── helpers ──────────────────────────────────────────────────────────
-
-/**
- * Build a map of tool_call id → function name by scanning assistant messages.
- * Assistant messages contain `tool_calls: [{id, function: {name, arguments}}]`.
- */
-function buildToolNameMap(messages) {
-  const map = new Map();
-  for (const msg of messages) {
-    if (!msg || msg.role !== "assistant" || !Array.isArray(msg.tool_calls)) continue;
-    for (const call of msg.tool_calls) {
-      if (call.id && call.function) {
-        map.set(call.id, call.function.name || "unknown");
-      }
-    }
-  }
-  return map;
-}