karajan-code 4.52.0 → 4.53.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "4.52.0",
+  "version": "4.53.1",
   "description": "Local multi-agent coding orchestrator with TDD, SonarQube, and code review pipeline",
   "type": "module",
   "license": "AGPL-3.0",
@@ -76,6 +76,7 @@
     "setup": "node scripts/install.js",
     "test": "vitest run",
     "test:scenarios": "vitest run --config tests/scenarios/vitest.config.js --root .",
+    "contract:claude": "node scripts/contract-claude.mjs",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "lint": "eslint src/ packages/",

package/scripts/contract-claude.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * KJC-TSK-1063 (QS-C4): npm run contract:claude. With the claude installed on
+ * this machine (and its session), records the contract answers again when its
+ * version differs from the recorded one, then replays the contract test. The
+ * new recordings go in a PR like any other change. --force records anyway.
+ */
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { claudeContractCheck } from "../src/checks/claude-contract-check.js";
+
+const root = fileURLToPath(new URL("..", import.meta.url));
+const step = (cmd, args) => {
+  const res = spawnSync(cmd, args, { cwd: root, stdio: "inherit" });
+  if (res.status !== 0) process.exit(res.status ?? 1);
+};
+
+const check = await claudeContractCheck(root);
+console.log(`${check.ok ? "✓" : "⚠"} ${check.detail}`);
+if (check.ok && !process.argv.includes("--force")) process.exit(0);
+step("node", ["scripts/record-agent-fixtures.mjs", "claude"]);
+step("node", ["scripts/record-agent-fixtures.mjs", "claude", "--task"]);
+step("npx", ["vitest", "run", "tests/agents/agent-contract-fixtures.test.js"]);
+console.log("✓ kj reads the installed claude: commit tests/agents/fixtures/claude in a PR");

package/scripts/esbuild-sea.config.mjs

@@ -35,6 +35,13 @@ const seaTransformPlugin = {
         modified = true;
       }
 
