karajan-code 4.33.0 → 4.35.0

package/package.json

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

package/src/agents/base-agent.js

@@ -34,6 +34,28 @@ export class BaseAgent {
     this.environment = environment;
   }
 
+  /**
+   * KJC-BUG-0217 (issue #1409) — los flags con los que kj invoca el CLI de un
+   * provider eran una constante del codigo, y hay versiones que rechazan la
+   * combinacion: kimi-code 0.27.0 responde "Cannot combine --prompt with
+   * --yolo" y dejaba `kj agent run` inutilizable, sin mas salida que parchear
+   * kj. Ahora el proyecto puede declararlos:
+   *
+   *   agents: { kimi: { task_args: [], review_args: [] } }
+   *
+   * Sin declaracion valen los de siempre. Una declaracion que no sea una lista
+   * de cadenas se ignora: la config no puede romper la invocacion.
+   *
+   * @param {"task"|"review"} kind
+   * @param {string[]} fallback
+   * @returns {string[]}
+   */
+  declaredArgs(kind, fallback) {
+    const declared = this.config?.agents?.[this.name]?.[`${kind}_args`];
+    if (!Array.isArray(declared) || declared.some((a) => typeof a !== "string")) return fallback;
+    return declared;
+  }
+
   /**
    * Run a shell command through the injected CommandRunner. Subclasses should
    * call this instead of importing runCommand directly so tests can swap in

package/src/agents/kimi-agent.js

@@ -1,6 +1,9 @@
 import { BaseAgent } from "./base-agent.js";
 import { resolveBin } from "./resolve-bin.js";
 
+/** El rechazo de kimi-code 0.27.0 a `-p` junto con `-y`, en su forma literal. */
+const REJECTS_COMBINATION = /cannot combine .* with /i;
+
 /**
  * Kimi Code (Moonshot, binary `kimi`) — KJC-TSK-0729 fase 2: the eighth
  * built-in agent and the free-tier reserve of the reviewer/solomon panel.
@@ -17,7 +20,7 @@ import { resolveBin } from "./resolve-bin.js";
 export class KimiAgent extends BaseAgent {
   async runTask(task) {
     // Coder mode IS an agentic run: file edits and shell need approval.
-    return this._exec(task, this.getRoleModel(task.role || "coder"), ["-y"]);
+    return this._exec(task, this.getRoleModel(task.role || "coder"), this.declaredArgs("task", ["-y"]));
   }
 
   async reviewTask(task) {
@@ -27,7 +30,7 @@ export class KimiAgent extends BaseAgent {
     return this._exec(
       { ...task, prompt: `Do NOT use any tools. Answer directly from this prompt only.\n\n${task.prompt}` },
       this.getRoleModel(task.role || "reviewer"),
-      [],
+      this.declaredArgs("review", []),
     );
   }
 
@@ -40,6 +43,12 @@ export class KimiAgent extends BaseAgent {
       timeout: task.timeoutMs,
       cwd: task.cwd,
     });
-    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+    // KJC-BUG-0217 (issue #1409): el CLI puede rechazar la COMBINACION de flags
+    // (kimi-code 0.27.0: "Cannot combine --prompt with --yolo"). Ese error crudo
+    // no dice que hacer; el de kj si.
+    const error = REJECTS_COMBINATION.test(String(res.stderr || ""))
+      ? `${res.stderr}\n\nkimi rechaza la combinacion de flags con la que kj lo invoca. Declara los que acepta esta version: agents.kimi.task_args (una lista vacia deja el prompt solo, sin auto-aprobado).`
+      : res.stderr;
+    return { ok: res.exitCode === 0, output: res.stdout, error, exitCode: res.exitCode };
   }
 }

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

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

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

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

package/src/checks/release-check.js

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

package/src/cli/register-meta.js

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

package/src/commands/code.js

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

package/src/commands/harden.js

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

package/src/commands/policy.js

@@ -15,6 +15,8 @@ import { checkStagedDiff, evalToolCall, loadPolicy } from "../policy/engine.js";
 import { liftSealedSupervisorViolations } from "../policy/supervisor-verify.js";
 import { loadExceptionRecords, loadGlobalExceptionRecords, loadStandingExceptions, recordPolicyException } from "../policy/exceptions.js";
 import { buildPolicyReport } from "../policy/report.js";
+import { budgetedNet } from "../review/loc-budget.js";
+import { sealPanel } from "../environment/panel.js";
 import { policyFileHash, recordGateDecision } from "../policy/decisions.js";
 import { readIdentity } from "../identity/store.js";
 import { verifyDecisionChain } from "@karajan-family/governance";
@@ -32,12 +34,10 @@ async function stagedFacts(projectDir, gitFn, range = null) {
     .split("\n")
     .map((s) => s.trim())
     .filter(Boolean);
-  let net = 0;
-  for (const line of (await run([...base, "--numstat"])).split("\n")) {
-    const [a, r] = line.trim().split(/\s+/);
-    if (a && a !== "-") net += Number(a) || 0;
-    if (r && r !== "-") net -= Number(r) || 0;
-  }
+  // KJC-BUG-0208: el presupuesto lo decide un solo modulo. Este sitio sumaba el
+  // numstat entero, asi que el job policy-check de CI contaba la documentacion
+  // y el gate bloqueante no: la misma regla con dos respuestas.
+  const { net } = budgetedNet(await run([...base, "--numstat"]));
   return { files, netLinesAdded: net };
 }
 
@@ -209,18 +209,23 @@ export async function policyCommand({ action, config = {}, flags = {}, logger =
   // identidad DECLARADA del clon (identity.local.yml), para que el informe
   // y el anchor la vean. Lo llama el Sentinel; cualquiera puede auditarlo.
   if (action === "seal") {
-    if (!flags.escape) {
-      logger.error?.("policy seal: --escape <KJ_ALLOW_X> es obligatorio — un escape sin nombre no es auditable");
+    // KJC-TSK-0868: el mismo asiento sirve para el panel — el anfitrión escribió
+    // teniendo otro coder declarado. Mismo log encadenado, otro chokepoint.
+    if (!flags.escape && !flags.panel) {
+      logger.error?.("policy seal: --escape <KJ_ALLOW_X> o --panel <coder> es obligatorio — un asiento sin nombre no es auditable");
       return 1;
     }
     try {
       const who = readIdentity(projectDir);
-      const rec = recordGateDecision(projectDir, {
-        decision: "exempt", chokepoint: "tool", escape: flags.escape, tool: flags.tool ?? null,
-        who: who ? { gh: who.gh_user ?? null, git: who.git_email ?? null, grade: "declarada" } : null,
-        policy_hash: policyFileHash(projectDir),
-      });
-      logger.info?.(`✓ escape ${rec.escape} sellado (chokepoint tool${rec.tool ? `, ${rec.tool}` : ""})`);
+      const rec = flags.panel
+        ? sealPanel({ projectDir, coder: flags.panel, host: flags.host ?? null, honoured: Boolean(flags.honoured) })
+        : recordGateDecision(projectDir, {
+          decision: "exempt", chokepoint: "tool", escape: flags.escape, tool: flags.tool ?? null,
+          who: who ? { gh: who.gh_user ?? null, git: who.git_email ?? null, grade: "declarada" } : null,
+          policy_hash: policyFileHash(projectDir),
+        });
+      if (rec.chokepoint === "panel") logger.info?.(`✓ panel sellado: el coder declarado es ${rec.coder} y escribió ${rec.host ?? "el anfitrión"}`);
+      else logger.info?.(`✓ escape ${rec.escape} sellado (chokepoint tool${rec.tool ? `, ${rec.tool}` : ""})`);
       return 0;
     } catch (err) {
       logger.error?.(`policy seal: ${err.message}`);
@@ -238,6 +243,8 @@ export async function policyCommand({ action, config = {}, flags = {}, logger =
   const sup = liftSealedSupervisorViolations({ projectDir, violations });
   if (sup.lifted > 0) {
     logger.info?.(`✓ policy: ${sup.lifted} fichero(s) de supervisor verificados contra la provenance sellada (ADR 0009)`);
+    // KJC-BUG-0212: lo que este sitio no ha podido juzgar se dice, no se calla.
+    if (sup.note) logger.info?.(`ℓ policy: ${sup.note}`);
     violations = sup.violations;
   }
   const hard = flags.strict ? violations.filter((v) => v.enforcement === "deny") : [];

package/src/commands/rag.js

@@ -5,6 +5,7 @@
 import { openVecStore, countChunks, projectSlug, getLastIndexedCommit, setLastIndexedCommit } from "../rag/vec-store.js";
 import { makeGovernedEmbedder } from "../rag/governed-embedder.js";
 import { indexProject, indexProjectDelta } from "../rag/indexer.js";
+import { fileIndexState } from "../rag/coverage.js";
 import { query } from "../rag/retriever.js";
 import { installPostMergeHook, maybeAutoUpdate } from "../rag/auto-update.js";
 import { indexLibrary, LIBRARY_PROJECT } from "../rag/library.js";
@@ -171,3 +172,23 @@ export async function ragEvalCommand({ config, logger, flags = {} }) {
     db.close();
   }
 }
+
+/**
+ * KJC-BUG-0216 (issue #1807) — el hecho comprobable que el gate rag-first
+ * necesita antes de exigir una consulta: PUEDE el RAG responder sobre este
+ * fichero. Exit 0 = si; exit 1 = no, y la razon (sin adapter, segmento
+ * excluido, indice vacio o por detras) va en la salida.
+ */
+export async function ragCoversCommand({ file, config, flags = {} }) {
+  const projectDir = config?.projectDir || process.cwd();
+  const db = openDb(config);
+  try {
+    const state = fileIndexState(projectDir, file, { db });
+    if (flags.json) process.stdout.write(`${JSON.stringify(state)}\n`);
+    else process.stdout.write(`${state.state}: ${state.reason}\n`);
+    if (!state.canAnswer) process.exitCode = 1;
+    return state;
+  } finally {
+    db.close();
+  }
+}

