karajan-code 4.49.0 → 4.49.2

package/package.json

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

package/src/brain/agent-error-classifier.js

@@ -26,6 +26,9 @@ export const ERROR_CLASS = Object.freeze({
   // un problema de cuota — es motivo para tomar el siguiente eslabón de la
   // cadena declarada. No tiene cooldown: esperar no lo va a resucitar.
   MODEL_UNAVAILABLE: "MODEL_UNAVAILABLE",
+  // KJC-BUG-0327: the OS refused the invocation (E2BIG: the prompt, passed as an
+  // argument, is too large). The same command will fail again: no waiting.
+  INVOCATION_TOO_LARGE: "INVOCATION_TOO_LARGE",
   API_DOWN: "API_DOWN",
   AUTH_FAILED: "AUTH_FAILED",
   NETWORK_TIMEOUT: "NETWORK_TIMEOUT",
@@ -74,6 +77,12 @@ export function classifyAgentError({ provider = "unknown", stdout = "", stderr =
   const combined = `${stderr}\n${stdout}`;
   const base = { provider, exitCode, retryAfter: null, retryUntil: null };
 
+  // 0. KJC-BUG-0327 (#2087): E2BIG first. The error echoes the command, prompt
+  //    included, so any word the prompt carries (rate limit, 401...) would win.
+  if (/\bE2BIG\b|argument list too long/i.test(combined)) {
+    return { ...base, class: ERROR_CLASS.INVOCATION_TOO_LARGE, message: "the prompt is too large to pass as a command argument (E2BIG)", recoverable: true };
+  }
+
   // 1. AUTH_FAILED tiene prioridad absoluta — no es recuperable, escalar al usuario.
   if (AUTH_PATTERNS.test(combined)) {
     return { ...base, class: ERROR_CLASS.AUTH_FAILED, message: pickMessage(combined, AUTH_PATTERNS), recoverable: false };

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

@@ -36,6 +36,8 @@ export const DEFAULT_RECOVERY_POLICY = Object.freeze({
     // the next link straight away. Without a chain it aborts, because
     // retrying the same dead model is how a run burns quota saying nothing.
     [ERROR_CLASS.MODEL_UNAVAILABLE]: { mode: "abort", maxRetries: 0, fallbackEligible: true, fallbackImmediate: true },
+    // KJC-BUG-0327: the same oversized invocation fails again; take the next link.
+    [ERROR_CLASS.INVOCATION_TOO_LARGE]: { mode: "abort", maxRetries: 0, fallbackEligible: true, fallbackImmediate: true },
     [ERROR_CLASS.API_DOWN]: { mode: "backoff", maxRetries: 3, baseMs: 5_000, factor: 3, jitterPct: 0.2 },
     [ERROR_CLASS.NETWORK_TIMEOUT]: { mode: "backoff", maxRetries: 3, baseMs: 5_000, factor: 3, jitterPct: 0.2 },
     [ERROR_CLASS.SILENCED]: { mode: "backoff", maxRetries: 2, baseMs: 30_000, factor: 2, jitterPct: 0.15 },
@@ -144,7 +146,8 @@ export async function withBrainRecovery({
     const attempt = attemptsByClass[cls.class];
 
     emit(emitter, "brain:agent-error", eventBase, { role, class: cls.class, attempt, message: cls.message, provider: effectiveProvider });
-    logger?.warn?.(`[brain] ${role} (${effectiveProvider}) → ${cls.class} attempt ${attempt}/${classPolicy.maxRetries}: ${cls.message}`);
+    // KJC-BUG-0327: "attempt 4/3" read as one over budget; it is failure 4 with 3 retries allowed.
+    logger?.warn?.(`[brain] ${role} (${effectiveProvider}) → ${cls.class} failure ${attempt} (retries allowed: ${classPolicy.maxRetries}): ${cls.message}`);
 
     // KJC-TSK-0859: un modelo retirado se resuelve ANTES de abortar. No hay
     // cooldown que esperar, así que la condición de la cadena por cuota

package/src/checks/release-check.js

@@ -16,11 +16,37 @@ import { liftSealedSupervisorViolations } from "../policy/supervisor-verify.js";
 // policy IN FORCE now, not the one each PR was merged under. Artifact rules
 // only: diff-threshold invariants are PR-scoped by definition — skipped, and
 // said — so no line metric is needed (without a tag, the whole tree counts).
+/** The commit that introduced the kj pre-commit hook (kj setup), or null. */
+async function setupCommitOf(projectDir) {
+  const res = await runCommand("git", ["-C", projectDir, "log", "--diff-filter=A", "--format=%H", "--", ".karajan/hooks/pre-commit"]);
+  if (res.exitCode !== 0) return null;
+  return res.stdout.trim().split("\n").filter(Boolean).at(-1) ?? null;
+}
+
+/** Supervisor violations on files the setup commit added and nothing changed since. */
+async function withoutSetupInstalls(projectDir, setup, violations) {
+  const added = await runCommand("git", ["-C", projectDir, "diff-tree", "--root", "--no-commit-id", "--name-only", "-r", "--diff-filter=A", setup]);
+  const installed = new Set(added.exitCode === 0 ? added.stdout.split("\n").map((s) => s.trim()).filter(Boolean) : []);
+  const kept = [];
+  for (const v of violations) {
+    if (v.rule_id === "defaults.supervisor.write" && installed.has(v.file)) {
+      const changed = await runCommand("git", ["-C", projectDir, "diff", "--quiet", setup, "HEAD", "--", v.file]);
+      if (changed.exitCode === 0) continue;
+    }
+    kept.push(v);
+  }
+  return kept;
+}
+
 async function policyRangeCheck(projectDir) {
   const { policy, errors } = loadPolicy({ projectDir });
   if (errors.length > 0) return { name: "policy", ok: false, detail: `policy.yml invalid — ${errors[0]}` };
   const described = await runCommand("git", ["-C", projectDir, "describe", "--tags", "--abbrev=0", "--match", "v[0-9]*"]);
   const tag = described.exitCode === 0 ? described.stdout.trim() : null;
+  // KJC-BUG-0342 (#2105): with no tag the whole tree is judged, and the supervisor
+  // files the human's kj setup commit installed read as writes. Only those, and only
+  // while unchanged since that commit, are the setup and not judged.
+  const setup = tag ? null : await setupCommitOf(projectDir);
   const scope = tag ? `${tag}..HEAD` : "whole history (no previous tag)";
   const prScoped = new Set((policy.invariants ?? []).filter((i) => i.kind === "diff-threshold").map((i) => i.id));
   try {
@@ -37,7 +63,7 @@ async function policyRangeCheck(projectDir) {
     // KJC-BUG-0259: the history is judged on what is versioned (hooks, provenance);
     // the machine-local guards were verified when the seal was reviewed.
     const sup = liftSealedSupervisorViolations({ projectDir, violations: raw, trackedOnly: true });
-    const violations = sup.violations;
+    const violations = setup ? await withoutSetupInstalls(projectDir, setup, sup.violations) : sup.violations;
     const hard = violations.filter((v) => v.enforcement === "deny");
     const skipped = prScoped.size > 0 ? `; ${prScoped.size} diff-threshold invariant(s) skipped (PR-scoped)` : "";
     if (hard.length > 0) {

package/src/commands/review-gate.js

@@ -246,7 +246,11 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
   const locInv = pol.errors.length === 0
     ? (pol.policy.invariants || []).find((i) => i.kind === "diff-threshold" && i.metric === "net_lines_added")
     : null;
-  const sizeWarn = locInv?.max ?? config?.method_gates?.pr_size_warn ?? 150;
+  // KJC-BUG-0326 (#2085): two tiers. ~150 is the ideal (method_gates.pr_size_warn);
+  // up to the limit (the policy's net_lines_added max, else method_gates.pr_size_max,
+  // 200) is allowed without asking; above the limit, partition.
+  const sizeIdeal = config?.method_gates?.pr_size_warn ?? 150;
+  const sizeWarn = locInv?.max ?? config?.method_gates?.pr_size_max ?? 200;
   const sizeSource = locInv ? `policy [${locInv.id}]` : "method_gates";
   if (sizeWarn > 0) {
     const numstat = await rawDiff(flags.range, ["--numstat"]);
@@ -258,6 +262,9 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
     // 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 > sizeIdeal && added <= sizeWarn) {
+      console.log(`ℓ pr-size: ${added} lines added, over the ~${sizeIdeal} ideal, within the ${sizeWarn} limit: allowed, nothing to ask`);
+    }
     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.
@@ -265,12 +272,12 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
       const sizePolicy = config?.method_gates?.pr_size || "warn";
       // ADR 0015: no env escape — an exception is the user's label on the PR, judged in CI.
       if (sizePolicy === "block") {
-        const reason = `${added} lines added${split} exceeds the ${sizeWarn}-line budget (${sizeSource}; method_gates.pr_size: block) — partition the work; an exception is your user's large-pr-justified label on the PR`;
+        const reason = `${added} lines added${split} is over the ${sizeWarn}-line limit (${sizeSource}; method_gates.pr_size: block) — partition the work; an exception is your user's large-pr-justified label on the PR`;
         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${split} (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}, over the ${sizeWarn}-line limit (ideal ~${sizeIdeal}, source: ${sizeSource}) — partition the work before committing (method_gates.pr_size: block to harden)`);
       }
     }
   }

package/src/config/defaults.js

@@ -81,9 +81,11 @@ const DEFAULTS = {
     card_first_exempt_branches: ["chore/release-"],
     // MG-B: source changes without a test change — "warn" | "block".
     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.
+    // MG-C + KJC-BUG-0326: ~pr_size_warn added lines is the ideal; up to
+    // pr_size_max is allowed without asking; above it, partition (warn, or
+    // block with pr_size: "block"). A policy net_lines_added max wins over pr_size_max.
     pr_size_warn: 150,
+    pr_size_max: 200,
     // 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

package/src/environment/playbook.js

@@ -76,8 +76,8 @@ ${panel ? `${panel}\n` : ""}- Security findings are never overridable — not ev
   \`kj audit --security\` (zero tokens) and remediate BEFORE the review.
 - A design decision the card's AC don't cover belongs to the USER: record
   it as a proposed ADR (\`kj adr add\`) and ask — never bury it in a PR
-  bullet. An oversized-diff warning is not an opinion either: partition,
-  or get an explicit OK.
+  bullet. Diff size: ~150 net lines of code is the ideal, up to 200 is
+  allowed without asking, above 200 partition, always.
 - A non-trivial plan names at least two approaches — one as if the
   codebase didn't exist — and says why the winner won. Following the
   legacy line is a choice, never a default.

package/src/git/hu-automation.js

@@ -4,6 +4,7 @@
  */
 import { commitAll, pushBranch, createPullRequest, hasChanges } from "../utils/git.js";
 import { runCommand } from "../utils/process.js";
+import { stampStagedVerdict } from "../review/verdict-store.js";
 
 /**
  * Build a git-safe branch name for an HU story.
@@ -184,7 +185,16 @@ export async function finalizeHuCommit({ story, branchName, config, logger, cwd
   const title = story.title || story.id;
   const commitMsg = `feat(${story.id}): ${title}`;
   if (config.git?.auto_commit) {
-    const commitRes = await commitAll(commitMsg, cwd);
+    // KJC-BUG-0323: this commit runs after the HU's reviewer approved, so it
+    // records that verdict for the staged diff, as the other post-review commits do.
+    const commitRes = await commitAll(commitMsg, cwd, {
+      beforeCommit: ({ paths } = {}) => stampStagedVerdict({
+        projectDir: cwd || config.projectDir || process.cwd(),
+        paths,
+        reviewer: config.reviewer || "pipeline-reviewer",
+        summary: `kj run HU ${story.id}: reviewer approved`,
+      }),
+    });
     if (commitRes) {
       result.committed = true;
       logger.info(`HU ${story.id}: committed on '${branchName}'`);

package/src/harden/advisory.js

@@ -166,9 +166,28 @@ export function classifyArtifact(searchDir, artifact, altDirs = [searchDir]) {
  * own root (monorepo-aware, mirroring installConfigsForRoots). `minimal`
  * profile ships no config, so there is nothing to compare.
  */
+// KJC-BUG-0335 (#2094): the method's own pieces, not only the configs. Without
+// them the report said "0 missing" while the review gate demanded the Sentinel.
+const METHOD_PIECES = [
+  { id: "sentinel", what: "the Sentinel (it records the session, the RAG queries the review gate needs among them)",
+    files: [".karajan/harness/pretooluse-sentinel.mjs", ".karajan/harness/posttooluse.mjs", ".karajan/harness/stop.mjs"] },
+  { id: "git-hooks", what: "the git hooks", files: [".karajan/hooks/pre-commit", ".karajan/hooks/commit-msg", ".karajan/hooks/pre-push"] },
+];
+
+function methodPiece(projectDir, { id, what, files }) {
+  const head = { dir: ".", id, file: files[0], currentVersion: null, managedVersion: null, upToDate: null, improvements: [], mergeable: false };
+  const missing = files.filter((f) => !existsSync(join(projectDir, f)));
+  return missing.length === 0
+    ? { ...head, status: "KJ_MANAGED", foundAt: files[0], recommendation: "keep", rationale: `${what}: installed` }
+    : { ...head, status: "MISSING", foundAt: null, missing, recommendation: "install", rationale: `kj harden (without --report) installs ${what}; missing: ${missing.join(", ")}` };
+}
+
 export function compareHarden({ projectDir = process.cwd(), profile = "standard", only = [], exclude = [] } = {}) {
   if (profile === "minimal") return { artifacts: [] };
-  const artifacts = UNIVERSAL_CONFIGS.map((cfg) => ({ dir: ".", ...classifyArtifact(projectDir, toArtifact(cfg)) }));
+  const artifacts = [
+    ...METHOD_PIECES.map((piece) => methodPiece(projectDir, piece)),
+    ...UNIVERSAL_CONFIGS.map((cfg) => ({ dir: ".", ...classifyArtifact(projectDir, toArtifact(cfg)) })),
+  ];
   for (const { dir, language } of detectStackRoots(projectDir, { only, exclude })) {
     const searchDir = dir === "." ? projectDir : join(projectDir, dir);
     for (const cfg of CONFIGS_BY_LANGUAGE[language] ?? []) {

package/src/harden/sentinel/sentinel-shell.mjs

@@ -86,6 +86,38 @@ export const isGhIssueCreate = (cmd) => shellSegments(cmd).some((words) => {
   return subcommand[0] === "issue" && subcommand[1] === "create";
 });
 
+// KJC-BUG-0204: the real command puts flags between the verb's words
+// (firebase --account a@b deploy), so they are read in order, not adjacent.
+const PUBLISH_VERBS = [["npm", "publish"], ["firebase", "deploy"], ["gh", "release", "create"]];
+// Known options that take a separate value: that value is not a subcommand word
+// (npm --tag publish test does not publish). An unknown option is not skipped, so
+// a real publish behind it is still read (a false positive costs less than a miss).
+const VALUE_OPTIONS = {
+  npm: ["--prefix", "--tag", "--registry", "--userconfig", "--workspace", "-w", "--otp", "--access", "--cache", "--loglevel", "-C"],
+  firebase: ["--account", "--project", "-P", "--config", "-c", "--only", "--except", "--token", "--message", "-m"],
+  gh: ["--repo", "-R", "--hostname"],
+};
+
+/**
+ * KJC-BUG-0333 (#2093): a simple command whose head is npm, firebase or gh and
+ * whose own words then say publish/deploy/release create. Words inside a quoted
+ * argument of another command (a kj rag query text, a commit message) are one
+ * word of THAT command, so they never read as a publish.
+ * @param {string} cmd
+ */
+export const isPublishCommand = (cmd) => shellSegments(cmd).some((words) => PUBLISH_VERBS.some(([head, ...rest]) => {
+  const i = headIndex(words, [head]);
+  if (words[i]?.split("/").at(-1) !== head) return false;
+  let k = 0;
+  let skipValue = false;
+  for (const w of words.slice(i + 1)) {
+    if (skipValue) { skipValue = false; continue; }
+    if (VALUE_OPTIONS[head].includes(w)) { skipValue = true; continue; }
+    if (w === rest[k] && ++k === rest.length) return true;
+  }
+  return false;
+}));
+
 // KJC-BUG-0286: a $ expands only when something expandable follows it ($x, ${x},
 // $(cmd), $1, $@...). A lone "$ " in a grep pattern is a literal dollar sign.
 const LIVE_EXPANSION = /\$(?=[A-Za-z0-9_{(@*#?$!-])|`/;

package/src/harden/sentinel-hooks.js

@@ -473,20 +473,14 @@ import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { doc, CODE, TESTS, ROOT, BASE_BRANCHES, CARD, STATE, branchOf, foreignLane, load, save, session, violations, boardGate, pendingMoves, pendingText } from "./sentinel-lib.mjs";
 // KJC-TSK-0915 (ADR 0014): the shell reader is a real, unit-tested module copied here as is.
-import { isGhIssueCreate, optionValues, shellSegments, stripInertQuotes, stripTextOptionValues } from "./sentinel-shell.mjs";
+import { isGhIssueCreate, isPublishCommand, optionValues, shellSegments, stripInertQuotes, stripTextOptionValues } from "./sentinel-shell.mjs";
 import { DISCARD_VERBS, discardOf, foreignLost, removedFiles } from "./sentinel-discard.mjs";
 import { shellWrites, writesRepo } from "./sentinel-bash-write.mjs";
 const EDIT_TOOLS = ["Write", "Edit", "MultiEdit", "NotebookEdit"];
-// KJC-BUG-0204: el comando real lleva flags EN MEDIO del verbo
-// (firebase --account a@b --project p deploy --only hosting:main), asi que la
-// adyacencia dejaba pasar sin mirar justo el despliegue que el gate vigila.
-// Las palabras del verbo tienen que aparecer en orden, no pegadas.
-const PUBLISH_VERBS = [["npm", "publish"], ["firebase", "deploy"], ["gh", "release", "create"]];
-// Cada palabra se lee por su basename: /usr/bin/npm publish es la misma
-// publicacion que npm publish (catch de la review).
-const wordsOf = (text) => String(text).split(/[^A-Za-z0-9_.@:/-]+/).filter(Boolean).map((w) => w.slice(w.lastIndexOf("/") + 1)).filter(Boolean);
 const inOrder = (want, got) => { let i = 0; for (const w of got) if (w === want[i] && ++i === want.length) return true; return false; };
-const isPublish = (cmd) => { const got = wordsOf(cmd); return PUBLISH_VERBS.some((verb) => inOrder(verb, got)); };
+// KJC-BUG-0333: a publish is read per simple command by the shell reader, so
+// words inside a quoted argument of another command are not a publish.
+const isPublish = isPublishCommand;
 const PUSH = /\\bgit\\s+push\\b/;
 const PROTECTED = /\\.claude\\/settings\\.json\\b|\\.karajan\\/(hooks|harness)\\//;
 let raw = "";
@@ -565,15 +559,22 @@ process.stdin.on("end", () => {
       const ghCmd = String(input.command || "");
       if (tool === "Bash" && /(^|[^a-zA-Z])gh([^a-zA-Z]|$)/.test(ghCmd) && /(^|[^a-z])(pr|issue|release)([^a-z]|$)/.test(ghCmd) && /(^|[^a-z])(create|edit|comment|review)([^a-z]|$)/.test(ghCmd)) {
         const attrib = /co-authored-by:.{0,120}(claude|gpt|copilot|gemini)|(generated|written|created) (by|with).{0,120}(claude|gpt|copilot|gemini|codex)|generated with [[]?claude|🤖/is;
-        let corpus = ghCmd;
+        // KJC-BUG-0340: a body file's PATH is not published text (a scratch dir
+        // under .../claude-1000/... read as an attribution next to a title saying
+        // "generated by kj"); its content is. Each piece is judged on its own, so a
+        // match never spans from the command into a file.
+        const pieces = [];
+        let cmdText = ghCmd;
         // KJC-BUG-0245: the shell reader ends the path at ; && | (a regex took "pr.md;").
         for (const bodyPath of optionValues(ghCmd, ["--body-file", "--notes-file", "--comment-file"])) {
-          try { corpus += "\\n" + readFileSync(bodyPath, "utf8"); } catch {
+          cmdText = cmdText.split(bodyPath).join(" ");
+          try { pieces.push(readFileSync(bodyPath, "utf8")); } catch {
             console.error("karajan sentinel: no puedo leer " + bodyPath + " para el escaneo de atribucion — sin escaneo no se publica." + doc("attribution"));
             process.exit(2);
           }
         }
-        if (attrib.test(corpus)) {
+        pieces.push(cmdText);
+        if (pieces.some((p) => attrib.test(p))) {
           console.error("karajan sentinel: atribucion a IA detectada en contenido a PUBLICAR (PR/issue/release) — prohibida por regla determinista del proyecto: limpia el texto." + doc("attribution"));
           process.exit(2);
         }
@@ -798,7 +799,9 @@ process.stdin.on("end", () => {
       // puede ejecutar cualquier cosa (reviewer catch: grep foo $(rm ...)).
       // (find fuera: -delete/-exec mutan — reviewer catch; sus tokens de
       // carril los caza el escaner de abajo.)
-      const READONLY = /^[ \\t]*(grep|rg|cat|head|tail|less|ls|wc|diff|stat|file|du|tree|git (log|show|diff|status|blame))\\b[^;|&<>$\`(){}\\n\\r]*$/;
+      // KJC-BUG-0338: kj rag query only reads, and the rag-first gate asks for it
+      // with a quoted question that names the file.
+      const READONLY = /^[ \\t]*(grep|rg|cat|head|tail|less|ls|wc|diff|stat|file|du|tree|git (log|show|diff|status|blame)|kj rag query)\\b[^;|&<>$\`(){}\\n\\r]*$/;
       // KJC-BUG-0286 (#1982): a command whose EVERY segment only reads mutates
       // nothing, however it is chained (grep | grep, git show | grep, cd && git
       // status). A cd with a literal target is one such segment: the paths after
@@ -1423,8 +1426,11 @@ export function installSentinelHooks({ projectDir = process.cwd(), logger = cons
   };
   const [lib, post, stop, pre] = Object.entries(SCRIPT_BODIES).map(([name, body]) => {
     if (keepsItsSeal(name)) {
-      deferred.push(name);
-      return join(projectDir, ".karajan", "harness", name);
+      const abs = join(projectDir, ".karajan", "harness", name);
+      // KJC-BUG-0325: only a sealed guard the current template would change is
+      // waiting for the human; one identical to it has nothing to advance.
+      if (readFileSync(abs, "utf8") !== body) deferred.push(name);
+      return abs;
     }
     return writeHarnessScript(projectDir, name, body);
   });

package/src/orchestrator/drivers/init-context.js

@@ -36,6 +36,17 @@ import { getIntegration } from "../integrations.js";
 import { tryAutoStartBoard } from "./post-loop.js";
 import { runPreLoopStages } from "./pre-loop.js";
 
+/**
+ * KJC-BUG-0324: the coder is built before the pre-loop, with the run's first
+ * config, so what the pre-loop resolves (the Domain Curator's domainContext,
+ * the methodology) never reached its prompt. The run and the coder both take
+ * the resolved config; the coder is initialized after this.
+ */
+export function adoptPreLoopConfig(ctx, updatedConfig) {
+  ctx.config = updatedConfig;
+  ctx.coderRoleInstance.config = updatedConfig;
+}
+
 export async function initFlowContext({ task, config, logger, emitter, askQuestion, pgTaskId, pgProject, flags }) {
   // Auto-init .karajan/ if missing (copies coder-rules, review-rules, role templates)
   const initProjectDir = config.projectDir || process.cwd();
@@ -182,7 +193,7 @@ export async function initFlowContext({ task, config, logger, emitter, askQuesti
 
   const preLoopResult = await runPreLoopStages({ config, logger, emitter, eventBase: ctx.eventBase, session: ctx.session, flags, pipelineFlags: ctx.pipelineFlags, coderRole: ctx.coderRole, trackBudget: ctx.trackBudget, task, askQuestion, pgTaskId, pgProject, stageResults: ctx.stageResults, brainCtx: ctx.brainCtx });
   ctx.plannedTask = preLoopResult.plannedTask;
-  ctx.config = preLoopResult.updatedConfig;
+  adoptPreLoopConfig(ctx, preLoopResult.updatedConfig);
 
   // --- Session Journal: persist pre-loop outputs + display plan summary ---
   const reportDir = ctx.config.output?.report_dir || ".reviews";

package/src/orchestrator/drivers/iteration-phases/quality-gates.js

@@ -21,7 +21,7 @@ import {
 import { runImpeccableStage } from "../../post-loop-stages.js";
 import { runPerfStage } from "../../stages/perf-stage.js";
 import { runTddDisciplineStage } from "../../stages/tdd-discipline-stage.js";
-import { runSuiteGreenStage } from "../../stages/suite-green-stage.js";
+import { runSuiteGreenStage, suiteGreenRequired } from "../../stages/suite-green-stage.js";
 import { runToolJudgeStage } from "../../stages/tool-judge-stage.js";
 import { tryCiComment } from "../../ci-integration.js";
 
@@ -31,7 +31,7 @@ export async function runQualityGateStages({ config, logger, emitter, eventBase,
   if (tddResult.action === "continue") return { action: "continue" };
 
   // KJC-BUG-0298 (#1993): with TDD, a red suite never reaches the reviewer.
-  if (config.development?.methodology === "tdd" && config.development?.require_green_suite !== false && config?.testHarness?.disableSuiteGreenStage !== true) {
+  if (config.development?.methodology === "tdd" && suiteGreenRequired(config)) {
     const green = await runSuiteGreenStage({ config, logger, emitter, eventBase, session, iteration: i });
     if (green.action === "continue") return { action: "continue" };
   }

package/src/orchestrator/drivers/pre-loop.js

@@ -62,6 +62,23 @@ import {
 import { tryCiComment } from "../ci-integration.js";
 import { getIntegration } from "../integrations.js";
 
+/**
+ * KJC-BUG-0332 (#2092, root of #2090/#2091): a plan run implements the plan's
+ * certified HUs. Triaging the plan's original task auto-generated other HUs
+ * (HU-01..) that ran instead, and could call it analysis-only, skipping the
+ * coder and approving an empty diff. In a plan run there is no triage; each HU
+ * carries its own task type, which the HU batch applies.
+ */
+export async function triageForRun({ flags, runTriage }) {
+  if (flags?.plan) {
+    return {
+      roleOverrides: {}, // applyTriageOverrides reads its keys: no override, never null
+      stageResult: { ok: true, taskType: "sw", level: null, roles: [], shouldDecompose: false, subtasks: [], fromPlan: flags.plan, summary: "plan run: the plan's HUs are the work" },
+    };
+  }
+  return (await runTriage()) ?? { roleOverrides: null, stageResult: null };
+}
+
 export async function runPreLoopStages({ config, logger, emitter, eventBase, session, flags, pipelineFlags, coderRole, trackBudget, task, askQuestion, pgTaskId, pgProject, stageResults, brainCtx }) {
   // KJC-BUG-0058: on `kj resume` `stageResults` is rehydrated from
   // `session.stage_results`. Persist after every successful pre-loop stage
@@ -121,7 +138,8 @@ export async function runPreLoopStages({ config, logger, emitter, eventBase, ses
   // stages it gates (researcher, architect, planner) ARE skipped if
   // already complete.
   const triageCtx = { config, logger, emitter, eventBase, session, coderRole, trackBudget, pipelineFlags };
-  const triageResult = await runStage(stageRegistry.get("triage"), triageCtx) ?? { roleOverrides: null, stageResult: null };
+  const triageResult = await triageForRun({ flags, runTriage: () => runStage(stageRegistry.get("triage"), triageCtx) });
+  if (triageResult.stageResult?.fromPlan) logger.info(`Triage skipped: plan ${flags.plan} runs its own certified HUs`);
   applyTriageOverrides(pipelineFlags, triageResult.roleOverrides);
   await persistStage("triage", triageResult.stageResult);
 

package/src/orchestrator/drivers/run-hu-batch.js

@@ -26,6 +26,7 @@ import { emitProgress, makeEvent } from "../../utils/events.js";
 import { needsSubPipeline, runHuSubPipeline } from "../hu-sub-pipeline.js";
 import { runCoderStage } from "../stages/coder-stage.js";
 import { runSonarStage } from "../stages/sonar-stage.js";
+import { runSuiteGreenStage, suiteGreenRequired } from "../stages/suite-green-stage.js";
 import { runIterationLoop } from "./iteration-loop.js";
 import { classifyFailure, createFailureTracker } from "../repair/repair-detector.js";
 import { runRepair } from "../repair/repair-runner.js";
@@ -235,6 +236,16 @@ export async function runHuBatch({ ctx, task, askQuestion, emitter, logger }) {
             }
           }
 
+          // KJC-BUG-0328 (#2088): a code HU is never approved over a red project
+          // suite; it goes back to the coder, as in the iteration loop.
+          if ((huPolicies.tdd || huPolicies.testsRequired) && suiteGreenRequired(laneConfig)) {
+            const green = await runSuiteGreenStage({ config: laneConfig, logger, emitter, eventBase: ctx.eventBase, session: laneSession, iteration: attempt });
+            if (green.action === "continue") {
+              lanePlannedTask = `${huTask}\n\n--- TEST SUITE RED ---\n${laneSession.last_reviewer_feedback}`;
+              continue;
+            }
+          }
+
           // Brain runs acceptance tests
           logger.info(`HU ${story.id}: running ${story.acceptance_tests.length} acceptance tests`);
           emitProgress(emitter, makeEvent("hu:acceptance-start", { ...ctx.eventBase, stage: "acceptance" }, {

package/src/orchestrator/stages/suite-green-stage.js

@@ -17,6 +17,11 @@ import { resolveCmds } from "../../commands/harden.js";
 const TAIL_CHARS = 2000;
 const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
 
+/** Whether the project asks for a green suite (opt-out, and off in the test harness). */
+export function suiteGreenRequired(config) {
+  return config?.development?.require_green_suite !== false && config?.testHarness?.disableSuiteGreenStage !== true;
+}
+
 /** @returns {Promise<{action: "ok"|"continue", result: object}>} */
 export async function runSuiteGreenStage({ config, logger, emitter, eventBase, session, iteration, resolveCmdsImpl = resolveCmds, runTestsImpl = null }) {
   const projectDir = config?.projectDir || process.cwd();

package/src/planning-game/client.js

@@ -14,8 +14,22 @@ import { withRetry } from "../utils/retry.js";
 const DEFAULT_API_URL = "http://localhost:3000/api";
 const DEFAULT_TIMEOUT_MS = 10000;
 
-function getApiUrl() {
-  return process.env.PG_API_URL || DEFAULT_API_URL;
+// KJC-BUG-0322: PG_API_URL > planning_game.api_url (passed by the caller) > localhost.
+function getApiUrl(apiUrl) {
+  const fromEnv = process.env.PG_API_URL?.trim();
+  if (fromEnv) return fromEnv;
+  const fromConfig = typeof apiUrl === "string" ? apiUrl.trim() : "";
+  return fromConfig ? fromConfig : DEFAULT_API_URL;
+}
+
+// Origin and path only: credentials or a query token in a configured URL never reach a log.
+function urlForMessage(url) {
+  try {
+    const u = new URL(url);
+    return `${u.origin}${u.pathname}`;
+  } catch {
+    return "(invalid Planning Game URL)";
+  }
 }
 
 async function fetchWithTimeout(url, options = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
@@ -37,7 +51,7 @@ async function fetchWithTimeout(url, options = {}, timeoutMs = DEFAULT_TIMEOUT_M
       err.httpStatus = 408;
       throw err;
     }
-    throw new Error(`Planning Game network error: ${error?.message || "unknown error"}`, { cause: error });
+    throw new Error(`Planning Game network error at ${urlForMessage(url)}: ${error?.message ?? "unknown error"}`, { cause: error });
   } finally {
     clearTimeout(timeoutId);
   }
@@ -58,15 +72,15 @@ async function parseJsonResponse(response) {
   }
 }
 
-export async function fetchCard({ projectId, cardId, timeoutMs = DEFAULT_TIMEOUT_MS }) {
-  const url = `${getApiUrl()}/projects/${encodeURIComponent(projectId)}/cards/${encodeURIComponent(cardId)}`;
+export async function fetchCard({ projectId, cardId, apiUrl, timeoutMs = DEFAULT_TIMEOUT_MS }) {
+  const url = `${getApiUrl(apiUrl)}/projects/${encodeURIComponent(projectId)}/cards/${encodeURIComponent(cardId)}`;
   const response = await fetchWithRetry(url, {}, timeoutMs);
   const data = await parseJsonResponse(response);
   return data?.card || data;
 }
 
-export async function updateCard({ projectId, cardId: _cardId, firebaseId, updates, timeoutMs = DEFAULT_TIMEOUT_MS }) {
-  const url = `${getApiUrl()}/projects/${encodeURIComponent(projectId)}/cards/${encodeURIComponent(firebaseId)}`;
+export async function updateCard({ projectId, cardId: _cardId, firebaseId, updates, apiUrl, timeoutMs = DEFAULT_TIMEOUT_MS }) {
+  const url = `${getApiUrl(apiUrl)}/projects/${encodeURIComponent(projectId)}/cards/${encodeURIComponent(firebaseId)}`;
   const response = await fetchWithRetry(
     url,
     {
@@ -79,8 +93,8 @@ export async function updateCard({ projectId, cardId: _cardId, firebaseId, updat
   return parseJsonResponse(response);
 }
 
-export async function createCard({ projectId, card, timeoutMs = DEFAULT_TIMEOUT_MS }) {
-  const url = `${getApiUrl()}/projects/${encodeURIComponent(projectId)}/cards`;
+export async function createCard({ projectId, card, apiUrl, timeoutMs = DEFAULT_TIMEOUT_MS }) {
+  const url = `${getApiUrl(apiUrl)}/projects/${encodeURIComponent(projectId)}/cards`;
   const response = await fetchWithRetry(
     url,
     {
@@ -93,8 +107,8 @@ export async function createCard({ projectId, card, timeoutMs = DEFAULT_TIMEOUT_
   return parseJsonResponse(response);
 }
 
-export async function relateCards({ projectId, sourceCardId, targetCardId, relationType, timeoutMs = DEFAULT_TIMEOUT_MS }) {
-  const url = `${getApiUrl()}/projects/${encodeURIComponent(projectId)}/cards/relate`;
+export async function relateCards({ projectId, sourceCardId, targetCardId, relationType, apiUrl, timeoutMs = DEFAULT_TIMEOUT_MS }) {
+  const url = `${getApiUrl(apiUrl)}/projects/${encodeURIComponent(projectId)}/cards/relate`;
   const response = await fetchWithRetry(
     url,
     {

package/src/planning-game/pipeline-adapter.js

@@ -63,9 +63,10 @@ async function handlePgDecomposition({ triageResult, pgTaskId, pgProject, config
     const normalizedAnswer = (answer || "").trim().toLowerCase();
     const isAccept = normalizedAnswer === "1" || normalizedAnswer === "yes" || normalizedAnswer === "sí" || normalizedAnswer === "si";
     if (isAccept) {
-      const parentCard = await fetchCard({ projectId: pgProject, cardId: pgTaskId }).catch(() => null);
+      const apiUrl = config.planning_game?.api_url;
+      const parentCard = await fetchCard({ projectId: pgProject, cardId: pgTaskId, apiUrl }).catch(() => null);
       const createdSubtasks = await createDecompositionSubtasks({
-        client: { createCard, relateCards },
+        client: { createCard: (args) => createCard({ ...args, apiUrl }), relateCards: (args) => relateCards({ ...args, apiUrl }) },
         projectId: pgProject,
         parentCardId: pgTaskId,
         parentFirebaseId: parentCard?.firebaseId || null,
@@ -129,7 +130,8 @@ export async function markPgCardToValidate({ pgCard, pgProject, config, session,
       projectId: pgProject,
       cardId: session.pg_task_id,
       firebaseId: pgCard.firebaseId,
-      updates: pgUpdates
+      updates: pgUpdates,
+      apiUrl: config.planning_game?.api_url
     });
     logger.info(`Planning Game: ${session.pg_task_id} → To Validate`);
   } catch (err) {
@@ -201,9 +203,9 @@ async function markPgCardInProgress({ pgTaskId, pgProject, config, logger }) {
   // its own HUs and said approved. With a card named, no card is a loud stop.
   let pgCard;
   try {
-    pgCard = await fetchCard({ projectId: pgProject, cardId: pgTaskId });
+    pgCard = await fetchCard({ projectId: pgProject, cardId: pgTaskId, apiUrl: config.planning_game?.api_url });
   } catch (err) {
-    throw new Error(`Planning Game: card ${pgTaskId} could not be read (${err.message}): the run would implement without the card's acceptance criteria. Check PG_API_URL, or run without pgTask.`, { cause: err });
+    throw new Error(`Planning Game: card ${pgTaskId} could not be read (${err.message}): the run would implement without the card's acceptance criteria. Check planning_game.api_url in the config (PG_API_URL overrides it), or run without pgTask.`, { cause: err });
   }
   if (!pgCard) throw new Error(`Planning Game: card ${pgTaskId} not found in project ${pgProject}: the run would implement without the card's acceptance criteria. Check the id, or run without pgTask.`);
   try {
@@ -212,6 +214,7 @@ async function markPgCardInProgress({ pgTaskId, pgProject, config, logger }) {
         projectId: pgProject,
         cardId: pgTaskId,
         firebaseId: pgCard.firebaseId,
+        apiUrl: config.planning_game?.api_url,
         updates: {
           status: "In Progress",
           startDate: new Date().toISOString(),

package/src/policy/engine.js

@@ -9,6 +9,7 @@
  */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { stripTextOptionValues } from "../harden/sentinel/sentinel-shell.mjs";
 import {
   ALLOW_VERDICT,
   checkArtifacts,
@@ -72,7 +73,10 @@ export function loadPolicy({ projectDir = process.cwd(), deps = {} } = {}) {
  *  es no-verificable ⇒ deny (roles sin declarar quedan como hoy). */
 export function evalToolCall(policy, { role = "coder", tool, input = {}, root = null }) {
   if (WRITE_TOOLS.has(tool)) return evalWrite(policy, role, input.file_path || input.notebook_path, root);
-  if (tool === "Bash") return evalShell(policy, role, input.command);
+  // KJC-BUG-0343: the inert prose of a text option (--title, --error, -m...) is
+  // not a target: a report naming a supervisor path is not a write to it. A path
+  // anywhere else, or a value that can expand, is still judged.
+  if (tool === "Bash") return evalShell(policy, role, stripTextOptionValues(String(input.command ?? "")));
   if (READONLY_TOOLS.has(tool) || !policy.roles?.[role]) return ALLOW_VERDICT;
   return denyVerdict(`roles.${role}.tools`, `tool "${tool}" fuera del registro de la policy — no verificable para el rol declarado ${role}`);
 }

package/src/policy/exceptions.js

@@ -6,7 +6,8 @@
  */
 import { appendFileSync, mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { homedir, userInfo } from "node:os";
+import { userInfo } from "node:os";
+import { getKarajanHome } from "../utils/paths.js";
 import { spawnSync } from "node:child_process";
 import { recordPolicyException as kernelRecord } from "@karajan-family/governance";
 
@@ -36,7 +37,10 @@ export function loadStandingExceptions(projectDir, { home } = {}) {
  * Ruta del almacén GLOBAL (~/.karajan): excepciones de la máquina, no de un
  * proyecto. `home` es inyectable SOLO para tests.
  */
-export const globalExceptionsFile = ({ home } = {}) => join(home ?? homedir(), ".karajan", "policy-exceptions.jsonl");
+// KJC-BUG-0337: with no injected home it is the Karajan home (honours KARAJAN_HOME,
+// and the suite's temp home), not homedir(): the tests read the machine's real grants.
+const globalDir = (home) => (home ? join(home, ".karajan") : getKarajanHome());
+export const globalExceptionsFile = ({ home } = {}) => join(globalDir(home), "policy-exceptions.jsonl");
 
 function readRecordsAt(file, origin) {
   let raw;
@@ -85,7 +89,7 @@ function defaultAppend(projectDir, line) {
 }
 
 const globalAppend = (home) => (_projectDir, line) => {
-  const dir = join(home ?? homedir(), ".karajan");
+  const dir = globalDir(home);
   mkdirSync(dir, { recursive: true });
   appendFileSync(join(dir, "policy-exceptions.jsonl"), line, "utf8");
 };

package/src/privacy/scan.js

@@ -70,6 +70,17 @@ const SECRET_HEURISTICS = [
 const FIREBASE_WEB_MARKERS = /firebaseConfig|authDomain|firebasestorage|firestore\.googleapis\.com|firebaseapp\.com/;
 const FIREBASE_KEY_HINT = "si es la clave web de Firebase (publica por diseno): declarala en el allow de ~/.karajan/privacy.yml y restringela por dominio en la consola de Google";
 
+// KJC-BUG-0329 (#2089): a lockfile dependency named *-token/*-auth/*-secret has a
+// version for value. Only a WHOLE value made of versions (digits.x[.y], optional
+// prerelease) joined by range operators is discarded (and counted); digits with
+// no dot, or a version glued to text, are still a secret assignment.
+// Prerelease and build metadata with the full SemVer charset (1.2.3-beta-1+build.5).
+const SEMVER_TOKEN = String.raw`\d+\.(?:\d+|x|\*)(?:\.(?:\d+|x|\*))?(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?`;
+const SEMVER_OP = String.raw`(?:[\^~]|[<>]=?|=)`;
+// Between two versions there is always an operator (||, a hyphen range, or a comparator).
+const SEMVER_JOIN = String.raw`\s*(?:(?:\|\||-)\s*${SEMVER_OP}?|${SEMVER_OP})\s*`;
+const SEMVER_VALUE = new RegExp(String.raw`^\s*${SEMVER_OP}?\s*${SEMVER_TOKEN}(?:${SEMVER_JOIN}${SEMVER_TOKEN})*\s*$`);
+
 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 },
@@ -138,6 +149,12 @@ export function scanText(text, { list = loadPrivacyList(), source = "<text>" } =
       re.lastIndex = 0;
       let m;
       while ((m = re.exec(probe)) !== null) {
+        if (type === "secret-assignment" && SEMVER_VALUE.test(m[1])) {
+          discarded += 1;
+          probe = probe.slice(0, m.index) + " ".repeat(m[0].length) + probe.slice(m.index + m[0].length);
+          re.lastIndex = m.index + m[0].length;
+          continue;
+        }
         findings.push({ severity: "warn", type, source, line: i + 1, masked: `${maskValue(m[1])} — move it to .env or a secret manager` });
         probe = probe.slice(0, m.index) + " ".repeat(m[0].length) + probe.slice(m.index + m[0].length);
         re.lastIndex = m.index + m[0].length;

package/src/review/card-first.js

@@ -11,7 +11,9 @@ import { listPlans, loadPlan } from "../plan/plan-store.js";
 import { escapeRegExp } from "../utils/escape-regexp.js";
 import { verifyCardAlive } from "./card-verify.js";
 
-const LIVE_STATUSES = new Set(["pending", "running", "failed"]);
+// KJC-BUG-0323: coding/reviewing are the run working the HU, certified is ready
+// to run; the gate blocked the pipeline's own commit on its own HU.
+const LIVE_STATUSES = new Set(["pending", "running", "failed", "certified", "coding", "reviewing"]);
 // Card-shaped reference: LIN-123, bb-002 and multi-segment ids like
 // KJC-TSK-0684 (optional middle segments) — tight enough to skip slugs.
 // Shared with the method report (MG-D): one pattern, one truth.

package/src/sonar/api.js

@@ -126,13 +126,20 @@ export async function getQualityGateStatus(config, projectKey = null) {
 
 export async function getOpenIssues(config, projectKey = null) {
   const effectiveProjectKey = await resolveSonarProjectKey(config, { projectKey, cwd: queryCwd(config) });
-  const body = await sonarFetch(config, `/api/issues/search?projectKeys=${effectiveProjectKey}&statuses=OPEN`);
+  // KJC-BUG-0339 (#2099): current SonarQube ignores projectKeys and answered with
+  // every project's issues, so the audit of one repo listed others' paths. The
+  // project goes in `components` (and projectKeys stays for old servers), and the
+  // answer is filtered by the key too: an issue of another project never leaves.
+  const key = encodeURIComponent(effectiveProjectKey);
+  const body = await sonarFetch(config, `/api/issues/search?components=${key}&projectKeys=${key}&statuses=OPEN`);
 
   let parsedIssues = [];
   let parsedRaw = body;
   try {
     const parsed = JSON.parse(body);
-    parsedIssues = parsed.issues || [];
+    // A project key may hold colons (Maven-style): match the whole key as a prefix.
+    const ownComponent = (c) => c === effectiveProjectKey || String(c ?? "").startsWith(`${effectiveProjectKey}:`);
+    parsedIssues = (parsed.issues || []).filter((i) => (i.project != null ? i.project === effectiveProjectKey : ownComponent(i.component)));
     parsedRaw = parsed;
   } catch { /* SonarQube response is not valid JSON */ }
 

package/src/spec-review/run-spec-review.js

@@ -51,6 +51,13 @@ export async function runSpecReview({ spec, config, logger, askQuestion, flags =
     return { proceed: true, skipped: true };
   }
   if (!spec || !String(spec).trim()) return { proceed: true, skipped: true };
+  // KJC-BUG-0321 (#2074): with --plan the spec is the plan's original task, which
+  // `kj plan` reviewed when it generated the plan, and the HUs were certified since.
+  // Reviewing it again flags the plan, not the HUs being run.
+  if (flags.plan) {
+    logger?.info?.(`Spec review skipped: plan ${flags.plan} was reviewed when it was generated and its HUs certified.`);
+    return { proceed: true, skipped: true };
+  }
 
   const role = new SpecReviewerRole({ config, logger });
   await role.init({ task: spec });

package/templates/roles/coder.md

@@ -52,7 +52,7 @@ Karajan projects MAY enforce a CI gate that fails any PR whose net delta exceeds
 
 - Stay under **~150 LOC per iteration** (safety margin against the 200 hard limit).
 - The gate counts the SUM of every changed file, not per-file. Tests count too. 5 files × 40 LOC = 200 = on the limit.
-- If the task clearly requires >150 LOC, STOP and report the partition needed. Don't ship a 500-LOC PR — the gate rejects it and the work is redone, burning tokens twice.
+- Up to 200 LOC is allowed without asking. If the task clearly requires >200 LOC, STOP and report the partition needed. Don't ship a 500-LOC PR — the gate rejects it and the work is redone, burning tokens twice.
 - Excluded from the count: lockfiles, snapshots, `dist/`, `node_modules/`, generated `tests/_diet/`, `public/docs/`. Source + tests count.
 
 ## Task completeness