karajan-code 3.7.1 → 3.7.2

package/package.json

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

package/src/agents/availability.js

@@ -29,3 +29,24 @@ export async function assertAgentsAvailable(agentNames = []) {
   }
   throw new Error(lines.join("\n"));
 }
+
+/**
+ * Non-throwing counterpart to assertAgentsAvailable: probe each agent CLI in
+ * parallel and return the subset whose `--version` succeeds. Used by the
+ * audit fallback (KJC-BUG-0094) to skip uninstalled providers instead of
+ * aborting the whole command when any one is missing.
+ * @param {string[]} agentNames
+ * @returns {Promise<string[]>}
+ */
+export async function filterAvailableAgents(agentNames = []) {
+  const unique = [...new Set(agentNames.filter(Boolean))];
+  const probes = await Promise.all(
+    unique.map(async (name) => {
+      const meta = getAgentMeta(name);
+      if (!meta?.bin) return null;
+      const res = await runCommand(resolveBin(meta.bin), ["--version"]);
+      return res.exitCode === 0 ? name : null;
+    })
+  );
+  return probes.filter(Boolean);
+}

package/src/audit/audit-fallback.js

@@ -0,0 +1,66 @@
+// Resilient provider/model fallback for the `kj audit` CLI (KJC-BUG-0094).
+// The CLI audit calls AuditRole.executeWithDeterministic directly, bypassing
+// the orchestrator's recovery paths, so a dead configured model (e.g. an
+// inherited "claude-fable-5") killed the command. The LLM phase now tries:
+// configured provider+model → same provider default model → remaining known
+// providers. First success wins; the deterministic context is reused.
+import { resolveRole } from "../config.js";
+import { AuditRole } from "../roles/audit-role.js";
+
+const KNOWN_PROVIDERS = ["claude", "codex", "gemini"];
+
+/** Ordered, de-duplicated fallback candidates for the audit role. */
+export function buildAuditFallbackCandidates(config) {
+  const effective = resolveRole(config, "audit");
+  const primary = effective.provider || "claude";
+  const candidates = [{ provider: primary, model: effective.model ?? null }];
+  if (effective.model) candidates.push({ provider: primary, model: null });
+  for (const p of KNOWN_PROVIDERS) {
+    if (p !== primary) candidates.push({ provider: p, model: null });
+  }
+  const seen = new Set();
+  return candidates.filter((c) => {
+    const key = `${c.provider}::${c.model ?? ""}`;
+    return seen.has(key) ? false : (seen.add(key), true);
+  });
+}
+
+// Pin the audit role to a provider/model. Sets BOTH the per-role override and
+// `coder_options.model` (the audit role inherits its model from the coder
+// bucket); a null model neutralizes both so the provider default is used.
+export function withAuditProvider(config, provider, model) {
+  return {
+    ...config,
+    roles: { ...(config?.roles || {}), audit: { ...(config?.roles?.audit || {}), provider, model: model ?? undefined } },
+    coder_options: { ...(config?.coder_options || {}), model: model ?? undefined },
+  };
+}
+
+/** Run the audit LLM phase with automatic provider/model fallback. */
+export async function runAuditWithFallback({
+  config, logger, roleInput, deterministicCtx, available, candidates, onFallback, createRole,
+}) {
+  const makeRole = createRole || ((cfg) => new AuditRole({ config: cfg, logger }));
+  const all = candidates || buildAuditFallbackCandidates(config);
+  const usable = available ? all.filter((c) => available.includes(c.provider)) : all;
+  if (usable.length === 0) {
+    throw new Error("No available audit provider — install claude, codex, or gemini, or set roles.audit.provider");
+  }
+
+  let last = null;
+  let attempts = 0;
+  for (const cand of usable) {
+    attempts += 1;
+    if (attempts > 1) onFallback?.(cand, attempts);
+    const role = makeRole(withAuditProvider(config, cand.provider, cand.model));
+    const meta = { provider: cand.provider, model: cand.model ?? null };
+    try {
+      const result = await role.executeWithDeterministic(roleInput, deterministicCtx);
+      if (result?.ok) return { ...result, ...meta, attempts };
+      last = { ...result, ...meta };
+    } catch (err) {
+      last = { ok: false, result: { error: err.message, provider: cand.provider }, summary: `Audit failed: ${err.message}`, ...meta };
+    }
+  }
+  return { ...last, attempts, exhausted: true };
+}

package/src/commands/audit.js

@@ -3,10 +3,11 @@ import fs from "node:fs/promises";
 import readline from "node:readline";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { assertAgentsAvailable } from "../agents/availability.js";
+import { assertAgentsAvailable, filterAvailableAgents } from "../agents/availability.js";
 import { resolveRole } from "../config.js";
 import { AUDIT_DIMENSIONS } from "../prompts/audit.js";
 import { AuditRole } from "../roles/audit-role.js";