package/src/commands/report.js

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

package/src/commands/review-gate.js

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

package/src/config/defaults.js

@@ -68,7 +68,10 @@ const DEFAULTS = {
   state_backend: "hu-board",
   // verify_cmd (KJC-TSK-0732): user adapter that checks a card ref against
   // the real tracker — prints {exists, live, status} JSON; {ref} substituted.
-  board: { name: null, verify_cmd: null },
+  // unverifiable (KJC-TSK-0878): que hacer cuando el adaptador no puede
+  // responder (sin red, sin credenciales, JSON invalido). "warn" degrada a
+  // branch-ref diciendolo; "block" se niega a aprobar lo que no ha comprobado.
+  board: { name: null, verify_cmd: null, unverifiable: "warn" },
   // Method gates (KJC-PCS-0068): rules climb from playbook text to
   // deterministic enforcement. card_first: "auto" = block with hu-board
   // (fully verifiable), warn with planning-game/external (presence only);
@@ -91,6 +94,11 @@ const DEFAULTS = {
   coder_rules: "./.karajan/coder-rules.md",
   base_branch: "main",
   coder_options: { model: null, auto_approve: true, fallback_coder: null },
+  // KJC-BUG-0217: los flags con los que kj invoca el CLI de cada provider son
+  // los que su version acepta, y eso cambia con el CLI. Aqui se declaran por
+  // agente cuando los de serie no valen: { kimi: { task_args: [] } } deja el
+  // prompt solo, sin auto-aprobado, para una version que rechaza la combinacion.
+  agents: {},
   reviewer_options: {
     output_format: "json",
     require_schema: true,
@@ -256,6 +264,10 @@ const DEFAULTS = {
       enabled: true,
       patterns: [],
       protected_files: [],
+      // KJC-BUG-0215: cauce declarado para el falso positivo de las reglas que
+      // acusan por el NOMBRE del identificador. Entradas `NAME` (todo el repo)
+      // o `path/to/file:NAME` (solo ese fichero, que es lo preferible).
+      non_secret_assignments: [],
       on_violation: "block"
     },
     perf: {