karajan-code 1.13.2 → 1.15.0

package/package.json

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

package/src/cli.js

@@ -87,6 +87,7 @@ program
   .option("--auto-pr")
   .option("--enable-becaria", "Enable BecarIA Gateway (early PR + dispatch comments/reviews)")
   .option("--branch-prefix <prefix>")
+  .option("--task-type <type>", "Explicit task type: sw, infra, doc, add-tests, refactor")
   .option("--methodology <name>")
   .option("--no-auto-rebase")
   .option("--no-sonar")

package/src/config.js

@@ -97,6 +97,7 @@ const DEFAULTS = {
       disabled_rules: ["javascript:S1116", "javascript:S3776"]
     }
   },
+  policies: {},
   serena: { enabled: false },
   planning_game: { enabled: false, project_id: null, codeveloper: null },
   becaria: { enabled: false, review_event: "becaria-review", comment_event: "becaria-comment", comment_prefix: true },
@@ -285,6 +286,7 @@ export function applyRunOverrides(config, flags) {
     out.development.methodology = methodology;
     out.development.require_test_changes = methodology === "tdd";
   }
+  if (flags.taskType) out.taskType = String(flags.taskType);
   if (flags.noSonar || flags.sonar === false) out.sonarqube.enabled = false;
   out.serena = out.serena || { enabled: false };
   if (flags.enableSerena !== undefined) out.serena.enabled = Boolean(flags.enableSerena);

package/src/guards/policy-resolver.js

@@ -0,0 +1,37 @@
+export const VALID_TASK_TYPES = ["sw", "infra", "doc", "add-tests", "refactor"];
+
+export const DEFAULT_POLICIES = {
+  sw:        { tdd: true,  sonar: true,  reviewer: true, testsRequired: true  },
+  infra:     { tdd: false, sonar: false, reviewer: true, testsRequired: false },
+  doc:       { tdd: false, sonar: false, reviewer: true, testsRequired: false },
+  "add-tests": { tdd: false, sonar: true,  reviewer: true, testsRequired: true  },
+  refactor:  { tdd: true,  sonar: true,  reviewer: true, testsRequired: false },
+};
+
+const FALLBACK_TYPE = "sw";
+
+/**
+ * Resolve pipeline policies for a given taskType.
+ * Unknown / null / undefined taskType falls back to "sw" (conservative).
+ * configOverrides optionally merges over defaults per taskType.
+ */
+export function resolvePolicies(taskType, configOverrides) {
+  const resolvedType = VALID_TASK_TYPES.includes(taskType) ? taskType : FALLBACK_TYPE;
+  const base = { ...DEFAULT_POLICIES[resolvedType] };
+  const overrides = configOverrides?.[resolvedType];
+  if (overrides && typeof overrides === "object") {
+    Object.assign(base, overrides);
+  }
+  return base;
+}
+
+/**
+ * Resolve policies for a taskType and return a flat object with the resolved
+ * taskType plus all policy flags. This is the main entry point for the
+ * orchestrator to determine which pipeline stages to enable/disable.
+ */
+export function applyPolicies({ taskType, policies } = {}) {
+  const resolvedType = VALID_TASK_TYPES.includes(taskType) ? taskType : FALLBACK_TYPE;
+  const resolved = resolvePolicies(taskType, policies);
+  return { taskType: resolvedType, ...resolved };
+}

package/src/mcp/run-kj.js

