karajan-code 4.33.0 → 4.34.0

package/package.json

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

package/src/brain/one-shot-policy.js

@@ -0,0 +1,26 @@
+/**
+ * Recovery for a command that runs once (KJC-BUG-0194).
+ *
+ * The pipeline can afford to wait: a quota wall means hibernate, persist the
+ * session and resume when the window reopens. A one-shot command cannot.
+ * Sleeping five hours inside `kj code` or `kj audit` is worse than the failure
+ * it is handling, and an MCP caller gets no answer at all.
+ *
+ * So here a quota wall takes the next declared candidate AT ONCE, and with
+ * none left it stops and says what it tried. Everything else keeps the
+ * pipeline's behaviour: a retired model still moves on immediately, provider
+ * 500s still back off, an auth failure still aborts.
+ */
+import { DEFAULT_RECOVERY_POLICY } from "./with-brain-recovery.js";
+import { ERROR_CLASS } from "./agent-error-classifier.js";
+
+const takeTheNextOne = { mode: "abort", maxRetries: 0, fallbackEligible: true, fallbackImmediate: true };
+
+export const ONE_SHOT_POLICY = Object.freeze({
+  ...DEFAULT_RECOVERY_POLICY,
+  classes: {
+    ...DEFAULT_RECOVERY_POLICY.classes,
+    [ERROR_CLASS.QUOTA_EXHAUSTED_DAILY]: takeTheNextOne,
+    [ERROR_CLASS.QUOTA_EXHAUSTED_MONTHLY]: takeTheNextOne,
+  },
+});

package/src/brain/with-brain-recovery.js

