karajan-code 4.17.0 → 4.19.0

package/src/policy/engine.js

@@ -1,26 +1,41 @@
 /**
- * policy engine — PL-A (KJC-TSK-0733, épica KJC-PCS-0074, ADR 0001).
- * Policy as DATA (`.karajan/policy.yml`, vocabulario CERRADO), engine as
- * code: módulo puro, determinista, sin red ni LLM. Una regla que el motor
- * no puede aplicar falla FUERTE al cargar — jamás se ignora en silencio.
- * Deny gana a allow; una allow-list convierte el exterior en denegación.
- * Consumidores: kj policy (PL-A) → gates PL-B → CI PL-C → middleware PL-D.
+ * karajan-code policy ADAPTER (GOV-A, KJC-TSK-0745, ADR 0003). El motor
+ * vive en @karajan-family/governance (packages/governance): aquí queda SOLO lo
+ * que es de este dominio — dónde vive el fichero de policy, los defaults
+ * inexcepcionables del supervisor del Sentinel, y el mapeo de tools del
+ * harness (Write/Edit/Bash…) a capabilities del kernel. La superficie
+ * pública de este módulo no cambia: loadPolicy/evalToolCall/checkStagedDiff
+ * siguen siendo lo que los gates de PL-B consumen.
  */
 import { readFileSync } from "node:fs";
-import { isAbsolute, join, posix, relative } from "node:path";
-import yaml from "js-yaml";
-import { commandPatternToRegExp, matchesAny } from "./glob.js";
+import { join } from "node:path";
+import {
+  ALLOW_VERDICT,
+  checkArtifacts,
+  denyVerdict,
+  evalShell,
+  evalWrite,
+  parsePolicy,
+  DEFAULT_POLICY as KERNEL_DEFAULT_POLICY,
+} from "@karajan-family/governance";
 
-// Vocabulario CERRADO e incremental: cada capacidad entra al set EN el PR
-// que trae su evaluación — declararla antes sería una regla que miente.
-const ROLE_CAPS = new Set(["write", "shell"]);
-const INVARIANT_KINDS = new Set(["diff-threshold"]);
-const INVARIANT_METRICS = new Set(["net_lines_added"]);
+// Defaults inexcepcionables de karajan-code: los ficheros del supervisor
+// (antes hardcodeados en el PRETOOL del Sentinel — PL-B). Misma semántica
+// textual: nombrarlos deniega, con o sin root, y la policy no los debilita.
+export const SUPERVISOR_DEFAULTS = [
+  {
+    id: "defaults.supervisor.write",
+    pattern: /\.claude\/settings\.json\b|\.karajan\/(hooks|harness)\//,
+    message: "nombra ficheros del supervisor — solo el humano los modifica, fuera de la sesión",
+  },
+];
+
+// Tools del harness: mapeo acción → capability del kernel. Registro cerrado
+// (fallo de solomon: lo desconocido no se permite a un rol DECLARADO).
 const WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
-// Registro de tools conocidas (fallo de solomon: lo desconocido no se
-// permite a un rol DECLARADO — crece por PR consciente).
 const READONLY_TOOLS = new Set(["Read", "Grep", "Glob", "LS", "WebFetch", "WebSearch"]);
