karajan-code 4.18.0 → 4.20.0

package/package.json

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

package/scripts/dual-publish.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * dual-publish (MIG-A, KJC-TSK-0751, épica KJC-PCS-0077, ADR 0004) — el
+ * MISMO contenido sale bajo dos nombres npm durante la migración al scope:
+ * karajan-code (legacy, publish normal) y @karajan-family/code (scoped).
+ *
+ * Uso:
+ *   node scripts/dual-publish.mjs --pack-only          # genera+verifica el tarball scoped
+ *   node scripts/dual-publish.mjs --publish --otp=XXX  # publica el scoped (tras publicar el legacy)
+ *
+ * El swap del name es EN SITIO con restauración en finally: un crash a mitad
+ * no deja el manifest renombrado. La verificación es el MISMO verify-pack
+ * (name-agnóstico desde la parte 1): empaqueta, instala aislado y corre kj.
+ * El PRIMER publish del scoped lo hace el usuario (cuenta karajan-family,
+ * security key); los siguientes van con la sesión normal.
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const LEGACY_NAME = "karajan-code";
+export const SCOPED_NAME = "@karajan-family/code";
+
+/**
+ * Ejecuta `fn` con el manifest renombrado al scoped (+ publishConfig public,
+ * obligatorio para scoped) y lo RESTAURA byte a byte pase lo que pase.
+ */
+export async function withScopedName(repoRoot, fn) {
+  const pkgPath = join(repoRoot, "package.json");
+  const original = readFileSync(pkgPath, "utf8");
+  const pkg = JSON.parse(original);
+  if (pkg.name !== LEGACY_NAME) {
+    throw new Error(`dual-publish: el manifest dice "${pkg.name}" y solo se renombra desde ${LEGACY_NAME} — jamás a ciegas`);
+  }
+  // publishConfig se MERGEA, no se pisa (catch de codex): un registry/tag
+  // preexistente debe sobrevivir al publish scoped.
+  writeFileSync(pkgPath, `${JSON.stringify({ ...pkg, name: SCOPED_NAME, publishConfig: { ...pkg.publishConfig, access: "public" } }, null, 2)}\n`, "utf8");
+  try {
+    return await fn();
+  } finally {
+    writeFileSync(pkgPath, original, "utf8");
+  }
+}
+
+// argv[1] normalizado (catch de codex): node lo absolutiza hoy, pero el
+// guard no debe depender de ese detalle de implementación.
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1]);
+if (isMain) {
+  const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+  const args = process.argv.slice(2);
+  const publish = args.includes("--publish");
+  const otp = args.find((a) => a.startsWith("--otp="))?.slice(6);
+  await withScopedName(repoRoot, async () => {
+    console.log(`dual-publish: manifest → ${SCOPED_NAME} (temporal)`);
+    // La E2E real: empaqueta el scoped, instálalo aislado y corre kj.
+    execFileSync("node", [join(repoRoot, "scripts", "verify-pack.mjs")], { cwd: repoRoot, stdio: "inherit" });
+    if (publish) {
+      const pubArgs = ["publish", "--ignore-scripts", ...(otp ? [`--otp=${otp}`] : [])];
+      console.log(`dual-publish: npm ${pubArgs.join(" ").replace(/--otp=\S+/, "--otp=***")}`);
+      execFileSync("npm", pubArgs, { cwd: repoRoot, stdio: "inherit" });
+    } else {
+      console.log("dual-publish: --pack-only — verificado y SIN publicar (usa --publish en la release)");
+    }
+  });
+  console.log(`dual-publish: manifest restaurado a ${LEGACY_NAME} ✓`);
+}

package/scripts/verify-pack.mjs

@@ -27,6 +27,9 @@ import { fileURLToPath } from "node:url";
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const pkg = JSON.parse(fs.readFileSync(path.join(repoRoot, "package.json"), "utf8"));
 const expectedVersion = pkg.version;
+// MIG-A (KJC-TSK-0751): el nombre sale del manifest — el MISMO verify-pack
+// valida el tarball unscoped y el @karajan-family/* del dual-publish.
+const pkgName = pkg.name;
 
 // Subprocess env: strip CLAUDECODE (Claude Code blocks nested non-interactive
 // runs otherwise) and force a non-interactive, quiet npm.
