karajan-code 4.21.0 → 4.23.0

package/src/cli/register-meta.js

@@ -5,6 +5,9 @@ import { architectCommand } from "../commands/architect.js";
 import { onboardCommand } from "../commands/onboard.js";
 import { startCommand } from "../commands/start.js";
 import { identityCommand } from "../commands/identity.js";
+import { policyCommand } from "../commands/policy.js";
+import { claimsCommand, claimsGateCommand } from "../commands/claims.js";
+import { stewardSweepCommand } from "../commands/steward.js";
 import { ragIndexCommand, ragQueryCommand, ragInstallHooksCommand, ragEvalCommand } from "../commands/rag.js";
 import { qmdQueryCommand } from "../commands/qmd.js";
 import { ragMcpCommand } from "../commands/rag-mcp.js";
@@ -311,6 +314,34 @@ export function registerMeta(program, { pkgVersion }) {
     });
 
   // KJC-TSK-0733 PL-A — policy as code: motor determinista en modo warn.
+  // CLM-B (KJC-TSK-0802): the data the AI states, checked against what actually ran.
+  const stewardCmd = program.command("steward").description("El Steward: gobierna el ESTADO del proyecto — invariantes con caducidad y cuatro veredictos (épica claims/steward)");
+  stewardCmd.command("sweep")
+    .description("Barrido read-only de los invariantes: deja el informe versionado en .karajan/steward/ (md + json) y sale con 1 solo si algo está ROTO — unknown y not-observable informan con su remedio")
+    .option("--if-stale <days>", "Solo barre si el informe tiene más de N días — retomar trabajo con informe fresco no re-barre")
+    .option("--json", "Machine-readable")
+    .action(async (flags) => {
+      await withConfig(pkgVersion, "steward-sweep", flags, async ({ config }) => {
+        process.exitCode = await stewardSweepCommand({ flags, config });
+      });
+    });
+  const claimsCmd = program.command("claims").description("Afirmaciones con fuente: comprueba los datos que la IA afirma en un turno contra las salidas de ese turno (ADR claims-with-evidence)");
+  claimsCmd.command("check")
+    .description("Cruza el mensaje final del turno con sus salidas — exit 2 solo si un dato está DESMENTIDO por su propia fuente; falla abierto si no puede leer el transcript")
+    .requiredOption("--transcript <path>", "Ruta del transcript de la sesión (la que pasa el hook)")
+    .option("--file <path>", "Cruza el contenido de este fichero (cuerpo de PR, card) en vez del mensaje final del turno")
+    .option("--json", "Machine-readable")
+    .action(async (flags) => { process.exitCode = await claimsCommand({ flags }); });
+  claimsCmd.command("gate")
+    .description("El mismo cruce, gobernado por method_gates.claims del proyecto (off|warn|block) — lo invocan los hooks; off = silencio, block = exit 2 solo con un dato desmentido")
+    .requiredOption("--transcript <path>", "Ruta del transcript de la sesión")
+    .option("--file <path>", "Cruza el contenido de este fichero (cuerpo de PR, card) en vez del mensaje final del turno")
+    .action(async (flags) => {
+      await withConfig(pkgVersion, "claims-gate", flags, async ({ config }) => {
+        process.exitCode = await claimsGateCommand({ flags, config });
+      });
+    });
+
   const policyCmd = program.command("policy").description("Policy as code (.karajan/policy.yml, vocabulario cerrado): eval/check deterministas, grant con caducidad, anchor del decision log — deny en commit y CI");
   policyCmd.command("eval")
     .description("Evalúa UNA tool call: imprime {decision, rule_id, reason}; --strict devuelve exit 2 en deny (contrato para adaptadores de hooks)")
