karajan-code 4.21.0 → 4.23.0

package/src/environment/playbook.js

@@ -52,7 +52,8 @@ const playbookBody = (stateBackend, boardName) => `# Karajan method (v4)
 
 You are the orchestrator; Karajan governs. A task is DONE when its
 done-statement is literally true, the full suite is green, and every commit
-carries a cross-AI verdict.
+carries a cross-AI verdict. A card closed? Point your user at the board
+(\`kj board start\` → http://localhost:4000/#governance): that is where to look.
 
 Invariants (the git gates enforce these — they are not suggestions):
 

package/src/guards/duplicate-members.js

@@ -0,0 +1,86 @@
+/**
+ * Duplicate class members (KJC-TSK-0796) — a bug JavaScript refuses to report.
+ *
+ * Declaring the same member twice in a class is legal: the LAST one wins and the
+ * first disappears in silence. No runtime error, no lint warning, no compiler
+ * complaint. That is how a `updated()` that loaded the data was lost in GREBLA
+ * and a tab stayed empty in production for 17 days.
+ *
+ * What matters is not that there is a duplicate — it is WHAT WAS LOST: the body
+ * that will never run. That is what the finding says.
+ *
+ * Honest about its limits (the fourth verdict): a file this guard could not read,
+ * or one whose member names are computed at runtime, is reported as NOT OBSERVABLE
+ * — never as clean.
+ */
+import { parse } from "@babel/parser";
+
+const plugins = (file) => [
+  ...(/\.(ts|tsx|mts|cts)$/.test(file) ? ["typescript"] : []),
+  ...(/\.(tsx|jsx)$/.test(file) || !/\.(ts|mts|cts)$/.test(file) ? ["jsx"] : []),
+  "decorators",
+];
+const isClass = (node) => node?.type === "ClassDeclaration" || node?.type === "ClassExpression";
+
+/** Walks every node of the tree; enough for a syntax-only guard (no scope analysis). */
+function walk(node, visit) {
+  if (!node || typeof node.type !== "string") return;
+  visit(node);
+  for (const key of Object.keys(node)) {
+    const child = node[key];
+    if (Array.isArray(child)) child.forEach((c) => walk(c, visit));
+    else if (child && typeof child.type === "string") walk(child, visit);
+  }
+}
+
+const memberName = (member) => {
+  if (member.computed) return null; // `[expr]() {}` — the name is not known until it runs
+  const key = member.key ?? member.id;
+  if (key?.type === "Identifier") return key.name;
+  if (key?.type === "PrivateName") return `#${key.id.name}`;
+  if (key?.type === "StringLiteral" || key?.type === "NumericLiteral") return String(key.value);
+  return null;
+};
+
+/**
+ * @param {string} source
+ * @param {{file?: string}} [where]
+ * @returns {{findings: Array<object>, notObservable: {file: string, reason: string}|null}}
+ *   Each finding: {file, className, member, lostLine, winnerLine, message}.
+ */
+export function findDuplicateMembers(source, { file = "<source>" } = {}) {
+  let tree;
+  try {
+    tree = parse(source, { sourceType: "unambiguous", allowReturnOutsideFunction: true, plugins: plugins(file) });
+  } catch (err) {
+    return { findings: [], notObservable: { file, reason: `could not be parsed (${err.message}) — not read as clean` } };
+  }
+  const findings = [];
+  let computed = 0;
+  walk(tree, (node) => {
+    if (!isClass(node)) return;
+    const className = node.id?.name ?? "(anonymous)";
+    const seen = new Map();
+    for (const member of node.body.body) {
+      // get/set of the same name are legal, and a static member is a different slot from an
+      // instance one — treating either as a duplicate would be the false positive that gets a
+      // guard switched off (the credibility rule of KJC-PCS-0082).
+      // A TypeScript overload signature (TSDeclareMethod) declares the same name on purpose and
+      // carries no body: counting it would flag every overloaded method in the codebase.
+      if (member.type === "StaticBlock" || member.type === "TSDeclareMethod" || member.type === "TSIndexSignature" || member.kind === "get" || member.kind === "set") continue;
+      const name = memberName(member);
+      if (name === null) { computed += 1; continue; }
+      const key = `${member.static ? "static " : ""}${name}`;
+      const line = member.loc.start.line;
+      const first = seen.get(key);
+      if (first === undefined) { seen.set(key, line); continue; }
+      findings.push({
+        file, className, member: key, lostLine: first, winnerLine: line,
+        message: `${file}:${line} — ${className}: the ${key} of line ${first} never runs, the one of line ${line} replaces it`,
+      });
+      seen.set(key, line); // a third copy is reported against the second, not against the first
+    }
+  });
+  const notObservable = computed > 0 && findings.length === 0 ? { file, reason: `${computed} member name(s) computed at runtime — this file cannot be fully checked` } : null;
+  return { findings, notObservable };
+}

package/src/harden/sentinel-hooks.js

