karajan-code 1.9.6 → 1.10.1

package/package.json

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

package/src/cli.js

@@ -17,6 +17,7 @@ import { runCommandHandler } from "./commands/run.js";
 import { resumeCommand } from "./commands/resume.js";
 import { sonarCommand, sonarOpenCommand } from "./commands/sonar.js";
 import { rolesCommand } from "./commands/roles.js";
+import { agentsCommand } from "./commands/agents.js";
 
 const PKG_PATH = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../package.json");
 const PKG_VERSION = JSON.parse(readFileSync(PKG_PATH, "utf8")).version;
@@ -161,6 +162,15 @@ program
     });
   });
 
+program
+  .command("agents [subcommand] [role] [provider]")
+  .description("List or change AI agent assignments per role (e.g. kj agents set coder gemini)")
+  .action(async (subcommand, role, provider) => {
+    await withConfig("agents", {}, async ({ config }) => {
+      await agentsCommand({ config, subcommand: subcommand || "list", role, provider });
+    });
+  });
+
 program
   .command("plan")
   .description("Generate implementation plan")

package/src/commands/agents.js

@@ -0,0 +1,68 @@
+import { loadConfig, writeConfig, getConfigPath, resolveRole } from "../config.js";
+import { checkBinary, KNOWN_AGENTS } from "../utils/agent-detect.js";
+
+const ASSIGNABLE_ROLES = [
+  "coder", "reviewer", "planner", "refactorer", "triage",
+  "researcher", "tester", "security", "solomon"
+];
+
+const VALID_PROVIDERS = KNOWN_AGENTS.map((a) => a.name);
+
+export function listAgents(config) {
+  return ASSIGNABLE_ROLES.map((role) => {
+    const resolved = resolveRole(config, role);
+    return {
+      role,
+      provider: resolved.provider || "-",
+      model: resolved.model || "-"
+    };
+  });
+}
+
+export async function setAgent(role, provider) {
+  if (!ASSIGNABLE_ROLES.includes(role)) {
+    throw new Error(`Unknown role "${role}". Valid roles: ${ASSIGNABLE_ROLES.join(", ")}`);
+  }
+  if (!VALID_PROVIDERS.includes(provider)) {
+    const bin = await checkBinary(provider);
+    if (!bin.ok) {
+      throw new Error(`Provider "${provider}" not found. Available: ${VALID_PROVIDERS.join(", ")}`);
+    }
+  }
+
+  const { config } = await loadConfig();
+  config.roles = config.roles || {};
+  config.roles[role] = config.roles[role] || {};
+  config.roles[role].provider = provider;
+
+  const configPath = getConfigPath();
+  await writeConfig(configPath, config);
+
+  return { role, provider, configPath };
+}
+
+export async function agentsCommand({ config, subcommand, role, provider }) {
+  if (subcommand === "set") {
+    if (!role || !provider) {
+      console.log("Usage: kj agents set <role> <provider>");
+      console.log(`Roles: ${ASSIGNABLE_ROLES.join(", ")}`);
+      console.log(`Providers: ${VALID_PROVIDERS.join(", ")}`);
+      return;
+    }
+    const result = await setAgent(role, provider);
+    console.log(`Set ${result.role} -> ${result.provider} (saved to ${result.configPath})`);
+    return result;
+  }
+
+  const agents = listAgents(config);
+  const roleWidth = Math.max(...agents.map((a) => a.role.length), 4);
+  const provWidth = Math.max(...agents.map((a) => a.provider.length), 8);
+  console.log(`${"Role".padEnd(roleWidth)}  ${"Provider".padEnd(provWidth)}  Model`);
+  console.log("-".repeat(roleWidth + provWidth + 10));
+  for (const a of agents) {
+    console.log(`${a.role.padEnd(roleWidth)}  ${a.provider.padEnd(provWidth)}  ${a.model}`);
+  }
+  return agents;
+}
+
+export { ASSIGNABLE_ROLES, VALID_PROVIDERS };

package/src/commands/doctor.js

@@ -1,3 +1,6 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
 import { runCommand } from "../utils/process.js";
 import { exists } from "../utils/fs.js";
 import { getConfigPath } from "../config.js";