@@ -54,13 +57,13 @@ let gTmp = null;
 let pnpmTmp = null;
 let qsTmp = null;
 try {
-  console.log(`verify-pack: packing karajan-code@${expectedVersion}…`);
+  console.log(`verify-pack: packing ${pkgName}@${expectedVersion}…`);
   // --json gives us the exact filename without parsing human output.
   const packOut = run("npm", ["pack", "--json", "--silent"], { cwd: repoRoot });
   const filename = JSON.parse(packOut)[0]?.filename;
   if (!filename) fail("npm pack did not report a filename", packOut);
-  // npm normalizes scoped names in --json but karajan-code is unscoped;
-  // the file lands in cwd under the reported name.
+  // npm --json reports the exact filename (scoped names normalized to
+  // scope-name-x.y.z.tgz); the file lands in cwd under that name.
   tgzPath = path.join(repoRoot, filename);
   if (!fs.existsSync(tgzPath)) fail(`packed tarball not found at ${tgzPath}`);
 
@@ -93,7 +96,7 @@ try {
   const { scanPaths, loadPrivacyList } = await import(
     path.join(repoRoot, "src", "privacy", "scan.js")
   );
-  const shippedDir = path.join(tmpDir, "node_modules", "karajan-code");
+  const shippedDir = path.join(tmpDir, "node_modules", ...pkgName.split("/"));
   const pFindings = scanPaths([shippedDir], { list: loadPrivacyList() });
   const pBlocks = pFindings.filter((f) => f.severity === "block");
   if (pBlocks.length > 0) {
@@ -265,7 +268,7 @@ try {
     );
   }
 
-  console.log(`\n✓ verify-pack: karajan-code@${expectedVersion} installs clean and runs.`);
+  console.log(`\n✓ verify-pack: ${pkgName}@${expectedVersion} installs clean and runs.`);
 } finally {
   if (tgzPath && fs.existsSync(tgzPath)) fs.rmSync(tgzPath, { force: true });
   if (tmpDir && fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true });

package/src/agents/base-agent.js

@@ -12,6 +12,7 @@
 
 import { defaultEnvironment } from "../infrastructure/environment.js";
 import { buildAgentEnv } from "../utils/role-env.js";
+import { isModelCompatible } from "../config/role-resolver.js";
 
 const MODEL_NOT_SUPPORTED_PATTERNS = [
   /model.{0,30}is not supported/i,
@@ -95,10 +96,19 @@ export class BaseAgent {
    * @returns {string|null}
    */
   getRoleModel(role) {
-    const roleModel = this.config?.roles?.[role]?.model;
-    if (roleModel) return roleModel;
-    if (role === "reviewer") return this.config?.reviewer_options?.model || null;
-    return this.config?.coder_options?.model || null;
+    const roleModel =
+      this.config?.roles?.[role]?.model ||
+      (role === "reviewer" ? this.config?.reviewer_options?.model : this.config?.coder_options?.model) ||
+    null;
+    // KJC-BUG-0144 (campo, issue #1465): un default por-rol (start: haiku)
+    // puede caer sobre un provider de OTRA familia (agy, codex...) — el
+    // modelo se descarta con aviso y el agente usa su propio default,
+    // nunca se le pasa un --model ajeno.
+    if (roleModel && !isModelCompatible(this.name, roleModel)) {
+      this.logger?.warn?.(`model "${roleModel}" belongs to another family — dropping it for ${this.name} (role ${role})`);
+      return null;
+    }
+    return roleModel;
   }
 
   /**

package/src/agents/codex-agent.js

@@ -77,9 +77,26 @@ export class CodexAgent extends BaseAgent {
   }
 
   async _exec(task, model, role) {
+    // KJC-BUG-0143 (campo, issue #1471): codex exec >= 0.146 rechaza
+    // --full-auto ("unexpected argument"); el auto-approve moderno para un
+    // coder que escribe es --sandbox workspace-write. Los CLIs antiguos no
+    // conocen --sandbox: si lo rechazan, se reintenta con el flag legacy.
+    const autoApprove = role !== "reviewer" && this.isAutoApproveEnabled(role);
+    const res = await this._execOnce(task, model, role, { autoApprove, legacyAutoFlag: false });
+    if (!res.ok && autoApprove && /unexpected argument '--sandbox'/.test(res.error || "")) {
+      this.logger?.warn("codex CLI sin --sandbox — reintentando con el flag legacy --full-auto");
+      return this._execOnce(task, model, role, { autoApprove, legacyAutoFlag: true });
+    }
+    return res;
+  }
+
+  async _execOnce(task, model, role, { autoApprove, legacyAutoFlag }) {
     const args = ["exec", "--skip-git-repo-check"];
     if (model) args.push("--model", model);
-    if (role !== "reviewer" && this.isAutoApproveEnabled(role)) args.push("--full-auto");
+    if (autoApprove) {
+      if (legacyAutoFlag) args.push("--full-auto");
+      else args.push("--sandbox", "workspace-write");
+    }
     args.push("-");
     const res = await this.runCommand(resolveBin("codex"), args, {
       onOutput: task.onOutput,

package/src/audit/deterministic-summary.js

@@ -38,6 +38,7 @@ export function formatDeterministicSummary(ctx) {
   if (ctx.sonarFindings) lines.push(...formatSonarBlock(ctx.sonarFindings));
   if (ctx.osvFindings) lines.push(...formatOsvBlock(ctx.osvFindings));
   if (ctx.semgrepFindings) lines.push(...formatSemgrepBlock(ctx.semgrepFindings));
+  if (ctx.infraFindings) lines.push(...formatInfraBlock(ctx.infraFindings));
   if (ctx.circularDeps) lines.push(...formatCircularDepsBlock(ctx.circularDeps));
   if (ctx.deadExports) lines.push(...formatDeadExportsBlock(ctx.deadExports));
   if (ctx.injectionFindings) lines.push(...formatInjectionBlock(ctx.injectionFindings));
@@ -133,6 +134,25 @@ function formatSemgrepBlock(semgrepFindings) {
   return lines;
 }
 
+// INF-C (KJC-TSK-0760): checkov misconfigs — same shape as the semgrep
+// block; a not-applicable repo (no infra markers) declares it in one line.
+function formatInfraBlock(infraFindings) {
+  if (!infraFindings.available) {
+    return ["### Infra misconfigurations (checkov)", `- Status: not available — ${infraFindings.reason || "checkov not installed"}`, ""];
+  }
+  const lines = ["### Infra misconfigurations (checkov)"];
+  lines.push(`- Total findings: ${infraFindings.total ?? 0}`);
+  const cap = MAX_SAMPLE_SEMGREP_PER_SEVERITY * 3;
+  for (const f of (infraFindings.findings || []).slice(0, cap)) {
+    const lineSuffix = f.line ? `:${f.line}` : "";
+    lines.push(`  - [${f.severity}] ${f.file}${lineSuffix} [${f.rule}] ${f.message}${f.guideline ? ` (${f.guideline})` : ""}`);
+  }
+  const overflow = (infraFindings.total ?? 0) - cap;
+  if (overflow > 0) lines.push(`  - ... and ${overflow} more`);
+  lines.push("");
+  return lines;
+}
+
 function formatOsvBlock(osvFindings) {
   if (!osvFindings.available) {
     return ["### OSV Vulnerabilities", `- Status: not available — ${osvFindings.reason || "osv-scanner not installed"}`, ""];
@@ -298,6 +318,7 @@ export function deterministicContextHasFindings(ctx) {
   if (ctx.sonarFindings?.qualityGate?.status === "ERROR") return true;
   if (ctx.osvFindings?.available && (ctx.osvFindings.total ?? 0) > 0) return true;
   if (ctx.semgrepFindings?.available && (ctx.semgrepFindings.total ?? 0) > 0) return true;
+  if (ctx.infraFindings?.available && (ctx.infraFindings.total ?? 0) > 0) return true;
   if (ctx.circularDeps?.available && (ctx.circularDeps.total ?? 0) > 0) return true;
   if (ctx.deadExports?.available && (ctx.deadExports.total ?? 0) > 0) return true;
   if (ctx.growthDelta && (Math.abs(ctx.growthDelta.lines || 0) > 100 || Math.abs(ctx.growthDelta.deps || 0) > 0)) return true;

package/src/audit/infra-findings.js

@@ -0,0 +1,100 @@
+/**
+ * Checkov infra-misconfiguration collector for `kj audit` (INF-C,
+ * KJC-TSK-0760, epic KJC-PCS-0078).
+ *
+ * One tool covers the whole infra surface — terraform, kubernetes, helm,
+ * kustomize, ansible, dockerfiles — so checkov is THE infra scanner (tfsec
+ * and tflint stay out of scope: single dependency to learn and install).
+ * Findings enter the audit through the SAME best-effort channel as
+ * semgrep-findings (KJC-TSK-0366): no infra markers → not-applicable (zero
+ * noise, checkov never runs); missing binary → declared with the install
+ * command; non-zero exit with JSON on stdout (checkov's failed-checks
+ * behavior) rescued; unparseable output degrades SAYING so.
+ */
+
+import { runGoverned, jobsCap } from "../utils/tool-governor.js";
+import { detectInfraMarkers } from "../utils/project-detect.js";
+
+const SCAN_TIMEOUT_MS = 120_000;
+const INSTALL_HINT = "install via 'pipx install checkov' or 'pip install checkov'";
+
+/**
+ * Run checkov on the project and return a structured result.
+ *
+ * @param {string} projectDir - absolute path to the project root
+ * @param {object} [logger]
+ * @returns {Promise<{available: boolean, reason?: string, total?: number, findings?: object[]}>}
+ */
+export async function collectInfraFindings(projectDir, logger = null) {
+  // KJC-BUG-0122 doctrine: external scanners never fire from the unit suite.
+  if (process.env.VITEST && process.env.KJ_ALLOW_REAL_SCANS !== "1") {
+    return { available: false, reason: "real scans disabled under the test runner (set KJ_ALLOW_REAL_SCANS=1 to opt in)" };
+  }
+  if (!(await detectInfraMarkers(projectDir))) {
+    return { available: false, reason: "no infra markers (terraform/helm/kustomize/ansible) — not applicable" };
+  }
+  let stdout;
+  try {
+    const { stdout: out } = await runGoverned(
+      "checkov",
+      ["-d", projectDir || ".", "--output", "json", "--quiet", "--compact", `--parallel-runner-count=${jobsCap()}`],
+      { cwd: projectDir, timeout: SCAN_TIMEOUT_MS + 5000, maxBuffer: 32 * 1024 * 1024 }
+    );
+    stdout = out;
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      if (logger?.warn) logger.warn(`checkov not found in PATH — ${INSTALL_HINT}`);
+      return { available: false, reason: `checkov not installed — ${INSTALL_HINT}` };
+    }
+    if (err.killed) {
+      if (logger?.warn) logger.warn(`checkov timed out after ${SCAN_TIMEOUT_MS}ms`);
+      return { available: false, reason: `checkov timed out after ${SCAN_TIMEOUT_MS}ms` };
+    }
+    // checkov exits non-zero when checks fail, but still emits the report.
+    if (typeof err.stdout === "string" && err.stdout.trim().length > 0) {
+      stdout = err.stdout;
+    } else {
+      if (logger?.warn) logger.warn(`checkov failed: ${err.message}`);
+      return { available: false, reason: `checkov failed: ${err.message}` };
+    }
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch (err) {
+    if (logger?.warn) logger.warn(`checkov output not parseable: ${err.message}`);
+    return { available: false, reason: "checkov output not parseable as JSON" };
+  }
+
+  return { available: true, ...parseCheckovOutput(parsed) };
+}
+
+/**
+ * Convert checkov's JSON (object for one framework, array for several)
+ * into the flat findings list the audit prompt consumes. Checkov OSS may
+ * omit severity — WARNING is the honest default.
+ *
+ * @param {object|object[]} raw
+ * @returns {{total: number, findings: object[]}}
+ */
+export function parseCheckovOutput(raw) {
+  const reports = Array.isArray(raw) ? raw : [raw];
+  const findings = [];
+  for (const report of reports) {
+    const failed = report?.results?.failed_checks;
+    if (!Array.isArray(failed)) continue;
+    for (const c of failed) {
+      findings.push({
+        rule: c.check_id || "(unknown)",
+        severity: String(c.severity || "WARNING").toUpperCase(),
+        framework: report.check_type || "infra",
+        file: String(c.file_path || "").replace(/^\//, ""),
+        line: Array.isArray(c.file_line_range) ? (c.file_line_range[0] ?? 0) : 0,
+        message: c.check_name || "",
+        guideline: c.guideline || null,
+      });
+    }
+  }
+  return { total: findings.length, findings };
+}

package/src/checks/guarantee-level.js

@@ -0,0 +1,38 @@
+/**
+ * Guarantee level en runtime (KJC-TSK-0756, hallazgo de campo de Pedro):
+ * la doctrina "kj jamás finge una supervisión que no puede aplicar" vivía
+ * solo en el README — ahora kj doctor la DECLARA para el host actual, con
+ * el porqué. El acoplamiento a Claude es UNA capa (tier A: hooks síncronos
+ * bloqueantes, que hoy solo ese harness expone) y es decisión de ADR
+ * (v4.13), no accidente; el tier B (git gates) es el suelo agnóstico.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { detectHostAgent } from "../utils/agent-detect.js";
+
+/** Pure: computes the three tiers from observable facts. */
+export function guaranteeLevel({ host, harnessWired, policyDeclared, policyWorkflow }) {
+  const tierA = host === "claude" && harnessWired
+    ? { active: true, reason: "Claude Code expone hooks síncronos bloqueantes y el harness del Sentinel está instalado (kj harden)" }
+    : host === "claude"
+      ? { active: false, reason: "host Claude sin harness instalado — corre kj harden para activar la supervisión en el turno" }
+      : { active: false, reason: `el host ${host ?? "desconocido"} no expone hooks síncronos bloqueantes — no se finge la supervisión; el tier B sigue siendo el suelo de garantía` };
+  const tierB = { active: true, reason: "los gates viven en el repositorio, no en el harness: cualquier host, el diff violador no entra" };
+  const tierC = policyDeclared && policyWorkflow
+    ? { active: true, reason: "kj-policy.yml re-verifica el PR contra la policy declarada (merge-blocking)" }
+    : policyDeclared
+      ? { active: false, reason: "hay policy declarada pero sin workflow de CI — corre kj harden para sembrar kj-policy.yml" }
+      : { active: false, reason: "sin .karajan/policy.yml declarada — el tier C solo existe donde hay policy que verificar" };
+  return { host: host ?? null, tierA, tierB, tierC };
+}
+
+/** Facts from disk + env; injectable for tests. */
+export function collectGuaranteeFacts({ projectDir = process.cwd(), deps = {} } = {}) {
+  const { detectHost = detectHostAgent, exists = existsSync } = deps;
+  return guaranteeLevel({
+    host: detectHost(),
+    harnessWired: exists(join(projectDir, ".karajan", "harness", "pretooluse-sentinel.mjs")),
+    policyDeclared: exists(join(projectDir, ".karajan", "policy.yml")),
+    policyWorkflow: exists(join(projectDir, ".github", "workflows", "kj-policy.yml")),
+  });
+}

package/src/cli/register-meta.js

@@ -286,7 +286,7 @@ export function registerMeta(program, { pkgVersion }) {
     });
 
   // KJC-TSK-0733 PL-A — policy as code: motor determinista en modo warn.
-  const policyCmd = program.command("policy").description("Policy as code (.karajan/policy.yml, vocabulario cerrado) — PL-A: modo warn");
+  const policyCmd = program.command("policy").description("Policy as code (.karajan/policy.yml, vocabulario cerrado): eval/check deterministas, grant con caducidad, anchor del decision log — deny en commit y CI");
   policyCmd.command("eval")
     .description("Evalúa UNA tool call: imprime {decision, rule_id, reason}; --strict devuelve exit 2 en deny (contrato para adaptadores de hooks)")
     .option("--role <role>", "Rol del agente", "coder")

package/src/cli/register-roles-skills.js

@@ -1,5 +1,5 @@
 import { rolesCommand } from "../commands/roles.js";
-import { agentsCommand } from "../commands/agents.js";
+import { agentsCommand, ASSIGNABLE_ROLES, VALID_PROVIDERS } from "../commands/agents.js";
 import { withConfig } from "./_shared.js";
 
 /**
@@ -30,6 +30,22 @@ export function registerRolesSkills(program, { pkgVersion }) {
     .command("agents [subcommand] [role] [provider]")
     .description("List or change AI agent assignments per role (e.g. kj agents set coder gemini)")
     .option("--global", "Persist change to kj.config.yml (default for CLI)")
+    // KJC-TSK-0755: el --help enumera valores REALES (de las constantes, no
+    // duplicados a mano) — la firma genérica obligaba a preguntar.
+    .addHelpText("after", [
+      "",
+      "Subcommands:",
+      "  list (default)   Show the provider assigned to each role",
+      "  set              Change one: kj agents set <role> <provider>",
+      "",
+      `Roles:     ${ASSIGNABLE_ROLES.join(", ")}`,
+      `Providers: ${VALID_PROVIDERS.join(", ")}  (kj doctor shows which are installed)`,
+      "",
+      "Examples:",
+      "  kj agents                          # current assignments",
+      "  kj agents set reviewer codex",
+      "  kj agents set solomon agy --global",
+    ].join("\n"))
     .action(async (subcommand, role, provider, flags) => {
       await withConfig(pkgVersion, "agents", {}, async ({ config }) => {
         await agentsCommand({ config, subcommand: subcommand || "list", role, provider, global: flags.global });

package/src/commands/agents.js

@@ -1,12 +1,14 @@
 import { loadConfig, writeConfig, getConfigPath, getProjectConfigPath, loadProjectConfig, resolveRole } from "../config.js";
 import { checkBinary, KNOWN_AGENTS } from "../utils/agent-detect.js";
 
-const ASSIGNABLE_ROLES = [
+// Exportados para que el --help se autoalimente de las constantes reales
+// (KJC-TSK-0755, hallazgo de campo: la firma genérica obligaba a preguntar).
+export const ASSIGNABLE_ROLES = [
   "coder", "reviewer", "planner", "refactorer", "triage",
   "researcher", "tester", "security", "solomon"
 ];
 
-const VALID_PROVIDERS = KNOWN_AGENTS.map((a) => a.name);
+export const VALID_PROVIDERS = KNOWN_AGENTS.map((a) => a.name);
 
 export function listAgents(config, sessionOverrides = {}, projectConfig = null) {
   return ASSIGNABLE_ROLES.map((role) => {

package/src/commands/doctor.js

@@ -13,6 +13,7 @@
 
 import readline from "node:readline";
 import { runChecks as runCheckPipeline, toLegacyShape } from "../checks/runner.js";
+import { collectGuaranteeFacts } from "../checks/guarantee-level.js";
 import { STATUS } from "../checks/types.js";
 import { getSystemChecks } from "../checks/system.js";
 import { getConfigFileChecks } from "../checks/config-files.js";
@@ -140,16 +141,31 @@ export async function runChecks({ config }) {
  */
 export async function doctorCommand({ config, checkOnly = false, yes = false, json = false, verbose = false, projectOnly = false }) {
   const report = await runDoctor({ config, checkOnly, yes, projectOnly });
+  // KJC-TSK-0756 (campo, Pedro): el guarantee level del host actual se
+  // DECLARA en runtime — la doctrina no vive solo en el README.
+  report.guarantee = collectGuaranteeFacts({ projectDir: config?.projectDir || process.cwd() });
 
   if (json) {
     console.log(JSON.stringify(report, null, 2));
   } else {
     printHuman(report, { verbose });
+    printGuaranteeLevel(report.guarantee);
   }
 
   return hasBlockingFailure(report) ? 1 : 0;
 }
 
+// KJC-TSK-0756: la seccion de guarantee level — consola es el medio del
+// doctor (excepcion no-console de commands).
+function printGuaranteeLevel(g) {
+  const mark = (t) => (t.active ? "ACTIVE " : "OFF    ");
+  console.log();
+  console.log(`Guarantee level (host: ${g.host ?? "desconocido"}) — kj jamas finge una supervision que no puede aplicar:`);
+  console.log(`  ${mark(g.tierA)} A tool-time (Sentinel en el turno): ${g.tierA.reason}`);
+  console.log(`  ${mark(g.tierB)} B commit-time (git gates, el SUELO): ${g.tierB.reason}`);
+  console.log(`  ${mark(g.tierC)} C merge-time (re-check en CI): ${g.tierC.reason}`);
+}
+
 function hasBlockingFailure(report) {
   return report.checks.some((c) => c.status === STATUS.FAIL || c.status === STATUS.TIMEOUT);
 }

package/src/commands/review-gate.js

@@ -13,6 +13,7 @@ import { runOneShotReview } from "../review/one-shot-review.js";
 import { runSolomonArbitration } from "../review/solomon-arbitration.js";
 import { ensureGateTrackable } from "../review/gate-gitignore.js";
 import { runSonarPregate, formatSonarFinding } from "../review/sonar-pregate.js";
+import { runMutationPregate, formatSurvivor } from "../review/mutation-pregate.js";
 import { checkCardFirst } from "../review/card-first.js";
 import { checkTestsWithCode } from "../review/tests-with-code.js";
 import { loadPrivacyList, scanText } from "../privacy/scan.js";
@@ -325,6 +326,28 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
     }
   }
 
+  // MUT-A (KJC-TSK-0716): mutation pre-gate — opt-in (method_gates.mutation),
+  // SOLO en --staged (jamás en pre-commit: cuesta minutos; y jamás en --range:
+  // el scope es el ÍNDICE y anotaría trabajo ajeno — catch de codex). block
+  // cierra ANTES de gastar reviewer; warn viaja como advisory en su task.
+  const mut = flags.staged && !flags.range ? await runMutationPregate({ config, projectDir }) : { enabled: false, ok: true };
+  if (mut.enabled) {
+    if (mut.available === false) {
+      console.log(`⚠ mutation pre-gate no disponible: ${mut.reason} — degradado avisando (method_gates.mutation)`);
+    } else if (mut.survived.length > 0) {
+      console.log(`Mutantes supervivientes en el diff — score ${mut.score ?? "n/a"}%:`);
+      for (const m of mut.survived) console.log(`  ✗ ${formatSurvivor(m)}`);
+      if (!mut.ok) {
+        console.log("✗ mutation gate: la suite verde no PRUEBA el cambio — mata los supervivientes antes del review (method_gates.mutation: block).");
+        process.exitCode = 1;
+        return { verdict: "rejected", reviewer: "mutation", issues: mut.survived.map((m) => ({ severity: "high", file: m.file, description: formatSurvivor(m) })) };
+      }
+      task = `${task || "Review the following diff for correctness, security and maintainability."}\n\n`
+        + `Surviving mutants on the changed lines (weak asserts — fold into your review):\n`
+        + mut.survived.map((m) => `- ${formatSurvivor(m)}`).join("\n");
+    }
+  }
+
   const record = await runOneShotReview({ diff, task, config, logger, projectDir });
   printVerdict(record);
   process.exitCode = record.verdict === "approved" ? 0 : 1;

package/src/config/role-resolver.js

@@ -20,8 +20,13 @@
 
 /**
  * Check if a model string is compatible with an agent provider.
- * Only returns false when the model clearly belongs to a DIFFERENT provider.
+ * Only returns false when the model clearly belongs to a DIFFERENT family.
  * Returns true if we can't determine or if the model is ambiguous.
+ *
+ * KJC-BUG-0144: exported and family-based — an agent may serve another
+ * family's models (agy is Google's Antigravity, gemini family), and the
+ * same check now guards BaseAgent.getRoleModel so per-role defaults
+ * (e.g. start's haiku) never reach a provider from another family.
  */
 const AGENT_MODEL_SIGNATURES = {
   claude: ["claude", "sonnet", "opus", "haiku"],
@@ -29,21 +34,26 @@ const AGENT_MODEL_SIGNATURES = {
   gemini: ["gemini", "flash-"]
 };
 
-function isModelCompatible(agent, model) {
-  if (!model || !agent) return true;
-  const lower = model.toLowerCase();
+// Single-family CLIs: they only serve their own vendor's models. Agents NOT
+// in this map (aider, opencode, copilot, kimi...) are multi-model hosts —
+// they route to arbitrary models, so any model name is allowed there.
+const AGENT_FAMILY = { claude: "claude", codex: "codex", gemini: "gemini", agy: "gemini" };
 
-  // Check if model clearly belongs to a different provider
-  for (const [provider, signatures] of Object.entries(AGENT_MODEL_SIGNATURES)) {
-    if (provider === agent) continue;
-    if (signatures.some(s => lower.includes(s))) {
-      // Model belongs to a different provider — incompatible
-      return false;
-    }
+function modelFamily(model) {
+  const lower = model.toLowerCase();
+  for (const [family, signatures] of Object.entries(AGENT_MODEL_SIGNATURES)) {
+    if (signatures.some(s => lower.includes(s))) return family;
   }
+  return null;
+}
 
-  // Model doesn't clearly belong to any other provider — allow it
-  return true;
+export function isModelCompatible(agent, model) {
+  if (!model || !agent) return true;
+  const agentFamily = AGENT_FAMILY[agent];
+  if (!agentFamily) return true; // multi-model host — bring your own model
+  const family = modelFamily(model);
+  if (!family) return true; // ambiguous/custom/local — allow it
+  return family === agentFamily;
 }
 
 // Roles that inherit provider/model from the coder when not explicitly configured

package/src/environment/briefs.js

@@ -71,6 +71,9 @@ const B = {
         [
           ...(tdd ? ["TDD is ON: the failing test exists FIRST, then the code."] : []),
           "The suite is never left red, and never goes green by deleting or skipping tests.",
+          ...(config?.method_gates?.mutation
+            ? ["Green is not proof: run `kj mutate --since <base>` after the suite passes and BEFORE review — kill surviving mutants (weak asserts) first."]
+            : []),
         ],
         "green suite + the list of new/changed tests and what each one pins.");
     },

package/src/environment/playbook.js

@@ -61,7 +61,9 @@ Invariants (the git gates enforce these — they are not suggestions):
   \`kj_rag_query\` tool: reach for it before grepping by hand.
 - ${trackingLine(stateBackend, boardName)}
 - Tests prove behavior: the failing test exists first (TDD), and the suite
-  is never left red.
+  is never left red. Green is not proof: with \`method_gates.mutation\`
+  declared, run \`kj mutate --since <base>\` after green and BEFORE the
+  review — a surviving mutant is a weak assert; kill it first.
 - Every diff is reviewed by a DIFFERENT AI before it is committed
   (\`kj review --staged\`): verdicts bind to the exact diff — change the code
   and it must be reviewed again. Disagree with a rejection? \`kj solomon\`.

package/src/harden/sentinel-hooks.js

@@ -35,8 +35,10 @@ import { fileURLToPath } from "node:url";
 const here = dirname(fileURLToPath(import.meta.url));
 export const STATE = join(here, "sentinel-state.json");
 export const ROOT = join(here, "..", "..");
-export const TESTS = /(^|\\/)(tests?|__tests__|spec)\\/|\\.(test|spec)\\.[a-z]+$/;
-export const CODE = /\\.(m?[jt]sx?|c[jt]s|py|go|rs|java|rb|php|cs|swift|kt|astro|svelte|vue|c|h|cc|cpp|hpp)$/;
+// INF-A (KJC-TSK-0758): infra IS source — terraform/k8s/shell/Docker edits
+// engage the method like app code; *_test.* files (terratest) are tests.
+export const TESTS = /(^|\\/)(tests?|__tests__|spec)\\/|\\.(test|spec)\\.[a-z]+$|_test\\.[a-z]+$/;
+export const CODE = /\\.(m?[jt]sx?|c[jt]s|py|go|rs|java|rb|php|cs|swift|kt|astro|svelte|vue|c|h|cc|cpp|hpp|tf|hcl|ya?ml|sh)$|(^|\\/)(Dockerfile|Makefile|Vagrantfile)$/;
 export const CARD = new RegExp(${JSON.stringify(CARD_REF_RE.source)}, "i");
 export const BASE_BRANCHES = new Set(["main", "master"]);
 export const load = () => { try { return JSON.parse(readFileSync(STATE, "utf8")); } catch { return {}; } };
@@ -226,6 +228,43 @@ process.stdin.on("end", () => {
       process.exit(2);
     }
     if (process.env.KJ_SENTINEL_OFF === "1") process.exit(0);
+    // KJC-BUG-0142: cada deny anuncia su escape como prefijo del comando
+    // (KJ_ALLOW_X=1 cmd), pero el hook corre con el env del HOST — el
+    // prefijo jamas llegaba a process.env y el escape era inalcanzable
+    // (deadlock real del gate de release: la landing solo se pone verde
+    // tras el deploy y el deploy estaba bloqueado por el mismo gate). Un
+    // escape es una excepcion CONSCIENTE y auditada, no un boundary de
+    // seguridad (security sigue sin escape y la autoprotecion corre antes),
+    // asi que el TEXTO del comando es fuente valida: solo asignaciones
+    // LITERALES al inicio (tokens VAR=VAL antes del primer verbo) y solo
+    // sobre un comando SIMPLE — con ;|& $() backtick o salto de linea el
+    // prefijo shell no alcanzaria a los comandos posteriores (catch de
+    // codex: "X=1 true && npm publish" escaparia sin serlo), asi que el
+    // escape por texto se rechaza y queda la via env de siempre.
+    const CMD_TEXT = tool === "Bash" ? String(input.command || "") : "";
+    const ESC_TAB = String.fromCharCode(9);
+    const ESC_NL = String.fromCharCode(10);
+    const ESC_BT = String.fromCharCode(96);
+    const escOn = (name) => {
+      if (process.env[name] === "1") return true;
+      let found = false;
+      let i = 0;
+      while (i < CMD_TEXT.length) {
+        while (i < CMD_TEXT.length && (CMD_TEXT[i] === " " || CMD_TEXT[i] === ESC_TAB)) i += 1;
+        const start = i;
+        while (i < CMD_TEXT.length && CMD_TEXT[i] !== " " && CMD_TEXT[i] !== ESC_TAB && CMD_TEXT[i] !== ESC_NL) i += 1;
+        const tok = CMD_TEXT.slice(start, i);
+        const eq = tok.indexOf("=");
+        if (eq <= 0 || !/^[A-Z][A-Z0-9_]*$/.test(tok.slice(0, eq))) break;
+        if (tok === name + "=1") found = true;
+      }
+      if (!found) return false;
+      for (const c of CMD_TEXT) {
+        if (c === ";" || c === "|" || c === "&" || c === ESC_NL || c === ESC_BT) return false;
+        if (c === "$" || c === "(" || c === ")") return false;
+      }
+      return true;
+    };
     // MONO-0 (KJC-TSK-0737, ADR 0002): cada sesion muta solo SU worktree;
     // otro carril del MISMO repo se deniega ANTES del dano. Lectura libre.
     const laneOf = (p) => {
@@ -243,7 +282,7 @@ process.stdin.on("end", () => {
       return d ? foreignLane(d) : null;
     };
     const laneDeny = (what, lane) => {
-      if (process.env.KJ_ALLOW_CROSS_LANE === "1") { recordEscape(sid, "KJ_ALLOW_CROSS_LANE", tool); return false; }
+      if (escOn("KJ_ALLOW_CROSS_LANE")) { recordEscape(sid, "KJ_ALLOW_CROSS_LANE", tool); return false; }
       console.error("kj sentinel: " + what + " vive en otro carril (" + lane + ") de este repo — cada sesion muta solo SU worktree (MONO-0). Cruce deliberado: KJ_ALLOW_CROSS_LANE=1, queda registrado.");
       return true;
     };
@@ -270,7 +309,7 @@ process.stdin.on("end", () => {
         // directorio se deniega conservadoramente — el remedio es no
         // necesitarlo (git -C, npm --prefix, rutas absolutas).
         if (/(^|[;&|(\\s])(cd|pushd)([ \\t]|$)/.test(cmd)) {
-          if (process.env.KJ_ALLOW_CROSS_LANE === "1") { recordEscape(sid, "KJ_ALLOW_CROSS_LANE", tool); }
+          if (escOn("KJ_ALLOW_CROSS_LANE")) { recordEscape(sid, "KJ_ALLOW_CROSS_LANE", tool); }
           else {
             console.error("kj sentinel: cd/pushd en un comando mutador — las rutas posteriores no son verificables por el guard de carriles (MONO-0); usa git -C / npm --prefix / rutas ABSOLUTAS sin cd (o KJ_ALLOW_CROSS_LANE=1, queda registrado).");
             process.exit(2);
@@ -289,7 +328,7 @@ process.stdin.on("end", () => {
         // de tokens de abajo; el residuo (expansion anidada en segmentos
         // runner) queda documentado como en la regla de ficheros PROTECTED.
         if (/>{1,2}[ \\t]*["']?[\\$\`]/.test(cmd)) {
-          if (process.env.KJ_ALLOW_CROSS_LANE === "1") { recordEscape(sid, "KJ_ALLOW_CROSS_LANE", tool); }
+          if (escOn("KJ_ALLOW_CROSS_LANE")) { recordEscape(sid, "KJ_ALLOW_CROSS_LANE", tool); }
           else {
             console.error("kj sentinel: redireccion con destino tras variable/sustitucion — el guard de carriles no puede verificarlo (MONO-0); usa una ruta LITERAL (o KJ_ALLOW_CROSS_LANE=1, queda registrado).");
             process.exit(2);
@@ -299,8 +338,63 @@ process.stdin.on("end", () => {
         // en cualquier posicion, y una ruta entrecomillada con espacios es
         // invisible al tokenizador: ambas => deny conservador (endpoint
         // pedido por el reviewer; friccion asumida, el remedio es literal).
-        if (/\\$\\(|\`/.test(cmd) || /["'][^"'\\n]*\\/[^"'\\n]* [^"'\\n]*["']/.test(cmd)) {
-          if (process.env.KJ_ALLOW_CROSS_LANE === "1") { recordEscape(sid, "KJ_ALLOW_CROSS_LANE", tool); }
+        // KJC-BUG-0140: pares de comillas REALES, no regex sobre el texto —
+        // la comilla de CIERRE de un string + un redirect literal + la de
+        // apertura del siguiente creaban la ilusion de ruta con espacios y
+        // denegaban el flujo estandar commit -m "..." > log && echo "ok".
+        // Se recorre alternando estado (doctrina del parseCommand del motor):
+        // solo el CONTENIDO realmente entrecomillado con slash y espacio
+        // deniega — incluidas comillas a mitad de token (scp host:"/a b/x")
+        // y la comilla sin cerrar (no verificable).
+        // ...y por TOKEN completo, no por span: spans adyacentes concatenan
+        // ("dir with"" spaces/file" es UNA ruta) — catch de codex.
+        const quotedPathWithSpaces = (s) => {
+          // Un backslash pegado a comilla o blanco (comilla escapada,
+          // espacio escapado) altera donde CIERRA el string o esconde
+          // espacios: opaco => deny (doctrina del motor) — catch de codex.
+          // Caracteres construidos con fromCharCode: CERO escaping en este
+          // template — fuente y artefacto identicos, nada que malinterpretar
+          // (el doble-escaping confundio cuatro reviews; solomon desestimo
+          // la primera y las demas se volvieron ilegibles igual).
+          // El punto escapado de un sed y similares siguen libres.
+          const BS = String.fromCharCode(92);
+          const TAB = String.fromCharCode(9);
+          const NL = String.fromCharCode(10);
+          for (let i = s.indexOf(BS); i !== -1; i = s.indexOf(BS, i + 1)) {
+            const n = s[i + 1] || "";
+            if (n === '"' || n === "'" || n === " " || n === TAB) return true;
+          }
+          let q = null;
+          let tok = "";
+          let hadQuote = false;
+          const flush = () => {
+            const bad = hadQuote && tok.includes("/") && tok.includes(" ");
+            tok = "";
+            hadQuote = false;
+            return bad;
+          };
+          for (const ch of s) {
+            if (q) {
+              if (ch === q) q = null;
+              else tok += ch;
+              continue;
+            }
+            if (ch === '"' || ch === "'") {
+              q = ch;
+              hadQuote = true;
+              continue;
+            }
+            if (ch === " " || ch === TAB || ch === NL || ch === ";" || ch === "|" || ch === "&" || ch === "<" || ch === ">" || ch === "(" || ch === ")") {
+              if (flush()) return true;
+              continue;
+            }
+            tok += ch;
+          }
+          if (q !== null) return true; // comilla sin cerrar: no verificable
+          return flush();
+        };
+        if (/\\$\\(|\`/.test(cmd) || quotedPathWithSpaces(cmd)) {
+          if (escOn("KJ_ALLOW_CROSS_LANE")) { recordEscape(sid, "KJ_ALLOW_CROSS_LANE", tool); }
           else {
             console.error("kj sentinel: sustitucion de comandos o ruta entrecomillada con espacios en un comando mutador — no verificable por el guard de carriles (MONO-0); usa valores/rutas LITERALES sin sustitucion (o KJ_ALLOW_CROSS_LANE=1, queda registrado).");
             process.exit(2);
@@ -309,7 +403,7 @@ process.stdin.on("end", () => {
         const SAFE_EXP_SEG = /^([A-Za-z_][A-Za-z0-9_]*=[^ \\t]*[ \\t]*)*((npm|pnpm|yarn|vitest|jest|kj|gh|echo|printf|true|test)\\b|git[ \\t](?![^\\n]*(-C[ \\t]|--git-dir|--work-tree)))[^;|&\\n]*$|^[A-Za-z_][A-Za-z0-9_]*=[^;|&\\n]*$/;
         const segs = cmd.split(/&&|\\|\\||[;|\\n]/).map((s) => s.trim()).filter(Boolean);
         if (!segs.every((s) => !/[\\$]/.test(s) || SAFE_EXP_SEG.test(s))) {
-          if (process.env.KJ_ALLOW_CROSS_LANE === "1") { recordEscape(sid, "KJ_ALLOW_CROSS_LANE", tool); }
+          if (escOn("KJ_ALLOW_CROSS_LANE")) { recordEscape(sid, "KJ_ALLOW_CROSS_LANE", tool); }
           else {
             console.error("kj sentinel: expansion de shell en una herramienta generica de fichero/interprete — el objetivo no es verificable por el guard de carriles (MONO-0); usa rutas LITERALES o un runner del toolchain (o KJ_ALLOW_CROSS_LANE=1, queda registrado).");
             process.exit(2);
@@ -344,20 +438,20 @@ process.stdin.on("end", () => {
       const actorRole = process.env.KJ_POLICY_ROLE || "coder";
       const pres = spawnSync("kj", ["policy", "eval", "--strict", "--role", actorRole, "--tool", tool, "--input", JSON.stringify(input)], { cwd: ROOT, encoding: "utf8" });
       if (pres.error || pres.status === null) {
-        console.error("kj sentinel: .karajan/policy.yml declara enforcement pero kj no es ejecutable — la policy no se puede evaluar; restaura kj en el PATH (npm i -g karajan-code) o retira la policy conscientemente.");
+        console.error("kj sentinel: .karajan/policy.yml declara enforcement pero kj no es ejecutable — la policy no se puede evaluar; restaura kj en el PATH (npm i -g @karajan-family/code, o el nombre legacy karajan-code) o retira la policy conscientemente.");
         process.exit(2);
       }
       if (pres.status === 2) {
         let v = null;
         try { v = JSON.parse(String(pres.stdout || "").trim().split("\\n").pop()); } catch { /* mensaje generico */ }
         const secure = !!(v && v.class === "security");
-        if (!secure && process.env.KJ_ALLOW_POLICY === "1") { recordEscape(sid, "KJ_ALLOW_POLICY", tool); }
+        if (!secure && escOn("KJ_ALLOW_POLICY")) { recordEscape(sid, "KJ_ALLOW_POLICY", tool); }
         else {
           console.error("kj sentinel: policy deny [" + ((v && v.rule_id) || "policy") + "] " + ((v && v.reason) || "la tool call viola la policy del proyecto") + (secure ? " [security — sin escape ni arbitraje]" : " (KJ_ALLOW_POLICY=1 = excepcion consciente, queda registrada; el commit exigira ademas KJ_POLICY_REASON)"));
           process.exit(2);
         }
       } else if (pres.status !== 0) {
-        if (process.env.KJ_ALLOW_POLICY === "1") { recordEscape(sid, "KJ_ALLOW_POLICY", tool); }
+        if (escOn("KJ_ALLOW_POLICY")) { recordEscape(sid, "KJ_ALLOW_POLICY", tool); }
         else {
           console.error("kj sentinel: kj policy eval fallo (exit " + pres.status + ") — la policy declarada no se pudo evaluar, deny por defecto; diagnostica con kj policy check y corrige .karajan/policy.yml fuera de la sesion (o KJ_ALLOW_POLICY=1 = excepcion consciente, queda registrada).");
           process.exit(2);
@@ -371,7 +465,7 @@ process.stdin.on("end", () => {
         const branch = branchOf();
         const why = !branch ? null : BASE_BRANCHES.has(branch) ? "base" : !CARD.test(branch) ? "nocard" : null;
         if (why) {
-          if (process.env.KJ_ALLOW_NO_CARD === "1") { recordEscape(sid, "KJ_ALLOW_NO_CARD", tool); process.exit(0); }
+          if (escOn("KJ_ALLOW_NO_CARD")) { recordEscape(sid, "KJ_ALLOW_NO_CARD", tool); process.exit(0); }
           console.error(why === "base"
             ? "kj sentinel: no se editan fuentes en la rama base '" + branch + "' — crea la card (kj hu add) y la rama: git checkout -b feat/<CARD-ID>-descripcion. (KJ_ALLOW_NO_CARD=1 = excepcion consciente, queda registrada)"
             : "kj sentinel: la rama '" + branch + "' no referencia ninguna card — crea/mueve la card a running (kj hu add | kj hu move) y usa una rama feat/<CARD-ID>-descripcion. (KJ_ALLOW_NO_CARD=1 = excepcion consciente, queda registrada)");
@@ -382,7 +476,7 @@ process.stdin.on("end", () => {
     if (tool === "Bash") {
       const cmd = String(input.command || "");
       if (PUBLISH.test(cmd)) {
-        if (process.env.KJ_ALLOW_RELEASE === "1") { recordEscape(sid, "KJ_ALLOW_RELEASE", tool); process.exit(0); }
+        if (escOn("KJ_ALLOW_RELEASE")) { recordEscape(sid, "KJ_ALLOW_RELEASE", tool); process.exit(0); }
         const res = spawnSync("kj", ["release", "check", "--json"], { cwd: ROOT, encoding: "utf8" });
         if (res.error || res.status === null) process.exit(0);
         if (res.status !== 0) {

package/src/harden/workflow-engine.js

@@ -19,18 +19,18 @@ import { extraWorkflowsFor, mutationWorkflowFor, qualityWorkflowFor, policyWorkf
 // npx del workflow de policy (jamás @latest en CI). Lectura LAZY: en el
 // bundle SEA no hay package.json junto al módulo y una lectura eager a
 // nivel de módulo tumbaba el binario entero al cargar (ENOENT /package.json).
-let _ownVersion;
-function ownVersion() {
-  if (_ownVersion === undefined) {
+let _ownPkg;
+function ownPkg() {
+  if (_ownPkg === undefined) {
     try {
-      _ownVersion = JSON.parse(
+      _ownPkg = JSON.parse(
         readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json"), "utf8"),
-      ).version;
+      );
     } catch {
-      _ownVersion = null;
+      _ownPkg = null;
     }
   }
-  return _ownVersion;
+  return _ownPkg;
 }
 
 const BLOCK_VERSION = 1;
@@ -81,9 +81,9 @@ export function installWorkflows({
   // PL-C: el tier C solo existe donde el proyecto DECLARA policy. Versión a
   // pinear: la plumbeada por el CLI (SEA) o la propia; "latest" es último
   // recurso inalcanzable en los caminos reales.
-  const pinned = kjVersion ?? ownVersion() ?? "latest";
+  const pinned = kjVersion ?? ownPkg()?.version ?? "latest";
   const policy = existsSync(join(projectDir, ".karajan", "policy.yml"))
-    ? { file: "kj-policy.yml", blockId: "wf-policy", body: policyWorkflowFor(pinned) }
+    ? { file: "kj-policy.yml", blockId: "wf-policy", body: policyWorkflowFor(pinned, ownPkg()?.name ?? "karajan-code") }
     : null;
   const all = [...WORKFLOWS, ...(quality ? [quality] : []), ...extras, ...(mut ? [mut] : []), ...(policy ? [policy] : [])];
   const results = [];

package/src/harden/workflow-templates.js

@@ -57,7 +57,7 @@ export const WORKFLOWS = [
 // PL-C (KJC-TSK-0735) — tier C del ADR 0001: re-check merge-blocking en CI
 // (cubre el hook local manipulado). Solo se siembra con policy declarada;
 // npx PINEADO a la versión del kj que corrió harden — jamás @latest en CI.
-export const policyWorkflowFor = (kjVersion) => [
+export const policyWorkflowFor = (kjVersion, kjName = "karajan-code") => [
   "name: Policy",
   "on:",
   "  pull_request:",
@@ -77,7 +77,7 @@ export const policyWorkflowFor = (kjVersion) => [
   "        env:",
   "          BASE_REF: ${{ github.base_ref }}",
   "        run: |",
-  `          if [ -f bin/kj.js ]; then npm ci --ignore-scripts && KJ="node bin/kj.js"; else KJ="npx --yes karajan-code@${kjVersion}"; fi`,
+  `          if [ -f bin/kj.js ]; then npm ci --ignore-scripts && KJ="node bin/kj.js"; else KJ="npx --yes ${kjName}@${kjVersion}"; fi`,
   '          $KJ policy check --range "origin/${BASE_REF}...HEAD" --strict',
   "", // línea en blanco pre-marcador: prettier la exige tras un block scalar
 ].join("\n");

package/src/mutate/diff-scope.js

@@ -89,8 +89,12 @@ export function buildScope({ language, files, ranges }) {
  * the injectable git runner (defaults to `runCommand`).
  * @param {{since: string, language: string, toRef?: string, run?: Function}} params
  */
-export async function getDiffScope({ since, language, toRef = "HEAD", run = runCommand }) {
-  const result = await run("git", ["diff", "--unified=0", `${since}..${toRef}`]).catch(
+export async function getDiffScope({ since, language, toRef = "HEAD", staged = false, run = runCommand }) {
+  // MUT-A (KJC-TSK-0716): staged=true scopea al ÍNDICE (git diff --cached) —
+  // lo que el review gate evalúa. since..HEAD con since=HEAD sería un diff
+  // VACÍO y el pre-gate no mutaría nada (catch de codex, agravado).
+  const args = staged ? ["diff", "--unified=0", "--cached"] : ["diff", "--unified=0", `${since}..${toRef}`];
+  const result = await run("git", args).catch(
     () => null,
   );
   if (!result || result.exitCode !== 0) {

package/src/review/mutation-pregate.js

@@ -0,0 +1,48 @@
+/**
+ * Mutation pre-gate (MUT-A, KJC-TSK-0716) — audita "tests prove behavior":
+ * asserts flojos dejan mutantes vivos con la suite verde. OPT-IN
+ * (method_gates.mutation: warn|block — cuesta minutos) y SOLO en --staged:
+ * supervivientes como advisory al reviewer; block cierra ANTES con la
+ * lista exacta. Indisponible = degrada avisando, nunca en silencio.
+ */
+import { runMutation } from "../mutate/runner.js";
+import { getDiffScope } from "../mutate/diff-scope.js";
+import { detectProjectStack } from "../utils/stack-detect.js";
+import { getMutationTool } from "../mutate/tool-registry.js";
+
+export const formatSurvivor = (s) =>
+  `${s.file}:${s.line} (${s.mutator ?? s.status ?? "?"}) — mátalo con un assert que distinga el cambio`;
+
+async function defaultMutate({ projectDir }) {
+  const { language } = await detectProjectStack(projectDir);
+  const tool = getMutationTool(language);
+  if (!tool.supported) throw new Error(`lenguaje no soportado (${language ?? "desconocido"}) — ${tool.reason}`);
+  const scope = await getDiffScope({ staged: true, language });
+  if (scope.empty) return { result: { score: 100, killed: 0, total: 0, survived: [] } };
+  const outcome = await runMutation({ binary: tool.binary, args: scope.args, cwd: projectDir });
+  if (!outcome.result) throw new Error(`la herramienta ${tool.id} no produjo un informe legible`);
+  return outcome;
+}
+
+/**
+ * @returns {Promise<{enabled: boolean, ok: boolean, available?: boolean, mode?: string, survived?: object[], score?: number, reason?: string}>}
+ */
+export async function runMutationPregate({ config = {}, projectDir = process.cwd(), deps = {} } = {}) {
+  const mode = config?.method_gates?.mutation;
+  if (mode !== "warn" && mode !== "block") return { enabled: false, ok: true };
+  const { mutateFn = defaultMutate } = deps;
+  let outcome;
+  try {
+    outcome = await mutateFn({ projectDir });
+  } catch (err) {
+    // Sin herramienta no hay medición: se degrada DICIENDO qué red cayó.
+    return { enabled: true, ok: true, available: false, mode, reason: err.message };
+  }
+  // Payload malformado del runner = misma degradación que el error (catch
+  // de codex): jamás crashear el review gate por un informe roto.
+  if (!outcome?.result || !Array.isArray(outcome.result.survived ?? [])) {
+    return { enabled: true, ok: true, available: false, mode, reason: "el runner de mutación devolvió un informe ilegible" };
+  }
+  const { survived = [], score } = outcome.result;
+  return { enabled: true, available: true, mode, survived, score, ok: mode === "warn" || survived.length === 0 };
+}

package/src/roles/audit-role.js

@@ -6,6 +6,7 @@ import { collectSonarFindings } from "../audit/sonar-findings.js";
 import { collectWebPerfInput } from "../audit/webperf-input.js";
 import { collectOsvFindings } from "../audit/osv-findings.js";
 import { collectSemgrepFindings } from "../audit/semgrep-findings.js";
+import { collectInfraFindings } from "../audit/infra-findings.js";
 import { collectCircularDeps } from "../audit/circular-deps.js";
 import { collectDeadExports } from "../audit/dead-exports.js";
 import { collectInjectionFindings } from "../audit/injection-findings.js";
@@ -58,6 +59,7 @@ export class AuditRole extends AgentRole {
     const noMadge = (typeof input === "object" ? Boolean(input?.noMadge) : false) || securityOnly;
     const noKnip = (typeof input === "object" ? Boolean(input?.noKnip) : false) || securityOnly;
     const noInjectionScan = typeof input === "object" ? Boolean(input?.noInjectionScan) : false;
+    const noInfraScan = typeof input === "object" ? Boolean(input?.noInfraScan) : false;
     const noAiSlop = (typeof input === "object" ? Boolean(input?.noAiSlop) : false) || securityOnly;
     const projectDir = this.config?.projectDir || process.cwd();
     let basalCost = null;
@@ -70,6 +72,7 @@ export class AuditRole extends AgentRole {
     let circularDeps = null;
     let deadExports = null;
     let injectionFindings = null;
+    let infraFindings = null;
     let aiSlop = null;
     if (!securityOnly) {
       try {
@@ -127,6 +130,14 @@ export class AuditRole extends AgentRole {
         injectionFindings = await collectInjectionFindings(projectDir, this.logger);
       } catch { /* injection scan is best-effort (KJC-TSK-0498) */ }
     }
+    // Checkov infra misconfigs — INF-C (KJC-TSK-0760). Security surface, so
+    // it ALSO runs in securityOnly. Best-effort: no infra markers or missing
+    // checkov return available:false declaring why.
+    if (!noInfraScan) {
+      try {
+        infraFindings = await collectInfraFindings(projectDir, this.logger);
+      } catch { /* checkov is best-effort */ }
+    }
     // AI-slop tells (KJC-TSK-0503). Deterministic, offline, regex-based.
     // Local equivalent of Deslopify-style review. Best-effort.
     if (!noAiSlop) {
@@ -134,7 +145,7 @@ export class AuditRole extends AgentRole {
         aiSlop = await collectAiSlop(projectDir);
       } catch { /* ai-slop scan is best-effort */ }
     }
-    return { projectDir, basalCost, growthDelta, stack, sonarFindings, webperf, osvFindings, semgrepFindings, circularDeps, deadExports, injectionFindings, aiSlop };
+    return { projectDir, basalCost, growthDelta, stack, sonarFindings, webperf, osvFindings, semgrepFindings, circularDeps, deadExports, injectionFindings, infraFindings, aiSlop };
   }
 
   /**

package/src/roles/tester-role.js

@@ -24,7 +24,14 @@ const COVERAGE_COMMANDS = {
   rspec: "bundle exec rspec 2>&1",
   phpunit: "vendor/bin/phpunit --coverage-text 2>&1",
   "dotnet-test": "dotnet test --collect:\"XPlat Code Coverage\" 2>&1",
-  "dart-test": "dart test 2>&1"
+  "dart-test": "dart test 2>&1",
+  // INF-B: the basic suite ALWAYS runs first; checkov is the additive deep
+  // scan. If checkov is missing this chain fails and the brief falls back to
+  // the basic suite alone (declared degradation, never green-by-omission).
+  "terraform-validate": "terraform init -backend=false -input=false 2>&1 && terraform validate 2>&1 && checkov -d . --compact --quiet 2>&1",
+  "helm-lint": "helm lint . 2>&1 && checkov -d . --compact --quiet 2>&1",
+  "kustomize-build": "kustomize build . > /dev/null && checkov -d . --compact --quiet 2>&1",
+  "ansible-lint": "ansible-lint 2>&1 && checkov -d . --compact --quiet 2>&1"
 };
 
 const TEST_COMMANDS = {
@@ -39,7 +46,12 @@ const TEST_COMMANDS = {
   rspec: "bundle exec rspec 2>&1",
   phpunit: "vendor/bin/phpunit 2>&1",
   "dotnet-test": "dotnet test 2>&1",
-  "dart-test": "dart test 2>&1"
+  "dart-test": "dart test 2>&1",
+  // INF-B (KJC-TSK-0759): infra suites — validity IS the test floor.
+  "terraform-validate": "terraform init -backend=false -input=false 2>&1 && terraform validate 2>&1",
+  "helm-lint": "helm lint . 2>&1",
+  "kustomize-build": "kustomize build . > /dev/null && echo kustomize build: OK",
+  "ansible-lint": "ansible-lint 2>&1"
 };
 
 export class TesterRole extends AgentRole {
@@ -82,9 +94,14 @@ export class TesterRole extends AgentRole {
     if (detection.hasTests && detection.framework) {
       const coverageCmd = COVERAGE_COMMANDS[detection.framework];
       const testCmd = TEST_COMMANDS[detection.framework];
+      // INF-B: infra suites have no node_modules — the step-0 contract is
+      // "the tool exists or you SAY which one is missing", never a fake green.
+      const step0 = detection.language === "infra"
+        ? "**Step 0**: Verify the SUITE tool is installed (`which terraform`/`helm`/`kustomize`/`ansible-lint`). If the suite tool is MISSING, do NOT fake a green: report it in `failures` with the exact install command and set tests_pass: false. `checkov` (the deep scan below) is OPTIONAL: if it is missing, run the basic suite as the fallback and SAY the deep scan was skipped (degraded, never green-by-omission)."
+        : "**Step 0**: If node_modules/ does not exist, run `npm install` (or `pnpm install`) first.";
       sections.push(
         `## Detected test framework: ${detection.framework} (${detection.language})`,
-        "**Step 0**: If node_modules/ does not exist, run `npm install` (or `pnpm install`) first.",
+        step0,
         `**Step 1**: Run the test suite with coverage:`,
         "```bash",
         coverageCmd || testCmd,

package/src/start/sweep.js

@@ -7,6 +7,8 @@
 // brief+tests; existing/legacy = + drift, harden advisory, rag + qmd status.
 // Collaborators are injected (opts.deps) so it stays trivially testable.
 import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join, relative } from "node:path";
 import { execFileSync } from "node:child_process";
 
 import { collectAll } from "../onboarder/collectors/index.js";
@@ -23,11 +25,50 @@ const CODE_EXT = new Set([
   ".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx", ".py", ".go",
   ".rs", ".java", ".php", ".rb", ".c", ".cc", ".cpp", ".cs",
 ]);
+// KJC-BUG-0141 — infra projects (k8s/terraform/shell/Docker) ARE source code,
+// and code nested deeper than the display tree's maxDepth must still count.
+const INFRA_EXT = new Set([".yaml", ".yml", ".tf", ".hcl", ".sh"]);
+const INFRA_NAMES = new Set(["Dockerfile", "Makefile", "Vagrantfile"]);
+const SCAN_IGNORED = new Set([
+  "node_modules", "dist", "build", "out", "vendor", "coverage", "target", "__pycache__",
+]);
+const SCAN_MAX_DEPTH = 6;
 const SCAFFOLD_MAX_FILES = 3;
 const CI_MARKERS = [".github/workflows", ".gitlab-ci.yml"];
 
 const safe = async (fn) => { try { return await fn(); } catch { return null; } };
 
+const isTestPath = (p) => {
+  const posix = p.replaceAll("\\", "/");
+  return /\.(test|spec)\./.test(posix) || /(^|\/)(test|tests|__tests__)\//.test(posix);
+};
+
+/**
+ * Deep source counter with its own walk: the display tree stops at depth 2,
+ * which made backend/app/… projects look empty (KJC-BUG-0141).
+ * @returns {Promise<{code: number, infra: number}>}
+ */
+export async function deepSourceScan(projectDir, { maxDepth = SCAN_MAX_DEPTH } = {}) {
+  const counts = { code: 0, infra: 0 };
+  const walk = async (dir, depth) => {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const ent of entries) {
+      if (ent.name.startsWith(".") || SCAN_IGNORED.has(ent.name)) continue;
+      const full = join(dir, ent.name);
+      if (ent.isDirectory()) {
+        if (depth < maxDepth) await walk(full, depth + 1);
+        continue;
+      }
+      if (!ent.isFile() || isTestPath(relative(projectDir, full))) continue;
+      const ext = ent.name.slice(ent.name.lastIndexOf("."));
+      if (CODE_EXT.has(ext)) counts.code += 1;
+      else if (INFRA_EXT.has(ext) || INFRA_NAMES.has(ent.name)) counts.infra += 1;
+    }
+  };
+  await walk(projectDir, 0);
+  return counts;
+}
+
 /** Count real source files in a tree bundle, skipping tests. */
 export function countCodeFiles(tree = []) {
   let n = 0;
@@ -35,8 +76,7 @@ export function countCodeFiles(tree = []) {
     if (node.kind === "dir") n += countCodeFiles(node.children);
     else if (node.kind === "file") {
       const ext = node.path.slice(node.path.lastIndexOf("."));
-      const isTest = /\.(test|spec)\./.test(node.path) || /(^|\/)(test|tests|__tests__)\//.test(node.path);
-      if (CODE_EXT.has(ext) && !isTest) n += 1;
+      if (CODE_EXT.has(ext) && !isTestPath(node.path)) n += 1;
     }
   }
   return n;
@@ -73,20 +113,22 @@ function readRagStatus(projectDir) {
  */
 export async function runReadOnlySweep(projectDir, { declared = null, profile = "standard", deps = {} } = {}) {
   const d = {
-    collectAll, detectTestFramework, checkHarden, compareHarden,
+    collectAll, detectTestFramework, checkHarden, compareHarden, sourceScan: deepSourceScan,
     detectQmd, ragStatus: readRagStatus, gitAgeDays: lastCommitAgeDays, ...deps,
   };
 
   const brief = await safe(() => d.collectAll(projectDir));
   const tests = await safe(() => d.detectTestFramework(projectDir));
+  const scan = await safe(() => d.sourceScan(projectDir));
 
   const tree = brief?.tree ?? [];
   const present = brief?.configs?.present ?? [];
-  const codeFiles = countCodeFiles(tree);
+  const codeFiles = scan ? scan.code + scan.infra : countCodeFiles(tree);
   const commitCount = brief?.git?.commitCount ?? 0;
 
   const signals = {
     hasSourceCode: codeFiles > 0,
+    infraFiles: scan?.infra ?? 0,
     scaffoldingOnly: codeFiles > 0 && codeFiles <= SCAFFOLD_MAX_FILES && commitCount <= 1,
     hasTests: Boolean(tests?.hasTests),
     hasCI: CI_MARKERS.some((m) => present.includes(m)),

package/src/utils/project-detect.js

@@ -42,6 +42,18 @@ const LANGUAGE_MARKERS = [
   { file: "pubspec.yaml", framework: "dart-test", language: "dart" },
 ];
 
+// --- Infra (INF-B, KJC-TSK-0759) ---
+// Checked AFTER app-language markers: a mixed repo keeps its app framework.
+// Only unequivocal markers — a stray .yaml never classifies as infra.
+const INFRA_MARKERS = [
+  { file: "*.tf", glob: true, framework: "terraform-validate", language: "infra" },
+  { file: "terraform", framework: "terraform-validate", language: "infra" },
+  { file: "Chart.yaml", framework: "helm-lint", language: "infra" },
+  { file: "kustomization.yaml", framework: "kustomize-build", language: "infra" },
+  { file: "kustomization.yml", framework: "kustomize-build", language: "infra" },
+  { file: "ansible.cfg", framework: "ansible-lint", language: "infra" },
+];
+
 /** Test file patterns per language (used by TDD policy). */
 export const TEST_PATTERNS_BY_LANGUAGE = {
   javascript: ["/tests/", "/__tests__/", ".test.", ".spec."],
@@ -55,6 +67,7 @@ export const TEST_PATTERNS_BY_LANGUAGE = {
   php:        ["/tests/", "/test/", "Test.php"],
   swift:      ["/Tests/", "Tests.swift"],
   dart:       ["/test/", "_test.dart"],
+  infra:      ["/tests/", "/test/", "_test."],
 };
 
 function frameworkFromConfig(filename) {
@@ -93,7 +106,29 @@ export async function detectTestFramework(cwd = process.cwd()) {
   }
 
   // 3. Multi-language: check project markers
-  for (const marker of LANGUAGE_MARKERS) {
+  const lang = await matchMarkers(cwd, LANGUAGE_MARKERS);
+  if (lang) return lang;
+
+  // 4. Infra (INF-B): terraform/helm/kustomize/ansible have their own suite.
+  const infra = await matchMarkers(cwd, INFRA_MARKERS);
+  if (infra) return infra;
+
+  return { hasTests: false, framework: null, language: null };
+}
+
+/**
+ * True when the project carries unequivocal infra markers (terraform, helm,
+ * kustomize, ansible) — regardless of the app framework the repo may also
+ * have. Used by INF-C's audit collector to gate the checkov scan.
+ * @param {string} cwd
+ * @returns {Promise<boolean>}
+ */
+export async function detectInfraMarkers(cwd = process.cwd()) {
+  return Boolean(await matchMarkers(cwd, INFRA_MARKERS));
+}
+
+async function matchMarkers(cwd, markers) {
+  for (const marker of markers) {
     try {
       if (marker.glob) {
         const entries = await fs.readdir(cwd);
@@ -107,8 +142,7 @@ export async function detectTestFramework(cwd = process.cwd()) {
       }
     } catch { /* not found */ }
   }
-
-  return { hasTests: false, framework: null, language: null };
+  return null;
 }
 
 /**

package/src/utils/update-check.js

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import { readFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { isSea } from "node:sea";
@@ -8,7 +9,25 @@ const CACHE_FILE = "update-check.json";
 // KJC-TSK-0690: 6h — kj can ship several releases a day; a session should
 // not work a full day blind. KJ_NO_UPDATE_CHECK=1 opts out (CI).
 const CACHE_TTL_MS = 6 * 60 * 60 * 1000;
-const PACKAGE_NAME = "karajan-code";
+// MIG-A (KJC-TSK-0751): el nombre npm se lee del PROPIO manifest — con el
+// dual-publish del scope, el mismo código vive como karajan-code y como
+// @karajan-family/code y cada instalación se auto-actualiza por SU nombre.
+// Lazy + fallback: en el bundle SEA no hay package.json junto al módulo.
+let _pkgName;
+export function packageName() {
+  if (_pkgName) return _pkgName;
+  try {
+    _pkgName = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).name || "karajan-code";
+  } catch {
+    _pkgName = "karajan-code";
+  }
+  return _pkgName;
+}
+
+// URL del registro con el nombre CODIFICADO — el scoped @karajan-family/code
+// lleva @ y / que rompen la ruta sin encode (catch de codex).
+export const registryLatestUrl = (name = packageName()) =>
+  `https://registry.npmjs.org/${encodeURIComponent(name)}/latest`;
 const CHANGELOG_URL = "https://raw.githubusercontent.com/manufosela/karajan-code/main/CHANGELOG.md";
 const HIGHLIGHT_MAX = 160;
 
@@ -55,10 +74,10 @@ export function updateInstruction({ channel, platform = process.platform }) {
       : `Re-run the installer: curl -fsSL ${INSTALL_SH_URL} | sh`;
   }
   if (channel === "npm") {
-    return `Run: npm install -g ${PACKAGE_NAME}`;
+    return `Run: npm install -g ${packageName()}`;
   }
   // Channel unknown — offer both paths, never silently pick a wrong one.
-  return `Update: npm install -g ${PACKAGE_NAME}  (or re-run the binary installer — see README)`;
+  return `Update: npm install -g ${packageName()}  (or re-run the binary installer — see README)`;
 }
 
 /**
@@ -100,7 +119,7 @@ export async function checkForUpdate(currentVersion) {
     // Fetch from npm (timeout 3s, don't block)
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 3000);
-    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+    const res = await fetch(registryLatestUrl(), {
       signal: controller.signal,
       headers: { "Accept": "application/json" },
     });
@@ -174,7 +193,7 @@ export async function performSelfUpdate({ currentVersion, exec, logger = console
   try {
     // Registry over HTTP, not `npm view` — standalone-binary machines may
     // not have npm at all.
-    const res = await fetchFn(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+    const res = await fetchFn(registryLatestUrl(), {
       headers: { Accept: "application/json" },
     });
     if (!res.ok) throw new Error(`registry responded ${res.status}`);
@@ -213,7 +232,7 @@ export async function performSelfUpdate({ currentVersion, exec, logger = console
       }
     } else {
       // No stdio:inherit — capture and drop npm's warnings on the success path.
-      await run("npm", ["install", "-g", `${PACKAGE_NAME}@latest`]);
+      await run("npm", ["install", "-g", `${packageName()}@latest`]);
     }
   } catch (err) {
     if (err.stdout) logger.error(err.stdout);