@@ -121,7 +121,10 @@ export async function withBrainRecovery({
 
   while (true) {
     const result = await effectiveAgent.runTask(taskArgs);
-    if (result?.ok) return result;
+    // KJC-TSK-0873: quien HA CORRIDO viaja con el resultado. Tras una caída al
+    // fallback, el llamante creía que había escrito el provider declarado, y
+    // con eso el recuento del panel contaba trabajo ajeno como propio.
+    if (result?.ok) return { ...result, provider: effectiveProvider };
 
     const cls = classifyAgentError({
       provider: effectiveProvider,

package/src/checks/release-check.js

@@ -106,6 +106,42 @@ async function packPrivacyCheck(projectDir, pkg) {
   }
 }
 
+/**
+ * KJC-BUG-0204 — an item may declare WHICH command repairs it (`remedied_by`),
+ * so the gate stops blocking the one action that would turn it green. It was
+ * the landing: the check demanded a deployed site and the guard blocked the
+ * deploy, leaving `KJ_ALLOW_RELEASE=1` — switching the gate off entirely — as
+ * the only way to reach the publish that came next.
+ */
+const remedy = (item) => (typeof item?.remedied_by === "string" && item.remedied_by.trim() ? { remediedBy: item.remedied_by.trim() } : {});
+
+/**
+ * The words of a verb must appear in the command IN ORDER, as whole words:
+ * `firebase deploy` covers `firebase --account a@b --project p deploy --only x`,
+ * and `deploy firebase` is a different command. Separators (`;`, `|`, `&`,
+ * parentheses) split words, so `(npm publish)` is still a publication.
+ * A word is read by its basename, so `/usr/bin/npm publish` is the same
+ * publication as `npm publish` (review catch: an absolute path hid one).
+ */
+const wordsOf = (text) => String(text).split(/[^A-Za-z0-9_.@:/-]+/).filter(Boolean).map((w) => w.slice(w.lastIndexOf("/") + 1)).filter(Boolean);
+
+export function remediesCommand(remediedBy, command) {
+  const want = wordsOf(remediedBy);
+  if (want.length === 0) return false;
+  let i = 0;
+  for (const word of wordsOf(command)) if (word === want[i] && ++i === want.length) return true;
+  return false;
+}
+
+/**
+ * A publication is irreversible: no declared item may excuse one. Detected with
+ * the SAME tolerance as a remedy (review catch): matching only adjacent words
+ * left `npm --registry https://r.example publish` undetected, so an item could
+ * have lifted a red check while the publication went ahead.
+ */
+const PUBLICATION_VERBS = ["npm publish", "gh release create"];
+const isPublication = (command) => PUBLICATION_VERBS.some((verb) => remediesCommand(verb, command));
+
 async function declaredItems(projectDir, config, version) {
   const items = config?.release_check?.items;
   if (!Array.isArray(items)) return [];
@@ -116,13 +152,16 @@ async function declaredItems(projectDir, config, version) {
       const p = isAbsolute(item.file_contains.path) ? item.file_contains.path : join(projectDir, item.file_contains.path);
       const needle = String(item.file_contains.pattern).replaceAll("{version}", version ?? "");
       const ok = existsSync(p) && readFileSync(p, "utf8").includes(needle);
-      checks.push({ name, ok, detail: ok ? `"${needle}" found in ${item.file_contains.path}` : `"${needle}" NOT found in ${item.file_contains.path}` });
+      checks.push({ name, ok, ...remedy(item), detail: ok ? `"${needle}" found in ${item.file_contains.path}` : `"${needle}" NOT found in ${item.file_contains.path}` });
     } else if (item?.command) {
       try {
         const res = await runCommand("sh", ["-c", String(item.command).replaceAll("{version}", version ?? "")], { cwd: projectDir });
-        checks.push({ name, ok: res.exitCode === 0, detail: res.exitCode === 0 ? "command exited 0" : `command exited ${res.exitCode}` });
+        checks.push({ name, ok: res.exitCode === 0, ...remedy(item), detail: res.exitCode === 0 ? "command exited 0" : `command exited ${res.exitCode}` });
       } catch (err) {
-        checks.push({ name, ok: false, detail: `command failed to run: ${err.message}` });
+        // El remedio viaja tambien cuando el item no se pudo ni ejecutar
+        // (catch de la review): si no, el comando que lo repara queda
+        // bloqueado justo cuando el check no ha podido comprobar nada.
+        checks.push({ name, ok: false, ...remedy(item), detail: `command failed to run: ${err.message}` });
       }
     } else {
       checks.push({ name, ok: false, detail: "unknown item shape — use file_contains {path, pattern} or command" });
@@ -160,10 +199,17 @@ export async function dualPublishCheck(projectDir, pkg, run = runCommand) {
   }
 }
 
-export async function runReleaseCheck({ projectDir = process.cwd(), config = {} } = {}) {
+export async function runReleaseCheck({ projectDir = process.cwd(), config = {}, forCommand = null } = {}) {
   const { checks, version, pkg } = await genericChecks(projectDir);
   const pack = await packPrivacyCheck(projectDir, pkg);
   const dual = await dualPublishCheck(projectDir, pkg);
   checks.push(...(pack ? [pack] : []), ...(dual ? [dual] : []), await policyRangeCheck(projectDir), ...await declaredItems(projectDir, config, version));
-  return { ok: checks.every((c) => c.ok), version, checks };
+  if (forCommand === null) return { ok: checks.every((c) => c.ok), version, checks };
+  // A lifted check stays RED in the report: the fact is not falsified, it just
+  // stops blocking the command that exists to repair it. The mark travels ON
+  // the check (review catch): two items may share a name, and a name-keyed
+  // list would have exempted a red check nothing remedies.
+  const liftable = !isPublication(forCommand);
+  const marked = checks.map((c) => (liftable && !c.ok && c.remediedBy && remediesCommand(c.remediedBy, forCommand) ? { ...c, lifted: true } : c));
+  return { ok: marked.every((c) => c.ok || c.lifted === true), version, checks: marked, lifted: marked.filter((c) => c.lifted).map((c) => c.name) };
 }

package/src/cli/register-meta.js

@@ -40,6 +40,9 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { verifySentinelScripts, resolveSentinelRoot } from "../harden/sentinel-hooks.js";
+import { boardGate } from "../review/board-pending.js";
+import { panelDeviation } from "../environment/panel.js";
+import { detectHostAgent } from "../utils/agent-detect.js";
 
 /**
  * Register the "meta" / single-role / housekeeping commands: pre-pipeline
@@ -337,12 +340,16 @@ export function registerMeta(program, { pkgVersion }) {
   release.command("check")
     .description("Verify the release checklist deterministically (manifest vs CHANGELOG vs tags, privacy scan of publishable files, plus the project's release_check.items); exit 1 lists exactly what is missing")
     .option("--json", "Machine-readable result")
+    // KJC-BUG-0204: el guard pregunta POR un comando. Un item que declara
+    // remedied_by no bloquea el comando que lo repara; publicar nunca se exime.
+    .option("--for-command <cmd>", "Evaluate the checklist for this command: red items whose remedied_by is this command do not block it")
     .action(async (flags) => {
       await withConfig(pkgVersion, "release-check", flags, async ({ config }) => {
-        const res = await runReleaseCheck({ projectDir: config?.projectDir || process.cwd(), config });
+        const res = await runReleaseCheck({ projectDir: config?.projectDir || process.cwd(), config, forCommand: flags.forCommand ?? null });
         if (flags.json) process.stdout.write(`${JSON.stringify(res)}\n`);
         else {
           for (const c of res.checks) console.log(`  ${c.ok ? "✓" : "✗"} ${c.name}: ${c.detail}`);
+          if (res.lifted?.length) console.log(`  ℓ no bloquean este comando porque es su remedio: ${res.lifted.join(", ")}`);
           console.log(res.ok ? `release check: ready to release ${res.version ?? ""}`.trim() : "release check: NOT ready — fix the red items first");
         }
         process.exitCode = res.ok ? 0 : 1;
@@ -419,8 +426,12 @@ export function registerMeta(program, { pkgVersion }) {
     });
   policyCmd.command("seal")
     .description("Sella en el decision log un escape KJ_ALLOW_* usado en tool-time (exempt, chokepoint=tool, identidad declarada del clon) — lo invoca el Sentinel, GOV-F")
-    .requiredOption("--escape <name>", "Escape usado (p.ej. KJ_ALLOW_BOARD)")
+    .option("--escape <name>", "Escape usado (p.ej. KJ_ALLOW_BOARD)")
     .option("--tool <tool>", "Tool que lo usó (Bash, Edit…)")
+    // KJC-TSK-0868: el panel se sella igual, con su propio chokepoint.
+    .option("--panel <coder>", "Coder declarado cuando el anfitrión escribió el código")
+    .option("--host <agent>", "Anfitrión que escribió, para el asiento del panel")
+    .option("--honoured", "El panel se CUMPLIÓ: escribió el coder declarado (KJC-TSK-0873)")
     .action(async (flags) => {
       await withConfig(pkgVersion, "policy-seal", flags, async ({ config }) => {
         process.exitCode = await policyCommand({ action: "seal", config, flags });
@@ -466,9 +477,38 @@ export function registerMeta(program, { pkgVersion }) {
     .action((flags) => {
       const res = verifySentinelScripts();
       if (flags.json) process.stdout.write(`${JSON.stringify(res)}\n`);
+      // KJC-BUG-0197: manipulación y desfase son hechos distintos y se leen
+      // distinto. Un desfase no es un defecto: los guardias que corren están
+      // sellados, solo son más viejos que las plantillas de este árbol.
+      else if (res.drift?.length && res.ok) console.log(`sentinel verify: scripts sellados, con desfase (${res.drift.join(", ")}) — ${res.reason}`);
       else console.log(res.ok ? "sentinel verify: scripts intactos" : `sentinel verify: modificados fuera de kj harden: ${res.mismatched.join(", ")} — restaura con kj harden`);
       process.exitCode = res.ok ? 0 : 1;
     });
+  // KJC-TSK-0868: el anfitrión escribiendo con otro coder declarado no se
+  // bloquea, se registra. El Stop gate pregunta una vez por sesión.
+  sentinel.command("panel-check")
+    .description("Record in the decision log that the host wrote code while another coder is declared (chokepoint panel); prints nothing and records nothing when the panel was honoured")
+    .requiredOption("--session <id>", "Host session id, for the record")
+    .action(async (flags) => {
+      await withConfig(pkgVersion, "sentinel-panel-check", flags, async ({ config }) => {
+        const dev = panelDeviation(config, detectHostAgent());
+        if (!dev) return;
+        process.exitCode = await policyCommand({ action: "seal", config, flags: { panel: dev.coder, host: dev.host }, logger: { info: () => {}, error: console.error } });
+        if (process.exitCode === 0) console.log(`ℓ panel: el coder declarado es ${dev.coder} y ha escrito ${dev.host} — registrado como excepción consciente (kj report lo cuenta)`);
+      });
+    });
+  // KJC-BUG-0198: el guard pregunta, kj decide con un hecho comprobable (otra
+  // PR abierta de la card), y exit 2 = bloquea.
+  sentinel.command("board-gate")
+    .description("Decide which pending board moves actually block: a card still being delivered in another open PR is carried, everything else blocks; exit 2 = blocked")
+    .requiredOption("--session <id>", "Host session id whose pending moves are evaluated")
+    .option("--json", "Machine-readable result")
+    .action((flags) => {
+      const res = boardGate({ projectDir: resolveSentinelRoot(), sessionId: flags.session });
+      if (flags.json) process.stdout.write(`${JSON.stringify(res)}\n`);
+      else for (const c of res.carried) console.log(`ℓ board-sync: ${c.card} ${c.why} — se moverá al cerrarla`);
+      process.exitCode = res.blocking.length > 0 ? 2 : 0;
+    });
 
   // KJC-TSK-0704 — the outbound privacy boundary: audit before anything ships.
   const privacy = program.command("privacy").description("Personal-data (PII) auditing of outbound boundaries: staged diffs, build outputs, docs trees");

package/src/commands/code.js

@@ -5,23 +5,13 @@ import { buildCoderPrompt } from "../prompts/coder.js";
 import { resolveCardContext } from "../prompts/card-context.js";
 import { composeTask, resolveRagContext } from "../prompts/session-context.js";
 import { resolveRole } from "../config.js";
-import { withBrainRecovery, DEFAULT_RECOVERY_POLICY } from "../brain/with-brain-recovery.js";
-import { buildRoleFallbackChain } from "../brain/role-fallback-chain.js";
-import { ERROR_CLASS } from "../brain/agent-error-classifier.js";
-
 // KJC-TSK-0859: the agents no longer substitute a dead model behind your back,
-// so the command needs the declared chain. A one-shot CLI must not inherit the
-// pipeline's standby either: sleeping five hours inside `kj code` would be
-// worse than the failure. A quota wall takes the next candidate at once, and
-// with none left it stops and says what it tried.
-const ONE_SHOT_POLICY = Object.freeze({
-  ...DEFAULT_RECOVERY_POLICY,
-  classes: {
-    ...DEFAULT_RECOVERY_POLICY.classes,
-    [ERROR_CLASS.QUOTA_EXHAUSTED_DAILY]: { mode: "abort", maxRetries: 0, fallbackEligible: true, fallbackImmediate: true },
-    [ERROR_CLASS.QUOTA_EXHAUSTED_MONTHLY]: { mode: "abort", maxRetries: 0, fallbackEligible: true, fallbackImmediate: true },
-  },
-});
+// so the command needs the declared chain, with the one-shot policy a command
+// deserves (KJC-BUG-0194 moved it to its own module: audit needs the same).
+import { withBrainRecovery } from "../brain/with-brain-recovery.js";
+import { buildRoleFallbackChain } from "../brain/role-fallback-chain.js";
+import { ONE_SHOT_POLICY } from "../brain/one-shot-policy.js";
+import { sealPanel } from "../environment/panel.js";
 import { withCliRunLog } from "../utils/cli-run-log.js";
 import { createCliProgressReporter } from "../utils/cli-progress.js";
 
@@ -89,6 +79,18 @@ export async function codeCommand({ task, config, logger, flags = {} }) {
       logger.warn(result.error);
     }
     logger.info(`Coder completed (exit ${result.exitCode})`);
+    // KJC-TSK-0873: aqui es donde el panel SE CUMPLE — el coder declarado ha
+    // escrito. Queda asentado junto a las desviaciones para que el recuento de
+    // kj report signifique algo: casi siempre y casi nunca no se ven igual.
+    // Solo cuenta como cumplido si el coder declarado TERMINO bien: ni una
+    // salida distinta de cero ni una caida al fallback son "escribio el coder
+    // que elegiste" (dos catches de la review). Si escribio otro, se asienta
+    // como desviacion nombrandolo.
+    const ranBy = result.provider || coderRole.provider;
+    if (result.exitCode === 0) {
+      try { sealPanel({ projectDir: config.projectDir, coder: coderRole.provider, host: ranBy, honoured: ranBy === coderRole.provider }); }
+      catch (err) { logger.warn(`panel: no se pudo sellar quién escribió (${err.message}) — el trabajo del coder no se toca`); }
+    }
     // The work is in the tree, not committed: the gate is the next step and a
     // DIFFERENT AI runs it. Saying so here is what keeps the panel honest.
     logger.info(`The work is in the tree. Review it before committing: kj review --staged (a different AI than ${coderRole.provider}).`);

package/src/commands/harden.js

@@ -153,7 +153,10 @@ export async function hardenCommand({
       result.harnessHooks = hh.wired ? "wired" : "script-only";
       // KJC-TSK-0713 — the Sentinel: method state + Stop gate (turn cannot
       // end red). Same Claude-only harness surface as the tool gate.
-      const sh = installSentinelHooks({ projectDir, logger });
+      // KJC-BUG-0193: solo un humano avanza lo que un humano selló. Sin
+      // --commit, un guardia sellado se queda como está en lugar de quedarse
+      // sin sello, que es como una sesión se dejaba sin herramientas.
+      const sh = installSentinelHooks({ projectDir, logger, human: commitSupervisor });
       result.sentinelHooks = sh.wired ? "wired" : "script-only";
     }
   } catch (err) {
@@ -195,7 +198,11 @@ export async function hardenCommand({
     logger.info?.(`  • ${c.file}: ${c.action}${note}`);
   }
   for (const w of out.workflows) logger.info?.(`  • ${w.file}: ${w.action}`);
-  for (const g of out.guidelines) logger.info?.(`  • ${g.file}: ${g.action}`);
+  for (const g of out.guidelines) {
+    logger.info?.(`  • ${g.file}: ${g.action}`);
+    // KJC-BUG-0206: quitar reglas no puede leerse como "updated" y nada más.
+    if (g.shrank) logger.warn?.(`    ⚠ ${g.file} queda con MENOS reglas que antes — revisa si el lenguaje detectado es el que crees (kj check lo dice)`);
+  }
   if (!dryRun) logger.info?.("core.hooksPath set. Verify later with `kj check`.");
   // IDN-A (KJC-TSK-0762): a hardened clone declares who works it. Captured
   // only with a human confirming; headless runs get the pending command.

package/src/commands/policy.js

@@ -15,6 +15,8 @@ import { checkStagedDiff, evalToolCall, loadPolicy } from "../policy/engine.js";
 import { liftSealedSupervisorViolations } from "../policy/supervisor-verify.js";
 import { loadExceptionRecords, loadGlobalExceptionRecords, loadStandingExceptions, recordPolicyException } from "../policy/exceptions.js";
 import { buildPolicyReport } from "../policy/report.js";
+import { budgetedNet } from "../review/loc-budget.js";
+import { sealPanel } from "../environment/panel.js";
 import { policyFileHash, recordGateDecision } from "../policy/decisions.js";
 import { readIdentity } from "../identity/store.js";
 import { verifyDecisionChain } from "@karajan-family/governance";
@@ -32,12 +34,10 @@ async function stagedFacts(projectDir, gitFn, range = null) {
     .split("\n")
     .map((s) => s.trim())
     .filter(Boolean);
-  let net = 0;
-  for (const line of (await run([...base, "--numstat"])).split("\n")) {
-    const [a, r] = line.trim().split(/\s+/);
-    if (a && a !== "-") net += Number(a) || 0;
-    if (r && r !== "-") net -= Number(r) || 0;
-  }
+  // KJC-BUG-0208: el presupuesto lo decide un solo modulo. Este sitio sumaba el
+  // numstat entero, asi que el job policy-check de CI contaba la documentacion
+  // y el gate bloqueante no: la misma regla con dos respuestas.
+  const { net } = budgetedNet(await run([...base, "--numstat"]));
   return { files, netLinesAdded: net };
 }
 
@@ -209,18 +209,23 @@ export async function policyCommand({ action, config = {}, flags = {}, logger =
   // 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") {
-    if (!flags.escape) {
-      logger.error?.("policy seal: --escape <KJ_ALLOW_X> es obligatorio — un escape sin nombre no es auditable");
+    // 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;
     }
     try {
       const who = readIdentity(projectDir);
-      const rec = 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),
-      });
-      logger.info?.(`✓ escape ${rec.escape} sellado (chokepoint tool${rec.tool ? `, ${rec.tool}` : ""})`);
+      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;
     } catch (err) {
       logger.error?.(`policy seal: ${err.message}`);
@@ -238,6 +243,8 @@ export async function policyCommand({ action, config = {}, flags = {}, logger =
   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;
   }
   const hard = flags.strict ? violations.filter((v) => v.enforcement === "deny") : [];

package/src/commands/report.js

@@ -226,6 +226,26 @@ export function formatSentinelEscapes(state) {
   return `Sentinel escapes used (${events.length}):\n${lines.join("\n")}`;
 }
 
+/**
+ * KJC-TSK-0873 — the panel tally. The user chose who writes; this says how
+ * often it happened. One number alone would not: a project where the panel is
+ * honoured almost always and one where it almost never is look identical until
+ * both sides are counted.
+ */
+export function formatPanelTally(lines) {
+  let honoured = 0;
+  let host = 0;
+  for (const line of lines) {
+    let rec;
+    try { rec = JSON.parse(line); } catch { continue; }
+    if (rec?.chokepoint !== "panel") continue;
+    if (rec.decision === "ok") honoured += 1;
+    else host += 1;
+  }
+  if (honoured + host === 0) return null;
+  return `Panel (who wrote): declared coder ${honoured}, host ${host}`;
+}
+
 // The sentinel state is a PROJECT artifact (<project>/.karajan/harness), not
 // a session artifact: the `dir` the report handlers receive is the GLOBAL
 // sessions root (~/.karajan/sessions) and never contains it. `kj report` is
@@ -241,6 +261,14 @@ async function printSentinelEscapes({ projectDir = process.cwd(), format } = {})
       console.log(text);
     }
   } catch { /* no sentinel state in this project — nothing to report */ }
+  try {
+    const log = await fs.readFile(path.join(projectDir, ".karajan", "policy-decisions.jsonl"), "utf8");
+    const tally = formatPanelTally(log.split("\n").filter((l) => l.trim()));
+    if (tally) {
+      console.log("");
+      console.log(tally);
+    }
+  } catch { /* no decision log — no panel to tally */ }
 }
 
 function formatDuration(ms) {

package/src/commands/review-gate.js

@@ -23,6 +23,7 @@ import { liftSealedSupervisorViolations } from "../policy/supervisor-verify.js";
 import { checkTestsWithCode } from "../review/tests-with-code.js";
 import { loadPrivacyList, scanText } from "../privacy/scan.js";
 import { isGeneratedPath, splitAddedByFile } from "../privacy/diff-scope.js";
+import { budgetedAdded, budgetedNet } from "../review/loc-budget.js";
 import { checkStagedDiff, loadPolicy } from "../policy/engine.js";
 import { loadStandingExceptions, recordPolicyException } from "../policy/exceptions.js";
 import { policyFileHash, recordGateDecision } from "../policy/decisions.js";
@@ -203,14 +204,17 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
   const sizeSource = locInv ? `policy [${locInv.id}]` : "method_gates";
   if (sizeWarn > 0) {
     const numstat = await rawDiff(flags.range, ["--numstat"]);
-    const added = numstat.split("\n").reduce((acc, l) => acc + (Number(l.split("\t")[0]) || 0), 0);
+    // KJC-BUG-0205: the budget caps CODE growth, so generated output and human
+    // documentation are exempt — the same rule CI applies. Counting everything
+    // here warned 234 lines on a doc-only PR that CI counted at 104, and two
+    // implementations of one rule that disagree teach people to trust neither.
+    const { added, exempt, testAdded } = budgetedAdded(numstat);
+    // Said out loud: an exemption nobody sees is indistinguishable from a gate
+    // that is not looking.
+    if (exempt > 0) console.log(`ℓ pr-size: ${exempt} line(s) exempt from the budget (generated output and human docs; AI-rule files always count)`);
     if (added > sizeWarn) {
       // KJC-TSK-0795 AC5: say how much of the weight is the module's OWN tests —
       // partitioning is a decision, and it must never split code from its tests.
-      const testAdded = numstat.split("\n").reduce((acc, l) => {
-        const [a, , ...f] = l.split("\t");
-        return acc + (/\/tests?\/|__tests__\/|\.test\.|\.spec\./.test(`/${f.join("\t")}`) ? Number(a) || 0 : 0);
-      }, 0);
       const split = testAdded > 0 ? ` (${added - testAdded} source + ${testAdded} accompanying tests — partition by feature, never code from its tests)` : "";
       const sizePolicy = config?.method_gates?.pr_size || "warn";
       if (process.env.KJ_ALLOW_LARGE_PR === "1") {
@@ -289,12 +293,10 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
   // hooks. enforcement=warn avisa; deny cierra salvo excepción probatoria
   // (KJ_ALLOW_POLICY=1 + KJ_POLICY_REASON, registrada con identidad y hash
   // del diff); class=security cierra sin escape y sin arbitraje.
-  let net = 0;
-  for (const l of (await rawDiff(flags.range, ["--numstat"])).split("\n")) {
-    const [a, r] = l.trim().split(/\s+/);
-    if (a && a !== "-") net += Number(a) || 0;
-    if (r && r !== "-") net -= Number(r) || 0;
-  }
+  // KJC-BUG-0208: el mismo modulo que decide el presupuesto decide el metrico
+  // del invariante. Sumar aqui el numstat entero daba dos cifras para la misma
+  // regla en dos lineas seguidas del mismo comando.
+  const { net } = budgetedNet(await rawDiff(flags.range, ["--numstat"]));
   // GOV-B (KJC-TSK-0746): las permanentes concedidas (kj policy grant)
   // eximen su regla mientras viven; el descarte de líneas corruptas se dice.
   const std = loadStandingExceptions(projectDir);

package/src/environment/panel.js

@@ -11,6 +11,8 @@
  * code, and then it says so instead of staying quiet.
  */
 import { resolveRole } from "../config/role-resolver.js";
+import { policyFileHash, recordGateDecision } from "../policy/decisions.js";
+import { readIdentity } from "../identity/store.js";
 
 /** Roles worth announcing: who writes, who reviews, who arbitrates. */
 export const PANEL_ROLES = ["coder", "reviewer", "solomon"];
@@ -42,6 +44,37 @@ export function panelLine(config) {
   ].join("\n");
 }
 
+/**
+ * KJC-TSK-0868: the host writing the code while another coder is declared is
+ * not an offence to block, it is a fact to record. Announcing at session start
+ * is not enough: the user chose who writes and finds out it did not happen by
+ * accident, one turn at a time.
+ *
+ * @returns {{coder: string, host: string}|null} null when there is nothing to
+ *   record: no coder declared, no host detected, or the host IS the coder.
+ */
+export function panelDeviation(config, host) {
+  const { coder } = resolvePanel(config);
+  if (!coder || !host || coder === host) return null;
+  return { coder, host };
+}
+
+/**
+ * KJC-TSK-0873: the log holds both sides. A deviation alone cannot say whether
+ * the panel is honoured almost always or almost never, and those are different
+ * situations. The compliance seat is written where the declared coder is
+ * actually invoked (`kj code`); the deviation one when the turn ends.
+ */
+export function sealPanel({ projectDir, coder, host = null, honoured = false }) {
+  const who = readIdentity(projectDir);
+  return recordGateDecision(projectDir, {
+    decision: honoured ? "ok" : "exempt", chokepoint: "panel", escape: null, tool: null,
+    coder, host: honoured ? coder : host,
+    who: who ? { gh: who.gh_user ?? null, git: who.git_email ?? null, grade: "declarada" } : null,
+    policy_hash: policyFileHash(projectDir),
+  });
+}
+
 /** Human-facing one-liner for `kj check` and friends. */
 export function panelSummary(config) {
   const { coder, reviewer, solomon } = resolvePanel(config);

package/src/harden/guidelines-engine.js

@@ -28,6 +28,8 @@ export function stripDevHooksBlock(source) {
   return { content: `${before}${joiner}${after}`, migrated: true };
 }
 
+const countLines = (text) => String(text || "").split("\n").filter((l) => l.trim()).length;
+
 export function installGuidelines({ projectDir = process.cwd(), dryRun = false, language = null } = {}) {
   // KJC-BUG-0199 (issue #1773): the rules that enter the agent's context must
   // be the rules of THIS project's language. kj harden already detects it for
@@ -45,8 +47,12 @@ export function installGuidelines({ projectDir = process.cwd(), dryRun = false,
       body,
       style: "html",
     });
+    // KJC-BUG-0206: harden removing rules is a fact worth saying. It silently
+    // dropped six lines from this repo's own files because the detected language
+    // had no block, and "updated" read like an improvement.
+    const shrank = countLines(content) < countLines(raw);
     if (!dryRun && (migrated || action !== "unchanged")) writeFileSync(target, content);
-    results.push({ file, action: migrated ? "migrated" : action });
+    results.push({ file, action: migrated ? "migrated" : action, ...(shrank ? { shrank: true } : {}) });
   }
   return { dryRun, guidelines: results };
 }

package/src/harden/guidelines-templates.js

@@ -76,9 +76,18 @@ export const LANGUAGE_GUIDELINES = {
   ],
 };
 
+/**
+ * Languages that share another's block (KJC-BUG-0206). TypeScript is the same
+ * ecosystem as JavaScript, and the block already says so in its heading; but the
+ * stack detector reports `typescript` for a repo with a tsconfig, so the lookup
+ * missed and harden ERASED the rules a project already had.
+ */
+const ALIASES = { typescript: "javascript" };
+
 /** The guidelines body for a language (unknown or absent ⇒ the core alone). */
 export function guidelinesBody(language = null) {
-  const extra = LANGUAGE_GUIDELINES[String(language || "").toLowerCase()] ?? [];
+  const key = String(language || "").toLowerCase();
+  const extra = LANGUAGE_GUIDELINES[ALIASES[key] ?? key] ?? [];
   return [...CORE, ...extra].join("\n");
 }
 

package/src/harden/harness-hooks.js

@@ -44,6 +44,12 @@ process.stdin.on("end", () => {
 `;
 
 /** Write a managed hook script under .karajan/harness/ and return its path. */
+/**
+ * KJC-BUG-0211: el cuerpo canonico de los guardias que instala ESTE modulo,
+ * para que quien verifica un sello pueda RECOMPUTAR en vez de fiarse del hash.
+ */
+export const HARNESS_BODIES = { "pretooluse.mjs": SCRIPT_BODY };
+
 export function writeHarnessScript(projectDir, name, body) {
   const dir = join(projectDir, ".karajan", "harness");
   mkdirSync(dir, { recursive: true });