karajan-code 4.18.0 → 4.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "4.18.0",
+  "version": "4.19.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/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/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

@@ -299,7 +299,62 @@ 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)) {
+        // 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 (process.env.KJ_ALLOW_CROSS_LANE === "1") { 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).");
@@ -344,7 +399,7 @@ 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) {

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/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/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);