+import { buildAuditFallbackCandidates, runAuditWithFallback } from "../audit/audit-fallback.js";
 import { withCliRunLog } from "../utils/cli-run-log.js";
 import { createCliProgressReporter } from "../utils/cli-progress.js";
 import { runAgentReadiness, formatAgentReadinessReport } from "../audit/agent-readiness.js";
@@ -260,7 +261,11 @@ export async function auditCommand({ task, config, logger, dimensions, json, age
 
   return withCliRunLog("audit", { projectDir: config?.projectDir, logger }, async ({ runLog }) => {
     const auditRoleConfig = resolveRole(config, "audit");
-    await assertAgentsAvailable([auditRoleConfig.provider]);
+    // KJC-BUG-0094: proceed if any fallback candidate is installed; throw only when NONE are.
+    const fallbackCandidates = buildAuditFallbackCandidates(config);
+    const candidateProviders = [...new Set(fallbackCandidates.map((c) => c.provider))];
+    const available = await filterAvailableAgents(candidateProviders);
+    if (available.length === 0) await assertAgentsAvailable([auditRoleConfig.provider]);
     logger.info(`Audit (${auditRoleConfig.provider}) starting...`);
     runLog.logText(`[audit] provider=${auditRoleConfig.provider} dimensions=${dimensions || "all"} deterministicOnly=${deterministicOnly}`);
 
@@ -347,7 +352,18 @@ export async function auditCommand({ task, config, logger, dimensions, json, age
     const progress = createCliProgressReporter({ role: "auditor" });
     let roleResult;
     try {
-      roleResult = await role.executeWithDeterministic({ ...roleInput, onOutput: progress.onOutput }, deterministicCtx);
+      // KJC-BUG-0094: resilient fallback — if the configured provider/model
+      // is down (e.g. an inherited model like "claude-fable-5" is offline),
+      // degrade to the provider default, then to the next installed provider,
+      // reusing the deterministic context so no static analysis is re-run.
+      roleResult = await runAuditWithFallback({
+        config, logger,
+        roleInput: { ...roleInput, onOutput: progress.onOutput },
+        deterministicCtx,
+        available,
+        candidates: fallbackCandidates,
+        onFallback: (cand) => logger.warn(`Audit provider fallback → ${cand.provider}${cand.model ? ` (${cand.model})` : " (default model)"}`),
+      });
       progress.finish(roleResult.ok ? "done" : "failed");
     } catch (err) { progress.finish("failed"); throw err; }
 

package/src/commands/board.js

@@ -77,15 +77,18 @@ async function findAvailablePort(desiredPort, maxTries = 10) {
 
 /**
  * Build the board URL. When `projectSlug` is provided, the URL points at
- * the per-project view (`/p/<slug>`) so the caller's project shows up
- * pre-filtered instead of "All projects".
+ * the per-project view via the SPA hash route (`#board/<slug>`) so the
+ * caller's project shows up pre-filtered instead of "All projects". The
+ * frontend router is hash-based (see public/utils/init-listeners.js); a
+ * real `/p/<slug>` path is not a route and silently falls back to the
+ * global dashboard. KJC-BUG-0093.
  * @param {number} port
  * @param {string|null} [projectSlug]
  * @returns {string}
  */
-function buildBoardUrl(port, projectSlug) {
+export function buildBoardUrl(port, projectSlug) {
   const base = `http://localhost:${port}`;
-  return projectSlug ? `${base}/p/${projectSlug}` : base;
+  return projectSlug ? `${base}/#board/${projectSlug}` : base;
 }
 
 /**

package/src/commands/plan/generate.js

@@ -513,8 +513,8 @@ async function planGenerateImpl({ task, config, logger, json, context, runLog, f
       const { projectSlug: slugFor } = await import("../../plan/plan-store.js");
       const boardPort = config?.hu_board?.port ?? 4000;
       // `projectSlug` scopes the board URL to this project's view
-      // (`/p/<slug>`) instead of the global "All projects" dashboard. The
-      // board UI hides multi-project chrome when it sees that prefix.
+      // (`#board/<slug>`) instead of the global "All projects" dashboard.
+      // The hash route opens the board pre-filtered to that project.
       const boardResult = await startBoard(boardPort, { projectSlug: slugFor(projectDir) });
       const status = boardResult.alreadyRunning ? "already running" : "started";
       console.log(renderBoardBanner({ url: boardResult.url, status, projectName: plan.name }));

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

@@ -347,8 +347,8 @@ export async function tryAutoStartBoard(config, logger, emitter, eventBase) {
   try {
     const { startBoard, renderBoardBanner } = await import("../../commands/board.js");
     const boardPort = config.hu_board.port || 4000;
-    // Scope the board URL to the current run's project (`/p/<slug>`) so
-    // the user lands on a filtered view, not the global dashboard.
+    // Scope the board URL to the current run's project (`#board/<slug>`)
+    // so the user lands on a filtered view, not the global dashboard.
     const slug = config.projectDir ? slugFor(config.projectDir) : null;
     const boardResult = await startBoard(boardPort, { projectSlug: slug });
     const status = boardResult.alreadyRunning ? "already running" : "started";