@@ -320,7 +351,6 @@ export function registerMeta(program, { pkgVersion }) {
     .option("--strict", "Exit 2 si deny")
     .action(async (flags) => {
       await withConfig(pkgVersion, "policy-eval", flags, async ({ config }) => {
-        const { policyCommand } = await import("../commands/policy.js");
         process.exitCode = await policyCommand({ action: "eval", config, flags });
       });
     });
@@ -331,7 +361,6 @@ export function registerMeta(program, { pkgVersion }) {
     .option("--reason <text>", "Justificación escrita en el momento")
     .action(async (flags) => {
       await withConfig(pkgVersion, "policy-grant", flags, async ({ config }) => {
-        const { policyCommand } = await import("../commands/policy.js");
         process.exitCode = await policyCommand({ action: "grant", config, flags });
       });
     });
@@ -348,10 +377,27 @@ export function registerMeta(program, { pkgVersion }) {
     .description("Verifica la cadena del decision log y sella su head-hash en .karajan/policy-anchor.json (trackeado) — anclaje temporal en la historia de git, GOV-C2")
     .action(async (flags) => {
       await withConfig(pkgVersion, "policy-anchor", flags, async ({ config }) => {
-        const { policyCommand } = await import("../commands/policy.js");
         process.exitCode = await policyCommand({ action: "anchor", config, flags });
       });
     });
+  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("--tool <tool>", "Tool que lo usó (Bash, Edit…)")
+    .action(async (flags) => {
+      await withConfig(pkgVersion, "policy-seal", flags, async ({ config }) => {
+        process.exitCode = await policyCommand({ action: "seal", config, flags });
+      });
+    });
+  policyCmd.command("report")
+    .description("Informe determinista del decision log y las concesiones: avisos/denegaciones/exenciones por regla, denegaciones abiertas, concesiones vivas/vencidas/renovadas y señales — cadena rota = exit 1 (PL-E)")
+    .option("--soon <days>", "Días para considerar una concesión 'próxima a vencer'", "7")
+    .option("--json", "Machine-readable")
+    .action(async (flags) => {
+      await withConfig(pkgVersion, "policy-report", flags, async ({ config }) => {
+        process.exitCode = await policyCommand({ action: "report", config, flags });
+      });
+    });
   policyCmd.command("check")
     .description("Comprueba el diff (staged, o base...head con --range) contra la policy — warn por defecto; --strict devuelve exit 2 si hay violación enforcement=deny (tier C, merge-blocking)")
     .option("--role <role>", "Rol del agente", "coder")
@@ -360,7 +406,6 @@ export function registerMeta(program, { pkgVersion }) {
     .option("--json", "Machine-readable")
     .action(async (flags) => {
       await withConfig(pkgVersion, "policy-check", flags, async ({ config }) => {
-        const { policyCommand } = await import("../commands/policy.js");
         process.exitCode = await policyCommand({ action: "check", config, flags });
       });
     });
@@ -599,9 +644,10 @@ export function registerMeta(program, { pkgVersion }) {
 
   program
     .command("board [action]")
-    .description("Manage HU Board (start|stop|status|open|cleanup)")
+    .description("Manage HU Board (start|stop|status|open|cleanup) — SIN acción arranca un servidor persistente en segundo plano (equivale a `start`)")
     .option("--port <number>", "Port (default: 4000)", "4000")
     .option("--bind <host>", "Bind host (default: 127.0.0.1; use 0.0.0.0 to expose on LAN — token auth auto-enforced)")
+    .option("--force", "Arranca aunque hu_board.enabled sea false en kj.config.yml")
     .action(async (action = "start", opts) => {
       await withConfig(pkgVersion, "board", opts, async ({ config, logger }) => {
         // KJC-TSK-0684 (issue #1287): an external board is the source of
@@ -612,6 +658,21 @@ export function registerMeta(program, { pkgVersion }) {
           console.log(`⚠ this project's board lives in ${name} (state_backend: external) — kj does not run a parallel HU Board here.`);
           return;
         }
+        // KJC-BUG-0152 (issue #1427): `kj board` with no action starts a persistent server.
+        // Doing that while hu_board.enabled is false contradicts kj doctor, which reports the
+        // board as skipped — two commands saying opposite things about the same config. The
+        // system works or fails loudly; it never does the opposite of what the config says.
+        // Only `start` is gated (the bare command defaults to it): stop, status, cleanup and open
+        // never bring a server up, and blocking them would take away the way to tidy up.
+        if (config?.hu_board?.enabled === false && !opts.force && action === "start") {
+          logger.error(
+            `hu_board.enabled es false en kj.config.yml — no arranco el HU Board (kj doctor ya lo reporta como omitido).\n` +
+            `  Para arrancarlo igualmente: kj board ${action} --force\n` +
+            `  Para dejarlo activado siempre: pon hu_board.enabled: true en kj.config.yml`
+          );
+          process.exitCode = 1;
+          return;
+        }
         const port = Number(opts.port) || config.hu_board?.port || 4000;
         const bind = opts.bind || config.hu_board?.bind || "127.0.0.1";
         await boardCommand({ action, port, bind, logger });

package/src/commands/claims.js

@@ -0,0 +1,73 @@
+/**
+ * `kj claims check --transcript <path>` (CLM-B, KJC-TSK-0802) — checks the data
+ * the AI states in a turn against what actually ran in that same turn.
+ *
+ * Deterministic and free: no model in the loop. Exit 2 only when a datum is
+ * DENIED by its own source — a proven hallucination. Everything else is
+ * reported, per the accepted ADR: inform always, block almost never.
+ *
+ * It fails OPEN. A verifier that cannot read the transcript says so and gets out
+ * of the way: a broken check must never hold a session hostage.
+ */
+import { readFileSync } from "node:fs";
+import { readTurn } from "../claims/turn.js";
+import { crossCheck, formatClaimReport } from "../claims/cross-check.js";
+
+/**
+ * `kj claims gate` — the same check, run by the Stop hook with the PROJECT's
+ * say-so. The hook stays policy-free: kj reads `method_gates.claims` and
+ * decides. "off" (default: adoption is explicit) exits 0 in silence; "warn"
+ * reports and never blocks; "block" refuses only a datum DENIED by its own
+ * source — unbacked data is reported either way, per the accepted ADR:
+ * inform always, block almost never.
+ */
+export async function claimsGateCommand({ flags = {}, config = {}, logger = console, readTurnFn = readTurn, readFileFn = readFileSync } = {}) {
+  const mode = config?.method_gates?.claims ?? "off";
+  if (mode !== "warn" && mode !== "block") return 0;
+  let turn;
+  try {
+    turn = readTurnFn(flags.transcript);
+    // CLM-C: with --file the ARTIFACT is what gets checked — a PR body, a card, a
+    // note — against the same turn's outputs. The final message is what outlives
+    // the turn least; the artifact is what outlives it most.
+    if (flags.file) turn = { ...turn, text: String(readFileFn(flags.file, "utf8")) };
+  } catch {
+    return 0; // not observable: a gate that cannot read its inputs gets out of the way
+  }
+  const result = crossCheck(turn);
+  if (result.denied.length && mode === "block") {
+    logger.error(formatClaimReport(result));
+    return 2;
+  }
+  if (result.denied.length || result.unbacked.length) logger.error(formatClaimReport(result));
+  return 0;
+}
+
+export async function claimsCommand({ flags = {}, logger = console, readTurnFn = readTurn, readFileFn = readFileSync } = {}) {
+  const path = flags.transcript;
+  if (!path) {
+    logger.error("kj claims check: --transcript <path> is required");
+    return 1;
+  }
+  let turn;
+  try {
+    turn = readTurnFn(path);
+    if (flags.file) turn = { ...turn, text: String(readFileFn(flags.file, "utf8")) };
+  } catch (err) {
+    // Not observable: the transcript could not be read. Never reported as clean.
+    const note = `kj claims: transcript not readable (${err.message}) — nothing checked`;
+    if (flags.json) logger.log(JSON.stringify({ ok: true, checked: false, reason: note }));
+    else logger.error(note);
+    return 0;
+  }
+
+  const result = crossCheck(turn);
+  if (flags.json) {
+    logger.log(JSON.stringify({ ok: true, checked: true, denied: result.denied, unbacked: result.unbacked, claims: result.claims.length }));
+  } else if (result.denied.length || result.unbacked.length) {
+    logger.error(formatClaimReport(result));
+  } else {
+    logger.log(`kj claims: ${result.claims.length} dato(s) comprobado(s), todos con respaldo en este turno`);
+  }
+  return result.denied.length ? 2 : 0;
+}

package/src/commands/hu.js

@@ -43,7 +43,9 @@ export function findTitleMatches(title, allHus) {
   return { identical, similar };
 }
 
-async function backlogPlan(projectDir) {
+// Exported for the Steward's proposed-work sync (KJC-TSK-0792): broken
+// invariants land in the same backlog the brain already consumes.
+export async function backlogPlan(projectDir) {
   const plans = await listPlans(projectDir);
   const existing = plans.find((p) => p.alias === BACKLOG_NAME || p.name === BACKLOG_NAME);
   if (existing) return loadPlan(projectDir, existing.planId);

package/src/commands/init.js

@@ -862,7 +862,7 @@ export async function initCommand({ logger, flags = {} }) {
       await installAiTrashHook(logger);
     } else {
       logger.warn("ai-trash kj-trash binary not found — destructive ops unprotected.");
-      logger.warn("  Install karajan-code globally (npm i -g karajan-code) so kj-trash is on PATH.");
+      logger.warn("  Install karajan-code globally (npm i -g @karajan-family/code) so kj-trash is on PATH.");
     }
   }
 

package/src/commands/policy.js

@@ -12,7 +12,10 @@ import { createHash } from "node:crypto";
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { checkStagedDiff, evalToolCall, loadPolicy } from "../policy/engine.js";
-import { loadStandingExceptions, recordPolicyException } from "../policy/exceptions.js";
+import { loadExceptionRecords, loadStandingExceptions, recordPolicyException } from "../policy/exceptions.js";
+import { buildPolicyReport } from "../policy/report.js";
+import { policyFileHash, recordGateDecision } from "../policy/decisions.js";
+import { readIdentity } from "../identity/store.js";
 import { verifyDecisionChain } from "@karajan-family/governance";
 
 const execFileAsync = promisify(execFile);
@@ -123,6 +126,39 @@ export async function policyCommand({ action, config = {}, flags = {}, logger =
     }
   }
 
+  // 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 */ }
+    const exc = loadExceptionRecords(projectDir);
+    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}`);
+    }
+    logger.info?.(`concesiones: vivas ${g.alive.length} (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.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;
+  }
+
   if (action === "eval") {
     let input;
     try {
@@ -131,9 +167,54 @@ export async function policyCommand({ action, config = {}, flags = {}, logger =
       logger.error?.("policy eval: --input debe ser JSON válido");
       return 1;
     }
-    const verdict = evalToolCall(policy, { role: flags.role || "coder", tool: flags.tool, input, root: projectDir });
+    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 verdict.decision === "deny" && flags.strict ? 2 : 0;
+    return strictDeny ? 2 : 0;
+  }
+
+  // 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") {
+    if (!flags.escape) {
+      logger.error?.("policy seal: --escape <KJ_ALLOW_X> es obligatorio — un escape 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}` : ""})`);
+      return 0;
+    } catch (err) {
+      logger.error?.(`policy seal: ${err.message}`);
+      return 1;
+    }
   }
 
   // check — staged por defecto, base...head con --range (CI). Warn salvo

package/src/commands/privacy.js

@@ -28,9 +28,12 @@ export async function privacyScanCommand({ paths = [], flags = {}, logger = cons
   const warns = findings.filter((f) => f.severity === "warn");
   const ok = blocks.length === 0;
   process.exitCode = ok ? 0 : 1;
+  // KJC-TSK-0797 AC4: "nothing found" and "found but explained by context"
+  // are different truths — the report says which one it is.
+  const discarded = findings.discardedByContext || 0;
   // --json keeps stdout machine-clean: exactly one JSON document, no prose.
   if (flags.json) {
-    process.stdout.write(`${JSON.stringify({ ok, blocks: blocks.length, warns: warns.length, findings })}\n`);
+    process.stdout.write(`${JSON.stringify({ ok, blocks: blocks.length, warns: warns.length, discardedByContext: discarded, findings })}\n`);
     return { ok, findings };
   }
   for (const f of blocks) logger.error?.(`✗ BLOCK [${f.type}] ${f.source}:${f.line} → ${f.masked}`);
@@ -38,8 +41,9 @@ export async function privacyScanCommand({ paths = [], flags = {}, logger = cons
   if (!list.present) {
     logger.info?.(`hint: no personal denylist found — create ${privacyConfigPath()} (personal: [...], allow: [...]) so YOUR data blocks, not just warns`);
   }
+  const context = discarded > 0 ? `; ${discarded} candidate(s) discarded by context — git SHAs / documentation domains` : "";
   logger.info?.(ok
-    ? `privacy scan: clean of denylist hits (${warns.length} generic warning(s))`
+    ? `privacy scan: clean of denylist hits (${warns.length} generic warning(s)${context})`
     : `privacy scan: ${blocks.length} personal-data hit(s) — this must not ship`);
   return { ok, findings };
 }

package/src/commands/resume.js

@@ -1,5 +1,6 @@
 import { EventEmitter } from "node:events";
 import { resumeFlow } from "../orchestrator.js";
+import { sweepOnResume } from "./steward.js";
 import { createActivityLog } from "../activity-log.js";
 import { printEvent } from "../utils/display/event-handlers.js";
 import { withCliRunLog } from "../utils/cli-run-log.js";
@@ -9,6 +10,9 @@ import { createCliAskQuestion } from "../utils/cli-ask-question.js";
 export async function resumeCommand({ sessionId, answer, config, logger, flags }) {
   const jsonMode = flags?.json;
   const quietMode = config.output?.quiet !== false;
+  // STW-E (KJC-TSK-0793): resuming work is when someone is in front to review
+  // the state — sweep if the report went stale; adoption stays explicit.
+  await sweepOnResume({ config, logger });
 
   // Same wrapper as every other CLI command — without it `.kj/run.log`
   // is never opened during the resume and `kj-tail` stays silent

package/src/commands/review-gate.js

@@ -12,7 +12,7 @@ import { checkVerdict, diffHash } from "../review/verdict-store.js";
 import { runOneShotReview } from "../review/one-shot-review.js";
 import { runSolomonArbitration } from "../review/solomon-arbitration.js";
 import { ensureGateTrackable } from "../review/gate-gitignore.js";
-import { runSonarPregate, formatSonarFinding } from "../review/sonar-pregate.js";
+import { runSonarPregate, formatSonarFinding, addedLinesByFile } from "../review/sonar-pregate.js";
 import { runMutationPregate, formatSurvivor } from "../review/mutation-pregate.js";
 import { checkCardFirst } from "../review/card-first.js";
 import { checkTestsWithCode } from "../review/tests-with-code.js";
@@ -162,16 +162,23 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
     const numstat = await rawDiff(flags.range, ["--numstat"]);
     const added = numstat.split("\n").reduce((acc, l) => acc + (Number(l.split("\t")[0]) || 0), 0);
     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") {
         console.log(`⚠ pr-size exempt: ${added} lines added — KJ_ALLOW_LARGE_PR=1 (explicit escape hatch)`);
       } else if (sizePolicy === "block") {
-        const reason = `${added} lines added exceeds the ${sizeWarn}-line budget (${sizeSource}; method_gates.pr_size: block) — partition the work, or get your user's explicit OK and re-run with KJ_ALLOW_LARGE_PR=1`;
+        const reason = `${added} lines added${split} exceeds the ${sizeWarn}-line budget (${sizeSource}; method_gates.pr_size: block) — partition the work, or get your user's explicit OK and re-run with KJ_ALLOW_LARGE_PR=1`;
         console.log(`✗ pr-size gate: ${reason}`);
         process.exitCode = 1;
         return { verdict: "rejected", reviewer: "pr-size", issues: [{ severity: "high", description: reason }] };
       } else {
-        console.log(`⚠ pr-size: ${added} lines added (guideline ~${sizeWarn}, source: ${sizeSource}) — an oversized warning is not an opinion: partition, or ask your user (method_gates.pr_size: block to harden)`);
+        console.log(`⚠ pr-size: ${added} lines added${split} (guideline ~${sizeWarn}, source: ${sizeSource}) — an oversized warning is not an opinion: partition, or ask your user (method_gates.pr_size: block to harden)`);
       }
     }
   }
@@ -213,7 +220,12 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
     }
   }
 
-  const tests = checkTestsWithCode({ config, stagedFiles: changedFiles });
+  // KJC-TSK-0795 AC1: hand the gate the numbers so a delete-only diff is
+  // exempt — deleting code adds no behavior to test.
+  const numstat = (await rawDiff(flags.range, ["--numstat"])).split("\n").map((l) => l.trim()).filter(Boolean)
+    .map((l) => { const [a, r, ...f] = l.split(/\s+/); return { file: f.join(" "), added: a === "-" ? 1 : Number(a) || 0, removed: r === "-" ? 0 : Number(r) || 0 }; });
+  const tests = checkTestsWithCode({ config, stagedFiles: changedFiles, numstat });
+  if (tests.mode === "delete-only") console.log(`⚠ tests-with-code: exempt — ${tests.reason}`);
   if (tests.mode === "warn") console.log(`⚠ tests-with-code: ${tests.reason}`);
   if (tests.mode === "exempt") console.log(`⚠ tests-with-code exempt: ${tests.reason}`);
   if (!tests.ok) {
@@ -289,8 +301,10 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
     console.log(res.ok
       ? `✓ verdict ok — approved by ${res.verdict.reviewer} (diff ${res.verdict.diffHash.slice(0, 12)})`
       : `✗ ${res.reason}`);
-    // GOV-C: el allow del chokepoint de COMMIT es evidencia — se sella.
-    if (res.ok) seal("allow");
+    // GOV-C: el allow del chokepoint de COMMIT es evidencia — se sella. PL-E
+    // (KJC-TSK-0767): con las reglas que AVISARON, para que "nace avisando y
+    // gana dientes" se decida con datos (kj policy report), no a ciegas.
+    if (res.ok) seal("allow", gate.warns.length > 0 ? { warn_rule_ids: gate.warns.map((w) => w.rule_id) } : {});
     process.exitCode = res.ok ? 0 : 1;
     return res;
   }
@@ -301,15 +315,26 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
   // the cross-AI reviewer weighs them. Unavailable sonar degrades loudly.
   let task = flags.task;
   if (flags.sonar !== false) {
-    const pre = await runSonarPregate({ config, stagedFiles: changedFiles, logger });
+    // KJC-TSK-0795 AC3: only issues on lines this diff ADDS may veto.
+    const touchedLines = addedLinesByFile(await rawDiff(flags.range, ["--unified=0"]));
+    const pre = await runSonarPregate({ config, stagedFiles: changedFiles, touchedLines, logger });
     if (!pre.available) {
-      console.log(`⚠ sonar pre-gate skipped: ${pre.reason}`);
+      // KJC-BUG-0156 (issue #1543): a scan that FAILED must not read like one
+      // more config warning — it hid a dead quality gate for 8 straight PRs.
+      // Still fail-open (a laptop without Docker still commits), but SAID.
+      const chosen = /disabled in config/.test(pre.reason || "");
+      console.log(chosen
+        ? `⚠ sonar pre-gate skipped: ${pre.reason}`
+        : `✗ sonar pre-gate UNAVAILABLE — the quality gate did NOT run on this diff: ${pre.reason}`);
     } else {
       const found = [...pre.blocking, ...pre.advisory];
       if (found.length > 0) {
-        console.log(`Sonar on the changed files — ${pre.blocking.length} blocking, ${pre.advisory.length} advisory (project total: ${pre.totalProject}):`);
+        console.log(`Sonar on the changed lines — ${pre.blocking.length} blocking, ${pre.advisory.length} advisory (project total: ${pre.totalProject}):`);
         for (const f of found) console.log(`  - ${formatSonarFinding(f)}`);
       }
+      if ((pre.preexisting || []).length > 0) {
+        console.log(`⚠ sonar trend: ${pre.preexisting.length} preexisting issue(s) on untouched lines of these files — not this PR's veto, but the debt is real`);
+      }
       if (pre.blocking.length > 0) {
         console.log("✗ REJECTED by sonar (deterministic) — fix the blocking findings; the cross-AI reviewer was not invoked.");
         process.exitCode = 1;

package/src/commands/steward.js

@@ -0,0 +1,146 @@
+/**
+ * `kj steward sweep` (STW-B, KJC-TSK-0790, epic KJC-PCS-0081) — a READ-ONLY
+ * pass over the Steward invariants that leaves the verdict IN THE REPO:
+ * `.karajan/steward/report.md` (a person: verdict, last evidence, and the
+ * command that renews each invariant) and `report.json` (a machine — and the
+ * BASELINE the next sweep compares against: the versioned report is the
+ * shared memory, never a record on one machine). Exit 1 only when something
+ * is BROKEN — unknown and not-observable inform with their remedy.
+ */
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import {
+  VERDICTS, resolveFreshness, evaluateMainCi, evaluateSecurityAudit,
+  evaluateVulnAging, evaluateDeadCodeTrend, evaluateCoverageConfig,
+  evaluatePhantomCoverage, runInvariants,
+} from "../steward/invariants.js";
+import { loadPreviousAudit } from "../audit/basal-cost.js";
+import { collectOsvFindings } from "../audit/osv-findings.js";
+import { recordGateDecision } from "../policy/decisions.js";
+import { syncProposedWork } from "../steward/proposed-work.js";
+
+const stewardDir = (projectDir) => path.join(projectDir, ".karajan", "steward");
+
+/** `gh run list` for push runs on the base branch — the sweep's default probe. */
+const ghRuns = (projectDir, baseBranch) => () => {
+  const out = execFileSync("gh", ["run", "list", "--branch", baseBranch, "--event", "push", "--limit", "30", "--json", "name,conclusion,createdAt"], { cwd: projectDir, encoding: "utf8", timeout: 30_000 });
+  return JSON.parse(out).map((r) => ({ workflow: r.name, conclusion: r.conclusion, createdAt: r.createdAt }));
+};
+
+const readJson = (file) => { try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch { return null; } };
+
+export async function stewardSweepCommand({ flags = {}, config = {}, logger = console, probes = {} } = {}) {
+  const projectDir = config.projectDir || process.cwd();
+  const baseBranch = config.base_branch || "main";
+  // STW-E (KJC-TSK-0793): --if-stale <days> — resuming work with a fresh
+  // report does not re-sweep; the report in the repo stays the ONE source.
+  if (flags.ifStale !== undefined) {
+    const prev = readJson(path.join(stewardDir(projectDir), "report.json"));
+    const ageMs = prev?.sweptAt ? (probes.nowMs ?? Date.now()) - Date.parse(prev.sweptAt) : Infinity;
+    if (ageMs < Number(flags.ifStale) * 86_400_000) {
+      logger.info?.(`steward: report is fresh (swept ${prev.sweptAt}) — not re-sweeping`);
+      return 0;
+    }
+  }
+  const freshness = resolveFreshness(config);
+  const nowMs = probes.nowMs ?? Date.now();
+  const runsFn = probes.runsFn ?? ghRuns(projectDir, baseBranch);
+
+  // Live osv probe (best-effort): unavailable is null → the invariant answers
+  // unknown with its remedy, never a clean bill.
+  let vulns = probes.vulns ?? null;
+  if (vulns === null) {
+    try {
+      const osv = await (probes.osvFn ?? collectOsvFindings)(projectDir, logger);
+      if (osv?.available) vulns = (osv.vulnerabilities || []).map((v) => ({ id: v.id, severity: v.severity, publishedAt: v.publishedAt ?? null }));
+    } catch { /* stays null — unknown */ }
+  }
+
+  // Dead-code baseline: the PREVIOUS report in the repo — shared memory.
+  const prevReport = readJson(path.join(stewardDir(projectDir), "report.json"));
+  const snapshot = await loadPreviousAudit(projectDir).catch(() => null);
+  const deadNow = typeof snapshot?.knipDeadExports?.exports === "number"
+    ? { deadExports: snapshot.knipDeadExports.exports + (snapshot.knipDeadExports.files || 0) }
+    : Array.isArray(snapshot?.deadExports) ? { deadExports: snapshot.deadExports.length } : null;
+
+  const invariants = [
+    { id: "main-ci", renew: "push to the base branch (or fix the red run)", evaluate: () => evaluateMainCi({ projectDir, baseBranch, freshness: freshness.values, runsFn, nowMs }) },
+    { id: "security-audit", renew: "kj audit --security", evaluate: () => evaluateSecurityAudit({ projectDir, freshness: freshness.values, nowMs }) },
+    { id: "vulnerable-deps", renew: "kj audit (osv-scanner)", evaluate: () => evaluateVulnAging({ vulns, freshness: freshness.values, nowMs }) },
+    { id: "dead-code-trend", renew: "kj audit (knip inventory)", evaluate: () => evaluateDeadCodeTrend({ current: deadNow, previous: prevReport?.deadCodeBaseline ?? null }) },
+    { id: "coverage-config", renew: "configure a coverage threshold", evaluate: () => evaluateCoverageConfig({ projectDir }) },
+    { id: "phantom-coverage", renew: "KJC-TSK-0800 ships the detectors", evaluate: () => evaluatePhantomCoverage() },
+  ];
+  const results = runInvariants(invariants, {}).map((r, i) => ({ ...r, renew: invariants[i].renew }));
+  const broken = results.filter((r) => r.verdict === VERDICTS.BROKEN);
+
+  const report = {
+    sweptAt: new Date(nowMs).toISOString(),
+    baseBranch,
+    freshness: { ...freshness.values, declared: freshness.declared },
+    invariants: results,
+    deadCodeBaseline: deadNow ? { ...deadNow, timestamp: new Date(nowMs).toISOString() } : (prevReport?.deadCodeBaseline ?? null),
+  };
+  const mark = { [VERDICTS.OK]: "✓", [VERDICTS.BROKEN]: "✗", [VERDICTS.UNKNOWN]: "?", [VERDICTS.NOT_OBSERVABLE]: "∅" };
+  const md = [
+    "# Steward report",
+    "", `Last swept: ${report.sweptAt}`, "",
+    `Freshness: ${freshness.declared ? "declared by the project" : "calibrated defaults (the project declared none)"} — ${Object.entries(freshness.values).map(([k, v]) => `${k}=${v}`).join(", ")}`, "",
+    ...results.map((r) => [
+      `## ${mark[r.verdict] || "?"} ${r.id} — ${r.verdict}`,
+      `- evidence: ${r.evidence || "(none)"}`,
+      ...(r.remedy ? [`- remedy: ${r.remedy}`] : []),
+      `- renews with: ${r.renew}`, "",
+    ]).flat(),
+  ].join("\n");
+
+  fs.mkdirSync(stewardDir(projectDir), { recursive: true });
+  fs.writeFileSync(path.join(stewardDir(projectDir), "report.md"), md);
+  fs.writeFileSync(path.join(stewardDir(projectDir), "report.json"), `${JSON.stringify(report, null, 2)}\n`);
+
+  // Every sweep is SEALED in the decision chain — the same criterion policy
+  // decisions already meet: recorded and verifiable, not just notified.
+  try {
+    const counts = {};
+    for (const r of results) counts[r.verdict] = (counts[r.verdict] || 0) + 1;
+    recordGateDecision(projectDir, { kind: "steward-sweep", verdicts: { ok: counts[VERDICTS.OK] || 0, broken: broken.length, unknown: counts[VERDICTS.UNKNOWN] || 0, "not-observable": counts[VERDICTS.NOT_OBSERVABLE] || 0 }, broken_ids: broken.map((b) => b.id) });
+  } catch (err) { logger.warn?.(`⚠ steward: the sweep could not be sealed in the decision chain (${err.message})`); }
+
+  // STW-D (KJC-TSK-0792): every break is PROPOSED work on the board the brain
+  // already consumes. AFTER the report and the seal: a board failure never
+  // costs either, and it is said loudly — never swallowed.
+  try {
+    const sync = await syncProposedWork({ projectDir, config, results, sweptAt: report.sweptAt });
+    if (!sync.synced) logger.warn?.(`⚠ steward: broken invariants not carded — ${sync.reason}`);
+    else if (sync.created || sync.updated || sync.resolved) logger.info?.(`steward board: ${sync.created} card(s) proposed, ${sync.updated} updated, ${sync.resolved} resolved`);
+  } catch (err) { logger.warn?.(`⚠ steward: carding the broken invariants failed (${err.message}) — the report and the seal stand`); }
+
+  // A report nobody can see is not shared state — say it, do not fix their tree.
+  try {
+    execFileSync("git", ["check-ignore", "-q", path.join(".karajan", "steward", "report.md")], { cwd: projectDir });
+    logger.warn?.("⚠ steward: the report path is gitignored — untrack .karajan/steward from .gitignore so the state is shared");
+  } catch { /* not ignored — good */ }
+
+  if (flags.json) {
+    process.stdout.write(`${JSON.stringify(report)}\n`);
+  } else {
+    for (const r of results) logger.info?.(`${mark[r.verdict]} ${r.id}: ${r.verdict}${r.verdict === VERDICTS.OK ? "" : ` — ${r.remedy || r.evidence}`}`);
+    logger.info?.(broken.length ? `steward: ${broken.length} invariant(s) BROKEN — the report names them (.karajan/steward/report.md)` : "steward: nothing broken — the full state is in .karajan/steward/report.md");
+  }
+  process.exitCode = broken.length ? 1 : 0;
+  return broken.length ? 1 : 0;
+}
+
+/**
+ * STW-E — the on-resume mode: when work resumes there is someone in front to
+ * review the report, which is the requirement. Only for projects that ADOPTED
+ * the Steward (a report exists, or method_gates.steward is declared): the
+ * default imposes nothing. Best-effort: a failed sweep never stops a resume.
+ */
+export async function sweepOnResume({ config = {}, logger = console, sweepFn = stewardSweepCommand } = {}) {
+  const projectDir = config.projectDir || process.cwd();
+  const adopted = fs.existsSync(path.join(stewardDir(projectDir), "report.json")) || Boolean(config.method_gates?.steward);
+  if (!adopted) return;
+  try { await sweepFn({ flags: { ifStale: 1 }, config, logger }); } catch (err) { logger.warn?.(`⚠ steward: on-resume sweep failed (${err.message}) — resuming anyway`); }
+}

package/src/config/defaults.js

@@ -80,7 +80,12 @@ const DEFAULTS = {
     tests_with_code: "warn",
     // MG-C: informative nudge when the staged diff exceeds this many
     // added lines (0 disables). The project's CI owns any hard budget.
-    pr_size_warn: 150
+    pr_size_warn: 150,
+    // CLM-B (claims-with-evidence ADR): the Stop gate crosses the hard data of
+    // the turn's final message against that turn's tool outputs. "off" (adoption
+    // is explicit) | "warn" (report only) | "block" (a datum DENIED by its own
+    // source refuses to end the turn; unbacked data is still only reported).
+    claims: "off"
   },
   review_rules: "./.karajan/review-rules.md",
   coder_rules: "./.karajan/coder-rules.md",