@@ -29,7 +29,7 @@ const LIB_BODY = `// kj sentinel shared lib (KJC-TSK-0714) — managed by \`kj h
 // Single source for every sentinel script: state, branch, classification,
 // violations, and escape recording.
 import { readFileSync, writeFileSync } from "node:fs";
-import { execSync } from "node:child_process";
+import { execSync, spawnSync } from "node:child_process";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 const here = dirname(fileURLToPath(import.meta.url));
@@ -75,9 +75,24 @@ export const violations = (s, branch) => {
   if (!s || !(s.edited_sources || []).length) return v;
   if (BASE_BRANCHES.has(branch)) v.push("Fuentes editadas en la rama base '" + branch + "' — crea una rama: git checkout -b feat/<CARD-ID>-descripcion");
   else if (branch && !CARD.test(branch)) v.push("La rama '" + branch + "' no referencia ninguna card — usa feat/<CARD-ID>-descripcion (y una card VIVA en el board)");
-  if (!(s.edited_tests || []).length) v.push("Fuentes editadas sin tocar un solo test (" + s.edited_sources.join(", ") + ") — escribe o actualiza el test que prueba el cambio");
+  if (!(s.edited_tests || []).length && sessionAddsCode(s)) v.push("Fuentes editadas sin tocar un solo test (" + s.edited_sources.join(", ") + ") — escribe o actualiza el test que prueba el cambio");
   return v;
 };
+// KJC-TSK-0795 AC1: deleting code adds no behavior to test — a session whose
+// source edits only REMOVED lines owes no test. Unreadable git = conservative
+// (the violation stands): a gate must never stand down on a shrug.
+const sessionAddsCode = (s) => {
+  const files = s.edited_sources || [];
+  // _git builds a shell string: any path outside a strict charset stays out of
+  // it — and the gate stays ARMED for it (conservative, and injection-proof).
+  if (files.some((f) => !/^[A-Za-z0-9._/-]+$/.test(f))) return true;
+  const stat = _git("diff HEAD --numstat -- " + files.join(" "), ROOT);
+  if (!stat) return true;
+  return stat.split(String.fromCharCode(10)).some((l) => {
+    const a = l.trim().replaceAll(String.fromCharCode(9), " ").split(" ").filter(Boolean)[0];
+    return a === "-" || Number(a) > 0;
+  });
+};
 export const recordEscape = (sid, escape, tool) => {
   const state = load();
   const s = session(state, sid);
@@ -85,6 +100,18 @@ export const recordEscape = (sid, escape, tool) => {
   if (!s.escapes.includes(escape)) s.escapes.push(escape);
   (state.escape_events ||= []).push({ escape, tool, sid, ts: Date.now() });
   save(state);
+  // GOV-F (KJC-TSK-0768): el escape es una excepcion consciente — entra en el
+  // decision log hash-encadenado (kj policy seal), no solo en este estado.
+  // Best-effort CON aviso: fail-closed aqui encerraria la sesion justo cuando
+  // kj no carga, que es cuando mas se usa el escape (restaurar con git).
+  try {
+    const args = ["policy", "seal", "--escape", escape];
+    if (tool) args.push("--tool", String(tool));
+    const r = spawnSync("kj", args, { cwd: ROOT, encoding: "utf8" });
+    if (r.error || r.status !== 0) console.error("kj sentinel: escape " + escape + " usado pero NO sellado en el decision log (kj policy seal " + (r.error ? r.error.message : "exit " + r.status) + ") — revisa kj; el escape queda solo en sentinel-state.json");
+  } catch (e) {
+    console.error("kj sentinel: escape " + escape + " usado pero NO sellado en el decision log: " + e.message);
+  }
 };
 `;
 
