karajan-code 4.14.0 → 4.16.0

package/package.json

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

package/packages/ai-trash/src/install.js

@@ -8,7 +8,14 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
 export const DEFAULT_SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
-export const HOOK_COMMAND = "kj-trash hook";
+// KJC-BUG-0095: the bare command fails SILENTLY when the bin drops off PATH
+// (nvm switch, global reinstall) — the anti-delete net goes down without
+// notice. The installed line fails CLOSED: a missing bin blocks the tool
+// call (exit 2) naming the net and the remedy, never a quiet pass-through.
+export const LEGACY_HOOK_COMMAND = "kj-trash hook";
+export const HOOK_COMMAND =
+  "if command -v kj-trash >/dev/null 2>&1; then exec kj-trash hook; fi; " +
+  "echo 'kj-trash: bin not on PATH — the anti-delete net is DOWN. Fix: npm i -g karajan-code (or remove this hook from ~/.claude/settings.json).' >&2; exit 2";
 const MATCHER = "Bash";
 
 async function readSettings(path) {
@@ -34,6 +41,20 @@ export function patchSettings(settings, command = HOOK_COMMAND, matcher = MATCHE
     entry = { matcher, hooks: [{ type: "command", command }] };
     preToolUse.push(entry);
     mutated = true;
+  } else if (hasHookCommand(entry, LEGACY_HOOK_COMMAND) && command !== LEGACY_HOOK_COMMAND) {
+    // KJC-BUG-0095 migration: upgrade the silent legacy line in place —
+    // deduped (reviewer catch): an entry already carrying the new line
+    // must end up with a single copy, not legacy-turned-duplicate.
+    let seen = false;
+    entry.hooks = entry.hooks
+      .map((h) => (h.type === "command" && h.command === LEGACY_HOOK_COMMAND ? { ...h, command } : h))
+      .filter((h) => {
+        if (!(h.type === "command" && h.command === command)) return true;
+        if (seen) return false;
+        seen = true;
+        return true;
+      });
+    mutated = true;
   } else if (!hasHookCommand(entry, command)) {
     entry.hooks = [...(entry.hooks ?? []), { type: "command", command }];
     mutated = true;

package/scripts/verify-pack.mjs

@@ -208,7 +208,17 @@ try {
   // better-sqlite3's native build by default, so DB-backed commands need
   // `pnpm approve-builds`; that's surfaced as a doctor warning, KJC-BUG-0092 —
   // not a gate failure, since it's inherent to pnpm.) Auto-skips without pnpm.
-  const hasPnpm = spawnSync("pnpm", ["--version"], { encoding: "utf8", env: childEnv }).status === 0;
+  // KJC-BUG-0135: `npm run` leaks npm_config_* into the child env, and pnpm
+  // maps those variables onto its own config — which can re-anchor it to THIS
+  // repo (7-aug incident: the repo's node_modules converted to pnpm layout,
+  // native bindings wiped, and simple-git-hooks' hook overwrote
+  // .karajan/hooks). The smoke runs with a scrubbed env and a pinned --dir,
+  // and the tripwire below turns any host contamination into a loud gate
+  // failure instead of a silent green.
+  const pnpmEnv = Object.fromEntries(Object.entries(childEnv).filter(([k]) => !/^npm_config_/i.test(k)));
+  const HOST_MARKERS = ["pnpm-lock.yaml", "pnpm-workspace.yaml", path.join("node_modules", ".pnpm")];
+  const hostMarkersBefore = new Set(HOST_MARKERS.filter((m) => fs.existsSync(path.join(repoRoot, m))));
+  const hasPnpm = spawnSync("pnpm", ["--version"], { encoding: "utf8", env: pnpmEnv }).status === 0;
   if (!hasPnpm) {
     console.log("verify-pack: pnpm not installed — skipping pnpm smoke (npm path covered above) ⚠");
   } else {
@@ -224,11 +234,11 @@ try {
     // versions (supply-chain protection), so right after publishing
     // karajan-core it silently resolves an OLD one and this smoke fails on
     // missing subpaths. The gate verifies packaging, not release-age policy.
-    spawnSync("pnpm", ["add", tgzPath, "--store-dir", path.join(pnpmTmp, ".store"), "--config.minimum-release-age=0"], {
-      encoding: "utf8",
-      env: childEnv,
-      cwd: pnpmTmp,
-    });
+    spawnSync(
+      "pnpm",
+      ["add", tgzPath, "--dir", pnpmTmp, "--ignore-workspace", "--store-dir", path.join(pnpmTmp, ".store"), "--config.minimum-release-age=0"],
+      { encoding: "utf8", env: pnpmEnv, cwd: pnpmTmp },
+    );
     const pnpmBin = path.join(pnpmTmp, "node_modules", ".bin", "kj");
     if (!fs.existsSync(pnpmBin)) fail(`kj binary missing after pnpm install: ${pnpmBin}`);
     let pnpmVersion;
@@ -242,6 +252,18 @@ try {
     }
     console.log(`verify-pack: pnpm install + kj --version → ${pnpmVersion} ✓ (DB build needs \`pnpm approve-builds\`)`);
   }
+  // Tripwire (KJC-BUG-0135): the smoke must NEVER touch the host repo. If a
+  // pnpm artifact appeared at the repo root during this run, the gate fails
+  // naming it — never a green over a contaminated tree.
+  const contaminated = HOST_MARKERS.filter(
+    (m) => !hostMarkersBefore.has(m) && fs.existsSync(path.join(repoRoot, m)),
+  );
+  if (contaminated.length > 0) {
+    fail(
+      `pnpm smoke contaminated the host repo: ${contaminated.join(", ")} appeared at the repo root`,
+      "remove the listed files and run `npm ci` to restore the npm layout; then verify .karajan/hooks with `git status`",
+    );
+  }
 
   console.log(`\n✓ verify-pack: karajan-code@${expectedVersion} installs clean and runs.`);
 } finally {

package/src/agents/agy-agent.js

@@ -37,6 +37,7 @@ export class AgyAgent extends BaseAgent {
       onOutput: task.onOutput,
       silenceTimeoutMs: task.silenceTimeoutMs,
       timeout: task.timeoutMs,
+      cwd: task.cwd,
     });
     const parsed = extractAgyOutput(res.stdout);
     const ok = res.exitCode === 0 && parsed?.status === "SUCCESS";

package/src/agents/base-agent.js

@@ -60,7 +60,7 @@ export class BaseAgent {
       // a PATH is a partial overlay and merges over the inherited env first,
       // so an overlay caller can never cost the child PATH/HOME.
       const complete = options.env && ("PATH" in options.env || "Path" in options.env);
-      const base = complete ? options.env : { ...process.env, ...(options.env || {}) };
+      const base = complete ? options.env : { ...process.env, ...options.env };
       options = {
         ...options,
         env: buildAgentEnv(base, {

package/src/agents/claude-agent.js

@@ -374,7 +374,8 @@ export class ClaudeAgent extends BaseAgent {
         onOutput: streamFilter,
         silenceTimeoutMs: task.silenceTimeoutMs,
         timeout: task.timeoutMs,
-        env: task.env
+        env: task.env,
+        cwd: task.cwd
       }));
       const raw = pickOutput(res);
       const output = extractTextFromStreamJson(raw);
@@ -384,7 +385,7 @@ export class ClaudeAgent extends BaseAgent {
 
     // Without streaming, use json output to get structured response via stderr
     args.push("--output-format", "json");
-    const res = await this.runCommand(resolveBin("claude"), args, cleanExecaOpts({ env: task.env }));
+    const res = await this.runCommand(resolveBin("claude"), args, cleanExecaOpts({ env: task.env, cwd: task.cwd }));
     const raw = pickOutput(res);
     const output = extractTextFromStreamJson(raw);
     const usage = extractUsageFromStreamJson(raw);

package/src/agents/codex-agent.js

@@ -85,7 +85,9 @@ export class CodexAgent extends BaseAgent {
       onOutput: task.onOutput,
       silenceTimeoutMs: task.silenceTimeoutMs,
       timeout: task.timeoutMs,
-      input: task.prompt
+      input: task.prompt,
+      // TOR-A (KJC-TSK-0723): tournament lanes run the coder INSIDE the lane.
+      cwd: task.cwd
     });
     const usage = extractCodexTokens(res.stdout);
     return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode, ...usage };

package/src/agents/kimi-agent.js

@@ -38,6 +38,7 @@ export class KimiAgent extends BaseAgent {
       onOutput: task.onOutput,
       silenceTimeoutMs: task.silenceTimeoutMs,
       timeout: task.timeoutMs,
+      cwd: task.cwd,
     });
     return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
   }

package/src/checks/release-check.js

@@ -28,9 +28,7 @@ async function genericChecks(projectDir) {
   checks.push({ name: "manifest", ok: Boolean(version), detail: version ? `version ${version}` : "package.json has no version" });
 
   const clPath = join(projectDir, "CHANGELOG.md");
-  if (!existsSync(clPath)) {
-    checks.push({ name: "changelog-current", ok: false, detail: "no CHANGELOG.md — the release story must exist before the release" });
-  } else {
+  if (existsSync(clPath)) {
     const cl = readFileSync(clPath, "utf8");
     const topVersioned = (cl.match(/^## \[(\d+\.\d+\.\d+)\]/m) || [])[1] || null;
     // Content still sitting under [Unreleased] means unpromoted entries —
@@ -39,25 +37,20 @@ async function genericChecks(projectDir) {
     const unreleasedBody = afterUnreleased.split(/^## \[/m)[0] ?? "";
     const pending = /\S/.test(unreleasedBody);
     const ok = topVersioned === version && !pending;
-    checks.push({
-      name: "changelog-current",
-      ok,
-      detail: ok
-        ? `top section is [${version}], Unreleased empty`
-        : pending
-          ? `[Unreleased] still carries content — promote it into [${version}] before releasing`
-          : `top CHANGELOG section is [${topVersioned ?? "none"}] but the manifest says ${version} — promote Unreleased before releasing`,
-    });
+    let detail = `top section is [${version}], Unreleased empty`;
+    if (pending) detail = `[Unreleased] still carries content — promote it into [${version}] before releasing`;
+    else if (!ok) detail = `top CHANGELOG section is [${topVersioned ?? "none"}] but the manifest says ${version} — promote Unreleased before releasing`;
+    checks.push({ name: "changelog-current", ok, detail });
+  } else {
+    checks.push({ name: "changelog-current", ok: false, detail: "no CHANGELOG.md — the release story must exist before the release" });
   }
 
   const tagsOut = await runCommand("git", ["-C", projectDir, "tag", "--list", "v[0-9]*"]);
   const tags = (tagsOut.stdout || "").split("\n").map((t) => t.trim().replace(/^v/, "")).filter((t) => /^\d+\.\d+\.\d+$/.test(t));
   const ahead = version ? tags.filter((t) => semverCmp(t, version) > 0) : [];
-  checks.push({
-    name: "tags",
-    ok: ahead.length === 0,
-    detail: ahead.length ? `tag(s) ahead of the manifest exist: v${ahead.join(", v")}` : (tags.includes(version) ? `v${version} already tagged` : `tag v${version} pending (created after publish)`),
-  });
+  let tagDetail = tags.includes(version) ? `v${version} already tagged` : `tag v${version} pending (created after publish)`;
+  if (ahead.length > 0) tagDetail = `tag(s) ahead of the manifest exist: v${ahead.join(", v")}`;
+  checks.push({ name: "tags", ok: ahead.length === 0, detail: tagDetail });
   return { checks, version, pkg };
 }
 

package/src/cli/advanced-commands.js

@@ -27,7 +27,7 @@ export const META_COMMANDS = ["advanced", "help"];
  * so a newly-registered command can never silently vanish from `kj advanced`.
  */
 export const ADVANCED_GROUPS = [
-  { title: "Pipeline (piezas sueltas)", commands: ["autorun", "code", "review", "solomon", "agent", "scan"] },
+  { title: "Pipeline (piezas sueltas)", commands: ["autorun", "code", "review", "solomon", "agent", "scan", "tournament"] },
   { title: "Análisis pre-run", commands: ["discover", "triage", "researcher", "architect", "onboard", "brief"] },
   { title: "Búsqueda / RAG", commands: ["rag", "qmd", "watch"] },
   { title: "Calidad / auditoría", commands: ["audit", "check", "mutate", "webperf", "sonar", "privacy", "release"] },

package/src/cli/register-pipeline.js

@@ -3,6 +3,8 @@ import { ollamaStartCommand, ollamaStopCommand, ollamaStatusCommand, ollamaPullC
 import { configCommand } from "../commands/config.js";
 import { codeCommand } from "../commands/code.js";
 import { reviewCommand } from "../commands/review.js";
+import { tournamentCommand } from "../commands/tournament.js";
+import { resolveTaskInput } from "../utils/task-file.js";
 import { reviewGateCommand, solomonCommand } from "../commands/review-gate.js";
 import { scanCommand } from "../commands/scan.js";
 import { installToolsCommand } from "../commands/install-tools.js";
@@ -144,7 +146,6 @@ export function registerPipeline(program, { pkgVersion }) {
             effectiveTask = plan.task;
           }
         }
-        const { resolveTaskInput } = await import("../utils/task-file.js");
         const resolvedTask = await resolveTaskInput({ task: effectiveTask, taskFile: flags.taskFile, projectDir: config.projectDir, logger });
         const res = await runCommandHandler({ task: resolvedTask, config, logger, flags });
         // KJC-TSK-0674 (issue #1289): an aborted run (spec-review cancel,
@@ -163,7 +164,6 @@ export function registerPipeline(program, { pkgVersion }) {
     .option("--skip-spec-review", "Bypass the spec-reviewer pre-pipeline audit")
     .action(async (task, flags) => {
       const code = await withConfig(pkgVersion, "autorun", flags, async ({ config, logger }) => {
-        const { resolveTaskInput } = await import("../utils/task-file.js");
         const { autorunCommand } = await import("../commands/autorun.js");
         const resolvedTask = await resolveTaskInput({ task, taskFile: flags.taskFile, projectDir: config.projectDir, logger });
         const res = await autorunCommand({ task: resolvedTask, config, logger, flags });
@@ -181,7 +181,6 @@ export function registerPipeline(program, { pkgVersion }) {
     .option("--coder-model <name>")
     .action(async (task, flags) => {
       await withConfig(pkgVersion, "code", flags, async ({ config, logger }) => {
-        const { resolveTaskInput } = await import("../utils/task-file.js");
         const resolvedTask = await resolveTaskInput({ task, taskFile: flags.taskFile, projectDir: config.projectDir, logger });
         await codeCommand({ task: resolvedTask, config, logger });
       });
@@ -199,6 +198,30 @@ export function registerPipeline(program, { pkgVersion }) {
       });
     });
 
+  // KJC-TSK-0723 (TOR-A) — the governed tournament: same task, N coders,
+  // isolated lanes; the method picks the winner (TOR-B/C), not vibes.
+  program
+    .command("tournament")
+    .description("Fan the SAME task out to N coders in isolated worktree lanes and collect per-lane evidence (diff, suite, log)")
+    .argument("[task]", "Task description (REQUIRED — provide as argument or via --task-file)")
+    .option("--task-file <path>", "Read the task from a file (e.g. .md)")
+    .option("--coders <csv>", "Comma-separated coder agents (minimum 2), e.g. claude,codex,agy")
+    .option("--score <id>", "Score an EXISTING tournament from its artifacts (deterministic, zero LLM)")
+    .option("--judge <id>", "Cross-AI judge ranks the finalists (scoreboard in sight; solomon on tie/dispute)")
+    .option("--crown <id>", "Commit the judged winner in its lane THROUGH the real review gate")
+    .option("--card <ref>", "With --crown: card reference for the commit message (card-first gates)")
+    .option("--json", "With --score/--judge/--crown: emit stable JSON")
+    .action(async (task, flags) => {
+      await withConfig(pkgVersion, "tournament", flags, async ({ config, logger }) => {
+        if (flags.score || flags.judge || flags.crown) {
+          await tournamentCommand({ task: "", config, logger, flags });
+          return;
+        }
+        const resolvedTask = await resolveTaskInput({ task, taskFile: flags.taskFile, projectDir: config.projectDir, logger });
+        await tournamentCommand({ task: resolvedTask, config, logger, flags });
+      });
+    });
+
   program
     .command("review")
     .description("Run only reviewer (--staged/--check: v4 cross-AI gate with recorded verdict)")
@@ -220,7 +243,6 @@ export function registerPipeline(program, { pkgVersion }) {
           await reviewGateCommand({ config, logger, flags: { ...flags, task } });
           return;
         }
-        const { resolveTaskInput } = await import("../utils/task-file.js");
         const resolvedTask = await resolveTaskInput({ task, taskFile: flags.taskFile, projectDir: config.projectDir, logger });
         await reviewCommand({ task: resolvedTask, config, logger, baseRef: flags.baseRef });
       });

package/src/commands/env.js

@@ -62,7 +62,7 @@ export async function envInstallCommand({ config = null, logger = null, flags =
     // The effective backend feeds the render on EVERY non-error path —
     // chosen, declared-in-file or default — so the playbook never falls
     // back to hu-board while the selection said otherwise.
-    config = { ...config, state_backend: sel.backend, board: sel.boardName ? { ...(config?.board || {}), name: sel.boardName } : config?.board };
+    config = { ...config, state_backend: sel.backend, board: sel.boardName ? { ...config?.board, name: sel.boardName } : config?.board };
   } catch (err) {
     console.log(`⚠ board selection failed (${err.message}) — continuing with the configured default`);
   }

package/src/commands/harden.js

@@ -184,7 +184,10 @@ export async function hardenCommand({
   const verb = dryRun ? "would install" : "installed";
   logger.info?.(`kj harden (${profile}) — ${verb} ${result.hooks.length} hook(s) → ${result.hooksPath}`);
   for (const h of result.hooks) logger.info?.(`  • ${h.hook}: ${h.action}`);
-  for (const c of out.configs) logger.info?.(`  • ${c.file}: ${c.action}`);
+  for (const c of out.configs) {
+    const note = c.note ? ` (${c.note})` : "";
+    logger.info?.(`  • ${c.file}: ${c.action}${note}`);
+  }
   for (const w of out.workflows) logger.info?.(`  • ${w.file}: ${w.action}`);
   for (const g of out.guidelines) logger.info?.(`  • ${g.file}: ${g.action}`);
   if (!dryRun) logger.info?.("core.hooksPath set. Verify later with `kj check`.");

package/src/commands/rag.js

@@ -98,7 +98,8 @@ export async function ragQueryCommand({ text, config, logger, flags = {} }) {
     // KJC-TSK-0697 — `--library` targets the distilled-canon collection:
     // its own project namespace plus the kind filter.
     const library = Boolean(flags.library);
-    const project = library ? LIBRARY_PROJECT : (flags.project === "all" ? null : (flags.project || detected || null));
+    let project = flags.project === "all" ? null : (flags.project || detected || null);
+    if (library) project = LIBRARY_PROJECT;
     // KJC-BUG-0061 follow-up: align the CLI `--json` shape with the MCP
     // handler. The MCP tool responds `{ hits: [], empty: true, topK, scope }`
     // so agents (and the `/kj-rag-query` skill from Camino B) have a
@@ -115,9 +116,8 @@ export async function ragQueryCommand({ text, config, logger, flags = {} }) {
     // Safe by grammar: parseWhere (core where-parser.js) accepts ONLY
     // AND-joined key=value pairs — an OR or parens never parses, so the
     // composed clause cannot leak past the kind filter; it fails loudly.
-    const where = library
-      ? (flags.where ? `kind=library AND ${flags.where}` : "kind=library")
-      : (flags.where || null);
+    let where = flags.where || null;
+    if (library) where = flags.where ? `kind=library AND ${flags.where}` : "kind=library";
     const rerankOpts = flags.rerank ? { model: flags.rerankModel } : null;
     const hits = await query(db, makeGovernedEmbedder(config), text, { topK, scope, project, mode, alpha, where, rerankOpts });
     if (flags.json) {

package/src/commands/review-gate.js

@@ -26,6 +26,9 @@ async function enforceCardFirst({ config, projectDir }) {
   const branch = branchRes.stdout?.trim() || "HEAD";
   const card = await checkCardFirst({ config, projectDir, branch });
   if (card.mode === "warn") console.log(`⚠ card-first: ${card.reason}`);
+  // KJC-TSK-0732: the verification LEVEL is part of the verdict — a pass on
+  // branch-ref alone must never read as a tracker-verified pass.
+  if (card.note) console.log(`⚠ card-first: ${card.note}`);
   if (card.mode === "exempt" && card.reason.includes("KJ_ALLOW_NO_CARD")) console.log(`⚠ card-first exempt: ${card.reason}`);
   if (!card.ok) {
     console.log(`✗ card-first gate: ${card.reason}`);

package/src/commands/tournament.js

@@ -0,0 +1,85 @@
+/**
+ * `kj tournament` (KJC-TSK-0723, TOR-A) — fan the SAME task out to N coders
+ * in N isolated worktree lanes and collect the evidence. The deterministic
+ * scoreboard (TOR-B) and the governed judgement/merge (TOR-C) build on the
+ * artifacts this command leaves under .kj/tournaments/<id>/.
+ */
+import path from "node:path";
+import { runTournament } from "../tournament/run.js";
+import { scoreTournament } from "../tournament/scoreboard.js";
+import { judgeTournament } from "../tournament/judge.js";
+import { crownWinner } from "../tournament/crown.js";
+
+// The id feeds a path — same traversal class codex caught in TOR-A's coder
+// names: strict slug, no separators, before any filesystem use.
+function tournamentDirFor(config, rawId) {
+  const id = String(rawId);
+  if (!/^[a-z0-9][a-z0-9-]{0,63}$/i.test(id)) {
+    throw new Error(`tournament: id inválido "${id}" — usa el id que imprimió el torneo (p. ej. tor-abc123)`);
+  }
+  return path.join(config?.projectDir || process.cwd(), ".kj", "tournaments", id);
+}
+
+export async function tournamentCommand({
+  task, config, logger = console, flags = {},
+  runTournamentFn = runTournament, scoreTournamentFn = scoreTournament,
+  judgeTournamentFn = judgeTournament, crownWinnerFn = crownWinner,
+}) {
+  // TOR-C: `--judge <id>` ranks the finalists; `--crown <id>` commits the
+  // winner through the real gate in its lane.
+  if (flags.judge) {
+    const judgement = await judgeTournamentFn({ tournamentDir: tournamentDirFor(config, flags.judge), config, logger });
+    if (flags.json) logger?.info?.(JSON.stringify(judgement));
+    else logger?.info?.(`  siguiente: kj tournament --crown ${flags.judge}${judgement.escalated ? " (ganador vía solomon)" : ""}`);
+    return judgement;
+  }
+  if (flags.crown) {
+    const crown = await crownWinnerFn({
+      tournamentDir: tournamentDirFor(config, flags.crown), config, logger, cardRef: flags.card || null,
+    });
+    if (flags.json) logger?.info?.(JSON.stringify(crown));
+    return crown;
+  }
+
+  // TOR-B: `--score <id>` scores an EXISTING tournament from its artifacts.
+  if (flags.score) {
+    const tournamentDir = tournamentDirFor(config, flags.score);
+    const board = await scoreTournamentFn({ tournamentDir });
+    if (flags.json) {
+      logger?.info?.(JSON.stringify(board));
+      return board;
+    }
+    logger?.info?.(`scoreboard ${board.id} — regla: ${board.rule}`);
+    for (const r of board.rows) {
+      if (!r.finalist) {
+        logger?.info?.(`  ${r.coder.padEnd(10)} eliminado (${r.eliminated_by})`);
+        continue;
+      }
+      const mut = typeof r.mutation?.score === "number" ? `${r.mutation.score}%` : "n/a";
+      logger?.info?.(`  ${r.coder.padEnd(10)} FINALISTA  loc:${String(r.loc.net).padStart(5)}  tests:${r.loc.testsTouched}  mutation:${mut}`);
+    }
+    logger?.info?.(`  ranking: ${board.ranking.join(" > ") || "(sin finalistas)"}`);
+    return board;
+  }
+
+  if (!task || !String(task).trim()) {
+    throw new Error("tournament: falta la tarea — kj tournament \"<tarea>\" --coders claude,codex");
+  }
+  const coders = String(flags.coders || "")
+    .split(",")
+    .map((c) => c.trim())
+    .filter(Boolean);
+  if (coders.length < 2) {
+    throw new Error("tournament: hacen falta al menos 2 en --coders — p. ej. --coders claude,codex,agy (con uno no hay torneo)");
+  }
+
+  const res = await runTournamentFn({ task, coders, config, logger });
+
+  const completed = res.lanes.filter((l) => l.status === "completed");
+  const green = completed.filter((l) => l.suite?.ok);
+  logger?.info?.("");
+  logger?.info?.(`torneo ${res.id}: ${completed.length}/${res.lanes.length} carriles completados, ${green.length} con suite verde`);
+  logger?.info?.(`  evidencia: ${res.dir}`);
+  logger?.info?.("  siguiente: el scoreboard determinista (TOR-B) puntuará los carriles; de momento compara los diff.patch a mano.");
+  return res;
+}

package/src/config/defaults.js

@@ -66,7 +66,9 @@ const DEFAULTS = {
   // through the host agent's MCP/tools, never mirrored by kj. There is NO
   // "none": Karajan does not run without a board.
   state_backend: "hu-board",
-  board: { name: null },
+  // verify_cmd (KJC-TSK-0732): user adapter that checks a card ref against
+  // the real tracker — prints {exists, live, status} JSON; {ref} substituted.
+  board: { name: null, verify_cmd: null },
   // Method gates (KJC-PCS-0068): rules climb from playbook text to
   // deterministic enforcement. card_first: "auto" = block with hu-board
   // (fully verifiable), warn with planning-game/external (presence only);

package/src/environment/board-select.js

@@ -53,6 +53,7 @@ export async function pickStateBackend({ projectDir = process.cwd(), home = os.h
   const backend = external ? "external" : value;
   const boardName = external ? value.slice("external:".length) : null;
   await persistStateBackend(projectDir, backend, boardName);
-  logger.info?.(`✓ board: ${backend}${boardName ? ` (${boardName})` : ""} — persisted in .karajan/kj.config.yml`);
+  const suffix = boardName ? ` (${boardName})` : "";
+  logger.info?.(`✓ board: ${backend}${suffix} — persisted in .karajan/kj.config.yml`);
   return { backend, boardName, source: "chosen" };
 }

package/src/harden/config-engine.js

@@ -15,6 +15,24 @@ import { CONFIGS_BY_LANGUAGE, UNIVERSAL_CONFIGS } from "./config-templates.js";
 
 const BLOCK_VERSION = 1;
 
+// KJC-BUG-0137 (issue #1357): is the tool a config demands actually installed?
+// Declared dependency or a resolvable bin both count; an unreadable
+// package.json is no evidence of the tool.
+function hasTool(dirs, tool) {
+  for (const d of dirs) {
+    if (existsSync(join(d, "node_modules", ".bin", tool))) return true;
+    const pkgPath = join(d, "package.json");
+    if (!existsSync(pkgPath)) continue;
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      if (pkg.devDependencies?.[tool] || pkg.dependencies?.[tool]) return true;
+    } catch {
+      /* unreadable ⇒ keep looking */
+    }
+  }
+  return false;
+}
+
 function writeFile(target, content) {
   mkdirSync(dirname(target), { recursive: true });
   writeFileSync(target, content);
@@ -47,6 +65,15 @@ function seedInto(targetDir, configs, dryRun, prefix, results, altDirs = [target
         results.push({ file, action: "covered", by: variant });
         continue;
       }
+      // KJC-BUG-0137: no tool ⇒ no config — report the actionable gap instead.
+      if (cfg.requires && !hasTool(altDirs, cfg.requires)) {
+        results.push({
+          file,
+          action: "omitted",
+          note: `${cfg.requires} is not installed — npm i -D ${cfg.requires}, then re-run kj harden`,
+        });
+        continue;
+      }
     }
 
     if (cfg.json) {

package/src/harden/config-templates.js

@@ -95,10 +95,15 @@ export const UNIVERSAL_CONFIGS = [
   { file: "commitlint.config.js", blockId: "commitlint", style: "slash", body: COMMITLINT_BODY },
 ];
 
-/** `json:true` ⇒ seed-only (no comment syntax for a marker). */
+/**
+ * `json:true` ⇒ seed-only (no comment syntax for a marker). `requires` names
+ * the tool the config is for: absent from the project ⇒ the config is omitted
+ * with the install command in the report (KJC-BUG-0137) — a config without its
+ * tool is decorative, and kj never generates a demand it didn't satisfy.
+ */
 export const JS_CONFIGS = [
-  { file: "eslint.config.js", blockId: "eslint", style: "slash", body: ESLINT_BODY },
-  { file: ".prettierrc.json", json: true, body: PRETTIER_BODY },
+  { file: "eslint.config.js", blockId: "eslint", style: "slash", body: ESLINT_BODY, requires: "eslint" },
+  { file: ".prettierrc.json", json: true, body: PRETTIER_BODY, requires: "prettier" },
 ];
 export const PY_CONFIGS = [{ file: "ruff.toml", blockId: "ruff", style: "hash", body: RUFF_BODY }];
 export const GO_CONFIGS = [{ file: ".golangci.yml", blockId: "golangci", style: "hash", body: GOLANGCI_BODY }];

package/src/harden/hook-templates.js

@@ -109,7 +109,7 @@ export function hookBody(hook, cmds = {}, { globalHooksDir = null, baseBranch =
         "# POSIX-safe extraction (no grep -o): the ref is the leading",
         "# card-shaped token of the branch's last segment (feat/REF-desc).",
         "seg=$(printf '%s' \"$branch\" | tr '[:upper:]' '[:lower:]'); seg=\"${seg##*/}\"",
-        "ref=$(printf '%s' \"$seg\" | sed -nE 's/^([a-z][a-z0-9]{1,9}(-[a-z][a-z0-9]{1,9})*-[0-9]{1,6})(-.*)?$/\\1/p')",
+        String.raw`ref=$(printf '%s' "$seg" | sed -nE 's/^([a-z][a-z0-9]{1,9}(-[a-z][a-z0-9]{1,9})*-[0-9]{1,6})(-.*)?$/\1/p')`,
         'header=$(head -n1 "$msg_file")',
         'if [ -n "$ref" ] && [ -n "$header" ]; then',
         '  case "$header" in',
@@ -122,7 +122,7 @@ export function hookBody(hook, cmds = {}, { globalHooksDir = null, baseBranch =
         "        stamp=$(printf '%s' \"$ref\" | tr '[:lower:]' '[:upper:]')",
         '        new_header="$header ($stamp)"',
         '        if [ "${#new_header}" -le 100 ]; then',
-        "          { printf '%s\\n' \"$new_header\"; tail -n +2 \"$msg_file\"; } > \"$msg_file.kjtmp\" && mv \"$msg_file.kjtmp\" \"$msg_file\"",
+        String.raw`          { printf '%s\n' "$new_header"; tail -n +2 "$msg_file"; } > "$msg_file.kjtmp" && mv "$msg_file.kjtmp" "$msg_file"`,
         "        fi",
         "      fi",
         "      ;;",

package/src/harden/workflow-engine.js

@@ -34,6 +34,16 @@ export function detectPackageManager(projectDir) {
   return "npm";
 }
 
+// KJC-BUG-0137: the JS quality workflow only carries a lint step when the
+// project HAS a lint script — and then it enforces (no --if-present).
+function hasLintScript(projectDir) {
+  try {
+    return Boolean(JSON.parse(readFileSync(join(projectDir, "package.json"), "utf8")).scripts?.lint);
+  } catch {
+    return false;
+  }
+}
+
 export function installWorkflows({
   projectDir = process.cwd(),
   language = null,
@@ -43,7 +53,7 @@ export function installWorkflows({
 } = {}) {
   const dir = join(projectDir, WORKFLOWS_DIR);
   const pm = detectPackageManager(projectDir);
-  const quality = qualityWorkflowFor(language, pm);
+  const quality = qualityWorkflowFor(language, pm, hasLintScript(projectDir));
   const extras = extraWorkflowsFor({ profile, publishable: isPublishableNpm(projectDir), pm });
   const mut = mutation ? mutationWorkflowFor(language, pm) : null;
   const all = [...WORKFLOWS, ...(quality ? [quality] : []), ...extras, ...(mut ? [mut] : [])];