karajan-code 4.70.4 → 5.0.1

package/src/commands/policy.js

@@ -14,6 +14,7 @@ import { join } from "node:path";
 import { checkStagedDiff, evalToolCall, loadPolicy } from "../policy/engine.js";
 import { liftSealedSupervisorViolations } from "../policy/supervisor-verify.js";
 import { rosterViolation } from "../policy/roster-check.js";
+import { adrNumberViolation } from "../policy/adr-number-check.js";
 import { loadExceptionRecords, loadGlobalExceptionRecords, loadStandingExceptions, recordPolicyException } from "../policy/exceptions.js";
 import { buildPolicyReport } from "../policy/report.js";
 import { budgetedNet } from "../review/loc-budget.js";
@@ -43,6 +44,12 @@ async function stagedFacts(projectDir, gitFn, range = null) {
   return { files, netLinesAdded: net };
 }
 
+/**
+ * KJC-TSK-1257: one function per subcommand; anything else is `check`. Each one
+ * receives the loaded policy and keeps the exit codes it always had.
+ */
+const ACTIONS = { anchor: anchorAction, grant: grantAction, report: reportAction, eval: evalAction, seal: sealAction };
+
 export async function policyCommand({ action, config = {}, flags = {}, logger = console, deps = {} }) {
   const projectDir = config?.projectDir || process.cwd();
   const { policy, errors } = loadPolicy({ projectDir, deps });
@@ -51,208 +58,223 @@ export async function policyCommand({ action, config = {}, flags = {}, logger =
     logger.error?.("policy: el fichero declara lo que el motor no puede aplicar — corrígelo (una regla que miente es peor que ninguna)");
     return 1;
   }
+  // Own keys only: an action named like an Object.prototype member ("toString") runs check, as before.
+  const run = Object.hasOwn(ACTIONS, action ?? "") ? ACTIONS[action] : checkAction;
+  return run({ projectDir, policy, errors, flags, logger, deps });
+}
 
-  // GOV-C2 (KJC-TSK-0749): anclaje temporal sin blockchain — verificar la
-  // cadena ENTERA y sellar su head-hash en un fichero TRACKEADO por git:
-  // reescribir el log de ayer exige reescribir el repo de ayer. Un anchor
-  // previo con más entradas que el log actual = truncado ⇒ no se re-sella.
-  if (action === "anchor") {
-    let raw;
-    try {
-      raw = readFileSync(join(projectDir, ".karajan", "policy-decisions.jsonl"), "utf8");
-    } catch {
-      logger.info?.("policy anchor: sin decisiones que anclar — el log nace con el primer deny/excepción/commit-allow");
-      return 0;
-    }
-    const lines = raw.split("\n").filter((l) => l.trim());
-    // Fichero vacío o solo whitespace = sin decisiones (catch de codex:
-    // lines.at(-1) undefined reventaba el hash en vez de salir limpio).
-    if (lines.length === 0) {
-      logger.info?.("policy anchor: sin decisiones que anclar — el log nace con el primer deny/excepción/commit-allow");
-      return 0;
-    }
-    const chain = verifyDecisionChain(lines);
-    if (!chain.ok) {
-      logger.error?.(`✗ policy anchor: cadena rota en la entrada ${chain.at} (${chain.reason}) — el log ha sido manipulado; NO se sella`);
-      return 1;
-    }
-    const anchorFile = join(projectDir, ".karajan", "policy-anchor.json");
-    try {
-      const prev = JSON.parse(readFileSync(anchorFile, "utf8"));
-      if (Number.isFinite(prev.length) && prev.length > chain.length) {
-        logger.error?.(`✗ policy anchor: el log retrocede (anchor previo=${prev.length} entradas, actual=${chain.length}) — truncado tras el último sello; NO se re-sella`);
-        return 1;
-      }
-    } catch { /* sin anchor previo (o ilegible): primer sello */ }
-    const head = createHash("sha256").update(lines.at(-1), "utf8").digest("hex");
-    writeFileSync(anchorFile, `${JSON.stringify({ head, length: chain.length, ts: new Date().toISOString() }, null, 2)}\n`, "utf8");
-    logger.info?.(`✓ policy anchor: cadena íntegra (${chain.length} decisiones) — head ${head.slice(0, 12)} sellado en .karajan/policy-anchor.json; committéalo para anclarlo en la historia de git`);
+const NO_DECISIONS = "policy anchor: sin decisiones que anclar — el log nace con el primer deny/excepción/commit-allow";
+
+// GOV-C2 (KJC-TSK-0749): anclaje temporal sin blockchain — verificar la
+// cadena ENTERA y sellar su head-hash en un fichero TRACKEADO por git:
+// reescribir el log de ayer exige reescribir el repo de ayer. Un anchor
+// previo con más entradas que el log actual = truncado ⇒ no se re-sella.
+function anchorAction({ projectDir, logger }) {
+  let raw;
+  try {
+    raw = readFileSync(join(projectDir, ".karajan", "policy-decisions.jsonl"), "utf8");
+  } catch {
+    logger.info?.(NO_DECISIONS);
     return 0;
   }
-
-  // GOV-B (KJC-TSK-0746): conceder una excepción PERMANENTE con el modelo
-  // probatorio completo — quién (identidad), regla exacta, justificación en
-  // el momento y caducidad obligatoria. Los defaults.* del consumidor son
-  // inexcepcionables: no se conceden ni desde aquí.
-  if (action === "grant") {
-    const { rule, until, reason } = flags;
-    if (!rule || !until || !reason?.trim()) {
-      logger.error?.("policy grant: --rule, --until (ISO) y --reason son obligatorios — una excepción sin quién/por qué/hasta cuándo no es una excepción, es un agujero");
-      return 1;
-    }
-    // Inexcepcionable = inexcepcionable TAMBIÉN al conceder (catch de codex):
-    // defaults.*, cualquier cap con class security, y una policy inválida
-    // (sin policy legible no se puede probar que la regla NO es security).
-    const m = /^roles\.([^.]+)\.(write|shell)/.exec(rule);
-    if (rule.startsWith("defaults.") || errors.length > 0 || (m && policy.roles?.[m[1]]?.[m[2]]?.class === "security")) {
-      logger.error?.(`policy grant: "${rule}" es inexcepcionable (default del proyecto o clase security) o la policy no es verificable — no se concede, ni con razón`);
+  const lines = raw.split("\n").filter((l) => l.trim());
+  // Fichero vacío o solo whitespace = sin decisiones (catch de codex:
+  // lines.at(-1) undefined reventaba el hash en vez de salir limpio).
+  if (lines.length === 0) {
+    logger.info?.(NO_DECISIONS);
+    return 0;
+  }
+  const chain = verifyDecisionChain(lines);
+  if (!chain.ok) {
+    logger.error?.(`✗ policy anchor: cadena rota en la entrada ${chain.at} (${chain.reason}) — el log ha sido manipulado; NO se sella`);
+    return 1;
+  }
+  const anchorFile = join(projectDir, ".karajan", "policy-anchor.json");
+  try {
+    const prev = JSON.parse(readFileSync(anchorFile, "utf8"));
+    if (Number.isFinite(prev.length) && prev.length > chain.length) {
+      logger.error?.(`✗ policy anchor: el log retrocede (anchor previo=${prev.length} entradas, actual=${chain.length}) — truncado tras el último sello; NO se re-sella`);
       return 1;
     }
-    try {
-      // GOV-E (KJC-TSK-0750, idea del lector): la renovación es SEÑAL — una
-      // regla re-concedida N veces es la política real pidiendo que la
-      // cambien por su cauce. Se cuenta contra TODAS las permanentes previas
-      // (vencidas incluidas: precisamente esas son la sedimentación).
-      // KJC-TSK-0813: --global escribe en ~/.karajan (todos los proyectos de
-      // la máquina). El contador de renovaciones cuenta sobre la FUSIÓN.
-      const scope = flags.global ? "global" : "project";
-      const previous = loadStandingExceptions(projectDir, { home: deps.home }).standing.filter((e) => e.rule_id === rule).length;
-      const rec = recordPolicyException({
-        projectDir, scope, deps: { home: deps.home },
-        entry: { rule_id: rule, justification: reason.trim(), scopeKind: "permanente", expiresAt: until },
-      });
-      const ambit = scope === "global" ? " [ámbito global — todos tus proyectos de esta máquina]" : "";
-      logger.info?.(`✓ excepción permanente registrada${ambit}: [${rec.rule_id}] hasta ${rec.expiresAt} — concedida por ${rec.who?.git ?? "?"} (${rec.who?.grade ?? "?"})`);
-      if (previous >= 1) {
-        logger.warn?.(`⚠ ${previous + 1}ª concesión sobre esta regla — una excepción que se renueva ya no es una excepción: considera cambiar la política por su cauce (PR a .karajan/policy.yml)`);
-      }
-      return 0;
-    } catch (err) {
-      logger.error?.(`policy grant: ${err.message}`);
-      return 1;
+  } catch { /* sin anchor previo (o ilegible): primer sello */ }
+  const head = createHash("sha256").update(lines.at(-1), "utf8").digest("hex");
+  writeFileSync(anchorFile, `${JSON.stringify({ head, length: chain.length, ts: new Date().toISOString() }, null, 2)}\n`, "utf8");
+  logger.info?.(`✓ policy anchor: cadena íntegra (${chain.length} decisiones) — head ${head.slice(0, 12)} sellado en .karajan/policy-anchor.json; committéalo para anclarlo en la historia de git`);
+  return 0;
+}
+
+// Inexcepcionable = inexcepcionable TAMBIÉN al conceder (catch de codex):
+// defaults.*, cualquier cap con class security, y una policy inválida
+// (sin policy legible no se puede probar que la regla NO es security).
+function isUnexemptable(rule, { policy, errors }) {
+  const m = /^roles\.([^.]+)\.(write|shell)/.exec(rule);
+  return rule.startsWith("defaults.") || errors.length > 0 || Boolean(m && policy.roles?.[m[1]]?.[m[2]]?.class === "security");
+}
+
+// GOV-B (KJC-TSK-0746): conceder una excepción PERMANENTE con el modelo
+// probatorio completo — quién (identidad), regla exacta, justificación en
+// el momento y caducidad obligatoria. Los defaults.* del consumidor son
+// inexcepcionables: no se conceden ni desde aquí.
+function grantAction({ projectDir, policy, errors, flags, logger, deps }) {
+  const { rule, until, reason } = flags;
+  if (!rule || !until || !reason?.trim()) {
+    logger.error?.("policy grant: --rule, --until (ISO) y --reason son obligatorios — una excepción sin quién/por qué/hasta cuándo no es una excepción, es un agujero");
+    return 1;
+  }
+  if (isUnexemptable(rule, { policy, errors })) {
+    logger.error?.(`policy grant: "${rule}" es inexcepcionable (default del proyecto o clase security) o la policy no es verificable — no se concede, ni con razón`);
+    return 1;
+  }
+  try {
+    // GOV-E (KJC-TSK-0750, idea del lector): la renovación es SEÑAL — una
+    // regla re-concedida N veces es la política real pidiendo que la
+    // cambien por su cauce. Se cuenta contra TODAS las permanentes previas
+    // (vencidas incluidas: precisamente esas son la sedimentación).
+    // KJC-TSK-0813: --global escribe en ~/.karajan (todos los proyectos de
+    // la máquina). El contador de renovaciones cuenta sobre la FUSIÓN.
+    const scope = flags.global ? "global" : "project";
+    const previous = loadStandingExceptions(projectDir, { home: deps.home }).standing.filter((e) => e.rule_id === rule).length;
+    const rec = recordPolicyException({
+      projectDir, scope, deps: { home: deps.home },
+      entry: { rule_id: rule, justification: reason.trim(), scopeKind: "permanente", expiresAt: until },
+    });
+    const ambit = scope === "global" ? " [ámbito global — todos tus proyectos de esta máquina]" : "";
+    logger.info?.(`✓ excepción permanente registrada${ambit}: [${rec.rule_id}] hasta ${rec.expiresAt} — concedida por ${rec.who?.git ?? "?"} (${rec.who?.grade ?? "?"})`);
+    if (previous >= 1) {
+      logger.warn?.(`⚠ ${previous + 1}ª concesión sobre esta regla — una excepción que se renueva ya no es una excepción: considera cambiar la política por su cauce (PR a .karajan/policy.yml)`);
     }
+    return 0;
+  } catch (err) {
+    logger.error?.(`policy grant: ${err.message}`);
+    return 1;
   }
+}
 
-  // PL-E (KJC-TSK-0767): el informe — evidencia de proceso determinista
-  // sobre los dos jsonl. Cadena rota = exit 1: un informe sobre un log
-  // manipulado no es un informe. El resto es informativo (exit 0).
-  if (action === "report") {
-    let decisionLines = [];
-    try {
-      decisionLines = readFileSync(join(projectDir, ".karajan", "policy-decisions.jsonl"), "utf8").split("\n").filter((l) => l.trim());
-    } catch { /* sin decisiones aún: el informe lo dice con ceros */ }
-    // KJC-TSK-0813 (AC3): el informe cubre TAMBIÉN el almacén global — cada
-    // registro llega con su origin FÍSICO estampado por la carga.
-    const proj = loadExceptionRecords(projectDir);
-    const glob = loadGlobalExceptionRecords({ home: deps.home });
-    const exc = { records: [...proj.records, ...glob.records], discarded: proj.discarded + glob.discarded };
-    const soonDays = Number(flags.soon ?? 7);
-    const report = buildPolicyReport({ decisionLines, exceptionRecords: exc.records, policy, soonDays: Number.isFinite(soonDays) ? soonDays : 7 });
-    if (flags.json) {
-      logger.info?.(JSON.stringify({ ...report, exceptions_discarded: exc.discarded }));
-      return report.chain.ok ? 0 : 1;
-    }
-    const { chain, decisions: d, rules, grants: g } = report;
-    if (chain.ok) logger.info?.(`✓ decision log: cadena íntegra (${chain.length} decisiones)`);
-    else logger.error?.(`✗ decision log: cadena rota en la entrada ${chain.at} (${chain.reason}) — el log ha sido manipulado`);
-    if (d.discarded > 0 || exc.discarded > 0) logger.warn?.(`⚠ líneas corruptas descartadas: ${d.discarded} en decisiones, ${exc.discarded} en excepciones`);
-    const cps = Object.entries(d.chokepoints).map(([k, v]) => `${k} ${v}`).join(" · ") || "ninguno";
-    logger.info?.(`decisiones: allow ${d.allow} · deny ${d.deny} · exempt ${d.exempt} · abiertas ${d.open} (chokepoints: ${cps})`);
-    logger.info?.(rules.length > 0 ? "reglas (ordenadas por fricción):" : "reglas: ninguna ha avisado ni denegado todavía");
-    for (const r of rules) {
-      const meta = [r.enforcement && `enforcement=${r.enforcement}`, r.class && `class=${r.class}`].filter(Boolean).join(" ");
-      logger.info?.(`  [${r.rule_id}] ${meta} — warn ${r.warns} · deny ${r.denies} · exempt ${r.exempts} · abiertas ${r.open}`);
-    }
-    // Con 0 globales el resumen queda EXACTAMENTE como siempre (hay consumidores de texto).
-    const globals = g.alive.filter((e) => e.origin === "global").length;
-    logger.info?.(`concesiones: vivas ${g.alive.length} (${globals > 0 ? `${globals} globales, ` : ""}próximas a vencer ${g.soon.length}) · vencidas ${g.expired.length} · puntuales ${g.point}`);
-    for (const e of g.alive) logger.info?.(`  [${e.rule_id}] hasta ${e.expiresAt}${e.origin === "global" ? " [global]" : ""} — ${e.who?.git ?? "?"}: ${e.justification ?? "sin justificación"}`);
-    logger.info?.(report.signals.length > 0 ? "señales:" : "señales: ninguna");
-    for (const s of report.signals) logger.warn?.(`  ⚠ ${s}`);
-    return chain.ok ? 0 : 1;
+// PL-E (KJC-TSK-0767): el informe — evidencia de proceso determinista
+// sobre los dos jsonl. Cadena rota = exit 1: un informe sobre un log
+// manipulado no es un informe. El resto es informativo (exit 0).
+function reportAction({ projectDir, policy, flags, logger, deps }) {
+  let decisionLines = [];
+  try {
+    decisionLines = readFileSync(join(projectDir, ".karajan", "policy-decisions.jsonl"), "utf8").split("\n").filter((l) => l.trim());
+  } catch { /* sin decisiones aún: el informe lo dice con ceros */ }
+  // KJC-TSK-0813 (AC3): el informe cubre TAMBIÉN el almacén global — cada
+  // registro llega con su origin FÍSICO estampado por la carga.
+  const proj = loadExceptionRecords(projectDir);
+  const glob = loadGlobalExceptionRecords({ home: deps.home });
+  const exc = { records: [...proj.records, ...glob.records], discarded: proj.discarded + glob.discarded };
+  const soonDays = Number(flags.soon ?? 7);
+  const report = buildPolicyReport({ decisionLines, exceptionRecords: exc.records, policy, soonDays: Number.isFinite(soonDays) ? soonDays : 7 });
+  if (flags.json) logger.info?.(JSON.stringify({ ...report, exceptions_discarded: exc.discarded }));
+  else printReport(report, exc.discarded, logger);
+  return report.chain.ok ? 0 : 1;
+}
+
+function printReport(report, excDiscarded, logger) {
+  const { chain, decisions: d, rules, grants: g } = report;
+  if (chain.ok) logger.info?.(`✓ decision log: cadena íntegra (${chain.length} decisiones)`);
+  else logger.error?.(`✗ decision log: cadena rota en la entrada ${chain.at} (${chain.reason}) — el log ha sido manipulado`);
+  if (d.discarded > 0 || excDiscarded > 0) logger.warn?.(`⚠ líneas corruptas descartadas: ${d.discarded} en decisiones, ${excDiscarded} en excepciones`);
+  const cps = Object.entries(d.chokepoints).map(([k, v]) => `${k} ${v}`).join(" · ") || "ninguno";
+  logger.info?.(`decisiones: allow ${d.allow} · deny ${d.deny} · exempt ${d.exempt} · abiertas ${d.open} (chokepoints: ${cps})`);
+  printRules(rules, logger);
+  printGrants(g, logger);
+  logger.info?.(report.signals.length > 0 ? "señales:" : "señales: ninguna");
+  for (const s of report.signals) logger.warn?.(`  ⚠ ${s}`);
+}
+
+function printRules(rules, logger) {
+  logger.info?.(rules.length > 0 ? "reglas (ordenadas por fricción):" : "reglas: ninguna ha avisado ni denegado todavía");
+  for (const r of rules) {
+    const meta = [r.enforcement && `enforcement=${r.enforcement}`, r.class && `class=${r.class}`].filter(Boolean).join(" ");
+    logger.info?.(`  [${r.rule_id}] ${meta} — warn ${r.warns} · deny ${r.denies} · exempt ${r.exempts} · abiertas ${r.open}`);
   }
+}
 
-  if (action === "eval") {
-    let input;
-    try {
-      input = flags.input ? JSON.parse(flags.input) : {};
-    } catch {
-      logger.error?.("policy eval: --input debe ser JSON válido");
-      return 1;
-    }
-    const role = flags.role || "coder";
-    const verdict = evalToolCall(policy, { role, tool: flags.tool, input, root: projectDir });
-    const strictDeny = verdict.decision === "deny" && Boolean(flags.strict);
-    // GOV-F (KJC-TSK-0768): el deny de tool-time (contrato --strict del
-    // Sentinel) entra en la MISMA cadena que las decisiones de commit — con
-    // el hash del tool_input como artefacto. Un sello fallido se dice ANTES
-    // del veredicto (la última línea de stdout sigue siendo el JSON que el
-    // Sentinel parsea) y el deny se mantiene: jamás un allow por fallo de registro.
-    if (strictDeny) {
-      try {
-        recordGateDecision(projectDir, {
-          decision: "deny", chokepoint: "tool", rule_ids: [verdict.rule_id], role, tool: flags.tool ?? null,
-          ...(verdict.class ? { class: verdict.class } : {}),
-          // El hash es del payload CRUDO recibido (--input tal cual), no de su
-          // re-serialización: el mismo JSON con otro orden o espacios es otro
-          // artefacto para la auditoría (catch de codex).
-          policy_hash: policyFileHash(projectDir), artifact_hash: createHash("sha256").update(String(flags.input ?? ""), "utf8").digest("hex"),
-        });
-      } catch (err) {
-        logger.error?.(`policy eval: deny NO sellado en el decision log (${err.message}) — el deny se mantiene`);
-      }
-    }
-    logger.info?.(JSON.stringify(verdict));
-    return strictDeny ? 2 : 0;
+function printGrants(g, logger) {
+  // Con 0 globales el resumen queda EXACTAMENTE como siempre (hay consumidores de texto).
+  const globals = g.alive.filter((e) => e.origin === "global").length;
+  const globalNote = globals > 0 ? `${globals} globales, ` : "";
+  logger.info?.(`concesiones: vivas ${g.alive.length} (${globalNote}próximas a vencer ${g.soon.length}) · vencidas ${g.expired.length} · puntuales ${g.point}`);
+  for (const e of g.alive) {
+    const origin = e.origin === "global" ? " [global]" : "";
+    logger.info?.(`  [${e.rule_id}] hasta ${e.expiresAt}${origin} — ${e.who?.git ?? "?"}: ${e.justification ?? "sin justificación"}`);
   }
+}
 
-  // GOV-F (KJC-TSK-0768): un escape KJ_ALLOW_* usado en tool-time es una
-  // excepción consciente — se sella como exempt chokepoint=tool con la
-  // identidad DECLARADA del clon (identity.local.yml), para que el informe
-  // y el anchor la vean. Lo llama el Sentinel; cualquiera puede auditarlo.
-  if (action === "seal") {
-    // KJC-TSK-0868: el mismo asiento sirve para el panel — el anfitrión escribió
-    // teniendo otro coder declarado. Mismo log encadenado, otro chokepoint.
-    if (!flags.escape && !flags.panel) {
-      logger.error?.("policy seal: --escape <KJ_ALLOW_X> o --panel <coder> es obligatorio — un asiento sin nombre no es auditable");
-      return 1;
-    }
+function evalAction({ projectDir, policy, flags, logger }) {
+  let input;
+  try {
+    input = flags.input ? JSON.parse(flags.input) : {};
+  } catch {
+    logger.error?.("policy eval: --input debe ser JSON válido");
+    return 1;
+  }
+  const role = flags.role || "coder";
+  const verdict = evalToolCall(policy, { role, tool: flags.tool, input, root: projectDir });
+  const strictDeny = verdict.decision === "deny" && Boolean(flags.strict);
+  // GOV-F (KJC-TSK-0768): el deny de tool-time (contrato --strict del
+  // Sentinel) entra en la MISMA cadena que las decisiones de commit — con
+  // el hash del tool_input como artefacto. Un sello fallido se dice ANTES
+  // del veredicto (la última línea de stdout sigue siendo el JSON que el
+  // Sentinel parsea) y el deny se mantiene: jamás un allow por fallo de registro.
+  if (strictDeny) {
     try {
-      const who = readIdentity(projectDir);
-      const rec = flags.panel
-        ? sealPanel({ projectDir, coder: flags.panel, host: flags.host ?? null, honoured: Boolean(flags.honoured) })
-        : recordGateDecision(projectDir, {
-          decision: "exempt", chokepoint: "tool", escape: flags.escape, tool: flags.tool ?? null,
-          who: who ? { gh: who.gh_user ?? null, git: who.git_email ?? null, grade: "declarada" } : null,
-          policy_hash: policyFileHash(projectDir),
-        });
-      if (rec.chokepoint === "panel") logger.info?.(`✓ panel sellado: el coder declarado es ${rec.coder} y escribió ${rec.host ?? "el anfitrión"}`);
-      else logger.info?.(`✓ escape ${rec.escape} sellado (chokepoint tool${rec.tool ? `, ${rec.tool}` : ""})`);
-      return 0;
+      recordGateDecision(projectDir, {
+        decision: "deny", chokepoint: "tool", rule_ids: [verdict.rule_id], role, tool: flags.tool ?? null,
+        ...(verdict.class ? { class: verdict.class } : {}),
+        // El hash es del payload CRUDO recibido (--input tal cual), no de su
+        // re-serialización: el mismo JSON con otro orden o espacios es otro
+        // artefacto para la auditoría (catch de codex).
+        policy_hash: policyFileHash(projectDir), artifact_hash: createHash("sha256").update(String(flags.input ?? ""), "utf8").digest("hex"),
+      });
     } catch (err) {
-      logger.error?.(`policy seal: ${err.message}`);
-      return 1;
+      logger.error?.(`policy eval: deny NO sellado en el decision log (${err.message}) — el deny se mantiene`);
     }
   }
+  logger.info?.(JSON.stringify(verdict));
+  return strictDeny ? 2 : 0;
+}
 
-  // check — staged por defecto, base...head con --range (CI). Warn salvo
-  // --strict (PL-C): con --strict, una violación enforcement=deny devuelve
-  // exit 2 nombrando la regla — el contrato merge-blocking del tier C.
-  const facts = await stagedFacts(projectDir, deps.gitFn, flags.range || null);
-  let violations = checkStagedDiff(policy, { role: flags.role || "coder", ...facts });
-  // ADR 0009 (KJC-BUG-0161): en CI la misma exención estructural que en la
-  // review — supervisor respaldado por provenance sellada + render canónico.
-  const sup = liftSealedSupervisorViolations({ projectDir, violations });
-  if (sup.lifted > 0) {
-    logger.info?.(`✓ policy: ${sup.lifted} fichero(s) de supervisor verificados contra la provenance sellada (ADR 0009)`);
-    // KJC-BUG-0212: lo que este sitio no ha podido juzgar se dice, no se calla.
-    if (sup.note) logger.info?.(`ℓ policy: ${sup.note}`);
-    violations = sup.violations;
+// GOV-F (KJC-TSK-0768): un escape KJ_ALLOW_* usado en tool-time es una
+// excepción consciente — se sella como exempt chokepoint=tool con la
+// identidad DECLARADA del clon (identity.local.yml), para que el informe
+// y el anchor la vean. Lo llama el Sentinel; cualquiera puede auditarlo.
+function sealAction({ projectDir, flags, logger }) {
+  // KJC-TSK-0868: el mismo asiento sirve para el panel — el anfitrión escribió
+  // teniendo otro coder declarado. Mismo log encadenado, otro chokepoint.
+  if (!flags.escape && !flags.panel) {
+    logger.error?.("policy seal: --escape <KJ_ALLOW_X> o --panel <coder> es obligatorio — un asiento sin nombre no es auditable");
+    return 1;
   }
-  // KJC-TSK-1000 (HUM-B3, ADR 0018): a change of the roster of phones is judged
-  // against the base's roster: admitted by a present phone or by the recovery code.
-  const roster = await rosterViolation({ projectDir, files: facts.files, range: flags.range || null, run: gitRunner(projectDir, deps.gitFn) });
-  if (roster) violations = [...violations, roster];
+  try {
+    const who = readIdentity(projectDir);
+    const rec = flags.panel
+      ? sealPanel({ projectDir, coder: flags.panel, host: flags.host ?? null, honoured: Boolean(flags.honoured) })
+      : recordGateDecision(projectDir, {
+        decision: "exempt", chokepoint: "tool", escape: flags.escape, tool: flags.tool ?? null,
+        who: who ? { gh: who.gh_user ?? null, git: who.git_email ?? null, grade: "declarada" } : null,
+        policy_hash: policyFileHash(projectDir),
+      });
+    if (rec.chokepoint === "panel") {
+      logger.info?.(`✓ panel sellado: el coder declarado es ${rec.coder} y escribió ${rec.host ?? "el anfitrión"}`);
+    } else {
+      const tool = rec.tool ? `, ${rec.tool}` : "";
+      logger.info?.(`✓ escape ${rec.escape} sellado (chokepoint tool${tool})`);
+    }
+    return 0;
+  } catch (err) {
+    logger.error?.(`policy seal: ${err.message}`);
+    return 1;
+  }
+}
+
+// check — staged por defecto, base...head con --range (CI). Warn salvo
+// --strict (PL-C): con --strict, una violación enforcement=deny devuelve
+// exit 2 nombrando la regla — el contrato merge-blocking del tier C.
+async function checkAction({ projectDir, policy, flags, logger, deps }) {
+  const facts = await stagedFacts(projectDir, deps.gitFn, flags.range || null);
+  const violations = await checkViolations({ projectDir, policy, flags, logger, deps, facts });
   const hard = flags.strict ? violations.filter((v) => v.enforcement === "deny") : [];
   if (flags.json) {
     logger.info?.(JSON.stringify({ mode: flags.strict ? "strict" : "warn", violations }));
@@ -274,3 +296,23 @@ export async function policyCommand({ action, config = {}, flags = {}, logger =
   logger.warn?.(`policy check: ${violations.length} aviso(s) — check es modo warn, no bloquea; los deny los aplican kj review --staged y el pre-commit (PL-B)`);
   return 0;
 }
+
+async function checkViolations({ projectDir, policy, flags, logger, deps, facts }) {
+  let violations = checkStagedDiff(policy, { role: flags.role || "coder", ...facts });
+  // ADR 0009 (KJC-BUG-0161): en CI la misma exención estructural que en la
+  // review — supervisor respaldado por provenance sellada + render canónico.
+  const sup = liftSealedSupervisorViolations({ projectDir, violations });
+  if (sup.lifted > 0) {
+    logger.info?.(`✓ policy: ${sup.lifted} fichero(s) de supervisor verificados contra la provenance sellada (ADR 0009)`);
+    // KJC-BUG-0212: lo que este sitio no ha podido juzgar se dice, no se calla.
+    if (sup.note) logger.info?.(`ℓ policy: ${sup.note}`);
+    violations = sup.violations;
+  }
+  // KJC-TSK-1000 (HUM-B3, ADR 0018): a change of the roster of phones is judged
+  // against the base's roster: admitted by a present phone or by the recovery code.
+  const run = gitRunner(projectDir, deps.gitFn);
+  const roster = await rosterViolation({ projectDir, files: facts.files, range: flags.range || null, run });
+  // HU-2792: a PR may not add an ADR number that the base already has.
+  const adr = await adrNumberViolation({ files: facts.files, range: flags.range || null, run });
+  return [...violations, ...[roster, adr].filter(Boolean)];
+}

package/src/commands/qmd.js

@@ -43,20 +43,8 @@ export async function qmdQueryCommand({ text, config, logger, flags = {} }) {
     if (err?.code === "ENOENT") return notInstalled(logger);
     throw err;
   }
-
-  const stderr = out.stderr || "";
-  if (out.exitCode === 127 || QMD_NOT_INSTALLED.test(stderr)) return notInstalled(logger);
-  if (COLLECTION_MISSING.test(stderr)) {
-    logger.error?.(`[qmd] ${INIT_HINT}`);
-    process.exitCode = 1;
-    return { ok: false, error: "collection not registered", collection };
-  }
-  if (out.exitCode !== 0) {
-    const msg = (stderr || out.stdout || `qmd exit ${out.exitCode}`).trim();
-    logger.error?.(`[qmd] ${msg}`);
-    process.exitCode = out.exitCode || 1;
-    return { ok: false, error: msg };
-  }
+  const failure = runFailure(out, collection, logger);
+  if (failure) return failure;
 
   let results;
   try { results = JSON.parse(out.stdout || "[]"); }
@@ -75,12 +63,30 @@ export async function qmdQueryCommand({ text, config, logger, flags = {} }) {
     return { ok: true, results: [] };
   }
   logger.info(`[qmd] ${results.length} hit(s) in ${collection}:`);
-  for (const h of results) {
-    const src = h.source || h.path || h.file || "?";
-    const score = typeof h.score === "number" ? ` · score=${h.score.toFixed(4)}` : "";
-    const snippet = h.snippet || h.text || h.body || "";
-    logger.info(`  - ${src}${score}`);
-    if (snippet) logger.info(`    ${snippet.length > 200 ? `${snippet.slice(0, 200)}…` : snippet}`);
-  }
+  for (const h of results) printHit(h, logger);
   return { ok: true, results };
 }
+
+// A finished qmd run that did not answer: not installed, no collection, or a failing exit.
+function runFailure(out, collection, logger) {
+  const stderr = out.stderr || "";
+  if (out.exitCode === 127 || QMD_NOT_INSTALLED.test(stderr)) return notInstalled(logger);
+  if (COLLECTION_MISSING.test(stderr)) {
+    logger.error?.(`[qmd] ${INIT_HINT}`);
+    process.exitCode = 1;
+    return { ok: false, error: "collection not registered", collection };
+  }
+  if (out.exitCode === 0) return null;
+  const msg = (stderr || out.stdout || `qmd exit ${out.exitCode}`).trim();
+  logger.error?.(`[qmd] ${msg}`);
+  process.exitCode = out.exitCode || 1;
+  return { ok: false, error: msg };
+}
+
+function printHit(h, logger) {
+  const src = h.source || h.path || h.file || "?";
+  const score = typeof h.score === "number" ? ` · score=${h.score.toFixed(4)}` : "";
+  const snippet = h.snippet || h.text || h.body || "";
+  logger.info(`  - ${src}${score}`);
+  if (snippet) logger.info(`    ${snippet.length > 200 ? `${snippet.slice(0, 200)}…` : snippet}`);
+}