@@ -112,9 +139,11 @@ process.stdin.on("end", () => {
     const clearPending = (cardId) => {
       const state = load();
       const s = session(state, sid);
-      const before = (s.pending_moves || []).length;
       s.pending_moves = (s.pending_moves || []).filter((p) => p.card !== null && p.card !== cardId);
-      if (s.pending_moves.length !== before) save(state);
+      // KJC-TSK-0774: a card closed this turn is what the Stop hook points the
+      // user at when the focus comes back (the board is where to look).
+      if (cardId && !(s.closed_cards ||= []).includes(cardId)) s.closed_cards.push(cardId);
+      save(state);
     };
     if (/__update_card$/.test(String(tool)) && /^mcp__/.test(String(tool))) {
       // The MCP response reaches the hook as {content:[{text:"<json>"}]}: once
@@ -122,7 +151,21 @@ process.stdin.on("end", () => {
       // the first real update_card did not clear its pending entry).
       const cid = /\\\\?"cardId\\\\?"\\s*:\\s*\\\\?"([A-Za-z0-9-]+)\\\\?"/.exec(text);
       const st = /\\\\?"status\\\\?"\\s*:\\s*\\\\?"([^"\\\\]+)\\\\?"/.exec(text);
-      if (cid && st && CLOSING.includes(st[1].toLowerCase())) clearPending(cid[1].toUpperCase());
+      if (cid && st && CLOSING.includes(st[1].toLowerCase())) {
+        clearPending(cid[1].toUpperCase());
+        // KJC-BUG-0157: a pending whose card-id NEVER existed (branch named
+        // before the tracker confirmed the create) could not be cleared by any
+        // verified route. The pending's TRUE identity is its PR: a CONFIRMED
+        // closing update whose request names that PR clears it too — still a
+        // real tracker call seen by this hook, never a promise in prose.
+        const prIn = Number(input?.updates?.pipelineStatus?.prCreated?.prNumber);
+        if (Number.isFinite(prIn) && prIn > 0) {
+          const state = load();
+          const s = session(state, sid);
+          s.pending_moves = (s.pending_moves || []).filter((p) => Number(p.pr) !== prIn);
+          save(state);
+        }
+      }
       process.exit(0);
     }
     if (tool === "Bash") {
@@ -133,20 +176,30 @@ process.stdin.on("end", () => {
       const mergeCmd = /\\bgh\\s+pr\\s+merge(\\s+(\\d+))?/.exec(cmdText);
       const said = /merged pull request #(\\d+)/i.exec(text);
       let mergedPr = said ? Number(said[1]) : null;
-      if (mergedPr === null && mergeCmd) {
-        const args = ["pr", "view", ...(mergeCmd[2] ? [mergeCmd[2]] : []), "--json", "number,state"];
+      // KJC-BUG-0148: the card belongs to the PR's HEAD branch, not to whatever
+      // branch the working tree happens to be on (found live: a merge issued
+      // from another card's lane pinned the pending move on the wrong card).
+      let headRef = null;
+      if (mergeCmd || said) {
+        const n = said ? said[1] : mergeCmd[2];
+        const args = ["pr", "view", ...(n ? [n] : []), "--json", "number,state,headRefName"];
         const r = spawnSync("gh", args, { cwd: ROOT, encoding: "utf8" });
-        try { const v = JSON.parse(r.status === 0 ? r.stdout : "null"); if (v && v.state === "MERGED") mergedPr = Number(v.number); } catch { /* unknown = not confirmed */ }
+        try {
+          const v = JSON.parse(r.status === 0 ? r.stdout : "null");
+          if (v && v.state === "MERGED") { mergedPr = Number(v.number); headRef = v.headRefName || null; }
+        } catch { /* unknown = not confirmed (or confirmed only by the printed line) */ }
       }
       if (mergedPr !== null) {
         const state = load();
         const s = session(state, sid);
-        const ref = CARD.exec(branchOf() || "");
-        (s.pending_moves ||= []).push({ card: ref ? ref[0].toUpperCase() : null, pr: mergedPr, at: Date.now() });
+        const ref = CARD.exec(headRef || branchOf() || "");
+        (s.pending_moves ||= []).push({ card: ref ? ref[0].toUpperCase() : null, pr: mergedPr, at: Date.now(), ...(headRef ? {} : { head: "unknown" }) });
         save(state);
       }
       const moved = /kj\\s+hu\\s+move\\s+([A-Za-z0-9-]+)\\s+([a-z&-]+)/i.exec(String(input.command || ""));
-      if (moved && CLOSING.includes(moved[2].toLowerCase()) && !/error|fail/i.test(text)) clearPending(moved[1].toUpperCase());
+      // "not found" counts as failure (KJC-BUG-0154): a move that moved nothing must not
+      // clear a pending — that would discard a LEGITIMATE one without touching the tracker.
+      if (moved && CLOSING.includes(moved[2].toLowerCase()) && !/error|fail|not found/i.test(text)) clearPending(moved[1].toUpperCase());
       process.exit(0);
     }
     const file = input.file_path || input.notebook_path;
@@ -177,7 +230,19 @@ const STOP_BODY = `#!/usr/bin/env node
 // after 3 unresolved blocks — a sentinel bug never bricks the session — and
 // the fail-open is recorded in the state. \`--status\` prints, never blocks.
 import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import { load, save, branchOf, violations, ROOT } from "./sentinel-lib.mjs";
+// KJC-TSK-0774: when the turn ends green with cards closed, remind the user
+// where to look — the board URL if it runs (pid file alive), else how to start it.
+const boardHint = () => {
+  const home = process.env.KARAJAN_HOME || process.env.KJ_HOME || join(homedir(), ".karajan");
+  try {
+    process.kill(Number(readFileSync(join(home, "hu-board.pid"), "utf8").trim()), 0);
+    return "http://localhost:" + (process.env.KJ_BOARD_PORT || "4000") + "/#governance";
+  } catch { return "no esta arrancado: kj board start (luego http://localhost:4000/#governance)"; }
+};
 if (process.argv.includes("--status")) {
   const st = load();
   const branch = branchOf();
@@ -194,7 +259,7 @@ process.stdin.on("data", (d) => { raw += d; });
 process.stdin.on("end", () => {
   try {
     if (process.env.KJ_SENTINEL_OFF === "1") process.exit(0);
-    const { session_id: sid = "default" } = JSON.parse(raw);
+    const { session_id: sid = "default", transcript_path: transcript = null } = JSON.parse(raw);
     const state = load();
     // Tamper check runs regardless of session state: shell indirection leaves
     // no edit-tool record, but it cannot survive \`kj sentinel verify\`, whose
@@ -216,14 +281,38 @@ process.stdin.on("end", () => {
       process.exit(2);
     }
     state.tamper_blocks = 0;
+    // CLM-B (KJC-TSK-0802, claims-with-evidence ADR): the hard data of the turn's
+    // final message, crossed against that turn's outputs. It runs even without a
+    // tracked session — a turn with no edits still ends with a final message. The
+    // hook carries no policy: kj reads method_gates.claims and answers 0 (off,
+    // clean, or warn) or 2 (a datum DENIED by its own source, in block mode). A
+    // missing kj or an errored spawn fails open.
+    let claimsNote = "";
+    let claimsBlock = null;
+    if (transcript) {
+      const c = spawnSync("kj", ["claims", "gate", "--transcript", transcript], { cwd: ROOT, encoding: "utf8" });
+      if (!c.error && c.status === 2) claimsBlock = "claims: un dato del mensaje final esta DESMENTIDO por las salidas de este turno — verificalo o marcalo como no comprobado. Detalle: kj claims check --transcript " + transcript;
+      else if (!c.error && c.status === 0 && (c.stderr || "").trim()) claimsNote = "kj claims: " + c.stderr.trim().split(String.fromCharCode(10))[0] + " — datos sin respaldo en este turno (informa, no bloquea).";
+    }
     const s = state.sessions?.[sid];
-    if (!s) process.exit(0);
+    if (!s) {
+      if (claimsBlock) { console.error("kj sentinel: el turno NO puede terminar:" + String.fromCharCode(10) + "- " + claimsBlock); process.exit(2); }
+      if (claimsNote) console.log(JSON.stringify({ systemMessage: claimsNote }));
+      process.exit(0);
+    }
     const v = violations(s, branchOf());
+    if (claimsBlock) v.push(claimsBlock);
     if (!v.length) {
       s.blocks = 0;
+      const notes = [];
+      if (claimsNote) notes.push(claimsNote);
+      if ((s.escapes || []).length) notes.push("kj sentinel: esta sesion uso " + s.escapes.length + " escape(s): " + s.escapes.join(", ") + " — decision registrada; detalle en kj sentinel status.");
+      if ((s.closed_cards || []).length) {
+        notes.push("kj sentinel: card(s) cerrada(s) en este turno: " + s.closed_cards.join(", ") + " — el board las muestra: " + boardHint());
+        s.closed_cards = [];
+      }
       save(state);
-      if ((s.escapes || []).length)
-        console.log(JSON.stringify({ systemMessage: "kj sentinel: esta sesion uso " + s.escapes.length + " escape(s): " + s.escapes.join(", ") + " — decision registrada; detalle en kj sentinel status." }));
+      if (notes.length) console.log(JSON.stringify({ systemMessage: notes.join("\\n") }));
       process.exit(0);
     }
     s.blocks = (s.blocks || 0) + 1;
@@ -251,7 +340,7 @@ import { dirname, join, relative, resolve } from "node:path";
 import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { homedir } from "node:os";
-import { CODE, TESTS, ROOT, BASE_BRANCHES, CARD, branchOf, foreignLane, load, violations, recordEscape, pendingMoves, pendingText } from "./sentinel-lib.mjs";
+import { CODE, TESTS, ROOT, BASE_BRANCHES, CARD, branchOf, foreignLane, load, save, session, violations, recordEscape, pendingMoves, pendingText } from "./sentinel-lib.mjs";
 const EDIT_TOOLS = ["Write", "Edit", "MultiEdit", "NotebookEdit"];
 const PUBLISH = /\\bnpm\\s+publish\\b|\\bfirebase\\s+deploy\\b|\\bgh\\s+release\\s+create\\b/;
 const PUSH = /\\bgit\\s+push\\b/;
@@ -260,7 +349,7 @@ let raw = "";
 process.stdin.on("data", (d) => { raw += d; });
 process.stdin.on("end", () => {
   try {
-    const { session_id: sid = "default", tool_name: tool, tool_input: input = {} } = JSON.parse(raw);
+    const { session_id: sid = "default", tool_name: tool, tool_input: input = {}, transcript_path: transcript = null } = JSON.parse(raw);
     // Self-protection (KJC-TSK-0715) rules run BEFORE any escape, including
     // KJ_SENTINEL_OFF: the sentinel is not dismantled from inside a session —
     // only the human, editing outside it.
@@ -313,11 +402,36 @@ process.stdin.on("end", () => {
         if (tok === name + "=1") found = true;
       }
       if (!found) return false;
-      for (const c of CMD_TEXT) {
-        if (c === ";" || c === "|" || c === "&" || c === ESC_NL || c === ESC_BT) return false;
-        if (c === "$" || c === "(" || c === ")") return false;
+      // KJC-BUG-0147: lo que va ENTRE COMILLAS no encadena comandos — un
+      // mensaje "fix(x): ... (KJC-TSK-1)" es un comando simple. Dentro de
+      // comillas dobles $ y backtick siguen expandiendo (se rechazan); en
+      // comillas simples todo es literal. Y si el escape esta pero se ignora,
+      // SE DICE: un escape ignorado en silencio era el bug.
+      const bad = escSimple();
+      if (bad === null) return true;
+      if (!escNoted.has(name)) {
+        escNoted.add(name);
+        console.error("kj sentinel: " + name + "=1 presente pero IGNORADO — el escape solo vale en un comando simple y este contiene " + JSON.stringify(bad) + " fuera de comillas simples (sin ; | & $ ( ) backtick ni salto de linea: parte el comando o usa -F fichero)");
       }
-      return true;
+      return false;
+    };
+    const escNoted = new Set();
+    const escSimple = () => {
+      let q = null;
+      for (let i = 0; i < CMD_TEXT.length; i += 1) {
+        const c = CMD_TEXT[i];
+        if (q === "'") { if (c === "'") q = null; continue; }
+        if (q === '"') {
+          if (c === '"') q = null;
+          else if (c === "$" || c === ESC_BT) return c;
+          else if (c === "\\\\") i += 1;
+          continue;
+        }
+        if (c === "\\\\") { i += 1; continue; }
+        if (c === "'" || c === '"') { q = c; continue; }
+        if (c === ";" || c === "|" || c === "&" || c === ESC_NL || c === ESC_BT || c === "$" || c === "(" || c === ")") return c;
+      }
+      return q === null ? null : "comilla sin cerrar";
     };
     // IDN-B (KJC-TSK-0763, ADR 0005): identity lock — gh and mutating git never
     // run under an account other than the one THIS CLONE declared (the incident:
@@ -615,6 +729,37 @@ process.stdin.on("end", () => {
       }
     }
     if (EDIT_TOOLS.includes(tool)) {
+      // STW-C (KJC-TSK-0791): the sweep's verdict has consequence where work
+      // STARTS. Inform ALWAYS, once per session and impossible to miss; BLOCK
+      // almost never — only security and persistent red main, and only when
+      // the project adopted it (method_gates.steward: block). Unknown is never
+      // treated as broken: nothing is asserted that is not known. No report =
+      // the project does not use the Steward yet — silence, adoption is explicit.
+      try {
+        const rep = JSON.parse(readFileSync(join(ROOT, ".karajan", "steward", "report.json"), "utf8"));
+        const bad = (rep.invariants || []).filter((r) => r.verdict === "broken");
+        const stale = (rep.invariants || []).filter((r) => r.verdict === "unknown");
+        if (bad.length || stale.length) {
+          const hard = bad.filter((r) => r.id === "vulnerable-deps" || r.id === "main-ci");
+          let blockOn = false;
+          try { blockOn = /steward:\\s*["']?block/.test(readFileSync(join(ROOT, ".karajan", "kj.config.yml"), "utf8")); } catch { /* no config — no block */ }
+          if (hard.length && blockOn) {
+            if (escOn("KJ_ALLOW_STEWARD")) { recordEscape(sid, "KJ_ALLOW_STEWARD", tool); }
+            else {
+              console.error("kj sentinel: steward — el estado del proyecto bloquea empezar (barrido " + rep.sweptAt + "):" + String.fromCharCode(10) + hard.map((r) => "- " + r.id + ": " + (r.evidence || "") + " -> " + (r.remedy || r.renew || "kj steward sweep")).join(String.fromCharCode(10)) + String.fromCharCode(10) + "(KJ_ALLOW_STEWARD=1 = excepcion consciente de esta sesion, queda registrada)");
+              process.exit(2);
+            }
+          }
+          const st = load();
+          const s = session(st, sid);
+          if (!s.steward_informed) {
+            s.steward_informed = true;
+            save(st);
+            const lines = [...bad.map((r) => "ROTO " + r.id + ": " + (r.remedy || r.evidence || "")), ...stale.map((r) => "desconocido " + r.id + " (no se afirma lo que no se sabe) — refresca: " + (r.renew || "kj steward sweep"))];
+            console.log(JSON.stringify({ systemMessage: "kj steward (barrido " + rep.sweptAt + "): " + lines.join(" | ") + " — detalle: .karajan/steward/report.md" }));
+          }
+        }
+      } catch { /* no report or unreadable — the Steward is not adopted here */ }
       const file = input.file_path || input.notebook_path;
       const rel = file ? relative(ROOT, String(file)).replaceAll("\\\\", "/") : "";
       if (rel && CODE.test(rel) && !TESTS.test(rel)) {
@@ -648,6 +793,19 @@ process.stdin.on("end", () => {
       }
       // (the pending entry itself is recorded by the PostToolUse hook, only once
       // gh confirms "merged pull request #N" — a failed merge never blocks)
+      // CLM-C (KJC-TSK-0803): a PR body outlives the turn — an invented figure
+      // there misleads every future reader. When the command writes one from a
+      // file, kj crosses ITS data against this turn's outputs; the hook carries
+      // no policy (kj reads method_gates.claims; off = this check does not exist).
+      const bodyFile = /\\bgh\\s+pr\\s+(?:create|edit)\\b/.test(cmd) ? /--body-file[= ]+("([^"]+)"|'([^']+)'|([^\\s"']+))/.exec(cmd) : null;
+      if (bodyFile && transcript) {
+        const body = bodyFile[2] || bodyFile[3] || bodyFile[4];
+        const g = spawnSync("kj", ["claims", "gate", "--transcript", transcript, "--file", body], { cwd: ROOT, encoding: "utf8" });
+        if (!g.error && g.status === 2) {
+          console.error("kj sentinel: claims — un dato del cuerpo de la PR esta DESMENTIDO por las salidas de este turno:\\n" + (g.stderr || "").trim() + "\\nVerificalo o marcalo como no comprobado antes de crear la PR. Detalle: kj claims check --transcript " + transcript + " --file " + body);
+          process.exit(2);
+        }
+      }
       if (PUBLISH.test(cmd)) {
         if (escOn("KJ_ALLOW_RELEASE")) { recordEscape(sid, "KJ_ALLOW_RELEASE", tool); process.exit(0); }
         const res = spawnSync("kj", ["release", "check", "--json"], { cwd: ROOT, encoding: "utf8" });
@@ -659,7 +817,15 @@ process.stdin.on("end", () => {
           process.exit(2);
         }
       } else if (PUSH.test(cmd)) {
-        const v = violations(load().sessions?.[sid], branchOf());
+        // KJC-BUG-0147: the board escape covers the push too — a pending move
+        // blocks the push like it blocks the commit, and the SAME conscious,
+        // recorded escape opens both (multi-PR cards are a legitimate plan).
+        const sess = load().sessions?.[sid];
+        let v = violations(sess, branchOf());
+        if (v.length && pendingMoves(sess).length && escOn("KJ_ALLOW_BOARD")) {
+          recordEscape(sid, "KJ_ALLOW_BOARD", tool);
+          v = violations({ ...sess, pending_moves: [] }, branchOf());
+        }
         if (v.length) {
           console.error("kj sentinel: git push con el metodo en rojo:\\n" + v.map((x) => "- " + x).join("\\n") + "\\nResuelve antes de empujar. Estado: kj sentinel status");
           process.exit(2);

package/src/harden/workflow-engine.js

@@ -12,8 +12,9 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { dirname } from "node:path";
 
+import { parse as parseYaml } from "yaml";
 import { upsertManagedBlock } from "../utils/managed-markers.js";
-import { extraWorkflowsFor, mutationWorkflowFor, qualityWorkflowFor, policyWorkflowFor, WORKFLOWS } from "./workflow-templates.js";
+import { extraWorkflowsFor, mutationWorkflowFor, qualityWorkflowFor, policyWorkflowFor, stewardWorkflowFor, WORKFLOWS } from "./workflow-templates.js";
 
 // La versión del kj que corre harden — es la que se pinea en el fallback
 // npx del workflow de policy (jamás @latest en CI). Lectura LAZY: en el
@@ -85,7 +86,12 @@ export function installWorkflows({
   const policy = existsSync(join(projectDir, ".karajan", "policy.yml"))
     ? { file: "kj-policy.yml", blockId: "wf-policy", body: policyWorkflowFor(pinned, ownPkg()?.name ?? "karajan-code") }
     : null;
-  const all = [...WORKFLOWS, ...(quality ? [quality] : []), ...extras, ...(mut ? [mut] : []), ...(policy ? [policy] : [])];
+  // STW-E (KJC-TSK-0793): the scheduled sweep is OPT-IN — the project says
+  // steward.action: true in its config; nothing is imposed by default.
+  let stewardOn = false;
+  try { stewardOn = parseYaml(readFileSync(join(projectDir, ".karajan", "kj.config.yml"), "utf8"))?.steward?.action === true; } catch { /* no config — no action */ }
+  const steward = stewardOn ? { file: "kj-steward.yml", blockId: "wf-steward", body: stewardWorkflowFor(pinned, ownPkg()?.name ?? "karajan-code") } : null;
+  const all = [...WORKFLOWS, ...(quality ? [quality] : []), ...extras, ...(mut ? [mut] : []), ...(policy ? [policy] : []), ...(steward ? [steward] : [])];
   const results = [];
   for (const wf of all) {
     const target = join(dir, wf.file);

package/src/harden/workflow-templates.js

@@ -186,7 +186,10 @@ export const SHRINK_BUDGET_WORKFLOW = [
   "        env:",
   "          BASE_REF: ${{ github.base_ref }}",
   "        run: |",
-  "          d=$(git diff --numstat \"origin/${BASE_REF}...HEAD\" -- . ':!**/*.md' ':!*.lock' ':!package-lock.json' || true)",
+  // KJC-TSK-0795 AC4 — measured in GREBLA: a 414-line warning that was almost
+  // all pnpm-lock.yaml. Generated files are weight nobody wrote: the generated
+  // gate applies the same exclusions kj's own repo applies.
+  "          d=$(git diff --numstat \"origin/${BASE_REF}...HEAD\" -- . ':!**/*.md' ':!*.lock' ':!package-lock.json' ':!pnpm-lock.yaml' ':!npm-shrinkwrap.json' ':!dist/**' ':!build/**' ':!coverage/**' ':!**/*.snap' ':!**/__snapshots__/**' || true)",
   '          a=$(printf "%s\\n" "$d" | awk \'$1!="-"{s+=$1}END{print s+0}\')',
   '          r=$(printf "%s\\n" "$d" | awk \'$2!="-"{s+=$2}END{print s+0}\')',
   '          net=$((a - r)); echo "net=$net (limit=$LOC_LIMIT)"',
@@ -272,6 +275,40 @@ export function mutationWorkflowFor(language, pm = "npm") {
   return { file: "kj-mutation.yml", blockId: "wf-mutation", body };
 }
 
+// STW-E (KJC-TSK-0793): the scheduled Steward sweep — OPT-IN via
+// steward.action: true. Decay happens precisely on the days nobody looks, so
+// the watcher cannot live inside a session: the Action runs where the repo
+// lives, publishes the SAME report file every other mode writes (one source
+// of truth), and a broken invariant never stops the report from publishing.
+export function stewardWorkflowFor(kjVersion, pkgName = "karajan-code") {
+  return [
+    "name: Steward sweep",
+    "on:",
+    "  schedule:",
+    '    - cron: "17 6 * * 1"',
+    "  workflow_dispatch: {}",
+    "permissions:",
+    "  contents: write",
+    "jobs:",
+    "  sweep:",
+    "    runs-on: ubuntu-latest",
+    "    steps:",
+    `      - uses: ${PINNED_ACTIONS.checkout}`,
+    `      - uses: ${PINNED_ACTIONS.setupNode}`,
+    "        with:",
+    '          node-version: "22"',
+    `      - run: npm install -g ${pkgName}@${kjVersion}`,
+    "      - name: Sweep (a broken invariant must not stop the report)",
+    "        env:",
+    "          GH_TOKEN: ${{ github.token }}",
+    "        run: kj steward sweep || true",
+    "      - name: Publish the report and the proposed cards",
+    "        run: |",
+    "          git add .karajan/steward .karajan/plans 2>/dev/null || true",
+    '          git diff --cached --quiet || { git -c user.name="github-actions[bot]" -c user.email="41898282+github-actions[bot]@users.noreply.github.com" commit -m "chore(steward): sweep report [skip ci]" && git push; }',
+  ].join("\n");
+}
+
 /** Conditional workflows: shrink-budget on strict, pack-smoke when publishable. */
 export function extraWorkflowsFor({ profile = "standard", publishable = false, pm = "npm" } = {}) {
   const extras = [];

package/src/policy/exceptions.js

@@ -24,13 +24,23 @@ function defaultIdentity(projectDir) {
  * @returns {{standing: object[], discarded: number}}
  */
 export function loadStandingExceptions(projectDir) {
+  const { records, discarded } = loadExceptionRecords(projectDir);
+  return { standing: records.filter((rec) => rec.scopeKind === "permanente"), discarded };
+}
+
+/**
+ * TODOS los registros del jsonl (permanentes y puntuales) con el mismo parse
+ * tolerante — el informe (PL-E) cuenta también las puntuales.
+ * @returns {{records: object[], discarded: number}}
+ */
+export function loadExceptionRecords(projectDir) {
   let raw;
   try {
     raw = readFileSync(join(projectDir, ".karajan", "policy-exceptions.jsonl"), "utf8");
   } catch {
-    return { standing: [], discarded: 0 };
+    return { records: [], discarded: 0 };
   }
-  const standing = [];
+  const records = [];
   let discarded = 0;
   for (const line of raw.split("\n")) {
     if (!line.trim()) continue;
@@ -39,12 +49,12 @@ export function loadStandingExceptions(projectDir) {
       // 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);
+      else records.push(rec);
     } catch {
       discarded += 1;
     }
   }
-  return { standing, discarded };
+  return { records, discarded };
 }
 
 function defaultAppend(projectDir, line) {

package/src/policy/report.js

@@ -0,0 +1,99 @@
+/**
+ * PL-E (KJC-TSK-0767) — el informe de policy, PURO (líneas del decision log +
+ * excepciones + policy + reloj ⇒ objeto determinista; cero I/O, cero LLM).
+ * Responde: ¿qué reglas avisan y cuánto (gana dientes con datos)?, ¿qué
+ * denegaciones siguen abiertas (la renuncia deja rastro)?, ¿qué concesiones
+ * viven, vencen o se renuevan (la renovación es señal)?
+ */
+import { verifyDecisionChain } from "@karajan-family/governance";
+
+const DAY_MS = 86_400_000;
+const WARN_SIGNAL_MIN = 5;
+
+/** enforcement/class de una regla según la policy cargada (null si no se sabe). */
+function ruleMeta(policy, ruleId) {
+  if (!policy) return {};
+  if (ruleId.startsWith("defaults.")) return { enforcement: "deny", class: "security" };
+  const m = /^roles\.([^.]+)\.([^.]+)/.exec(ruleId);
+  const spec = m ? policy.roles?.[m[1]]?.[m[2]] : policy.invariants?.find((i) => i.id === ruleId);
+  if (!spec) return {};
+  return { enforcement: spec.enforcement || "warn", ...(spec.class ? { class: spec.class } : {}) };
+}
+
+function parseDecisions(lines) {
+  const records = [];
+  let discarded = 0;
+  for (const line of lines) {
+    try {
+      const rec = JSON.parse(line);
+      if (typeof rec === "object" && rec !== null) records.push(rec);
+      else discarded += 1;
+    } catch {
+      discarded += 1;
+    }
+  }
+  return { records, discarded };
+}
+
+// Abiertas = denies posteriores al último allow/exempt: el log acaba en
+// rechazo sin que nada haya pasado después. Heurística declarada — el log
+// no lleva rama ni autor, así que no distingue "arreglado" de "abandonado".
+const lastResolvedIndex = (records) => records.findLastIndex((r) => r.decision === "allow" || r.decision === "exempt");
+
+function tallyRules(records, policy, lastResolved) {
+  const rules = new Map();
+  const row = (id) => {
+    if (!rules.has(id)) rules.set(id, { rule_id: id, ...ruleMeta(policy, id), warns: 0, denies: 0, exempts: 0, open: 0 });
+    return rules.get(id);
+  };
+  // Un sello lleva un rule_id por FICHERO violador: se cuentan decisiones
+  // por regla, no ficheros — de ahí el Set por entrada.
+  const ids = (list) => new Set(list ?? []);
+  records.forEach((rec, i) => {
+    for (const id of ids(rec.warn_rule_ids)) row(id).warns += 1;
+    if (rec.decision === "deny") for (const id of ids(rec.rule_ids)) { row(id).denies += 1; if (i > lastResolved) row(id).open += 1; }
+    if (rec.decision === "exempt") for (const id of ids(rec.rule_ids)) row(id).exempts += 1;
+  });
+  return [...rules.values()].toSorted((a, b) => (b.denies + b.warns) - (a.denies + a.warns));
+}
+
+function tallyGrants(exceptionRecords, now, soonDays) {
+  const perm = exceptionRecords.filter((e) => e?.scopeKind === "permanente");
+  // Una caducidad ilegible (NaN) NO está viva: la excepción falla cerrada.
+  const alive = [];
+  const expired = [];
+  for (const e of perm) (Date.parse(e.expiresAt) > now.getTime() ? alive : expired).push(e);
+  const soon = alive.filter((e) => Date.parse(e.expiresAt) - now.getTime() <= soonDays * DAY_MS);
+  const counts = Map.groupBy(perm, (e) => e.rule_id);
+  const renewals = [...counts].filter(([, v]) => v.length >= 2).map(([rule_id, v]) => ({ rule_id, count: v.length }));
+  return { alive, expired, soon, renewals, point: exceptionRecords.length - perm.length };
+}
+
+function signalsFor(rules, grants) {
+  const out = [];
+  for (const g of grants.renewals) out.push(`[${g.rule_id}] concedida ${g.count} veces — una excepción que se renueva ya no es una excepción: es la política pidiendo cambio (PR a .karajan/policy.yml)`);
+  for (const r of rules) {
+    if (r.warns >= WARN_SIGNAL_MIN && r.denies === 0 && r.enforcement !== "deny") out.push(`[${r.rule_id}] ha avisado ${r.warns} veces y nunca ha bloqueado — decide: promover a enforcement=deny o retirarla; un aviso perpetuo es ruido`);
+    if (r.open > 0) out.push(`[${r.rule_id}] ${r.open} denegación(es) abierta(s) — el log acaba en rechazo: ¿arreglo pendiente, excepción por pedir, o renuncia?`);
+  }
+  for (const g of grants.soon) out.push(`[${g.rule_id}] vence ${g.expiresAt} — al vencer vuelve a bloquear sola; renueva por su cauce o deja que caduque`);
+  return out;
+}
+
+/**
+ * @returns {{chain: object, decisions: object, rules: object[], grants: object, signals: string[]}}
+ */
+export function buildPolicyReport({ decisionLines = [], exceptionRecords = [], policy = null, now = new Date(), soonDays = 7 } = {}) {
+  const chain = decisionLines.length ? verifyDecisionChain(decisionLines) : { ok: true, length: 0 };
+  const { records, discarded } = parseDecisions(decisionLines);
+  const count = (d) => records.filter((r) => r.decision === d).length;
+  const chokepoints = Object.fromEntries([...Map.groupBy(records, (r) => r.chokepoint ?? "unknown")].map(([k, v]) => [k, v.length]));
+  const lastResolved = lastResolvedIndex(records);
+  const rules = tallyRules(records, policy, lastResolved);
+  const grants = tallyGrants(exceptionRecords, now, soonDays);
+  const decisions = {
+    total: records.length, discarded, allow: count("allow"), deny: count("deny"), exempt: count("exempt"),
+    open: records.filter((r, i) => r.decision === "deny" && i > lastResolved).length, chokepoints,
+  };
+  return { chain, decisions, rules, grants, signals: signalsFor(rules, grants) };
+}