karajan-code 4.41.0 → 4.43.0

package/package.json

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

package/src/commands/harden.js

@@ -26,6 +26,7 @@ import { detectStackRoots } from "../harden/stack-roots.js";
 import { installWorkflows } from "../harden/workflow-engine.js";
 import { detectTestFramework } from "../utils/project-detect.js";
 import { ensureIdentity } from "../identity/bootstrap.js";
+import { commitContract, contractChanges } from "../environment/contract-commit.js";
 
 const JS_TEST_CMD = {
   vitest: "npx vitest run",
@@ -104,8 +105,12 @@ export async function hardenCommand({
   exclude = [],
   commitSupervisor = false,
   kjVersion = null,
+  // KJC-BUG-0289: the contract files already dirty before anything was generated
+  // (kj init captures them before writing its own). What is dirty NOW is the person's.
+  contractBefore = null,
   logger = console,
 } = {}) {
+  const dirtyBefore = contractBefore ?? contractChanges(projectDir);
   const repoCfg = readHardenConfig(projectDir);
   const onlyDirs = [...(repoCfg.only ?? []), ...only];
   const excludeDirs = [...(repoCfg.exclude ?? []), ...exclude];
@@ -200,6 +205,15 @@ export async function hardenCommand({
     workflows: wf?.workflows ?? [],
     guidelines: gl?.guidelines ?? [],
   };
+  // KJC-BUG-0289 (#1984): what kj harden generates, kj commits (KJC-BUG-0273's
+  // path): only that, never on the base branch. Left to the agent, 3.2k generated
+  // lines exceeded its own PR size and stayed untracked. The seal (--commit, ADR
+  // 0009) stays a human act over the supervisor alone.
+  if (!dryRun) {
+    out.contract = commitContract({ projectDir, before: dirtyBefore, baseBranch });
+    if (out.contract.committed) logger.info?.(`kj harden: contract committed by kj, ${out.contract.files.length} generated file(s)`);
+    else if (!out.contract.reason.startsWith("nothing")) logger.warn?.(`kj harden: the contract kj generated is NOT committed (${out.contract.reason})`);
+  }
 
   if (json) {
     logger.info?.(JSON.stringify(out));

package/src/commands/init.js

@@ -26,6 +26,7 @@ import { installQmd } from "../utils/qmd-install.js";
 import { registerQmdCollections } from "../utils/qmd-collection.js";
 import { isGitRepo } from "../harden/harden-engine.js";
 import { hardenCommand } from "./harden.js";
+import { contractChanges } from "../environment/contract-commit.js";
 import { detectProjectStack } from "../utils/stack-detect.js";
 import { bootstrapSonarToken } from "../sonar/token-bootstrap.js";
 
@@ -771,6 +772,11 @@ export async function initCommand({ logger, flags = {} }) {
     const toStderr = (...args) => console.error(...args);
     logger = { ...logger, info: toStderr, warn: toStderr, error: toStderr };
   }
+  // KJC-BUG-0289: what is dirty NOW is the person's; kj harden commits only what
+  // init and harden generate below (skills, settings, hooks, configs, guidelines).
+  // Outside a repository (ensureGitRepo runs later) git cannot answer and the
+  // baseline is empty: everything generated afterwards is kj's.
+  const contractBefore = contractChanges(process.cwd());
   const karajanHome = getKarajanHome();
   await ensureDir(karajanHome);
   logger.info(`Ensured ${karajanHome} exists`);
@@ -928,7 +934,7 @@ export async function initCommand({ logger, flags = {} }) {
     logger.info("Quality harness skipped (--no-harden).");
   } else if (ensureGitRepo({ projectDir: process.cwd(), logger })) {
     logger.info("Installing quality harness (kj harden)...");
-    await hardenCommand({ projectDir: process.cwd(), logger });
+    await hardenCommand({ projectDir: process.cwd(), logger, contractBefore });
     hardened = true;
   } else {
     logger.warn("Quality harness NOT installed: this is not a git repository and `git init` failed — Karajan's guarantees live in git hooks. Fix git, then run `kj harden`.");

package/src/commands/pr-size.js

@@ -20,13 +20,19 @@ function mergeBase(projectDir, base) {
   throw new Error(`pr-size: no merge base with ${base} (nor origin/${base})`);
 }
 
-/** @returns {Promise<{added: number, exempt: number, testAdded: number, base: string}>} */
-export async function branchSize({ projectDir = process.cwd(), base = "main" } = {}) {
+/**
+ * @param {{projectDir?: string, base?: string, exclude?: string[]}} opts
+ *   `exclude` (KJC-BUG-0299): paths that will not be part of the commit (what
+ *   was pending before a pipeline run) are not the branch's size either.
+ * @returns {Promise<{added: number, exempt: number, testAdded: number, base: string}>}
+ */
+export async function branchSize({ projectDir = process.cwd(), base = "main", exclude = [] } = {}) {
   const from = mergeBase(projectDir, base);
+  const skip = new Set(exclude);
   // Working tree against the merge base: committed and uncommitted together.
-  let numstat = git(projectDir, ["diff", "--numstat", from]);
+  let numstat = git(projectDir, ["diff", "--numstat", from]).split("\n").filter((l) => l && !skip.has(l.split("\t").slice(2).join("\t"))).map((l) => `${l}\n`).join("");
   // New files not yet added are where a branch grows while it is written.
-  for (const file of git(projectDir, ["ls-files", "--others", "--exclude-standard"]).split("\n").filter(Boolean)) {
+  for (const file of git(projectDir, ["ls-files", "--others", "--exclude-standard"]).split("\n").filter((f) => f && !skip.has(f))) {
     let text;
     try { text = readFileSync(join(projectDir, file), "utf8"); } catch { continue; }
     if (text.includes("\0")) continue; // binary

package/src/config/defaults.js

@@ -115,6 +115,9 @@ const DEFAULTS = {
     // tests actually fail without the implementation. Off by default to
     // preserve current iteration latency.
     require_red_then_green: false,
+    // KJC-BUG-0298: with TDD the project's test suite runs every iteration and a
+    // red suite goes back to the coder, never to the reviewer.
+    require_green_suite: true,
     test_file_patterns: ["/tests/", "/__tests__/", ".test.", ".spec."],
     source_file_extensions: [".js", ".jsx", ".ts", ".tsx", ".py", ".go", ".java", ".rb", ".php", ".cs"]
   },
@@ -200,7 +203,8 @@ const DEFAULTS = {
     }
   },
   ci: { enabled: false, review_event: "kj-review", comment_event: "kj-comment", comment_prefix: true },
-  git: { auto_commit: false, auto_push: false, auto_pr: false, auto_rebase: true, branch_prefix: "feat/" },
+  // KJC-BUG-0299: pr_size_limit = lines added (CI budget count) over which the pipeline commits nothing.
+  git: { pr_size_limit: 200, auto_commit: false, auto_push: false, auto_pr: false, auto_rebase: true, branch_prefix: "feat/" },
   output: { report_dir: "./.reviews", log_level: "info", quiet: true },
   budget: {
     warn_threshold_pct: 80,

package/src/config/schema.js

@@ -118,12 +118,17 @@ const Development = v.optional(v.looseObject({
   require_test_changes: v.optional(v.boolean()),
   // KJC-TSK-0398: opt-in flag; module lands in PR1, integration in PR3.
   require_red_then_green: v.optional(v.boolean()),
+  // KJC-BUG-0298: run the suite every iteration under TDD (default true).
+  require_green_suite: v.optional(v.boolean()),
+  test_timeout_ms: v.optional(v.number()),
   test_file_patterns: v.optional(v.array(v.string())),
   source_file_extensions: v.optional(v.array(v.string())),
 }));
 
 const Git = v.optional(v.looseObject({
   auto_commit: v.optional(v.boolean()),
+  // KJC-BUG-0299: lines added (CI budget count) over which the pipeline commits nothing.
+  pr_size_limit: v.optional(v.number()),
   auto_push: v.optional(v.boolean()),
   auto_pr: v.optional(v.boolean()),
   auto_rebase: v.optional(v.boolean()),

package/src/config/test-harness.js

@@ -29,6 +29,7 @@
  * | config.testHarness key         | globalThis key                  | prod default |
  * |--------------------------------|----------------------------------|--------------|
  * | disableSonarStage              | __KJ_DISABLE_SONAR_STAGE        | false        |
+ * | disableSuiteGreenStage         | __KJ_DISABLE_SUITE_GREEN_STAGE  | false        |
  * | defaultSkillsMode              | __KJ_DEFAULT_SKILLS_MODE        | "auto"       |
  * | defaultPreflightExtended       | __KJ_DEFAULT_PREFLIGHT_EXTENDED | true         |
  * | defaultBrainDecisor            | __KJ_DEFAULT_BRAIN_DECISOR      | true         |
@@ -37,6 +38,9 @@
 
 const GLOBAL_KEYS = {
   disableSonarStage:        "__KJ_DISABLE_SONAR_STAGE",
+  // KJC-BUG-0298: the suite-green gate runs the project's REAL test command;
+  // under Vitest that is this repo's own suite inside a test. Off in tests/setup.js.
+  disableSuiteGreenStage:   "__KJ_DISABLE_SUITE_GREEN_STAGE",
   defaultSkillsMode:        "__KJ_DEFAULT_SKILLS_MODE",
   defaultPreflightExtended: "__KJ_DEFAULT_PREFLIGHT_EXTENDED",
   defaultBrainDecisor:      "__KJ_DEFAULT_BRAIN_DECISOR",
@@ -45,6 +49,7 @@ const GLOBAL_KEYS = {
 
 const PROD_DEFAULTS = Object.freeze({
   disableSonarStage:        false,
+  disableSuiteGreenStage:   false,
   defaultSkillsMode:        "auto",
   defaultPreflightExtended: true,
   defaultBrainDecisor:      true,

package/src/environment/contract-commit.js

@@ -8,6 +8,9 @@
  * seal (ADR 0009), which stays a human act.
  */
 import { execFileSync } from "node:child_process";
+import { basename } from "node:path";
+
+import { GENERATED_CONFIG_FILES } from "../harden/config-templates.js";
 
 /** What kj generates and the whole team must inherit by cloning (prefixes). */
 export const CONTRACT_PATHS = [
@@ -23,13 +26,20 @@ export const CONTRACT_PATHS = [
   "GEMINI.md",
   // KJC-TSK-0879: in a Rulesync repo kj's rules live in .rulesync/rules/karajan.md.
   ".rulesync/",
+  // KJC-BUG-0289 (#1984): the governance the whole team inherits (ADR 0016, KJC-BUG-0269).
+  ".karajan/rules.yml",
+  ".karajan/policy-anchor.json",
+  ".karajan/supervisor-signers.json",
 ];
 
 const FRESH_MESSAGE = "chore(bootstrap): el contrato del método, para que quien clone lo herede";
 const REGEN_MESSAGE = "chore(kj): el contrato del método, generado por kj";
 
 const runner = (projectDir, env) => (args) => execFileSync("git", ["-C", projectDir, ...args], { encoding: "utf8", env, stdio: ["ignore", "pipe", "pipe"] });
-const isContract = (file) => CONTRACT_PATHS.some((p) => (p.endsWith("/") || p.endsWith("-") ? file.startsWith(p) : file === p));
+// KJC-BUG-0289: the lint/format/commit configs harden generates sit at the root
+// or under a stack root (a fullstack monorepo is hardened on every side).
+const isContract = (file) =>
+  CONTRACT_PATHS.some((p) => (p.endsWith("/") || p.endsWith("-") ? file.startsWith(p) : file === p)) || GENERATED_CONFIG_FILES.has(basename(file));
 
 /** The contract files git sees as changed, with their porcelain code (`??` untracked). */
 function contractStatus(git) {

package/src/git/automation.js

@@ -5,6 +5,7 @@
 
 import { addCheckpoint } from "../session/store.js";
 import { pipelineSonarBlock, stampStagedVerdict } from "../review/verdict-store.js";
+import { branchSize } from "../commands/pr-size.js";
 import {
   ensureGitRepo,
   currentBranch,
@@ -79,7 +80,9 @@ export function commitMessageFromTask(task, taskType = null) {
     .replaceAll(/\s+/g, " ")
     .trim();
   const prefix = prefixForTaskType(taskType);
-  return `${prefix}: ${clean.slice(0, 72) || "karajan update"}`;
+  // KJC-BUG-0294 (#1993): cut on a word, never mid-word (a title with no blank keeps the hard cut).
+  const cut = clean.length > 72 ? clean.slice(0, 72).replace(/\s+\S*$/, "") : clean;
+  return `${prefix}: ${cut || "karajan update"}`;
 }
 
 /**
@@ -111,6 +114,11 @@ export async function prepareGitAutomation({ config, task, logger, session }) {
 
   const baseBranch = config.base_branch;
   const autoRebase = config.git.auto_rebase !== false;
+  // KJC-BUG-0294 (#1993): what is dirty or untracked NOW is not the run's; the
+  // pipeline commits only what it changes. Both names of a pending rename are
+  // kept. Fails closed: with no answer from git the run stops here rather than
+  // commit the person's pending changes later.
+  const preexisting = await listPendingPaths();
   const repoHasCommits = await hasCommits();
 
   // New repo without commits: create branch directly (no fetch/sync possible)
@@ -120,7 +128,7 @@ export async function prepareGitAutomation({ config, task, logger, session }) {
     await createBranch(created);
     logger.info(`New repo — created working branch: ${created}`);
     await addCheckpoint(session, { stage: "git-prep", branch: created, created: true, newRepo: true });
-    return { enabled: true, branch: created, baseBranch, autoRebase };
+    return { enabled: true, branch: created, baseBranch, autoRebase, preexisting };
   }
 
   await fetchBase(baseBranch).catch(() => {
@@ -153,7 +161,7 @@ export async function prepareGitAutomation({ config, task, logger, session }) {
     await addCheckpoint(session, { stage: "git-prep", branch, created: false });
   }
 
-  return { enabled: true, branch, baseBranch, autoRebase };
+  return { enabled: true, branch, baseBranch, autoRebase, preexisting };
 }
 
 export function buildPrBody({ task: _task, stageResults }) {
@@ -194,7 +202,7 @@ export async function earlyPrCreation({ gitCtx, task, logger, session, stageResu
   if (!gitCtx?.enabled) return null;
 
   const commitMsg = commitMessageFromTask(task);
-  const commitResult = await commitAll(commitMsg);
+  const commitResult = await commitAll(commitMsg, null, { exclude: gitCtx.preexisting || [] });
   if (!commitResult.committed) {
     logger.info("earlyPrCreation: no changes to commit");
     return null;
@@ -230,7 +238,7 @@ export async function incrementalPush({ gitCtx, task, logger, session }) {
   if (!gitCtx?.enabled) return null;
 
   const commitMsg = commitMessageFromTask(task);
-  const commitResult = await commitAll(commitMsg);
+  const commitResult = await commitAll(commitMsg, null, { exclude: gitCtx.preexisting || [] });
   if (!commitResult.committed) {
     logger.info("incrementalPush: no changes to commit");
     return null;
@@ -246,8 +254,18 @@ export async function incrementalPush({ gitCtx, task, logger, session }) {
   return { commits };
 }
 
-export async function finalizeGitAutomation({ config, gitCtx, task, logger, session, stageResults = null }) {
+const DEFAULT_PR_SIZE_LIMIT = 200;
+
+export async function finalizeGitAutomation({ config, gitCtx, task, logger, session, stageResults = null, review = null, measureSize = branchSize }) {
   if (!gitCtx?.enabled) return { git: "disabled", commits: [] };
+  // KJC-BUG-0297 (#1993): the pipeline commits only what a reviewer approved. An
+  // approval that reviewed nothing (reviewer disabled) stamps no verdict and
+  // commits nothing: the changes stay in the tree, and the log says why.
+  if (review && review.reviewed === false) {
+    logger.warn("No review, no commit: the reviewer was disabled, so the pipeline commits nothing; the changes stay in the tree for a review (kj review --staged)");
+    await addCheckpoint(session, { stage: "git-commit", committed: false, skipped: "unreviewed" });
+    return { committed: false, branch: gitCtx.branch, prUrl: null, pr: null, commits: [], unreviewed: true };
+  }
 
   // Take a snapshot of pending paths BEFORE staging so we can decide
   // whether what's about to be committed is just Karajan scaffolding
@@ -268,13 +286,31 @@ export async function finalizeGitAutomation({ config, gitCtx, task, logger, sess
 
   let committed = false;
   const commits = [];
+  // KJC-BUG-0299 (#1993): the PR budget is applied BEFORE the commit, with the
+  // CI gate's own count (kj pr-size), over what this commit will contain. A
+  // step planned at 150 lines once committed 960. Where the branch cannot be
+  // measured (a fresh repo with no base yet) kj says so and goes on.
   if (config.git.auto_commit) {
+    const limit = Number(config.git.pr_size_limit) > 0 ? Number(config.git.pr_size_limit) : DEFAULT_PR_SIZE_LIMIT;
+    let size = null;
+    try {
+      size = await measureSize({ projectDir: config.projectDir || process.cwd(), base: gitCtx.baseBranch, exclude: gitCtx.preexisting || [] });
+    } catch (err) {
+      logger.warn(`pr-size: the branch could not be measured (${err.message}); the budget is not checked for this commit`);
+    }
+    if (size && size.added > limit) {
+      logger.warn(`pr-size: ${size.added} line(s) added against ${gitCtx.baseBranch}, over the budget of ${limit}: nothing committed. Split the step (several commits, several HUs); the changes stay in the tree`);
+      await addCheckpoint(session, { stage: "git-commit", committed: false, skipped: "over-budget", added: size.added, limit });
+      return { committed: false, branch: gitCtx.branch, prUrl: null, pr: null, commits: [], overBudget: { added: size.added, limit } };
+    }
     // ENV-F1: this path only runs after the pipeline's reviewer approved,
     // so stamp that verdict for the staged diff — the v4 pre-commit gate
     // (when the repo opted in) accepts the pipeline's own commit.
     const commitResult = await commitAll(commitMsg, null, {
-      beforeCommit: () => stampStagedVerdict({
+      exclude: gitCtx.preexisting || [],
+      beforeCommit: ({ paths } = {}) => stampStagedVerdict({
         projectDir: config?.projectDir || process.cwd(),
+        paths,
         reviewer: config?.reviewer || "pipeline-reviewer",
         summary: `kj run session ${session?.id || ""}: reviewer approved`.trim(),
         // KJC-TSK-0838: the sonar stage result travels with the stamp.
@@ -285,7 +321,12 @@ export async function finalizeGitAutomation({ config, gitCtx, task, logger, sess
     if (commitResult.commit) {
       commits.push(commitResult.commit);
     }
-    await addCheckpoint(session, { stage: "git-commit", committed });
+    // KJC-BUG-0294: what was pending before the run stays out of the commit and is named;
+    // if the run also touched one of those files, its edit is in the tree, not in the commit.
+    if (commitResult.leftOut?.length) {
+      logger.warn(`Left out of the commit, pending before the run (review and commit them yourself): ${commitResult.leftOut.join(", ")}`);
+    }
+    await addCheckpoint(session, { stage: "git-commit", committed, leftOut: commitResult.leftOut || [] });
     logger.info(committed ? "Committed changes" : "No changes to commit");
   }
 

package/src/git/coder-commit-guard.js

@@ -0,0 +1,40 @@
+/**
+ * KJC-BUG-0285 (#1982): the coder commits nothing; the pipeline does, once the
+ * review approves. With --auto-commit the coder ran git commit inside its
+ * iteration, before the reviewer, and the rejected commit stayed on the branch.
+ * The stage reads HEAD before the coder runs and, when HEAD moved on top of it,
+ * undoes those commits SOFTLY: the changes stay in the tree and the index for
+ * the review. A rewritten branch (HEAD no longer descends from the start) is
+ * left alone. Plain git, no injected runner: it never throws, it says.
+ */
+import { spawnSync } from "node:child_process";
+
+const git = (args, cwd) => spawnSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+
+/** @returns {string|null} the sha HEAD points at, or null outside a repo with commits */
+export function headSha(cwd = process.cwd()) {
+  try {
+    const res = git(["rev-parse", "HEAD"], cwd);
+    return res.status === 0 ? res.stdout.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+/** @returns {{undone: number, reason?: string}} */
+export function undoCommitsSince(sha, cwd = process.cwd()) {
+  if (!sha) return { undone: 0, reason: "no starting commit" };
+  try {
+    const head = headSha(cwd);
+    if (!head || head === sha) return { undone: 0 };
+    if (git(["merge-base", "--is-ancestor", sha, "HEAD"], cwd).status !== 0) {
+      return { undone: 0, reason: "HEAD no longer descends from the iteration's start" };
+    }
+    const undone = Number(git(["rev-list", "--count", `${sha}..HEAD`], cwd).stdout.trim());
+    const reset = git(["reset", "--soft", sha], cwd);
+    if (reset.status !== 0) return { undone: 0, reason: `git reset --soft failed: ${reset.stderr.trim()}` };
+    return { undone };
+  } catch (err) {
+    return { undone: 0, reason: err.message };
+  }
+}

package/src/harden/hook-templates.js

@@ -133,6 +133,12 @@ export function hookBody(hook, cmds = {}, { globalHooksDir = null, baseBranch =
         `if git diff --cached -- . ':(exclude).github/workflows/kj-no-ai-attribution.yml' ':(exclude)src/harden/hook-templates.js' ':(exclude)src/harden/workflow-templates.js' ':(exclude)src/harden/sentinel-hooks.js' ':(exclude)scripts/ai-attribution-guard.yml' ':(exclude)tests/harden/attribution-guard.test.js' ':(exclude)tests/harden/sentinel-hooks.test.js' ':(exclude).karajan/hooks/pre-commit' ':(exclude).karajan/hooks/commit-msg' ':(exclude).karajan/harness/' | grep '^+' | grep -qiE '${AI_ATTRIBUTION}|generated with \\[?claude'; then`,
         "  echo 'kj harden: AI attribution is not allowed in committed content'; exit 1",
         "fi",
+        "# KJC-BUG-0296 (issue #1989): the host agent's runtime and local state never",
+        "# enter a commit, however they were staged (a blanket `git add -A` put a",
+        "# Claude scheduler lock into main). Checked on the staged list itself.",
+        "if git diff --cached --name-only | grep -qE '^(\\.claude/[^/]*\\.lock|\\.claude/scheduled_tasks\\.lock|\\.kj/|\\.karajan/identity\\.local\\.yml|\\.karajan/harness/sentinel-state\\.json)'; then",
+        "  echo 'kj harden: agent runtime files are staged (.claude/*.lock, .kj/, identity.local.yml, sentinel-state.json) — unstage them: git restore --staged <path>'; exit 1",
+        "fi",
         "# v4 review gate (ENV-C1, opt-in via `kj review --install-gate`):",
         "# a staged diff only enters with a recorded cross-AI approved verdict.",
         "# KJC-BUG-0165: the gate is active once the marker is COMMITTED (HEAD),",

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

@@ -64,10 +64,14 @@ export const headIndex = (words, heads) => {
   return k < 0 ? words.length : i + k;
 };
 
+// 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_{(@*#?$!-])|`/;
+
 /**
  * KJC-BUG-0243: blank the quoted text that cannot run: single-quoted spans, and
- * double-quoted spans with no $ or backtick. What remains is what the shell can
- * still expand or execute, so operator and substitution checks read only that.
+ * double-quoted spans with no live $ or backtick. What remains is what the shell
+ * can still expand or execute, so operator and substitution checks read only that.
  * @param {string} cmd
  */
 export const stripInertQuotes = (cmd) => {
@@ -79,7 +83,7 @@ export const stripInertQuotes = (cmd) => {
     while (j < cmd.length && cmd[j] !== q) j += q === '"' && cmd[j] === "\\" ? 2 : 1;
     if (j >= cmd.length) return out + cmd.slice(i); // unclosed: left as is, for the caller to deny
     const body = cmd.slice(i + 1, j);
-    out += q === "'" || !/[$`]/.test(body) ? q + q : q + body + q;
+    out += q === "'" || !LIVE_EXPANSION.test(body) ? q + q : q + body + q;
     i = j;
   }
   return out;

package/src/harden/sentinel-hooks.js

@@ -135,7 +135,8 @@ const POST_BODY = `#!/usr/bin/env node
 // a tool call (PostToolUse, always exit 0).
 import console from "node:console";
 import process from "node:process";
-import { relative } from "node:path";
+import { realpathSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
 import { spawnSync } from "node:child_process";
 import { CODE, TESTS, ROOT, CARD, branchOf, load, save, session } from "./sentinel-lib.mjs";
 import { remindersFor } from "./sentinel-reminders.mjs";
@@ -170,20 +171,37 @@ process.stdin.on("end", () => {
     // every question with silence, so the gate would demand what no query can
     // deliver. kj says so explicitly, in both its human and json forms.
     const EMPTY_INDEX = /No chunks indexed yet|"empty"\\s*:\\s*true/;
+    // KJC-BUG-0293 (#1996, #1995): the index names its sources through whatever
+    // spelling of the project directory indexed them (a symlinked workspace, an
+    // alias). Compared as TEXT against the harness root, every hit fell outside
+    // the tree and was dropped in silence: rag_hits stayed empty and only new
+    // files passed. Both sides are compared by REAL path, and what still falls
+    // outside is written down for the gate to name.
+    // A path whose file is gone (or not yet there) resolves through its deepest
+    // existing ancestor, so an alias of the directory still lands in the tree.
+    const realOf = (p) => {
+      try { return realpathSync(p); } catch { /* resolve the parent instead */ }
+      const d = dirname(p);
+      return !d || d === p ? p : join(realOf(d), basename(p));
+    };
+    const ROOT_REAL = realOf(ROOT);
     const recordRag = (query, sources, answer = "") => {
       const state = load();
       const s = session(state, sid);
       s.at = Date.now();
       if (EMPTY_INDEX.test(String(answer))) s.rag_index_empty = true;
       const hits = [];
+      const dropped = [];
       for (const src of sources) {
-        const rel = relative(ROOT, String(src)).split(String.fromCharCode(92)).join("/");
-        if (!rel || rel.startsWith("..") || rel.startsWith("/") || hits.includes(rel)) continue;
-        hits.push(rel);
+        const rel = relative(ROOT_REAL, realOf(String(src))).split(String.fromCharCode(92)).join("/");
+        if (!rel || rel === ".." || rel.startsWith("../") || rel.startsWith("/")) { dropped.push(String(src)); continue; }
+        if (!hits.includes(rel)) hits.push(rel);
       }
       (s.rag_queries ||= []).push({ ts: Date.now(), text: String(query || "").slice(0, 200), hits });
       const all = (s.rag_hits ||= []);
       for (const h of hits) if (!all.includes(h)) all.push(h);
+      if (hits.length === 0 && dropped.length > 0) s.rag_dropped = { root: ROOT_REAL, count: dropped.length, sample: dropped.slice(0, 3) };
+      else if (hits.length > 0) delete s.rag_dropped; // an answer inside the tree ends the diagnosis
       save(state);
     };
     // Sources are read STRUCTURALLY, never through the stringified response:
@@ -195,7 +213,9 @@ process.stdin.on("end", () => {
     };
     const parseJson = (t) => { try { return JSON.parse(t); } catch { return null; } };
     if (/__kj_rag_query$/.test(String(tool)) && /^mcp__/.test(String(tool))) {
-      const parts = Array.isArray(response?.content) ? response.content : [];
+      // KJC-BUG-0293: the host may hand the answer as {content:[parts]}, as the
+      // bare array of parts, or as the text itself; all three are the same answer.
+      const parts = Array.isArray(response?.content) ? response.content : Array.isArray(response) ? response : [{ text: typeof response === "string" ? response : "" }];
       recordRag(input.text, parts.flatMap((p) => sourcesOf(parseJson(String(p?.text || "")))), parts.map((p) => String(p?.text || "")).join(String.fromCharCode(10)));
       process.exit(0);
     }
@@ -292,7 +312,9 @@ process.stdin.on("end", () => {
     const s = session(state, sid);
     s.at = Date.now();
     const rel = relative(ROOT, file).replaceAll("\\\\", "/");
-    const bucket = TESTS.test(rel) ? s.edited_tests : CODE.test(rel) ? s.edited_sources : null;
+    // KJC-BUG-0279 (#1981): a file outside the repository is not one of its sources.
+    const inside = rel && rel !== ".." && !rel.startsWith("../") && !rel.startsWith("/");
+    const bucket = !inside ? null : TESTS.test(rel) ? s.edited_tests : CODE.test(rel) ? s.edited_sources : null;
     if (bucket && !bucket.includes(rel)) bucket.push(rel);
     // KJC-TSK-0910: the branch size while it is written, with the CI budget
     // (kj pr-size), said once per threshold crossed. Context, never a block.
@@ -747,8 +769,15 @@ process.stdin.on("end", () => {
       // (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-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
+      // it need no verifying when nothing after it writes. One mutating segment
+      // and the whole command is judged below, as before.
+      const CD_LITERAL = /^[ \\t]*(cd|pushd)([ \\t]+[^ \\t;|&<>$\`(){}\\n\\r]*)?[ \\t]*$/;
+      const readsOnly = (s) => s.split(/&&|\\|\\||[;|]/).every((seg) => READONLY.test(seg) || CD_LITERAL.test(seg));
       // KJC-BUG-0243: operators inside inert quotes (grep -e "a|b") do not chain anything.
-      if (!READONLY.test(stripInertQuotes(cmd))) {
+      if (!readsOnly(stripInertQuotes(cmd))) {
         // cd/pushd invalida TODO razonamiento textual de rutas posteriores
         // (carrera de bypasses confirmada en review: destino bare, con $,
         // relativas post-cd...): en un comando NO-read-only, cambiar de
@@ -960,7 +989,8 @@ process.stdin.on("end", () => {
       } 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)) {
+      // KJC-BUG-0279 (#1981): outside the repository there is no source to govern.
+      if (rel && rel !== ".." && !rel.startsWith("../") && !rel.startsWith("/") && CODE.test(rel) && !TESTS.test(rel)) {
         const branch = branchOf();
         const why = !branch ? null : BASE_BRANCHES.has(branch) ? "base" : !CARD.test(branch) ? "nocard" : null;
         // ADR 0015 (KJC-TSK-0925): no escape. Without a card there is no work.
@@ -1017,7 +1047,13 @@ process.stdin.on("end", () => {
               console.error("karajan sentinel: rag-first — el indice aun no tiene " + rel + " (" + absent + "); indexalo y consulta despues: kj_rag_query / kj rag query <que hace " + rel + ">" + doc("rag-first"));
               process.exit(2);
             } else {
-              console.error("karajan sentinel: rag-first — el RAG no ha respondido sobre " + rel + " en esta sesion; consulta antes de tocarlo: kj_rag_query / kj rag query <que hace " + rel + " y donde mas vive ese concepto>." + doc("rag-first"));
+              // KJC-BUG-0293 (#1996): hits that fell outside the tree are named, so the
+              // person learns the index was built from another path instead of querying again.
+              const dropped = rs.rag_dropped;
+              const outside = dropped?.count
+                ? " La ultima consulta devolvio " + dropped.count + " hit(s) fuera de este arbol (" + dropped.root + "): " + (dropped.sample || []).join(", ") + " — el indice se construyo desde otra ruta; reindexa desde esta: kj rag index --with-sources."
+                : "";
+              console.error("karajan sentinel: rag-first — el RAG no ha respondido sobre " + rel + " en esta sesion; consulta antes de tocarlo: kj_rag_query / kj rag query <que hace " + rel + " y donde mas vive ese concepto>." + outside + doc("rag-first"));
               process.exit(2);
             }
           }
@@ -1034,7 +1070,10 @@ process.stdin.on("end", () => {
       // bandera no puede apagar el gate de commit, y mover core.hooksPath lo
       // apaga entero. El --no-verify que kj harden --commit usa por dentro no
       // pasa por aqui: no es una tool call. Escape humano, sellado como el resto.
-      const words = wordsOf(cmd);
+      // KJC-BUG-0286 (#1982): judged on the git commit SEGMENT alone, read by the
+      // shell reader: a "commit" inside a grep pattern piped after git show, or
+      // the -n of a grep in the same pipeline, is not a skipped hook.
+      const commitSegments = shellSegments(cmd).map((ws) => ws.map((w) => w.slice(w.lastIndexOf("/") + 1))).filter((ws) => inOrder(["git", "commit"], ws));
       // git acepta abreviaturas no ambiguas de las opciones largas, asi que
       // --no-ver salta el hook igual que --no-verify (catch de la review).
       const shortWithN = (w) => w.length > 1 && w[0] === "-" && w[1] !== "-" && w.includes("n");
@@ -1051,12 +1090,45 @@ process.stdin.on("end", () => {
       // --config-env=core.hooksPath=VAR) y una propiedad de seguridad no puede
       // depender de como parta las palabras el separador (catch de la review).
       const movesHooks = cmd.toLowerCase().includes("core.hookspath");
-      if ((inOrder(["git", "commit"], words) && words.some(skipsVerify)) || movesHooks) {
+      if (commitSegments.some((ws) => ws.some(skipsVerify)) || movesHooks) {
         // ADR 0015 (KJC-TSK-0926): no escape. A broken hook is fixed; skipping it,
         // if it ever must happen, is the user's act in their own terminal.
         console.error("karajan sentinel: el gate de commit no se apaga con una bandera — el review cruzado y la policy corren en el hook, y saltarselos deja el diff sin veredicto. Si el hook esta roto, arreglalo; si de verdad hace falta saltarlo, lo hace tu usuario en su terminal." + doc("escapes"));
         process.exit(2);
       }
+      // KJC-BUG-0296 (#1989): the staged set is reviewed by name. A blanket
+      // git add -A / git add . / git add -u put a Claude scheduler lock into
+      // main; and the agent's runtime files (.claude/*.lock, .kj/, the local
+      // identity, the Sentinel state, the harness) are never staged at all.
+      // (No backticks in this template: they would end the string.)
+      const RUNTIME = /^(\\.\\/)?(\\.claude\\/[^/]*\\.lock|\\.kj\\/|\\.karajan\\/identity\\.local\\.yml|\\.karajan\\/harness\\/sentinel-state\\.json)/;
+      for (const ws of shellSegments(cmd)) {
+        const gi = ws.findIndex((x) => x.slice(x.lastIndexOf("/") + 1) === "git");
+        if (gi < 0) continue;
+        // git's own options come before the verb: -C <dir>, -c k=v, --git-dir=…
+        let vi = gi + 1;
+        while (vi < ws.length && ws[vi].startsWith("-")) vi += ws[vi] === "-C" || ws[vi] === "-c" ? 2 : 1;
+        if (ws[vi] !== "add") continue;
+        const args = ws.slice(vi + 1);
+        // The pathspec: after "--" if present, else every non-option word. "." is
+        // the whole tree whichever way it is written; -A/-u with no pathspec too.
+        const dash = args.indexOf("--");
+        const spec = dash >= 0 ? args.slice(dash + 1) : args.filter((a) => !a.startsWith("-"));
+        const whole = spec.some((a) => a === "." || a === "./");
+        const blanket = whole || (args.some((a) => a === "-A" || a === "--all" || a === "-u" || a === "--update") && spec.length === 0);
+        if (blanket) {
+          console.error("karajan sentinel: git add -A / . / -u stagea lo que no has revisado — stagea por nombre (git add -- <ruta>...) y mira git diff --cached --stat antes de commitear." + doc("commit-gate"));
+          process.exit(2);
+        }
+        // Directories too: .kj is runtime whole; .claude and .karajan hold the
+        // contract, so only a forced add (-f, past the ignore) reaches their locks.
+        const force = args.some((a) => a === "-f" || a === "--force");
+        const runtime = spec.find((a) => RUNTIME.test(a) || /^(\\.\\/)?\\.kj\\/?$/.test(a) || (force && /^(\\.\\/)?(\\.claude|\\.karajan)\\/?$/.test(a)));
+        if (runtime) {
+          console.error("karajan sentinel: " + runtime + " es runtime del agente (locks de .claude, .kj/, identidad local, estado del Sentinel) y no se commitea — fuera del stage." + doc("commit-gate"));
+          process.exit(2);
+        }
+      }
       const MERGE = /\\bgh\\s+pr\\s+merge(\\s+(\\d+))?/;
       const ADVANCE = /\\bgit\\s+commit\\b|\\bgit\\s+push\\b|\\bgh\\s+pr\\s+create\\b/; // push also falls under violations() — explicit here too (review catch)
       const mergeM = cmd.match(MERGE);

package/src/orchestrator/config-init.js

@@ -360,10 +360,12 @@ export function applyAutoSimplify({ pipelineFlags, triageLevel, config, flags, l
   if (flags.mode) return false;
   if (flags.enableReviewer !== undefined || flags.enableTester !== undefined) return false;
 
-  pipelineFlags.reviewerEnabled = false;
+  // KJC-BUG-0297 (#1993): a simple task still gets its cross-AI review. With
+  // the reviewer off, the gate's stub read as an approval and the pipeline
+  // stamped a verdict nobody gave and committed it. Only the tester is lighter.
   pipelineFlags.testerEnabled = false;
 
-  const disabledRoles = ["reviewer", "tester"];
+  const disabledRoles = ["tester"];
   logger.info(`Simple task (${triageLevel}) — lightweight pipeline (disabled: ${disabledRoles.join(", ")})`);
   emitProgress(
     emitter,

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

@@ -21,6 +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 { runToolJudgeStage } from "../../stages/tool-judge-stage.js";
 import { tryCiComment } from "../../ci-integration.js";
 
@@ -29,6 +30,12 @@ export async function runQualityGateStages({ config, logger, emitter, eventBase,
   if (tddResult.action === "pause") return { action: "return", result: tddResult.result };
   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) {
+    const green = await runSuiteGreenStage({ config, logger, emitter, eventBase, session, iteration: i });
+    if (green.action === "continue") return { action: "continue" };
+  }
+
   // KJC-TSK-0398 PR3: opt-in red-then-green check.
   if (config.development?.require_red_then_green) {
     const disc = await runTddDisciplineStage({