@@ -6,9 +9,24 @@ import { resolveRoleMdPath, loadFirstExisting } from "../roles/base-role.js";
 import { ensureGitRepo } from "../utils/git.js";
 import { checkBinary, KNOWN_AGENTS } from "../utils/agent-detect.js";
 
+function getPackageVersion() {
+  const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../package.json");
+  return JSON.parse(readFileSync(pkgPath, "utf8")).version;
+}
+
 export async function runChecks({ config }) {
   const checks = [];
 
+  // 0. Karajan version
+  const version = getPackageVersion();
+  checks.push({
+    name: "karajan",
+    label: "Karajan Code",
+    ok: true,
+    detail: `v${version}`,
+    fix: null
+  });
+
   // 1. Config file
   const configPath = getConfigPath();
   const configExists = await exists(configPath);

package/src/commands/run.js

@@ -4,7 +4,7 @@ import { assertAgentsAvailable } from "../agents/availability.js";
 import { createActivityLog } from "../activity-log.js";
 import { printHeader, printEvent } from "../utils/display.js";
 import { resolveRole } from "../config.js";
-import { parseCardId, buildTaskFromCard, buildCompletionUpdates } from "../planning-game/adapter.js";
+import { parseCardId } from "../planning-game/adapter.js";
 
 export async function runCommandHandler({ task, config, logger, flags }) {
   const requiredProviders = [
@@ -22,24 +22,10 @@ export async function runCommandHandler({ task, config, logger, flags }) {
   if (config.pipeline?.security?.enabled) requiredProviders.push(resolveRole(config, "security").provider);
   await assertAgentsAvailable(requiredProviders);
 
-  // --- Planning Game: resolve card context ---
+  // --- Planning Game: resolve card ID ---
   const pgCardId = flags?.pgTask || parseCardId(task);
   const pgProject = flags?.pgProject || config.planning_game?.project_id || null;
-  let pgCard = null;
-  let enrichedTask = task;
-
-  if (pgCardId && pgProject && config.planning_game?.enabled !== false) {
-    try {
-      const { fetchCard, updateCard } = await import("../planning-game/client.js");
-      pgCard = await fetchCard({ projectId: pgProject, cardId: pgCardId });
-      if (pgCard) {
-        enrichedTask = buildTaskFromCard(pgCard);
-        logger.info(`Planning Game: loaded card ${pgCardId} from project ${pgProject}`);
-      }
-    } catch (err) {
-      logger.warn(`Planning Game: could not load card ${pgCardId}: ${err.message}`);
-    }
-  }
+  const enrichedTask = task;
 
   const jsonMode = flags?.json;
 
@@ -65,26 +51,8 @@ export async function runCommandHandler({ task, config, logger, flags }) {
     printHeader({ task: enrichedTask, config });
   }
 
-  const startDate = new Date().toISOString();
   const result = await runFlow({ task: enrichedTask, config, logger, flags, emitter, pgTaskId: pgCardId || null, pgProject: pgProject || null });
 
-  // --- Planning Game: update card on completion ---
-  if (pgCard && pgProject && result?.approved) {
-    try {
-      const { updateCard } = await import("../planning-game/client.js");
-      const updates = buildCompletionUpdates({
-        approved: true,
-        commits: result.git?.commits || [],
-        startDate,
-        codeveloper: config.planning_game?.codeveloper || null
-      });
-      await updateCard({ projectId: pgProject, cardId: pgCardId, firebaseId: pgCard.firebaseId, updates });
-      logger.info(`Planning Game: updated ${pgCardId} to "${updates.status}"`);
-    } catch (err) {
-      logger.warn(`Planning Game: could not update card ${pgCardId}: ${err.message}`);
-    }
-  }
-
   if (jsonMode) {
     console.log(JSON.stringify(result, null, 2));
   }

package/src/mcp/server-handlers.js

@@ -442,6 +442,21 @@ export async function handleToolCall(name, args, server, extra) {
     return runKjCommand({ command: "doctor", options: a });
   }
 
+  if (name === "kj_agents") {
+    const action = a.action || "list";
+    if (action === "set") {
+      if (!a.role || !a.provider) {
+        return failPayload("Missing required fields: role and provider");
+      }
+      const { setAgent } = await import("../commands/agents.js");
+      const result = await setAgent(a.role, a.provider);
+      return { ok: true, ...result, message: `${result.role} now uses ${result.provider}` };
+    }
+    const config = await buildConfig(a);
+    const { listAgents } = await import("../commands/agents.js");
+    return { ok: true, agents: listAgents(config) };
+  }
+
   if (name === "kj_config") {
     return runKjCommand({
       command: "config",

package/src/mcp/tools.js

@@ -97,7 +97,7 @@ export const tools = [
   {
     name: "kj_resume",
     description:
-      "Resume a paused session by ID. Provide an answer to the question that caused the pause. Sends real-time progress notifications via MCP logging.",
+      "Resume a paused, stopped, or failed session by ID. For paused sessions, provide an answer. For stopped/failed sessions, re-runs the flow from scratch. Sends real-time progress notifications via MCP logging.",
     inputSchema: {
       type: "object",
       required: ["sessionId"],
@@ -136,6 +136,19 @@ export const tools = [
       }
     }
   },
+  {
+    name: "kj_agents",
+    description: "List or change which AI agent (provider) is assigned to each pipeline role. Use action='list' to see current assignments. Use action='set' with role and provider to change it persistently (writes to kj.config.yml, no restart needed).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["list", "set"], description: "Action: list current agents or set a role's provider" },
+        role: { type: "string", description: "Role to change (e.g. coder, reviewer, planner, triage)" },
+        provider: { type: "string", description: "New provider to assign (e.g. claude, codex, gemini, aider)" },
+        kjHome: { type: "string" }
+      }
+    }
+  },
   {
     name: "kj_code",
     description: "Run coder-only mode",

package/src/orchestrator.js

@@ -157,6 +157,32 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
 
   eventBase.sessionId = session.id;
 
+  // --- Planning Game: mark card as In Progress ---
+  let pgCard = null;
+  if (pgTaskId && pgProject && config.planning_game?.enabled !== false) {
+    try {
+      const { fetchCard, updateCard } = await import("./planning-game/client.js");
+      pgCard = await fetchCard({ projectId: pgProject, cardId: pgTaskId });
+      if (pgCard && pgCard.status !== "In Progress") {
+        await updateCard({
+          projectId: pgProject,
+          cardId: pgTaskId,
+          firebaseId: pgCard.firebaseId,
+          updates: {
+            status: "In Progress",
+            startDate: new Date().toISOString(),
+            developer: "dev_016",
+            codeveloper: config.planning_game?.codeveloper || null
+          }
+        });
+        logger.info(`Planning Game: ${pgTaskId} → In Progress`);
+      }
+    } catch (err) {
+      logger.warn(`Planning Game: could not update ${pgTaskId}: ${err.message}`);
+    }
+  }
+  session.pg_card = pgCard || null;
+
   emitProgress(
     emitter,
     makeEvent("session:start", eventBase, {
@@ -295,7 +321,13 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
 
       await addCheckpoint(session, { stage: "interactive-checkpoint", elapsed_minutes: Number(elapsedStr), answer });
 
-      if (!answer || answer.trim() === "4" || answer.trim().toLowerCase().startsWith("stop")) {
+      // Explicit stop: only when the user clearly chose option 4 or typed "stop".
+      // A null/empty answer (e.g. elicitInput failure, AI timeout) defaults to
+      // "continue 5 more minutes" so the session is not killed accidentally.
+      const trimmedAnswer = (answer || "").trim();
+      const isExplicitStop = trimmedAnswer === "4" || trimmedAnswer.toLowerCase().startsWith("stop");
+
+      if (isExplicitStop) {
         await markSessionStatus(session, "stopped");
         emitProgress(
           emitter,
@@ -308,12 +340,15 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
         return { approved: false, sessionId: session.id, reason: "user_stopped", elapsed_minutes: Number(elapsedStr) };
       }
 
-      if (answer.trim() === "2" || answer.trim().toLowerCase().startsWith("continue until")) {
+      // No answer or unrecognized → default to continue 5 more minutes
+      if (!trimmedAnswer) {
+        lastCheckpointAt = Date.now();
+      } else if (trimmedAnswer === "2" || trimmedAnswer.toLowerCase().startsWith("continue until")) {
         checkpointDisabled = true;
-      } else if (answer.trim() === "1" || answer.trim().toLowerCase().includes("5 m")) {
+      } else if (trimmedAnswer === "1" || trimmedAnswer.toLowerCase().includes("5 m")) {
         lastCheckpointAt = Date.now();
       } else {
-        const customMinutes = parseInt(answer.trim().replace(/\D/g, ""), 10);
+        const customMinutes = parseInt(trimmedAnswer.replace(/\D/g, ""), 10);
         if (customMinutes > 0) {
           lastCheckpointAt = Date.now();
           config.session.checkpoint_interval_minutes = customMinutes;
@@ -484,6 +519,30 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
       }
       session.budget = budgetSummary();
       await markSessionStatus(session, "approved");
+
+      // --- Planning Game: mark card as To Validate ---
+      if (pgCard && pgProject) {
+        try {
+          const { updateCard } = await import("./planning-game/client.js");
+          const { buildCompletionUpdates } = await import("./planning-game/adapter.js");
+          const pgUpdates = buildCompletionUpdates({
+            approved: true,
+            commits: gitResult?.commits || [],
+            startDate: session.pg_card?.startDate || session.created_at,
+            codeveloper: config.planning_game?.codeveloper || null
+          });
+          await updateCard({
+            projectId: pgProject,
+            cardId: session.pg_task_id,
+            firebaseId: pgCard.firebaseId,
+            updates: pgUpdates
+          });
+          logger.info(`Planning Game: ${session.pg_task_id} → To Validate`);
+        } catch (err) {
+          logger.warn(`Planning Game: could not update ${session.pg_task_id} on completion: ${err.message}`);
+        }
+      }
+
       emitProgress(
         emitter,
         makeEvent("session:end", { ...eventBase, stage: "done" }, {
@@ -561,11 +620,20 @@ export async function resumeFlow({ sessionId, answer, config, logger, flags = {}
     return session;
   }
 
-  if (session.status !== "running") {
-    logger.info(`Session ${sessionId} has status ${session.status}`);
+  // Allow resuming "stopped" sessions (checkpoint stop) and "failed" sessions
+  const resumableStatuses = ["running", "stopped", "failed"];
+  if (!resumableStatuses.includes(session.status)) {
+    logger.info(`Session ${sessionId} has status ${session.status} — not resumable`);
     return session;
   }
 
+  // Mark as running again for stopped/failed sessions
+  if (session.status !== "running") {
+    logger.info(`Resuming ${session.status} session ${sessionId}`);
+    session.status = "running";
+    await saveSession(session);
+  }
+
   // Session was paused and now resumed with answer - re-run the flow
   const task = session.task;
   const sessionConfig = config || session.config_snapshot;

package/src/prompts/coder.js

@@ -10,6 +10,14 @@ const SUBAGENT_PREAMBLE_SERENA = [
   "Execute the task directly. Focus only on coding."
 ].join(" ");
 
+const SUBPROCESS_CONSTRAINTS = [
+  "## Environment constraints",
+  "You run as a non-interactive subprocess (no stdin, no TTY).",
+  "- If the task requires a CLI wizard or interactive init (e.g. `create-react-app`, `pnpm create astro`, `npm init`), ALWAYS use non-interactive flags: `--yes`, `--no-input`, `--template <name>`, `--defaults`, etc.",
+  "- Never run a command that waits for user input — it will hang forever.",
+  "- If a task absolutely cannot be done non-interactively, say so explicitly instead of hanging."
+].join("\n");
+
 const SERENA_INSTRUCTIONS = [
   "## Serena MCP — symbol-level code navigation",
   "You have access to Serena MCP tools for efficient code navigation.",
@@ -26,7 +34,8 @@ export function buildCoderPrompt({ task, reviewerFeedback = null, sonarSummary =
     serenaEnabled ? SUBAGENT_PREAMBLE_SERENA : SUBAGENT_PREAMBLE,
     `Task:\n${task}`,
     "Implement directly in the repository.",
-    "Keep changes minimal and production-ready."
+    "Keep changes minimal and production-ready.",
+    SUBPROCESS_CONSTRAINTS
   ];
 
   if (serenaEnabled) {