karajan-code 4.42.0 → 4.43.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "4.42.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/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/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/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-hooks.js

@@ -1096,6 +1096,39 @@ process.stdin.on("end", () => {
         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({

package/src/orchestrator/drivers/iteration-phases/reviewer-gate.js

@@ -29,9 +29,11 @@ export async function runReviewerGateStage({ pipelineFlags, reviewerRole, config
   };
   const reviewerResult = await runStage(stageRegistry.get("reviewer"), reviewerCtx);
   if (reviewerResult === null) {
+    // KJC-BUG-0297 (#1993): `reviewed: false` so the pipeline never stamps a
+    // verdict nobody gave nor commits on it (finalizeGitAutomation).
     return {
       action: "ok",
-      review: { approved: true, blocking_issues: [], non_blocking_suggestions: [], summary: "Reviewer disabled by pipeline", confidence: 1 }
+      review: { approved: true, reviewed: false, blocking_issues: [], non_blocking_suggestions: [], summary: "Reviewer disabled by pipeline: nothing was reviewed", confidence: 0 }
     };
   }
   if (reviewerResult.action === "pause") return { action: "return", result: reviewerResult.result };

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

@@ -107,7 +107,7 @@ export async function handlePostLoopStages({ config, session, emitter, eventBase
 }
 
 export async function finalizeApprovedSession({ config, gitCtx, task, logger, session, stageResults, emitter, eventBase, budgetSummary, pgCard, pgProject, review, i, rtkTracker }) {
-  const gitResult = await finalizeGitAutomation({ config, gitCtx, task, logger, session, stageResults });
+  const gitResult = await finalizeGitAutomation({ config, gitCtx, task, logger, session, stageResults, review });
 
   // Accumulate final commits for PG card lifecycle tracking
   if (gitResult?.commits?.length) {

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

@@ -0,0 +1,55 @@
+/**
+ * KJC-BUG-0298 (#1993): with TDD, a red suite never reaches the reviewer. A
+ * step whose test was added without its implementation was approved with one
+ * failing file, because nothing in the iteration RAN the tests: the
+ * verification gate counts changed lines, the TDD check asks that tests changed
+ * alongside sources, and the red-then-green discipline is opt-in. This stage
+ * runs the project's own test command (the one kj harden resolves: npm test, a
+ * known framework, pytest, go test) and hands a red suite back to the coder.
+ * Opt-out: `development.require_green_suite: false`.
+ */
+import { addCheckpoint, saveSession } from "../../session/store.js";
+import { setReviewerFeedback } from "../../session/mutators.js";
+import { emitProgress, makeEvent } from "../../utils/events.js";
+import { runCommand } from "../../utils/process.js";
+import { resolveCmds } from "../../commands/harden.js";
+
+const TAIL_CHARS = 2000;
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
+
+/** @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();
+  let command = null;
+  try {
+    command = (await resolveCmdsImpl(projectDir))?.test || null;
+  } catch (err) {
+    logger?.warn?.(`suite-green: could not resolve the test command (${err.message})`);
+  }
+  if (!command) {
+    const message = "suite-green: no test command for this project (package.json scripts.test or a known framework): the suite was NOT run";
+    logger?.warn?.(message);
+    emitProgress(emitter, makeEvent("tests:result", { ...eventBase, stage: "tests" }, { status: "warn", message, detail: { ran: false } }));
+    return { action: "ok", result: { ran: false } };
+  }
+  const timeout = Number(config?.development?.test_timeout_ms) > 0 ? Number(config.development.test_timeout_ms) : DEFAULT_TIMEOUT_MS;
+  const run = runTestsImpl || (async () => {
+    const res = await runCommand("bash", ["-lc", command], { cwd: projectDir, timeout });
+    return { exitCode: res.exitCode ?? 1, output: `${res.stdout || ""}\n${res.stderr || ""}` };
+  });
+  const res = await run(command);
+  const ok = res.exitCode === 0;
+  const verdict = ok ? "green" : `red (exit ${res.exitCode})`;
+  emitProgress(emitter, makeEvent("tests:result", { ...eventBase, stage: "tests" }, {
+    status: ok ? "ok" : "fail",
+    message: `${command}: ${verdict}`,
+    detail: { ran: true, ok, command, exitCode: res.exitCode, executorType: "local" },
+  }));
+  await addCheckpoint(session, { stage: "suite-green", iteration, ok, command });
+  if (ok) return { action: "ok", result: { ran: true, ok: true, command } };
+  const tail = String(res.output || "").trim().slice(-TAIL_CHARS);
+  setReviewerFeedback(session, `The test suite is RED (${command}, exit ${res.exitCode}). Make it green before anything else:\n${tail}`);
+  await saveSession(session);
+  logger?.warn?.(`suite-green: ${command} exited ${res.exitCode}; back to the coder`);
+  return { action: "continue", result: { ran: true, ok: false, command, exitCode: res.exitCode } };
+}

package/src/review/gate-gitignore.js

@@ -18,6 +18,8 @@ import { runCommand } from "../utils/process.js";
 // init and the orchestrator's autoInit write this same block instead of a
 // bare `.karajan/` exclude (which git cannot re-include children of).
 export const CONTRACT_BLOCK = [
+  // KJC-BUG-0296 (#1989): the host agent's runtime locks never travel.
+  ".claude/*.lock",
   ".karajan/*",
   "# …except the v4 environment contract, which the whole team inherits:",
   "!.karajan/review-gate",

package/src/review/verdict-store.js

@@ -98,14 +98,16 @@ export async function loadVerdict(projectDir, hash) {
  * (KJC-BUG-0115).
  * @returns {Promise<{stamped: boolean}>}
  */
-export async function stampStagedVerdict({ projectDir, reviewer, summary = "", sonar = null }) {
+export async function stampStagedVerdict({ projectDir, reviewer, summary = "", sonar = null, paths = null }) {
   const dir = projectDir || process.cwd();
   try {
     await fs.access(path.join(dir, ".karajan", "review-gate"));
   } catch {
     return { stamped: false };
   }
-  const res = await runCommand("git", ["diff", "--cached"], { cwd: dir });
+  // KJC-BUG-0294: the pipeline commits by path (`--only`); the verdict must bind
+  // to that diff, not to other files the person had staged.
+  const res = await runCommand("git", ["diff", "--cached", ...(paths?.length ? ["--", ...paths] : [])], { cwd: dir });
   if (res.exitCode !== 0 || !res.stdout?.trim()) return { stamped: false };
   await saveVerdict(dir, res.stdout, {
     verdict: "approved", reviewer, host: "kj-pipeline", issues: [], summary,

package/src/roles/domain-curator-role.js

@@ -42,20 +42,13 @@ export class DomainCuratorRole {
     // 3. Deduplicate (file domains take precedence over registry entries)
     const allDomains = deduplicateDomains(fileDomains, registryDomains);
 
-    // 4. No domains found
+    // 4. No domains found. KJC-BUG-0295 (#1992): this used to ASK the user
+    // ("do you have domain documents?") and then do nothing with the answer:
+    // a cryptic, English-only question with no consequence, raised even when
+    // the card already carried the acceptance criteria. A question that changes
+    // nothing is not asked; what kj uses instead is said.
     if (allDomains.length === 0) {
-      if (askQuestion?.interactive) {
-        const answer = await askQuestion({
-          message: "No domain knowledge found for this task.\nDo you have domain documents to provide, or should the pipeline continue without domain context?",
-          type: "confirm"
-        });
-        // For now, just log. Future: support document ingestion.
-        if (answer === true) {
-          this.logger.info("Domain Curator: user indicated domain documents available — future feature");
-        }
-      } else {
-        this.logger.warn("Domain Curator: no domain knowledge found, continuing without domain context");
-      }
+      this.logger.info("Domain Curator: no domain documents in .karajan/domains/ nor the registry; the task's own text, the card's acceptance criteria and the repo are the context");
 
       return {
         ok: true,

package/src/utils/git.js

@@ -189,25 +189,32 @@ export async function hasChanges(cwd = null) {
  * is structural here — without it the slice(3) below would crop one
  * character off the first path.
  */
-export async function listPendingPaths() {
-  const res = await run("git", ["status", "--porcelain"]);
+/**
+ * KJC-BUG-0294: the pending entries as `git status --porcelain -z` reports them,
+ * NUL-separated so a path with blanks or quotes arrives whole. A rename is one
+ * entry "R  new\0old": `path` is the new name, `oldPath` the one that goes away.
+ * @returns {Promise<{path: string, oldPath?: string}[]>}
+ */
+export async function listPendingEntries(cwd = null) {
+  const res = await run("git", ["status", "--porcelain", "-z"], cwd ? { cwd } : {});
   if (res.exitCode !== 0) {
     throw new Error(`git status --porcelain failed: ${res.stderr || res.stdout}`);
   }
-  const stdout = res.stdout;
-  if (!stdout) return [];
-  const lines = stdout.split("\n").map((l) => l.replace(/\r$/, "")).filter(Boolean);
+  const tokens = String(res.stdout || "").split("\0").filter(Boolean);
   const out = [];
-  for (const line of lines) {
-    // Each line is "XY <path>" (XY = 2-char status, space, path).
-    // Renames look like "R  old -> new"; we want the new path.
-    const after = line.slice(3);
-    const arrow = after.indexOf(" -> ");
-    out.push(arrow !== -1 ? after.slice(arrow + 4) : after);
+  for (let i = 0; i < tokens.length; i += 1) {
+    const entry = { path: tokens[i].slice(3) };
+    if (/^[RC]/.test(tokens[i]) || /^.[RC]/.test(tokens[i])) entry.oldPath = tokens[++i];
+    out.push(entry);
   }
   return out;
 }
 
+/** The pending paths; a rename contributes both its names (the old one is a pending deletion). */
+export async function listPendingPaths(cwd = null) {
+  return (await listPendingEntries(cwd)).flatMap((e) => (e.oldPath ? [e.oldPath, e.path] : [e.path]));
+}
+
 // Locale-tolerant detection of "git commit refused because the working
 // tree was already clean by the time we ran it". Observed in N4
 // dogfooding (2026-05-07) — `hasChanges()` reported true after `add -A`
@@ -229,17 +236,36 @@ function isNothingToCommit(message) {
   return NOTHING_TO_COMMIT_PATTERNS.some((re) => re.test(m));
 }
 
-export async function commitAll(message, cwd = null, { beforeCommit = null } = {}) {
+/**
+ * KJC-BUG-0294 (#1993): the pipeline commits what the run changed, never what
+ * was already dirty or untracked before it (`exclude`: the paths pending when
+ * the run started, the harness kj generates among them). `git add -A` staged
+ * 22 untracked files and 960 lines of contract into one step's commit.
+ */
+export async function commitAll(message, cwd = null, { beforeCommit = null, exclude = [] } = {}) {
   const opts = cwd ? { cwd } : {};
-  await runGit(["add", "-A"], opts);
-  const changed = await hasChanges(cwd);
-  if (!changed) return { committed: false };
+  const skip = new Set(exclude);
+  const pending = await listPendingEntries(cwd);
+  const names = (e) => (e.oldPath ? [e.oldPath, e.path] : [e.path]);
+  // A rename of a file that was dirty before the run is that file under a new name.
+  const theirs = (e) => names(e).some((p) => skip.has(p));
+  // A rename stages its old name too (the deletion), or git keeps the old file.
+  const paths = pending.filter((e) => !theirs(e)).flatMap(names);
+  // A path dirty before the run may hold the run's edits too; they cannot be told
+  // apart, so the path stays out and is NAMED (`leftOut`) for the person to commit.
+  const leftOut = pending.filter(theirs).flatMap(names);
+  const said = leftOut.length > 0 ? { leftOut } : {};
+  if (paths.length === 0) return { committed: false, ...said };
+  await runGit(["add", "--", ...paths], opts);
   // ENV-F1 (KJC-TSK-0643): runs between staging and committing — the only
   // window where the staged diff is exactly what the commit will contain
   // (used to stamp the pipeline's review verdict for the v4 gate).
-  if (beforeCommit) await beforeCommit();
+  // The callback learns the exact paths, so a verdict stamped there binds to the
+  // diff this commit will contain and not to whatever else the index holds.
+  if (beforeCommit) await beforeCommit({ paths });
   try {
-    await runGit(["commit", "-m", message], opts);
+    // --only: these paths and nothing else; what the person had staged stays staged.
+    await runGit(["commit", "-m", message, "--only", "--", ...paths], opts);
   } catch (err) {
     // `git status --porcelain` and `git commit` disagreed about whether
     // there was anything to commit. Don't escalate — the only outcome
@@ -252,7 +278,7 @@ export async function commitAll(message, cwd = null, { beforeCommit = null } = {
   }
   const raw = await runGit(["log", "-1", "--pretty=format:%H%x1f%s"], opts);
   const [hash, commitMessage] = raw.split("\x1f");
-  return { committed: true, commit: { hash, message: commitMessage } };
+  return { committed: true, commit: { hash, message: commitMessage }, ...said };
 }
 
 /**