karajan-code 4.22.0 → 4.23.0

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) {
@@ -303,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",

package/src/harden/sentinel-hooks.js

@@ -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);
@@ -136,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") {
@@ -230,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
@@ -252,12 +281,31 @@ 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());
@@ -292,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/;
@@ -301,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.
@@ -681,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)) {
@@ -714,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" });

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/privacy/scan.js

@@ -52,12 +52,25 @@ const SECRET_HEURISTICS = [
   { type: "conn-string", re: /\b[a-z][a-z0-9+.-]*:\/\/[^\s:@/]+:([^\s@/]+)@/gi },
 ];
 
+// KJC-TSK-0797 (epic KJC-PCS-0082) — context BEFORE generics, measured twice:
+// GREBLA's pinned Actions reported as phone numbers, and this repo's own
+// workflow pinning flagged twelve times in one PR. A git object id is not a
+// phone; an email on an RFC 2606 documentation domain is not a person. Both
+// are blanked before redactPII and COUNTED, so a clean result can say
+// "nothing found" or "found and discarded by context" — never the same thing.
+// The personal denylist runs before this: the user's own datum always blocks.
+const CONTEXT_DISCARDS = [
+  { type: "git-sha", re: /\b(?:[0-9a-f]{64}|[0-9a-f]{40})\b/g },
+  { type: "doc-domain-email", re: /\b[A-Za-z0-9._%+-]+@(?:[A-Za-z0-9-]+\.)*(?:example\.(?:com|org|net)|test|invalid|localhost|example)\b/g },
+];
+
 /**
  * Scan a text. Returns findings — denylist hits as `severity:"block"`
  * (masked value), generic PII as `severity:"warn"` (line already redacted).
  */
 export function scanText(text, { list = loadPrivacyList(), source = "<text>" } = {}) {
   const findings = [];
+  let discarded = 0;
   String(text).split("\n").forEach((line, i) => {
     let probe = line;
     for (const a of list.allow) probe = probe.split(a).join(" ");
@@ -86,6 +99,10 @@ export function scanText(text, { list = loadPrivacyList(), source = "<text>" } =
         re.lastIndex = m.index + m[0].length;
       }
     }
+    for (const { re } of CONTEXT_DISCARDS) {
+      re.lastIndex = 0;
+      probe = probe.replace(re, (m) => { discarded += 1; return " ".repeat(m.length); });
+    }
     const red = redactPII(probe);
     if (red.total > 0) {
       for (const [type, n] of Object.entries(red.counts)) {
@@ -93,12 +110,14 @@ export function scanText(text, { list = loadPrivacyList(), source = "<text>" } =
       }
     }
   });
+  findings.discardedByContext = discarded;
   return findings;
 }
 
 /** Scan files/dirs recursively (skips node_modules/.git, binaries, big files). */
 export function scanPaths(paths, { list = loadPrivacyList() } = {}) {
   const findings = [];
+  let discarded = 0;
   const visit = (p) => {
     if (!existsSync(p)) return;
     // Skip symlinks: an ancestor link recurses forever; an outside link ships nothing.
@@ -113,8 +132,11 @@ export function scanPaths(paths, { list = loadPrivacyList() } = {}) {
     if (BINARY_EXT.has(extname(p).toLowerCase()) || st.size > MAX_FILE_BYTES) return;
     const content = readFileSync(p);
     if (content.includes(0)) return; // binary sniff: NUL byte
-    findings.push(...scanText(content.toString("utf8"), { list, source: p }));
+    const fileFindings = scanText(content.toString("utf8"), { list, source: p });
+    discarded += fileFindings.discardedByContext || 0;
+    findings.push(...fileFindings);
   };
   for (const p of paths) visit(p);
+  findings.discardedByContext = discarded;
   return findings;
 }

package/src/review/sonar-pregate.js

@@ -28,13 +28,38 @@ export function formatSonarFinding(issue) {
   return `(${issue.severity}) [${issueFile(issue)}${line}] ${issue.rule} — ${issue.message}`;
 }
 
+/**
+ * KJC-TSK-0795 AC3: the NEW line numbers each file gains in a unified diff
+ * (`git diff --unified=0`). Only what the diff ADDS can be the author's fault.
+ * @param {string} diffText @returns {Map<string, Set<number>>}
+ */
+export function addedLinesByFile(diffText) {
+  const map = new Map();
+  let current = null;
+  for (const raw of String(diffText || "").split("\n")) {
+    if (raw.startsWith("+++ ")) {
+      const p = raw.slice(4).trim();
+      current = p.startsWith("b/") ? p.slice(2) : p === "/dev/null" ? null : p;
+      continue;
+    }
+    const h = current ? /^@@ [^+]*\+(\d+)(?:,(\d+))? @@/.exec(raw) : null;
+    if (!h) continue;
+    const start = Number(h[1]);
+    const count = h[2] === undefined ? 1 : Number(h[2]);
+    if (count === 0) continue;
+    const set = map.get(current) ?? map.set(current, new Set()).get(current);
+    for (let i = 0; i < count; i++) set.add(start + i);
+  }
+  return map;
+}
+
 /**
  * Scan the project (single-flight via the tool governor) and return the
  * open issues that live on the staged files, split by blocking severity.
  * Every failure path degrades to {available:false, reason} — the pre-gate
  * never breaks the review, it only refuses to stay silent.
  */
-export async function runSonarPregate({ config, stagedFiles = [], logger = null }) {
+export async function runSonarPregate({ config, stagedFiles = [], touchedLines = null, logger = null }) {
   if (config?.review_gate?.sonar === false) {
     return { available: false, reason: "disabled in config (review_gate.sonar: false)" };
   }
@@ -42,16 +67,26 @@ export async function runSonarPregate({ config, stagedFiles = [], logger = null
   try {
     lock = await acquireToolLock("sonar-scanner", { timeoutMs: 300_000 });
     const scan = await runSonarScan(config);
+    if (scan.note) logger?.warn?.(scan.note); // KJC-BUG-0156: precedence is said, never silent
     if (!scan.ok) {
       return { available: false, reason: (scan.stderr || scan.stdout || "sonar scan failed").trim() };
     }
+    // The scan above ALWAYS runs before issues are read (single-flight): the
+    // verdict is about the code as it is now, never a stale server analysis
+    // (KJC-TSK-0795 AC2 — that failure mode has no route here, by design).
     const res = await getOpenIssues(config, scan.projectKey);
     const staged = new Set(stagedFiles);
     const onStaged = (res.issues || []).filter((i) => staged.has(issueFile(i)));
+    // KJC-TSK-0795 AC3: with the diff's line map, only issues on lines the PR
+    // ADDS can veto — a 3-line PR must not answer for 30 preexisting issues.
+    // No line, or an untouched line, is the file's TREND: reported, never a block.
+    const isTouched = (i) => !touchedLines || (i.line != null && touchedLines.get(issueFile(i))?.has(Number(i.line)));
+    const own = onStaged.filter(isTouched);
     return {
       available: true,
-      blocking: onStaged.filter((i) => BLOCKING_SEVERITIES.has(String(i.severity).toUpperCase())),
-      advisory: onStaged.filter((i) => !BLOCKING_SEVERITIES.has(String(i.severity).toUpperCase())),
+      blocking: own.filter((i) => BLOCKING_SEVERITIES.has(String(i.severity).toUpperCase())),
+      advisory: own.filter((i) => !BLOCKING_SEVERITIES.has(String(i.severity).toUpperCase())),
+      preexisting: touchedLines ? onStaged.filter((i) => !isTouched(i)) : [],
       totalProject: res.total ?? (res.issues || []).length,
     };
   } catch (err) {