karajan-code 1.25.0 → 1.25.2

package/package.json

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

package/src/cli.js

@@ -103,6 +103,8 @@ program
   .option("--checkpoint-interval <n>", "Minutes between interactive checkpoints (default: 5)")
   .option("--pg-task <cardId>", "Planning Game card ID (e.g., KJC-TSK-0042)")
   .option("--pg-project <projectId>", "Planning Game project ID")
+  .option("--auto-simplify", "Auto-simplify pipeline for simple tasks (disable reviewer/tester)")
+  .option("--no-auto-simplify", "Force full pipeline regardless of triage level")
   .option("--smart-models", "Enable smart model selection based on triage complexity")
   .option("--no-smart-models", "Disable smart model selection")
   .option("--dry-run", "Show what would be executed without running anything")

package/src/config.js

@@ -31,7 +31,8 @@ const DEFAULTS = {
     impeccable: { enabled: false },
     triage: { enabled: true },
     discover: { enabled: false },
-    architect: { enabled: false }
+    architect: { enabled: false },
+    auto_simplify: true
   },
   review_mode: "standard",
   max_iterations: 5,
@@ -283,6 +284,8 @@ const PIPELINE_ENABLE_FLAGS = [
   ["enableArchitect", "architect"]
 ];
 
+const AUTO_SIMPLIFY_FLAG = "autoSimplify";
+
 // Scalar flags: [flagName, setter] — truthy check
 const SCALAR_FLAGS = [
   ["mode", (out, v) => { out.review_mode = v; }],
@@ -361,6 +364,7 @@ function applyBecariaOverride(out, flags) {
 }
 
 function applyMiscOverrides(out, flags) {
+  if (flags[AUTO_SIMPLIFY_FLAG] !== undefined) out.pipeline.auto_simplify = Boolean(flags[AUTO_SIMPLIFY_FLAG]);
   if (flags.noSonar || flags.sonar === false) out.sonarqube.enabled = false;
   out.sonarcloud = out.sonarcloud || {};
   if (flags.enableSonarcloud === true) out.sonarcloud.enabled = true;

package/src/mcp/run-kj.js

@@ -53,6 +53,8 @@ export async function runKjCommand({ command, commandArgs = [], options = {}, en
   if (options.autoRebase === false) args.push("--no-auto-rebase");
   addOptionalValue(args, "--task-type", options.taskType);
   normalizeBoolFlag(options.noSonar, "--no-sonar", args);
+  if (options.autoSimplify === true) args.push("--auto-simplify");
+  if (options.autoSimplify === false) args.push("--no-auto-simplify");
   if (options.smartModels === true) args.push("--smart-models");
   if (options.smartModels === false) args.push("--no-smart-models");
   addOptionalValue(args, "--checkpoint-interval", options.checkpointInterval);

package/src/mcp/server-handlers.js

@@ -823,10 +823,43 @@ function handleRoles(a) {
   return runKjCommand({ command: "roles", commandArgs, options: a });
 }
 
+const RESUME_MAX_ANSWER_LENGTH = 500;
+const RESUME_INJECTION_PATTERNS = [
+  /ignore\s+(previous|all|above)\s+(instructions|rules|prompts)/i,
+  /you\s+are\s+now/i,
+  /new\s+instructions?:/i,
+  /override\s+(all|security|guardrails|rules)/i,
+  /skip\s+(all\s+)?(review|test|sonar|security|solomon|guard)s?\b/i,
+  /disable\s+(tdd|review|test|sonar|security)\b/i,
+  /set\s+(status|approved|verdict)\s*(=|to|:)/i,
+  /force\s+(approve|merge|push|commit)\b/i,
+];
+
+export function validateResumeAnswer(answer) {
+  if (answer == null || answer === "") return { valid: true, sanitized: answer ?? null };
+  if (typeof answer !== "string") return { valid: true, sanitized: String(answer) };
+  if (answer.length > RESUME_MAX_ANSWER_LENGTH) {
+    return { valid: false, reason: `Answer too long (${answer.length} chars, max ${RESUME_MAX_ANSWER_LENGTH})` };
+  }
+  for (const pattern of RESUME_INJECTION_PATTERNS) {
+    if (pattern.test(answer)) {
+      return { valid: false, reason: "Answer rejected: matches guardrail bypass pattern" };
+    }
+  }
+  return { valid: true, sanitized: answer.trim() };
+}
+
 async function handleResume(a, server, extra) {
   if (!a.sessionId) {
     return failPayload("Missing required field: sessionId");
   }
+  if (a.answer) {
+    const validation = validateResumeAnswer(a.answer);
+    if (!validation.valid) {
+      return failPayload(`Resume answer rejected: ${validation.reason}`);
+    }
+    a.answer = validation.sanitized;
+  }
   applySessionOverrides(a, ["coder", "reviewer", "tester", "security", "solomon", "enableTester", "enableSecurity", "enableImpeccable"]);
   return handleResumeDirect(a, server, extra);
 }

package/src/mcp/tools.js

@@ -90,6 +90,7 @@ export const tools = [
         autoPr: { type: "boolean" },
         autoRebase: { type: "boolean" },
         branchPrefix: { type: "string" },
+        autoSimplify: { type: "boolean", description: "Auto-simplify pipeline for simple tasks (level trivial/simple). Disable with false to force full pipeline." },
         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." },

package/src/orchestrator.js

@@ -214,6 +214,29 @@ function applyTriageOverrides(pipelineFlags, roleOverrides) {
   }
 }
 
+const SIMPLE_LEVELS = new Set(["trivial", "simple"]);
+
+function applyAutoSimplify({ pipelineFlags, triageLevel, config, flags, logger, emitter, eventBase }) {
+  if (!config.pipeline?.auto_simplify) return false;
+  if (!triageLevel || !SIMPLE_LEVELS.has(triageLevel)) return false;
+  if (flags.mode) return false;
+  if (flags.enableReviewer !== undefined || flags.enableTester !== undefined) return false;
+
+  pipelineFlags.reviewerEnabled = false;
+  pipelineFlags.testerEnabled = false;
+
+  const disabledRoles = ["reviewer", "tester"];
+  logger.info(`Simple task (${triageLevel}) — lightweight pipeline (disabled: ${disabledRoles.join(", ")})`);
+  emitProgress(
+    emitter,
+    makeEvent("pipeline:simplify", { ...eventBase, stage: "triage" }, {
+      message: `Simple task (${triageLevel}) — lightweight pipeline`,
+      detail: { level: triageLevel, disabledRoles }
+    })
+  );
+  return true;
+}
+
 async function handlePgDecomposition({ triageResult, pgTaskId, pgProject, config, askQuestion, emitter, eventBase, session, stageResults, logger }) {
   const shouldDecompose = triageResult.stageResult?.shouldDecompose
     && triageResult.stageResult.subtasks?.length > 1
@@ -795,6 +818,14 @@ async function runPreLoopStages({ config, logger, emitter, eventBase, session, f
   applyTriageOverrides(pipelineFlags, triageResult.roleOverrides);
   stageResults.triage = triageResult.stageResult;
 
+  // --- Auto-simplify pipeline for simple tasks (before explicit flag overrides) ---
+  const simplified = applyAutoSimplify({
+    pipelineFlags,
+    triageLevel: triageResult.stageResult?.level || null,
+    config, flags, logger, emitter, eventBase
+  });
+  if (simplified) stageResults.triage.autoSimplified = true;
+
   await handlePgDecomposition({ triageResult, pgTaskId, pgProject, config, askQuestion, emitter, eventBase, session, stageResults, logger });
 
   applyFlagOverrides(pipelineFlags, flags);