karajan-code 4.70.3 → 4.70.4

package/package.json

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

package/src/checks/ai-surface.js

@@ -11,11 +11,13 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { claudeConfigFile, codexHome } from "../utils/agent-home.js";
 
-const sources = (projectDir, home) => [
+// KJC-TSK-1344: claude and codex configs of the account CLAUDE_CONFIG_DIR / CODEX_HOME select.
+const sources = (projectDir, home, env = process.env) => [
   { file: path.join(projectDir, ".mcp.json"), format: "json" },
-  { file: path.join(home, ".claude.json"), format: "json" },
-  { file: path.join(home, ".codex", "config.toml"), format: "toml" },
+  { file: claudeConfigFile({ home, env }), format: "json" },
+  { file: path.join(codexHome({ home, env }), "config.toml"), format: "toml" },
   { file: path.join(home, ".gemini", "settings.json"), format: "json" },
 ];
 
@@ -34,9 +36,9 @@ const tomlServerNames = (text) =>
   new Set([...text.matchAll(/^\s*\[mcp_servers\.["']?([^\]"']+)["']?\]/gm)].map((m) => m[1]));
 
 /** Sorted `name (config-file)` entries for every MCP reachable in this project. */
-export function collectAiSurface({ projectDir = process.cwd(), home = os.homedir() } = {}) {
+export function collectAiSurface({ projectDir = process.cwd(), home = os.homedir(), env = process.env } = {}) {
   const surface = new Set();
-  for (const { file, format } of sources(projectDir, home)) {
+  for (const { file, format } of sources(projectDir, home, env)) {
     if (!existsSync(file)) continue;
     let text;
     try { text = readFileSync(file, "utf8"); } catch { continue; }
@@ -50,11 +52,11 @@ export function collectAiSurface({ projectDir = process.cwd(), home = os.homedir
  * Diff the current surface against the last-seen snapshot and persist the
  * new state. First run records the baseline silently.
  */
-export function checkAiSurface({ projectDir = process.cwd(), home = os.homedir(), statePath = path.join(os.homedir(), ".karajan", "ai-surface.json"), extraSurface = [] } = {}) {
+export function checkAiSurface({ projectDir = process.cwd(), home = os.homedir(), env = process.env, statePath = path.join(os.homedir(), ".karajan", "ai-surface.json"), extraSurface = [] } = {}) {
   // KJC-TSK-0728: extraSurface carries entries the (async) caller collected
   // outside config files — e.g. observed agent CLIs as "grok (cli)" — so
   // they ride the same snapshot and the same "NEW since last check" drift.
-  const surface = [...new Set([...collectAiSurface({ projectDir, home }), ...extraSurface])].sort();
+  const surface = [...new Set([...collectAiSurface({ projectDir, home, env }), ...extraSurface])].sort();
   let state = {};
   try { state = JSON.parse(readFileSync(statePath, "utf8")); } catch { /* first run or corrupt → baseline */ }
   const prev = Array.isArray(state[projectDir]) ? state[projectDir] : null;

package/src/checks/config-files.js

@@ -18,6 +18,7 @@ import { getConfigPath } from "../config.js";
 import { resolveRoleMdPath, loadFirstExisting } from "../roles/base-role.js";
 import { withDocLink } from "../utils/doc-links.js";
 import { STRATEGY } from "./types.js";
+import { codexHome } from "../utils/agent-home.js";
 
 /**
  * kj.config.yml presence check.
@@ -218,16 +219,16 @@ function createStaleMcpPathCheck() {
 }
 
 /**
- * Codex config (~/.codex/config.toml) validity.
+ * Codex config ($CODEX_HOME/config.toml, ~/.codex by default) validity.
+ * KJC-TSK-1344: the account CODEX_HOME selects is the one whose config counts.
  */
-function createCodexConfigCheck() {
+export function createCodexConfigCheck({ env = process.env, home = os.homedir() } = {}) {
+  const codexTomlPath = path.join(codexHome({ home, env }), "config.toml");
   return {
     name: "agent-config:codex",
-    label: "Agent config: codex (~/.codex/config.toml)",
+    label: `Agent config: codex (${codexTomlPath})`,
     strategy: STRATEGY.MANUAL,
     async detect() {
-      const home = os.homedir();
-      const codexTomlPath = path.join(home, ".codex", "config.toml");
       try {
         const raw = await fs.readFile(codexTomlPath, "utf8");
         const duplicates = findDuplicateTomlKeys(raw);
@@ -236,7 +237,7 @@ function createCodexConfigCheck() {
             ok: false,
             severity: "warn",
             detail: `Duplicate TOML keys: ${duplicates.join(", ")}`,
-            fix: `Remove duplicate entries in ~/.codex/config.toml: ${duplicates.join(", ")}`,
+            fix: `Remove duplicate entries in ${codexTomlPath}: ${duplicates.join(", ")}`,
           };
         }
         return { ok: true, severity: "info", detail: "Valid TOML (no duplicate keys)" };
@@ -248,7 +249,7 @@ function createCodexConfigCheck() {
           ok: false,
           severity: "warn",
           detail: `Cannot read: ${err.message.split("\n")[0]}`,
-          fix: "Check file permissions on ~/.codex/config.toml",
+          fix: `Check file permissions on ${codexTomlPath}`,
         };
       }
     },

package/src/cli/register-pipeline.js

@@ -136,6 +136,9 @@ export function registerPipeline(program, { pkgVersion }) {
     .option("-q, --quiet", "Show only stage status lines, suppress raw agent output (default)")
     .option("-v, --verbose", "Show full agent output (stream-json, raw lines)")
     .action(async (task, flags) => {
+      // KJC-BUG-0448: run's --profile is the model profile; harden and check use
+      // --profile for the harness, so the config loader reads modelProfile.
+      if (flags.profile) flags.modelProfile = flags.profile;
       await withConfig(pkgVersion, "run", flags, async ({ config, logger }) => {
         // If `--plan <id>` was passed and the user didn't provide a task
         // argument or --task-file, fall back to the task embedded in the

package/src/commands/env.js

@@ -135,7 +135,9 @@ export async function envInstallCommand({ config = null, logger = null, flags =
         console.log(result.pendingBlock);
         return result;
       }
-      await reviewGateCommand({ config, flags: { installGate: true } });
+      const gate = await reviewGateCommand({ config, flags: { installGate: true } });
+      // KJC-BUG-0447: a gate no hook runs is decorative; never call it active.
+      if (!gate?.enforced) throw new Error("the review gate is declared but no pre-commit hook runs it");
       console.log("✓ enforcement active: git hooks + cross-AI verdict gate — a commit outside the method is rejected, not narrated");
     } catch (err) {
       result.exitCode = PENDING_EXIT_CODE;

package/src/commands/go.js

@@ -11,6 +11,7 @@ import os from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { checkBinary } from "../utils/agent-detect.js";
+import { agentAuthFiles } from "../utils/agent-home.js";
 import { createCliAskQuestion } from "../utils/cli-ask-question.js";
 import { bootstrapCommand } from "./bootstrap.js";
 import { boardCommand } from "./board.js";
@@ -21,12 +22,14 @@ export const MAGGLE_AGENTS = [
   { name: "claude", label: "Claude Code (Anthropic)", authPaths: [".claude.json", ".claude"], install: "npm install -g @anthropic-ai/claude-code", login: "claude   (sigue el enlace de inicio de sesión que te muestre)" },
   { name: "codex", label: "Codex (OpenAI)", authPaths: [".codex/auth.json"], install: "npm install -g @openai/codex", login: "codex login" },
 ];
-export async function detectMaggleAgents({ home = os.homedir(), checkBin = checkBinary } = {}) {
+export async function detectMaggleAgents({ home = os.homedir(), env = process.env, checkBin = checkBinary } = {}) {
   return Promise.all(
     MAGGLE_AGENTS.map(async (a) => {
       let installed = false;
       try { installed = (await checkBin(a.name)).ok; } catch { /* not installed */ }
-      const authenticated = installed && a.authPaths.some((p) => existsSync(path.join(home, p)));
+      // KJC-TSK-1344: the session lives where CLAUDE_CONFIG_DIR / CODEX_HOME point.
+      const files = agentAuthFiles(a.name, { home, env }) ?? a.authPaths.map((p) => path.join(home, p));
+      const authenticated = installed && files.some((f) => existsSync(f));
       return { ...a, installed, authenticated };
     }),
   );

package/src/commands/harden.js

@@ -25,12 +25,20 @@ import { installHarnessHooks } from "../harden/harness-hooks.js";
 import { installSentinelHooks } from "../harden/sentinel-hooks.js";
 import { installSandbox } from "../harden/sandbox.js";
 import { detectStackRoots } from "../harden/stack-roots.js";
-import { installWorkflows, resolveKjPin } from "../harden/workflow-engine.js";
+import { detectPackageManager, installWorkflows, resolveKjPin } from "../harden/workflow-engine.js";
 import { adviseBranchProtection } from "../harden/branch-protection.js";
 import { detectTestFramework } from "../utils/project-detect.js";
 import { ensureIdentity } from "../identity/bootstrap.js";
 import { commitContract, contractChanges } from "../environment/contract-commit.js";
 
+// How each package manager runs a package.json script in a hook (`bun test` is bun's own runner, not the script).
+const HOOK_RUNNERS = {
+  npm: { run: (s) => `npm run -s ${s}`, test: "npm test" },
+  pnpm: { run: (s) => `pnpm run -s ${s}`, test: "pnpm test" },
+  yarn: { run: (s) => `yarn run ${s}`, test: "yarn test" },
+  bun: { run: (s) => `bun run ${s}`, test: "bun run test" },
+};
+
 const JS_TEST_CMD = {
   vitest: "npx vitest run",
   jest: "npx jest",
@@ -51,10 +59,12 @@ export async function resolveCmds(projectDir, language) {
   if (existsSync(pkgPath)) {
     try {
       const scripts = JSON.parse(readFileSync(pkgPath, "utf8")).scripts ?? {};
-      if (scripts.lint) cmds.lint = "npm run -s lint";
-      if (scripts["format:check"]) cmds.format = "npm run -s format:check";
-      else if (scripts.format) cmds.format = "npm run -s format";
-      if (scripts.test) cmds.test = "npm test";
+      // KJC-BUG-0450 (#2789): the project's own package manager, as the workflows use it.
+      const pm = HOOK_RUNNERS[detectPackageManager(projectDir)] ?? HOOK_RUNNERS.npm;
+      if (scripts.lint) cmds.lint = pm.run("lint");
+      if (scripts["format:check"]) cmds.format = pm.run("format:check");
+      else if (scripts.format) cmds.format = pm.run("format");
+      if (scripts.test) cmds.test = pm.test;
     } catch {
       /* unreadable package.json → fall back to framework detection */
     }

package/src/commands/review-gate.js

@@ -34,6 +34,7 @@ import { evaluatePolicyGate } from "../review/policy-gate.js";
 import { correctionNote, reviewCorrectionRounds } from "../review/correction-rounds.js";
 import { cooldownAdvisories, cooldownGate, DEFAULT_COOLDOWN_HOURS, formatCooldown } from "../review/dep-cooldown.js";
 import { branchOverlaps, formatOverlaps } from "../review/branch-overlap.js";
+import { gateHookStatus } from "../review/gate-hook.js";
 
 // KJC-TSK-0686 (MG-A): card-first is a gate, not a habit. Runs on --staged
 // (before spending sonar/reviewer effort) AND on --check — the pre-commit
@@ -195,18 +196,20 @@ export async function reviewGateCommand({ config, logger = null, flags = {} }) {
     const marker = join(projectDir, ".karajan", "review-gate");
     await fs.mkdir(join(projectDir, ".karajan"), { recursive: true });
     await fs.writeFile(marker, "# Cross-AI review gate enabled (ENV-C1). Commit this file so the whole team inherits the gate.\n");
-    console.log("✓ review gate enabled — commits now require an approved cross-AI verdict (kj review --staged)");
+    // KJC-BUG-0447 (#2655): the marker declares the gate; only a pre-commit that runs it enforces it.
+    const hook = gateHookStatus(projectDir);
+    if (hook.enforced) console.log("✓ review gate enabled — commits now require an approved cross-AI verdict (kj review --staged)");
+    else {
+      console.log(`✗ review gate declared (.karajan/review-gate) but NOT enforced: ${hook.reason} — run \`kj harden\` so the pre-commit hook runs it`);
+      process.exitCode = 1;
+    }
     // KJC-TSK-0646: a `.karajan/` dir-exclude would silently keep the
     // contract out of git — rewrite it so the team actually inherits it.
     const gi = await ensureGateTrackable(projectDir);
     if (gi.changed) {
       console.log("✓ .gitignore adjusted: the gate contract (.karajan/review-gate, hooks) is now trackable — commit it");
     }
-    const hookProbe = await runCommand("git", ["config", "core.hooksPath"]);
-    if (!hookProbe.stdout?.trim()) {
-      console.log("⚠ no core.hooksPath configured — run `kj harden` so the pre-commit hook enforces the gate");
-    }
-    return { installed: true };
+    return { installed: true, enforced: hook.enforced };
   }
 
   // KJC-BUG-0173: manual GC of the verdict store. Opportunistic pruning runs

package/src/config/overrides.js

@@ -102,7 +102,8 @@ function applyRoleOverrides(out, flags) {
   if (flags.reviewerModel) out.reviewer_options.model = String(flags.reviewerModel);
 
   // KJC-TSK-0699: a profile fills only the models nothing above has set.
-  const profile = flags.profile ?? out.model_profile;
+  // KJC-BUG-0448: its own key — `--profile` belongs to harden/check (the harness profile).
+  const profile = flags.modelProfile ?? out.model_profile;
   if (profile) {
     applyModelProfile(out, String(profile));
     out.model_profile = String(profile);

package/src/environment/board-access.js

@@ -14,6 +14,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { claudeConfigFile, codexHome } from "../utils/agent-home.js";
 
 const TOKEN_CONVENTIONS = {
   linear: ["LINEAR_API_KEY"],
@@ -23,18 +24,19 @@ const TOKEN_CONVENTIONS = {
   asana: ["ASANA_ACCESS_TOKEN"],
 };
 
-function mcpConfigPaths(projectDir, home) {
+// KJC-TSK-1344: claude and codex configs of the account CLAUDE_CONFIG_DIR / CODEX_HOME select.
+function mcpConfigPaths(projectDir, home, env = process.env) {
   return [
     path.join(projectDir, ".mcp.json"),
-    path.join(home, ".claude.json"),
-    path.join(home, ".codex", "config.toml"),
+    claudeConfigFile({ home, env }),
+    path.join(codexHome({ home, env }), "config.toml"),
     path.join(home, ".gemini", "settings.json"),
   ];
 }
 
-function mcpConfigsMention(slug, projectDir, home) {
+function mcpConfigsMention(slug, projectDir, home, env) {
   const needle = slug.toLowerCase();
-  for (const p of mcpConfigPaths(projectDir, home)) {
+  for (const p of mcpConfigPaths(projectDir, home, env)) {
     try {
       if (existsSync(p) && readFileSync(p, "utf8").toLowerCase().includes(needle)) return p;
     } catch { /* unreadable config — keep looking */ }
@@ -50,13 +52,13 @@ function mcpConfigsMention(slug, projectDir, home) {
  */
 export function detectAvailableBoards({ projectDir = process.cwd(), env = process.env, home = os.homedir() } = {}) {
   const boards = [{ value: "hu-board", label: "HU Board (bundled, zero setup)" }];
-  if (mcpConfigsMention("planning-game", projectDir, home)) {
+  if (mcpConfigsMention("planning-game", projectDir, home, env)) {
     boards.push({ value: "planning-game", label: "Planning Game (MCP detected)" });
   }
   for (const [slug, envs] of Object.entries(TOKEN_CONVENTIONS)) {
     const token = envs.find((k) => env[k]);
     if (token) boards.push({ value: `external:${slug}`, label: `${slug} (token ${token})` });
-    else if (mcpConfigsMention(slug, projectDir, home)) boards.push({ value: `external:${slug}`, label: `${slug} (MCP detected)` });
+    else if (mcpConfigsMention(slug, projectDir, home, env)) boards.push({ value: `external:${slug}`, label: `${slug} (MCP detected)` });
   }
   return boards;
 }
@@ -65,7 +67,7 @@ export function verifyBoardAccess({ config = {}, projectDir = process.cwd(), env
   const backend = config.state_backend || "hu-board";
 
   if (backend === "planning-game") {
-    const hit = mcpConfigsMention("planning-game", projectDir, home);
+    const hit = mcpConfigsMention("planning-game", projectDir, home, env);
     if (hit) return { ok: true, backend, via: `planning-game MCP (${hit})` };
     return {
       ok: false, backend,
@@ -77,7 +79,7 @@ export function verifyBoardAccess({ config = {}, projectDir = process.cwd(), env
     const name = String(config.board?.name || "").trim();
     if (!name) return { ok: false, backend, needed: ["declare board.name in kj.config.yml (e.g. Linear, Trello, Jira, GitHub Issues)"] };
     const slug = name.toLowerCase().split(/\s+/)[0];
-    const hit = mcpConfigsMention(slug, projectDir, home);
+    const hit = mcpConfigsMention(slug, projectDir, home, env);
     if (hit) return { ok: true, backend, via: `${name} MCP detected (${hit})` };
     const tokenEnvs = config.board?.token_env ? [config.board.token_env] : (TOKEN_CONVENTIONS[slug] || []);
     const found = tokenEnvs.find((k) => env[k]);

package/src/harden/branch-protection.js

@@ -43,6 +43,34 @@ const addCommand = ({ missing, ...target }) =>
   `gh api -X POST ${protectionPath(target)}/required_status_checks/contexts ${missing.map((c) => `-f ${shellQuote(`contexts[]=${c}`)}`).join(" ")}`;
 
 const settingsUrl = ({ owner, repo }) => `https://github.com/${owner}/${repo}/settings/branches`;
+const rulesUrl = ({ owner, repo }) => `https://github.com/${owner}/${repo}/settings/rules`;
+
+/**
+ * KJC-BUG-0449 (#2787): every rule that applies to the branch, rulesets included.
+ * [] when none applies (a 404 included); null when it cannot be read.
+ */
+async function branchRules({ owner, repo, branch }, run) {
+  let res;
+  try { res = await run("gh", ["api", `repos/${owner}/${repo}/rules/branches/${encodeURIComponent(branch)}`]); } catch { return null; }
+  if (res.exitCode !== 0) return /404/.test(`${res.stderr}${res.stdout}`) ? [] : null;
+  try {
+    const rules = JSON.parse(res.stdout || "[]");
+    return Array.isArray(rules) ? rules : null;
+  } catch { return null; }
+}
+
+const rulesetChecks = (rules) => rules
+  .filter((r) => r?.type === "required_status_checks")
+  .flatMap((r) => (r.parameters?.required_status_checks ?? []).map((c) => c.context));
+
+/** No classic protection: the rulesets decide, and they are fixed in their own page, never with a PUT. */
+function rulesetAdvice({ rules, checks, target }) {
+  if (rules === null) return { status: "unverified", reason: "the branch rules could not be read", settings: rulesUrl(target), missing: checks };
+  if (rules.length === 0) return { status: "unprotected", command: protectCommand({ ...target, checks }) };
+  const required = new Set(rulesetChecks(rules));
+  const missing = checks.filter((c) => !required.has(c));
+  return missing.length > 0 ? { status: "ruleset-missing", missing, settings: rulesUrl(target) } : { status: "ok", via: "ruleset" };
+}
 
 /**
  * What the base branch needs for the checks to be required, and how. A command
@@ -61,14 +89,18 @@ export async function protectionAdvice({ owner, repo, branch, checks, run = runC
     return { status: "unverified", reason: err.message, settings: settingsUrl(target), missing: checks };
   }
   if (res.exitCode !== 0) {
-    if (/404|not protected/i.test(`${res.stderr}${res.stdout}`)) return { status: "unprotected", command: protectCommand({ ...target, checks }) };
+    if (/404|not protected/i.test(`${res.stderr}${res.stdout}`)) return rulesetAdvice({ rules: await branchRules(target, run), checks, target });
     return { status: "unverified", reason: (res.stderr || res.stdout || "gh failed").trim(), settings: settingsUrl(target), missing: checks };
   }
   const protection = JSON.parse(res.stdout || "{}");
+  const rules = await branchRules(target, run);
+  const fromRules = rulesetChecks(rules ?? []);
   const statusChecks = protection.required_status_checks;
-  if (!statusChecks) return { status: "no-checks", settings: settingsUrl(target), missing: checks };
-  const existing = new Set(statusChecks.contexts ?? []);
+  const existing = new Set([...(statusChecks?.contexts ?? []), ...fromRules]);
   const missing = checks.filter((c) => !existing.has(c));
+  // Unreadable rules: a ruleset may require what the classic layer lacks, so nothing is "missing" for sure.
+  if (rules === null && missing.length > 0) return { status: "unverified", reason: "the branch rules could not be read", settings: rulesUrl(target), missing };
+  if (!statusChecks && fromRules.length === 0) return { status: "no-checks", settings: settingsUrl(target), missing: checks };
   // KJC-BUG-0401: required checks an admin skips are not required for an agent holding an admin's token.
   const bindAdmins = protection.enforce_admins?.enabled === false ? `gh api -X POST ${protectionPath(target)}/enforce_admins` : null;
   if (missing.length > 0) return { status: "missing", missing, command: [addCommand({ ...target, missing }), bindAdmins].filter(Boolean).join(" && ") };
@@ -105,6 +137,7 @@ export async function adviseBranchProtection({ projectDir, branch, logger, run =
     missing: `${branch} does not require ${advice.missing?.length} kj check(s) (${list}). An admin runs (kj never does):`,
     "no-checks": `${branch} is protected but requires no status checks. An admin enables "Require status checks" and adds ${list} in:`,
     unverified: `could not read the protection of ${branch} (${advice.reason}). An admin checks that ${list} are required in:`,
+    "ruleset-missing": `${branch} is protected by a ruleset that does not require ${advice.missing?.length} kj check(s) (${list}). An admin adds them to the ruleset (no second protection layer) in:`,
     "admins-exempt": `${branch} requires the kj checks, but admins can merge without them, and an agent working with an admin's token would. An admin runs (kj never does):`,
   }[advice.status];
   logger.warn?.(`  ⚠ branch protection: ${why}`);

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

@@ -11,9 +11,9 @@ import { appendFileSync, existsSync, readFileSync, realpathSync, statSync } from
 import { spawnSync } from "node:child_process";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
-import { doc, CODE, TESTS, ROOT, BASE_BRANCHES, CARD, STATE, branchOf, foreignLane, load, save, session, boardGate, pendingMoves, pendingText } from "./sentinel-lib.mjs";
+import { doc, CODE, TESTS, ROOT, BASE_BRANCHES, CARD, STATE, branchOf, foreignLane, load, save, session, boardGate, pendingMoves, pendingText, stagedVerdict } from "./sentinel-lib.mjs";
 // KJC-TSK-0915 (ADR 0014): the shell reader is a real, unit-tested module copied here as is.
-import { isGhIssueCreate, isPublishCommand, isReadOnlyCommand, optionValues, shellSegments, stripInertQuotes, stripTextOptionValues, stripTextOnlyCommandValues } from "./sentinel-shell.mjs";
+import { commitStaging, isGhIssueCreate, isPublishCommand, isReadOnlyCommand, optionValues, shellSegments, stripInertQuotes, stripTextOptionValues, stripTextOnlyCommandValues } from "./sentinel-shell.mjs";
 import { DISCARD_VERBS, discardOf, foreignLost, removedFiles } from "./sentinel-discard.mjs";
 import { sandboxCovers, shellWrites, writesRepo } from "./sentinel-bash-write.mjs";
 const EDIT_TOOLS = ["Write", "Edit", "MultiEdit", "NotebookEdit"];
@@ -635,6 +635,24 @@ 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-0455 (#2933): the verdict of the staged diff, checked HERE as well as in
+      // the pre-commit hook: a repo whose hook does not run the gate, or a review piped into
+      // tail that hid its failure, let a commit through with no verdict at all.
+      const plan = commitStaging(cmd);
+      if (plan.commits) {
+        // 4.x: the hook payload carries no cwd; the session works in the project root.
+        const verdict = stagedVerdict(plan.dir ? resolve(ROOT, plan.dir) : ROOT);
+        if (verdict.gate && plan.stages) {
+          console.error("karajan sentinel: stagea y commitea en comandos separados — el veredicto se comprueba sobre lo que ya esta stageado, y este comando stagea a la vez que commitea (git add/rm/mv, -a o rutas en git commit). Stagea por nombre, pasa kj review --staged y luego git commit." + doc("commit-verdict"));
+          process.exit(2);
+        }
+        // Only an approved verdict passes, or nothing staged (a merge: git itself decides).
+        if (verdict.gate && verdict.state !== "approved" && verdict.state !== "empty") {
+          const why = { rejected: "el review de este diff fue RECHAZADO por " + (verdict.reviewer || "el reviewer") + " — corrige y vuelve a pasar kj review --staged", unknown: "git no pudo leer el diff stageado, asi que el veredicto no se puede comprobar" }[verdict.state] || "no hay veredicto para el diff stageado — pasa kj review --staged (solo, sin tuberias que oculten si falla)";
+          console.error("karajan sentinel: commit sin veredicto aprobado: " + why + "." + doc("commit-verdict"));
+          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 (the .claude locks, .kj/, the local

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

@@ -4,6 +4,7 @@
 import process from "node:process";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { execSync, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 const here = dirname(fileURLToPath(import.meta.url));
@@ -65,6 +66,28 @@ export const bootstrapPhase = () => {
   try { execSync("git rev-parse --verify HEAD", { cwd: ROOT, stdio: ["ignore", "ignore", "ignore"] }); return false; }
   catch { return true; }
 };
+// KJC-BUG-0455 (#2933): the cross-AI verdict of the diff staged in `dir`, read the way
+// `kj review --check` reads it (sha256 of `git diff --cached`, trailing blanks trimmed,
+// in <top>/.karajan/reviews). gate:false when the repo has not committed the gate marker.
+// state: approved | rejected | missing | empty (nothing staged) | unknown (git failed).
+export const stagedVerdict = (dir) => {
+  const git = (args) => spawnSync("git", ["-C", dir, ...args], { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+  // No commit yet (or no repo): no committed marker can exist, as the hook reads it.
+  if (git(["rev-parse", "--verify", "-q", "HEAD"]).status !== 0) return { gate: false };
+  // A git error is not a missing marker: it fails closed.
+  const marker = git(["ls-tree", "--name-only", "HEAD", ".karajan/review-gate"]);
+  if (marker.status !== 0) return { gate: true, state: "unknown" };
+  if (!marker.stdout.trim()) return { gate: false };
+  const top = git(["rev-parse", "--show-toplevel"]).stdout?.trim();
+  const diff = git(["diff", "--cached"]);
+  if (!top || diff.status !== 0) return { gate: true, state: "unknown" };
+  if (!diff.stdout.trim()) return { gate: true, state: "empty" };
+  const hash = createHash("sha256").update(diff.stdout.trimEnd(), "utf8").digest("hex");
+  try {
+    const v = JSON.parse(readFileSync(join(top, ".karajan", "reviews", hash + ".json"), "utf8"));
+    return { gate: true, state: v.verdict === "approved" ? "approved" : "rejected", reviewer: v.reviewer || null };
+  } catch { return { gate: true, state: "missing" }; }
+};
 // KJC-BUG-0198/0262: a card split across PRs is carried while another PR of it is
 // open. kj decides with that checkable fact, the same answer for commit and push
 // (the Stop gate still holds the turn: the board owes the move); when kj does not

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

@@ -300,3 +300,78 @@ export const isReadOnlyCommand = (cmd) => {
 
 /** Short flags of a cluster stop at "e": the rest is -e's value (-fen = -f -e n). */
 export const shortOpts = (a) => (/^-[a-zA-Z]/.test(a) ? a.slice(1).split("e")[0] : "");
+
+// KJC-BUG-0455 (#2933): git commit's options that take a value, and the git verbs that
+// change the index. A commit that stages in the same command commits a diff nobody
+// could have reviewed yet: the verdict is checked against what is staged BEFORE it runs.
+const COMMIT_VALUE_OPTS = new Set(["-m", "-F", "-C", "-c", "-t", "--message", "--file", "--reuse-message", "--reedit-message", "--template", "--author", "--date", "--cleanup", "--fixup", "--squash", "--trailer", "--pathspec-from-file"]);
+const COMMIT_VALUE_SHORT = new Set(["m", "F", "C", "c", "t"]);
+const INDEX_VERBS = new Set(["add", "rm", "mv", "stage", "restore", "reset", "apply", "update-index"]);
+
+/** Where `git` is in a segment and its verb, skipping git's global options; null when not git. */
+const gitVerbOf = (words) => {
+  if (words[0]?.slice(words[0].lastIndexOf("/") + 1) !== "git") return null;
+  let i = 1;
+  let dir = null;
+  while (i < words.length) {
+    const w = words[i];
+    if (GIT_GLOBAL_WITH_VALUE.has(w)) {
+      if (w === "-C") {
+        dir = words[i + 1] ?? null;
+      }
+      i += 2; // the option and its value
+    } else if (GIT_GLOBAL_FLAG.test(w)) {
+      i += 1;
+    } else {
+      break;
+    }
+  }
+  return { verb: words[i], at: i, dir };
+};
+
+/** How many words a git commit argument takes, and whether it makes the commit stage on its own. */
+const commitArg = (a) => {
+  if (a === "--all") return { stages: true, words: 1 };
+  if (a.startsWith("--")) {
+    // --message=x carries its value; --message x takes the next word.
+    return { stages: false, words: COMMIT_VALUE_OPTS.has(a) ? 2 : 1 };
+  }
+  if (/^-[a-zA-Z]/.test(a)) {
+    const cluster = a.slice(1);
+    const valueAt = [...cluster].findIndex((c) => COMMIT_VALUE_SHORT.has(c));
+    const flags = valueAt < 0 ? cluster : cluster.slice(0, valueAt);
+    if (flags.includes("a")) return { stages: true, words: 1 };
+    // -m x takes the next word; -mx carries its value.
+    return { stages: false, words: valueAt === cluster.length - 1 ? 2 : 1 };
+  }
+  return { stages: true, words: 1 }; // a pathspec
+};
+
+/** -a/--all, or a path (with or without --), makes git commit stage on its own. */
+const commitStagesItself = (args) => {
+  let i = 0;
+  while (i < args.length) {
+    if (args[i] === "--") {
+      return i + 1 < args.length;
+    }
+    const { stages, words } = commitArg(args[i]);
+    if (stages) {
+      return true;
+    }
+    i += words;
+  }
+  return false;
+};
+
+/**
+ * Does the command run git commit, and does it stage in the same command?
+ * @param {string} cmd
+ * @returns {{commits: boolean, stages: boolean, dir: string|null}}
+ */
+export const commitStaging = (cmd) => {
+  const gits = shellSegments(cmd).map((words) => ({ words, g: gitVerbOf(words) })).filter((s) => s.g);
+  const commits = gits.filter((s) => s.g.verb === "commit");
+  if (commits.length === 0) return { commits: false, stages: false, dir: null };
+  const stages = gits.some((s) => INDEX_VERBS.has(s.g.verb)) || commits.some((s) => commitStagesItself(s.words.slice(s.g.at + 1)));
+  return { commits: true, stages, dir: commits[0].g.dir };
+};

package/src/harden/workflow-engine.js

@@ -57,9 +57,20 @@ export function isPublishableNpm(projectDir) {
   }
 }
 
-/** Lockfile-detected package manager (KJC-BUG-0131): npm ci kills pnpm/yarn CI. */
+const KNOWN_PMS = new Set(["npm", "pnpm", "yarn", "bun"]);
+
+/**
+ * The project's package manager (KJC-BUG-0131: npm ci kills pnpm/yarn CI).
+ * KJC-BUG-0450 (#2789): the same answer for hooks and workflows; the
+ * packageManager field of package.json first, then the lockfile.
+ */
 export function detectPackageManager(projectDir) {
+  try {
+    const declared = String(JSON.parse(readFileSync(join(projectDir, "package.json"), "utf8")).packageManager || "").split("@")[0];
+    if (KNOWN_PMS.has(declared)) return declared;
+  } catch { /* no or unreadable package.json: the lockfile decides */ }
   if (existsSync(join(projectDir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(projectDir, "bun.lock")) || existsSync(join(projectDir, "bun.lockb"))) return "bun";
   if (existsSync(join(projectDir, "yarn.lock"))) return "yarn";
   return "npm";
 }

package/src/mcp/handlers/hu-handlers.js

@@ -4,44 +4,67 @@
  */
 
 import { handleSuggestion } from "../suggest-handler.js";
+import { runKjCommand } from "../run-kj.js";
 import {
   resolveProjectDir,
   failPayload,
 } from "../shared-helpers.js";
 
+export const HU_STATUSES = ["pending", "running", "done", "failed", "skipped"];
+
+/**
+ * KJC-BUG-0452 (#2815): kj_hu used the old kj run store, so an agent saw an empty
+ * board while `kj hu list` showed every card. It runs the CLI's own `kj hu` in a
+ * subprocess: the same board (local, shared or a lane's), and stdout, which is
+ * this server's protocol channel, stays clean.
+ */
+async function kjHu(projectDir, args) {
+  const res = await runKjCommand({ command: "hu", commandArgs: [...args, "--json"], options: { projectDir } });
+  if (!res.ok) return { error: `kj hu ${args[0]} failed: ${res.errorSummary || res.stderr || "no output"}` };
+  const line = String(res.stdout || "").trim().split("\n").reverse().find((l) => /^[[{]/.test(l.trim()));
+  try { return { data: JSON.parse(line) }; } catch { return { error: `kj hu ${args[0]} answered no JSON: ${String(res.stdout || "").slice(0, 200)}` }; }
+}
+
+const notOnBoard = (id) => `HU ${id} is not on the board — kj_hu list shows its cards`;
+
+async function createHu(projectDir, a) {
+  if (!a.title) return failPayload("Missing required field: title (required for create)");
+  const args = ["add", a.title, ...(a.acceptanceCriteria ? ["--ac", a.acceptanceCriteria] : []), ...(a.ref ? ["--ref", a.ref] : [])];
+  const added = await kjHu(projectDir, args);
+  if (added.error) return failPayload(added.error);
+  if (!a.status || a.status === "pending") return { ok: true, hu: added.data };
+  return moveHu(projectDir, added.data.short_id || added.data.id, a.status);
+}
+
+async function moveHu(projectDir, huId, status) {
+  if (!HU_STATUSES.includes(status)) return failPayload(`Unknown status "${status}": use ${HU_STATUSES.join(", ")}`);
+  const moved = await kjHu(projectDir, ["move", huId, status]);
+  return moved.error ? failPayload(moved.error) : { ok: true, hu: moved.data };
+}
+
 export async function handleHu(a, server) {
   const action = a.action;
   if (!action) return failPayload("Missing required field: action");
-
   const projectDir = await resolveProjectDir(server, a.projectDir);
-  const { createManualHu, listHus, getHu, updateHuStatus } = await import("../../hu/store.js");
 
   switch (action) {
-    case "create": {
-      if (!a.title) return failPayload("Missing required field: title (required for create)");
-      const hu = await createManualHu(projectDir, {
-        title: a.title,
-        description: a.description,
-        status: a.status,
-        acceptanceCriteria: a.acceptanceCriteria
-      });
-      return { ok: true, hu };
-    }
+    case "create":
+      return createHu(projectDir, a);
     case "list": {
-      const hus = await listHus(projectDir);
-      return { ok: true, hus };
+      const listed = await kjHu(projectDir, ["list"]);
+      return listed.error ? failPayload(listed.error) : { ok: true, hus: listed.data };
     }
     case "get": {
       if (!a.huId) return failPayload("Missing required field: huId (required for get)");
-      const hu = await getHu(projectDir, a.huId);
-      return { ok: true, hu };
+      const listed = await kjHu(projectDir, ["list"]);
+      if (listed.error) return failPayload(listed.error);
+      const hu = listed.data.find((h) => h.id === a.huId || h.short_id === a.huId);
+      return hu ? { ok: true, hu } : failPayload(notOnBoard(a.huId));
     }
-    case "update": {
+    case "update":
       if (!a.huId) return failPayload("Missing required field: huId (required for update)");
       if (!a.status) return failPayload("Missing required field: status (required for update)");
-      const hu = await updateHuStatus(projectDir, a.huId, a.status);
-      return { ok: true, hu };
-    }
+      return moveHu(projectDir, a.huId, a.status);
     default:
       return failPayload(`Unknown hu action: ${action}`);
   }

package/src/mcp/tools.js

@@ -335,17 +335,17 @@ export const tools = [
   },
   {
     name: "kj_hu",
-    description: "Manage user stories (HUs) in the local board",
+    description: "Manage user stories (HUs) in the HU Board, the same board `kj hu` uses (local or shared)",
     inputSchema: {
       type: "object",
       required: ["action"],
       properties: {
         action: { type: "string", enum: ["create", "update", "list", "get"], description: "Action to perform" },
         title: { type: "string", description: "HU title (required for create)" },
-        description: { type: "string", description: "HU description" },
-        acceptanceCriteria: { type: "string", description: "Acceptance criteria" },
+        acceptanceCriteria: { type: "string", description: "Acceptance criteria, one per line" },
+        ref: { type: "string", description: "Id of this card's replica in the external tracker (Planning Game, Jira, Linear...)" },
         huId: { type: "string", description: "HU ID (required for update/get)" },
-        status: { type: "string", description: "HU status (for create/update)", enum: ["pending", "coding", "reviewing", "done", "failed", "blocked"] },
+        status: { type: "string", description: "HU status (for create/update)", enum: ["pending", "running", "done", "failed", "skipped"] },
         projectDir: { type: "string", description: "Project directory (defaults to cwd)" }
       }
     }

package/src/review/dual-review.js

@@ -47,10 +47,11 @@ function verdictOf(sides, findings, coverage) {
   if (blockers.length) return { status: "rejected", approved: false, reason: `confirmed blocker(s): ${blockers.map(where).join(", ")}`, summary };
   const rejecting = sides.filter((s) => !s.verdict?.approved).map((s) => s.reviewer);
   if (rejecting.length === 0 && !coverage.truncated) return { status: "approved", approved: true, summary };
-  const reason = rejecting.length
-    ? `${rejecting.join(" and ")} rejected, but no blocking finding was confirmed by the other family`
-    : "not every file was reviewed";
-  return { status: "partial", approved: false, reason, summary };
+  const dispute = rejecting.length ? `${rejecting.join(" and ")} rejected, but no blocking finding was confirmed by the other family` : null;
+  // KJC-BUG-0453 (#2921): "partial" only when files were left out (they are in coverage.unreviewed);
+  // everything reviewed and the reviewers disagreeing is "disputed".
+  if (coverage.truncated) return { status: "partial", approved: false, reason: ["not every file was reviewed", dispute].filter(Boolean).join("; "), summary };
+  return { status: "disputed", approved: false, reason: dispute, summary };
 }
 
 /** The two sides (reviewer, model, verdict, coverage, findings, outcomes, verification) as one result. */

package/src/review/gate-hook.js

@@ -0,0 +1,39 @@
+/**
+ * KJC-BUG-0447 (issue #2655): is the review gate actually ENFORCED? The marker
+ * only declares it; what refuses a commit is a pre-commit hook that runs
+ * `kj review --check`. Checked where git will look (core.hooksPath, local or
+ * global, or .git/hooks), never assumed from a hooks path being configured.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+// The contract: a line that RUNS the check and stops the commit when it fails, as the
+// pre-commit kj harden writes (`kj review --check || { ...; exit 1; }`) or `|| exit 1`.
+// A comment, the phrase inside an echo, `|| true`, `|| exit 0` or a group that does
+// not END in `exit N` (N > 0) enforce nothing. Right after `||`, a bare `exit` keeps
+// the failing check's status; inside a group it would take the previous command's.
+const GATE_LINE = /^\s*kj review --check\s*\|\|\s*(?:exit(?:\s+[1-9]\d*)?\s*(?:;|#|$)|\{(?:[^}]*;)?\s*exit\s+[1-9]\d*\s*;?\s*\})/;
+const runsGate = (body) => body.split("\n").some((line) => GATE_LINE.test(line));
+
+/** @returns {{enforced: boolean, hooksDir: string|null, reason: string|null}} */
+export function gateHookStatus(projectDir) {
+  let hooksDir;
+  try {
+    // --git-path hooks honours core.hooksPath (repo or global) and worktrees.
+    const rel = execFileSync("git", ["rev-parse", "--git-path", "hooks"], { cwd: projectDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    hooksDir = path.resolve(projectDir, rel);
+  } catch {
+    return { enforced: false, hooksDir: null, reason: "not a git repository: no hook can enforce the gate" };
+  }
+  const hook = path.join(hooksDir, "pre-commit");
+  let body;
+  try { body = fs.readFileSync(hook, "utf8"); } catch {
+    return { enforced: false, hooksDir, reason: `no pre-commit hook in ${hooksDir}, where git looks for hooks` };
+  }
+  if (!runsGate(body)) return { enforced: false, hooksDir, reason: `${hook} does not run kj review --check` };
+  try { fs.accessSync(hook, fs.constants.X_OK); } catch {
+    return { enforced: false, hooksDir, reason: `${hook} is not executable, so git skips it` };
+  }
+  return { enforced: true, hooksDir, reason: null };
+}

package/src/review/one-shot-review.js

@@ -14,12 +14,13 @@ import { buildReviewerPrompt } from "../prompts/reviewer.js";
 import { resolveReviewProfile } from "./profiles.js";
 import { parseReviewVerdict } from "./parser.js";
 import { detectAvailableAgents, detectHostAgent } from "../utils/agent-detect.js";
+import { accountLabel } from "../utils/agent-home.js";
 import { saveVerdict, diffHash } from "./verdict-store.js";
 import { summarizeGeneratedFiles } from "./prompt-diff.js";
 import { reportUnparseableVerdict } from "./unparseable-verdict.js";
 import { detectWorkspace } from "./workspace.js";
 import { branchOf } from "./correction-rounds.js";
-import { isQuotaExhausted, candidateStatus, pickQuotaFallback, formatCandidateMenu } from "./reviewer-fallback.js";
+import { isQuotaExhausted, candidateStatus, pickQuotaFallback, formatCandidateMenu, reviewerFailureMessage } from "./reviewer-fallback.js";
 
 // Cross-AI preference when the configured reviewer IS the host.
 const CROSS_ORDER = ["codex", "claude", "gemini", "opencode", "aider"];
@@ -60,6 +61,7 @@ export async function runOneShotReview({
   // review can never unlock a commit of one's own.
   reviewerOverride = null,
   persist = true,
+  env = process.env,
 }) {
   if (!diff || !diff.trim()) {
     throw new Error("nothing to review — the diff is empty (stage your changes or pass --range)");
@@ -79,7 +81,9 @@ export async function runOneShotReview({
       // KJC-BUG-0347: generated files summarized; the verdict still binds to the full diff.
       diff: summarizeGeneratedFiles(diff), reviewRules: rules, mode: "standard", provider: who, projectDir,
     });
-    logger?.info?.(`kj review: host=${hostAgent || "none"} → reviewer=${who} (cross-AI)`);
+    // KJC-TSK-1344: with two subscriptions per CLI, say which account reviews.
+    const account = accountLabel(who, { env });
+    logger?.info?.(`kj review: host=${hostAgent || "none"} → reviewer=${who} (cross-AI)${account ? ` [${account}]` : ""}`);
     return createAgentFn(who, cfg, logger).reviewTask({ prompt, role: "reviewer" });
   };
 
@@ -115,7 +119,7 @@ export async function runOneShotReview({
   }
 
   if (!result?.ok) {
-    throw new Error(`reviewer ${activeReviewer} failed: ${result?.error || "no output"}`);
+    throw new Error(reviewerFailureMessage(activeReviewer, result?.error));
   }
 
   // KJC-BUG-0146, second half: parseMaybeJsonString only PARSES — it returns whatever JSON came

package/src/review/publish-pr.js

@@ -9,6 +9,8 @@ import { diffHash, loadVerdict } from "./verdict-store.js";
 import { isCleanMerge } from "./clean-merge.js";
 
 export const MARKER = (head) => `<!-- kj-review head=${head} -->`;
+/** Who may publish a kj review that counts: verify-pr ignores anyone else. */
+export const TRUSTED = new Set(["OWNER", "MEMBER", "COLLABORATOR"]);
 
 // gh runs in the project's own directory, so it reads and writes the same repo the verdicts belong to.
 async function json(run, cmd, args, cwd) {
@@ -39,7 +41,8 @@ export async function publishPrReview({ projectDir, pr, run = runCommand }) {
   }
   if (uncovered.length > 0) throw new Error(`PR #${pr}: ${uncovered.length} commit(s) without an approved verdict of their exact diff, nothing published: ${uncovered.join(", ")}`);
   const reviews = await json(run, "gh", ["api", `repos/{owner}/{repo}/pulls/${pr}/reviews`], projectDir);
-  if ((reviews ?? []).some((r) => String(r.body ?? "").includes(MARKER(info.headRefOid)))) {
+  // KJC-BUG-0456: one a non-member posted (gh switched to another account) does not count in CI.
+  if ((reviews ?? []).some((r) => TRUSTED.has(r.author_association) && String(r.body ?? "").includes(MARKER(info.headRefOid)))) {
     return { published: false, reason: `a kj review for head ${info.headRefOid.slice(0, 7)} is already published` };
   }
   const body = [

package/src/review/reviewer-fallback.js

@@ -14,6 +14,7 @@ import { existsSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { checkBinary } from "../utils/agent-detect.js";
+import { agentAuthFiles } from "../utils/agent-home.js";
 
 export const REVIEWER_CANDIDATES = [
   {
@@ -70,9 +71,22 @@ export const REVIEWER_CANDIDATES = [
 
 const QUOTA_RE = /usage limit|quota|rate.?limit|credits? (?:exhausted|left: ?0)|hit your .{0,20}limit/i;
 
+// KJC-BUG-0451 (#2799): codex puts a `rate_limits` telemetry object in every JSON event;
+// it says how much quota is LEFT, so it is no evidence that the quota ran out.
+const RATE_LIMITS_TELEMETRY = /"rate_limits"\s*:\s*(?:\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}|null)/g;
+
 /** True when the agent error smells like exhausted quota, not a real failure. */
 export function isQuotaExhausted(text) {
-  return typeof text === "string" && QUOTA_RE.test(text);
+  return typeof text === "string" && QUOTA_RE.test(text.replace(RATE_LIMITS_TELEMETRY, ""));
+}
+
+// The CLI could not reach its service at all: a sandboxed shell or the network, not the reviewer.
+const UNREACHABLE_RE = /routing discovery failed|ENOTFOUND|ECONNREFUSED|ECONNRESET|EAI_AGAIN|getaddrinfo|stream disconnected|network (?:error|is unreachable)/i;
+
+/** The real error, plus a hint when the reviewer CLI never reached its service. */
+export function reviewerFailureMessage(reviewer, error) {
+  const base = `reviewer ${reviewer} failed: ${error || "no output"}`;
+  return UNREACHABLE_RE.test(String(error || "")) ? `${base} — ${reviewer} could not reach its service (a sandboxed shell or the network?); run kj review from an unsandboxed shell` : base;
 }
 
 /** installed × authenticated for every candidate, from cheap local checks. */
@@ -86,8 +100,10 @@ export async function candidateStatus({ home = os.homedir(), checkBin = checkBin
       // Session-file heuristics, or env keys for CLIs (aider) that carry
       // no session file. Key present ≠ credit left — it is menu signal;
       // the failover only sticks if the candidate actually answers.
+      // KJC-TSK-1344: codex and claude keep the account where CODEX_HOME / CLAUDE_CONFIG_DIR say.
+      const files = agentAuthFiles(c.name, { home, env }) ?? c.authPaths.map((p) => path.join(home, p));
       const authenticated =
-        c.authPaths.some((p) => existsSync(path.join(home, p))) ||
+        files.some((f) => existsSync(f)) ||
         (c.authEnv || []).some((name) => Boolean(env[name]));
       return { ...c, installed, authenticated };
     }),

package/src/review/verify-pr.js

@@ -7,12 +7,11 @@
  */
 import { runCommand } from "../utils/process.js";
 import { diffHash } from "./verdict-store.js";
-import { MARKER } from "./publish-pr.js";
+import { MARKER, TRUSTED } from "./publish-pr.js";
 import { isCleanMerge } from "./clean-merge.js";
 import { verifiedSupervisorFiles } from "../policy/supervisor-verify.js";
 import { PROVENANCE_FILE } from "../harden/supervisor-commit.js";
 
-const TRUSTED = new Set(["OWNER", "MEMBER", "COLLABORATOR"]);
 // The marker of a kj review for any head: what MARKER writes up to the head itself.
 const MARKER_PREFIX = MARKER("\0").split("\0")[0];
 // One line per commit, as publish-pr writes it: - `<sha7>` headline: approved by X (diff <hash12>)...

package/src/utils/agent-home.js

@@ -0,0 +1,33 @@
+/**
+ * KJC-TSK-1344 — where each CLI keeps its account. One person may hold two
+ * subscriptions per CLI (personal and work): claude switches account with
+ * CLAUDE_CONFIG_DIR and codex with CODEX_HOME. kj passes both to the agents
+ * (role-env allows CLAUDE* and CODEX*), so it must also LOOK there for the
+ * session and the config, never at a fixed ~/.codex or ~/.claude.json.
+ */
+import os from "node:os";
+import path from "node:path";
+
+const ACCOUNT_VAR = { codex: "CODEX_HOME", claude: "CLAUDE_CONFIG_DIR" };
+
+export const codexHome = ({ home = os.homedir(), env = process.env } = {}) =>
+  env.CODEX_HOME || path.join(home, ".codex");
+
+export const claudeConfigFile = ({ home = os.homedir(), env = process.env } = {}) =>
+  path.join(env.CLAUDE_CONFIG_DIR || home, ".claude.json");
+
+/** Absolute files that mark a logged-in session, or null for agents without an account variable. */
+export function agentAuthFiles(agent, { home = os.homedir(), env = process.env } = {}) {
+  if (agent === "codex") return [path.join(codexHome({ home, env }), "auth.json")];
+  if (agent === "claude") {
+    const dir = env.CLAUDE_CONFIG_DIR;
+    return dir ? [path.join(dir, ".claude.json"), path.join(dir, ".credentials.json")] : [path.join(home, ".claude.json"), path.join(home, ".claude")];
+  }
+  return null;
+}
+
+/** "CODEX_HOME=/path" when the variable moves the account, null on the default. */
+export function accountLabel(agent, { env = process.env } = {}) {
+  const name = ACCOUNT_VAR[agent];
+  return name && env[name] ? `${name}=${env[name]}` : null;
+}