+      // KJC-TSK-0703: the injection catalog is data read next to its module; inlined the same way.
+      const CATALOG_READ = /readFileSync\(new URL\("(\.\/injection-patterns\.json)", import\.meta\.url\), "utf8"\)/g;
+      if (CATALOG_READ.test(contents)) {
+        contents = contents.replace(CATALOG_READ, (_m, rel) => JSON.stringify(readFileSync(path.resolve(path.dirname(args.path), rel), "utf8")));
+        modified = true;
+      }
+
       // Replace import.meta.dirname with __dirname
       if (contents.includes("import.meta.dirname")) {
         contents = contents.replaceAll("import.meta.dirname", "__dirname");

package/scripts/record-agent-fixtures.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/**
+ * QS-B (KJC-TSK-1039): records what each agent CLI REALLY emits for a review,
+ * so the contract tests replay real answers instead of the ones we imagine.
+ *
+ *   node scripts/record-agent-fixtures.mjs claude codex
+ *
+ * Each CLI runs through its own kj adapter (same argv kj uses) in a throwaway
+ * directory; claude is recorded twice, the second time with a SessionStart hook
+ * in that directory, the way a session with hooks meets it (#2151). The answer
+ * is redacted (home, user, emails, session ids) and must pass the privacy scan
+ * before tests/agents/fixtures/<cli>/review.json is written.
+ */
+import { copyFileSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir, userInfo } from "node:os";
+import { join } from "node:path";
+import { createAgent } from "../src/agents/index.js";
+import { buildEnvironment, defaultEnvironment } from "../src/infrastructure/environment.js";
+import { loadPrivacyList, scanPaths } from "../src/privacy/scan.js";
+
+const PROMPT = [
+  "You are reviewing this diff. Answer ONLY with one JSON object:",
+  '{"approved": boolean, "blocking_issues": [], "non_blocking_suggestions": [], "summary": string, "confidence": number}',
+  "diff --git a/sum.js b/sum.js",
+  "+export const sum = (a, b) => a + b;",
+].join("\n");
+
+const OUT = new URL("../tests/agents/fixtures/", import.meta.url).pathname;
+const logger = { info() {}, warn() {}, error() {}, debug() {} };
+
+export function redact(text, { home = homedir(), user = userInfo().username } = {}) {
+  return String(text ?? "")
+    .replaceAll(home, "/home/user")
+    .replaceAll(new RegExp(`\\b${user}\\b`, "g"), "user")
+    .replaceAll(/[\w.+-]+@[\w-]+\.[\w.]+/g, "user@example.com")
+    .replaceAll(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, "redacted-id");
+}
+
+// The init event describes the recording machine (tools, MCP servers, plugins,
+// paths): only its shape stays, so it leaks nothing about that machine.
+const isInit = (event) => event?.type === "system" && event.subtype === "init";
+// An allowlist, not a denylist: each CLI version adds fields about the machine
+// (socket paths, memory paths, terminal commands). Only the event's shape stays.
+const INIT_KEEP = ["type", "subtype", "session_id", "uuid", "model", "permissionMode", "apiKeySource", "claude_code_version", "output_style"];
+const trimEvent = (event) => (isInit(event) ? Object.fromEntries(INIT_KEEP.filter((k) => k in event).map((k) => [k, event[k]])) : event);
+
+// Both shapes claude emits: NDJSON (stream-json) and one JSON array (json, the coder's runTask).
+export function trimInitEvents(stdout) {
+  const text = String(stdout ?? "");
+  if (text.trim().startsWith("[")) {
+    try { return JSON.stringify(JSON.parse(text).map(trimEvent)); } catch { /* not one array: read it by lines */ }
+  }
+  return text.split("\n").map((line) => {
+    let event;
+    try { event = JSON.parse(line); } catch { return line; }
+    return isInit(event) ? JSON.stringify(trimEvent(event)) : line;
+  }).join("\n");
+}
+
+// #2151: a SessionStart hook makes claude open its answer with hook events.
+function withSessionHook(dir) {
+  mkdirSync(join(dir, ".claude"), { recursive: true });
+  const hooks = { SessionStart: [{ hooks: [{ type: "command", command: "echo kj-fixture-hook" }] }] };
+  writeFileSync(join(dir, ".claude", "settings.json"), `${JSON.stringify({ hooks }, null, 2)}\n`);
+}
+
+// KJC-TSK-1044: the coder's answer, with no tool to use and one exact line to say.
+const TASK_PROMPT = "Reply with exactly this line and nothing else: kj-contract-ok";
+
+async function record(cli, { hooks = false, task = false } = {}) {
+  process.chdir(mkdtempSync(join(tmpdir(), "kj-fixtures-")));
+  if (hooks) withSessionHook(process.cwd());
+  const calls = [];
+  const runner = { run: async (cmd, args, opts) => { const res = await defaultEnvironment.runner.run(cmd, args, opts); calls.push(res); return res; } };
+  const agent = createAgent(cli, {}, logger, buildEnvironment({ runner }));
+  const version = (await defaultEnvironment.runner.run(cli, ["--version"], {})).stdout?.trim() || "unknown";
+  if (task) await agent.runTask({ prompt: TASK_PROMPT, role: "coder" });
+  else await agent.reviewTask({ prompt: PROMPT, role: "reviewer" });
+  const last = calls.at(-1);
+  if (!last) throw new Error(`${cli}: the adapter ran no command`);
+  // Scanned in the throwaway directory: a fixture with a privacy hit never reaches the repo.
+  const candidate = join(process.cwd(), "fixture.json");
+  writeFileSync(candidate, `${JSON.stringify({ cli, version: redact(version), exitCode: last.exitCode, stdout: redact(trimInitEvents(last.stdout)), stderr: redact(last.stderr) }, null, 2)}\n`);
+  const blocks = scanPaths([candidate], { list: loadPrivacyList() }).filter((f) => f.severity === "block");
+  if (blocks.length > 0) throw new Error(`${cli}: ${blocks.length} privacy hit(s) in the recording; fix the redaction (left in ${candidate})`);
+  const file = join(OUT, cli, `${task ? "task" : "review"}${hooks ? "-hooks" : ""}.json`);
+  mkdirSync(join(OUT, cli), { recursive: true });
+  copyFileSync(candidate, file);
+  return `${cli} ${version}: exit ${last.exitCode} → ${file}`;
+}
+
+// --task records the coder (runTask) instead of the reviewer.
+const task = process.argv.includes("--task");
+const clis = process.argv.slice(2).filter((a) => a !== "--task");
+for (const cli of clis) {
+  console.log(await record(cli, { task }));
+  if (cli === "claude" && !task) console.log(await record(cli, { hooks: true }));
+}

package/src/agents/claude-agent.js

@@ -342,7 +342,15 @@ function buildPromptArgs(task) {
   return { args: ["-p", "--allowedTools", ...ALLOWED_TOOLS], input: String(task.prompt ?? "") };
 }
 
+// KJC-TSK-0914: the model claude runs on when nobody declares one; whatever the
+// user declares (roles.<role>.model, coder/reviewer options, --coder-model) wins.
+export const CLAUDE_DEFAULT_MODEL = "claude-opus-5-5";
+
 export class ClaudeAgent extends BaseAgent {
+  getRoleModel(role) {
+    return super.getRoleModel(role) ?? CLAUDE_DEFAULT_MODEL;
+  }
+
   async runTask(task) {
     const role = task.role || "coder";
     const model = this.getRoleModel(role);

package/src/agents/model-registry.js

@@ -86,6 +86,11 @@ registerModel("gpt-5.4-mini", { provider: "openai", pricing: { input_per_million
 
 // Default models & General aliases
 registerModel("codex", { provider: "openai", pricing: { input_per_million: 1.5, output_per_million: 4 } });
+// KJC-TSK-0699: the models the codex CLI lists (0.146.1). List prices after the
+// 2026-07-30 cut; Sol at its base rate, not the temporary promotion.
+registerModel("gpt-5.6-sol", { provider: "openai", pricing: { input_per_million: 5.0, output_per_million: 30.0 } });
+registerModel("gpt-5.6-terra", { provider: "openai", pricing: { input_per_million: 2.0, output_per_million: 12.0 } });
+registerModel("gpt-5.6-luna", { provider: "openai", pricing: { input_per_million: 0.2, output_per_million: 1.2 } });
 registerModel("o4-mini", { provider: "openai", pricing: { input_per_million: 1.5, output_per_million: 4 } });
 registerModel("o3", { provider: "openai", pricing: { input_per_million: 10, output_per_million: 40 } });
 

package/src/agents/opencode-agent.js

@@ -33,6 +33,20 @@ function extractOpenCodeUsage(text) {
   return null;
 }
 
+/**
+ * KJC-BUG-0358: with --format json opencode reports a failure as an error event
+ * on stdout ({"type":"error","error":{"name","data":{"message"}}}) and leaves
+ * stderr empty. Returns that message, or "" when there is no error event.
+ */
+function openCodeErrorEvent(stdout) {
+  for (const line of String(stdout ?? "").split("\n")) {
+    let event;
+    try { event = JSON.parse(line); } catch { continue; }
+    if (event?.type === "error") return event.error?.data?.message ?? event.error?.name ?? "opencode reported an error";
+  }
+  return "";
+}
+
 export class OpenCodeAgent extends BaseAgent {
   async runTask(task) {
     const role = task.role || "coder";
@@ -57,6 +71,7 @@ export class OpenCodeAgent extends BaseAgent {
       timeout: task.timeoutMs
     });
     const usage = extractOpenCodeUsage(res.stdout) ?? extractOpenCodeUsage(res.stderr);
-    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode, ...usage };
+    const error = res.exitCode === 0 ? res.stderr : res.stderr || openCodeErrorEvent(res.stdout);
+    return { ok: res.exitCode === 0, output: res.stdout, error, exitCode: res.exitCode, ...usage };
   }
 }

package/src/audit/issue-filter.js

@@ -11,6 +11,8 @@
 //   2. Inline ignore: `// karajan-audit-ignore: <tool>:<ruleId>` on the issue
 //      line or the previous one. Legacy `// karajan-sonar-ignore: <ruleId>`
 //      keeps working when the issue's tool is "sonar".
+//   3. Sonar only: S1135 on the Spanish word «todo» (not an uppercase TODO
+//      tag) is suppressed by reading the issue's line (KJC-TSK-1042).
 //
 // Issues filtered out are kept in the `suppressed` list with `_suppressedBy`
 // metadata for auditability — no silent dropping.
@@ -53,6 +55,19 @@ export const DEFAULT_FALSE_POSITIVES = [
   },
 ];
 
+/**
+ * KJC-TSK-1042: Sonar's TODO-tag rule (S1135, every language) matches the word
+ * regardless of case, so a Spanish comment like «todo el fichero» is reported
+ * as a pending task. Only the uppercase TODO tag counts. Returns the reason to
+ * suppress, or null; a line that cannot be read keeps the finding.
+ */
+export function spanishTodoWord(issue, absPath) {
+  if (!/:S1135$/.test(issue.rule ?? "") || !issue.line || !fs.existsSync(absPath)) return null;
+  const text = fs.readFileSync(absPath, "utf8").split("\n")[issue.line - 1] ?? "";
+  if (!/\btodo\b/i.test(text) || /\bTODO\b/.test(text)) return null;
+  return "the Spanish word «todo», not an uppercase TODO tag";
+}
+
 export function hasInlineIgnore(filePath, line, ruleId, tool = "sonar") {
   if (!filePath || !line || !ruleId) return false;
   if (!fs.existsSync(filePath)) return false;
@@ -109,11 +124,14 @@ export function filterFalsePositives(issues, opts = {}) {
       }
     }
 
-    // 2. Inline ignore (only checked if no static rule matched).
+    // 2. Inline ignore, then the Spanish word «todo» (only if no static rule matched).
     if (!matched && issue.rule && issue.line && path) {
       const absPath = path.startsWith("/") ? path : `${projectRoot}/${path}`;
       if (hasInlineIgnore(absPath, issue.line, issue.rule, tool)) {
         matched = { tool, rule: issue.rule, path, reason: "inline `// karajan-audit-ignore`" };
+      } else if (tool === "sonar") {
+        const reason = spanishTodoWord(issue, absPath);
+        if (reason) matched = { tool, rule: issue.rule, path, reason };
       }
     }
 

package/src/checks/audit-cycle.js

@@ -0,0 +1,41 @@
+/**
+ * KJC-TSK-0719 (SPD-C): the audit was due by calendar and staleness only. Now
+ * it is due by work cycles too: every N cards closed (distinct card refs in
+ * the commits) or M commits since the last recorded audit. The marker is that
+ * audit's timestamp, so running kj audit resets the counter. kj check shows it.
+ */
+import { existsSync } from "node:fs";
+import { runCommand } from "../utils/process.js";
+import { getAuditHistoryDbPath, getLatestPreviousRun, openAuditHistoryDb } from "../audit/audit-history.js";
+
+export const DEFAULT_EVERY_CARDS = 10;
+export const DEFAULT_EVERY_COMMITS = 60;
+const CARD_REF = /\b[A-Z]{2,5}-(?:TSK|BUG)-\d{4}\b/g;
+
+/**
+ * The last audit that finished with a score, or null; never creates the
+ * database to find out. A run without a score swept nothing, so it is no marker.
+ */
+export function readLatestAudit(projectDir) {
+  if (!existsSync(getAuditHistoryDbPath(projectDir))) return null;
+  const db = openAuditHistoryDb(projectDir);
+  try { return getLatestPreviousRun(db); } finally { db.close(); }
+}
+
+export async function auditCycle({ projectDir = process.cwd(), config = {}, run = runCommand, latestAudit = readLatestAudit } = {}) {
+  const everyCards = config?.audit_cycle?.every_cards ?? DEFAULT_EVERY_CARDS;
+  const everyCommits = config?.audit_cycle?.every_commits ?? DEFAULT_EVERY_COMMITS;
+  const last = latestAudit(projectDir);
+  if (!last) return { due: true, line: "⚠ audit due: no audit recorded yet: run kj audit" };
+  // A work commit is a non-merge one: a merge brings no work of its own, and the
+  // commits it brings in are already in this log (it walks every parent), so
+  // counting merges too would double each PR in a merge workflow.
+  const res = await run("git", ["-C", projectDir, "log", `--since=${last.timestamp}`, "--no-merges", "--format=%s"]);
+  if (res.exitCode !== 0) return { due: false, line: `⚠ audit cycle not checked: git log failed (${(res.stderr || "").trim()})` };
+  const lines = res.stdout.split("\n").filter(Boolean);
+  const cards = new Set(lines.flatMap((s) => s.match(CARD_REF) ?? [])).size;
+  const commits = lines.length;
+  const due = cards >= everyCards || commits >= everyCommits;
+  const counter = `${cards}/${everyCards} cards, ${commits}/${everyCommits} commits since the last audit (${last.timestamp.slice(0, 10)})`;
+  return { due, cards, commits, line: due ? `⚠ audit due: ${counter}: run kj audit` : `audit cycle: ${counter}` };
+}

package/src/checks/claude-contract-check.js

@@ -0,0 +1,27 @@
+/**
+ * KJC-TSK-1063 (QS-C4): the agent contract recordings (tests/agents/fixtures)
+ * note the claude version they were made with. Anthropic updates claude on its
+ * own; a newer one may change its output and break kj. The check lives on the
+ * maintainer's machine, with the claude session already there, not in CI with
+ * a credential: kj release check is red until npm run contract:claude records
+ * again with the installed claude and the contract test passes.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { runCommand } from "../utils/process.js";
+
+const RECORDING = join("tests", "agents", "fixtures", "claude", "review.json");
+
+export const versionOf = (text) => /\d+\.\d+\.\d+/.exec(String(text ?? ""))?.[0] ?? null;
+
+/** null where the project carries no contract recordings (any project but kj itself). */
+export async function claudeContractCheck(projectDir, run = runCommand) {
+  const file = join(projectDir, RECORDING);
+  if (!existsSync(file)) return null;
+  const recorded = versionOf(JSON.parse(readFileSync(file, "utf8")).version);
+  const res = await run("claude", ["--version"], { cwd: projectDir }).catch((err) => ({ exitCode: 1, stdout: "", stderr: err.message }));
+  const installed = res.exitCode === 0 ? versionOf(res.stdout) : null;
+  if (!installed) return { name: "claude-contract", ok: false, detail: "claude --version gave no version: the contract with claude cannot be checked on this machine" };
+  if (installed === recorded) return { name: "claude-contract", ok: true, detail: `contract recorded with the installed claude ${installed}` };
+  return { name: "claude-contract", ok: false, detail: `claude ${installed} installed, contract recorded with ${recorded}: run npm run contract:claude and commit the recordings in a PR` };
+}

package/src/checks/method.js

@@ -68,8 +68,9 @@ export async function collectMethodStats({ projectDir, run = runCommand, sample
 export function sonarProof(v) {
   const s = v?.sonar;
   if (!s || v.verdict !== "approved") return null;
-  // A pipeline stamp has no mode: the stage ran, or it did not.
-  if (s.source === "pipeline") return s.ran ? "proved" : "unproved";
+  // A pipeline stamp has no mode: it ran and covered every staged source, or
+  // not (KJC-TSK-0839; a stamp from before it carries no lists and counts as run).
+  if (s.source === "pipeline") return s.ran && (s.uncovered || []).length === 0 ? "proved" : "unproved";
   // A block without a mode was written before the requirement existed
   // (the block landed one PR before fail-closed): not retroactive either.
   if (!s.mode) return null;

package/src/checks/release-check.js

@@ -11,6 +11,8 @@ import { runCommand } from "../utils/process.js";
 import { loadPrivacyList, scanPaths } from "../privacy/scan.js";
 import { checkStagedDiff, loadPolicy } from "../policy/engine.js";
 import { liftSealedSupervisorViolations } from "../policy/supervisor-verify.js";
+import { npmTokenAgeCheck } from "./supply-chain-check.js";
+import { claudeContractCheck } from "./claude-contract-check.js";
 
 // KJC-TSK-0769 — the effect boundary: what ships is re-evaluated against the
 // policy IN FORCE now, not the one each PR was merged under. Artifact rules
@@ -247,7 +249,11 @@ export async function runReleaseCheck({ projectDir = process.cwd(), config = {},
   const pack = await packPrivacyCheck(projectDir, pkg);
   const dual = await dualPublishCheck(projectDir, pkg);
   const scenarios = await scenarioBatteryCheck(projectDir, pkg);
-  checks.push(...[pack, dual, scenarios].filter(Boolean), await policyRangeCheck(projectDir), ...await declaredItems(projectDir, config, version));
+  // KJC-TSK-1059: what publishes to npm also says how old its long-lived tokens are (a warning).
+  const tokens = pkg?.name && !pkg.private ? await npmTokenAgeCheck({ maxDays: config?.supply_chain?.npm_token_max_days }) : null;
+  // KJC-TSK-1063: kj never ships unchecked against the claude installed here.
+  const claudeContract = await claudeContractCheck(projectDir);
+  checks.push(...[pack, dual, scenarios, tokens, claudeContract].filter(Boolean), await policyRangeCheck(projectDir), ...await declaredItems(projectDir, config, version));
   if (forCommand === null) return { ok: checks.every((c) => c.ok), version, checks };
   // A lifted check stays RED in the report: the fact is not falsified, it just
   // stops blocking the command that exists to repair it. The mark travels ON

package/src/checks/sonar.js

@@ -8,6 +8,7 @@
  */
 
 import { isSonarReachable } from "../sonar/manager.js";
+import { getProjectQualityProfiles } from "../sonar/api.js";
 import { STRATEGY } from "./types.js";
 import { withDocLink } from "../utils/doc-links.js";
 
@@ -22,6 +23,24 @@ function sonarHost(config) {
   return config.sonarqube?.host || "http://localhost:9000";
 }
 
+/** KJC-TSK-1051 (TEAM-E): the project runs on the team's quality profile, or the check says why not. */
+async function teamProfileResult(config, { host, profile }) {
+  let profiles;
+  try {
+    profiles = await getProjectQualityProfiles(config);
+  } catch (err) {
+    return { ok: false, severity: "warn", detail: `Reachable at ${host}, but the quality profile could not be read (${err.message})`, extra: { host } };
+  }
+  if (profiles.includes(profile)) return { ok: true, severity: "fail", detail: `Reachable at ${host}, on the team profile ${profile}`, extra: { host } };
+  return {
+    ok: false,
+    severity: "warn",
+    detail: `Reachable at ${host}, but the project runs on ${profiles.join(", ") || "no profile"}, not the team profile ${profile}`,
+    fix: `An admin assigns ${profile} to the project in SonarQube (Project Settings > Quality Profiles).`,
+    extra: { host },
+  };
+}
+
 /**
  * Informative check: Sonar enabled/disabled status.
  * Produces an OK result with disabled description when Sonar is off.
@@ -51,18 +70,17 @@ function createSonarStatusCheck() {
       } catch {
         reachable = false;
       }
-      return {
-        ok: reachable,
-        severity: "fail",
-        detail: reachable ? `Reachable at ${host}` : `Not reachable at ${host}`,
-        fix: reachable
-          ? undefined
-          : withDocLink(
-              "Run 'kj sonar start' or 'docker start karajan-sonarqube'. Use --no-sonar to skip.",
-              "sonar_docker"
-            ),
-        extra: { host, reachable },
-      };
+      // KJC-TSK-1051 (TEAM-E): an external SonarQube is the team's server, never started here.
+      const external = config.sonarqube?.external === true;
+      if (!reachable) {
+        const fix = external
+          ? `The team's SonarQube at ${host} is not answering (sonarqube.external: kj does not start a local one): check the network or VPN, or ask whoever runs it.`
+          : withDocLink("Run 'kj sonar start' or 'docker start karajan-sonarqube'. Use --no-sonar to skip.", "sonar_docker");
+        return { ok: false, severity: "fail", detail: `Not reachable at ${host}`, fix, extra: { host, reachable } };
+      }
+      const profile = config.sonarqube?.quality_profile;
+      if (!profile) return { ok: true, severity: "fail", detail: `Reachable at ${host}`, extra: { host, reachable } };
+      return teamProfileResult(config, { host, profile });
     },
   };
 }

package/src/checks/supply-chain-check.js

@@ -0,0 +1,47 @@
+/**
+ * KJC-TSK-1059: the supply-chain cooldown outside the review. kj check reads
+ * what the branch's lockfile installs against the merge base with the base
+ * branch; kj release check reads how old the long-lived npm tokens are.
+ * Both warn, never block: they are signals, and a signal never stays silent.
+ */
+import { runCommand } from "../utils/process.js";
+import { cooldownAdvisories, DEFAULT_COOLDOWN_HOURS, formatCooldown } from "../review/dep-cooldown.js";
+
+export const DEFAULT_TOKEN_MAX_DAYS = 90;
+const DAY_MS = 86_400_000;
+
+/** The cooldown warnings for what the branch brings in, committed or not. */
+export async function branchCooldownLines({ projectDir = process.cwd(), base = "main", thresholdHours = DEFAULT_COOLDOWN_HOURS, run = runCommand, now = Date.now() } = {}) {
+  let from = null;
+  for (const ref of [`origin/${base}`, base]) {
+    const res = await run("git", ["-C", projectDir, "merge-base", "HEAD", ref]);
+    if (res.exitCode === 0 && res.stdout.trim()) { from = res.stdout.trim(); break; }
+  }
+  if (!from) return [`⚠ supply-chain cooldown not checked: no merge base with ${base}`];
+  const diff = await run("git", ["-C", projectDir, "diff", from, "--", "package-lock.json", "**/package-lock.json"]);
+  if (diff.exitCode !== 0) return [`⚠ supply-chain cooldown not checked: git diff failed (${(diff.stderr || "").trim()})`];
+  return formatCooldown(await cooldownAdvisories(diff.stdout, { thresholdHours, run, now }), thresholdHours).lines;
+}
+
+/**
+ * A token without an expiry is a long-lived (classic) one: the older it is,
+ * the longer a leaked copy keeps working. Each one over maxDays is named.
+ */
+export async function npmTokenAgeCheck({ run = runCommand, now = Date.now(), maxDays = DEFAULT_TOKEN_MAX_DAYS } = {}) {
+  const res = await run("npm", ["token", "list", "--json"]);
+  if (res.exitCode !== 0) {
+    return { name: "npm-tokens", ok: true, warn: true, detail: `could not list npm tokens (${(res.stderr || res.stdout || "").trim()}): their age is unverified` };
+  }
+  let tokens;
+  try { tokens = JSON.parse(res.stdout || "[]"); } catch (err) {
+    return { name: "npm-tokens", ok: true, warn: true, detail: `npm token list gave no JSON (${err.message}): their age is unverified` };
+  }
+  const old = tokens
+    .filter((t) => !t.expires && t.created)
+    // Never the token field, masked or not: only a short prefix of its id reaches a log.
+    .map((t) => ({ label: `id ${String(t.key ?? "?").slice(0, 6)}…`, days: Math.floor((now - Date.parse(t.created)) / DAY_MS) }))
+    .filter((t) => t.days > maxDays);
+  if (old.length === 0) return { name: "npm-tokens", ok: true, warn: false, detail: `no long-lived npm token older than ${maxDays} days` };
+  const list = old.map((t) => `${t.label} (${t.days} days)`).join(", ");
+  return { name: "npm-tokens", ok: true, warn: true, detail: `${old.length} long-lived npm token(s) older than ${maxDays} days: ${list}. Rotate them, or move to granular tokens with an expiry` };
+}

package/src/cli/register-meta.js

@@ -334,6 +334,7 @@ export function registerMeta(program, { pkgVersion }) {
     // KJC-BUG-0257: the valid states, said before the call fails.
     .description(`Move a card; <status> is one of: ${HU_STATUSES.join(", ")}`)
     .option("--json", "Machine-readable output")
+    .option("--release", "Take over a running card reserved by someone else (the explicit act)")
     .action(async (id, status, flags) => {
       await withConfig(pkgVersion, "hu", flags, async ({ config }) => {
         await huCommand({ config, action: "move", args: [id, status], flags });
@@ -515,7 +516,11 @@ export function registerMeta(program, { pkgVersion }) {
         const res = await runReleaseCheck({ projectDir: config?.projectDir || process.cwd(), config, forCommand: flags.forCommand ?? null });
         if (flags.json) process.stdout.write(`${JSON.stringify(res)}\n`);
         else {
-          for (const c of res.checks) console.log(`  ${c.ok ? "✓" : "✗"} ${c.name}: ${c.detail}`);
+          const mark = (c) => {
+            if (!c.ok) return "✗";
+            return c.warn ? "⚠" : "✓";
+          };
+          for (const c of res.checks) console.log(`  ${mark(c)} ${c.name}: ${c.detail}`);
           if (res.lifted?.length) console.log(`  ℓ no bloquean este comando porque es su remedio: ${res.lifted.join(", ")}`);
           console.log(res.ok ? `release check: ready to release ${res.version ?? ""}`.trim() : "release check: NOT ready — fix the red items first");
         }

package/src/cli/register-pipeline.js

@@ -14,6 +14,7 @@ import { runCommandHandler } from "../commands/run.js";
 import { statusCommand } from "../commands/status.js";
 import { loadPlan } from "../plan/plan-store.js";
 import { withConfig } from "./_shared.js";
+import { publishPrReview } from "../review/publish-pr.js";
 
 /**
  * Register the "core pipeline" commands: everything the user runs day-to-day
@@ -66,6 +67,7 @@ export function registerPipeline(program, { pkgVersion }) {
     .option("--coder-model <name>")
     .option("--reviewer-model <name>")
     .option("--refactorer-model <name>")
+    .option("--profile <name>", "Model profile for every role without an explicit model: frugal | standard | deep (the reviewer never goes below standard)")
     .option("--enable-planner")
     .option("--enable-reviewer")
     .option("--enable-refactorer")
@@ -254,8 +256,15 @@ export function registerPipeline(program, { pkgVersion }) {
     // this the rule could only complain, which is the gate with no exit.
     .option("--walked <route>", "Recorrido comprobado como lo haría una persona (repetible) — queda en el veredicto", (v, prev) => [...(prev || []), v], [])
     .option("--walked-with <tool>", "Con qué se comprobó el recorrido (por ejemplo chrome-devtools)")
+    .option("--publish-pr <n>", "Publish the cross-AI verdicts of a PR's commits on it as one GitHub review")
     .action(async (task, flags) => {
       await withConfig(pkgVersion, "review", flags, async ({ config, logger }) => {
+        // KJC-TSK-0913: the verdicts kj already holds, published on the PR as one review.
+        if (flags.publishPr) {
+          const r = await publishPrReview({ projectDir: config.projectDir || process.cwd(), pr: flags.publishPr });
+          logger.info(r.published ? `✓ PR #${flags.publishPr}: review published (${r.commits} commit(s))` : `PR #${flags.publishPr}: ${r.reason}`);
+          return;
+        }
         // ENV-B1 (KJC-TSK-0637): the gate mode records a verdict tied to
         // the exact diff so the pre-commit hook can enforce cross-AI review.
         if (flags.staged || flags.check || flags.range || flags.installGate || flags.prune) {

package/src/cli/register-plan.js

@@ -12,6 +12,7 @@ import {
   planShareCommand,
   planUnshareCommand,
 } from "../commands/plan.js";
+import { planLicenseCommand } from "../commands/plan/license.js";
 import { parseCanvasMarkdown } from "../canvas/parse-md.js";
 import { validateCanvas } from "../canvas/validate.js";
 import { canvasToTask } from "../canvas/to-flat.js";
@@ -195,6 +196,15 @@ export function registerPlan(program, { pkgVersion }) {
     });
   });
 
+  // KJC-TSK-0717 (SPD-A): the REWORK licence, from the module's mutation score.
+  plan.command("license").description("Score a module with kj mutate and record the REWORK licence on an HU")
+    .argument("<planId>").argument("<huId>").requiredOption("--module <path>", "The module the REWORK regenerates")
+    .action(async (planId, huId, flags) => {
+      await withConfig(pkgVersion, "plan", flags, async ({ config }) => {
+        process.exitCode = await planLicenseCommand({ config, planId, huId, module: flags.module });
+      });
+    });
+
   // KJC-TSK-0402: re-ejecuta reviewer + self-fix + structural pass sobre
   // un plan existente. Acepta --prompt opcional con feedback humano que
   // el reviewer inyecta como contexto extra antes de revisar.

package/src/commands/check.js

@@ -11,6 +11,8 @@ import { checkAiSurface, formatAiSurface } from "../checks/ai-surface.js";
 import { detectObservedAgents } from "../utils/agent-detect.js";
 import { panelSummary } from "../environment/panel.js";
 import { loadConfig } from "../config.js";
+import { branchCooldownLines } from "../checks/supply-chain-check.js";
+import { auditCycle } from "../checks/audit-cycle.js";
 
 export async function checkCommand({ projectDir = process.cwd(), profile = "standard", json = false, logger = console } = {}) {
   const result = await checkHarden({ projectDir, profile });
@@ -34,9 +36,15 @@ export async function checkCommand({ projectDir = process.cwd(), profile = "stan
     aiSurface = checkAiSurface({ projectDir, extraSurface: clis });
   } catch { /* inventory is best-effort */ }
 
+  // KJC-TSK-1059: young dependencies the branch brings in, a warning outside the review.
+  const depCooldown = await branchCooldownLines({ projectDir, base: config?.base_branch ?? "main", thresholdHours: config?.supply_chain?.cooldown_hours })
+    .catch((err) => [`⚠ supply-chain cooldown not checked: ${err.message}`]);
+  // KJC-TSK-0719 (SPD-C): the audit is due by work cycles too; visibility, never the exit code.
+  const audit = await auditCycle({ projectDir, config }).catch((err) => ({ due: false, line: `⚠ audit cycle not checked: ${err.message}` }));
+
   const ok = result.ok && ragCoverage.ok;
   if (json) {
-    logger.info?.(JSON.stringify({ ...result, ok, method, ragCoverage, aiSurface }));
+    logger.info?.(JSON.stringify({ ...result, ok, method, ragCoverage, aiSurface, depCooldown, auditCycle: audit }));
     return ok ? 0 : 1;
   }
 
@@ -45,6 +53,8 @@ export async function checkCommand({ projectDir = process.cwd(), profile = "stan
   if (method) logger.info?.(`  method: ${formatMethodStats(method)}`);
   logger.info?.(`  ${ragCoverage.ok ? "✓" : "✗"} rag-coverage: ${ragCoverage.detail}`);
   if (aiSurface) logger.info?.(`  ${formatAiSurface(aiSurface)}`);
+  for (const line of depCooldown) logger.info?.(`  ${line}`);
+  logger.info?.(`  ${audit.line}`);
   // KJC-TSK-0865: who writes and who reviews is the user's choice, so it is
   // said out loud next to everything else that describes the project. Never
   // a check: it has no ok/fail, it informs.

package/src/commands/config.js

@@ -3,6 +3,7 @@ import { spawnSync } from "node:child_process";
 import yaml from "js-yaml";
 import { loadConfig, validateConfig, getConfigPath, writeConfig } from "../config.js";
 import { ensureDir } from "../utils/fs.js";
+import { formatModelProfile } from "../utils/model-selector.js";
 import path from "node:path";
 
 function resolveEditor() {
@@ -70,5 +71,6 @@ export async function configCommand({ json = false, edit = false }) {
 
   console.log(`Config path: ${cfgPath}`);
   console.log(`Exists: ${exists}`);
+  console.log(formatModelProfile(config));
   console.log(JSON.stringify(config, null, 2));
 }

package/src/commands/harden.js

@@ -24,6 +24,7 @@ import { installHarnessHooks } from "../harden/harness-hooks.js";
 import { installSentinelHooks } from "../harden/sentinel-hooks.js";
 import { detectStackRoots } from "../harden/stack-roots.js";
 import { installWorkflows } 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";
@@ -250,6 +251,8 @@ export async function hardenCommand({
       out.identityCommand = id.command;
     }
   }
+  // KJC-TSK-0928: the method's checks only stop a merge with branch protection; kj says the exact command.
+  if (!dryRun) out.branchProtection = await adviseBranchProtection({ projectDir, branch: await resolveBaseBranch(projectDir), logger });
   // KJC-BUG-0161 / ADR 0009 (opción A): --commit versiona la regeneración
   // del supervisor con procedencia sellada. Acto humano — el guard vive en
   // commitSupervisorRegeneration y rechaza sesiones de agente.