-export const DEFAULT_POLICY = Object.freeze({ version: 1, roles: {}, invariants: [] });
+
+export const DEFAULT_POLICY = KERNEL_DEFAULT_POLICY;
 
 function defaultReadFile(projectDir) {
   try {
@@ -34,7 +49,7 @@ function defaultReadFile(projectDir) {
 
 /**
  * @returns {{policy: object, errors: string[]}} errors non-empty ⇒ the file
- * declares something this engine cannot enforce — callers must surface it.
+ * declares something the engine cannot enforce — callers must surface it.
  */
 export function loadPolicy({ projectDir = process.cwd(), deps = {} } = {}) {
   const { readFile = defaultReadFile } = deps;
@@ -42,207 +57,12 @@ export function loadPolicy({ projectDir = process.cwd(), deps = {} } = {}) {
   try {
     raw = readFile(projectDir);
   } catch (err) {
-    return { policy: DEFAULT_POLICY, errors: [`policy.yml: ilegible (${err.code || err.message}) — presente pero no leible NO es "sin policy"`] };
-  }
-  if (raw == null) return { policy: DEFAULT_POLICY, errors: [] };
-
-  const errors = [];
-  let doc;
-  try {
-    doc = yaml.load(raw) || {};
-  } catch (err) {
-    return { policy: DEFAULT_POLICY, errors: [`policy.yml: YAML invalido — ${err.message}`] };
-  }
-  if (typeof doc !== "object" || Array.isArray(doc)) {
-    return { policy: DEFAULT_POLICY, errors: ["policy.yml: la raiz debe ser un objeto"] };
-  }
-  if (doc.version !== 1) {
-    errors.push(`policy.yml: version "${doc.version}" no soportada — este motor habla version 1`);
-  }
-  const roles = doc.roles ?? {};
-  if (typeof roles !== "object" || roles === null || Array.isArray(roles)) {
-    errors.push("policy.yml: roles debe ser un objeto");
-  } else {
-    validateRoles(roles, errors);
-  }
-  const invs = doc.invariants ?? [];
-  if (Array.isArray(invs)) {
-    for (const inv of invs) {
-      if (!INVARIANT_KINDS.has(inv?.kind)) {
-        errors.push(`policy.yml: invariant "${inv?.id}" con kind "${inv?.kind}" no existe en el vocabulario v1`);
-      } else if (!INVARIANT_METRICS.has(inv?.metric) || !Number.isFinite(inv?.max) || typeof inv?.id !== "string") {
-        errors.push(`policy.yml: invariant "${inv?.id}" requiere id string, metric (${[...INVARIANT_METRICS].join(", ")}) y max numérico`);
-      }
-    }
-  } else {
-    errors.push("policy.yml: invariants debe ser una lista");
-  }
-  return { policy: { roles: {}, invariants: [], ...doc }, errors };
-}
-
-function validateRoles(roles, errors) {
-  for (const [role, caps] of Object.entries(roles)) {
-    for (const [cap, spec] of Object.entries(caps || {})) {
-      if (!ROLE_CAPS.has(cap)) {
-        errors.push(`policy.yml: roles.${role}.${cap} no existe en el vocabulario (v1: ${[...ROLE_CAPS].join(", ")})`);
-        continue;
-      }
-      if (typeof spec !== "object" || spec === null || Array.isArray(spec)) {
-        errors.push(`policy.yml: roles.${role}.${cap} debe ser un objeto {allow, deny}`);
-        continue;
-      }
-      for (const key of Object.keys(spec)) {
-        if (key !== "allow" && key !== "deny") {
-          errors.push(`policy.yml: roles.${role}.${cap}.${key} no existe en el vocabulario (v1: allow, deny)`);
-        }
-      }
-      for (const list of ["allow", "deny"]) {
-        const v = spec?.[list];
-        if (v !== undefined && (!Array.isArray(v) || v.some((g) => typeof g !== "string"))) {
-          errors.push(`policy.yml: roles.${role}.${cap}.${list} debe ser una lista de strings (glob)`);
-        }
-      }
-    }
-  }
-}
-
-const deny = (rule_id, reason) => ({ decision: "deny", rule_id, reason });
-const ALLOW = Object.freeze({ decision: "allow" });
-
-// Normaliza el destino a ruta RELATIVA canónica: absolutas se relativizan
-// contra root (sin root ⇒ null), y `..`/escapes ⇒ null (reviewer catch:
-// src/../.env no puede esquivar los globs, ni una absoluta salirse del root).
-function normalizeTarget(filePath, root) {
-  let p = String(filePath).replaceAll("\\", "/");
-  if (isAbsolute(p)) {
-    if (!root) return null;
-    p = relative(root, p).replaceAll("\\", "/");
+    return {
+      policy: { ...KERNEL_DEFAULT_POLICY, defaults: SUPERVISOR_DEFAULTS },
+      errors: [`policy.yml: ilegible (${err.code || err.message}) — presente pero no leible NO es "sin policy"`],
+    };
   }
-  p = posix.normalize(p).replace(/^\.\//, "");
-  return p.startsWith("..") || isAbsolute(p) ? null : p;
-}
-
-function evalWrite(policy, role, filePath, root) {
-  const write = policy.roles?.[role]?.write;
-  if (!write) return ALLOW;
-  // Rol restringido + destino ausente/no-canonizable = no verificable ⇒ deny
-  // (reviewer catches: tool call malformado, traversal, absoluta sin root).
-  const p = filePath ? normalizeTarget(filePath, root) : null;
-  if (p == null) return deny(`roles.${role}.write`, `destino "${filePath ?? ""}" no verificable contra la policy del rol ${role}`);
-  if (matchesAny(p, write.deny)) {
-    return deny(`roles.${role}.write.deny`, `${p} esta denegado para el rol ${role}`);
-  }
-  if (Array.isArray(write.allow) && !matchesAny(p, write.allow)) {
-    return deny(`roles.${role}.write.allow`, `${p} esta fuera de la allow-list de escritura del rol ${role}`);
-  }
-  return ALLOW;
-}
-
-// Launchers y asignaciones de entorno se PELAN antes de casar patrones
-// (reviewer catch: "sudo git push" o "FOO=1 git add -A" no esquivan la
-// regla del subcomando real); capas excesivas ⇒ opaco ⇒ deny.
-const LAUNCHER_RE = /^(sudo(\s+-\S+)*|command|nohup|time|nice(\s+-n\s*\d+)?|stdbuf\s+\S+|env)\s+|^([A-Za-z_][A-Za-z0-9_]*=\S*\s+)+/;
-function stripLaunchers(seg) {
-  let s = seg;
-  for (let i = 0; i < 5; i++) {
-    const m = s.match(LAUNCHER_RE);
-    if (!m) return s;
-    // Asignaciones que alteran QUÉ ejecutable resuelve (PATH, LD_*, GIT_*,
-    // NODE_OPTIONS) o llevan expansión son opacas — no se pelan, denegan.
-    if (/^(PATH|LD_\w*|NODE_OPTIONS|GIT_\w*)=/.test(m[0]) || m[0].includes("$")) return null;
-    s = s.slice(m[0].length);
-  }
-  return null; // sigue envuelto tras 5 capas: no verificable
-}
-
-// Tokenizador consciente de comillas: separa segmentos SOLO por operadores
-// no entrecomillados (reviewer catch: un ';' dentro de un mensaje no es
-// separador) y canonicaliza tokens sin comillas a la vez. Cualquier
-// construcción que ejecute o redirija texto opaco al análisis — escapes,
-// expansión ($ salvo entre comillas simples), sustitución/backticks,
-// redirecciones, backgrounding, comillas sin cerrar — devuelve null.
-function parseCommand(cmd) {
-  const segs = [];
-  let toks = [];
-  let cur = "";
-  let q = null;
-  const pushTok = () => {
-    if (cur) {
-      toks.push(cur);
-      cur = "";
-    }
-  };
-  const pushSeg = () => {
-    pushTok();
-    if (toks.length > 0) {
-      segs.push(toks.join(" "));
-      toks = [];
-    }
-  };
-  const s = String(cmd);
-  for (let i = 0; i < s.length; i++) {
-    const ch = s[i];
-    if (ch === "\\" || ch === "`") return null;
-    if (ch === "$" && q !== "'") return null;
-    if (q) {
-      if (ch === q) q = null;
-      else cur += ch;
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      q = ch;
-      continue;
-    }
-    if (ch === ">" || ch === "<") return null;
-    if (ch === "&" && s[i + 1] === "&") {
-      pushSeg();
-      i++;
-      continue;
-    }
-    if (ch === "|" && s[i + 1] === "|") {
-      pushSeg();
-      i++;
-      continue;
-    }
-    if (ch === "&") return null;
-    if (ch === ";" || ch === "|" || ch === "\n") {
-      pushSeg();
-      continue;
-    }
-    if (/\s/.test(ch)) {
-      pushTok();
-      continue;
-    }
-    cur += ch;
-  }
-  if (q) return null;
-  pushSeg();
-  return segs;
-}
-
-// Envolturas que re-ejecutan texto (lección del guard del Sentinel).
-const WRAPPER_RE = /^(sh|bash|zsh|dash|ksh)\s+(-\S+\s+)*-\S*c(\s|$)|^eval\b|^xargs\b|^source\b|^\.\s/;
-
-// Deny si CUALQUIER segmento casa; con allow-list, CADA segmento debe casar.
-function evalShell(policy, role, command) {
-  const shell = policy.roles?.[role]?.shell;
-  if (!shell) return ALLOW;
-  if (!command) return deny(`roles.${role}.shell`, `comando ausente — no verificable para el rol ${role}`);
-  const segs = parseCommand(command);
-  if (segs == null) {
-    return deny(`roles.${role}.shell`, "construcciones opacas (escapes, expansión, sustitución, redirecciones, backgrounding o comillas sin cerrar) — no verificable");
-  }
-  for (const raw of segs) {
-    const seg = stripLaunchers(raw);
-    if (seg == null) return deny(`roles.${role}.shell`, `el segmento "${raw}" no es canonicalizable — no verificable`);
-    if (WRAPPER_RE.test(seg)) return deny(`roles.${role}.shell`, `el segmento "${seg}" re-ejecuta texto (envoltura/eval) — no verificable`);
-    const hit = Array.isArray(shell.deny) && shell.deny.find((p) => commandPatternToRegExp(p).test(seg));
-    if (hit) return deny(`roles.${role}.shell.deny`, `el segmento "${seg}" casa con el patrón denegado "${hit}"`);
-    if (Array.isArray(shell.allow) && !shell.allow.some((p) => commandPatternToRegExp(p).test(seg))) {
-      return deny(`roles.${role}.shell.allow`, `el segmento "${seg}" está fuera de la allow-list de shell del rol ${role}`);
-    }
-  }
-  return ALLOW;
+  return parsePolicy(raw, { defaults: SUPERVISOR_DEFAULTS });
 }
 
 /** One tool call against the policy. `root` permite evaluar file_path
@@ -251,26 +71,12 @@ function evalShell(policy, role, command) {
 export function evalToolCall(policy, { role = "coder", tool, input = {}, root = null }) {
   if (WRITE_TOOLS.has(tool)) return evalWrite(policy, role, input.file_path || input.notebook_path, root);
   if (tool === "Bash") return evalShell(policy, role, input.command);
-  if (READONLY_TOOLS.has(tool) || !policy.roles?.[role]) return ALLOW;
-  return deny(`roles.${role}.tools`, `tool "${tool}" fuera del registro de la policy — no verificable para el rol declarado ${role}`);
+  if (READONLY_TOOLS.has(tool) || !policy.roles?.[role]) return ALLOW_VERDICT;
+  return denyVerdict(`roles.${role}.tools`, `tool "${tool}" fuera del registro de la policy — no verificable para el rol declarado ${role}`);
 }
 
-/** El gate del RESULTADO: ficheros del diff + métricas contra rol e invariantes. */
-export function checkStagedDiff(policy, { role = "coder", files = [], netLinesAdded = null } = {}) {
-  const violations = [];
-  for (const f of files) {
-    const r = evalWrite(policy, role, f);
-    if (r.decision === "deny") violations.push({ rule_id: r.rule_id, reason: r.reason, file: f });
-  }
-  for (const inv of policy.invariants || []) {
-    if (inv.kind !== "diff-threshold" || inv.metric !== "net_lines_added") continue;
-    if (!Number.isFinite(netLinesAdded)) {
-      // Métrica ausente con invariante declarado = no verificable, jamás un
-      // pase silencioso (reviewer catch).
-      violations.push({ rule_id: inv.id, reason: "net_lines_added no disponible — el invariante no es verificable sin la métrica" });
-    } else if (netLinesAdded > inv.max) {
-      violations.push({ rule_id: inv.id, reason: `net_lines_added=${netLinesAdded} supera el máximo ${inv.max}` });
-    }
-  }
-  return violations;
+/** El gate del RESULTADO en este dominio: los artefactos son los ficheros
+ *  del diff staged y la métrica sale de numstat. */
+export function checkStagedDiff(policy, facts) {
+  return checkArtifacts(policy, facts);
 }

package/src/policy/exceptions.js

@@ -0,0 +1,60 @@
+/**
+ * Adaptador de excepciones de karajan-code (GOV-A, KJC-TSK-0745). El
+ * registro vive en el kernel (@karajan-family/governance); aquí solo lo que es de
+ * este dominio: la identidad (git user + usuario del SO — DECLARADA, no
+ * autenticada) y el destino append-only `.karajan/policy-exceptions.jsonl`.
+ */
+import { appendFileSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { userInfo } from "node:os";
+import { spawnSync } from "node:child_process";
+import { recordPolicyException as kernelRecord } from "@karajan-family/governance";
+
+function defaultIdentity(projectDir) {
+  const git = (args) => spawnSync("git", ["-C", projectDir, "config", ...args], { encoding: "utf8" }).stdout?.trim() || null;
+  // grade DECLARADA: git+os es atribución, no autenticación — el registro
+  // no debe venderse como más evidencia de la que es (GOV-B).
+  return { git: `${git(["user.name"]) ?? "?"} <${git(["user.email"]) ?? "?"}>`, os: userInfo().username, grade: "declarada" };
+}
+
+/**
+ * Standing exceptions del dominio code: las permanentes del jsonl. Parse
+ * TOLERANTE — una línea corrupta se descarta CONTÁNDOLA (el gate la
+ * reporta), jamás rompe la evaluación. Las puntuales no dan standing.
+ * @returns {{standing: object[], discarded: number}}
+ */
+export function loadStandingExceptions(projectDir) {
+  let raw;
+  try {
+    raw = readFileSync(join(projectDir, ".karajan", "policy-exceptions.jsonl"), "utf8");
+  } catch {
+    return { standing: [], discarded: 0 };
+  }
+  const standing = [];
+  let discarded = 0;
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const rec = JSON.parse(line);
+      // JSON válido pero no-objeto (null, número…) es tan corrupto como el
+      // que no parsea: se descarta contando (catch de codex, explícito).
+      if (typeof rec !== "object" || rec === null) discarded += 1;
+      else if (rec.scopeKind === "permanente") standing.push(rec);
+    } catch {
+      discarded += 1;
+    }
+  }
+  return { standing, discarded };
+}
+
+function defaultAppend(projectDir, line) {
+  const dir = join(projectDir, ".karajan");
+  mkdirSync(dir, { recursive: true });
+  appendFileSync(join(dir, "policy-exceptions.jsonl"), line, "utf8");
+}
+
+/** @returns {object} the recorded entry (with ts + who resolved). */
+export function recordPolicyException({ projectDir, entry, deps = {} }) {
+  const { append = defaultAppend, identity = defaultIdentity } = deps;
+  return kernelRecord({ projectDir, entry, deps: { append, identity } });
+}

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/review/policy-gate.js

@@ -0,0 +1,26 @@
+/**
+ * Adaptador del gate de policy en el flujo de review de karajan-code
+ * (GOV-A, KJC-TSK-0745). La decisión warn/deny/inexcepcionable/excepción
+ * vive en el kernel (@karajan-family/governance); aquí solo el dominio: la
+ * excepción se pide con KJ_ALLOW_POLICY=1 + KJ_POLICY_REASON, y el
+ * artefacto de este dominio es el diff staged — por eso el alcance
+ * registrado dice "este diff exacto".
+ */
+import { evaluateGate } from "@karajan-family/governance";
+
+/**
+ * @returns {{ok: boolean, invalid?: boolean, warns: object[], denials: object[], exempted: object[]}}
+ */
+export function evaluatePolicyGate({
+  policy, errors = [], role = "coder", files = [], netLinesAdded = null,
+  diffHashValue = null, env = process.env, recordException = () => {},
+  standingExceptions = [], now = new Date(),
+}) {
+  return evaluateGate({
+    policy, errors, role, files, netLinesAdded,
+    artifactHash: diffHashValue,
+    exemption: { requested: env.KJ_ALLOW_POLICY === "1", justification: env.KJ_POLICY_REASON, hint: 'KJ_POLICY_REASON="por qué"' },
+    recordException: (entry) => recordException({ ...entry, scope: "este diff exacto" }),
+    standingExceptions, now,
+  });
+}

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

package/src/policy/glob.js

@@ -1,44 +0,0 @@
-// glob → RegExp anclada — primitivo de la policy layer (PL-A, KJC-TSK-0733).
-// Semántica: doble asterisco cruza directorios; doble asterisco + barra es
-// prefijo de directorio OPCIONAL (así "**" "/*.env*" casa también con .env
-// en la raíz); "*" no sale de su segmento; "?" es un carácter. Sin
-// dependencias: el vocabulario es pequeño a propósito — una lib general
-// traería semánticas que la policy no declara.
-export function globToRegExp(glob) {
-  let re = "";
-  const s = String(glob);
-  let i = 0;
-  while (i < s.length) {
-    const c = s[i];
-    if (c === "*" && s[i + 1] === "*" && s[i + 2] === "/") {
-      re += "(?:.*/)?";
-      i += 3;
-    } else if (c === "*" && s[i + 1] === "*") {
-      re += ".*";
-      i += 2;
-    } else if (c === "*") {
-      re += "[^/]*";
-      i += 1;
-    } else if (c === "?") {
-      re += "[^/]";
-      i += 1;
-    } else {
-      re += c.replaceAll(/[.+^${}()|[\]\\]/g, String.raw`\$&`);
-      i += 1;
-    }
-  }
-  return new RegExp(`^${re}$`);
-}
-
-/** true si `value` casa con ALGUNO de los globs (lista no-array ⇒ false). */
-export const matchesAny = (value, globs) =>
-  Array.isArray(globs) && globs.some((g) => globToRegExp(g).test(value));
-
-/** Patrón de comando shell → RegExp anclada al INICIO: `*` = cualquier cosa
- *  (los comandos no son rutas — sin semántica de segmentos). */
-export function commandPatternToRegExp(pattern) {
-  const re = String(pattern)
-    .replaceAll(/[.+^${}()|[\]\\?]/g, String.raw`\$&`)
-    .replaceAll("*", ".*");
-  return new RegExp(`^${re}`);
-}