karajan-code 1.31.1 → 1.32.0

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="docs/karajan-code-logo-small.png" alt="Karajan Code" width="200">
+  <img src="docs/karajan-code-logo.svg" alt="Karajan Code" width="180">
 </p>
 
 <h1 align="center">Karajan Code</h1>
@@ -46,6 +46,7 @@ Use Karajan when you want:
 - **Zero-config operation** — auto-detects test frameworks, starts SonarQube, simplifies pipeline for trivial tasks
 - **Composable role architecture** — define agent behaviors as plain markdown files that travel with your project
 - **Local-first** — your code, your keys, your machine, no data leaves unless you say so
+- **Zero API costs** — Karajan uses AI agent CLIs (Claude Code, Codex, Gemini CLI), not APIs. You pay your existing subscription (Claude Pro, ChatGPT Plus), not per-token API fees. No surprise bills.
 
 If Claude Code is a smart pair programmer, Karajan is the CI/CD pipeline for AI-assisted development. They work great together — Karajan is designed to be used as an MCP server inside Claude Code.
 
@@ -64,6 +65,8 @@ That's it. No Docker required (SonarQube uses Docker, but Karajan auto-manages i
 kj run "Create a utility function that validates Spanish DNI numbers, with tests"
 ```
 
+[**▶ Watch the full pipeline demo**](https://karajancode.com#demo) — HU certification, triage, architecture, TDD, SonarQube, code review, Solomon arbitration, security audit.
+
 Karajan will:
 1. Triage the task complexity and activate the right roles
 2. Write tests first (TDD)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "1.31.1",
+  "version": "1.32.0",
   "description": "Local multi-agent coding orchestrator with TDD, SonarQube, and code review pipeline",
   "type": "module",
   "license": "AGPL-3.0",

package/src/orchestrator/post-loop-stages.js

@@ -1,6 +1,7 @@
 import { TesterRole } from "../roles/tester-role.js";
 import { SecurityRole } from "../roles/security-role.js";
 import { ImpeccableRole } from "../roles/impeccable-role.js";
+import { AuditRole } from "../roles/audit-role.js";
 import { addCheckpoint, saveSession } from "../session-store.js";
 import { emitProgress, makeEvent } from "../utils/events.js";
 import { invokeSolomon } from "./solomon-escalation.js";
@@ -290,5 +291,113 @@ export async function runImpeccableStage({ config, logger, emitter, eventBase, s
   return { action: "ok", stageResult: { ok: impeccableOutput.ok, verdict, summary: impeccableOutput.summary || "No frontend design issues found" } };
 }
 
+export async function runFinalAuditStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget, iteration, task, diff }) {
+  logger.setContext({ iteration, stage: "audit" });
+  emitProgress(
+    emitter,
+    makeEvent("audit:start", { ...eventBase, stage: "audit" }, {
+      message: "Final audit — verifying code quality"
+    })
+  );
+
+  const auditStart = Date.now();
+  const { output: auditOutput, provider, attempts } = await runRoleWithFallback(
+    AuditRole,
+    { roleName: "audit", config, logger, emitter, eventBase, task, iteration, diff }
+  );
+  const totalDuration = Date.now() - auditStart;
+
+  trackBudget({
+    role: "audit",
+    provider: provider || coderRole.provider,
+    model: config?.roles?.audit?.model || coderRole.model,
+    result: auditOutput,
+    duration_ms: totalDuration
+  });
+
+  await addCheckpoint(session, {
+    stage: "audit",
+    iteration,
+    ok: auditOutput.ok,
+    provider: provider || coderRole.provider,
+    model: config?.roles?.audit?.model || coderRole.model || null,
+    attempts: attempts.length > 1 ? attempts : undefined
+  });
+
+  if (!auditOutput.ok) {
+    // Audit agent failed to run — treat as advisory, don't block pipeline
+    logger.warn(`Audit agent error (advisory): ${auditOutput.summary}`);
+    emitProgress(
+      emitter,
+      makeEvent("audit:end", { ...eventBase, stage: "audit" }, {
+        status: "warn",
+        message: `Audit: agent error (advisory), continuing — ${auditOutput.summary}`
+      })
+    );
+    return { action: "ok", stageResult: { ok: false, summary: auditOutput.summary || "Audit agent error (advisory)", auto_continued: true } };
+  }
+
+  // Parse findings from audit result
+  const result = auditOutput.result || {};
+  const summary = result.summary || {};
+  const overallHealth = summary.overallHealth || "fair";
+  const criticalCount = summary.critical || 0;
+  const highCount = summary.high || 0;
+
+  // Collect critical and high findings for feedback
+  const actionableFindings = [];
+  if (result.dimensions) {
+    for (const [dimName, dim] of Object.entries(result.dimensions)) {
+      for (const finding of (dim.findings || [])) {
+        if (finding.severity === "critical" || finding.severity === "high") {
+          actionableFindings.push({
+            dimension: dimName,
+            ...finding
+          });
+        }
+      }
+    }
+  }
+
+  const hasActionableIssues = (overallHealth === "poor" || overallHealth === "critical") && (criticalCount > 0 || highCount > 0);
+
+  if (hasActionableIssues) {
+    // Build feedback string for the coder
+    const feedbackLines = actionableFindings.map(f => {
+      const loc = f.file ? `${f.file}${f.line ? `:${f.line}` : ""}` : "";
+      return `[${f.severity.toUpperCase()}] ${loc} ${f.description}${f.recommendation ? ` — Fix: ${f.recommendation}` : ""}`;
+    });
+    const feedback = `Audit found ${criticalCount + highCount} critical/high issue(s) that must be fixed:\n${feedbackLines.join("\n")}`;
+
+    logger.warn(`Audit: ${criticalCount + highCount} actionable issues found, sending back to coder`);
+    emitProgress(
+      emitter,
+      makeEvent("audit:end", { ...eventBase, stage: "audit" }, {
+        status: "fail",
+        message: `Audit: ${criticalCount + highCount} issue(s) found, sending back to coder`
+      })
+    );
+
+    return { action: "retry", feedback, stageResult: { ok: false, summary: auditOutput.summary || `${criticalCount + highCount} actionable issues` } };
+  }
+
+  // Audit passed (good/fair or no critical/high findings)
+  const hasAdvisory = (summary.medium || 0) + (summary.low || 0) > 0;
+  const certifiedMsg = hasAdvisory
+    ? `Audit: CERTIFIED (with ${(summary.medium || 0) + (summary.low || 0)} advisory warning(s))`
+    : "Audit: CERTIFIED";
+
+  logger.info(certifiedMsg);
+  emitProgress(
+    emitter,
+    makeEvent("audit:end", { ...eventBase, stage: "audit" }, {
+      status: "ok",
+      message: certifiedMsg
+    })
+  );
+
+  return { action: "ok", stageResult: { ok: true, summary: certifiedMsg } };
+}
+
 // Exported for testing
 export { buildFallbackChain, isAgentFailure, runRoleWithFallback };

package/src/orchestrator.js

@@ -32,7 +32,7 @@ import { invokeSolomon } from "./orchestrator/solomon-escalation.js";
 import { PipelineContext } from "./orchestrator/pipeline-context.js";
 import { runTriageStage, runResearcherStage, runArchitectStage, runPlannerStage, runDiscoverStage, runHuReviewerStage } from "./orchestrator/pre-loop-stages.js";
 import { runCoderStage, runRefactorerStage, runTddCheckStage, runSonarStage, runSonarCloudStage, runReviewerStage } from "./orchestrator/iteration-stages.js";
-import { runTesterStage, runSecurityStage, runImpeccableStage } from "./orchestrator/post-loop-stages.js";
+import { runTesterStage, runSecurityStage, runImpeccableStage, runFinalAuditStage } from "./orchestrator/post-loop-stages.js";
 import { waitForCooldown, MAX_STANDBY_RETRIES } from "./orchestrator/standby.js";
 import { detectTestFramework } from "./utils/project-detect.js";
 import { runPreflightChecks } from "./orchestrator/preflight-checks.js";
@@ -669,6 +669,22 @@ async function handlePostLoopStages({ config, session, emitter, eventBase, coder
     }
   }
 
+  // Final audit — last quality gate before declaring success
+  const auditResult = await runFinalAuditStage({
+    config, logger, emitter, eventBase, session, coderRole, trackBudget,
+    iteration: i, task, diff: postLoopDiff
+  });
+  if (auditResult.stageResult) {
+    stageResults.audit = auditResult.stageResult;
+    await tryBecariaComment({ config, session, logger, agent: "Audit", body: `Final audit: ${auditResult.stageResult.summary || "completed"}` });
+  }
+  if (auditResult.action === "retry") {
+    // Audit found actionable issues — loop back to coder
+    session.last_reviewer_feedback = auditResult.feedback;
+    await saveSession(session);
+    return { action: "continue" };
+  }
+
   return { action: "proceed" };
 }
 
@@ -1199,7 +1215,7 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
   const checkpointIntervalMs = (ctx.config.session.checkpoint_interval_minutes ?? 5) * 60 * 1000;
   let lastCheckpointAt = Date.now();
   let checkpointDisabled = false;
-  let lastCheckpointSnapshot = null;
+  let lastCheckpointSnapshot = takeCheckpointSnapshot(ctx.session);
 
   let i = 0;
   while (i < ctx.config.max_iterations) {