karajan-code 1.50.1 → 1.52.0

package/README.md

@@ -14,6 +14,7 @@
   <a href="https://github.com/manufosela/karajan-code/actions"><img src="https://github.com/manufosela/karajan-code/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
   <a href="https://www.gnu.org/licenses/agpl-3.0"><img src="https://img.shields.io/badge/license-AGPL--3.0-blue.svg" alt="License"></a>
   <a href="https://nodejs.org"><img src="https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg" alt="Node.js"></a>
+  <a href="https://github.com/manufosela/homebrew-tap"><img src="https://img.shields.io/badge/homebrew-tap-orange.svg" alt="Homebrew"></a>
 </p>
 
 <p align="center">
@@ -52,19 +53,33 @@ If Claude Code is a smart pair programmer, Karajan is the CI/CD pipeline for AI-
 
 ## Install
 
-**One-liner** (detects your OS, installs via npm):
+**npm** (recommended):
+```bash
+npm install -g karajan-code
+```
+
+**Homebrew** (macOS):
+```bash
+brew tap manufosela/tap
+brew install karajan-code
+```
 
+**One-liner** (detects OS, installs via npm):
 ```bash
 curl -fsSL https://raw.githubusercontent.com/manufosela/karajan-code/main/scripts/install-kj.sh | sh
 ```
 
-**Or directly with npm:**
+**Docker** (no Node.js needed):
+```bash
+docker run --rm -v $(pwd):/workspace karajan-code kj --version
+```
 
+**Python**:
 ```bash
-npm install -g karajan-code
+cd wrappers/python && pip install .
 ```
 
-That's it. No Docker required (SonarQube uses Docker, but Karajan auto-manages it). No config files to copy. `kj init` auto-detects your installed agents.
+That's it. `kj init` auto-detects your installed agents and installs RTK for token optimization.
 
 ## Three ways to use Karajan
 