@@ -48,6 +48,7 @@ export async function runKjCommand({ command, commandArgs = [], options = {}, en
   normalizeBoolFlag(options.autoPush, "--auto-push", args);
   normalizeBoolFlag(options.autoPr, "--auto-pr", args);
   if (options.autoRebase === false) args.push("--no-auto-rebase");
+  addOptionalValue(args, "--task-type", options.taskType);
   normalizeBoolFlag(options.noSonar, "--no-sonar", args);
   if (options.smartModels === true) args.push("--smart-models");
   if (options.smartModels === false) args.push("--no-smart-models");

package/src/mcp/server-handlers.js

@@ -565,6 +565,12 @@ export async function handleToolCall(name, args, server, extra) {
     if (!a.task) {
       return failPayload("Missing required field: task");
     }
+    if (a.taskType) {
+      const validTypes = ["sw", "infra", "doc", "add-tests", "refactor"];
+      if (!validTypes.includes(a.taskType)) {
+        return failPayload(`Invalid taskType "${a.taskType}". Valid values: ${validTypes.join(", ")}`);
+      }
+    }
     if (!isPreflightAcked()) {
       const { config } = await loadConfig();
       const { listAgents } = await import("../commands/agents.js");

package/src/mcp/tools.js

@@ -88,6 +88,7 @@ export const tools = [
         branchPrefix: { type: "string" },
         smartModels: { type: "boolean", description: "Enable/disable smart model selection based on triage complexity" },
         checkpointInterval: { type: "number", description: "Minutes between interactive checkpoints (default: 5). Set 0 to disable." },
+        taskType: { type: "string", enum: ["sw", "infra", "doc", "add-tests", "refactor"], description: "Explicit task type for policy resolution. Overrides triage classification." },
         noSonar: { type: "boolean" },
         kjHome: { type: "string" },
         sonarToken: { type: "string" },

package/src/orchestrator/iteration-stages.js

@@ -3,7 +3,7 @@ import { CoderRole } from "../roles/coder-role.js";
 import { RefactorerRole } from "../roles/refactorer-role.js";
 import { SonarRole } from "../roles/sonar-role.js";
 import { addCheckpoint, markSessionStatus, saveSession, pauseSession } from "../session-store.js";
-import { generateDiff } from "../review/diff-generator.js";
+import { generateDiff, getUntrackedFiles } from "../review/diff-generator.js";
 import { evaluateTddPolicy } from "../review/tdd-policy.js";
 import { validateReviewResult } from "../review/schema.js";
 import { filterReviewScope, buildDeferredContext } from "../review/scope-filter.js";
@@ -198,7 +198,8 @@ export async function runRefactorerStage({ refactorerRole, config, logger, emitt
 export async function runTddCheckStage({ config, logger, emitter, eventBase, session, trackBudget, iteration, askQuestion }) {
   logger.setContext({ iteration, stage: "tdd" });
   const tddDiff = await generateDiff({ baseRef: session.session_start_sha });
-  const tddEval = evaluateTddPolicy(tddDiff, config.development);
+  const untrackedFiles = await getUntrackedFiles();
+  const tddEval = evaluateTddPolicy(tddDiff, config.development, untrackedFiles);
   await addCheckpoint(session, {
     stage: "tdd-policy",
     iteration,
@@ -227,34 +228,42 @@ export async function runTddCheckStage({ config, logger, emitter, eventBase, ses
     session.repeated_issue_count += 1;
     await saveSession(session);
     if (session.repeated_issue_count >= config.session.fail_fast_repeats) {
-      const question = `TDD policy has failed ${session.repeated_issue_count} times. The coder is not creating tests. How should we proceed? Issue: ${tddEval.reason}`;
-      if (askQuestion) {
-        const answer = await askQuestion(question, { iteration, stage: "tdd" });
-        if (answer) {
-          session.last_reviewer_feedback += `\nUser guidance: ${answer}`;
-          session.repeated_issue_count = 0;
-          await saveSession(session);
-          return { action: "continue" };
-        }
-      }
-      await pauseSession(session, {
-        question,
-        context: {
-          iteration,
-          stage: "tdd",
-          lastFeedback: tddEval.message,
-          repeatedCount: session.repeated_issue_count
-        }
-      });
       emitProgress(
         emitter,
-        makeEvent("question", { ...eventBase, stage: "tdd" }, {
-          status: "paused",
-          message: question,
-          detail: { question, sessionId: session.id }
+        makeEvent("solomon:escalate", { ...eventBase, stage: "tdd" }, {
+          message: `TDD sub-loop limit reached (${session.repeated_issue_count}/${config.session.fail_fast_repeats})`,
+          detail: { subloop: "tdd", retryCount: session.repeated_issue_count, reason: tddEval.reason }
         })
       );
-      return { action: "pause", result: { paused: true, sessionId: session.id, question, context: "tdd_fail_fast" } };
+
+      const solomonResult = await invokeSolomon({
+        config, logger, emitter, eventBase, stage: "tdd", askQuestion, session, iteration,
+        conflict: {
+          stage: "tdd",
+          task: session.task,
+          iterationCount: session.repeated_issue_count,
+          maxIterations: config.session.fail_fast_repeats,
+          reason: tddEval.reason,
+          sourceFiles: tddEval.sourceFiles,
+          testFiles: tddEval.testFiles,
+          history: [{ agent: "tdd-policy", feedback: tddEval.message }]
+        }
+      });
+
+      if (solomonResult.action === "pause") {
+        return { action: "pause", result: { paused: true, sessionId: session.id, question: solomonResult.question, context: "tdd_fail_fast" } };
+      }
+      if (solomonResult.action === "continue") {
+        if (solomonResult.humanGuidance) {
+          session.last_reviewer_feedback += `\nUser guidance: ${solomonResult.humanGuidance}`;
+        }
+        session.repeated_issue_count = 0;
+        await saveSession(session);
+        return { action: "continue" };
+      }
+      if (solomonResult.action === "subtask") {
+        return { action: "pause", result: { paused: true, sessionId: session.id, subtask: solomonResult.subtask, context: "tdd_subtask" } };
+      }
     }
     return { action: "continue" };
   }

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

@@ -56,12 +56,14 @@ export async function runTriageStage({ config, logger, emitter, eventBase, sessi
   const recommendedRoles = new Set(triageOutput.result?.roles || []);
   const roleOverrides = {};
   if (triageOutput.ok) {
-    roleOverrides.plannerEnabled = recommendedRoles.has("planner");
-    roleOverrides.researcherEnabled = recommendedRoles.has("researcher");
-    roleOverrides.refactorerEnabled = recommendedRoles.has("refactorer");
-    roleOverrides.reviewerEnabled = recommendedRoles.has("reviewer");
-    roleOverrides.testerEnabled = recommendedRoles.has("tester");
-    roleOverrides.securityEnabled = recommendedRoles.has("security");
+    // Triage can activate roles, but cannot deactivate roles explicitly enabled in pipeline config
+    const p = config.pipeline || {};
+    roleOverrides.plannerEnabled = recommendedRoles.has("planner") || Boolean(p.planner?.enabled);
+    roleOverrides.researcherEnabled = recommendedRoles.has("researcher") || Boolean(p.researcher?.enabled);
+    roleOverrides.refactorerEnabled = recommendedRoles.has("refactorer") || Boolean(p.refactorer?.enabled);
+    roleOverrides.reviewerEnabled = recommendedRoles.has("reviewer") || Boolean(p.reviewer?.enabled);
+    roleOverrides.testerEnabled = recommendedRoles.has("tester") || Boolean(p.tester?.enabled);
+    roleOverrides.securityEnabled = recommendedRoles.has("security") || Boolean(p.security?.enabled);
   }
 
   const shouldDecompose = triageOutput.result?.shouldDecompose || false;
@@ -72,6 +74,7 @@ export async function runTriageStage({ config, logger, emitter, eventBase, sessi
     level: triageOutput.result?.level || null,
     roles: Array.from(recommendedRoles),
     reasoning: triageOutput.result?.reasoning || null,
+    taskType: triageOutput.result?.taskType || "sw",
     shouldDecompose,
     subtasks
   };

package/src/orchestrator.js

@@ -22,6 +22,7 @@ import {
   incrementalPush
 } from "./git/automation.js";
 import { resolveRoleMdPath, loadFirstExisting } from "./roles/base-role.js";
+import { applyPolicies } from "./guards/policy-resolver.js";
 import { resolveReviewProfile } from "./review/profiles.js";
 import { CoderRole } from "./roles/coder-role.js";
 import { invokeSolomon } from "./orchestrator/solomon-escalation.js";
@@ -43,10 +44,15 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
   let testerEnabled = Boolean(config.pipeline?.tester?.enabled);
   let securityEnabled = Boolean(config.pipeline?.security?.enabled);
   let reviewerEnabled = config.pipeline?.reviewer?.enabled !== false;
-  const triageEnabled = Boolean(config.pipeline?.triage?.enabled);
+  // Triage is always mandatory — it classifies taskType for policy resolution
+  const triageEnabled = true;
 
   // --- Dry-run: return summary without executing anything ---
   if (flags.dryRun) {
+    const dryRunPolicies = applyPolicies({
+      taskType: flags.taskType || config.taskType || null,
+      policies: config.policies,
+    });
     const projectDir = config.projectDir || process.cwd();
     const { rules: reviewRules } = await resolveReviewProfile({ mode: config.review_mode, projectDir });
     const coderRules = await loadFirstExisting(resolveRoleMdPath("coder", projectDir));
@@ -56,6 +62,7 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
     const summary = {
       dry_run: true,
       task,
+      policies: dryRunPolicies,
       roles: {
         planner: plannerRole,
         coder: coderRole,
@@ -275,6 +282,33 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
   if (flags.enableTester !== undefined) testerEnabled = Boolean(flags.enableTester);
   if (flags.enableSecurity !== undefined) securityEnabled = Boolean(flags.enableSecurity);
 
+  // --- Policy resolver: gate stages by taskType ---
+  // Priority: explicit flag > config > triage classification > default (sw)
+  const resolvedPolicies = applyPolicies({
+    taskType: flags.taskType || config.taskType || stageResults.triage?.taskType || null,
+    policies: config.policies,
+  });
+  session.resolved_policies = resolvedPolicies;
+
+  // Apply policy gates on shallow copies (never mutate the caller's config)
+  if (!resolvedPolicies.tdd) {
+    config = { ...config, development: { ...config.development, methodology: "standard", require_test_changes: false } };
+  }
+  if (!resolvedPolicies.sonar) {
+    config = { ...config, sonarqube: { ...config.sonarqube, enabled: false } };
+  }
+  if (!resolvedPolicies.reviewer) {
+    reviewerEnabled = false;
+  }
+
+  emitProgress(
+    emitter,
+    makeEvent("policies:resolved", eventBase, {
+      message: `Policies resolved for taskType="${resolvedPolicies.taskType}"`,
+      detail: resolvedPolicies
+    })
+  );
+
   // --- Researcher (pre-planning) ---
   let researchContext = null;
   if (researcherEnabled) {

package/src/prompts/triage.js

@@ -47,10 +47,10 @@ export function buildTriagePrompt({ task, instructions, availableRoles }) {
   );
 
   sections.push(
-    "Classify the task complexity, recommend only the necessary pipeline roles, and assess whether the task should be decomposed into smaller subtasks.",
+    "Classify the task complexity, determine its taskType, recommend only the necessary pipeline roles, and assess whether the task should be decomposed into smaller subtasks.",
     "Keep the reasoning short and practical.",
     "Return a single valid JSON object and nothing else.",
-    'JSON schema: {"level":"trivial|simple|medium|complex","roles":["planner|researcher|refactorer|reviewer|tester|security"],"reasoning":string,"shouldDecompose":boolean,"subtasks":string[]}'
+    'JSON schema: {"level":"trivial|simple|medium|complex","roles":["planner|researcher|refactorer|reviewer|tester|security"],"taskType":"sw|infra|doc|add-tests|refactor","reasoning":string,"shouldDecompose":boolean,"subtasks":string[]}'
   );
 
   sections.push(`## Task\n${task}`);

package/src/review/diff-generator.js

@@ -20,3 +20,9 @@ export async function generateDiff({ baseRef }) {
   }
   return result.stdout;
 }
+
+export async function getUntrackedFiles() {
+  const result = await runCommand("git", ["ls-files", "--others", "--exclude-standard"]);
+  if (result.exitCode !== 0) return [];
+  return result.stdout.trim().split("\n").filter(Boolean);
+}

package/src/review/tdd-policy.js

@@ -19,13 +19,15 @@ function isSourceFile(file, extensions = []) {
   return extensions.some((ext) => file.endsWith(ext));
 }
 
-export function evaluateTddPolicy(diff, developmentConfig = {}) {
+export function evaluateTddPolicy(diff, developmentConfig = {}, untrackedFiles = []) {
   const requireTestChanges = developmentConfig.require_test_changes !== false;
   const patterns = developmentConfig.test_file_patterns || ["/tests/", "/__tests__/", ".test.", ".spec."];
   const extensions =
     developmentConfig.source_file_extensions || [".js", ".jsx", ".ts", ".tsx", ".py", ".go", ".java", ".rb", ".php", ".cs"];
 
-  const files = extractChangedFiles(diff);
+  const diffFiles = extractChangedFiles(diff);
+  const extra = Array.isArray(untrackedFiles) ? untrackedFiles : [];
+  const files = [...new Set([...diffFiles, ...extra])];
   const sourceFiles = files.filter((f) => isSourceFile(f, extensions) && !isTestFile(f, patterns));
   const testFiles = files.filter((f) => isTestFile(f, patterns));
 

package/src/roles/triage-role.js

@@ -1,9 +1,11 @@
 import { BaseRole } from "./base-role.js";
 import { createAgent as defaultCreateAgent } from "../agents/index.js";
 import { buildTriagePrompt } from "../prompts/triage.js";
+import { VALID_TASK_TYPES } from "../guards/policy-resolver.js";
 
 const VALID_LEVELS = new Set(["trivial", "simple", "medium", "complex"]);
 const VALID_ROLES = new Set(["planner", "researcher", "refactorer", "reviewer", "tester", "security"]);
+const FALLBACK_TASK_TYPE = "sw";
 
 function resolveProvider(config) {
   return (
@@ -74,6 +76,7 @@ export class TriageRole extends BaseRole {
             level: "medium",
             roles: ["reviewer"],
             reasoning: "Unstructured output, using safe defaults.",
+            taskType: FALLBACK_TASK_TYPE,
             provider,
             raw: result.output
           },
@@ -87,11 +90,13 @@ export class TriageRole extends BaseRole {
       const reasoning = String(parsed.reasoning || "").trim() || "No reasoning provided.";
       const shouldDecompose = Boolean(parsed.shouldDecompose);
       const subtasks = normalizeSubtasks(parsed.subtasks);
+      const taskType = VALID_TASK_TYPES.includes(parsed.taskType) ? parsed.taskType : FALLBACK_TASK_TYPE;
 
       const triageResult = {
         level,
         roles,
         reasoning,
+        taskType,
         provider
       };
 
@@ -116,6 +121,7 @@ export class TriageRole extends BaseRole {
           level: "medium",
           roles: ["reviewer"],
           reasoning: "Failed to parse triage output, using safe defaults.",
+          taskType: FALLBACK_TASK_TYPE,
           provider,
           raw: result.output
         },

package/templates/roles/triage.md

@@ -8,6 +8,7 @@ Return a single valid JSON object and nothing else:
 ```json
 {
   "level": "trivial|simple|medium|complex",
+  "taskType": "sw|infra|doc|add-tests|refactor",
   "roles": ["planner", "researcher", "refactorer", "reviewer", "tester", "security"],
   "reasoning": "brief practical justification",
   "shouldDecompose": false,
@@ -15,7 +16,14 @@ Return a single valid JSON object and nothing else:
 }
 ```
 
-## Classification guidance
+## Task type classification
+- `sw`: writing or modifying business logic, features, APIs, components, services.
+- `infra`: CI/CD, Docker, deploy scripts, build configuration, environment setup.
+- `doc`: documentation, README, CHANGELOG, comments-only changes.
+- `add-tests`: adding tests to existing code without changing functionality.
+- `refactor`: restructuring code without changing external behavior.
+
+## Complexity classification
 - `trivial`: tiny, low-risk, straightforward. Usually no extra roles.
 - `simple`: limited scope with low risk. Usually reviewer only.
 - `medium`: moderate scope/risk. Reviewer required; optional planner/researcher.