@@ -260,3 +275,8 @@ Issues and pull requests welcome. If something doesn't work as documented, [open
 ---
 
 Built by [@manufosela](https://github.com/manufosela). Head of Engineering at Geniova Technologies, co-organizer of NodeJS Madrid, author of [Liderazgo Afectivo](https://www.liderazgoafectivo.com). 90+ npm packages published.
+
+### Contributors
+
+- [@aitormf](https://github.com/aitormf) — OpenCode agent (5th built-in agent)
+- [@reiaguilera](https://github.com/reiaguilera) — Beta testing, feature proposals, and quality feedback

package/docs/README.es.md

@@ -14,6 +14,7 @@
   <a href="https://github.com/manufosela/karajan-code/actions"><img src="https://github.com/manufosela/karajan-code/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
   <a href="https://www.gnu.org/licenses/agpl-3.0"><img src="https://img.shields.io/badge/license-AGPL--3.0-blue.svg" alt="License"></a>
   <a href="https://nodejs.org"><img src="https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg" alt="Node.js"></a>
+  <a href="https://github.com/manufosela/homebrew-tap"><img src="https://img.shields.io/badge/homebrew-tap-orange.svg" alt="Homebrew"></a>
 </p>
 
 <p align="center">
@@ -52,11 +53,28 @@ Si Claude Code es un programador de pares inteligente, Karajan es el pipeline CI
 
 ## Instalacion
 
+**npm** (recomendado):
 ```bash
 npm install -g karajan-code
 ```
 
-Eso es todo. No requiere Docker (SonarQube usa Docker, pero Karajan lo gestiona automaticamente). Sin ficheros de configuracion que copiar. `kj init` auto-detecta tus agentes instalados.
+**Homebrew** (macOS):
+```bash
+brew tap manufosela/tap
+brew install karajan-code
+```
+
+**One-liner** (detecta SO, instala via npm):
+```bash
+curl -fsSL https://raw.githubusercontent.com/manufosela/karajan-code/main/scripts/install-kj.sh | sh
+```
+
+**Docker** (sin Node.js):
+```bash
+docker run --rm -v $(pwd):/workspace karajan-code kj --version
+```
+
+`kj init` auto-detecta tus agentes instalados e instala RTK para optimizacion de tokens.
 
 ## Tres formas de usar Karajan
 
@@ -230,3 +248,8 @@ Issues y pull requests bienvenidos. Si algo no funciona como esta documentado, [
 ---
 
 Construido por [@manufosela](https://github.com/manufosela). Head of Engineering en Geniova Technologies, co-organizador de NodeJS Madrid, autor de [Liderazgo Afectivo](https://www.liderazgoafectivo.com). 90+ paquetes npm publicados.
+
+### Contributors
+
+- [@aitormf](https://github.com/aitormf) — Agente OpenCode (5o agente built-in)
+- [@reiaguilera](https://github.com/reiaguilera) — Beta testing, propuestas de mejora y feedback de calidad

package/package.json

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

package/src/commands/doctor.js

@@ -208,15 +208,20 @@ async function checkBecariaInfra(config) {
 }
 
 async function checkRtk() {
-  const NOT_FOUND_DETAIL = `Not found — install for 60-90% token savings: ${getInstallCommand("rtk")}`;
-  let detail = NOT_FOUND_DETAIL;
+  const installCmd = getInstallCommand("rtk");
   try {
     const res = await runCommand("rtk", ["--version"]);
     if (res.exitCode === 0) {
-      detail = `${res.stdout.trim()} — token savings active`;
+      return { name: "rtk", label: "RTK (Rust Token Killer)", ok: true, detail: `${res.stdout.trim()} — token savings active`, fix: null };
     }
   } catch { /* not installed */ }
-  return { name: "rtk", label: "RTK (Rust Token Killer)", ok: true, detail, fix: null };
+  return {
+    name: "rtk",
+    label: "RTK (Rust Token Killer)",
+    ok: false,
+    detail: "Not found — 60-90% token savings available",
+    fix: `Install: ${installCmd}`
+  };
 }
 
 async function checkRuleFiles(config) {

package/src/commands/init.js

@@ -10,6 +10,8 @@ import { createWizard, isTTY } from "../utils/wizard.js";
 import { runCommand } from "../utils/process.js";
 import { getInstallCommand } from "../utils/os-detect.js";
 import { detectOsLocale, SUPPORTED_LANGUAGES } from "../utils/locale.js";
+import { detectRtk } from "../utils/rtk-detect.js";
+import { installRtk } from "../utils/rtk-install.js";
 
 async function runWizard(config, logger) {
   const agents = await detectAvailableAgents();
@@ -328,18 +330,16 @@ export async function initCommand({ logger, flags = {} }) {
   await ensureCoderRules(coderRulesPath, logger);
   await installSkills(logger, interactive);
 
-  // Check RTK availability and inform user
-  let hasRtk = false;
-  try {
-    const rtkRes = await runCommand("rtk", ["--version"]);
-    hasRtk = rtkRes.exitCode === 0;
-  } catch { /* rtk not installed */
-    hasRtk = false;
-  }
-  if (!hasRtk) {
-    logger.info("");
-    logger.info("RTK (Rust Token Killer) can reduce token usage by 60-90%.");
-    logger.info(`  Install: ${getInstallCommand("rtk")}`);
+  // Check RTK availability — auto-install if missing
+  const rtk = await detectRtk();
+  if (rtk.available) {
+    logger.info(`RTK ${rtk.version || ""} detected.`);
+  } else {
+    const installResult = await installRtk(logger);
+    if (!installResult.ok) {
+      logger.warn("RTK is optional but recommended for 60-90% token savings.");
+      logger.warn(`  Manual install: ${getInstallCommand("rtk")}`);
+    }
   }
 
   await setupSonarQube(config, logger);

package/src/commands/report.js

@@ -152,6 +152,7 @@ async function buildReport(dir, sessionId) {
   };
   if (session.pg_task_id) report.pg_task_id = session.pg_task_id;
   if (session.pg_project_id) report.pg_project_id = session.pg_project_id;
+  if (session.rtk_savings) report.rtk_savings = session.rtk_savings;
   return report;
 }
 
@@ -326,6 +327,16 @@ async function resolveTraceOptions(currency) {
   return { cur, rate };
 }
 
+function printRtkSavings(rtkSavings) {
+  if (!rtkSavings || !rtkSavings.callCount) return;
+  const tokens = rtkSavings.estimatedTokensSaved ?? 0;
+  const ratio = rtkSavings.savedPct ?? 0;
+  const commands = rtkSavings.callCount ?? 0;
+  console.log("");
+  console.log(`RTK Savings: ~${tokens} tokens saved (${ratio}% compression, ${commands} commands)`);
+  console.log(`  Original: ${rtkSavings.originalBytes} bytes, Compressed: ${rtkSavings.rtkBytes} bytes, Saved: ${rtkSavings.savedBytes} bytes`);
+}
+
 function printTraceReport(report, currency, exchangeRate) {
   console.log(`Session: ${report.session_id}`);
   printPgCardLine(report);
@@ -333,6 +344,7 @@ function printTraceReport(report, currency, exchangeRate) {
   console.log(`Task: ${report.task_description || "N/A"}`);
   console.log("");
   printTraceTable(report.budget_trace, { currency, exchangeRate });
+  printRtkSavings(report.rtk_savings);
 }
 
 async function handlePgTaskReport({ dir, pgTask, list, sessionId, format, trace, currency }) {

package/src/guards/intent-guard.js

@@ -6,6 +6,32 @@ import { VALID_TASK_TYPES } from "./policy-resolver.js";
  * Evaluated top-down; first match with confidence >= threshold wins.
  */
 const INTENT_PATTERNS = [
+  // No-code tasks (data analysis, document generation, SQL queries, CSV transforms)
+  // Placed before audit so specific multi-word patterns win over single-word "analizar"/"analyze"
+  {
+    id: "no-code",
+    keywords: [
+      "generate report", "create document", "analyze data", "transform csv",
+      "sql query", "sql queries", "generate queries", "data analysis", "process data",
+      "export to", "import from", "convert data", "parse file",
+      "generar informe", "crear documento", "analizar datos", "transformar csv",
+      "consulta sql", "generar consultas", "analisis de datos", "procesar datos",
+      "exportar a", "importar de", "convertir datos", "parsear fichero",
+    ],
+    taskType: "no-code",
+    level: "simple",
+    confidence: 0.9,
+    message: "No-code task detected — TDD and SonarQube disabled, coder generates non-code output",
+  },
+  // Audit / analysis tasks (no code changes, read-only analysis)
+  {
+    id: "audit",
+    keywords: ["audit", "review", "analyze", "check", "verify", "inspect", "scan", "auditar", "revisar", "analizar", "comprobar", "verificar", "inspeccionar"],
+    taskType: "audit",
+    level: "simple",
+    confidence: 0.9,
+    message: "Audit/analysis task detected — skipping coder and reviewer",
+  },
   // Documentation-only tasks
   {
     id: "doc-readme",

package/src/guards/policy-resolver.js

@@ -1,4 +1,4 @@
-export const VALID_TASK_TYPES = new Set(["sw", "infra", "doc", "add-tests", "refactor"]);
+export const VALID_TASK_TYPES = new Set(["sw", "infra", "doc", "add-tests", "refactor", "audit", "analysis", "no-code"]);
 
 export const DEFAULT_POLICIES = {
   sw:        { tdd: true,  sonar: true,  reviewer: true, testsRequired: true  },
@@ -6,6 +6,9 @@ export const DEFAULT_POLICIES = {
   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 },
+  audit:     { tdd: false, sonar: false, reviewer: false, testsRequired: false, coderRequired: false },
+  analysis:  { tdd: false, sonar: false, reviewer: false, testsRequired: false, coderRequired: false },
+  "no-code": { tdd: false, sonar: false, reviewer: true, testsRequired: false, coderRequired: true },
 };
 
 const FALLBACK_TYPE = "sw";

package/src/orchestrator.js

@@ -41,6 +41,9 @@ import { waitForCooldown, MAX_STANDBY_RETRIES } from "./orchestrator/standby.js"
 import { detectTestFramework } from "./utils/project-detect.js";
 import { runPreflightChecks } from "./orchestrator/preflight-checks.js";
 import { detectRtk } from "./utils/rtk-detect.js";
+import { createRtkRunner, RtkSavingsTracker } from "./utils/rtk-wrapper.js";
+import { setRunner as setDiffRunner } from "./review/diff-generator.js";
+import { setRunner as setGitRunner } from "./utils/git.js";
 import { detectNeededSkills, autoInstallSkills, cleanupAutoInstalledSkills } from "./skills/skill-detector.js";
 import { isOpenSkillsAvailable } from "./skills/openskills-client.js";
 
@@ -278,6 +281,9 @@ function resolvePipelinePolicies({ flags, config, stageResults, emitter, eventBa
   if (!resolvedPolicies.reviewer) {
     pipelineFlags.reviewerEnabled = false;
   }
+  if (resolvedPolicies.coderRequired === false) {
+    pipelineFlags.coderRequired = false;
+  }
 
   emitProgress(
     emitter,
@@ -760,7 +766,7 @@ async function handlePostLoopStages({ config, session, emitter, eventBase, coder
   return { action: "proceed" };
 }
 
-async function finalizeApprovedSession({ config, gitCtx, task, logger, session, stageResults, emitter, eventBase, budgetSummary, pgCard, pgProject, review, i }) {
+async function finalizeApprovedSession({ config, gitCtx, task, logger, session, stageResults, emitter, eventBase, budgetSummary, pgCard, pgProject, review, i, rtkTracker }) {
   const gitResult = await finalizeGitAutomation({ config, gitCtx, task, logger, session, stageResults });
 
   // Accumulate final commits for PG card lifecycle tracking
@@ -779,16 +785,24 @@ async function finalizeApprovedSession({ config, gitCtx, task, logger, session,
   await markPgCardToValidate({ pgCard, pgProject, config, session, gitResult, logger });
 
   const deferredIssues = session.deferred_issues || [];
+  const rtkSavings = rtkTracker?.hasData() ? rtkTracker.summary() : undefined;
+  if (rtkSavings) session.rtk_savings = rtkSavings;
+  await saveSession(session);
+
+  const endDetail = { approved: true, iterations: i, stages: stageResults, git: gitResult, budget: budgetSummary(), deferredIssues };
+  if (rtkSavings) endDetail.rtk_savings = rtkSavings;
   emitProgress(
     emitter,
     makeEvent("session:end", { ...eventBase, stage: "done" }, {
       message: deferredIssues.length > 0
         ? `Session approved (${deferredIssues.length} deferred issue(s) tracked as tech debt)`
         : "Session approved",
-      detail: { approved: true, iterations: i, stages: stageResults, git: gitResult, budget: budgetSummary(), deferredIssues }
+      detail: endDetail
     })
   );
-  return { approved: true, sessionId: session.id, review, git: gitResult, deferredIssues };
+  const result = { approved: true, sessionId: session.id, review, git: gitResult, deferredIssues };
+  if (rtkSavings) result.rtk_savings = rtkSavings;
+  return result;
 }
 
 // PG card "To Validate" logic moved to src/planning-game/pipeline-adapter.js → markPgCardToValidate()
@@ -1071,7 +1085,7 @@ async function runQualityGateStages({ config, logger, emitter, eventBase, sessio
   if (tddResult.action === "pause") return { action: "return", result: tddResult.result };
   if (tddResult.action === "continue") return { action: "continue" };
 
-  const skipSonarForTaskType = new Set(["infra", "doc"]);
+  const skipSonarForTaskType = new Set(["infra", "doc", "no-code"]);
   const effectiveTaskType = session.resolved_policies?.taskType || null;
   if (config.sonarqube.enabled && !skipSonarForTaskType.has(effectiveTaskType)) {
     const sonarResult = await runSonarStage({
@@ -1132,7 +1146,7 @@ async function runReviewerGateStage({ pipelineFlags, reviewerRole, config, logge
   return { action: "ok", review: reviewerResult.review };
 }
 
-async function handleApprovedReview({ config, session, emitter, eventBase, coderRole, trackBudget, i, task, stageResults, pipelineFlags, askQuestion, logger, gitCtx, budgetSummary, pgCard, pgProject, review }) {
+async function handleApprovedReview({ config, session, emitter, eventBase, coderRole, trackBudget, i, task, stageResults, pipelineFlags, askQuestion, logger, gitCtx, budgetSummary, pgCard, pgProject, review, rtkTracker }) {
   session.reviewer_retry_count = 0;
   const postLoopResult = await handlePostLoopStages({
     config, session, emitter, eventBase, coderRole, trackBudget, i, task, stageResults,
@@ -1141,11 +1155,11 @@ async function handleApprovedReview({ config, session, emitter, eventBase, coder
   if (postLoopResult.action === "return") return { action: "return", result: postLoopResult.result };
   if (postLoopResult.action === "continue") return { action: "continue" };
 
-  const result = await finalizeApprovedSession({ config, gitCtx, task, logger, session, stageResults, emitter, eventBase, budgetSummary, pgCard, pgProject, review, i });
+  const result = await finalizeApprovedSession({ config, gitCtx, task, logger, session, stageResults, emitter, eventBase, budgetSummary, pgCard, pgProject, review, i, rtkTracker });
   return { action: "return", result };
 }
 
-async function handleMaxIterationsReached({ session, budgetSummary, emitter, eventBase, config, stageResults, logger, askQuestion, task }) {
+async function handleMaxIterationsReached({ session, budgetSummary, emitter, eventBase, config, stageResults, logger, askQuestion, task, rtkTracker }) {
   // Escalate to Solomon / human before giving up
   const solomonResult = await invokeSolomon({
     config, logger, emitter, eventBase, stage: "max_iterations", askQuestion, session,
@@ -1178,13 +1192,17 @@ async function handleMaxIterationsReached({ session, budgetSummary, emitter, eve
 
   // Solomon also couldn't resolve — fail
   session.budget = budgetSummary();
+  const rtkSavings = rtkTracker?.hasData() ? rtkTracker.summary() : undefined;
+  if (rtkSavings) session.rtk_savings = rtkSavings;
   await markSessionStatus(session, "failed");
+  const failDetail = { approved: false, reason: "max_iterations", iterations: config.max_iterations, stages: stageResults, budget: budgetSummary() };
+  if (rtkSavings) failDetail.rtk_savings = rtkSavings;
   emitProgress(
     emitter,
     makeEvent("session:end", { ...eventBase, stage: "done" }, {
       status: "fail",
       message: "Max iterations reached (Solomon could not resolve)",
-      detail: { approved: false, reason: "max_iterations", iterations: config.max_iterations, stages: stageResults, budget: budgetSummary() }
+      detail: failDetail
     })
   );
   return { approved: false, sessionId: session.id, reason: "max_iterations" };
@@ -1232,9 +1250,14 @@ async function initFlowContext({ task, config, logger, emitter, askQuestion, pgT
   const rtkResult = await detectRtk();
   if (rtkResult.available) {
     config = { ...config, rtk: { available: true, version: rtkResult.version } };
-    logger.info(`RTK detected (${rtkResult.version}) — instructing agents to prefix Bash commands with rtk`);
+    const rtkTracker = new RtkSavingsTracker();
+    const rtkRunner = createRtkRunner(true, rtkTracker);
+    setDiffRunner(rtkRunner);
+    setGitRunner(rtkRunner);
+    ctx.rtkTracker = rtkTracker;
+    logger.info(`RTK detected (${rtkResult.version}) — wrapping internal git/diff commands with rtk`);
     emitProgress(emitter, makeEvent("rtk:detected", ctx.eventBase, {
-      message: "RTK detected — agent commands will use token optimization",
+      message: "RTK detected — internal commands wrapped for token optimization",
       detail: { version: rtkResult.version, executorType: "local" }
     }));
   }
@@ -1351,7 +1374,8 @@ async function runSingleIteration(ctx) {
     const approvedResult = await handleApprovedReview({
       config, session, emitter, eventBase, coderRole: ctx.coderRole, trackBudget: ctx.trackBudget, i, task,
       stageResults: ctx.stageResults, pipelineFlags: ctx.pipelineFlags, askQuestion: ctx.askQuestion, logger,
-      gitCtx: ctx.gitCtx, budgetSummary: ctx.budgetSummary, pgCard: ctx.pgCard, pgProject: ctx.pgProject, review
+      gitCtx: ctx.gitCtx, budgetSummary: ctx.budgetSummary, pgCard: ctx.pgCard, pgProject: ctx.pgProject, review,
+      rtkTracker: ctx.rtkTracker
     });
     if (approvedResult.action === "return" || approvedResult.action === "continue") return approvedResult;
   }
@@ -1430,7 +1454,7 @@ async function runIterationLoop(ctx, { task: loopTask, askQuestion, emitter, log
     if (iterResult.action === "retry") { i -= 1; }
   }
 
-  const maxIterResult = await handleMaxIterationsReached({ session: ctx.session, budgetSummary: ctx.budgetSummary, emitter, eventBase: ctx.eventBase, config: ctx.config, stageResults: ctx.stageResults, logger, askQuestion, task: loopTask });
+  const maxIterResult = await handleMaxIterationsReached({ session: ctx.session, budgetSummary: ctx.budgetSummary, emitter, eventBase: ctx.eventBase, config: ctx.config, stageResults: ctx.stageResults, logger, askQuestion, task: loopTask, rtkTracker: ctx.rtkTracker });
   return maxIterResult;
 }
 
@@ -1444,6 +1468,53 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
   const ctx = await initFlowContext({ task, config, logger, emitter, askQuestion, pgTaskId, pgProject, flags });
 
   try {
+    // --- Analysis-only flow: skip coder/reviewer when coderRequired === false ---
+    if (ctx.pipelineFlags.coderRequired === false) {
+      logger.info("Analysis-only task — skipping coder/reviewer iteration loop");
+      emitProgress(emitter, makeEvent("pipeline:analysis-only", { ...ctx.eventBase, stage: "analysis" }, {
+        message: "Analysis-only task — running security and audit stages only",
+        detail: { taskType: ctx.session.resolved_policies?.taskType, coderRequired: false }
+      }));
+
+      const analysisStageResults = ctx.stageResults;
+      const postLoopDiff = await generateDiff({ baseRef: ctx.session.session_start_sha });
+
+      if (ctx.pipelineFlags.securityEnabled) {
+        const securityResult = await runSecurityStage({
+          config: ctx.config, logger, emitter, eventBase: ctx.eventBase, session: ctx.session,
+          coderRole: ctx.coderRole, trackBudget: ctx.trackBudget,
+          iteration: 1, task: ctx.plannedTask, diff: postLoopDiff, askQuestion
+        });
+        if (securityResult.stageResult) analysisStageResults.security = securityResult.stageResult;
+      }
+
+      const auditResult = await runFinalAuditStage({
+        config: ctx.config, logger, emitter, eventBase: ctx.eventBase, session: ctx.session,
+        coderRole: ctx.coderRole, trackBudget: ctx.trackBudget,
+        iteration: 1, task: ctx.plannedTask, diff: postLoopDiff
+      });
+      if (auditResult.stageResult) analysisStageResults.audit = auditResult.stageResult;
+
+      ctx.session.budget = ctx.budgetSummary();
+      await markSessionStatus(ctx.session, "approved");
+
+      const analysisResult = {
+        approved: true,
+        sessionId: ctx.session.id,
+        analysisOnly: true,
+        stages: analysisStageResults,
+        budget: ctx.budgetSummary()
+      };
+      await writeHistoryRecord({ sessionId: ctx.session.id, task, result: analysisResult, logger });
+
+      emitProgress(emitter, makeEvent("session:end", { ...ctx.eventBase, stage: "done" }, {
+        message: "Analysis-only session completed",
+        detail: analysisResult
+      }));
+
+      return analysisResult;
+    }
+
     // --- HU Sub-Pipeline: run each certified HU as an independent iteration loop ---
     if (needsSubPipeline(ctx.stageResults.huReviewer)) {
       logger.info(`HU sub-pipeline: ${ctx.stageResults.huReviewer.certified} certified stories — running each as a sub-pipeline`);

package/src/prompts/triage.js

@@ -39,13 +39,15 @@ export function buildTriagePrompt({ task, instructions, availableRoles }) {
       "- **reviewer**: Enable for most tasks as a quality gate. Disable only for trivial, single-line changes.",
       "- **architect**: Enable when creating new modules/apps, changing data models or APIs, medium/complex tasks, or when design approach is ambiguous. Disable for simple fixes, doc-only, or CSS-only changes.",
       "- **hu-reviewer**: Enable for medium/complex tasks that benefit from story decomposition and certification. Disable for trivial/simple tasks, doc-only, or CSS-only changes.",
+      "- **audit/analysis taskType**: Set taskType to \"audit\" or \"analysis\" for tasks that only require reading/inspecting code without making changes (e.g., audit, review, analyze, check, verify, inspect, scan, auditar, revisar, analizar, comprobar, verificar, inspeccionar). The coder and reviewer will be skipped entirely for these tasks.",
+      "- **no-code taskType**: Use no-code when the task is about data analysis, document generation, SQL queries, CSV transformation, report generation, or any non-programming task. The coder will generate output (not source code), and TDD/SonarQube will be disabled. The reviewer still runs to validate logic/correctness.",
       "",
-      "Note: coder is ALWAYS active — you don't need to decide on it."
+      "Note: coder is ALWAYS active for coding tasks — you don't need to decide on it. However, for audit/analysis taskTypes the coder is skipped."
     ].join("\n"),
     "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|architect|hu-reviewer"],"taskType":"sw|infra|doc|add-tests|refactor","reasoning":string,"shouldDecompose":boolean,"subtasks":string[]}',
+    'JSON schema: {"level":"trivial|simple|medium|complex","roles":["planner|researcher|refactorer|reviewer|tester|security|architect|hu-reviewer"],"taskType":"sw|infra|doc|add-tests|refactor|audit|analysis|no-code","reasoning":string,"shouldDecompose":boolean,"subtasks":string[]}',
     `## Task\n${task}`
   );
 

package/src/review/diff-generator.js

@@ -1,10 +1,26 @@
 import { runCommand } from "../utils/process.js";
 
+/** @type {((command: string, args?: string[], options?: object) => Promise<object>)|null} */
+let _runner = null;
+
+/**
+ * Inject an RTK-aware runner so all git operations in this module benefit from token savings.
+ * Call once at pipeline start when RTK is available.
+ * @param {(command: string, args?: string[], options?: object) => Promise<object>} runner
+ */
+export function setRunner(runner) {
+  _runner = runner;
+}
+
+function run(command, args, ...rest) {
+  return (_runner || runCommand)(command, args, ...rest);
+}
+
 export async function computeBaseRef({ baseBranch = "main", baseRef = null }) {
   if (baseRef) return baseRef;
-  const mergeBase = await runCommand("git", ["merge-base", "HEAD", `origin/${baseBranch}`]);
+  const mergeBase = await run("git", ["merge-base", "HEAD", `origin/${baseBranch}`]);
   if (mergeBase.exitCode !== 0) {
-    const fallback = await runCommand("git", ["rev-parse", "HEAD~1"]);
+    const fallback = await run("git", ["rev-parse", "HEAD~1"]);
     if (fallback.exitCode !== 0) {
       throw new Error("Could not compute diff base reference");
     }
@@ -16,9 +32,9 @@ export async function computeBaseRef({ baseBranch = "main", baseRef = null }) {
 export async function generateDiff({ baseRef, stageNewFiles = false }) {
   // Stage untracked files so they appear in the diff (coder creates files but doesn't git add)
   if (stageNewFiles) {
-    await runCommand("git", ["add", "-A"]);
+    await run("git", ["add", "-A"]);
   }
-  const result = await runCommand("git", ["diff", stageNewFiles ? "--cached" : "", `${baseRef}`].filter(Boolean));
+  const result = await run("git", ["diff", stageNewFiles ? "--cached" : "", `${baseRef}`].filter(Boolean));
   if (result.exitCode !== 0) {
     throw new Error(`git diff failed: ${result.stderr || result.stdout}`);
   }
@@ -26,7 +42,7 @@ export async function generateDiff({ baseRef, stageNewFiles = false }) {
 }
 
 export async function getUntrackedFiles() {
-  const result = await runCommand("git", ["ls-files", "--others", "--exclude-standard"]);
+  const result = await run("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,7 +19,7 @@ function isSourceFile(file, extensions = []) {
   return extensions.some((ext) => file.endsWith(ext));
 }
 
-const SKIP_TDD_TASK_TYPES = new Set(["doc", "infra"]);
+const SKIP_TDD_TASK_TYPES = new Set(["doc", "infra", "no-code"]);
 
 const DEFAULT_TEST_PATTERNS = ["/tests/", "/__tests__/", ".test.", ".spec.", "/src/test/", "/test/", "Test.java", "Test.kt", "test_", "_test.py", "_test.go", "Test.cs", "_spec.rb", "Test.php", "_test.dart", "Tests.swift"];
 const DEFAULT_SOURCE_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx", ".py", ".go", ".java", ".kt", ".rb", ".php", ".cs", ".rs", ".swift", ".dart"];

package/src/skills/skill-detector.js

@@ -67,6 +67,15 @@ const TASK_TEXT_PATTERNS = [
   { pattern: /\bflutter\b/i, skill: "flutter" },
   { pattern: /\bswift\b/i, skill: "swift" },
   { pattern: /\bphp\b/i, skill: "php" },
+  { pattern: /\bSQL\b/i, skill: "sql-analysis" },
+  { pattern: /\bquer(?:y|ies)\b/i, skill: "sql-analysis" },
+  { pattern: /\bdatabase\b/i, skill: "sql-analysis" },
+  { pattern: /\bCSV\b/i, skill: "csv-transform" },
+  { pattern: /\btransform\b/i, skill: "csv-transform" },
+  { pattern: /\bparse\b/i, skill: "csv-transform" },
+  { pattern: /\breport\b/i, skill: "data-report" },
+  { pattern: /\banalysis\b/i, skill: "data-report" },
+  { pattern: /\bfindings\b/i, skill: "data-report" },
 ];
 
 /**

package/src/utils/display.js

@@ -252,6 +252,14 @@ function isBudgetUnavailable(budget) {
     (budget.total_tokens === 0 && budget.total_cost_usd === 0 && Object.keys(budget.breakdown_by_role || {}).length > 0);
 }
 
+function printSessionRtkSavings(rtkSavings) {
+  if (!rtkSavings || !rtkSavings.callCount) return;
+  const tokens = rtkSavings.estimatedTokensSaved ?? 0;
+  const ratio = rtkSavings.savedPct ?? 0;
+  const commands = rtkSavings.callCount ?? 0;
+  console.log(`  ${ANSI.dim}\u26a1 RTK: saved ~${tokens} tokens (${ratio}% compression, ${commands} commands)${ANSI.reset}`);
+}
+
 function printSessionBudget(budget) {
   if (!budget) return;
   if (isBudgetUnavailable(budget)) {
@@ -447,6 +455,7 @@ const EVENT_HANDLERS = {
     printSessionStages(event.detail?.stages);
     printSessionGit(event.detail?.git);
     printSessionBudget(event.detail?.budget);
+    printSessionRtkSavings(event.detail?.rtk_savings);
     console.log(`${ANSI.dim}Session: ${event.sessionId}${ANSI.reset}`);
   },
 

package/src/utils/git.js

@@ -1,5 +1,20 @@
 import { runCommand } from "./process.js";
 
+/** @type {((command: string, args?: string[], options?: object) => Promise<object>)|null} */
+let _runner = null;
+
+/**
+ * Inject an RTK-aware runner so all git operations in this module benefit from token savings.
+ * @param {(command: string, args?: string[], options?: object) => Promise<object>} runner
+ */
+export function setRunner(runner) {
+  _runner = runner;
+}
+
+function run(command, args, ...rest) {
+  return (_runner || runCommand)(command, args, ...rest);
+}
+
 function slugifyTask(task) {
   return String(task)
     .toLowerCase()
@@ -9,7 +24,7 @@ function slugifyTask(task) {
 }
 
 async function runGit(args, options = {}) {
-  const res = await runCommand("git", args, options);
+  const res = await run("git", args, options);
   if (res.exitCode !== 0) {
     throw new Error(`git ${args.join(" ")} failed: ${res.stderr || res.stdout}`);
   }
@@ -17,7 +32,7 @@ async function runGit(args, options = {}) {
 }
 
 export async function ensureGitRepo() {
-  const res = await runCommand("git", ["rev-parse", "--is-inside-work-tree"]);
+  const res = await run("git", ["rev-parse", "--is-inside-work-tree"]);
   return res.exitCode === 0 && res.stdout.trim() === "true";
 }
 

package/src/utils/rtk-install.js

@@ -0,0 +1,38 @@
+import { runCommand } from "./process.js";
+import { getInstallCommand } from "./os-detect.js";
+import { detectRtk } from "./rtk-detect.js";
+
+/**
+ * Install RTK (Rust Token Killer) using the OS-appropriate command.
+ * @param {object} logger - Logger with info/warn methods
+ * @returns {Promise<{ ok: boolean, version: string|null, error: string|null }>}
+ */
+export async function installRtk(logger) {
+  const command = getInstallCommand("rtk");
+
+  logger.info("Installing RTK (Rust Token Killer)...");
+
+  try {
+    const result = await runCommand("sh", ["-c", command], { timeout: 120_000 });
+
+    if (result.exitCode !== 0) {
+      const error = (result.stderr || "").trim() || `exit code ${result.exitCode}`;
+      logger.warn(`RTK install failed: ${error}`);
+      return { ok: false, version: null, error };
+    }
+
+    // Verify installation
+    const check = await detectRtk();
+    if (check.available) {
+      logger.info(`RTK ${check.version || ""} installed successfully.`);
+      return { ok: true, version: check.version, error: null };
+    }
+
+    logger.warn("RTK install command succeeded but rtk binary not found in PATH.");
+    return { ok: false, version: null, error: "Binary not found after install" };
+  } catch (err) {
+    const error = err.message || String(err);
+    logger.warn(`RTK install failed: ${error}`);
+    return { ok: false, version: null, error };
+  }
+}

package/src/utils/rtk-wrapper.js

@@ -0,0 +1,87 @@
+import { runCommand } from "./process.js";
+
+/**
+ * Commands that RTK can safely wrap for token-optimized output.
+ */
+export const RTK_SUPPORTED_COMMANDS = [
+  "git", "ls", "find", "grep", "cat", "head", "tail",
+  "wc", "diff", "tree", "du", "file"
+];
+
+const supportedSet = new Set(RTK_SUPPORTED_COMMANDS);
+
+/**
+ * Wrap a command with RTK if available and the command is in the whitelist.
+ * @param {string} command
+ * @param {string[]} args
+ * @param {boolean} rtkAvailable
+ * @returns {{ command: string, args: string[] }}
+ */
+export function wrapWithRtk(command, args, rtkAvailable) {
+  if (rtkAvailable && supportedSet.has(command)) {
+    return { command: "rtk", args: [command, ...args] };
+  }
+  return { command, args };
+}
+
+/**
+ * Session-level accumulator for RTK byte savings.
+ */
+export class RtkSavingsTracker {
+  constructor() {
+    this.originalBytes = 0;
+    this.rtkBytes = 0;
+    this.callCount = 0;
+  }
+
+  record(originalSize, rtkSize) {
+    this.originalBytes += originalSize;
+    this.rtkBytes += rtkSize;
+    this.callCount += 1;
+  }
+
+  summary() {
+    const savedBytes = this.originalBytes - this.rtkBytes;
+    const savedPct = this.originalBytes > 0
+      ? Number(((savedBytes / this.originalBytes) * 100).toFixed(1))
+      : 0;
+    const estimatedTokensSaved = Math.floor(savedBytes / 4);
+    return {
+      originalBytes: this.originalBytes,
+      rtkBytes: this.rtkBytes,
+      savedBytes,
+      savedPct,
+      estimatedTokensSaved,
+      callCount: this.callCount
+    };
+  }
+
+  /** Returns true if any commands were recorded. */
+  hasData() {
+    return this.callCount > 0;
+  }
+}
+
+/**
+ * Create a runner function that transparently wraps supported commands with RTK.
+ * @param {boolean} rtkAvailable
+ * @param {RtkSavingsTracker} [tracker] - Optional savings tracker
+ * @returns {(command: string, args?: string[], options?: object) => Promise<object>}
+ */
+export function createRtkRunner(rtkAvailable, tracker = null) {
+  return async (command, args = [], options = {}) => {
+    const wrapped = wrapWithRtk(command, args, rtkAvailable);
+    const result = await runCommand(wrapped.command, wrapped.args, options);
+
+    if (tracker && rtkAvailable && supportedSet.has(command)) {
+      const outputSize = Buffer.byteLength(result.stdout || "", "utf8");
+      // For RTK-wrapped calls, the output is already compressed.
+      // We estimate the original size as outputSize (conservative — real savings
+      // would require running the command without RTK, which defeats the purpose).
+      // The tracker is useful when the caller provides real estimates externally.
+      tracker.record(outputSize, outputSize);
+    }
+
+    return result;
+  };
+}

package/templates/skills/kj-csv-transform.md

@@ -0,0 +1,40 @@
+# kj-csv-transform — CSV & Data Transformation
+
+Transform, validate, and process CSV and tabular data files.
+
+## Your task
+
+$ARGUMENTS
+
+## Coder instructions
+
+When working with CSV or tabular data:
+
+1. **Auto-detect delimiter** — do not assume comma. Detect the actual delimiter (comma, semicolon, tab, pipe) by inspecting the first few lines. Use libraries that support delimiter sniffing when available.
+2. **Handle encoding** — detect and handle file encoding (UTF-8, UTF-8 BOM, Latin-1/ISO-8859-1, Windows-1252). Convert to UTF-8 for processing.
+3. **Validate data types per column** — after parsing, verify that each column contains the expected data type (string, number, date, boolean). Flag rows with type mismatches.
+4. **Handle missing values explicitly** — define a strategy for missing/empty values (keep as null, fill with default, skip row). Never silently drop rows with missing data.
+5. **Preserve row count** — track input vs output row counts. Log any rows filtered, merged, or split so the transformation is auditable.
+6. **Quote fields correctly** — when writing CSV output, properly escape fields containing delimiters, quotes, or newlines.
+7. **Header normalization** — trim whitespace from headers, handle duplicate column names, and normalize casing if needed.
+8. **Large file support** — for files that may be large, use streaming/chunked processing instead of loading everything into memory.
+
+## Reviewer checklist
+
+When reviewing CSV/data transformation code, check for:
+
+- [ ] **Data integrity** — input row count matches expected output row count (accounting for intentional filters)?
+- [ ] **No silent data loss** — missing values are handled explicitly, not silently dropped?
+- [ ] **Correct transformations** — type conversions, date parsing, and numeric formatting are accurate?
+- [ ] **Encoding handled** — non-ASCII characters preserved correctly through the pipeline?
+- [ ] **Delimiter consistency** — detection works for the actual file, not just assumed comma?
+- [ ] **Edge cases** — empty files, single-row files, files with only headers, fields with embedded newlines?
+- [ ] **Memory safety** — large files processed via streams, not loaded entirely into memory?
+- [ ] **Output format** — output CSV is well-formed (proper quoting, consistent line endings)?
+
+## Output
+
+Provide the transformation code with:
+- Clear input/output format documentation
+- Row count summary (input rows, output rows, filtered rows, error rows)
+- Sample of transformed data for verification

package/templates/skills/kj-data-report.md

@@ -0,0 +1,44 @@
+# kj-data-report — Data Report Generation
+
+Generate structured data reports with clear findings, methodology, and recommendations.
+
+## Your task
+
+$ARGUMENTS
+
+## Coder instructions
+
+When generating data reports:
+
+1. **Structure the report** — follow this format:
+   - **Executive summary** — 2-3 sentences with the key takeaway
+   - **Methodology** — data sources, time range, filters applied, tools used
+   - **Findings** — organized by theme or priority, each with supporting data
+   - **Recommendations** — actionable next steps based on the findings
+2. **Include data tables** — present data in tables with clear headers, units, and formatting. Align numbers right, text left.
+3. **Highlight anomalies and outliers** — flag data points that deviate significantly from the norm. Quantify the deviation (e.g., "3x above average", "lowest in 12 months").
+4. **Quantify everything** — use percentages, counts, averages, medians, and trends. Avoid vague language like "significant increase" without numbers.
+5. **Show comparisons** — include period-over-period comparisons (MoM, YoY) and benchmarks where available.
+6. **Cite data sources** — reference the specific dataset, query, or file that produced each finding.
+7. **Separate facts from interpretation** — clearly distinguish what the data shows from what you conclude.
+8. **Include limitations** — note any data gaps, sample size issues, or caveats that affect conclusions.
+
+## Reviewer checklist
+
+When reviewing data reports, check for:
+
+- [ ] **Conclusions match data** — every claim is supported by the data presented? No logical leaps?
+- [ ] **No cherry-picking** — all relevant data included, not just data that supports a narrative?
+- [ ] **Methodology is sound** — data sources are appropriate, filters are justified, time ranges are sensible?
+- [ ] **Numbers add up** — percentages sum correctly, counts are consistent across sections?
+- [ ] **Anomalies explained** — outliers are acknowledged and investigated, not ignored?
+- [ ] **Actionable recommendations** — recommendations are specific, feasible, and tied to findings?
+- [ ] **Clear formatting** — tables are readable, units are specified, dates are unambiguous?
+- [ ] **Limitations disclosed** — caveats and data quality issues are transparently noted?
+
+## Output
+
+Deliver the report in the structured format above, with:
+- All data tables properly formatted
+- Key metrics highlighted
+- Clear separation between data, analysis, and recommendations

package/templates/skills/kj-sql-analysis.md

@@ -0,0 +1,40 @@
+# kj-sql-analysis — SQL Analysis & Generation
+
+Generate and review SQL queries with a focus on correctness, performance, and security.
+
+## Your task
+
+$ARGUMENTS
+
+## Coder instructions
+
+When writing or modifying SQL queries:
+
+1. **Parameterized queries only** — never concatenate user input into SQL strings. Use prepared statements or parameterized queries (`$1`, `?`, `:param`) to prevent injection.
+2. **Comment complex logic** — add inline comments explaining non-obvious JOINs, subqueries, CTEs, and window functions.
+3. **Validate against schema** — if a schema or migration files are available, verify that table names, column names, and types match the actual schema.
+4. **Prefer explicit column lists** — avoid `SELECT *`; list the columns you need.
+5. **Use aliases consistently** — when joining multiple tables, alias every table and prefix all column references.
+6. **Index-aware queries** — structure WHERE clauses and JOINs to leverage existing indexes. Avoid wrapping indexed columns in functions.
+7. **Limit result sets** — add `LIMIT` / `TOP` for queries that could return unbounded rows unless the full result is explicitly needed.
+8. **Handle NULLs explicitly** — use `COALESCE`, `IS NULL`, or `IS NOT NULL` where NULL values could affect logic.
+
+## Reviewer checklist
+
+When reviewing SQL-related code, check for:
+
+- [ ] **Injection risk** — any string concatenation or template literals building SQL?
+- [ ] **N+1 queries** — loops executing individual queries instead of a single batch/join?
+- [ ] **Missing indexes** — queries filtering or joining on columns without indexes?
+- [ ] **Correct JOINs** — LEFT vs INNER vs CROSS used intentionally? Accidental cartesian products?
+- [ ] **Transaction safety** — multi-statement operations wrapped in transactions where needed?
+- [ ] **Schema alignment** — column names, types, and constraints match the current schema?
+- [ ] **Performance** — unnecessary subqueries that could be CTEs or JOINs? Missing LIMIT on large tables?
+- [ ] **NULL handling** — aggregations, comparisons, and JOINs account for NULL values?
+
+## Output
+
+Provide the SQL queries with:
+- Inline comments for complex sections
+- Explanation of the query plan and expected performance characteristics
+- Any schema changes needed (new indexes, columns, tables)